Refactor new bytecode structs so that the fields are prefixed with "m_".
authormark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 16 Jan 2019 18:44:25 +0000 (18:44 +0000)
committermark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 16 Jan 2019 18:44:25 +0000 (18:44 +0000)
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):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@240041 268f45cc-cd09-0410-ab3c-d52691b4dbfc

35 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp
Source/JavaScriptCore/bytecode/BytecodeUseDef.h
Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
Source/JavaScriptCore/bytecode/CodeBlock.cpp
Source/JavaScriptCore/bytecode/CodeBlockInlines.h
Source/JavaScriptCore/bytecode/GetByIdStatus.cpp
Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp
Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h
Source/JavaScriptCore/bytecode/PutByIdStatus.cpp
Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.cpp
Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
Source/JavaScriptCore/dfg/DFGOSREntry.cpp
Source/JavaScriptCore/ftl/FTLOperations.cpp
Source/JavaScriptCore/generator/Argument.rb
Source/JavaScriptCore/generator/Metadata.rb
Source/JavaScriptCore/generator/Opcode.rb
Source/JavaScriptCore/jit/JIT.h
Source/JavaScriptCore/jit/JITArithmetic.cpp
Source/JavaScriptCore/jit/JITArithmetic32_64.cpp
Source/JavaScriptCore/jit/JITCall.cpp
Source/JavaScriptCore/jit/JITCall32_64.cpp
Source/JavaScriptCore/jit/JITInlines.h
Source/JavaScriptCore/jit/JITOpcodes.cpp
Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
Source/JavaScriptCore/jit/JITOperations.cpp
Source/JavaScriptCore/jit/JITPropertyAccess.cpp
Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp
Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
Source/JavaScriptCore/llint/LowLevelInterpreter.asm
Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm
Source/JavaScriptCore/llint/LowLevelInterpreter64.asm
Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
Source/JavaScriptCore/runtime/CommonSlowPaths.h

index 18f0cd4..347fa49 100644 (file)
@@ -1,3 +1,342 @@
+2019-01-16  Mark Lam  <mark.lam@apple.com>
+
+        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):
+
 2019-01-15  Mark Lam  <mark.lam@apple.com>
 
         JSFunction::canUseAllocationProfile() should account for builtin functions with no own prototypes.
index d681d2d..2be3c3c 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2016 Yusuke Suzuki <utatane.tea@gmail.com>
- * Copyright (C) 2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -74,12 +74,12 @@ public:
 
                 case op_yield: {
                     auto bytecode = instruction->as<OpYield>();
-                    unsigned liveCalleeLocalsIndex = bytecode.yieldPoint;
+                    unsigned liveCalleeLocalsIndex = bytecode.m_yieldPoint;
                     if (liveCalleeLocalsIndex >= m_yields.size())
                         m_yields.resize(liveCalleeLocalsIndex + 1);
                     YieldData& data = m_yields[liveCalleeLocalsIndex];
                     data.point = instruction.offset();
-                    data.argument = bytecode.argument;
+                    data.argument = bytecode.m_argument;
                     break;
                 }
 
index bba02b1..641835a 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -32,7 +32,7 @@
 namespace JSC {
 
 #define CALL_FUNCTOR(__arg) \
-    functor(__bytecode.__arg);
+    functor(__bytecode.m_##__arg);
 
 #define USES_OR_DEFS(__opcode, ...) \
     case __opcode::opcodeID: { \
@@ -51,15 +51,15 @@ void computeUsesForBytecodeOffset(Block* codeBlock, OpcodeID opcodeID, const Ins
         functor(codeBlock->scopeRegister());
 
     auto handleNewArrayLike = [&](auto op) {
-        int base = op.argv.offset();
-        for (int i = 0; i < static_cast<int>(op.argc); i++)
+        int base = op.m_argv.offset();
+        for (int i = 0; i < static_cast<int>(op.m_argc); i++)
             functor(VirtualRegister { base - i });
     };
 
     auto handleOpCallLike = [&](auto op) {
-        functor(op.callee);
-        int lastArg = -static_cast<int>(op.argv) + CallFrame::thisArgumentOffset();
-        for (int i = 0; i < static_cast<int>(op.argc); i++)
+        functor(op.m_callee);
+        int lastArg = -static_cast<int>(op.m_argv) + CallFrame::thisArgumentOffset();
+        for (int i = 0; i < static_cast<int>(op.m_argc); i++)
             functor(VirtualRegister { lastArg + i });
         if (opcodeID == op_call_eval)
             functor(codeBlock->scopeRegister());
@@ -258,8 +258,8 @@ void computeUsesForBytecodeOffset(Block* codeBlock, OpcodeID opcodeID, const Ins
 
     case op_strcat: {
         auto bytecode = instruction->as<OpStrcat>();
-        int base = bytecode.src.offset();
-        for (int i = 0; i < bytecode.count; i++)
+        int base = bytecode.m_src.offset();
+        for (int i = 0; i < bytecode.m_count; i++)
             functor(VirtualRegister { base - i });
         return;
     }
index 43153fe..a67c73e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -73,13 +73,13 @@ CallLinkStatus CallLinkStatus::computeFromLLInt(const ConcurrentJSLocker&, CodeB
     LLIntCallLinkInfo* callLinkInfo;
     switch (op) {
     case op_call:
-        callLinkInfo = &instruction->as<OpCall>().metadata(profiledBlock).callLinkInfo;
+        callLinkInfo = &instruction->as<OpCall>().metadata(profiledBlock).m_callLinkInfo;
         break;
     case op_construct:
-        callLinkInfo = &instruction->as<OpConstruct>().metadata(profiledBlock).callLinkInfo;
+        callLinkInfo = &instruction->as<OpConstruct>().metadata(profiledBlock).m_callLinkInfo;
         break;
     case op_tail_call:
-        callLinkInfo = &instruction->as<OpTailCall>().metadata(profiledBlock).callLinkInfo;
+        callLinkInfo = &instruction->as<OpTailCall>().metadata(profiledBlock).m_callLinkInfo;
         break;
     default:
         return CallLinkStatus();
index 315c46e..3f45a41 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -507,23 +507,23 @@ bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
 
     auto link_profile = [&](const auto& instruction, auto /*bytecode*/, auto& metadata) {
         m_numberOfNonArgumentValueProfiles++;
-        metadata.profile.m_bytecodeOffset = instruction.offset();
+        metadata.m_profile.m_bytecodeOffset = instruction.offset();
     };
 
     auto link_arrayProfile = [&](const auto& instruction, auto /*bytecode*/, auto& metadata) {
-        metadata.arrayProfile.m_bytecodeOffset = instruction.offset();
+        metadata.m_arrayProfile.m_bytecodeOffset = instruction.offset();
     };
 
     auto link_objectAllocationProfile = [&](const auto& /*instruction*/, auto bytecode, auto& metadata) {
-        metadata.objectAllocationProfile.initializeProfile(vm, m_globalObject.get(), this, m_globalObject->objectPrototype(), bytecode.inlineCapacity);
+        metadata.m_objectAllocationProfile.initializeProfile(vm, m_globalObject.get(), this, m_globalObject->objectPrototype(), bytecode.m_inlineCapacity);
     };
 
     auto link_arrayAllocationProfile = [&](const auto& /*instruction*/, auto bytecode, auto& metadata) {
-        metadata.arrayAllocationProfile.initializeIndexingMode(bytecode.recommendedIndexingType);
+        metadata.m_arrayAllocationProfile.initializeIndexingMode(bytecode.m_recommendedIndexingType);
     };
 
     auto link_hitCountForLLIntCaching = [&](const auto& /*instruction*/, auto /*bytecode*/, auto& metadata) {
-        metadata.hitCountForLLIntCaching = Options::prototypeHitCountForLLIntCaching();
+        metadata.m_hitCountForLLIntCaching = Options::prototypeHitCountForLLIntCaching();
     };
 
 #define LINK_FIELD(__field) \
@@ -607,28 +607,28 @@ bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
         case op_resolve_scope: {
             INITIALIZE_METADATA(OpResolveScope)
 
-            const Identifier& ident = identifier(bytecode.var);
-            RELEASE_ASSERT(bytecode.resolveType != LocalClosureVar);
+            const Identifier& ident = identifier(bytecode.m_var);
+            RELEASE_ASSERT(bytecode.m_resolveType != LocalClosureVar);
 
-            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, scope, ident, Get, bytecode.resolveType, InitializationMode::NotInitialization);
+            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, scope, ident, Get, bytecode.m_resolveType, InitializationMode::NotInitialization);
             RETURN_IF_EXCEPTION(throwScope, false);
 
-            metadata.resolveType = op.type;
-            metadata.localScopeDepth = op.depth;
+            metadata.m_resolveType = op.type;
+            metadata.m_localScopeDepth = op.depth;
             if (op.lexicalEnvironment) {
                 if (op.type == ModuleVar) {
                     // Keep the linked module environment strongly referenced.
                     if (stronglyReferencedModuleEnvironments.add(jsCast<JSModuleEnvironment*>(op.lexicalEnvironment)).isNewEntry)
                         addConstant(op.lexicalEnvironment);
-                    metadata.lexicalEnvironment.set(vm, this, op.lexicalEnvironment);
+                    metadata.m_lexicalEnvironment.set(vm, this, op.lexicalEnvironment);
                 } else
-                    metadata.symbolTable.set(vm, this, op.lexicalEnvironment->symbolTable());
+                    metadata.m_symbolTable.set(vm, this, op.lexicalEnvironment->symbolTable());
             } else if (JSScope* constantScope = JSScope::constantScopeForCodeBlock(op.type, this)) {
-                metadata.constantScope.set(vm, this, constantScope);
+                metadata.m_constantScope.set(vm, this, constantScope);
                 if (op.type == GlobalLexicalVar || op.type == GlobalLexicalVarWithVarInjectionChecks)
-                    metadata.localScopeDepth = 0;
+                    metadata.m_localScopeDepth = 0;
             } else
-                metadata.globalObject = nullptr;
+                metadata.m_globalObject = nullptr;
             break;
         }
 
@@ -636,61 +636,61 @@ bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
             INITIALIZE_METADATA(OpGetFromScope)
 
             link_profile(instruction, bytecode, metadata);
-            metadata.watchpointSet = nullptr;
+            metadata.m_watchpointSet = nullptr;
 
-            ASSERT(!isInitialization(bytecode.getPutInfo.initializationMode()));
-            if (bytecode.getPutInfo.resolveType() == LocalClosureVar) {
-                metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), ClosureVar, bytecode.getPutInfo.initializationMode());
+            ASSERT(!isInitialization(bytecode.m_getPutInfo.initializationMode()));
+            if (bytecode.m_getPutInfo.resolveType() == LocalClosureVar) {
+                metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), ClosureVar, bytecode.m_getPutInfo.initializationMode());
                 break;
             }
 
-            const Identifier& ident = identifier(bytecode.var);
-            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, scope, ident, Get, bytecode.getPutInfo.resolveType(), InitializationMode::NotInitialization);
+            const Identifier& ident = identifier(bytecode.m_var);
+            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, scope, ident, Get, bytecode.m_getPutInfo.resolveType(), InitializationMode::NotInitialization);
             RETURN_IF_EXCEPTION(throwScope, false);
 
-            metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), op.type, bytecode.getPutInfo.initializationMode());
+            metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), op.type, bytecode.m_getPutInfo.initializationMode());
             if (op.type == ModuleVar)
-                metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), ClosureVar, bytecode.getPutInfo.initializationMode());
+                metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), ClosureVar, bytecode.m_getPutInfo.initializationMode());
             if (op.type == GlobalVar || op.type == GlobalVarWithVarInjectionChecks || op.type == GlobalLexicalVar || op.type == GlobalLexicalVarWithVarInjectionChecks)
-                metadata.watchpointSet = op.watchpointSet;
+                metadata.m_watchpointSet = op.watchpointSet;
             else if (op.structure)
-                metadata.structure.set(vm, this, op.structure);
-            metadata.operand = op.operand;
+                metadata.m_structure.set(vm, this, op.structure);
+            metadata.m_operand = op.operand;
             break;
         }
 
         case op_put_to_scope: {
             INITIALIZE_METADATA(OpPutToScope)
 
-            if (bytecode.getPutInfo.resolveType() == LocalClosureVar) {
+            if (bytecode.m_getPutInfo.resolveType() == LocalClosureVar) {
                 // Only do watching if the property we're putting to is not anonymous.
-                if (bytecode.var != UINT_MAX) {
-                    SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(bytecode.symbolTableOrScopeDepth));
-                    const Identifier& ident = identifier(bytecode.var);
+                if (bytecode.m_var != UINT_MAX) {
+                    SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(bytecode.m_symbolTableOrScopeDepth));
+                    const Identifier& ident = identifier(bytecode.m_var);
                     ConcurrentJSLocker locker(symbolTable->m_lock);
                     auto iter = symbolTable->find(locker, ident.impl());
                     ASSERT(iter != symbolTable->end(locker));
                     iter->value.prepareToWatch();
-                    metadata.watchpointSet = iter->value.watchpointSet();
+                    metadata.m_watchpointSet = iter->value.watchpointSet();
                 } else
-                    metadata.watchpointSet = nullptr;
+                    metadata.m_watchpointSet = nullptr;
                 break;
             }
 
-            const Identifier& ident = identifier(bytecode.var);
-            metadata.watchpointSet = nullptr;
-            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.symbolTableOrScopeDepth, scope, ident, Put, bytecode.getPutInfo.resolveType(), bytecode.getPutInfo.initializationMode());
+            const Identifier& ident = identifier(bytecode.m_var);
+            metadata.m_watchpointSet = nullptr;
+            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_symbolTableOrScopeDepth, scope, ident, Put, bytecode.m_getPutInfo.resolveType(), bytecode.m_getPutInfo.initializationMode());
             RETURN_IF_EXCEPTION(throwScope, false);
 
-            metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), op.type, bytecode.getPutInfo.initializationMode());
+            metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), op.type, bytecode.m_getPutInfo.initializationMode());
             if (op.type == GlobalVar || op.type == GlobalVarWithVarInjectionChecks || op.type == GlobalLexicalVar || op.type == GlobalLexicalVarWithVarInjectionChecks)
-                metadata.watchpointSet = op.watchpointSet;
+                metadata.m_watchpointSet = op.watchpointSet;
             else if (op.type == ClosureVar || op.type == ClosureVarWithVarInjectionChecks) {
                 if (op.watchpointSet)
                     op.watchpointSet->invalidate(vm, PutToScopeFireDetail(this, ident));
             } else if (op.structure)
-                metadata.structure.set(vm, this, op.structure);
-            metadata.operand = op.operand;
+                metadata.m_structure.set(vm, this, op.structure);
+            metadata.m_operand = op.operand;
             break;
         }
 
@@ -706,13 +706,13 @@ bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
             bool shouldAnalyze = m_unlinkedCode->typeProfilerExpressionInfoForBytecodeOffset(instructionOffset, divotStart, divotEnd);
             SymbolTable* symbolTable = nullptr;
 
-            switch (bytecode.flag) {
+            switch (bytecode.m_flag) {
             case ProfileTypeBytecodeClosureVar: {
-                const Identifier& ident = identifier(bytecode.identifier);
-                unsigned localScopeDepth = bytecode.symbolTableOrScopeDepth;
+                const Identifier& ident = identifier(bytecode.m_identifier);
+                unsigned localScopeDepth = bytecode.m_symbolTableOrScopeDepth;
                 // Even though type profiling may be profiling either a Get or a Put, we can always claim a Get because
                 // we're abstractly "read"ing from a JSScope.
-                ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, bytecode.resolveType, InitializationMode::NotInitialization);
+                ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, bytecode.m_resolveType, InitializationMode::NotInitialization);
                 RETURN_IF_EXCEPTION(throwScope, false);
 
                 if (op.type == ClosureVar || op.type == ModuleVar)
@@ -733,9 +733,9 @@ bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
                 break;
             }
             case ProfileTypeBytecodeLocallyResolved: {
-                int symbolTableIndex = bytecode.symbolTableOrScopeDepth;
+                int symbolTableIndex = bytecode.m_symbolTableOrScopeDepth;
                 SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(symbolTableIndex));
-                const Identifier& ident = identifier(bytecode.identifier);
+                const Identifier& ident = identifier(bytecode.m_identifier);
                 ConcurrentJSLocker locker(symbolTable->m_lock);
                 // If our parent scope was created while profiling was disabled, it will not have prepared for profiling yet.
                 globalVariableID = symbolTable->uniqueIDForVariable(locker, ident.impl(), vm);
@@ -770,24 +770,24 @@ bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
             TypeLocation* location = locationPair.first;
             bool isNewLocation = locationPair.second;
 
-            if (bytecode.flag == ProfileTypeBytecodeFunctionReturnStatement)
+            if (bytecode.m_flag == ProfileTypeBytecodeFunctionReturnStatement)
                 location->m_divotForFunctionOffsetIfReturnStatement = ownerExecutable->typeProfilingStartOffset();
 
             if (shouldAnalyze && isNewLocation)
                 vm.typeProfiler()->insertNewLocation(location);
 
-            metadata.typeLocation = location;
+            metadata.m_typeLocation = location;
             break;
         }
 
         case op_debug: {
-            if (instruction->as<OpDebug>().debugHookType == DidReachBreakpoint)
+            if (instruction->as<OpDebug>().m_debugHookType == DidReachBreakpoint)
                 m_hasDebuggerStatement = true;
             break;
         }
 
         case op_create_rest: {
-            int numberOfArgumentsToSkip = instruction->as<OpCreateRest>().numParametersToSkip;
+            int numberOfArgumentsToSkip = instruction->as<OpCreateRest>().m_numParametersToSkip;
             ASSERT_UNUSED(numberOfArgumentsToSkip, numberOfArgumentsToSkip >= 0);
             // This is used when rematerializing the rest parameter during OSR exit in the FTL JIT.");
             m_numberOfArgumentsToSkip = numberOfArgumentsToSkip;
@@ -1095,8 +1095,8 @@ void CodeBlock::propagateTransitions(const ConcurrentJSLocker&, SlotVisitor& vis
             auto instruction = m_instructions->at(propertyAccessInstructions[i]);
             if (instruction->is<OpPutById>()) {
                 auto& metadata = instruction->as<OpPutById>().metadata(this);
-                StructureID oldStructureID = metadata.oldStructure;
-                StructureID newStructureID = metadata.newStructure;
+                StructureID oldStructureID = metadata.m_oldStructure;
+                StructureID newStructureID = metadata.m_newStructure;
                 if (!oldStructureID || !newStructureID)
                     continue;
                 Structure* oldStructure =
@@ -1207,11 +1207,11 @@ void CodeBlock::finalizeLLIntInlineCaches()
     const Vector<InstructionStream::Offset>& propertyAccessInstructions = m_unlinkedCode->propertyAccessInstructions();
 
     auto handleGetPutFromScope = [](auto& metadata) {
-        GetPutInfo getPutInfo = metadata.getPutInfo;
+        GetPutInfo getPutInfo = metadata.m_getPutInfo;
         if (getPutInfo.resolveType() == GlobalVar || getPutInfo.resolveType() == GlobalVarWithVarInjectionChecks 
             || getPutInfo.resolveType() == LocalClosureVar || getPutInfo.resolveType() == GlobalLexicalVar || getPutInfo.resolveType() == GlobalLexicalVarWithVarInjectionChecks)
             return;
-        WriteBarrierBase<Structure>& structure = metadata.structure;
+        WriteBarrierBase<Structure>& structure = metadata.m_structure;
         if (!structure || Heap::isMarked(structure.get()))
             return;
         if (Options::verboseOSR())
@@ -1224,9 +1224,9 @@ void CodeBlock::finalizeLLIntInlineCaches()
         switch (curInstruction->opcodeID()) {
         case op_get_by_id: {
             auto& metadata = curInstruction->as<OpGetById>().metadata(this);
-            if (metadata.mode != GetByIdMode::Default)
+            if (metadata.m_mode != GetByIdMode::Default)
                 break;
-            StructureID oldStructureID = metadata.modeMetadata.defaultMode.structure;
+            StructureID oldStructureID = metadata.m_modeMetadata.defaultMode.structure;
             if (!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
                 break;
             if (Options::verboseOSR())
@@ -1236,30 +1236,30 @@ void CodeBlock::finalizeLLIntInlineCaches()
         }
         case op_get_by_id_direct: {
             auto& metadata = curInstruction->as<OpGetByIdDirect>().metadata(this);
-            StructureID oldStructureID = metadata.structure;
+            StructureID oldStructureID = metadata.m_structure;
             if (!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
                 break;
             if (Options::verboseOSR())
                 dataLogF("Clearing LLInt property access.\n");
-            metadata.structure = 0;
-            metadata.offset = 0;
+            metadata.m_structure = 0;
+            metadata.m_offset = 0;
             break;
         }
         case op_put_by_id: {
             auto& metadata = curInstruction->as<OpPutById>().metadata(this);
-            StructureID oldStructureID = metadata.oldStructure;
-            StructureID newStructureID = metadata.newStructure;
-            StructureChain* chain = metadata.structureChain.get();
+            StructureID oldStructureID = metadata.m_oldStructure;
+            StructureID newStructureID = metadata.m_newStructure;
+            StructureChain* chain = metadata.m_structureChain.get();
             if ((!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
                 && (!newStructureID || Heap::isMarked(vm.heap.structureIDTable().get(newStructureID)))
                 && (!chain || Heap::isMarked(chain)))
                 break;
             if (Options::verboseOSR())
                 dataLogF("Clearing LLInt put transition.\n");
-            metadata.oldStructure = 0;
-            metadata.offset = 0;
-            metadata.newStructure = 0;
-            metadata.structureChain.clear();
+            metadata.m_oldStructure = 0;
+            metadata.m_offset = 0;
+            metadata.m_newStructure = 0;
+            metadata.m_structureChain.clear();
             break;
         }
         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=166418
@@ -1268,17 +1268,17 @@ void CodeBlock::finalizeLLIntInlineCaches()
             break;
         case op_to_this: {
             auto& metadata = curInstruction->as<OpToThis>().metadata(this);
-            if (!metadata.cachedStructure || Heap::isMarked(metadata.cachedStructure.get()))
+            if (!metadata.m_cachedStructure || Heap::isMarked(metadata.m_cachedStructure.get()))
                 break;
             if (Options::verboseOSR())
-                dataLogF("Clearing LLInt to_this with structure %p.\n", metadata.cachedStructure.get());
-            metadata.cachedStructure.clear();
-            metadata.toThisStatus = merge(metadata.toThisStatus, ToThisClearedByGC);
+                dataLogF("Clearing LLInt to_this with structure %p.\n", metadata.m_cachedStructure.get());
+            metadata.m_cachedStructure.clear();
+            metadata.m_toThisStatus = merge(metadata.m_toThisStatus, ToThisClearedByGC);
             break;
         }
         case op_create_this: {
             auto& metadata = curInstruction->as<OpCreateThis>().metadata(this);
-            auto& cacheWriteBarrier = metadata.cachedCallee;
+            auto& cacheWriteBarrier = metadata.m_cachedCallee;
             if (!cacheWriteBarrier || cacheWriteBarrier.unvalidatedGet() == JSCell::seenMultipleCalleeObjects())
                 break;
             JSCell* cachedFunction = cacheWriteBarrier.get();
@@ -1294,7 +1294,7 @@ void CodeBlock::finalizeLLIntInlineCaches()
             // are for outer functions, and we refer to those functions strongly, and they refer
             // to the symbol table strongly. But it's nice to be on the safe side.
             auto& metadata = curInstruction->as<OpResolveScope>().metadata(this);
-            WriteBarrierBase<SymbolTable>& symbolTable = metadata.symbolTable;
+            WriteBarrierBase<SymbolTable>& symbolTable = metadata.m_symbolTable;
             if (!symbolTable || Heap::isMarked(symbolTable.get()))
                 break;
             if (Options::verboseOSR())
@@ -1665,12 +1665,12 @@ void CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffset(InstructionStream
     auto instruction = m_instructions->at(bytecodeOffset);
     OpCatch op = instruction->as<OpCatch>();
     auto& metadata = op.metadata(this);
-    if (!!metadata.buffer) {
+    if (!!metadata.m_buffer) {
 #if !ASSERT_DISABLED
         ConcurrentJSLocker locker(m_lock);
         bool found = false;
         for (auto& profile : m_catchProfiles) {
-            if (profile.get() == metadata.buffer) {
+            if (profile.get() == metadata.m_buffer) {
                 found = true;
                 break;
             }
@@ -1713,7 +1713,7 @@ void CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffsetSlow(const OpCatch
     // the compiler thread reads fully initialized data.
     WTF::storeStoreFence(); 
 
-    op.metadata(this).buffer = profiles.get();
+    op.metadata(this).m_buffer = profiles.get();
 
     {
         ConcurrentJSLocker locker(m_lock);
@@ -2491,7 +2491,7 @@ ArrayProfile* CodeBlock::getArrayProfile(const ConcurrentJSLocker&, unsigned byt
     switch (instruction->opcodeID()) {
 #define CASE(Op) \
     case Op::opcodeID: \
-        return &instruction->as<Op>().metadata(this).arrayProfile;
+        return &instruction->as<Op>().metadata(this).m_arrayProfile;
 
     FOR_EACH_OPCODE_WITH_ARRAY_PROFILE(CASE)
 #undef CASE
@@ -2499,8 +2499,8 @@ ArrayProfile* CodeBlock::getArrayProfile(const ConcurrentJSLocker&, unsigned byt
     case OpGetById::opcodeID: {
         auto bytecode = instruction->as<OpGetById>();
         auto& metadata = bytecode.metadata(this);
-        if (metadata.mode == GetByIdMode::ArrayLength)
-            return &metadata.modeMetadata.arrayLengthMode.arrayProfile;
+        if (metadata.m_mode == GetByIdMode::ArrayLength)
+            return &metadata.m_modeMetadata.arrayLengthMode.arrayProfile;
         break;
     }
     default:
@@ -2686,22 +2686,22 @@ void CodeBlock::notifyLexicalBindingShadowing(VM& vm, const IdentifierSet& set)
         case op_resolve_scope: {
             auto bytecode = instruction->as<OpResolveScope>();
             auto& metadata = bytecode.metadata(this);
-            ResolveType originalResolveType = metadata.resolveType;
+            ResolveType originalResolveType = metadata.m_resolveType;
             if (originalResolveType == GlobalProperty || originalResolveType == GlobalPropertyWithVarInjectionChecks) {
-                const Identifier& ident = identifier(bytecode.var);
+                const Identifier& ident = identifier(bytecode.m_var);
                 if (set.contains(ident.impl())) {
                     // We pass JSGlobalLexicalScope as a start point of the scope chain.
                     // It should immediately find the lexical binding because that's the reason why we perform this rewriting now.
-                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.resolveType, InitializationMode::NotInitialization);
+                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.m_resolveType, InitializationMode::NotInitialization);
                     scope.releaseAssertNoException();
                     ASSERT(op.type == GlobalLexicalVarWithVarInjectionChecks || op.type == GlobalLexicalVar);
-                    metadata.resolveType = needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar;
-                    metadata.localScopeDepth = 0;
+                    metadata.m_resolveType = needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar;
+                    metadata.m_localScopeDepth = 0;
                     ASSERT(!op.lexicalEnvironment);
-                    JSScope* constantScope = JSScope::constantScopeForCodeBlock(metadata.resolveType, this);
+                    JSScope* constantScope = JSScope::constantScopeForCodeBlock(metadata.m_resolveType, this);
                     ASSERT(constantScope == globalObject->globalScope());
-                    metadata.constantScope.set(vm, this, constantScope);
-                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_resolve_scope from ", originalResolveType, " to ", metadata.resolveType);
+                    metadata.m_constantScope.set(vm, this, constantScope);
+                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_resolve_scope from ", originalResolveType, " to ", metadata.m_resolveType);
                 }
             }
             break;
@@ -2710,19 +2710,19 @@ void CodeBlock::notifyLexicalBindingShadowing(VM& vm, const IdentifierSet& set)
         case op_get_from_scope: {
             auto bytecode = instruction->as<OpGetFromScope>();
             auto& metadata = bytecode.metadata(this);
-            ResolveType originalResolveType = metadata.getPutInfo.resolveType();
+            ResolveType originalResolveType = metadata.m_getPutInfo.resolveType();
             if (originalResolveType == GlobalProperty || originalResolveType == GlobalPropertyWithVarInjectionChecks) {
-                const Identifier& ident = identifier(bytecode.var);
+                const Identifier& ident = identifier(bytecode.m_var);
                 if (set.contains(ident.impl())) {
                     // We pass JSGlobalLexicalScope as a start point of the scope chain.
                     // It should immediately find the lexical binding because that's the reason why we perform this rewriting now.
-                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.getPutInfo.resolveType(), InitializationMode::NotInitialization);
+                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.m_getPutInfo.resolveType(), InitializationMode::NotInitialization);
                     scope.releaseAssertNoException();
                     ASSERT(op.type == GlobalLexicalVarWithVarInjectionChecks || op.type == GlobalLexicalVar);
-                    metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar, bytecode.getPutInfo.initializationMode());
-                    metadata.watchpointSet = op.watchpointSet;
-                    metadata.operand = op.operand;
-                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_get_from_scope from ", originalResolveType, " to ", metadata.getPutInfo.resolveType());
+                    metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar, bytecode.m_getPutInfo.initializationMode());
+                    metadata.m_watchpointSet = op.watchpointSet;
+                    metadata.m_operand = op.operand;
+                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_get_from_scope from ", originalResolveType, " to ", metadata.m_getPutInfo.resolveType());
                 }
             }
             break;
@@ -2731,25 +2731,25 @@ void CodeBlock::notifyLexicalBindingShadowing(VM& vm, const IdentifierSet& set)
         case op_put_to_scope: {
             auto bytecode = instruction->as<OpPutToScope>();
             auto& metadata = bytecode.metadata(this);
-            ResolveType originalResolveType = metadata.getPutInfo.resolveType();
+            ResolveType originalResolveType = metadata.m_getPutInfo.resolveType();
             if (originalResolveType == GlobalProperty || originalResolveType == GlobalPropertyWithVarInjectionChecks) {
-                const Identifier& ident = identifier(bytecode.var);
+                const Identifier& ident = identifier(bytecode.m_var);
                 if (set.contains(ident.impl())) {
                     // We pass JSGlobalLexicalScope as a start point of the scope chain.
                     // It should immediately find the lexical binding because that's the reason why we perform this rewriting now.
-                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.symbolTableOrScopeDepth, globalObject->globalScope(), ident, Put, bytecode.getPutInfo.resolveType(), bytecode.getPutInfo.initializationMode());
+                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_symbolTableOrScopeDepth, globalObject->globalScope(), ident, Put, bytecode.m_getPutInfo.resolveType(), bytecode.m_getPutInfo.initializationMode());
                     scope.releaseAssertNoException();
                     ASSERT(op.type == GlobalLexicalVarWithVarInjectionChecks || op.type == GlobalLexicalVar || op.type == Dynamic);
 
                     ResolveType resolveType = op.type;
-                    metadata.watchpointSet = nullptr;
+                    metadata.m_watchpointSet = nullptr;
                     if (resolveType == GlobalLexicalVarWithVarInjectionChecks || resolveType == GlobalLexicalVar) {
                         resolveType = needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar;
-                        metadata.watchpointSet = op.watchpointSet;
+                        metadata.m_watchpointSet = op.watchpointSet;
                     }
-                    metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), resolveType, bytecode.getPutInfo.initializationMode());
-                    metadata.operand = op.operand;
-                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_put_to_scope from ", originalResolveType, " to ", metadata.getPutInfo.resolveType());
+                    metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), resolveType, bytecode.m_getPutInfo.initializationMode());
+                    metadata.m_operand = op.operand;
+                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_put_to_scope from ", originalResolveType, " to ", metadata.m_getPutInfo.resolveType());
                 }
             }
             break;
@@ -2879,7 +2879,7 @@ ValueProfile* CodeBlock::tryGetValueProfileForBytecodeOffset(int bytecodeOffset)
 
 #define CASE(Op) \
     case Op::opcodeID: \
-        return &instruction->as<Op>().metadata(this).profile;
+        return &instruction->as<Op>().metadata(this).m_profile;
 
         FOR_EACH_OPCODE_WITH_VALUE_PROFILE(CASE)
 
@@ -3018,15 +3018,15 @@ ArithProfile* CodeBlock::arithProfileForPC(const Instruction* pc)
 {
     switch (pc->opcodeID()) {
     case op_negate:
-        return &pc->as<OpNegate>().metadata(this).arithProfile;
+        return &pc->as<OpNegate>().metadata(this).m_arithProfile;
     case op_add:
-        return &pc->as<OpAdd>().metadata(this).arithProfile;
+        return &pc->as<OpAdd>().metadata(this).m_arithProfile;
     case op_mul:
-        return &pc->as<OpMul>().metadata(this).arithProfile;
+        return &pc->as<OpMul>().metadata(this).m_arithProfile;
     case op_sub:
-        return &pc->as<OpSub>().metadata(this).arithProfile;
+        return &pc->as<OpSub>().metadata(this).m_arithProfile;
     case op_div:
-        return &pc->as<OpDiv>().metadata(this).arithProfile;
+        return &pc->as<OpDiv>().metadata(this).m_arithProfile;
     default:
         break;
     }
@@ -3066,13 +3066,13 @@ void CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler()
         RELEASE_ASSERT(instruction->opcodeID() == op_profile_control_flow);
         auto bytecode = instruction->as<OpProfileControlFlow>();
         auto& metadata = bytecode.metadata(this);
-        int basicBlockStartOffset = bytecode.textOffset;
+        int basicBlockStartOffset = bytecode.m_textOffset;
         int basicBlockEndOffset;
         if (i + 1 < offsetsLength) {
             size_t endIdx = bytecodeOffsets[i + 1];
             auto endInstruction = m_instructions->at(endIdx);
             RELEASE_ASSERT(endInstruction->opcodeID() == op_profile_control_flow);
-            basicBlockEndOffset = endInstruction->as<OpProfileControlFlow>().textOffset - 1;
+            basicBlockEndOffset = endInstruction->as<OpProfileControlFlow>().m_textOffset - 1;
         } else {
             basicBlockEndOffset = m_sourceOffset + ownerScriptExecutable()->source().length() - 1; // Offset before the closing brace.
             basicBlockStartOffset = std::min(basicBlockStartOffset, basicBlockEndOffset); // Some start offsets may be at the closing brace, ensure it is the offset before.
@@ -3098,7 +3098,7 @@ void CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler()
         // m: op_profile_control_flow
         if (basicBlockEndOffset < basicBlockStartOffset) {
             RELEASE_ASSERT(i + 1 < offsetsLength); // We should never encounter dummy blocks at the end of a CodeBlock.
-            metadata.basicBlockLocation = vm()->controlFlowProfiler()->dummyBasicBlock();
+            metadata.m_basicBlockLocation = vm()->controlFlowProfiler()->dummyBasicBlock();
             continue;
         }
 
@@ -3122,7 +3122,7 @@ void CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler()
         for (const WriteBarrier<FunctionExecutable>& executable : m_functionExprs)
             insertFunctionGaps(executable);
 
-        metadata.basicBlockLocation = basicBlockLocation;
+        metadata.m_basicBlockLocation = basicBlockLocation;
     }
 }
 
index ed63eb3..f00b397 100644 (file)
@@ -39,7 +39,7 @@ void CodeBlock::forEachValueProfile(const Functor& func)
 
     if (m_metadata) {
 #define VISIT(__op) \
-    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.profile); });
+    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_profile); });
 
         FOR_EACH_OPCODE_WITH_VALUE_PROFILE(VISIT)
 
@@ -53,12 +53,12 @@ void CodeBlock::forEachArrayProfile(const Functor& func)
 {
     if (m_metadata) {
         m_metadata->forEach<OpGetById>([&] (auto& metadata) {
-            if (metadata.mode == GetByIdMode::ArrayLength)
-                func(metadata.modeMetadata.arrayLengthMode.arrayProfile);
+            if (metadata.m_mode == GetByIdMode::ArrayLength)
+                func(metadata.m_modeMetadata.arrayLengthMode.arrayProfile);
         });
 
 #define VISIT(__op) \
-    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.arrayProfile); });
+    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_arrayProfile); });
 
         FOR_EACH_OPCODE_WITH_ARRAY_PROFILE(VISIT)
 
@@ -71,7 +71,7 @@ void CodeBlock::forEachArrayAllocationProfile(const Functor& func)
 {
     if (m_metadata) {
 #define VISIT(__op) \
-    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.arrayAllocationProfile); });
+    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_arrayAllocationProfile); });
 
         FOR_EACH_OPCODE_WITH_ARRAY_ALLOCATION_PROFILE(VISIT)
 
@@ -84,7 +84,7 @@ void CodeBlock::forEachObjectAllocationProfile(const Functor& func)
 {
     if (m_metadata) {
 #define VISIT(__op) \
-    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.objectAllocationProfile); });
+    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_objectAllocationProfile); });
 
         FOR_EACH_OPCODE_WITH_OBJECT_ALLOCATION_PROFILE(VISIT)
 
@@ -97,7 +97,7 @@ void CodeBlock::forEachLLIntCallLinkInfo(const Functor& func)
 {
     if (m_metadata) {
 #define VISIT(__op) \
-    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.callLinkInfo); });
+    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_callLinkInfo); });
 
         FOR_EACH_OPCODE_WITH_LLINT_CALL_LINK_INFO(VISIT)
 
index 718a8d8..499ab2d 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -64,13 +64,13 @@ GetByIdStatus GetByIdStatus::computeFromLLInt(CodeBlock* profiledBlock, unsigned
         auto& metadata = instruction->as<OpGetById>().metadata(profiledBlock);
         // FIXME: We should not just bail if we see a get_by_id_proto_load.
         // https://bugs.webkit.org/show_bug.cgi?id=158039
-        if (metadata.mode != GetByIdMode::Default)
+        if (metadata.m_mode != GetByIdMode::Default)
             return GetByIdStatus(NoInformation, false);
-        structureID = metadata.modeMetadata.defaultMode.structure;
+        structureID = metadata.m_modeMetadata.defaultMode.structure;
         break;
     }
     case op_get_by_id_direct:
-        structureID = instruction->as<OpGetByIdDirect>().metadata(profiledBlock).structure;
+        structureID = instruction->as<OpGetByIdDirect>().metadata(profiledBlock).m_structure;
         break;
     case op_try_get_by_id: {
         // FIXME: We should not just bail if we see a try_get_by_id.
index 0e8c225..574cf27 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
+ * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -59,9 +59,9 @@ void LLIntPrototypeLoadAdaptiveStructureWatchpoint::fireInternal(VM& vm, const F
 
 void LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache(OpGetById::Metadata& metadata)
 {
-    metadata.mode = GetByIdMode::Default;
-    metadata.modeMetadata.defaultMode.cachedOffset = 0;
-    metadata.modeMetadata.defaultMode.structure = 0;
+    metadata.m_mode = GetByIdMode::Default;
+    metadata.m_modeMetadata.defaultMode.cachedOffset = 0;
+    metadata.m_modeMetadata.defaultMode.structure = 0;
 }
 
 
index 1f30d43..8bebbdf 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
+ * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -58,7 +58,7 @@ namespace JSC {
     CASE_OP(OpJbeloweq) \
     case op_switch_imm: { \
         auto bytecode = instruction->as<OpSwitchImm>(); \
-        auto& table = codeBlock->switchJumpTable(bytecode.tableIndex); \
+        auto& table = codeBlock->switchJumpTable(bytecode.m_tableIndex); \
         for (unsigned i = table.branchOffsets.size(); i--;) \
             SWITCH_CASE(table.branchOffsets[i]); \
         SWITCH_DEFAULT_OFFSET(OpSwitchImm); \
@@ -66,7 +66,7 @@ namespace JSC {
     } \
     case op_switch_char: { \
         auto bytecode = instruction->as<OpSwitchChar>(); \
-        auto& table = codeBlock->switchJumpTable(bytecode.tableIndex); \
+        auto& table = codeBlock->switchJumpTable(bytecode.m_tableIndex); \
         for (unsigned i = table.branchOffsets.size(); i--;) \
             SWITCH_CASE(table.branchOffsets[i]); \
         SWITCH_DEFAULT_OFFSET(OpSwitchChar); \
@@ -74,7 +74,7 @@ namespace JSC {
     } \
     case op_switch_string: { \
         auto bytecode = instruction->as<OpSwitchString>(); \
-        auto& table = codeBlock->stringSwitchJumpTable(bytecode.tableIndex); \
+        auto& table = codeBlock->stringSwitchJumpTable(bytecode.m_tableIndex); \
         auto iter = table.offsetTable.begin(); \
         auto end = table.offsetTable.end(); \
         for (; iter != end; ++iter) \
@@ -108,7 +108,7 @@ template<typename Op, typename Block>
 inline int jumpTargetForInstruction(Block&& codeBlock, const InstructionStream::Ref& instruction)
 {
     auto bytecode = instruction->as<Op>();
-    return jumpTargetForInstruction(codeBlock, instruction, bytecode.target);
+    return jumpTargetForInstruction(codeBlock, instruction, bytecode.m_target);
 }
 
 template<typename Block, typename Function>
@@ -123,7 +123,7 @@ inline void extractStoredJumpTargetsForInstruction(Block&& codeBlock, const Inst
     function(__target)
 
 #define SWITCH_DEFAULT_OFFSET(__op) \
-    function(jumpTargetForInstruction(codeBlock, instruction, bytecode.defaultOffset)) \
+    function(jumpTargetForInstruction(codeBlock, instruction, bytecode.m_defaultOffset)) \
 
 SWITCH_JMP(CASE_OP, SWITCH_CASE, SWITCH_DEFAULT_OFFSET)
 
@@ -154,7 +154,7 @@ inline void updateStoredJumpTargetsForInstruction(Block&& codeBlock, unsigned fi
 
 #define SWITCH_DEFAULT_OFFSET(__op) \
     do { \
-        int32_t target = jumpTargetForInstruction(codeBlockOrHashMap, instruction, bytecode.defaultOffset); \
+        int32_t target = jumpTargetForInstruction(codeBlockOrHashMap, instruction, bytecode.m_defaultOffset); \
         int32_t newTarget = function(target); \
         instruction->cast<__op>()->setDefaultOffset(BoundLabel(newTarget), [&]() { \
             codeBlock->addOutOfLineJumpTarget(finalOffset + instruction.offset(), newTarget); \
index 47545de..3080577 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -55,13 +55,13 @@ PutByIdStatus PutByIdStatus::computeFromLLInt(CodeBlock* profiledBlock, unsigned
     auto bytecode = instruction->as<OpPutById>();
     auto& metadata = bytecode.metadata(profiledBlock);
 
-    StructureID structureID = metadata.oldStructure;
+    StructureID structureID = metadata.m_oldStructure;
     if (!structureID)
         return PutByIdStatus(NoInformation);
     
     Structure* structure = vm.heap.structureIDTable().get(structureID);
 
-    StructureID newStructureID = metadata.newStructure;
+    StructureID newStructureID = metadata.m_newStructure;
     if (!newStructureID) {
         PropertyOffset offset = structure->getConcurrently(uid);
         if (!isValidOffset(offset))
@@ -79,7 +79,7 @@ PutByIdStatus PutByIdStatus::computeFromLLInt(CodeBlock* profiledBlock, unsigned
         return PutByIdStatus(NoInformation);
     
     ObjectPropertyConditionSet conditionSet;
-    if (!(bytecode.flags & PutByIdIsDirect)) {
+    if (!(bytecode.m_flags & PutByIdIsDirect)) {
         conditionSet =
             generateConditionsForPropertySetterMissConcurrently(
                 vm, profiledBlock->globalObject(), structure, uid);
index 1f8e02c..6bb9496 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2012-2019 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -145,7 +145,7 @@ static void dumpLineColumnEntry(size_t index, const InstructionStream& instructi
     const auto instruction = instructionStream.at(instructionOffset);
     const char* event = "";
     if (instruction->is<OpDebug>()) {
-        switch (instruction->as<OpDebug>().debugHookType) {
+        switch (instruction->as<OpDebug>().m_debugHookType) {
         case WillExecuteProgram: event = " WillExecuteProgram"; break;
         case DidExecuteProgram: event = " DidExecuteProgram"; break;
         case DidEnterCallFrame: event = " DidEnterCallFrame"; break;
index a138942..6676ee2 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
  * Copyright (C) 2012 Igalia, S.L.
  *
@@ -1389,13 +1389,13 @@ template<typename BinOp, typename JmpOp>
 bool BytecodeGenerator::fuseCompareAndJump(RegisterID* cond, Label& target, bool swapOperands)
 {
     auto binop = m_lastInstruction->as<BinOp>();
-    if (cond->index() == binop.dst.offset() && cond->isTemporary() && !cond->refCount()) {
+    if (cond->index() == binop.m_dst.offset() && cond->isTemporary() && !cond->refCount()) {
         rewind();
 
         if (swapOperands)
-            std::swap(binop.lhs, binop.rhs);
+            std::swap(binop.m_lhs, binop.m_rhs);
 
-        JmpOp::emit(this, binop.lhs, binop.rhs, target.bind(this));
+        JmpOp::emit(this, binop.m_lhs, binop.m_rhs, target.bind(this));
         return true;
     }
     return false;
@@ -1405,10 +1405,10 @@ template<typename UnaryOp, typename JmpOp>
 bool BytecodeGenerator::fuseTestAndJmp(RegisterID* cond, Label& target)
 {
     auto unop = m_lastInstruction->as<UnaryOp>();
-    if (cond->index() == unop.dst.offset() && cond->isTemporary() && !cond->refCount()) {
+    if (cond->index() == unop.m_dst.offset() && cond->isTemporary() && !cond->refCount()) {
         rewind();
 
-        JmpOp::emit(this, unop.operand, target.bind(this));
+        JmpOp::emit(this, unop.m_operand, target.bind(this));
         return true;
     }
     return false;
@@ -1709,49 +1709,49 @@ RegisterID* BytecodeGenerator::emitEqualityOp(RegisterID* dst, RegisterID* src1,
 {
     if (m_lastInstruction->is<OpTypeof>()) {
         auto op = m_lastInstruction->as<OpTypeof>();
-        if (src1->index() == op.dst.offset()
+        if (src1->index() == op.m_dst.offset()
             && src1->isTemporary()
             && m_codeBlock->isConstantRegisterIndex(src2->index())
             && m_codeBlock->constantRegister(src2->index()).get().isString()) {
             const String& value = asString(m_codeBlock->constantRegister(src2->index()).get())->tryGetValue();
             if (value == "undefined") {
                 rewind();
-                OpIsUndefined::emit(this, dst, op.value);
+                OpIsUndefined::emit(this, dst, op.m_value);
                 return dst;
             }
             if (value == "boolean") {
                 rewind();
-                OpIsBoolean::emit(this, dst, op.value);
+                OpIsBoolean::emit(this, dst, op.m_value);
                 return dst;
             }
             if (value == "number") {
                 rewind();
-                OpIsNumber::emit(this, dst, op.value);
+                OpIsNumber::emit(this, dst, op.m_value);
                 return dst;
             }
             if (value == "string") {
                 rewind();
-                OpIsCellWithType::emit(this, dst, op.value, StringType);
+                OpIsCellWithType::emit(this, dst, op.m_value, StringType);
                 return dst;
             }
             if (value == "symbol") {
                 rewind();
-                OpIsCellWithType::emit(this, dst, op.value, SymbolType);
+                OpIsCellWithType::emit(this, dst, op.m_value, SymbolType);
                 return dst;
             }
             if (Options::useBigInt() && value == "bigint") {
                 rewind();
-                OpIsCellWithType::emit(this, dst, op.value, BigIntType);
+                OpIsCellWithType::emit(this, dst, op.m_value, BigIntType);
                 return dst;
             }
             if (value == "object") {
                 rewind();
-                OpIsObjectOrNull::emit(this, dst, op.value);
+                OpIsObjectOrNull::emit(this, dst, op.m_value);
                 return dst;
             }
             if (value == "function") {
                 rewind();
-                OpIsFunction::emit(this, dst, op.value);
+                OpIsFunction::emit(this, dst, op.m_value);
                 return dst;
             }
         }
@@ -3889,7 +3889,7 @@ void BytecodeGenerator::endSwitch(uint32_t clauseCount, const Vector<Ref<Label>,
             return BoundLabel();
         });
 
-        UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->switchJumpTable(bytecode.tableIndex);
+        UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->switchJumpTable(bytecode.m_tableIndex);
         prepareJumpTableForSwitch(
             jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes, min, max,
             switchInfo.switchType == SwitchInfo::SwitchImmediate
@@ -3914,7 +3914,7 @@ void BytecodeGenerator::endSwitch(uint32_t clauseCount, const Vector<Ref<Label>,
             return BoundLabel();
         });
 
-        UnlinkedStringJumpTable& jumpTable = m_codeBlock->stringSwitchJumpTable(ref->as<OpSwitchString>().tableIndex);
+        UnlinkedStringJumpTable& jumpTable = m_codeBlock->stringSwitchJumpTable(ref->as<OpSwitchString>().m_tableIndex);
         prepareJumpTableForStringSwitch(jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes);
         break;
     }
@@ -4860,7 +4860,7 @@ void StructureForInContext::finalize(BytecodeGenerator& generator, UnlinkedCodeB
         // 1. dst stays the same.
         // 2. base stays the same.
         // 3. property gets switched to the original property.
-        OpGetByVal::emit<OpcodeSize::Wide>(&generator, bytecode.dst, bytecode.base, VirtualRegister(propertyRegIndex));
+        OpGetByVal::emit<OpcodeSize::Wide>(&generator, bytecode.m_dst, bytecode.m_base, VirtualRegister(propertyRegIndex));
 
         // 4. nop out the remaining bytes
         while (generator.m_writer.position() < end)
index 675c601..8e49207 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -1231,8 +1231,8 @@ template<typename CallOp>
 ByteCodeParser::Terminality ByteCodeParser::handleCall(const Instruction* pc, NodeType op, CallMode callMode)
 {
     auto bytecode = pc->as<CallOp>();
-    Node* callTarget = get(bytecode.callee);
-    int registerOffset = -static_cast<int>(bytecode.argv);
+    Node* callTarget = get(bytecode.m_callee);
+    int registerOffset = -static_cast<int>(bytecode.m_argv);
 
     CallLinkStatus callLinkStatus = CallLinkStatus::computeFor(
         m_inlineStackTop->m_profiledBlock, currentCodeOrigin(),
@@ -1240,8 +1240,8 @@ ByteCodeParser::Terminality ByteCodeParser::handleCall(const Instruction* pc, No
 
     InlineCallFrame::Kind kind = InlineCallFrame::kindFor(callMode);
 
-    return handleCall(bytecode.dst, op, kind, pc->size(), callTarget,
-        bytecode.argc, registerOffset, callLinkStatus, getPrediction());
+    return handleCall(bytecode.m_dst, op, kind, pc->size(), callTarget,
+        bytecode.m_argc, registerOffset, callLinkStatus, getPrediction());
 }
 
 void ByteCodeParser::refineStatically(CallLinkStatus& callLinkStatus, Node* callTarget)
@@ -1287,12 +1287,12 @@ template<typename CallOp>
 ByteCodeParser::Terminality ByteCodeParser::handleVarargsCall(const Instruction* pc, NodeType op, CallMode callMode)
 {
     auto bytecode = pc->as<CallOp>();
-    int firstFreeReg = bytecode.firstFree.offset();
-    int firstVarArgOffset = bytecode.firstVarArg;
+    int firstFreeReg = bytecode.m_firstFree.offset();
+    int firstVarArgOffset = bytecode.m_firstVarArg;
     
     SpeculatedType prediction = getPrediction();
     
-    Node* callTarget = get(bytecode.callee);
+    Node* callTarget = get(bytecode.m_callee);
     
     CallLinkStatus callLinkStatus = CallLinkStatus::computeFor(
         m_inlineStackTop->m_profiledBlock, currentCodeOrigin(),
@@ -1304,8 +1304,8 @@ ByteCodeParser::Terminality ByteCodeParser::handleVarargsCall(const Instruction*
     if (callLinkStatus.canOptimize()) {
         addToGraph(FilterCallLinkStatus, OpInfo(m_graph.m_plan.recordedStatuses().addCallLinkStatus(currentCodeOrigin(), callLinkStatus)), callTarget);
 
-        if (handleVarargsInlining(callTarget, bytecode.dst,
-            callLinkStatus, firstFreeReg, bytecode.thisValue, bytecode.arguments,
+        if (handleVarargsInlining(callTarget, bytecode.m_dst,
+            callLinkStatus, firstFreeReg, bytecode.m_thisValue, bytecode.m_arguments,
             firstVarArgOffset, op,
             InlineCallFrame::varargsKindFor(callMode))) {
             if (UNLIKELY(m_graph.compilation()))
@@ -1317,10 +1317,10 @@ ByteCodeParser::Terminality ByteCodeParser::handleVarargsCall(const Instruction*
     CallVarargsData* data = m_graph.m_callVarargsData.add();
     data->firstVarArgOffset = firstVarArgOffset;
     
-    Node* thisChild = get(bytecode.thisValue);
+    Node* thisChild = get(bytecode.m_thisValue);
     Node* argumentsChild = nullptr;
     if (op != TailCallForwardVarargs)
-        argumentsChild = get(bytecode.arguments);
+        argumentsChild = get(bytecode.m_arguments);
 
     if (op == TailCallVarargs || op == TailCallForwardVarargs) {
         if (allInlineFramesAreTailCalls()) {
@@ -1331,8 +1331,8 @@ ByteCodeParser::Terminality ByteCodeParser::handleVarargsCall(const Instruction*
     }
 
     Node* call = addToGraph(op, OpInfo(data), OpInfo(prediction), callTarget, thisChild, argumentsChild);
-    if (bytecode.dst.isValid())
-        set(bytecode.dst, call);
+    if (bytecode.m_dst.isValid())
+        set(bytecode.m_dst, call);
     return NonTerminal;
 }
 
@@ -4579,8 +4579,8 @@ void ByteCodeParser::parseGetById(const Instruction* currentInstruction)
     auto bytecode = currentInstruction->as<Op>();
     SpeculatedType prediction = getPrediction();
     
-    Node* base = get(bytecode.base);
-    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
+    Node* base = get(bytecode.m_base);
+    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     
     UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
     GetByIdStatus getByIdStatus = GetByIdStatus::computeFor(
@@ -4596,7 +4596,7 @@ void ByteCodeParser::parseGetById(const Instruction* currentInstruction)
         type = AccessType::GetDirect;
 
     handleGetById(
-        bytecode.dst, prediction, base, identifierNumber, getByIdStatus, type, opcodeLength);
+        bytecode.m_dst, prediction, base, identifierNumber, getByIdStatus, type, opcodeLength);
 
 }
 
@@ -4733,8 +4733,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             Node* op1 = getThis();
             if (op1->op() != ToThis) {
                 auto& metadata = currentInstruction->as<OpToThis>().metadata(codeBlock);
-                Structure* cachedStructure = metadata.cachedStructure.get();
-                if (metadata.toThisStatus != ToThisOK
+                Structure* cachedStructure = metadata.m_cachedStructure.get();
+                if (metadata.m_toThisStatus != ToThisOK
                     || !cachedStructure
                     || cachedStructure->classInfo()->methodTable.toThis != JSObject::info()->methodTable.toThis
                     || m_inlineStackTop->m_profiledBlock->couldTakeSlowCase(m_currentIndex)
@@ -4753,11 +4753,11 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_create_this: {
             auto bytecode = currentInstruction->as<OpCreateThis>();
-            Node* callee = get(VirtualRegister(bytecode.callee));
+            Node* callee = get(VirtualRegister(bytecode.m_callee));
 
             JSFunction* function = callee->dynamicCastConstant<JSFunction*>(*m_vm);
             if (!function) {
-                JSCell* cachedFunction = bytecode.metadata(codeBlock).cachedCallee.unvalidatedGet();
+                JSCell* cachedFunction = bytecode.metadata(codeBlock).m_cachedCallee.unvalidatedGet();
                 if (cachedFunction
                     && cachedFunction != JSCell::seenMultipleCalleeObjects()
                     && !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, BadCell)) {
@@ -4793,66 +4793,66 @@ void ByteCodeParser::parseBlock(unsigned limit)
                                 ASSERT(isInlineOffset(knownPolyProtoOffset));
                                 addToGraph(PutByOffset, OpInfo(data), object, object, weakJSConstant(prototype));
                             }
-                            set(VirtualRegister(bytecode.dst), object);
+                            set(VirtualRegister(bytecode.m_dst), object);
                             alreadyEmitted = true;
                         }
                     }
                 }
             }
             if (!alreadyEmitted) {
-                set(VirtualRegister(bytecode.dst),
-                    addToGraph(CreateThis, OpInfo(bytecode.inlineCapacity), callee));
+                set(VirtualRegister(bytecode.m_dst),
+                    addToGraph(CreateThis, OpInfo(bytecode.m_inlineCapacity), callee));
             }
             NEXT_OPCODE(op_create_this);
         }
 
         case op_new_object: {
             auto bytecode = currentInstruction->as<OpNewObject>();
-            set(bytecode.dst,
+            set(bytecode.m_dst,
                 addToGraph(NewObject,
-                    OpInfo(m_graph.registerStructure(bytecode.metadata(codeBlock).objectAllocationProfile.structure()))));
+                    OpInfo(m_graph.registerStructure(bytecode.metadata(codeBlock).m_objectAllocationProfile.structure()))));
             NEXT_OPCODE(op_new_object);
         }
             
         case op_new_array: {
             auto bytecode = currentInstruction->as<OpNewArray>();
-            int startOperand = bytecode.argv.offset();
-            int numOperands = bytecode.argc;
-            ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).arrayAllocationProfile;
+            int startOperand = bytecode.m_argv.offset();
+            int numOperands = bytecode.m_argc;
+            ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).m_arrayAllocationProfile;
             for (int operandIdx = startOperand; operandIdx > startOperand - numOperands; --operandIdx)
                 addVarArgChild(get(VirtualRegister(operandIdx)));
             unsigned vectorLengthHint = std::max<unsigned>(profile.vectorLengthHint(), numOperands);
-            set(bytecode.dst, addToGraph(Node::VarArg, NewArray, OpInfo(profile.selectIndexingType()), OpInfo(vectorLengthHint)));
+            set(bytecode.m_dst, addToGraph(Node::VarArg, NewArray, OpInfo(profile.selectIndexingType()), OpInfo(vectorLengthHint)));
             NEXT_OPCODE(op_new_array);
         }
 
         case op_new_array_with_spread: {
             auto bytecode = currentInstruction->as<OpNewArrayWithSpread>();
-            int startOperand = bytecode.argv.offset();
-            int numOperands = bytecode.argc;
-            const BitVector& bitVector = m_inlineStackTop->m_profiledBlock->unlinkedCodeBlock()->bitVector(bytecode.bitVector);
+            int startOperand = bytecode.m_argv.offset();
+            int numOperands = bytecode.m_argc;
+            const BitVector& bitVector = m_inlineStackTop->m_profiledBlock->unlinkedCodeBlock()->bitVector(bytecode.m_bitVector);
             for (int operandIdx = startOperand; operandIdx > startOperand - numOperands; --operandIdx)
                 addVarArgChild(get(VirtualRegister(operandIdx)));
 
             BitVector* copy = m_graph.m_bitVectors.add(bitVector);
             ASSERT(*copy == bitVector);
 
-            set(bytecode.dst,
+            set(bytecode.m_dst,
                 addToGraph(Node::VarArg, NewArrayWithSpread, OpInfo(copy)));
             NEXT_OPCODE(op_new_array_with_spread);
         }
 
         case op_spread: {
             auto bytecode = currentInstruction->as<OpSpread>();
-            set(bytecode.dst,
-                addToGraph(Spread, get(bytecode.argument)));
+            set(bytecode.m_dst,
+                addToGraph(Spread, get(bytecode.m_argument)));
             NEXT_OPCODE(op_spread);
         }
             
         case op_new_array_with_size: {
             auto bytecode = currentInstruction->as<OpNewArrayWithSize>();
-            ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).arrayAllocationProfile;
-            set(bytecode.dst, addToGraph(NewArrayWithSize, OpInfo(profile.selectIndexingType()), get(bytecode.length)));
+            ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).m_arrayAllocationProfile;
+            set(bytecode.m_dst, addToGraph(NewArrayWithSize, OpInfo(profile.selectIndexingType()), get(bytecode.m_length)));
             NEXT_OPCODE(op_new_array_with_size);
         }
             
@@ -4861,22 +4861,22 @@ void ByteCodeParser::parseBlock(unsigned limit)
             // Unfortunately, we can't allocate a new JSImmutableButterfly if the profile tells us new information because we
             // cannot allocate from compilation threads.
             WTF::loadLoadFence();
-            FrozenValue* frozen = get(VirtualRegister(bytecode.immutableButterfly))->constant();
+            FrozenValue* frozen = get(VirtualRegister(bytecode.m_immutableButterfly))->constant();
             WTF::loadLoadFence();
             JSImmutableButterfly* immutableButterfly = frozen->cast<JSImmutableButterfly*>();
             NewArrayBufferData data { };
             data.indexingMode = immutableButterfly->indexingMode();
             data.vectorLengthHint = immutableButterfly->toButterfly()->vectorLength();
 
-            set(VirtualRegister(bytecode.dst), addToGraph(NewArrayBuffer, OpInfo(frozen), OpInfo(data.asQuadWord)));
+            set(VirtualRegister(bytecode.m_dst), addToGraph(NewArrayBuffer, OpInfo(frozen), OpInfo(data.asQuadWord)));
             NEXT_OPCODE(op_new_array_buffer);
         }
             
         case op_new_regexp: {
             auto bytecode = currentInstruction->as<OpNewRegexp>();
-            ASSERT(bytecode.regexp.isConstant());
-            FrozenValue* frozenRegExp = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.regexp.offset()));
-            set(bytecode.dst, addToGraph(NewRegexp, OpInfo(frozenRegExp), jsConstant(jsNumber(0))));
+            ASSERT(bytecode.m_regexp.isConstant());
+            FrozenValue* frozenRegExp = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.m_regexp.offset()));
+            set(bytecode.m_dst, addToGraph(NewRegexp, OpInfo(frozenRegExp), jsConstant(jsNumber(0))));
             NEXT_OPCODE(op_new_regexp);
         }
 
@@ -4887,24 +4887,24 @@ void ByteCodeParser::parseBlock(unsigned limit)
             if (inlineCallFrame && !inlineCallFrame->isVarargs()) {
                 unsigned argumentsLength = inlineCallFrame->argumentCountIncludingThis - 1;
                 JSValue restLength;
-                if (argumentsLength <= bytecode.numParametersToSkip)
+                if (argumentsLength <= bytecode.m_numParametersToSkip)
                     restLength = jsNumber(0);
                 else
-                    restLength = jsNumber(argumentsLength - bytecode.numParametersToSkip);
+                    restLength = jsNumber(argumentsLength - bytecode.m_numParametersToSkip);
 
                 length = jsConstant(restLength);
             } else
-                length = addToGraph(GetRestLength, OpInfo(bytecode.numParametersToSkip));
-            set(bytecode.dst, length);
+                length = addToGraph(GetRestLength, OpInfo(bytecode.m_numParametersToSkip));
+            set(bytecode.m_dst, length);
             NEXT_OPCODE(op_get_rest_length);
         }
 
         case op_create_rest: {
             auto bytecode = currentInstruction->as<OpCreateRest>();
             noticeArgumentsUse();
-            Node* arrayLength = get(bytecode.arraySize);
-            set(bytecode.dst,
-                addToGraph(CreateRest, OpInfo(bytecode.numParametersToSkip), arrayLength));
+            Node* arrayLength = get(bytecode.m_arraySize);
+            set(bytecode.m_dst,
+                addToGraph(CreateRest, OpInfo(bytecode.m_numParametersToSkip), arrayLength));
             NEXT_OPCODE(op_create_rest);
         }
             
@@ -4912,74 +4912,74 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_bitnot: {
             auto bytecode = currentInstruction->as<OpBitnot>();
-            Node* op1 = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(ArithBitNot, op1));
+            Node* op1 = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(ArithBitNot, op1));
             NEXT_OPCODE(op_bitnot);
         }
 
         case op_bitand: {
             auto bytecode = currentInstruction->as<OpBitand>();
             SpeculatedType prediction = getPrediction();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberOrAnyIntResult() && op2->hasNumberOrAnyIntResult())
-                set(bytecode.dst, addToGraph(ArithBitAnd, op1, op2));
+                set(bytecode.m_dst, addToGraph(ArithBitAnd, op1, op2));
             else
-                set(bytecode.dst, addToGraph(ValueBitAnd, OpInfo(), OpInfo(prediction), op1, op2));
+                set(bytecode.m_dst, addToGraph(ValueBitAnd, OpInfo(), OpInfo(prediction), op1, op2));
             NEXT_OPCODE(op_bitand);
         }
 
         case op_bitor: {
             auto bytecode = currentInstruction->as<OpBitor>();
             SpeculatedType prediction = getPrediction();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberOrAnyIntResult() && op2->hasNumberOrAnyIntResult())
-                set(bytecode.dst, addToGraph(ArithBitOr, op1, op2));
+                set(bytecode.m_dst, addToGraph(ArithBitOr, op1, op2));
             else
-                set(bytecode.dst, addToGraph(ValueBitOr, OpInfo(), OpInfo(prediction), op1, op2));
+                set(bytecode.m_dst, addToGraph(ValueBitOr, OpInfo(), OpInfo(prediction), op1, op2));
             NEXT_OPCODE(op_bitor);
         }
 
         case op_bitxor: {
             auto bytecode = currentInstruction->as<OpBitxor>();
             SpeculatedType prediction = getPrediction();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberOrAnyIntResult() && op2->hasNumberOrAnyIntResult())
-                set(bytecode.dst, addToGraph(ArithBitXor, op1, op2));
+                set(bytecode.m_dst, addToGraph(ArithBitXor, op1, op2));
             else
-                set(bytecode.dst, addToGraph(ValueBitXor, OpInfo(), OpInfo(prediction), op1, op2));
-            NEXT_OPCODE(op_bitor);
+                set(bytecode.m_dst, addToGraph(ValueBitXor, OpInfo(), OpInfo(prediction), op1, op2));
+            NEXT_OPCODE(op_bitxor);
         }
 
         case op_rshift: {
             auto bytecode = currentInstruction->as<OpRshift>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(BitRShift, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(BitRShift, op1, op2));
             NEXT_OPCODE(op_rshift);
         }
 
         case op_lshift: {
             auto bytecode = currentInstruction->as<OpLshift>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(BitLShift, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(BitLShift, op1, op2));
             NEXT_OPCODE(op_lshift);
         }
 
         case op_urshift: {
             auto bytecode = currentInstruction->as<OpUrshift>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(BitURShift, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(BitURShift, op1, op2));
             NEXT_OPCODE(op_urshift);
         }
             
         case op_unsigned: {
             auto bytecode = currentInstruction->as<OpUnsigned>();
-            set(bytecode.dst, makeSafe(addToGraph(UInt32ToNumber, get(bytecode.operand))));
+            set(bytecode.m_dst, makeSafe(addToGraph(UInt32ToNumber, get(bytecode.m_operand))));
             NEXT_OPCODE(op_unsigned);
         }
 
@@ -4987,15 +4987,15 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_inc: {
             auto bytecode = currentInstruction->as<OpInc>();
-            Node* op = get(bytecode.srcDst);
-            set(bytecode.srcDst, makeSafe(addToGraph(ArithAdd, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
+            Node* op = get(bytecode.m_srcDst);
+            set(bytecode.m_srcDst, makeSafe(addToGraph(ArithAdd, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
             NEXT_OPCODE(op_inc);
         }
 
         case op_dec: {
             auto bytecode = currentInstruction->as<OpDec>();
-            Node* op = get(bytecode.srcDst);
-            set(bytecode.srcDst, makeSafe(addToGraph(ArithSub, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
+            Node* op = get(bytecode.m_srcDst);
+            set(bytecode.m_srcDst, makeSafe(addToGraph(ArithSub, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
             NEXT_OPCODE(op_dec);
         }
 
@@ -5003,53 +5003,53 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_add: {
             auto bytecode = currentInstruction->as<OpAdd>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberResult() && op2->hasNumberResult())
-                set(bytecode.dst, makeSafe(addToGraph(ArithAdd, op1, op2)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ArithAdd, op1, op2)));
             else
-                set(bytecode.dst, makeSafe(addToGraph(ValueAdd, op1, op2)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ValueAdd, op1, op2)));
             NEXT_OPCODE(op_add);
         }
 
         case op_sub: {
             auto bytecode = currentInstruction->as<OpSub>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberResult() && op2->hasNumberResult())
-                set(bytecode.dst, makeSafe(addToGraph(ArithSub, op1, op2)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ArithSub, op1, op2)));
             else
-                set(bytecode.dst, makeSafe(addToGraph(ValueSub, op1, op2)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ValueSub, op1, op2)));
             NEXT_OPCODE(op_sub);
         }
 
         case op_negate: {
             auto bytecode = currentInstruction->as<OpNegate>();
-            Node* op1 = get(bytecode.operand);
+            Node* op1 = get(bytecode.m_operand);
             if (op1->hasNumberResult())
-                set(bytecode.dst, makeSafe(addToGraph(ArithNegate, op1)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ArithNegate, op1)));
             else
-                set(bytecode.dst, makeSafe(addToGraph(ValueNegate, op1)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ValueNegate, op1)));
             NEXT_OPCODE(op_negate);
         }
 
         case op_mul: {
             // Multiply requires that the inputs are not truncated, unfortunately.
             auto bytecode = currentInstruction->as<OpMul>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberResult() && op2->hasNumberResult())
-                set(bytecode.dst, makeSafe(addToGraph(ArithMul, op1, op2)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ArithMul, op1, op2)));
             else
-                set(bytecode.dst, makeSafe(addToGraph(ValueMul, op1, op2)));
+                set(bytecode.m_dst, makeSafe(addToGraph(ValueMul, op1, op2)));
             NEXT_OPCODE(op_mul);
         }
 
         case op_mod: {
             auto bytecode = currentInstruction->as<OpMod>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, makeSafe(addToGraph(ArithMod, op1, op2)));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, makeSafe(addToGraph(ArithMod, op1, op2)));
             NEXT_OPCODE(op_mod);
         }
 
@@ -5057,20 +5057,20 @@ void ByteCodeParser::parseBlock(unsigned limit)
             // FIXME: ArithPow(Untyped, Untyped) should be supported as the same to ArithMul, ArithSub etc.
             // https://bugs.webkit.org/show_bug.cgi?id=160012
             auto bytecode = currentInstruction->as<OpPow>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(ArithPow, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(ArithPow, op1, op2));
             NEXT_OPCODE(op_pow);
         }
 
         case op_div: {
             auto bytecode = currentInstruction->as<OpDiv>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             if (op1->hasNumberResult() && op2->hasNumberResult())
-                set(bytecode.dst, makeDivSafe(addToGraph(ArithDiv, op1, op2)));
+                set(bytecode.m_dst, makeDivSafe(addToGraph(ArithDiv, op1, op2)));
             else
-                set(bytecode.dst, makeDivSafe(addToGraph(ValueDiv, op1, op2)));
+                set(bytecode.m_dst, makeDivSafe(addToGraph(ValueDiv, op1, op2)));
             NEXT_OPCODE(op_div);
         }
 
@@ -5085,14 +5085,14 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_mov: {
             auto bytecode = currentInstruction->as<OpMov>();
-            Node* op = get(bytecode.src);
-            set(bytecode.dst, op);
+            Node* op = get(bytecode.m_src);
+            set(bytecode.m_dst, op);
             NEXT_OPCODE(op_mov);
         }
 
         case op_check_tdz: {
             auto bytecode = currentInstruction->as<OpCheckTdz>();
-            addToGraph(CheckNotEmpty, get(bytecode.target));
+            addToGraph(CheckNotEmpty, get(bytecode.m_target));
             NEXT_OPCODE(op_check_tdz);
         }
 
@@ -5100,18 +5100,18 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpOverridesHasInstance>();
             JSFunction* defaultHasInstanceSymbolFunction = m_inlineStackTop->m_codeBlock->globalObjectFor(currentCodeOrigin())->functionProtoHasInstanceSymbolFunction();
 
-            Node* constructor = get(VirtualRegister(bytecode.constructor));
-            Node* hasInstanceValue = get(VirtualRegister(bytecode.hasInstanceValue));
+            Node* constructor = get(VirtualRegister(bytecode.m_constructor));
+            Node* hasInstanceValue = get(VirtualRegister(bytecode.m_hasInstanceValue));
 
-            set(VirtualRegister(bytecode.dst), addToGraph(OverridesHasInstance, OpInfo(m_graph.freeze(defaultHasInstanceSymbolFunction)), constructor, hasInstanceValue));
+            set(VirtualRegister(bytecode.m_dst), addToGraph(OverridesHasInstance, OpInfo(m_graph.freeze(defaultHasInstanceSymbolFunction)), constructor, hasInstanceValue));
             NEXT_OPCODE(op_overrides_has_instance);
         }
 
         case op_identity_with_profile: {
             auto bytecode = currentInstruction->as<OpIdentityWithProfile>();
-            Node* srcDst = get(bytecode.srcDst);
-            SpeculatedType speculation = static_cast<SpeculatedType>(bytecode.topProfile) << 32 | static_cast<SpeculatedType>(bytecode.bottomProfile);
-            set(bytecode.srcDst, addToGraph(IdentityWithProfile, OpInfo(speculation), srcDst));
+            Node* srcDst = get(bytecode.m_srcDst);
+            SpeculatedType speculation = static_cast<SpeculatedType>(bytecode.m_topProfile) << 32 | static_cast<SpeculatedType>(bytecode.m_bottomProfile);
+            set(bytecode.m_srcDst, addToGraph(IdentityWithProfile, OpInfo(speculation), srcDst));
             NEXT_OPCODE(op_identity_with_profile);
         }
 
@@ -5122,8 +5122,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 m_inlineStackTop->m_profiledBlock, m_inlineStackTop->m_baselineMap,
                 m_currentIndex);
             
-            Node* value = get(bytecode.value);
-            Node* prototype = get(bytecode.prototype);
+            Node* value = get(bytecode.m_value);
+            Node* prototype = get(bytecode.m_prototype);
 
             // Only inline it if it's Simple with a commonPrototype; bottom/top or variable
             // prototypes both get handled by the IC. This makes sense for bottom (unprofiled)
@@ -5151,102 +5151,102 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 
                 if (allOK) {
                     Node* match = addToGraph(MatchStructure, OpInfo(data), value);
-                    set(bytecode.dst, match);
+                    set(bytecode.m_dst, match);
                     NEXT_OPCODE(op_instanceof);
                 }
             }
             
-            set(bytecode.dst, addToGraph(InstanceOf, value, prototype));
+            set(bytecode.m_dst, addToGraph(InstanceOf, value, prototype));
             NEXT_OPCODE(op_instanceof);
         }
 
         case op_instanceof_custom: {
             auto bytecode = currentInstruction->as<OpInstanceofCustom>();
-            Node* value = get(bytecode.value);
-            Node* constructor = get(bytecode.constructor);
-            Node* hasInstanceValue = get(bytecode.hasInstanceValue);
-            set(bytecode.dst, addToGraph(InstanceOfCustom, value, constructor, hasInstanceValue));
+            Node* value = get(bytecode.m_value);
+            Node* constructor = get(bytecode.m_constructor);
+            Node* hasInstanceValue = get(bytecode.m_hasInstanceValue);
+            set(bytecode.m_dst, addToGraph(InstanceOfCustom, value, constructor, hasInstanceValue));
             NEXT_OPCODE(op_instanceof_custom);
         }
         case op_is_empty: {
             auto bytecode = currentInstruction->as<OpIsEmpty>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsEmpty, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsEmpty, value));
             NEXT_OPCODE(op_is_empty);
         }
         case op_is_undefined: {
             auto bytecode = currentInstruction->as<OpIsUndefined>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsUndefined, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsUndefined, value));
             NEXT_OPCODE(op_is_undefined);
         }
         case op_is_undefined_or_null: {
             auto bytecode = currentInstruction->as<OpIsUndefinedOrNull>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsUndefinedOrNull, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsUndefinedOrNull, value));
             NEXT_OPCODE(op_is_undefined_or_null);
         }
 
         case op_is_boolean: {
             auto bytecode = currentInstruction->as<OpIsBoolean>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsBoolean, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsBoolean, value));
             NEXT_OPCODE(op_is_boolean);
         }
 
         case op_is_number: {
             auto bytecode = currentInstruction->as<OpIsNumber>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsNumber, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsNumber, value));
             NEXT_OPCODE(op_is_number);
         }
 
         case op_is_cell_with_type: {
             auto bytecode = currentInstruction->as<OpIsCellWithType>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsCellWithType, OpInfo(bytecode.type), value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsCellWithType, OpInfo(bytecode.m_type), value));
             NEXT_OPCODE(op_is_cell_with_type);
         }
 
         case op_is_object: {
             auto bytecode = currentInstruction->as<OpIsObject>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsObject, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsObject, value));
             NEXT_OPCODE(op_is_object);
         }
 
         case op_is_object_or_null: {
             auto bytecode = currentInstruction->as<OpIsObjectOrNull>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsObjectOrNull, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsObjectOrNull, value));
             NEXT_OPCODE(op_is_object_or_null);
         }
 
         case op_is_function: {
             auto bytecode = currentInstruction->as<OpIsFunction>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(IsFunction, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(IsFunction, value));
             NEXT_OPCODE(op_is_function);
         }
 
         case op_not: {
             auto bytecode = currentInstruction->as<OpNot>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(LogicalNot, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(LogicalNot, value));
             NEXT_OPCODE(op_not);
         }
             
         case op_to_primitive: {
             auto bytecode = currentInstruction->as<OpToPrimitive>();
-            Node* value = get(bytecode.src);
-            set(bytecode.dst, addToGraph(ToPrimitive, value));
+            Node* value = get(bytecode.m_src);
+            set(bytecode.m_dst, addToGraph(ToPrimitive, value));
             NEXT_OPCODE(op_to_primitive);
         }
             
         case op_strcat: {
             auto bytecode = currentInstruction->as<OpStrcat>();
-            int startOperand = bytecode.src.offset();
-            int numOperands = bytecode.count;
+            int startOperand = bytecode.m_src.offset();
+            int numOperands = bytecode.m_count;
 #if CPU(X86)
             // X86 doesn't have enough registers to compile MakeRope with three arguments. The
             // StrCat we emit here may be turned into a MakeRope. Rather than try to be clever,
@@ -5271,105 +5271,105 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 ASSERT(indexInOperands < maxArguments);
                 operands[indexInOperands++] = get(VirtualRegister(startOperand - operandIdx));
             }
-            set(bytecode.dst, addToGraph(StrCat, operands[0], operands[1], operands[2]));
+            set(bytecode.m_dst, addToGraph(StrCat, operands[0], operands[1], operands[2]));
             NEXT_OPCODE(op_strcat);
         }
 
         case op_less: {
             auto bytecode = currentInstruction->as<OpLess>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareLess, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareLess, op1, op2));
             NEXT_OPCODE(op_less);
         }
 
         case op_lesseq: {
             auto bytecode = currentInstruction->as<OpLesseq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareLessEq, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareLessEq, op1, op2));
             NEXT_OPCODE(op_lesseq);
         }
 
         case op_greater: {
             auto bytecode = currentInstruction->as<OpGreater>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareGreater, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareGreater, op1, op2));
             NEXT_OPCODE(op_greater);
         }
 
         case op_greatereq: {
             auto bytecode = currentInstruction->as<OpGreatereq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareGreaterEq, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareGreaterEq, op1, op2));
             NEXT_OPCODE(op_greatereq);
         }
 
         case op_below: {
             auto bytecode = currentInstruction->as<OpBelow>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareBelow, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareBelow, op1, op2));
             NEXT_OPCODE(op_below);
         }
 
         case op_beloweq: {
             auto bytecode = currentInstruction->as<OpBeloweq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareBelowEq, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareBelowEq, op1, op2));
             NEXT_OPCODE(op_beloweq);
         }
 
         case op_eq: {
             auto bytecode = currentInstruction->as<OpEq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareEq, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareEq, op1, op2));
             NEXT_OPCODE(op_eq);
         }
 
         case op_eq_null: {
             auto bytecode = currentInstruction->as<OpEqNull>();
-            Node* value = get(bytecode.operand);
+            Node* value = get(bytecode.m_operand);
             Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
-            set(bytecode.dst, addToGraph(CompareEq, value, nullConstant));
+            set(bytecode.m_dst, addToGraph(CompareEq, value, nullConstant));
             NEXT_OPCODE(op_eq_null);
         }
 
         case op_stricteq: {
             auto bytecode = currentInstruction->as<OpStricteq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(CompareStrictEq, op1, op2));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(CompareStrictEq, op1, op2));
             NEXT_OPCODE(op_stricteq);
         }
 
         case op_neq: {
             auto bytecode = currentInstruction->as<OpNeq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
-            set(bytecode.dst, addToGraph(LogicalNot, addToGraph(CompareEq, op1, op2)));
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
+            set(bytecode.m_dst, addToGraph(LogicalNot, addToGraph(CompareEq, op1, op2)));
             NEXT_OPCODE(op_neq);
         }
 
         case op_neq_null: {
             auto bytecode = currentInstruction->as<OpNeqNull>();
-            Node* value = get(bytecode.operand);
+            Node* value = get(bytecode.m_operand);
             Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
-            set(bytecode.dst, addToGraph(LogicalNot, addToGraph(CompareEq, value, nullConstant)));
+            set(bytecode.m_dst, addToGraph(LogicalNot, addToGraph(CompareEq, value, nullConstant)));
             NEXT_OPCODE(op_neq_null);
         }
 
         case op_nstricteq: {
             auto bytecode = currentInstruction->as<OpNstricteq>();
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* invertedResult;
             invertedResult = addToGraph(CompareStrictEq, op1, op2);
-            set(bytecode.dst, addToGraph(LogicalNot, invertedResult));
+            set(bytecode.m_dst, addToGraph(LogicalNot, invertedResult));
             NEXT_OPCODE(op_nstricteq);
         }
 
@@ -5379,8 +5379,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpGetByVal>();
             SpeculatedType prediction = getPredictionWithoutOSRExit();
 
-            Node* base = get(bytecode.base);
-            Node* property = get(bytecode.property);
+            Node* base = get(bytecode.m_base);
+            Node* property = get(bytecode.m_property);
             bool compiledAsGetById = false;
             GetByIdStatus getByIdStatus;
             unsigned identifierNumber = 0;
@@ -5414,9 +5414,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
             }
 
             if (compiledAsGetById)
-                handleGetById(bytecode.dst, prediction, base, identifierNumber, getByIdStatus, AccessType::Get, currentInstruction->size());
+                handleGetById(bytecode.m_dst, prediction, base, identifierNumber, getByIdStatus, AccessType::Get, currentInstruction->size());
             else {
-                ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).arrayProfile, Array::Read);
+                ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).m_arrayProfile, Array::Read);
                 // FIXME: We could consider making this not vararg, since it only uses three child
                 // slots.
                 // https://bugs.webkit.org/show_bug.cgi?id=184192
@@ -5425,7 +5425,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 addVarArgChild(0); // Leave room for property storage.
                 Node* getByVal = addToGraph(Node::VarArg, GetByVal, OpInfo(arrayMode.asWord()), OpInfo(prediction));
                 m_exitOK = false; // GetByVal must be treated as if it clobbers exit state, since FixupPhase may make it generic.
-                set(bytecode.dst, getByVal);
+                set(bytecode.m_dst, getByVal);
             }
 
             NEXT_OPCODE(op_get_by_val);
@@ -5435,11 +5435,11 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpGetByValWithThis>();
             SpeculatedType prediction = getPrediction();
 
-            Node* base = get(bytecode.base);
-            Node* thisValue = get(bytecode.thisValue);
-            Node* property = get(bytecode.property);
+            Node* base = get(bytecode.m_base);
+            Node* thisValue = get(bytecode.m_thisValue);
+            Node* property = get(bytecode.m_property);
             Node* getByValWithThis = addToGraph(GetByValWithThis, OpInfo(), OpInfo(prediction), base, thisValue, property);
-            set(bytecode.dst, getByValWithThis);
+            set(bytecode.m_dst, getByValWithThis);
 
             NEXT_OPCODE(op_get_by_val_with_this);
         }
@@ -5455,10 +5455,10 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_put_by_val_with_this: {
             auto bytecode = currentInstruction->as<OpPutByValWithThis>();
-            Node* base = get(bytecode.base);
-            Node* thisValue = get(bytecode.thisValue);
-            Node* property = get(bytecode.property);
-            Node* value = get(bytecode.value);
+            Node* base = get(bytecode.m_base);
+            Node* thisValue = get(bytecode.m_thisValue);
+            Node* property = get(bytecode.m_property);
+            Node* value = get(bytecode.m_value);
 
             addVarArgChild(base);
             addVarArgChild(thisValue);
@@ -5471,10 +5471,10 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_define_data_property: {
             auto bytecode = currentInstruction->as<OpDefineDataProperty>();
-            Node* base = get(bytecode.base);
-            Node* property = get(bytecode.property);
-            Node* value = get(bytecode.value);
-            Node* attributes = get(bytecode.attributes);
+            Node* base = get(bytecode.m_base);
+            Node* property = get(bytecode.m_property);
+            Node* value = get(bytecode.m_value);
+            Node* attributes = get(bytecode.m_attributes);
 
             addVarArgChild(base);
             addVarArgChild(property);
@@ -5487,11 +5487,11 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_define_accessor_property: {
             auto bytecode = currentInstruction->as<OpDefineAccessorProperty>();
-            Node* base = get(bytecode.base);
-            Node* property = get(bytecode.property);
-            Node* getter = get(bytecode.getter);
-            Node* setter = get(bytecode.setter);
-            Node* attributes = get(bytecode.attributes);
+            Node* base = get(bytecode.m_base);
+            Node* property = get(bytecode.m_property);
+            Node* getter = get(bytecode.m_getter);
+            Node* setter = get(bytecode.m_setter);
+            Node* attributes = get(bytecode.m_attributes);
 
             addVarArgChild(base);
             addVarArgChild(property);
@@ -5519,21 +5519,21 @@ void ByteCodeParser::parseBlock(unsigned limit)
             SpeculatedType prediction = getPrediction();
 
             auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
-            Node* base = get(bytecode.base);
-            Node* thisValue = get(bytecode.thisValue);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
+            Node* base = get(bytecode.m_base);
+            Node* thisValue = get(bytecode.m_thisValue);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
 
-            set(bytecode.dst,
+            set(bytecode.m_dst,
                 addToGraph(GetByIdWithThis, OpInfo(identifierNumber), OpInfo(prediction), base, thisValue));
 
             NEXT_OPCODE(op_get_by_id_with_this);
         }
         case op_put_by_id: {
             auto bytecode = currentInstruction->as<OpPutById>();
-            Node* value = get(bytecode.value);
-            Node* base = get(bytecode.base);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
-            bool direct = !!(bytecode.flags & PutByIdIsDirect);
+            Node* value = get(bytecode.m_value);
+            Node* base = get(bytecode.m_base);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
+            bool direct = !!(bytecode.m_flags & PutByIdIsDirect);
 
             PutByIdStatus putByIdStatus = PutByIdStatus::computeFor(
                 m_inlineStackTop->m_profiledBlock,
@@ -5546,10 +5546,10 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_put_by_id_with_this: {
             auto bytecode = currentInstruction->as<OpPutByIdWithThis>();
-            Node* base = get(bytecode.base);
-            Node* thisValue = get(bytecode.thisValue);
-            Node* value = get(bytecode.value);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
+            Node* base = get(bytecode.m_base);
+            Node* thisValue = get(bytecode.m_thisValue);
+            Node* value = get(bytecode.m_value);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
 
             addToGraph(PutByIdWithThis, OpInfo(identifierNumber), base, thisValue, value);
             NEXT_OPCODE(op_put_by_id_with_this);
@@ -5565,11 +5565,11 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_put_getter_setter_by_id: {
             auto bytecode = currentInstruction->as<OpPutGetterSetterById>();
-            Node* base = get(bytecode.base);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
-            Node* getter = get(bytecode.getter);
-            Node* setter = get(bytecode.setter);
-            addToGraph(PutGetterSetterById, OpInfo(identifierNumber), OpInfo(bytecode.attributes), base, getter, setter);
+            Node* base = get(bytecode.m_base);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
+            Node* getter = get(bytecode.m_getter);
+            Node* setter = get(bytecode.m_setter);
+            addToGraph(PutGetterSetterById, OpInfo(identifierNumber), OpInfo(bytecode.m_attributes), base, getter, setter);
             NEXT_OPCODE(op_put_getter_setter_by_id);
         }
 
@@ -5583,31 +5583,31 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_del_by_id: {
             auto bytecode = currentInstruction->as<OpDelById>();
-            Node* base = get(bytecode.base);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
-            set(bytecode.dst, addToGraph(DeleteById, OpInfo(identifierNumber), base));
+            Node* base = get(bytecode.m_base);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
+            set(bytecode.m_dst, addToGraph(DeleteById, OpInfo(identifierNumber), base));
             NEXT_OPCODE(op_del_by_id);
         }
 
         case op_del_by_val: {
             auto bytecode = currentInstruction->as<OpDelByVal>();
-            Node* base = get(bytecode.base);
-            Node* key = get(bytecode.property);
-            set(bytecode.dst, addToGraph(DeleteByVal, base, key));
+            Node* base = get(bytecode.m_base);
+            Node* key = get(bytecode.m_property);
+            set(bytecode.m_dst, addToGraph(DeleteByVal, base, key));
             NEXT_OPCODE(op_del_by_val);
         }
 
         case op_profile_type: {
             auto bytecode = currentInstruction->as<OpProfileType>();
             auto& metadata = bytecode.metadata(codeBlock);
-            Node* valueToProfile = get(bytecode.target);
-            addToGraph(ProfileType, OpInfo(metadata.typeLocation), valueToProfile);
+            Node* valueToProfile = get(bytecode.m_target);
+            addToGraph(ProfileType, OpInfo(metadata.m_typeLocation), valueToProfile);
             NEXT_OPCODE(op_profile_type);
         }
 
         case op_profile_control_flow: {
             auto bytecode = currentInstruction->as<OpProfileControlFlow>();
-            BasicBlockLocation* basicBlockLocation = bytecode.metadata(codeBlock).basicBlockLocation;
+            BasicBlockLocation* basicBlockLocation = bytecode.metadata(codeBlock).m_basicBlockLocation;
             addToGraph(ProfileControlFlow, OpInfo(basicBlockLocation));
             NEXT_OPCODE(op_profile_control_flow);
         }
@@ -5617,7 +5617,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
         case op_jmp: {
             ASSERT(!m_currentBlock->terminal());
             auto bytecode = currentInstruction->as<OpJmp>();
-            int relativeOffset = jumpTarget(bytecode.target);
+            int relativeOffset = jumpTarget(bytecode.m_target);
             addToGraph(Jump, OpInfo(m_currentIndex + relativeOffset));
             if (relativeOffset <= 0)
                 flushForTerminal();
@@ -5626,24 +5626,24 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jtrue: {
             auto bytecode = currentInstruction->as<OpJtrue>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* condition = get(bytecode.condition);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* condition = get(bytecode.m_condition);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jtrue);
         }
 
         case op_jfalse: {
             auto bytecode = currentInstruction->as<OpJfalse>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* condition = get(bytecode.condition);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* condition = get(bytecode.m_condition);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jfalse);
         }
 
         case op_jeq_null: {
             auto bytecode = currentInstruction->as<OpJeqNull>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* value = get(bytecode.value);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* value = get(bytecode.m_value);
             Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
             Node* condition = addToGraph(CompareEq, value, nullConstant);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
@@ -5652,8 +5652,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jneq_null: {
             auto bytecode = currentInstruction->as<OpJneqNull>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* value = get(bytecode.value);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* value = get(bytecode.m_value);
             Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
             Node* condition = addToGraph(CompareEq, value, nullConstant);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
@@ -5662,9 +5662,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jless: {
             auto bytecode = currentInstruction->as<OpJless>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareLess, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jless);
@@ -5672,9 +5672,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jlesseq: {
             auto bytecode = currentInstruction->as<OpJlesseq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareLessEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jlesseq);
@@ -5682,9 +5682,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jgreater: {
             auto bytecode = currentInstruction->as<OpJgreater>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareGreater, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jgreater);
@@ -5692,9 +5692,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jgreatereq: {
             auto bytecode = currentInstruction->as<OpJgreatereq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareGreaterEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jgreatereq);
@@ -5702,9 +5702,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jeq: {
             auto bytecode = currentInstruction->as<OpJeq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jeq);
@@ -5712,9 +5712,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jstricteq: {
             auto bytecode = currentInstruction->as<OpJstricteq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareStrictEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jstricteq);
@@ -5722,9 +5722,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jnless: {
             auto bytecode = currentInstruction->as<OpJnless>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareLess, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jnless);
@@ -5732,9 +5732,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jnlesseq: {
             auto bytecode = currentInstruction->as<OpJnlesseq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareLessEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jnlesseq);
@@ -5742,9 +5742,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jngreater: {
             auto bytecode = currentInstruction->as<OpJngreater>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareGreater, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jngreater);
@@ -5752,9 +5752,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jngreatereq: {
             auto bytecode = currentInstruction->as<OpJngreatereq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareGreaterEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jngreatereq);
@@ -5762,9 +5762,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jneq: {
             auto bytecode = currentInstruction->as<OpJneq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jneq);
@@ -5772,9 +5772,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jnstricteq: {
             auto bytecode = currentInstruction->as<OpJnstricteq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareStrictEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
             LAST_OPCODE(op_jnstricteq);
@@ -5782,9 +5782,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jbelow: {
             auto bytecode = currentInstruction->as<OpJbelow>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareBelow, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jbelow);
@@ -5792,9 +5792,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_jbeloweq: {
             auto bytecode = currentInstruction->as<OpJbeloweq>();
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* op1 = get(bytecode.lhs);
-            Node* op2 = get(bytecode.rhs);
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* op1 = get(bytecode.m_lhs);
+            Node* op2 = get(bytecode.m_rhs);
             Node* condition = addToGraph(CompareBelowEq, op1, op2);
             addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
             LAST_OPCODE(op_jbeloweq);
@@ -5804,8 +5804,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpSwitchImm>();
             SwitchData& data = *m_graph.m_switchData.add();
             data.kind = SwitchImm;
-            data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.tableIndex];
-            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.defaultOffset));
+            data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.m_tableIndex];
+            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.m_defaultOffset));
             SimpleJumpTable& table = m_codeBlock->switchJumpTable(data.switchTableIndex);
             for (unsigned i = 0; i < table.branchOffsets.size(); ++i) {
                 if (!table.branchOffsets[i])
@@ -5815,7 +5815,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                     continue;
                 data.cases.append(SwitchCase::withBytecodeIndex(m_graph.freeze(jsNumber(static_cast<int32_t>(table.min + i))), target));
             }
-            addToGraph(Switch, OpInfo(&data), get(bytecode.scrutinee));
+            addToGraph(Switch, OpInfo(&data), get(bytecode.m_scrutinee));
             flushIfTerminal(data);
             LAST_OPCODE(op_switch_imm);
         }
@@ -5824,8 +5824,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpSwitchChar>();
             SwitchData& data = *m_graph.m_switchData.add();
             data.kind = SwitchChar;
-            data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.tableIndex];
-            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.defaultOffset));
+            data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.m_tableIndex];
+            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.m_defaultOffset));
             SimpleJumpTable& table = m_codeBlock->switchJumpTable(data.switchTableIndex);
             for (unsigned i = 0; i < table.branchOffsets.size(); ++i) {
                 if (!table.branchOffsets[i])
@@ -5836,7 +5836,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 data.cases.append(
                     SwitchCase::withBytecodeIndex(LazyJSValue::singleCharacterString(table.min + i), target));
             }
-            addToGraph(Switch, OpInfo(&data), get(bytecode.scrutinee));
+            addToGraph(Switch, OpInfo(&data), get(bytecode.m_scrutinee));
             flushIfTerminal(data);
             LAST_OPCODE(op_switch_char);
         }
@@ -5845,8 +5845,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpSwitchString>();
             SwitchData& data = *m_graph.m_switchData.add();
             data.kind = SwitchString;
-            data.switchTableIndex = bytecode.tableIndex;
-            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.defaultOffset));
+            data.switchTableIndex = bytecode.m_tableIndex;
+            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.m_defaultOffset));
             StringJumpTable& table = m_codeBlock->stringSwitchJumpTable(data.switchTableIndex);
             StringJumpTable::StringOffsetTable::iterator iter;
             StringJumpTable::StringOffsetTable::iterator end = table.offsetTable.end();
@@ -5857,7 +5857,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 data.cases.append(
                     SwitchCase::withBytecodeIndex(LazyJSValue::knownStringImpl(iter->key.get()), target));
             }
-            addToGraph(Switch, OpInfo(&data), get(bytecode.scrutinee));
+            addToGraph(Switch, OpInfo(&data), get(bytecode.m_scrutinee));
             flushIfTerminal(data);
             LAST_OPCODE(op_switch_string);
         }
@@ -5867,14 +5867,14 @@ void ByteCodeParser::parseBlock(unsigned limit)
             ASSERT(!m_currentBlock->terminal());
             if (!inlineCallFrame()) {
                 // Simple case: we are just producing a return
-                addToGraph(Return, get(bytecode.value));
+                addToGraph(Return, get(bytecode.m_value));
                 flushForReturn();
                 LAST_OPCODE(op_ret);
             }
 
             flushForReturn();
             if (m_inlineStackTop->m_returnValue.isValid())
-                setDirect(m_inlineStackTop->m_returnValue, get(bytecode.value), ImmediateSetWithFlush);
+                setDirect(m_inlineStackTop->m_returnValue, get(bytecode.m_value), ImmediateSetWithFlush);
 
             if (!m_inlineStackTop->m_continuationBlock && m_currentIndex + currentInstruction->size() != m_inlineStackTop->m_codeBlock->instructions().size()) {
                 // This is an early return from an inlined function and we do not have a continuation block, so we must allocate one.
@@ -5893,18 +5893,18 @@ void ByteCodeParser::parseBlock(unsigned limit)
         }
         case op_end:
             ASSERT(!inlineCallFrame());
-            addToGraph(Return, get(currentInstruction->as<OpEnd>().value));
+            addToGraph(Return, get(currentInstruction->as<OpEnd>().m_value));
             flushForReturn();
             LAST_OPCODE(op_end);
 
         case op_throw:
-            addToGraph(Throw, get(currentInstruction->as<OpThrow>().value));
+            addToGraph(Throw, get(currentInstruction->as<OpThrow>().m_value));
             flushForTerminal();
             LAST_OPCODE(op_throw);
             
         case op_throw_static_error: {
             auto bytecode = currentInstruction->as<OpThrowStaticError>();
-            addToGraph(ThrowStaticError, OpInfo(bytecode.errorType), get(bytecode.message));
+            addToGraph(ThrowStaticError, OpInfo(bytecode.m_errorType), get(bytecode.m_message));
             flushForTerminal();
             LAST_OPCODE(op_throw_static_error);
         }
@@ -5924,7 +5924,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
             RELEASE_ASSERT(!m_currentBlock->size() || (m_graph.compilation() && m_currentBlock->size() == 1 && m_currentBlock->at(0)->op() == CountExecution));
 
-            ValueProfileAndOperandBuffer* buffer = bytecode.metadata(codeBlock).buffer;
+            ValueProfileAndOperandBuffer* buffer = bytecode.metadata(codeBlock).m_buffer;
 
             if (!buffer) {
                 NEXT_OPCODE(op_catch); // This catch has yet to execute. Note: this load can be racy with the main thread.
@@ -6097,21 +6097,21 @@ void ByteCodeParser::parseBlock(unsigned limit)
             
         case op_call_eval: {
             auto bytecode = currentInstruction->as<OpCallEval>();
-            int registerOffset = -bytecode.argv;
-            addCall(bytecode.dst, CallEval, nullptr, get(bytecode.callee), bytecode.argc, registerOffset, getPrediction());
+            int registerOffset = -bytecode.m_argv;
+            addCall(bytecode.m_dst, CallEval, nullptr, get(bytecode.m_callee), bytecode.m_argc, registerOffset, getPrediction());
             NEXT_OPCODE(op_call_eval);
         }
             
         case op_jneq_ptr: {
             auto bytecode = currentInstruction->as<OpJneqPtr>();
-            Special::Pointer specialPointer = bytecode.specialPointer;
+            Special::Pointer specialPointer = bytecode.m_specialPointer;
             ASSERT(pointerIsCell(specialPointer));
             JSCell* actualPointer = static_cast<JSCell*>(
                 actualPointerFor(m_inlineStackTop->m_codeBlock, specialPointer));
             FrozenValue* frozenPointer = m_graph.freeze(actualPointer);
-            unsigned relativeOffset = jumpTarget(bytecode.target);
-            Node* child = get(bytecode.value);
-            if (bytecode.metadata(codeBlock).hasJumped) {
+            unsigned relativeOffset = jumpTarget(bytecode.m_target);
+            Node* child = get(bytecode.m_value);
+            if (bytecode.metadata(codeBlock).m_hasJumped) {
                 Node* condition = addToGraph(CompareEqPtr, OpInfo(frozenPointer), child);
                 addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
                 LAST_OPCODE(op_jneq_ptr);
@@ -6131,8 +6131,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             SymbolTable* symbolTable = nullptr;
             {
                 ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
-                resolveType = metadata.resolveType;
-                depth = metadata.localScopeDepth;
+                resolveType = metadata.m_resolveType;
+                depth = metadata.m_localScopeDepth;
                 switch (resolveType) {
                 case GlobalProperty:
                 case GlobalVar:
@@ -6140,15 +6140,15 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 case GlobalVarWithVarInjectionChecks:
                 case GlobalLexicalVar:
                 case GlobalLexicalVarWithVarInjectionChecks:
-                    constantScope = metadata.constantScope.get();
+                    constantScope = metadata.m_constantScope.get();
                     break;
                 case ModuleVar:
-                    lexicalEnvironment = metadata.lexicalEnvironment.get();
+                    lexicalEnvironment = metadata.m_lexicalEnvironment.get();
                     break;
                 case LocalClosureVar:
                 case ClosureVar:
                 case ClosureVarWithVarInjectionChecks:
-                    symbolTable = metadata.symbolTable.get();
+                    symbolTable = metadata.m_symbolTable.get();
                     break;
                 default:
                     break;
@@ -6156,8 +6156,8 @@ void ByteCodeParser::parseBlock(unsigned limit)
             }
 
             if (needsDynamicLookup(resolveType, op_resolve_scope)) {
-                unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.var];
-                set(bytecode.dst, addToGraph(ResolveScope, OpInfo(identifierNumber), get(bytecode.scope)));
+                unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_var];
+                set(bytecode.m_dst, addToGraph(ResolveScope, OpInfo(identifierNumber), get(bytecode.m_scope)));
                 NEXT_OPCODE(op_resolve_scope);
             }
 
@@ -6169,7 +6169,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
             // https://bugs.webkit.org/show_bug.cgi?id=193347
             if (m_inlineStackTop->m_codeBlock->scriptMode() != JSParserScriptMode::Module) {
                 if (resolveType == GlobalProperty || resolveType == GlobalPropertyWithVarInjectionChecks) {
-                    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.var];
+                    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_var];
                     JSGlobalObject* globalObject = m_inlineStackTop->m_codeBlock->globalObject();
                     m_graph.globalProperties().addLazily(DesiredGlobalProperty(globalObject, identifierNumber));
                 }
@@ -6184,21 +6184,21 @@ void ByteCodeParser::parseBlock(unsigned limit)
             case GlobalLexicalVarWithVarInjectionChecks: {
                 RELEASE_ASSERT(constantScope);
                 RELEASE_ASSERT(constantScope == JSScope::constantScopeForCodeBlock(resolveType, m_inlineStackTop->m_codeBlock));
-                set(bytecode.dst, weakJSConstant(constantScope));
-                addToGraph(Phantom, get(bytecode.scope));
+                set(bytecode.m_dst, weakJSConstant(constantScope));
+                addToGraph(Phantom, get(bytecode.m_scope));
                 break;
             }
             case ModuleVar: {
                 // Since the value of the "scope" virtual register is not used in LLInt / baseline op_resolve_scope with ModuleVar,
                 // we need not to keep it alive by the Phantom node.
                 // Module environment is already strongly referenced by the CodeBlock.
-                set(bytecode.dst, weakJSConstant(lexicalEnvironment));
+                set(bytecode.m_dst, weakJSConstant(lexicalEnvironment));
                 break;
             }
             case LocalClosureVar:
             case ClosureVar:
             case ClosureVarWithVarInjectionChecks: {
-                Node* localBase = get(bytecode.scope);
+                Node* localBase = get(bytecode.m_scope);
                 addToGraph(Phantom, localBase); // OSR exit cannot handle resolve_scope on a DCE'd scope.
                 
                 // We have various forms of constant folding here. This is necessary to avoid
@@ -6207,26 +6207,26 @@ void ByteCodeParser::parseBlock(unsigned limit)
                     InferredValue* singleton = symbolTable->singletonScope();
                     if (JSValue value = singleton->inferredValue()) {
                         m_graph.watchpoints().addLazily(singleton);
-                        set(bytecode.dst, weakJSConstant(value));
+                        set(bytecode.m_dst, weakJSConstant(value));
                         break;
                     }
                 }
                 if (JSScope* scope = localBase->dynamicCastConstant<JSScope*>(*m_vm)) {
                     for (unsigned n = depth; n--;)
                         scope = scope->next();
-                    set(bytecode.dst, weakJSConstant(scope));
+                    set(bytecode.m_dst, weakJSConstant(scope));
                     break;
                 }
                 for (unsigned n = depth; n--;)
                     localBase = addToGraph(SkipScope, localBase);
-                set(bytecode.dst, localBase);
+                set(bytecode.m_dst, localBase);
                 break;
             }
             case UnresolvedProperty:
             case UnresolvedPropertyWithVarInjectionChecks: {
-                addToGraph(Phantom, get(bytecode.scope));
+                addToGraph(Phantom, get(bytecode.m_scope));
                 addToGraph(ForceOSRExit);
-                set(bytecode.dst, addToGraph(JSConstant, OpInfo(m_constantNull)));
+                set(bytecode.m_dst, addToGraph(JSConstant, OpInfo(m_constantNull)));
                 break;
             }
             case Dynamic:
@@ -6237,9 +6237,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
         }
         case op_resolve_scope_for_hoisting_func_decl_in_eval: {
             auto bytecode = currentInstruction->as<OpResolveScopeForHoistingFuncDeclInEval>();
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
 
-            set(bytecode.dst, addToGraph(ResolveScopeForHoistingFuncDeclInEval, OpInfo(identifierNumber), get(bytecode.scope)));
+            set(bytecode.m_dst, addToGraph(ResolveScopeForHoistingFuncDeclInEval, OpInfo(identifierNumber), get(bytecode.m_scope)));
 
             NEXT_OPCODE(op_resolve_scope_for_hoisting_func_decl_in_eval);
         }
@@ -6247,7 +6247,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
         case op_get_from_scope: {
             auto bytecode = currentInstruction->as<OpGetFromScope>();
             auto& metadata = bytecode.metadata(codeBlock);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.var];
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_var];
             UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
 
             ResolveType resolveType;
@@ -6257,20 +6257,20 @@ void ByteCodeParser::parseBlock(unsigned limit)
             uintptr_t operand;
             {
                 ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
-                getPutInfo = metadata.getPutInfo;
+                getPutInfo = metadata.m_getPutInfo;
                 resolveType = getPutInfo.resolveType();
                 if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks || resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
-                    watchpoints = metadata.watchpointSet;
+                    watchpoints = metadata.m_watchpointSet;
                 else if (resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
-                    structure = metadata.structure.get();
-                operand = metadata.operand;
+                    structure = metadata.m_structure.get();
+                operand = metadata.m_operand;
             }
 
             if (needsDynamicLookup(resolveType, op_get_from_scope)) {
                 uint64_t opInfo1 = makeDynamicVarOpInfo(identifierNumber, getPutInfo.operand());
                 SpeculatedType prediction = getPrediction();
-                set(bytecode.dst,
-                    addToGraph(GetDynamicVar, OpInfo(opInfo1), OpInfo(prediction), get(bytecode.scope)));
+                set(bytecode.m_dst,
+                    addToGraph(GetDynamicVar, OpInfo(opInfo1), OpInfo(prediction), get(bytecode.m_scope)));
                 NEXT_OPCODE(op_get_from_scope);
             }
 
@@ -6292,21 +6292,21 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 if (status.state() != GetByIdStatus::Simple
                     || status.numVariants() != 1
                     || status[0].structureSet().size() != 1) {
-                    set(bytecode.dst, addToGraph(GetByIdFlush, OpInfo(identifierNumber), OpInfo(prediction), get(bytecode.scope)));
+                    set(bytecode.m_dst, addToGraph(GetByIdFlush, OpInfo(identifierNumber), OpInfo(prediction), get(bytecode.m_scope)));
                     break;
                 }
 
                 Node* base = weakJSConstant(globalObject);
                 Node* result = load(prediction, base, identifierNumber, status[0]);
-                addToGraph(Phantom, get(bytecode.scope));
-                set(bytecode.dst, result);
+                addToGraph(Phantom, get(bytecode.m_scope));
+                set(bytecode.m_dst, result);
                 break;
             }
             case GlobalVar:
             case GlobalVarWithVarInjectionChecks:
             case GlobalLexicalVar:
             case GlobalLexicalVarWithVarInjectionChecks: {
-                addToGraph(Phantom, get(bytecode.scope));
+                addToGraph(Phantom, get(bytecode.m_scope));
                 WatchpointSet* watchpointSet;
                 ScopeOffset offset;
                 JSSegmentedVariableObject* scopeObject = jsCast<JSSegmentedVariableObject*>(JSScope::constantScopeForCodeBlock(resolveType, m_inlineStackTop->m_codeBlock));
@@ -6362,7 +6362,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                     JSValue value = pointer->get();
                     if (value) {
                         m_graph.watchpoints().addLazily(watchpointSet);
-                        set(bytecode.dst, weakJSConstant(value));
+                        set(bytecode.m_dst, weakJSConstant(value));
                         break;
                     }
                 }
@@ -6376,13 +6376,13 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 Node* value = addToGraph(nodeType, OpInfo(operand), OpInfo(prediction));
                 if (resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
                     addToGraph(CheckNotEmpty, value);
-                set(bytecode.dst, value);
+                set(bytecode.m_dst, value);
                 break;
             }
             case LocalClosureVar:
             case ClosureVar:
             case ClosureVarWithVarInjectionChecks: {
-                Node* scopeNode = get(bytecode.scope);
+                Node* scopeNode = get(bytecode.m_scope);
                 
                 // Ideally we wouldn't have to do this Phantom. But:
                 //
@@ -6398,11 +6398,11 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 // prediction, we'd otherwise think that it has to exit. Then when it did execute, we
                 // would recompile. But if we can fold it here, we avoid the exit.
                 if (JSValue value = m_graph.tryGetConstantClosureVar(scopeNode, ScopeOffset(operand))) {
-                    set(bytecode.dst, weakJSConstant(value));
+                    set(bytecode.m_dst, weakJSConstant(value));
                     break;
                 }
                 SpeculatedType prediction = getPrediction();
-                set(bytecode.dst,
+                set(bytecode.m_dst,
                     addToGraph(GetClosureVar, OpInfo(operand), OpInfo(prediction), scopeNode));
                 break;
             }
@@ -6419,7 +6419,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
         case op_put_to_scope: {
             auto bytecode = currentInstruction->as<OpPutToScope>();
             auto& metadata = bytecode.metadata(codeBlock);
-            unsigned identifierNumber = bytecode.var;
+            unsigned identifierNumber = bytecode.m_var;
             if (identifierNumber != UINT_MAX)
                 identifierNumber = m_inlineStackTop->m_identifierRemap[identifierNumber];
             UniquedStringImpl* uid;
@@ -6435,13 +6435,13 @@ void ByteCodeParser::parseBlock(unsigned limit)
             uintptr_t operand;
             {
                 ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
-                getPutInfo = metadata.getPutInfo;
+                getPutInfo = metadata.m_getPutInfo;
                 resolveType = getPutInfo.resolveType();
                 if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks || resolveType == LocalClosureVar || resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
-                    watchpoints = metadata.watchpointSet;
+                    watchpoints = metadata.m_watchpointSet;
                 else if (resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
-                    structure = metadata.structure.get();
-                operand = metadata.operand;
+                    structure = metadata.m_structure.get();
+                operand = metadata.m_operand;
             }
 
             JSGlobalObject* globalObject = m_inlineStackTop->m_codeBlock->globalObject();
@@ -6449,7 +6449,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
             if (needsDynamicLookup(resolveType, op_put_to_scope)) {
                 ASSERT(identifierNumber != UINT_MAX);
                 uint64_t opInfo1 = makeDynamicVarOpInfo(identifierNumber, getPutInfo.operand());
-                addToGraph(PutDynamicVar, OpInfo(opInfo1), OpInfo(), get(bytecode.scope), get(bytecode.value));
+                addToGraph(PutDynamicVar, OpInfo(opInfo1), OpInfo(), get(bytecode.m_scope), get(bytecode.m_value));
                 NEXT_OPCODE(op_put_to_scope);
             }
 
@@ -6469,13 +6469,13 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 if (status.numVariants() != 1
                     || status[0].kind() != PutByIdVariant::Replace
                     || status[0].structure().size() != 1) {
-                    addToGraph(PutById, OpInfo(identifierNumber), get(bytecode.scope), get(bytecode.value));
+                    addToGraph(PutById, OpInfo(identifierNumber), get(bytecode.m_scope), get(bytecode.m_value));
                     break;
                 }
                 Node* base = weakJSConstant(globalObject);
-                store(base, identifierNumber, status[0], get(bytecode.value));
+                store(base, identifierNumber, status[0], get(bytecode.m_value));
                 // Keep scope alive until after put.
-                addToGraph(Phantom, get(bytecode.scope));
+                addToGraph(Phantom, get(bytecode.m_scope));
                 break;
             }
             case GlobalLexicalVar:
@@ -6493,21 +6493,21 @@ void ByteCodeParser::parseBlock(unsigned limit)
                     SymbolTableEntry entry = scopeObject->symbolTable()->get(uid);
                     ASSERT_UNUSED(entry, watchpoints == entry.watchpointSet());
                 }
-                Node* valueNode = get(bytecode.value);
+                Node* valueNode = get(bytecode.m_value);
                 addToGraph(PutGlobalVariable, OpInfo(operand), weakJSConstant(scopeObject), valueNode);
                 if (watchpoints && watchpoints->state() != IsInvalidated) {
                     // Must happen after the store. See comment for GetGlobalVar.
                     addToGraph(NotifyWrite, OpInfo(watchpoints));
                 }
                 // Keep scope alive until after put.
-                addToGraph(Phantom, get(bytecode.scope));
+                addToGraph(Phantom, get(bytecode.m_scope));
                 break;
             }
             case LocalClosureVar:
             case ClosureVar:
             case ClosureVarWithVarInjectionChecks: {
-                Node* scopeNode = get(bytecode.scope);
-                Node* valueNode = get(bytecode.value);
+                Node* scopeNode = get(bytecode.m_scope);
+                Node* valueNode = get(bytecode.m_value);
 
                 addToGraph(PutClosureVar, OpInfo(operand), scopeNode, valueNode);
 
@@ -6571,28 +6571,28 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_create_lexical_environment: {
             auto bytecode = currentInstruction->as<OpCreateLexicalEnvironment>();
-            ASSERT(bytecode.symbolTable.isConstant() && bytecode.initialValue.isConstant());
-            FrozenValue* symbolTable = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.symbolTable.offset()));
-            FrozenValue* initialValue = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.initialValue.offset()));
-            Node* scope = get(bytecode.scope);
+            ASSERT(bytecode.m_symbolTable.isConstant() && bytecode.m_initialValue.isConstant());
+            FrozenValue* symbolTable = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.m_symbolTable.offset()));
+            FrozenValue* initialValue = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.m_initialValue.offset()));
+            Node* scope = get(bytecode.m_scope);
             Node* lexicalEnvironment = addToGraph(CreateActivation, OpInfo(symbolTable), OpInfo(initialValue), scope);
-            set(bytecode.dst, lexicalEnvironment);
+            set(bytecode.m_dst, lexicalEnvironment);
             NEXT_OPCODE(op_create_lexical_environment);
         }
 
         case op_push_with_scope: {
             auto bytecode = currentInstruction->as<OpPushWithScope>();
-            Node* currentScope = get(bytecode.currentScope);
-            Node* object = get(bytecode.newScope);
-            set(bytecode.dst, addToGraph(PushWithScope, currentScope, object));
+            Node* currentScope = get(bytecode.m_currentScope);
+            Node* object = get(bytecode.m_newScope);
+            set(bytecode.m_dst, addToGraph(PushWithScope, currentScope, object));
             NEXT_OPCODE(op_push_with_scope);
         }
 
         case op_get_parent_scope: {
             auto bytecode = currentInstruction->as<OpGetParentScope>();
-            Node* currentScope = get(bytecode.scope);
+            Node* currentScope = get(bytecode.m_scope);
             Node* newScope = addToGraph(SkipScope, currentScope);
-            set(bytecode.dst, newScope);
+            set(bytecode.m_dst, newScope);
             addToGraph(Phantom, currentScope);
             NEXT_OPCODE(op_get_parent_scope);
         }
@@ -6609,14 +6609,14 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 result = weakJSConstant(function->scope());
             else
                 result = addToGraph(GetScope, callee);
-            set(bytecode.dst, result);
+            set(bytecode.m_dst, result);
             NEXT_OPCODE(op_get_scope);
         }
 
         case op_argument_count: {
             auto bytecode = currentInstruction->as<OpArgumentCount>();
             Node* sub = addToGraph(ArithSub, OpInfo(Arith::Unchecked), OpInfo(SpecInt32Only), getArgumentCount(), addToGraph(JSConstant, OpInfo(m_constantOne)));
-            set(bytecode.dst, sub);
+            set(bytecode.m_dst, sub);
             NEXT_OPCODE(op_argument_count);
         }
 
@@ -6624,15 +6624,15 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpCreateDirectArguments>();
             noticeArgumentsUse();
             Node* createArguments = addToGraph(CreateDirectArguments);
-            set(bytecode.dst, createArguments);
+            set(bytecode.m_dst, createArguments);
             NEXT_OPCODE(op_create_direct_arguments);
         }
             
         case op_create_scoped_arguments: {
             auto bytecode = currentInstruction->as<OpCreateScopedArguments>();
             noticeArgumentsUse();
-            Node* createArguments = addToGraph(CreateScopedArguments, get(bytecode.scope));
-            set(bytecode.dst, createArguments);
+            Node* createArguments = addToGraph(CreateScopedArguments, get(bytecode.m_scope));
+            set(bytecode.m_dst, createArguments);
             NEXT_OPCODE(op_create_scoped_arguments);
         }
 
@@ -6640,18 +6640,18 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpCreateClonedArguments>();
             noticeArgumentsUse();
             Node* createArguments = addToGraph(CreateClonedArguments);
-            set(bytecode.dst, createArguments);
+            set(bytecode.m_dst, createArguments);
             NEXT_OPCODE(op_create_cloned_arguments);
         }
             
         case op_get_from_arguments: {
             auto bytecode = currentInstruction->as<OpGetFromArguments>();
-            set(bytecode.dst,
+            set(bytecode.m_dst,
                 addToGraph(
                     GetFromArguments,
-                    OpInfo(bytecode.index),
+                    OpInfo(bytecode.m_index),
                     OpInfo(getPrediction()),
-                    get(bytecode.arguments)));
+                    get(bytecode.m_arguments)));
             NEXT_OPCODE(op_get_from_arguments);
         }
             
@@ -6659,9 +6659,9 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpPutToArguments>();
             addToGraph(
                 PutToArguments,
-                OpInfo(bytecode.index),
-                get(bytecode.arguments),
-                get(bytecode.value));
+                OpInfo(bytecode.m_index),
+                get(bytecode.m_arguments),
+                get(bytecode.m_value));
             NEXT_OPCODE(op_put_to_arguments);
         }
 
@@ -6669,7 +6669,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpGetArgument>();
             InlineCallFrame* inlineCallFrame = this->inlineCallFrame();
             Node* argument;
-            int32_t argumentIndexIncludingThis = bytecode.index;
+            int32_t argumentIndexIncludingThis = bytecode.m_index;
             if (inlineCallFrame && !inlineCallFrame->isVarargs()) {
                 int32_t argumentCountIncludingThisWithFixup = inlineCallFrame->argumentsWithFixup.size();
                 if (argumentIndexIncludingThis < argumentCountIncludingThisWithFixup)
@@ -6678,7 +6678,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                     argument = addToGraph(JSConstant, OpInfo(m_constantUndefined));
             } else
                 argument = addToGraph(GetArgument, OpInfo(argumentIndexIncludingThis), OpInfo(getPrediction()));
-            set(bytecode.dst, argument);
+            set(bytecode.m_dst, argument);
             NEXT_OPCODE(op_get_argument);
         }
         case op_new_async_generator_func:
@@ -6709,53 +6709,53 @@ void ByteCodeParser::parseBlock(unsigned limit)
 
         case op_set_function_name: {
             auto bytecode = currentInstruction->as<OpSetFunctionName>();
-            Node* func = get(bytecode.function);
-            Node* name = get(bytecode.name);
+            Node* func = get(bytecode.m_function);
+            Node* name = get(bytecode.m_name);
             addToGraph(SetFunctionName, func, name);
             NEXT_OPCODE(op_set_function_name);
         }
 
         case op_typeof: {
             auto bytecode = currentInstruction->as<OpTypeof>();
-            set(bytecode.dst, addToGraph(TypeOf, get(bytecode.value)));
+            set(bytecode.m_dst, addToGraph(TypeOf, get(bytecode.m_value)));
             NEXT_OPCODE(op_typeof);
         }
 
         case op_to_number: {
             auto bytecode = currentInstruction->as<OpToNumber>();
             SpeculatedType prediction = getPrediction();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(ToNumber, OpInfo(0), OpInfo(prediction), value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(ToNumber, OpInfo(0), OpInfo(prediction), value));
             NEXT_OPCODE(op_to_number);
         }
 
         case op_to_string: {
             auto bytecode = currentInstruction->as<OpToString>();
-            Node* value = get(bytecode.operand);
-            set(bytecode.dst, addToGraph(ToString, value));
+            Node* value = get(bytecode.m_operand);
+            set(bytecode.m_dst, addToGraph(ToString, value));
             NEXT_OPCODE(op_to_string);
         }
 
         case op_to_object: {
             auto bytecode = currentInstruction->as<OpToObject>();
             SpeculatedType prediction = getPrediction();
-            Node* value = get(bytecode.operand);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.message];
-            set(bytecode.dst, addToGraph(ToObject, OpInfo(identifierNumber), OpInfo(prediction), value));
+            Node* value = get(bytecode.m_operand);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_message];
+            set(bytecode.m_dst, addToGraph(ToObject, OpInfo(identifierNumber), OpInfo(prediction), value));
             NEXT_OPCODE(op_to_object);
         }
 
         case op_in_by_val: {
             auto bytecode = currentInstruction->as<OpInByVal>();
-            ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).arrayProfile, Array::Read);
-            set(bytecode.dst, addToGraph(InByVal, OpInfo(arrayMode.asWord()), get(bytecode.base), get(bytecode.property)));
+            ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).m_arrayProfile, Array::Read);
+            set(bytecode.m_dst, addToGraph(InByVal, OpInfo(arrayMode.asWord()), get(bytecode.m_base), get(bytecode.m_property)));
             NEXT_OPCODE(op_in_by_val);
         }
 
         case op_in_by_id: {
             auto bytecode = currentInstruction->as<OpInById>();
-            Node* base = get(bytecode.base);
-            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
+            Node* base = get(bytecode.m_base);
+            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
             UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
 
             InByIdStatus status = InByIdStatus::computeFor(
@@ -6784,43 +6784,43 @@ void ByteCodeParser::parseBlock(unsigned limit)
                     addToGraph(FilterInByIdStatus, OpInfo(m_graph.m_plan.recordedStatuses().addInByIdStatus(currentCodeOrigin(), status)), base);
 
                     Node* match = addToGraph(MatchStructure, OpInfo(data), base);
-                    set(bytecode.dst, match);
+                    set(bytecode.m_dst, match);
                     NEXT_OPCODE(op_in_by_id);
                 }
             }
 
-            set(bytecode.dst, addToGraph(InById, OpInfo(identifierNumber), base));
+            set(bytecode.m_dst, addToGraph(InById, OpInfo(identifierNumber), base));
             NEXT_OPCODE(op_in_by_id);
         }
 
         case op_get_enumerable_length: {
             auto bytecode = currentInstruction->as<OpGetEnumerableLength>();
-            set(bytecode.dst, addToGraph(GetEnumerableLength, get(bytecode.base)));
+            set(bytecode.m_dst, addToGraph(GetEnumerableLength, get(bytecode.m_base)));
             NEXT_OPCODE(op_get_enumerable_length);
         }
 
         case op_has_generic_property: {
             auto bytecode = currentInstruction->as<OpHasGenericProperty>();
-            set(bytecode.dst, addToGraph(HasGenericProperty, get(bytecode.base), get(bytecode.property)));
+            set(bytecode.m_dst, addToGraph(HasGenericProperty, get(bytecode.m_base), get(bytecode.m_property)));
             NEXT_OPCODE(op_has_generic_property);
         }
 
         case op_has_structure_property: {
             auto bytecode = currentInstruction->as<OpHasStructureProperty>();
-            set(bytecode.dst, addToGraph(HasStructureProperty, 
-                get(bytecode.base),
-                get(bytecode.property),
-                get(bytecode.enumerator)));
+            set(bytecode.m_dst, addToGraph(HasStructureProperty,
+                get(bytecode.m_base),
+                get(bytecode.m_property),
+                get(bytecode.m_enumerator)));
             NEXT_OPCODE(op_has_structure_property);
         }
 
         case op_has_indexed_property: {
             auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
-            Node* base = get(bytecode.base);
-            ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).arrayProfile, Array::Read);
-            Node* property = get(bytecode.property);
+            Node* base = get(bytecode.m_base);
+            ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).m_arrayProfile, Array::Read);
+            Node* property = get(bytecode.m_property);
             Node* hasIterableProperty = addToGraph(HasIndexedProperty, OpInfo(arrayMode.asWord()), OpInfo(static_cast<uint32_t>(PropertySlot::InternalMethodType::GetOwnProperty)), base, property);
-            set(bytecode.dst, hasIterableProperty);
+            set(bytecode.m_dst, hasIterableProperty);
             NEXT_OPCODE(op_has_indexed_property);
         }
 
@@ -6828,52 +6828,52 @@ void ByteCodeParser::parseBlock(unsigned limit)
             auto bytecode = currentInstruction->as<OpGetDirectPname>();
             SpeculatedType prediction = getPredictionWithoutOSRExit();
             
-            Node* base = get(bytecode.base);
-            Node* property = get(bytecode.property);
-            Node* index = get(bytecode.index);
-            Node* enumerator = get(bytecode.enumerator);
+            Node* base = get(bytecode.m_base);
+            Node* property = get(bytecode.m_property);
+            Node* index = get(bytecode.m_index);
+            Node* enumerator = get(bytecode.m_enumerator);
 
             addVarArgChild(base);
             addVarArgChild(property);
             addVarArgChild(index);
             addVarArgChild(enumerator);
-            set(bytecode.dst, addToGraph(Node::VarArg, GetDirectPname, OpInfo(0), OpInfo(prediction)));
+            set(bytecode.m_dst, addToGraph(Node::VarArg, GetDirectPname, OpInfo(0), OpInfo(prediction)));
 
             NEXT_OPCODE(op_get_direct_pname);
         }
 
         case op_get_property_enumerator: {
             auto bytecode = currentInstruction->as<OpGetPropertyEnumerator>();
-            set(bytecode.dst, addToGraph(GetPropertyEnumerator, get(bytecode.base)));
+            set(bytecode.m_dst, addToGraph(GetPropertyEnumerator, get(bytecode.m_base)));
             NEXT_OPCODE(op_get_property_enumerator);
         }
 
         case op_enumerator_structure_pname: {
             auto bytecode = currentInstruction->as<OpEnumeratorStructurePname>();
-            set(bytecode.dst, addToGraph(GetEnumeratorStructurePname,
-                get(bytecode.enumerator),
-                get(bytecode.index)));
+            set(bytecode.m_dst, addToGraph(GetEnumeratorStructurePname,
+                get(bytecode.m_enumerator),
+                get(bytecode.m_index)));
             NEXT_OPCODE(op_enumerator_structure_pname);
         }
 
         case op_enumerator_generic_pname: {
             auto bytecode = currentInstruction->as<OpEnumeratorGenericPname>();
-            set(bytecode.dst, addToGraph(GetEnumeratorGenericPname,
-                get(bytecode.enumerator),
-                get(bytecode.index)));
+            set(bytecode.m_dst, addToGraph(GetEnumeratorGenericPname,
+                get(bytecode.m_enumerator),
+                get(bytecode.m_index)));
             NEXT_OPCODE(op_enumerator_generic_pname);
         }
             
         case op_to_index_string: {
             auto bytecode = currentInstruction->as<OpToIndexString>();
-            set(bytecode.dst, addToGraph(ToIndexString, get(bytecode.index)));
+            set(bytecode.m_dst, addToGraph(ToIndexString, get(bytecode.m_index)));
             NEXT_OPCODE(op_to_index_string);
         }
             
         case op_log_shadow_chicken_prologue: {
             auto bytecode = currentInstruction->as<OpLogShadowChickenPrologue>();
             if (!m_inlineStackTop->m_inlineCallFrame)
-                addToGraph(LogShadowChickenPrologue, get(bytecode.scope));
+                addToGraph(LogShadowChickenPrologue, get(bytecode.m_scope));
             NEXT_OPCODE(op_log_shadow_chicken_prologue);
         }
 
@@ -6883,7 +6883,7 @@ void ByteCodeParser::parseBlock(unsigned limit)
                 // FIXME: The right solution for inlining is to elide these whenever the tail call
                 // ends up being inlined.
                 // https://bugs.webkit.org/show_bug.cgi?id=155686
-                addToGraph(LogShadowChickenTail, get(bytecode.thisValue), get(bytecode.scope));
+                addToGraph(LogShadowChickenTail, get(bytecode.m_thisValue), get(bytecode.m_scope));
             }
             NEXT_OPCODE(op_log_shadow_chicken_tail);
         }
@@ -7147,9 +7147,9 @@ void ByteCodeParser::parseCodeBlock()
 template <typename Bytecode>
 void ByteCodeParser::handlePutByVal(Bytecode bytecode, unsigned instructionSize)
 {
-    Node* base = get(bytecode.base);
-    Node* property = get(bytecode.property);
-    Node* value = get(bytecode.value);
+    Node* base = get(bytecode.m_base);
+    Node* property = get(bytecode.m_property);
+    Node* value = get(bytecode.m_value);
     bool isDirect = Bytecode::opcodeID == op_put_by_val_direct;
     bool compiledAsPutById = false;
     {
@@ -7190,7 +7190,7 @@ void ByteCodeParser::handlePutByVal(Bytecode bytecode, unsigned instructionSize)
     }
 
     if (!compiledAsPutById) {
-        ArrayMode arrayMode = getArrayMode(bytecode.metadata(m_inlineStackTop->m_codeBlock).arrayProfile, Array::Write);
+        ArrayMode arrayMode = getArrayMode(bytecode.metadata(m_inlineStackTop->m_codeBlock).m_arrayProfile, Array::Write);
 
         addVarArgChild(base);
         addVarArgChild(property);
@@ -7204,28 +7204,28 @@ void ByteCodeParser::handlePutByVal(Bytecode bytecode, unsigned instructionSize)
 template <typename Bytecode>
 void ByteCodeParser::handlePutAccessorById(NodeType op, Bytecode bytecode)
 {
-    Node* base = get(bytecode.base);
-    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
-    Node* accessor = get(bytecode.accessor);
-    addToGraph(op, OpInfo(identifierNumber), OpInfo(bytecode.attributes), base, accessor);
+    Node* base = get(bytecode.m_base);
+    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
+    Node* accessor = get(bytecode.m_accessor);
+    addToGraph(op, OpInfo(identifierNumber), OpInfo(bytecode.m_attributes), base, accessor);
 }
 
 template <typename Bytecode>
 void ByteCodeParser::handlePutAccessorByVal(NodeType op, Bytecode bytecode)
 {
-    Node* base = get(bytecode.base);
-    Node* subscript = get(bytecode.property);
-    Node* accessor = get(bytecode.accessor);
-    addToGraph(op, OpInfo(bytecode.attributes), base, subscript, accessor);
+    Node* base = get(bytecode.m_base);
+    Node* subscript = get(bytecode.m_property);
+    Node* accessor = get(bytecode.m_accessor);
+    addToGraph(op, OpInfo(bytecode.m_attributes), base, subscript, accessor);
 }
 
 template <typename Bytecode>
 void ByteCodeParser::handleNewFunc(NodeType op, Bytecode bytecode)
 {
-    FunctionExecutable* decl = m_inlineStackTop->m_profiledBlock->functionDecl(bytecode.functionDecl);
+    FunctionExecutable* decl = m_inlineStackTop->m_profiledBlock->functionDecl(bytecode.m_functionDecl);
     FrozenValue* frozen = m_graph.freezeStrong(decl);
-    Node* scope = get(bytecode.scope);
-    set(bytecode.dst, addToGraph(op, OpInfo(frozen), scope));
+    Node* scope = get(bytecode.m_scope);
+    set(bytecode.m_dst, addToGraph(op, OpInfo(frozen), scope));
     // Ideally we wouldn't have to do this Phantom. But:
     //
     // For the constant case: we must do it because otherwise we would have no way of knowing
@@ -7239,10 +7239,10 @@ void ByteCodeParser::handleNewFunc(NodeType op, Bytecode bytecode)
 template <typename Bytecode>
 void ByteCodeParser::handleNewFuncExp(NodeType op, Bytecode bytecode)
 {
-    FunctionExecutable* expr = m_inlineStackTop->m_profiledBlock->functionExpr(bytecode.functionDecl);
+    FunctionExecutable* expr = m_inlineStackTop->m_profiledBlock->functionExpr(bytecode.m_functionDecl);
     FrozenValue* frozen = m_graph.freezeStrong(expr);
-    Node* scope = get(bytecode.scope);
-    set(bytecode.dst, addToGraph(op, OpInfo(frozen), scope));
+    Node* scope = get(bytecode.m_scope);
+    set(bytecode.m_dst, addToGraph(op, OpInfo(frozen), scope));
     // Ideally we wouldn't have to do this Phantom. But:
     //
     // For the constant case: we must do it because otherwise we would have no way of knowing
index 845b9ec..1fffb70 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -392,7 +392,7 @@ MacroAssemblerCodePtr<ExceptionHandlerPtrTag> prepareCatchOSREntry(ExecState* ex
 
     auto instruction = exec->codeBlock()->instructions().at(exec->bytecodeOffset());
     ASSERT(instruction->is<OpCatch>());
-    ValueProfileAndOperandBuffer* buffer = instruction->as<OpCatch>().metadata(exec).buffer;
+    ValueProfileAndOperandBuffer* buffer = instruction->as<OpCatch>().metadata(exec).m_buffer;
     JSValue* dataBuffer = reinterpret_cast<JSValue*>(dfgCommon->catchOSREntryBuffer->dataBuffer());
     unsigned index = 0;
     buffer->forEach([&] (ValueProfileAndOperand& profile) {
index b1d4f89..31d36e6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2014-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -477,7 +477,7 @@ extern "C" JSCell* JIT_OPERATION operationMaterializeObjectInOSR(
         const Instruction* currentInstruction = codeBlock->instructions().at(materialization->origin().bytecodeIndex).ptr();
         RELEASE_ASSERT(currentInstruction->is<OpNewArrayBuffer>());
         auto newArrayBuffer = currentInstruction->as<OpNewArrayBuffer>();
-        ArrayAllocationProfile* profile = &newArrayBuffer.metadata(codeBlock).arrayAllocationProfile;
+        ArrayAllocationProfile* profile = &newArrayBuffer.metadata(codeBlock).m_arrayAllocationProfile;
 
         // FIXME: Share the code with CommonSlowPaths. Currently, codeBlock etc. are slightly different.
         IndexingType indexingMode = profile->selectIndexingType();
@@ -495,7 +495,7 @@ extern "C" JSCell* JIT_OPERATION operationMaterializeObjectInOSR(
             // We also cannot allocate a new butterfly from compilation threads since it's invalid to allocate cells from
             // a compilation thread.
             WTF::storeStoreFence();
-            codeBlock->constantRegister(newArrayBuffer.immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
+            codeBlock->constantRegister(newArrayBuffer.m_immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
             WTF::storeStoreFence();
         }
 
index b7a2733..99dcb93 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 Apple Inc. All rights reserved.
+# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -35,13 +35,17 @@ class Argument
     end
 
     def field
-        "#{@type.to_s} #{@name};"
+        "#{@type.to_s} #{field_name};"
     end
 
     def create_param
         "#{@type.to_s} #{@name}"
     end
 
+    def field_name
+        "m_#{@name}"
+    end
+
     def fits_check(size)
         Fits::check size, @name, @type
     end
@@ -55,7 +59,7 @@ class Argument
     end
 
     def load_from_stream(index, size)
-        "#{@name}(#{Fits::convert(size, "stream[#{index}]", @type)})"
+        "#{field_name}(#{Fits::convert(size, "stream[#{index}]", @type)})"
     end
 
     def setter
index 331da03..ad5efa5 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 Apple Inc. All rights reserved.
+# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -47,7 +47,7 @@ class Metadata
                 if type.kind_of? Hash
                     "#{prefix}union {\n#{convertFields(prefix + '    ', type)}\n#{prefix}};"
                 else
-                    "#{prefix}#{type.to_s} #{field.to_s};"
+                    "#{prefix}#{type.to_s} m_#{field.to_s};"
                 end
             end.join("\n")
         end
@@ -57,7 +57,7 @@ class Metadata
         inits = nil
         if @initializers && (not @initializers.empty?)
             inits = "\n            : " + @initializers.map do |metadata, arg|
-                "#{metadata}(__op.#{arg})"
+                "m_#{metadata}(__op.m_#{arg})"
             end.join("\n            , ").concat("\n       ");
         end
 
@@ -121,6 +121,6 @@ EOF
     end
 
     def self.field_name
-        "metadataID"
+        "m_metadataID"
     end
 end
index 98555f8..05c2595 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 Apple Inc. All rights reserved.
+# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -164,7 +164,7 @@ EOF
         dumper->printLocationAndOp(__location, &"*#{@name}"[!__isWide]);
 #{print_args { |arg|
 <<-EOF.chomp
-        dumper->dumpOperand(#{arg.name}, #{arg.index == 1});
+        dumper->dumpOperand(#{arg.field_name}, #{arg.index == 1});
 EOF
     }}
     }
@@ -225,7 +225,7 @@ EOF
 
     def struct_indices
         out = []
-        out += @args.map(&:name) unless @args.nil?
+        out += @args.map(&:field_name) unless @args.nil?
         out << Metadata.field_name unless @metadata.empty?
         out.map.with_index do |name, index|
             "const unsigned #{capitalized_name}_#{name}_index = #{index + 1};"
index 6c9d3bb..a6aa326 100644 (file)
@@ -361,7 +361,7 @@ namespace JSC {
         template<typename Metadata> void emitValueProfilingSite(Metadata&);
         void emitValueProfilingSiteIfProfiledOpcode(...);
         template<typename Op>
-        std::enable_if_t<std::is_same<decltype(Op::Metadata::profile), ValueProfile>::value, void>
+        std::enable_if_t<std::is_same<decltype(Op::Metadata::m_profile), ValueProfile>::value, void>
         emitValueProfilingSiteIfProfiledOpcode(Op bytecode);
 
         void emitArrayProfilingSiteWithCell(RegisterID cell, RegisterID indexingType, ArrayProfile*);
index e81459c..ba7594b 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -157,8 +157,8 @@ void JIT::emit_op_jbeloweq(const Instruction* currentInstruction)
 void JIT::emit_op_unsigned(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpUnsigned>();
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.operand.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_operand.offset();
     
     emitGetVirtualRegister(op1, regT0);
     emitJumpSlowCaseIfNotInt(regT0);
@@ -176,9 +176,9 @@ void JIT::emit_compareAndJump(const Instruction* instruction, RelationalConditio
     // - int immediate to int immediate
 
     auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_target);
     if (isOperandConstantChar(op1)) {
         emitGetVirtualRegister(op2, regT0);
         addSlowCase(branchIfNotCell(regT0));
@@ -223,9 +223,9 @@ template<typename Op>
 void JIT::emit_compareUnsignedAndJump(const Instruction* instruction, RelationalCondition condition)
 {
     auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_target);
     if (isOperandConstantInt(op2)) {
         emitGetVirtualRegister(op1, regT0);
         int32_t op2imm = getOperandConstantInt(op2);
@@ -244,9 +244,9 @@ template<typename Op>
 void JIT::emit_compareUnsigned(const Instruction* instruction, RelationalCondition condition)
 {
     auto bytecode = instruction->as<Op>();
-    int dst = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
     if (isOperandConstantInt(op2)) {
         emitGetVirtualRegister(op1, regT0);
         int32_t op2imm = getOperandConstantInt(op2);
@@ -267,9 +267,9 @@ template<typename Op>
 void JIT::emit_compareAndJumpSlow(const Instruction* instruction, DoubleCondition condition, size_t (JIT_OPERATION *operation)(ExecState*, EncodedJSValue, EncodedJSValue), bool invert, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_target);
 
     // We generate inline code for the following cases in the slow path:
     // - floating-point number to constant int immediate
@@ -365,7 +365,7 @@ void JIT::emit_compareAndJumpSlow(const Instruction* instruction, DoubleConditio
 void JIT::emit_op_inc(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpInc>();
-    int srcDst = bytecode.srcDst.offset();
+    int srcDst = bytecode.m_srcDst.offset();
 
     emitGetVirtualRegister(srcDst, regT0);
     emitJumpSlowCaseIfNotInt(regT0);
@@ -377,7 +377,7 @@ void JIT::emit_op_inc(const Instruction* currentInstruction)
 void JIT::emit_op_dec(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpDec>();
-    int srcDst = bytecode.srcDst.offset();
+    int srcDst = bytecode.m_srcDst.offset();
 
     emitGetVirtualRegister(srcDst, regT0);
     emitJumpSlowCaseIfNotInt(regT0);
@@ -393,9 +393,9 @@ void JIT::emit_op_dec(const Instruction* currentInstruction)
 void JIT::emit_op_mod(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpMod>();
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
     // Make sure registers are correct for x86 IDIV instructions.
     ASSERT(regT0 == X86Registers::eax);
@@ -451,7 +451,7 @@ void JIT::emitSlow_op_mod(const Instruction*, Vector<SlowCaseEntry>::iterator&)
 
 void JIT::emit_op_negate(const Instruction* currentInstruction)
 {
-    ArithProfile* arithProfile = &currentInstruction->as<OpNegate>().metadata(m_codeBlock).arithProfile;
+    ArithProfile* arithProfile = &currentInstruction->as<OpNegate>().metadata(m_codeBlock).m_arithProfile;
     JITNegIC* negateIC = m_codeBlock->addJITNegIC(arithProfile, currentInstruction);
     m_instructionToMathIC.add(currentInstruction, negateIC);
     emitMathICFast<OpNegate>(negateIC, currentInstruction, operationArithNegateProfiled, operationArithNegate);
@@ -469,9 +469,9 @@ template<typename Op, typename SnippetGenerator>
 void JIT::emitBitBinaryOpFastPath(const Instruction* currentInstruction, ProfilingPolicy profilingPolicy)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
 #if USE(JSVALUE64)
     JSValueRegs leftRegs = JSValueRegs(regT0);
@@ -516,8 +516,8 @@ void JIT::emitBitBinaryOpFastPath(const Instruction* currentInstruction, Profili
 void JIT::emit_op_bitnot(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpBitnot>();
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.operand.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_operand.offset();
 
 #if USE(JSVALUE64)
     JSValueRegs leftRegs = JSValueRegs(regT0);
@@ -577,9 +577,9 @@ template<typename Op>
 void JIT::emitRightShiftFastPath(const Instruction* currentInstruction, JITRightShiftGenerator::ShiftType snippetShiftType)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
 #if USE(JSVALUE64)
     JSValueRegs leftRegs = JSValueRegs(regT0);
@@ -639,7 +639,7 @@ ALWAYS_INLINE static OperandTypes getOperandTypes(const ArithProfile& arithProfi
 
 void JIT::emit_op_add(const Instruction* currentInstruction)
 {
-    ArithProfile* arithProfile = &currentInstruction->as<OpAdd>().metadata(m_codeBlock).arithProfile;
+    ArithProfile* arithProfile = &currentInstruction->as<OpAdd>().metadata(m_codeBlock).m_arithProfile;
     JITAddIC* addIC = m_codeBlock->addJITAddIC(arithProfile, currentInstruction);
     m_instructionToMathIC.add(currentInstruction, addIC);
     emitMathICFast<OpAdd>(addIC, currentInstruction, operationValueAddProfiled, operationValueAdd);
@@ -657,8 +657,8 @@ template <typename Op, typename Generator, typename ProfiledFunction, typename N
 void JIT::emitMathICFast(JITUnaryMathIC<Generator>* mathIC, const Instruction* currentInstruction, ProfiledFunction profiledFunction, NonProfiledFunction nonProfiledFunction)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int result = bytecode.dst.offset();
-    int operand = bytecode.operand.offset();
+    int result = bytecode.m_dst.offset();
+    int operand = bytecode.m_operand.offset();
 
 #if USE(JSVALUE64)
     // ArithNegate benefits from using the same register as src and dst.
@@ -708,9 +708,9 @@ void JIT::emitMathICFast(JITBinaryMathIC<Generator>* mathIC, const Instruction*
 {
     auto bytecode = currentInstruction->as<Op>();
     OperandTypes types = getOperandTypes(copiedArithProfile(bytecode));
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
 #if USE(JSVALUE64)
     JSValueRegs leftRegs = JSValueRegs(regT1);
@@ -783,7 +783,7 @@ void JIT::emitMathICSlow(JITUnaryMathIC<Generator>* mathIC, const Instruction* c
     mathICGenerationState.slowPathStart = label();
 
     auto bytecode = currentInstruction->as<Op>();
-    int result = bytecode.dst.offset();
+    int result = bytecode.m_dst.offset();
 
 #if USE(JSVALUE64)
     JSValueRegs srcRegs = JSValueRegs(regT1);
@@ -830,9 +830,9 @@ void JIT::emitMathICSlow(JITBinaryMathIC<Generator>* mathIC, const Instruction*
 
     auto bytecode = currentInstruction->as<Op>();
     OperandTypes types = getOperandTypes(copiedArithProfile(bytecode));
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
 #if USE(JSVALUE64)
     JSValueRegs leftRegs = JSValueRegs(regT1);
@@ -892,18 +892,18 @@ void JIT::emit_op_div(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpDiv>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
 #if USE(JSVALUE64)
-    OperandTypes types = getOperandTypes(metadata.arithProfile);
+    OperandTypes types = getOperandTypes(metadata.m_arithProfile);
     JSValueRegs leftRegs = JSValueRegs(regT0);
     JSValueRegs rightRegs = JSValueRegs(regT1);
     JSValueRegs resultRegs = leftRegs;
     GPRReg scratchGPR = regT2;
 #else
-    OperandTypes types = getOperandTypes(metadata.arithProfile);
+    OperandTypes types = getOperandTypes(metadata.m_arithProfile);
     JSValueRegs leftRegs = JSValueRegs(regT1, regT0);
     JSValueRegs rightRegs = JSValueRegs(regT3, regT2);
     JSValueRegs resultRegs = leftRegs;
@@ -913,7 +913,7 @@ void JIT::emit_op_div(const Instruction* currentInstruction)
 
     ArithProfile* arithProfile = nullptr;
     if (shouldEmitProfiling())
-        arithProfile = &currentInstruction->as<OpDiv>().metadata(m_codeBlock).arithProfile;
+        arithProfile = &currentInstruction->as<OpDiv>().metadata(m_codeBlock).m_arithProfile;
 
     SnippetOperand leftOperand(types.first());
     SnippetOperand rightOperand(types.second());
@@ -958,7 +958,7 @@ void JIT::emit_op_div(const Instruction* currentInstruction)
 
 void JIT::emit_op_mul(const Instruction* currentInstruction)
 {
-    ArithProfile* arithProfile = &currentInstruction->as<OpMul>().metadata(m_codeBlock).arithProfile;
+    ArithProfile* arithProfile = &currentInstruction->as<OpMul>().metadata(m_codeBlock).m_arithProfile;
     JITMulIC* mulIC = m_codeBlock->addJITMulIC(arithProfile, currentInstruction);
     m_instructionToMathIC.add(currentInstruction, mulIC);
     emitMathICFast<OpMul>(mulIC, currentInstruction, operationValueMulProfiled, operationValueMul);
@@ -974,7 +974,7 @@ void JIT::emitSlow_op_mul(const Instruction* currentInstruction, Vector<SlowCase
 
 void JIT::emit_op_sub(const Instruction* currentInstruction)
 {
-    ArithProfile* arithProfile = &currentInstruction->as<OpSub>().metadata(m_codeBlock).arithProfile;
+    ArithProfile* arithProfile = &currentInstruction->as<OpSub>().metadata(m_codeBlock).m_arithProfile;
     JITSubIC* subIC = m_codeBlock->addJITSubIC(arithProfile, currentInstruction);
     m_instructionToMathIC.add(currentInstruction, subIC);
     emitMathICFast<OpSub>(subIC, currentInstruction, operationValueSubProfiled, operationValueSub);
index 8be745d..a0f6f35 100644 (file)
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) 2008, 2015 Apple Inc. All rights reserved.
+* Copyright (C) 2008-2019 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
@@ -48,9 +48,9 @@ void JIT::emit_compareAndJump(const Instruction* instruction, RelationalConditio
     JumpList notInt32Op2;
 
     auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_target);
 
     // Character less.
     if (isOperandConstantChar(op1)) {
@@ -102,9 +102,9 @@ template <typename Op>
 void JIT::emit_compareUnsignedAndJump(const Instruction* instruction, RelationalCondition condition)
 {
     auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_target);
 
     if (isOperandConstantInt(op1)) {
         emitLoad(op2, regT3, regT2);
@@ -122,9 +122,9 @@ template <typename Op>
 void JIT::emit_compareUnsigned(const Instruction* instruction, RelationalCondition condition)
 {
     auto bytecode = instruction->as<Op>();
-    int dst = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
     if (isOperandConstantInt(op1)) {
         emitLoad(op2, regT3, regT2);
@@ -143,9 +143,9 @@ template <typename Op>
 void JIT::emit_compareAndJumpSlow(const Instruction *instruction, DoubleCondition, size_t (JIT_OPERATION *operation)(ExecState*, EncodedJSValue, EncodedJSValue), bool invert, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_target);
 
     linkAllSlowCases(iter);
 
@@ -158,8 +158,8 @@ void JIT::emit_compareAndJumpSlow(const Instruction *instruction, DoubleConditio
 void JIT::emit_op_unsigned(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpUnsigned>();
-    int result = bytecode.dst.offset();
-    int op1 = bytecode.operand.offset();
+    int result = bytecode.m_dst.offset();
+    int op1 = bytecode.m_operand.offset();
     
     emitLoad(op1, regT1, regT0);
     
@@ -171,7 +171,7 @@ void JIT::emit_op_unsigned(const Instruction* currentInstruction)
 void JIT::emit_op_inc(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpInc>();
-    int srcDst = bytecode.srcDst.offset();
+    int srcDst = bytecode.m_srcDst.offset();
 
     emitLoad(srcDst, regT1, regT0);
 
@@ -183,7 +183,7 @@ void JIT::emit_op_inc(const Instruction* currentInstruction)
 void JIT::emit_op_dec(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpDec>();
-    int srcDst = bytecode.srcDst.offset();
+    int srcDst = bytecode.m_srcDst.offset();
 
     emitLoad(srcDst, regT1, regT0);
 
@@ -199,9 +199,9 @@ void JIT::emitBinaryDoubleOp(const Instruction *instruction, OperandTypes types,
 
     auto bytecode = instruction->as<Op>();
     int opcodeID = Op::opcodeID;
-    int target = jumpTarget(instruction, bytecode.target);
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int target = jumpTarget(instruction, bytecode.m_target);
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
     if (!notInt32Op1.empty()) {
         // Double case 1: Op1 is not int32; Op2 is unknown.
@@ -336,9 +336,9 @@ void JIT::emit_op_mod(const Instruction* currentInstruction)
 {
 #if CPU(X86)
     auto bytecode = instruction->as<OpMod>();
-    int dst = bytecode.dst.offset();
-    int op1 = bytecode.lhs.offset();
-    int op2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
 
     // Make sure registers are correct for x86 IDIV instructions.
     ASSERT(regT0 == X86Registers::eax);
index b2ada75..afc4b29 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -51,7 +51,7 @@ template<typename Op>
 void JIT::emitPutCallResult(const Op& bytecode)
 {
     emitValueProfilingSite(bytecode.metadata(m_codeBlock));
-    emitPutVirtualRegister(bytecode.dst.offset());
+    emitPutVirtualRegister(bytecode.m_dst.offset());
 }
 
 template<typename Op>
@@ -62,14 +62,14 @@ std::enable_if_t<
 JIT::compileSetupFrame(const Op& bytecode, CallLinkInfo*)
 {
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int argCount = bytecode.argc;
-    int registerOffset = -static_cast<int>(bytecode.argv);
+    int argCount = bytecode.m_argc;
+    int registerOffset = -static_cast<int>(bytecode.m_argv);
 
     if (Op::opcodeID == op_call && shouldEmitProfiling()) {
         emitGetVirtualRegister(registerOffset + CallFrame::argumentOffsetIncludingThis(0), regT0);
         Jump done = branchIfNotCell(regT0);
         load32(Address(regT0, JSCell::structureIDOffset()), regT0);
-        store32(regT0, metadata.arrayProfile.addressOfLastSeenStructureID());
+        store32(regT0, metadata.m_arrayProfile.addressOfLastSeenStructureID());
         done.link(this);
     }
 
@@ -85,10 +85,10 @@ std::enable_if_t<
 , void>
 JIT::compileSetupFrame(const Op& bytecode, CallLinkInfo* info)
 {
-    int thisValue = bytecode.thisValue.offset();
-    int arguments = bytecode.arguments.offset();
-    int firstFreeRegister = bytecode.firstFree.offset();
-    int firstVarArgOffset = bytecode.firstVarArg;
+    int thisValue = bytecode.m_thisValue.offset();
+    int arguments = bytecode.m_arguments.offset();
+    int firstFreeRegister = bytecode.m_firstFree.offset();
+    int firstVarArgOffset = bytecode.m_firstVarArg;
 
     emitGetVirtualRegister(arguments, regT1);
     Z_JITOperation_EJZZ sizeOperation;
@@ -157,7 +157,7 @@ void JIT::compileCallEvalSlowCase(const Instruction* instruction, Vector<SlowCas
     CallLinkInfo* info = m_codeBlock->addCallLinkInfo();
     info->setUpCall(CallLinkInfo::Call, CodeOrigin(m_bytecodeOffset), regT0);
 
-    int registerOffset = -bytecode.argv;
+    int registerOffset = -bytecode.m_argv;
 
     addPtr(TrustedImm32(registerOffset * sizeof(Register) + sizeof(CallerFrameAndPC)), callFrameRegister, stackPointerRegister);
 
@@ -181,15 +181,15 @@ template<>
 bool JIT::compileTailCall(const OpTailCall& bytecode, CallLinkInfo* info, unsigned callLinkInfoIndex)
 {
     CallFrameShuffleData shuffleData;
-    shuffleData.numPassedArgs = bytecode.argc;
+    shuffleData.numPassedArgs = bytecode.m_argc;
     shuffleData.tagTypeNumber = GPRInfo::tagTypeNumberRegister;
     shuffleData.numLocals =
-        bytecode.argv - sizeof(CallerFrameAndPC) / sizeof(Register);
-    shuffleData.args.resize(bytecode.argc);
-    for (unsigned i = 0; i < bytecode.argc; ++i) {
+        bytecode.m_argv - sizeof(CallerFrameAndPC) / sizeof(Register);
+    shuffleData.args.resize(bytecode.m_argc);
+    for (unsigned i = 0; i < bytecode.m_argc; ++i) {
         shuffleData.args[i] =
             ValueRecovery::displacedInJSStack(
-                virtualRegisterForArgument(i) - bytecode.argv,
+                virtualRegisterForArgument(i) - bytecode.m_argv,
                 DataFormatJS);
     }
     shuffleData.callee =
@@ -206,7 +206,7 @@ void JIT::compileOpCall(const Instruction* instruction, unsigned callLinkInfoInd
 {
     OpcodeID opcodeID = Op::opcodeID;
     auto bytecode = instruction->as<Op>();
-    int callee = bytecode.callee.offset();
+    int callee = bytecode.m_callee.offset();
 
     /* Caller always:
         - Updates callFrameRegister to callee callFrame.
index 09c4d03..b42e997 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -49,13 +49,13 @@ template<typename Op>
 void JIT::emitPutCallResult(const Op& bytecode)
 {
     emitValueProfilingSite(bytecode.metadata(m_codeBlock));
-    emitStore(bytecode.dst.offset(), regT1, regT0);
+    emitStore(bytecode.m_dst.offset(), regT1, regT0);
 }
 
 void JIT::emit_op_ret(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpRet>();
-    int value = bytecode.value.offset();
+    int value = bytecode.m_value.offset();
 
     emitLoad(value, regT1, regT0);
 
@@ -153,14 +153,14 @@ std::enable_if_t<
 JIT::compileSetupFrame(const Op& bytecode, CallLinkInfo*)
 {
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int argCount = bytecode.argc;
-    int registerOffset = -static_cast<int>(bytecode.argv);
+    int argCount = bytecode.m_argc;
+    int registerOffset = -static_cast<int>(bytecode.m_argv);
 
     if (Op::opcodeID == op_call && shouldEmitProfiling()) {
         emitLoad(registerOffset + CallFrame::argumentOffsetIncludingThis(0), regT0, regT1);
         Jump done = branchIfNotCell(regT0);
         load32(Address(regT1, JSCell::structureIDOffset()), regT1);
-        store32(regT1, metadata.arrayProfile.addressOfLastSeenStructureID());
+        store32(regT1, metadata.m_arrayProfile.addressOfLastSeenStructureID());
         done.link(this);
     }
 
@@ -176,10 +176,10 @@ std::enable_if_t<
 JIT::compileSetupFrame(const Op& bytecode, CallLinkInfo* info)
 {
     OpcodeID opcodeID = Op::opcodeID;
-    int thisValue = bytecode.thisValue.offset();
-    int arguments = bytecode.arguments.offset();
-    int firstFreeRegister = bytecode.firstFree.offset();
-    int firstVarArgOffset = bytecode.firstVarArg;
+    int thisValue = bytecode.m_thisValue.offset();
+    int arguments = bytecode.m_arguments.offset();
+    int firstFreeRegister = bytecode.m_firstFree.offset();
+    int firstVarArgOffset = bytecode.m_firstVarArg;
 
     emitLoad(arguments, regT1, regT0);
     Z_JITOperation_EJZZ sizeOperation;
@@ -248,8 +248,8 @@ void JIT::compileCallEvalSlowCase(const Instruction* instruction, Vector<SlowCas
     CallLinkInfo* info = m_codeBlock->addCallLinkInfo();
     info->setUpCall(CallLinkInfo::Call, CodeOrigin(m_bytecodeOffset), regT0);
 
-    int registerOffset = -bytecode.argv;
-    int callee = bytecode.callee.offset();
+    int registerOffset = -bytecode.m_argv;
+    int callee = bytecode.m_callee.offset();
 
     addPtr(TrustedImm32(registerOffset * sizeof(Register) + sizeof(CallerFrameAndPC)), callFrameRegister, stackPointerRegister);
 
@@ -268,7 +268,7 @@ void JIT::compileOpCall(const Instruction* instruction, unsigned callLinkInfoInd
 {
     OpcodeID opcodeID = Op::opcodeID;
     auto bytecode = instruction->as<Op>();
-    int callee = bytecode.callee.offset();
+    int callee = bytecode.m_callee.offset();
 
     /* Caller always:
         - Updates callFrameRegister to callee callFrame.
index f54bfe9..e260c11 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -329,7 +329,7 @@ inline void JIT::emitValueProfilingSite(ValueProfile& valueProfile)
 }
 
 template<typename Op>
-inline std::enable_if_t<std::is_same<decltype(Op::Metadata::profile), ValueProfile>::value, void> JIT::emitValueProfilingSiteIfProfiledOpcode(Op bytecode)
+inline std::enable_if_t<std::is_same<decltype(Op::Metadata::m_profile), ValueProfile>::value, void> JIT::emitValueProfilingSiteIfProfiledOpcode(Op bytecode)
 {
     emitValueProfilingSite(bytecode.metadata(m_codeBlock));
 }
@@ -341,7 +341,7 @@ inline void JIT::emitValueProfilingSite(Metadata& metadata)
 {
     if (!shouldEmitProfiling())
         return;
-    emitValueProfilingSite(metadata.profile);
+    emitValueProfilingSite(metadata.m_profile);
 }
 
 inline void JIT::emitArrayProfilingSiteWithCell(RegisterID cell, RegisterID indexingType, ArrayProfile* arrayProfile)
@@ -710,11 +710,11 @@ ALWAYS_INLINE int JIT::jumpTarget(const Instruction* instruction, int target)
 
 ALWAYS_INLINE GetPutInfo JIT::copiedGetPutInfo(OpPutToScope bytecode)
 {
-    unsigned key = bytecode.metadataID + 1; // HashMap doesn't like 0 as a key
+    unsigned key = bytecode.m_metadataID + 1; // HashMap doesn't like 0 as a key
     auto iterator = m_copiedGetPutInfos.find(key);
     if (iterator != m_copiedGetPutInfos.end())
         return GetPutInfo(iterator->value);
-    GetPutInfo getPutInfo = bytecode.metadata(m_codeBlock).getPutInfo;
+    GetPutInfo getPutInfo = bytecode.metadata(m_codeBlock).m_getPutInfo;
     m_copiedGetPutInfos.add(key, getPutInfo.operand());
     return getPutInfo;
 }
@@ -722,11 +722,11 @@ ALWAYS_INLINE GetPutInfo JIT::copiedGetPutInfo(OpPutToScope bytecode)
 template<typename BinaryOp>
 ALWAYS_INLINE ArithProfile JIT::copiedArithProfile(BinaryOp bytecode)
 {
-    uint64_t key = static_cast<uint64_t>(BinaryOp::opcodeID) << 32 | static_cast<uint64_t>(bytecode.metadataID);
+    uint64_t key = static_cast<uint64_t>(BinaryOp::opcodeID) << 32 | static_cast<uint64_t>(bytecode.m_metadataID);
     auto iterator = m_copiedArithProfiles.find(key);
     if (iterator != m_copiedArithProfiles.end())
         return iterator->value;
-    ArithProfile arithProfile = bytecode.metadata(m_codeBlock).arithProfile;
+    ArithProfile arithProfile = bytecode.metadata(m_codeBlock).m_arithProfile;
     m_copiedArithProfiles.add(key, arithProfile);
     return arithProfile;
 }
index 6ec0749..2d5383f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2009-2019 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -56,8 +56,8 @@ namespace JSC {
 void JIT::emit_op_mov(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpMov>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.src.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_src.offset();
 
     if (m_codeBlock->isConstantRegisterIndex(src)) {
         JSValue value = m_codeBlock->getConstant(src);
@@ -77,7 +77,7 @@ void JIT::emit_op_end(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEnd>();
     RELEASE_ASSERT(returnValueGPR != callFrameRegister);
-    emitGetVirtualRegister(bytecode.value.offset(), returnValueGPR);
+    emitGetVirtualRegister(bytecode.m_value.offset(), returnValueGPR);
     emitRestoreCalleeSaves();
     emitFunctionEpilogue();
     ret();
@@ -86,7 +86,7 @@ void JIT::emit_op_end(const Instruction* currentInstruction)
 void JIT::emit_op_jmp(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJmp>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     addJump(jump(), target);
 }
 
@@ -94,7 +94,7 @@ void JIT::emit_op_new_object(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNewObject>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    Structure* structure = metadata.objectAllocationProfile.structure();
+    Structure* structure = metadata.m_objectAllocationProfile.structure();
     size_t allocationSize = JSFinalObject::allocationSize(structure->inlineCapacity());
     Allocator allocator = subspaceFor<JSFinalObject>(*m_vm)->allocatorForNonVirtual(allocationSize, AllocatorForMode::AllocatorIfExists);
 
@@ -110,7 +110,7 @@ void JIT::emit_op_new_object(const Instruction* currentInstruction)
         emitAllocateJSObject(resultReg, JITAllocator::constant(allocator), allocatorReg, TrustedImmPtr(structure), butterfly, scratchReg, slowCases);
         emitInitializeInlineStorage(resultReg, structure->inlineCapacity());
         addSlowCase(slowCases);
-        emitPutVirtualRegister(bytecode.dst.offset());
+        emitPutVirtualRegister(bytecode.m_dst.offset());
     }
 }
 
@@ -120,8 +120,8 @@ void JIT::emitSlow_op_new_object(const Instruction* currentInstruction, Vector<S
 
     auto bytecode = currentInstruction->as<OpNewObject>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    Structure* structure = metadata.objectAllocationProfile.structure();
+    int dst = bytecode.m_dst.offset();
+    Structure* structure = metadata.m_objectAllocationProfile.structure();
     callOperation(operationNewObject, structure);
     emitStoreCell(dst, returnValueGPR);
 }
@@ -129,9 +129,9 @@ void JIT::emitSlow_op_new_object(const Instruction* currentInstruction, Vector<S
 void JIT::emit_op_overrides_has_instance(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpOverridesHasInstance>();
-    int dst = bytecode.dst.offset();
-    int constructor = bytecode.constructor.offset();
-    int hasInstanceValue = bytecode.hasInstanceValue.offset();
+    int dst = bytecode.m_dst.offset();
+    int constructor = bytecode.m_constructor.offset();
+    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
 
     emitGetVirtualRegister(hasInstanceValue, regT0);
 
@@ -155,9 +155,9 @@ void JIT::emit_op_overrides_has_instance(const Instruction* currentInstruction)
 void JIT::emit_op_instanceof(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpInstanceof>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.value.offset();
-    int proto = bytecode.prototype.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_value.offset();
+    int proto = bytecode.m_prototype.offset();
 
     // Load the operands (baseVal, proto, and value respectively) into registers.
     // We use regT0 for baseVal since we will be done with this first, and we can then use it for the result.
@@ -186,7 +186,7 @@ void JIT::emitSlow_op_instanceof(const Instruction* currentInstruction, Vector<S
     linkAllSlowCases(iter);
     
     auto bytecode = currentInstruction->as<OpInstanceof>();
-    int resultVReg = bytecode.dst.offset();
+    int resultVReg = bytecode.m_dst.offset();
     
     JITInstanceOfGenerator& gen = m_instanceOfs[m_instanceOfIndex++];
     
@@ -204,8 +204,8 @@ void JIT::emit_op_instanceof_custom(const Instruction*)
 void JIT::emit_op_is_empty(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsEmpty>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
 
     emitGetVirtualRegister(value, regT0);
     compare64(Equal, regT0, TrustedImm32(JSValue::encode(JSValue())), regT0);
@@ -217,8 +217,8 @@ void JIT::emit_op_is_empty(const Instruction* currentInstruction)
 void JIT::emit_op_is_undefined(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsUndefined>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitGetVirtualRegister(value, regT0);
     Jump isCell = branchIfCell(regT0);
@@ -246,8 +246,8 @@ void JIT::emit_op_is_undefined(const Instruction* currentInstruction)
 void JIT::emit_op_is_undefined_or_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsUndefinedOrNull>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
 
     emitGetVirtualRegister(value, regT0);
 
@@ -261,8 +261,8 @@ void JIT::emit_op_is_undefined_or_null(const Instruction* currentInstruction)
 void JIT::emit_op_is_boolean(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsBoolean>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitGetVirtualRegister(value, regT0);
     xor64(TrustedImm32(static_cast<int32_t>(ValueFalse)), regT0);
@@ -274,8 +274,8 @@ void JIT::emit_op_is_boolean(const Instruction* currentInstruction)
 void JIT::emit_op_is_number(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsNumber>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitGetVirtualRegister(value, regT0);
     test64(NonZero, regT0, tagTypeNumberRegister, regT0);
@@ -286,9 +286,9 @@ void JIT::emit_op_is_number(const Instruction* currentInstruction)
 void JIT::emit_op_is_cell_with_type(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsCellWithType>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
-    int type = bytecode.type;
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
+    int type = bytecode.m_type;
 
     emitGetVirtualRegister(value, regT0);
     Jump isNotCell = branchIfNotCell(regT0);
@@ -307,8 +307,8 @@ void JIT::emit_op_is_cell_with_type(const Instruction* currentInstruction)
 void JIT::emit_op_is_object(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsObject>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
 
     emitGetVirtualRegister(value, regT0);
     Jump isNotCell = branchIfNotCell(regT0);
@@ -332,7 +332,7 @@ void JIT::emit_op_ret(const Instruction* currentInstruction)
 
     // Return the result in %eax.
     auto bytecode = currentInstruction->as<OpRet>();
-    emitGetVirtualRegister(bytecode.value.offset(), returnValueGPR);
+    emitGetVirtualRegister(bytecode.m_value.offset(), returnValueGPR);
 
     checkStackPointerAlignment();
     emitRestoreCalleeSaves();
@@ -343,8 +343,8 @@ void JIT::emit_op_ret(const Instruction* currentInstruction)
 void JIT::emit_op_to_primitive(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToPrimitive>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.src.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_src.offset();
 
     emitGetVirtualRegister(src, regT0);
     
@@ -360,15 +360,15 @@ void JIT::emit_op_to_primitive(const Instruction* currentInstruction)
 void JIT::emit_op_set_function_name(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSetFunctionName>();
-    emitGetVirtualRegister(bytecode.function.offset(), regT0);
-    emitGetVirtualRegister(bytecode.name.offset(), regT1);
+    emitGetVirtualRegister(bytecode.m_function.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_name.offset(), regT1);
     callOperation(operationSetFunctionName, regT0, regT1);
 }
 
 void JIT::emit_op_not(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNot>();
-    emitGetVirtualRegister(bytecode.operand.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_operand.offset(), regT0);
 
     // Invert against JSValue(false); if the value was tagged as a boolean, then all bits will be
     // clear other than the low bit (which will be 0 or 1 for false or true inputs respectively).
@@ -377,28 +377,28 @@ void JIT::emit_op_not(const Instruction* currentInstruction)
     addSlowCase(branchTestPtr(NonZero, regT0, TrustedImm32(static_cast<int32_t>(~1))));
     xor64(TrustedImm32(static_cast<int32_t>(ValueTrue)), regT0);
 
-    emitPutVirtualRegister(bytecode.dst.offset());
+    emitPutVirtualRegister(bytecode.m_dst.offset());
 }
 
 void JIT::emit_op_jfalse(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJfalse>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     GPRReg value = regT0;
     GPRReg scratch1 = regT1;
     GPRReg scratch2 = regT2;
     bool shouldCheckMasqueradesAsUndefined = true;
 
-    emitGetVirtualRegister(bytecode.condition.offset(), value);
+    emitGetVirtualRegister(bytecode.m_condition.offset(), value);
     addJump(branchIfFalsey(*vm(), JSValueRegs(value), scratch1, scratch2, fpRegT0, fpRegT1, shouldCheckMasqueradesAsUndefined, m_codeBlock->globalObject()), target);
 }
 
 void JIT::emit_op_jeq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJeqNull>();
-    int src = bytecode.value.offset();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int src = bytecode.m_value.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitGetVirtualRegister(src, regT0);
     Jump isImmediate = branchIfNotCell(regT0);
@@ -421,8 +421,8 @@ void JIT::emit_op_jeq_null(const Instruction* currentInstruction)
 void JIT::emit_op_jneq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJneqNull>();
-    int src = bytecode.value.offset();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int src = bytecode.m_value.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitGetVirtualRegister(src, regT0);
     Jump isImmediate = branchIfNotCell(regT0);
@@ -446,13 +446,13 @@ void JIT::emit_op_jneq_ptr(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJneqPtr>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int src = bytecode.value.offset();
-    Special::Pointer ptr = bytecode.specialPointer;
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int src = bytecode.m_value.offset();
+    Special::Pointer ptr = bytecode.m_specialPointer;
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     
     emitGetVirtualRegister(src, regT0);
     CCallHelpers::Jump equal = branchPtr(Equal, regT0, TrustedImmPtr(actualPointerFor(m_codeBlock, ptr)));
-    store8(TrustedImm32(1), &metadata.hasJumped);
+    store8(TrustedImm32(1), &metadata.m_hasJumped);
     addJump(jump(), target);
     equal.link(this);
 }
@@ -460,18 +460,18 @@ void JIT::emit_op_jneq_ptr(const Instruction* currentInstruction)
 void JIT::emit_op_eq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEq>();
-    emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
+    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
     emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
     compare32(Equal, regT1, regT0, regT0);
     boxBoolean(regT0, JSValueRegs { regT0 });
-    emitPutVirtualRegister(bytecode.dst.offset());
+    emitPutVirtualRegister(bytecode.m_dst.offset());
 }
 
 void JIT::emit_op_jeq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJeq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
-    emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
+    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
     emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
     addJump(branch32(Equal, regT0, regT1), target);
 }
@@ -479,32 +479,32 @@ void JIT::emit_op_jeq(const Instruction* currentInstruction)
 void JIT::emit_op_jtrue(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJtrue>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     GPRReg value = regT0;
     GPRReg scratch1 = regT1;
     GPRReg scratch2 = regT2;
     bool shouldCheckMasqueradesAsUndefined = true;
-    emitGetVirtualRegister(bytecode.condition.offset(), value);
+    emitGetVirtualRegister(bytecode.m_condition.offset(), value);
     addJump(branchIfTruthy(*vm(), JSValueRegs(value), scratch1, scratch2, fpRegT0, fpRegT1, shouldCheckMasqueradesAsUndefined, m_codeBlock->globalObject()), target);
 }
 
 void JIT::emit_op_neq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNeq>();
-    emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
+    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
     emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
     compare32(NotEqual, regT1, regT0, regT0);
     boxBoolean(regT0, JSValueRegs { regT0 });
 
-    emitPutVirtualRegister(bytecode.dst.offset());
+    emitPutVirtualRegister(bytecode.m_dst.offset());
 }
 
 void JIT::emit_op_jneq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJneq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
-    emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
+    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
     emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
     addJump(branch32(NotEqual, regT0, regT1), target);
 }
@@ -514,7 +514,7 @@ void JIT::emit_op_throw(const Instruction* currentInstruction)
     auto bytecode = currentInstruction->as<OpThrow>();
     ASSERT(regT0 == returnValueGPR);
     copyCalleeSavesToEntryFrameCalleeSavesBuffer(vm()->topEntryFrame);
-    emitGetVirtualRegister(bytecode.value.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_value.offset(), regT0);
     callOperationNoExceptionCheck(operationThrow, regT0);
     jumpToExceptionHandler(*vm());
 }
@@ -523,9 +523,9 @@ template<typename Op>
 void JIT::compileOpStrictEq(const Instruction* currentInstruction, CompileOpStrictEqType type)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int dst = bytecode.dst.offset();
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitGetVirtualRegisters(src1, regT0, src2, regT1);
     
@@ -566,9 +566,9 @@ template<typename Op>
 void JIT::compileOpStrictEqJump(const Instruction* currentInstruction, CompileOpStrictEqType type)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int target = jumpTarget(currentInstruction, bytecode.target);
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    int target = jumpTarget(currentInstruction, bytecode.m_target);
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitGetVirtualRegisters(src1, regT0, src2, regT1);
 
@@ -607,7 +607,7 @@ void JIT::emitSlow_op_jstricteq(const Instruction* currentInstruction, Vector<Sl
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpJstricteq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     callOperation(operationCompareStrictEq, regT0, regT1);
     emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
 }
@@ -617,7 +617,7 @@ void JIT::emitSlow_op_jnstricteq(const Instruction* currentInstruction, Vector<S
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpJnstricteq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     callOperation(operationCompareStrictEq, regT0, regT1);
     emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
 }
@@ -625,8 +625,8 @@ void JIT::emitSlow_op_jnstricteq(const Instruction* currentInstruction, Vector<S
 void JIT::emit_op_to_number(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToNumber>();
-    int dstVReg = bytecode.dst.offset();
-    int srcVReg = bytecode.operand.offset();
+    int dstVReg = bytecode.m_dst.offset();
+    int srcVReg = bytecode.m_operand.offset();
     emitGetVirtualRegister(srcVReg, regT0);
     
     addSlowCase(branchIfNotNumber(regT0));
@@ -639,20 +639,20 @@ void JIT::emit_op_to_number(const Instruction* currentInstruction)
 void JIT::emit_op_to_string(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToString>();
-    int srcVReg = bytecode.operand.offset();
+    int srcVReg = bytecode.m_operand.offset();
     emitGetVirtualRegister(srcVReg, regT0);
 
     addSlowCase(branchIfNotCell(regT0));
     addSlowCase(branchIfNotString(regT0));
 
-    emitPutVirtualRegister(bytecode.dst.offset());
+    emitPutVirtualRegister(bytecode.m_dst.offset());
 }
 
 void JIT::emit_op_to_object(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToObject>();
-    int dstVReg = bytecode.dst.offset();
-    int srcVReg = bytecode.operand.offset();
+    int dstVReg = bytecode.m_dst.offset();
+    int srcVReg = bytecode.m_operand.offset();
     emitGetVirtualRegister(srcVReg, regT0);
 
     addSlowCase(branchIfNotCell(regT0));
@@ -683,10 +683,10 @@ void JIT::emit_op_catch(const Instruction* currentInstruction)
     move(TrustedImmPtr(m_vm), regT3);
     load64(Address(regT3, VM::exceptionOffset()), regT0);
     store64(TrustedImm64(JSValue::encode(JSValue())), Address(regT3, VM::exceptionOffset()));
-    emitPutVirtualRegister(bytecode.exception.offset());
+    emitPutVirtualRegister(bytecode.m_exception.offset());
 
     load64(Address(regT0, Exception::valueOffset()), regT0);
-    emitPutVirtualRegister(bytecode.thrownValue.offset());
+    emitPutVirtualRegister(bytecode.m_thrownValue.offset());
 
 #if ENABLE(DFG_JIT)
     // FIXME: consider inline caching the process of doing OSR entry, including
@@ -694,7 +694,7 @@ void JIT::emit_op_catch(const Instruction* currentInstruction)
     // https://bugs.webkit.org/show_bug.cgi?id=175598
 
     auto& metadata = bytecode.metadata(m_codeBlock);
-    ValueProfileAndOperandBuffer* buffer = metadata.buffer;
+    ValueProfileAndOperandBuffer* buffer = metadata.m_buffer;
     if (buffer || !shouldEmitProfiling())
         callOperation(operationTryOSREnterAtCatch, m_bytecodeOffset);
     else
@@ -721,18 +721,18 @@ void JIT::emit_op_identity_with_profile(const Instruction*)
 void JIT::emit_op_get_parent_scope(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetParentScope>();
-    int currentScope = bytecode.scope.offset();
+    int currentScope = bytecode.m_scope.offset();
     emitGetVirtualRegister(currentScope, regT0);
     loadPtr(Address(regT0, JSScope::offsetOfNext()), regT0);
-    emitStoreCell(bytecode.dst.offset(), regT0);
+    emitStoreCell(bytecode.m_dst.offset(), regT0);
 }
 
 void JIT::emit_op_switch_imm(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSwitchImm>();
-    size_t tableIndex = bytecode.tableIndex;
-    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
-    unsigned scrutinee = bytecode.scrutinee.offset();
+    size_t tableIndex = bytecode.m_tableIndex;
+    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
+    unsigned scrutinee = bytecode.m_scrutinee.offset();
 
     // create jump table for switch destinations, track this switch statement.
     SimpleJumpTable* jumpTable = &m_codeBlock->switchJumpTable(tableIndex);
@@ -747,9 +747,9 @@ void JIT::emit_op_switch_imm(const Instruction* currentInstruction)
 void JIT::emit_op_switch_char(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSwitchChar>();
-    size_t tableIndex = bytecode.tableIndex;
-    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
-    unsigned scrutinee = bytecode.scrutinee.offset();
+    size_t tableIndex = bytecode.m_tableIndex;
+    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
+    unsigned scrutinee = bytecode.m_scrutinee.offset();
 
     // create jump table for switch destinations, track this switch statement.
     SimpleJumpTable* jumpTable = &m_codeBlock->switchJumpTable(tableIndex);
@@ -764,9 +764,9 @@ void JIT::emit_op_switch_char(const Instruction* currentInstruction)
 void JIT::emit_op_switch_string(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSwitchString>();
-    size_t tableIndex = bytecode.tableIndex;
-    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
-    unsigned scrutinee = bytecode.scrutinee.offset();
+    size_t tableIndex = bytecode.m_tableIndex;
+    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
+    unsigned scrutinee = bytecode.m_scrutinee.offset();
 
     // create jump table for switch destinations, track this switch statement.
     StringJumpTable* jumpTable = &m_codeBlock->stringSwitchJumpTable(tableIndex);
@@ -782,15 +782,15 @@ void JIT::emit_op_debug(const Instruction* currentInstruction)
     auto bytecode = currentInstruction->as<OpDebug>();
     load32(codeBlock()->debuggerRequestsAddress(), regT0);
     Jump noDebuggerRequests = branchTest32(Zero, regT0);
-    callOperation(operationDebug, static_cast<int>(bytecode.debugHookType));
+    callOperation(operationDebug, static_cast<int>(bytecode.m_debugHookType));
     noDebuggerRequests.link(this);
 }
 
 void JIT::emit_op_eq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEqNull>();
-    int dst = bytecode.dst.offset();
-    int src1 = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src1 = bytecode.m_operand.offset();
 
     emitGetVirtualRegister(src1, regT0);
     Jump isImmediate = branchIfNotCell(regT0);
@@ -822,8 +822,8 @@ void JIT::emit_op_eq_null(const Instruction* currentInstruction)
 void JIT::emit_op_neq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNeqNull>();
-    int dst = bytecode.dst.offset();
-    int src1 = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src1 = bytecode.m_operand.offset();
 
     emitGetVirtualRegister(src1, regT0);
     Jump isImmediate = branchIfNotCell(regT0);
@@ -868,7 +868,7 @@ void JIT::emit_op_enter(const Instruction*)
 void JIT::emit_op_get_scope(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetScope>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
     emitGetFromCallFrameHeaderPtr(CallFrameSlot::callee, regT0);
     loadPtr(Address(regT0, JSFunction::offsetOfScopeChain()), regT0);
     emitStoreCell(dst, regT0);
@@ -878,8 +878,8 @@ void JIT::emit_op_to_this(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToThis>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    WriteBarrierBase<Structure>* cachedStructure = &metadata.cachedStructure;
-    emitGetVirtualRegister(bytecode.srcDst.offset(), regT1);
+    WriteBarrierBase<Structure>* cachedStructure = &metadata.m_cachedStructure;
+    emitGetVirtualRegister(bytecode.m_srcDst.offset(), regT1);
 
     emitJumpSlowCaseIfNotJSCell(regT1);
 
@@ -894,8 +894,8 @@ void JIT::emit_op_create_this(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpCreateThis>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int callee = bytecode.callee.offset();
-    WriteBarrierBase<JSCell>* cachedFunction = &metadata.cachedCallee;
+    int callee = bytecode.m_callee.offset();
+    WriteBarrierBase<JSCell>* cachedFunction = &metadata.m_cachedCallee;
     RegisterID calleeReg = regT0;
     RegisterID rareDataReg = regT4;
     RegisterID resultReg = regT0;
@@ -926,13 +926,13 @@ void JIT::emit_op_create_this(const Instruction* currentInstruction)
     load32(Address(scratchReg, FunctionRareData::offsetOfObjectAllocationProfile() + ObjectAllocationProfile::offsetOfInlineCapacity()), scratchReg);
     emitInitializeInlineStorage(resultReg, scratchReg);
     addSlowCase(slowCases);
-    emitPutVirtualRegister(bytecode.dst.offset());
+    emitPutVirtualRegister(bytecode.m_dst.offset());
 }
 
 void JIT::emit_op_check_tdz(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpCheckTdz>();
-    emitGetVirtualRegister(bytecode.target.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_target.offset(), regT0);
     addSlowCase(branchIfEmpty(regT0));
 }
 
@@ -946,7 +946,7 @@ void JIT::emitSlow_op_eq(const Instruction* currentInstruction, Vector<SlowCaseE
     auto bytecode = currentInstruction->as<OpEq>();
     callOperation(operationCompareEq, regT0, regT1);
     boxBoolean(returnValueGPR, JSValueRegs { returnValueGPR });
-    emitPutVirtualRegister(bytecode.dst.offset(), returnValueGPR);
+    emitPutVirtualRegister(bytecode.m_dst.offset(), returnValueGPR);
 }
 
 void JIT::emitSlow_op_neq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
@@ -957,7 +957,7 @@ void JIT::emitSlow_op_neq(const Instruction* currentInstruction, Vector<SlowCase
     callOperation(operationCompareEq, regT0, regT1);
     xor32(TrustedImm32(0x1), regT0);
     boxBoolean(returnValueGPR, JSValueRegs { returnValueGPR });
-    emitPutVirtualRegister(bytecode.dst.offset(), returnValueGPR);
+    emitPutVirtualRegister(bytecode.m_dst.offset(), returnValueGPR);
 }
 
 void JIT::emitSlow_op_jeq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
@@ -965,7 +965,7 @@ void JIT::emitSlow_op_jeq(const Instruction* currentInstruction, Vector<SlowCase
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpJeq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     callOperation(operationCompareEq, regT0, regT1);
     emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
 }
@@ -975,7 +975,7 @@ void JIT::emitSlow_op_jneq(const Instruction* currentInstruction, Vector<SlowCas
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpJneq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     callOperation(operationCompareEq, regT0, regT1);
     emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
 }
@@ -985,10 +985,10 @@ void JIT::emitSlow_op_instanceof_custom(const Instruction* currentInstruction, V
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpInstanceofCustom>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.value.offset();
-    int constructor = bytecode.constructor.offset();
-    int hasInstanceValue = bytecode.hasInstanceValue.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_value.offset();
+    int constructor = bytecode.m_constructor.offset();
+    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
 
     emitGetVirtualRegister(value, regT0);
     emitGetVirtualRegister(constructor, regT1);
@@ -1065,8 +1065,8 @@ void JIT::emitSlow_op_check_traps(const Instruction*, Vector<SlowCaseEntry>::ite
 void JIT::emit_op_new_regexp(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNewRegexp>();
-    int dst = bytecode.dst.offset();
-    int regexp = bytecode.regexp.offset();
+    int dst = bytecode.m_dst.offset();
+    int regexp = bytecode.m_regexp.offset();
     callOperation(operationNewRegexp, jsCast<RegExp*>(m_codeBlock->getConstant(regexp)));
     emitStoreCell(dst, returnValueGPR);
 }
@@ -1076,14 +1076,14 @@ void JIT::emitNewFuncCommon(const Instruction* currentInstruction)
 {
     Jump lazyJump;
     auto bytecode = currentInstruction->as<Op>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
 
 #if USE(JSVALUE64)
-    emitGetVirtualRegister(bytecode.scope.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_scope.offset(), regT0);
 #else
-    emitLoadPayload(bytecode.scope.offset(), regT0);
+    emitLoadPayload(bytecode.m_scope.offset(), regT0);
 #endif
-    FunctionExecutable* funcExec = m_codeBlock->functionDecl(bytecode.functionDecl);
+    FunctionExecutable* funcExec = m_codeBlock->functionDecl(bytecode.m_functionDecl);
 
     OpcodeID opcodeID = Op::opcodeID;
     if (opcodeID == op_new_func)
@@ -1122,14 +1122,14 @@ template<typename Op>
 void JIT::emitNewFuncExprCommon(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
 #if USE(JSVALUE64)
-    emitGetVirtualRegister(bytecode.scope.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_scope.offset(), regT0);
 #else
-    emitLoadPayload(bytecode.scope.offset(), regT0);
+    emitLoadPayload(bytecode.m_scope.offset(), regT0);
 #endif
 
-    FunctionExecutable* function = m_codeBlock->functionExpr(bytecode.functionDecl);
+    FunctionExecutable* function = m_codeBlock->functionExpr(bytecode.m_functionDecl);
     OpcodeID opcodeID = Op::opcodeID;
 
     if (opcodeID == op_new_func_exp)
@@ -1168,28 +1168,28 @@ void JIT::emit_op_new_array(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNewArray>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    int valuesIndex = bytecode.argv.offset();
-    int size = bytecode.argc;
+    int dst = bytecode.m_dst.offset();
+    int valuesIndex = bytecode.m_argv.offset();
+    int size = bytecode.m_argc;
     addPtr(TrustedImm32(valuesIndex * sizeof(Register)), callFrameRegister, regT0);
     callOperation(operationNewArrayWithProfile, dst,
-        &metadata.arrayAllocationProfile, regT0, size);
+        &metadata.m_arrayAllocationProfile, regT0, size);
 }
 
 void JIT::emit_op_new_array_with_size(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNewArrayWithSize>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    int sizeIndex = bytecode.length.offset();
+    int dst = bytecode.m_dst.offset();
+    int sizeIndex = bytecode.m_length.offset();
 #if USE(JSVALUE64)
     emitGetVirtualRegister(sizeIndex, regT0);
     callOperation(operationNewArrayWithSizeAndProfile, dst,
-        &metadata.arrayAllocationProfile, regT0);
+        &metadata.m_arrayAllocationProfile, regT0);
 #else
     emitLoad(sizeIndex, regT1, regT0);
     callOperation(operationNewArrayWithSizeAndProfile, dst,
-        &metadata.arrayAllocationProfile, JSValueRegs(regT1, regT0));
+        &metadata.m_arrayAllocationProfile, JSValueRegs(regT1, regT0));
 #endif
 }
 
@@ -1197,9 +1197,9 @@ void JIT::emit_op_new_array_with_size(const Instruction* currentInstruction)
 void JIT::emit_op_has_structure_property(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpHasStructureProperty>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int enumerator = bytecode.enumerator.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int enumerator = bytecode.m_enumerator.offset();
 
     emitGetVirtualRegister(base, regT0);
     emitGetVirtualRegister(enumerator, regT1);
@@ -1243,10 +1243,10 @@ void JIT::emit_op_has_indexed_property(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
-    ArrayProfile* profile = &metadata.arrayProfile;
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
+    ArrayProfile* profile = &metadata.m_arrayProfile;
     ByValInfo* byValInfo = m_codeBlock->addByValInfo();
     
     emitGetVirtualRegisters(base, regT0, property, regT1);
@@ -1289,9 +1289,9 @@ void JIT::emitSlow_op_has_indexed_property(const Instruction* currentInstruction
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
     ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
 
     Label slowPath = label();
@@ -1308,10 +1308,10 @@ void JIT::emitSlow_op_has_indexed_property(const Instruction* currentInstruction
 void JIT::emit_op_get_direct_pname(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetDirectPname>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int index = bytecode.index.offset();
-    int enumerator = bytecode.enumerator.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int index = bytecode.m_index.offset();
+    int enumerator = bytecode.m_enumerator.offset();
 
     // Check that base is a cell
     emitGetVirtualRegister(base, regT0);
@@ -1349,9 +1349,9 @@ void JIT::emit_op_get_direct_pname(const Instruction* currentInstruction)
 void JIT::emit_op_enumerator_structure_pname(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEnumeratorStructurePname>();
-    int dst = bytecode.dst.offset();
-    int enumerator = bytecode.enumerator.offset();
-    int index = bytecode.index.offset();
+    int dst = bytecode.m_dst.offset();
+    int enumerator = bytecode.m_enumerator.offset();
+    int index = bytecode.m_index.offset();
 
     emitGetVirtualRegister(index, regT0);
     emitGetVirtualRegister(enumerator, regT1);
@@ -1373,9 +1373,9 @@ void JIT::emit_op_enumerator_structure_pname(const Instruction* currentInstructi
 void JIT::emit_op_enumerator_generic_pname(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEnumeratorGenericPname>();
-    int dst = bytecode.dst.offset();
-    int enumerator = bytecode.enumerator.offset();
-    int index = bytecode.index.offset();
+    int dst = bytecode.m_dst.offset();
+    int enumerator = bytecode.m_enumerator.offset();
+    int index = bytecode.m_index.offset();
 
     emitGetVirtualRegister(index, regT0);
     emitGetVirtualRegister(enumerator, regT1);
@@ -1398,8 +1398,8 @@ void JIT::emit_op_profile_type(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpProfileType>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    TypeLocation* cachedTypeLocation = metadata.typeLocation;
-    int valueToProfile = bytecode.target.offset();
+    TypeLocation* cachedTypeLocation = metadata.m_typeLocation;
+    int valueToProfile = bytecode.m_target.offset();
 
     emitGetVirtualRegister(valueToProfile, regT0);
 
@@ -1467,7 +1467,7 @@ void JIT::emit_op_log_shadow_chicken_prologue(const Instruction* currentInstruct
     GPRReg scratch1Reg = nonArgGPR0; // This must be a non-argument register.
     GPRReg scratch2Reg = regT2;
     ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
-    emitGetVirtualRegister(bytecode.scope.offset(), regT3);
+    emitGetVirtualRegister(bytecode.m_scope.offset(), regT3);
     logShadowChickenProloguePacket(shadowPacketReg, scratch1Reg, regT3);
 }
 
@@ -1480,8 +1480,8 @@ void JIT::emit_op_log_shadow_chicken_tail(const Instruction* currentInstruction)
     GPRReg scratch1Reg = nonArgGPR0; // This must be a non-argument register.
     GPRReg scratch2Reg = regT2;
     ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
-    emitGetVirtualRegister(bytecode.thisValue.offset(), regT2);
-    emitGetVirtualRegister(bytecode.scope.offset(), regT3);
+    emitGetVirtualRegister(bytecode.m_thisValue.offset(), regT2);
+    emitGetVirtualRegister(bytecode.m_scope.offset(), regT3);
     logShadowChickenTailPacket(shadowPacketReg, JSValueRegs(regT2), regT3, m_codeBlock, CallSiteIndex(m_bytecodeOffset));
 }
 
@@ -1491,7 +1491,7 @@ void JIT::emit_op_profile_control_flow(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpProfileControlFlow>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    BasicBlockLocation* basicBlockLocation = metadata.basicBlockLocation;
+    BasicBlockLocation* basicBlockLocation = metadata.m_basicBlockLocation;
 #if USE(JSVALUE64)
     basicBlockLocation->emitExecuteCode(*this);
 #else
@@ -1502,7 +1502,7 @@ void JIT::emit_op_profile_control_flow(const Instruction* currentInstruction)
 void JIT::emit_op_argument_count(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpArgumentCount>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
     load32(payloadFor(CallFrameSlot::argumentCount), regT0);
     sub32(TrustedImm32(1), regT0);
     JSValueRegs result = JSValueRegs::withTwoAvailableRegs(regT0, regT1);
@@ -1513,8 +1513,8 @@ void JIT::emit_op_argument_count(const Instruction* currentInstruction)
 void JIT::emit_op_get_rest_length(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetRestLength>();
-    int dst = bytecode.dst.offset();
-    unsigned numParamsToSkip = bytecode.numParametersToSkip;
+    int dst = bytecode.m_dst.offset();
+    unsigned numParamsToSkip = bytecode.m_numParametersToSkip;
     load32(payloadFor(CallFrameSlot::argumentCount), regT0);
     sub32(TrustedImm32(1), regT0);
     Jump zeroLength = branch32(LessThanOrEqual, regT0, Imm32(numParamsToSkip));
@@ -1543,8 +1543,8 @@ void JIT::emit_op_get_rest_length(const Instruction* currentInstruction)
 void JIT::emit_op_get_argument(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetArgument>();
-    int dst = bytecode.dst.offset();
-    int index = bytecode.index;
+    int dst = bytecode.m_dst.offset();
+    int index = bytecode.m_index;
 #if USE(JSVALUE64)
     JSValueRegs resultRegs(regT0);
 #else
index acdc007..47cce88 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2009-2019 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -50,8 +50,8 @@ namespace JSC {
 void JIT::emit_op_mov(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpMov>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.src.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_src.offset();
     
     if (m_codeBlock->isConstantRegisterIndex(src))
         emitStore(dst, getConstantOperand(src));
@@ -65,7 +65,7 @@ void JIT::emit_op_end(const Instruction* currentInstruction)
 {
     ASSERT(returnValueGPR != callFrameRegister);
     auto bytecode = currentInstruction->as<OpEnd>();
-    emitLoad(bytecode.value.offset(), regT1, returnValueGPR);
+    emitLoad(bytecode.m_value.offset(), regT1, returnValueGPR);
     emitRestoreCalleeSaves();
     emitFunctionEpilogue();
     ret();
@@ -74,7 +74,7 @@ void JIT::emit_op_end(const Instruction* currentInstruction)
 void JIT::emit_op_jmp(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJmp>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     addJump(jump(), target);
 }
 
@@ -82,7 +82,7 @@ void JIT::emit_op_new_object(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNewObject>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    Structure* structure = metadata.objectAllocationProfile.structure();
+    Structure* structure = metadata.m_objectAllocationProfile.structure();
     size_t allocationSize = JSFinalObject::allocationSize(structure->inlineCapacity());
     Allocator allocator = subspaceFor<JSFinalObject>(*m_vm)->allocatorForNonVirtual(allocationSize, AllocatorForMode::AllocatorIfExists);
 
@@ -98,7 +98,7 @@ void JIT::emit_op_new_object(const Instruction* currentInstruction)
         emitAllocateJSObject(resultReg, JITAllocator::constant(allocator), allocatorReg, TrustedImmPtr(structure), butterfly, scratchReg, slowCases);
         emitInitializeInlineStorage(resultReg, structure->inlineCapacity());
         addSlowCase(slowCases);
-        emitStoreCell(bytecode.dst.offset(), resultReg);
+        emitStoreCell(bytecode.m_dst.offset(), resultReg);
     }
 }
 
@@ -108,8 +108,8 @@ void JIT::emitSlow_op_new_object(const Instruction* currentInstruction, Vector<S
 
     auto bytecode = currentInstruction->as<OpNewObject>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    Structure* structure = metadata.objectAllocationProfile.structure();
+    int dst = bytecode.m_dst.offset();
+    Structure* structure = metadata.m_objectAllocationProfile.structure();
     callOperation(operationNewObject, structure);
     emitStoreCell(dst, returnValueGPR);
 }
@@ -117,9 +117,9 @@ void JIT::emitSlow_op_new_object(const Instruction* currentInstruction, Vector<S
 void JIT::emit_op_overrides_has_instance(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpOverridesHasInstance>();
-    int dst = bytecode.dst.offset();
-    int constructor = bytecode.constructor.offset();
-    int hasInstanceValue = bytecode.hasInstanceValue.offset();
+    int dst = bytecode.m_dst.offset();
+    int constructor = bytecode.m_constructor.offset();
+    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
 
     emitLoadPayload(hasInstanceValue, regT0);
     // We don't jump if we know what Symbol.hasInstance would do.
@@ -145,9 +145,9 @@ void JIT::emit_op_overrides_has_instance(const Instruction* currentInstruction)
 void JIT::emit_op_instanceof(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpInstanceof>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.value.offset();
-    int proto = bytecode.prototype.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_value.offset();
+    int proto = bytecode.m_prototype.offset();
 
     // Load the operands into registers.
     // We use regT0 for baseVal since we will be done with this first, and we can then use it for the result.
@@ -182,9 +182,9 @@ void JIT::emitSlow_op_instanceof(const Instruction* currentInstruction, Vector<S
     linkAllSlowCases(iter);
     
     auto bytecode = currentInstruction->as<OpInstanceof>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.value.offset();
-    int proto = bytecode.prototype.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_value.offset();
+    int proto = bytecode.m_prototype.offset();
     
     JITInstanceOfGenerator& gen = m_instanceOfs[m_instanceOfIndex++];
     
@@ -200,10 +200,10 @@ void JIT::emitSlow_op_instanceof_custom(const Instruction* currentInstruction, V
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpInstanceofCustom>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.value.offset();
-    int constructor = bytecode.constructor.offset();
-    int hasInstanceValue = bytecode.hasInstanceValue.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_value.offset();
+    int constructor = bytecode.m_constructor.offset();
+    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
 
     emitLoad(value, regT1, regT0);
     emitLoadPayload(constructor, regT2);
@@ -215,8 +215,8 @@ void JIT::emitSlow_op_instanceof_custom(const Instruction* currentInstruction, V
 void JIT::emit_op_is_empty(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsEmpty>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitLoad(value, regT1, regT0);
     compare32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag), regT0);
@@ -227,8 +227,8 @@ void JIT::emit_op_is_empty(const Instruction* currentInstruction)
 void JIT::emit_op_is_undefined(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsUndefined>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitLoad(value, regT1, regT0);
     Jump isCell = branchIfCell(regT1);
@@ -255,8 +255,8 @@ void JIT::emit_op_is_undefined(const Instruction* currentInstruction)
 void JIT::emit_op_is_undefined_or_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsUndefinedOrNull>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
 
     emitLoadTag(value, regT0);
     static_assert((JSValue::UndefinedTag + 1 == JSValue::NullTag) && (JSValue::NullTag & 0x1), "");
@@ -268,8 +268,8 @@ void JIT::emit_op_is_undefined_or_null(const Instruction* currentInstruction)
 void JIT::emit_op_is_boolean(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsBoolean>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitLoadTag(value, regT0);
     compare32(Equal, regT0, TrustedImm32(JSValue::BooleanTag), regT0);
@@ -279,8 +279,8 @@ void JIT::emit_op_is_boolean(const Instruction* currentInstruction)
 void JIT::emit_op_is_number(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsNumber>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
     
     emitLoadTag(value, regT0);
     add32(TrustedImm32(1), regT0);
@@ -291,9 +291,9 @@ void JIT::emit_op_is_number(const Instruction* currentInstruction)
 void JIT::emit_op_is_cell_with_type(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsCellWithType>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
-    int type = bytecode.type;
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
+    int type = bytecode.m_type;
 
     emitLoad(value, regT1, regT0);
     Jump isNotCell = branchIfNotCell(regT1);
@@ -311,8 +311,8 @@ void JIT::emit_op_is_cell_with_type(const Instruction* currentInstruction)
 void JIT::emit_op_is_object(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpIsObject>();
-    int dst = bytecode.dst.offset();
-    int value = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int value = bytecode.m_operand.offset();
 
     emitLoad(value, regT1, regT0);
     Jump isNotCell = branchIfNotCell(regT1);
@@ -330,8 +330,8 @@ void JIT::emit_op_is_object(const Instruction* currentInstruction)
 void JIT::emit_op_to_primitive(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToPrimitive>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.src.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_src.offset();
 
     emitLoad(src, regT1, regT0);
 
@@ -346,8 +346,8 @@ void JIT::emit_op_to_primitive(const Instruction* currentInstruction)
 void JIT::emit_op_set_function_name(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSetFunctionName>();
-    int func = bytecode.function.offset();
-    int name = bytecode.name.offset();
+    int func = bytecode.m_function.offset();
+    int name = bytecode.m_name.offset();
     emitLoadPayload(func, regT1);
     emitLoad(name, regT3, regT2);
     callOperation(operationSetFunctionName, regT1, JSValueRegs(regT3, regT2));
@@ -356,8 +356,8 @@ void JIT::emit_op_set_function_name(const Instruction* currentInstruction)
 void JIT::emit_op_not(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNot>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_operand.offset();
 
     emitLoadTag(src, regT0);
 
@@ -371,8 +371,8 @@ void JIT::emit_op_not(const Instruction* currentInstruction)
 void JIT::emit_op_jfalse(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJfalse>();
-    int cond = bytecode.condition.offset();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int cond = bytecode.m_condition.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitLoad(cond, regT1, regT0);
 
@@ -386,8 +386,8 @@ void JIT::emit_op_jfalse(const Instruction* currentInstruction)
 void JIT::emit_op_jtrue(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJtrue>();
-    int cond = bytecode.condition.offset();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int cond = bytecode.m_condition.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitLoad(cond, regT1, regT0);
     bool shouldCheckMasqueradesAsUndefined = true;
@@ -400,8 +400,8 @@ void JIT::emit_op_jtrue(const Instruction* currentInstruction)
 void JIT::emit_op_jeq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJeqNull>();
-    int src = bytecode.value.offset();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int src = bytecode.m_value.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitLoad(src, regT1, regT0);
 
@@ -426,8 +426,8 @@ void JIT::emit_op_jeq_null(const Instruction* currentInstruction)
 void JIT::emit_op_jneq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJneqNull>();
-    int src = bytecode.value.offset();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int src = bytecode.m_value.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitLoad(src, regT1, regT0);
 
@@ -453,15 +453,15 @@ void JIT::emit_op_jneq_ptr(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJneqPtr>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int src = bytecode.value.offset();
-    Special::Pointer ptr = bytecode.specialPointer;
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    int src = bytecode.m_value.offset();
+    Special::Pointer ptr = bytecode.m_specialPointer;
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
 
     emitLoad(src, regT1, regT0);
     Jump notCell = branchIfNotCell(regT1);
     Jump equal = branchPtr(Equal, regT0, TrustedImmPtr(actualPointerFor(m_codeBlock, ptr)));
     notCell.link(this);
-    store8(TrustedImm32(1), &metadata.hasJumped);
+    store8(TrustedImm32(1), &metadata.m_hasJumped);
     addJump(jump(), target);
     equal.link(this);
 }
@@ -470,9 +470,9 @@ void JIT::emit_op_eq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEq>();
 
-    int dst = bytecode.dst.offset();
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
     addSlowCase(branch32(NotEqual, regT1, regT3));
@@ -487,7 +487,7 @@ void JIT::emit_op_eq(const Instruction* currentInstruction)
 void JIT::emitSlow_op_eq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = currentInstruction->as<OpEq>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
 
     JumpList storeResult;
     JumpList genericCase;
@@ -514,9 +514,9 @@ void JIT::emitSlow_op_eq(const Instruction* currentInstruction, Vector<SlowCaseE
 void JIT::emit_op_jeq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJeq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
     addSlowCase(branch32(NotEqual, regT1, regT3));
@@ -554,16 +554,16 @@ void JIT::compileOpEqJumpSlow(Vector<SlowCaseEntry>::iterator& iter, CompileOpEq
 void JIT::emitSlow_op_jeq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = currentInstruction->as<OpJeq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     compileOpEqJumpSlow(iter, CompileOpEqType::Eq, target);
 }
 
 void JIT::emit_op_neq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNeq>();
-    int dst = bytecode.dst.offset();
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
     addSlowCase(branch32(NotEqual, regT1, regT3));
@@ -578,7 +578,7 @@ void JIT::emit_op_neq(const Instruction* currentInstruction)
 void JIT::emitSlow_op_neq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = currentInstruction->as<OpNeq>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
 
     JumpList storeResult;
     JumpList genericCase;
@@ -606,9 +606,9 @@ void JIT::emitSlow_op_neq(const Instruction* currentInstruction, Vector<SlowCase
 void JIT::emit_op_jneq(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpJneq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
     addSlowCase(branch32(NotEqual, regT1, regT3));
@@ -621,7 +621,7 @@ void JIT::emit_op_jneq(const Instruction* currentInstruction)
 void JIT::emitSlow_op_jneq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = currentInstruction->as<OpJneq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     compileOpEqJumpSlow(iter, CompileOpEqType::NEq, target);
 }
 
@@ -629,9 +629,9 @@ template <typename Op>
 void JIT::compileOpStrictEq(const Instruction* currentInstruction, CompileOpStrictEqType type)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int dst = bytecode.dst.offset();
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    int dst = bytecode.m_dst.offset();
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
 
@@ -669,9 +669,9 @@ template<typename Op>
 void JIT::compileOpStrictEqJump(const Instruction* currentInstruction, CompileOpStrictEqType type)
 {
     auto bytecode = currentInstruction->as<Op>();
-    int target = jumpTarget(currentInstruction, bytecode.target);
-    int src1 = bytecode.lhs.offset();
-    int src2 = bytecode.rhs.offset();
+    int target = jumpTarget(currentInstruction, bytecode.m_target);
+    int src1 = bytecode.m_lhs.offset();
+    int src2 = bytecode.m_rhs.offset();
 
     emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
 
@@ -708,7 +708,7 @@ void JIT::emitSlow_op_jstricteq(const Instruction* currentInstruction, Vector<Sl
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpJstricteq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     callOperation(operationCompareStrictEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
     emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
 }
@@ -718,7 +718,7 @@ void JIT::emitSlow_op_jnstricteq(const Instruction* currentInstruction, Vector<S
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpJnstricteq>();
-    unsigned target = jumpTarget(currentInstruction, bytecode.target);
+    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     callOperation(operationCompareStrictEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
     emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
 }
@@ -726,8 +726,8 @@ void JIT::emitSlow_op_jnstricteq(const Instruction* currentInstruction, Vector<S
 void JIT::emit_op_eq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEqNull>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_operand.offset();
 
     emitLoad(src, regT1, regT0);
     Jump isImmediate = branchIfNotCell(regT1);
@@ -758,8 +758,8 @@ void JIT::emit_op_eq_null(const Instruction* currentInstruction)
 void JIT::emit_op_neq_null(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpNeqNull>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_operand.offset();
 
     emitLoad(src, regT1, regT0);
     Jump isImmediate = branchIfNotCell(regT1);
@@ -792,7 +792,7 @@ void JIT::emit_op_throw(const Instruction* currentInstruction)
     auto bytecode = currentInstruction->as<OpThrow>();
     ASSERT(regT0 == returnValueGPR);
     copyCalleeSavesToEntryFrameCalleeSavesBuffer(vm()->topEntryFrame);
-    emitLoad(bytecode.value.offset(), regT1, regT0);
+    emitLoad(bytecode.m_value.offset(), regT1, regT0);
     callOperationNoExceptionCheck(operationThrow, JSValueRegs(regT1, regT0));
     jumpToExceptionHandler(*vm());
 }
@@ -800,8 +800,8 @@ void JIT::emit_op_throw(const Instruction* currentInstruction)
 void JIT::emit_op_to_number(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToNumber>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_operand.offset();
 
     emitLoad(src, regT1, regT0);
 
@@ -817,8 +817,8 @@ void JIT::emit_op_to_number(const Instruction* currentInstruction)
 void JIT::emit_op_to_string(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToString>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_operand.offset();
 
     emitLoad(src, regT1, regT0);
 
@@ -832,8 +832,8 @@ void JIT::emit_op_to_string(const Instruction* currentInstruction)
 void JIT::emit_op_to_object(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToObject>();
-    int dst = bytecode.dst.offset();
-    int src = bytecode.operand.offset();
+    int dst = bytecode.m_dst.offset();
+    int src = bytecode.m_operand.offset();
 
     emitLoad(src, regT1, regT0);
 
@@ -871,13 +871,13 @@ void JIT::emit_op_catch(const Instruction* currentInstruction)
 
     store32(TrustedImm32(0), Address(regT3, VM::exceptionOffset()));
 
-    unsigned exception = bytecode.exception.offset();
+    unsigned exception = bytecode.m_exception.offset();
     emitStore(exception, regT1, regT2);
 
     load32(Address(regT2, Exception::valueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
     load32(Address(regT2, Exception::valueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
 
-    unsigned thrownValue = bytecode.thrownValue.offset();
+    unsigned thrownValue = bytecode.m_thrownValue.offset();
     emitStore(thrownValue, regT1, regT0);
 
 #if ENABLE(DFG_JIT)
@@ -886,7 +886,7 @@ void JIT::emit_op_catch(const Instruction* currentInstruction)
     // https://bugs.webkit.org/show_bug.cgi?id=175598
 
     auto& metadata = bytecode.metadata(m_codeBlock);
-    ValueProfileAndOperandBuffer* buffer = metadata.buffer;
+    ValueProfileAndOperandBuffer* buffer = metadata.m_buffer;
     if (buffer || !shouldEmitProfiling())
         callOperation(operationTryOSREnterAtCatch, m_bytecodeOffset);
     else
@@ -913,18 +913,18 @@ void JIT::emit_op_identity_with_profile(const Instruction*)
 void JIT::emit_op_get_parent_scope(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetParentScope>();
-    int currentScope = bytecode.scope.offset();
+    int currentScope = bytecode.m_scope.offset();
     emitLoadPayload(currentScope, regT0);
     loadPtr(Address(regT0, JSScope::offsetOfNext()), regT0);
-    emitStoreCell(bytecode.dst.offset(), regT0);
+    emitStoreCell(bytecode.m_dst.offset(), regT0);
 }
 
 void JIT::emit_op_switch_imm(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSwitchImm>();
-    size_t tableIndex = bytecode.tableIndex;
-    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
-    unsigned scrutinee = bytecode.scrutinee.offset();
+    size_t tableIndex = bytecode.m_tableIndex;
+    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
+    unsigned scrutinee = bytecode.m_scrutinee.offset();
 
     // create jump table for switch destinations, track this switch statement.
     SimpleJumpTable* jumpTable = &m_codeBlock->switchJumpTable(tableIndex);
@@ -939,9 +939,9 @@ void JIT::emit_op_switch_imm(const Instruction* currentInstruction)
 void JIT::emit_op_switch_char(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSwitchChar>();
-    size_t tableIndex = bytecode.tableIndex;
-    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
-    unsigned scrutinee = bytecode.scrutinee.offset();
+    size_t tableIndex = bytecode.m_tableIndex;
+    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
+    unsigned scrutinee = bytecode.m_scrutinee.offset();
 
     // create jump table for switch destinations, track this switch statement.
     SimpleJumpTable* jumpTable = &m_codeBlock->switchJumpTable(tableIndex);
@@ -956,9 +956,9 @@ void JIT::emit_op_switch_char(const Instruction* currentInstruction)
 void JIT::emit_op_switch_string(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpSwitchString>();
-    size_t tableIndex = bytecode.tableIndex;
-    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
-    unsigned scrutinee = bytecode.scrutinee.offset();
+    size_t tableIndex = bytecode.m_tableIndex;
+    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
+    unsigned scrutinee = bytecode.m_scrutinee.offset();
 
     // create jump table for switch destinations, track this switch statement.
     StringJumpTable* jumpTable = &m_codeBlock->stringSwitchJumpTable(tableIndex);
@@ -974,7 +974,7 @@ void JIT::emit_op_debug(const Instruction* currentInstruction)
     auto bytecode = currentInstruction->as<OpDebug>();
     load32(codeBlock()->debuggerRequestsAddress(), regT0);
     Jump noDebuggerRequests = branchTest32(Zero, regT0);
-    callOperation(operationDebug, static_cast<int>(bytecode.debugHookType));
+    callOperation(operationDebug, static_cast<int>(bytecode.m_debugHookType));
     noDebuggerRequests.link(this);
 }
 
@@ -996,7 +996,7 @@ void JIT::emit_op_enter(const Instruction* currentInstruction)
 void JIT::emit_op_get_scope(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetScope>();
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
     emitGetFromCallFrameHeaderPtr(CallFrameSlot::callee, regT0);
     loadPtr(Address(regT0, JSFunction::offsetOfScopeChain()), regT0);
     emitStoreCell(dst, regT0);
@@ -1006,8 +1006,8 @@ void JIT::emit_op_create_this(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpCreateThis>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int callee = bytecode.callee.offset();
-    WriteBarrierBase<JSCell>* cachedFunction = &metadata.cachedCallee;
+    int callee = bytecode.m_callee.offset();
+    WriteBarrierBase<JSCell>* cachedFunction = &metadata.m_cachedCallee;
     RegisterID calleeReg = regT0;
     RegisterID rareDataReg = regT4;
     RegisterID resultReg = regT0;
@@ -1036,15 +1036,15 @@ void JIT::emit_op_create_this(const Instruction* currentInstruction)
     load32(Address(scratchReg, FunctionRareData::offsetOfObjectAllocationProfile() + ObjectAllocationProfile::offsetOfInlineCapacity()), scratchReg);
     emitInitializeInlineStorage(resultReg, scratchReg);
     addSlowCase(slowCases);
-    emitStoreCell(bytecode.dst.offset(), resultReg);
+    emitStoreCell(bytecode.m_dst.offset(), resultReg);
 }
 
 void JIT::emit_op_to_this(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpToThis>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    WriteBarrierBase<Structure>* cachedStructure = &metadata.cachedStructure;
-    int thisRegister = bytecode.srcDst.offset();
+    WriteBarrierBase<Structure>* cachedStructure = &metadata.m_cachedStructure;
+    int thisRegister = bytecode.m_srcDst.offset();
 
     emitLoad(thisRegister, regT3, regT2);
 
@@ -1058,16 +1058,16 @@ void JIT::emit_op_to_this(const Instruction* currentInstruction)
 void JIT::emit_op_check_tdz(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpCheckTdz>();
-    emitLoadTag(bytecode.target.offset(), regT0);
+    emitLoadTag(bytecode.m_target.offset(), regT0);
     addSlowCase(branchIfEmpty(regT0));
 }
 
 void JIT::emit_op_has_structure_property(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpHasStructureProperty>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int enumerator = bytecode.enumerator.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int enumerator = bytecode.m_enumerator.offset();
 
     emitLoadPayload(base, regT0);
     emitJumpSlowCaseIfNotJSCell(base);
@@ -1112,10 +1112,10 @@ void JIT::emit_op_has_indexed_property(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
-    ArrayProfile* profile = &metadata.arrayProfile;
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
+    ArrayProfile* profile = &metadata.m_arrayProfile;
     ByValInfo* byValInfo = m_codeBlock->addByValInfo();
     
     emitLoadPayload(base, regT0);
@@ -1159,9 +1159,9 @@ void JIT::emitSlow_op_has_indexed_property(const Instruction* currentInstruction
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
     ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
 
     Label slowPath = label();
@@ -1178,10 +1178,10 @@ void JIT::emitSlow_op_has_indexed_property(const Instruction* currentInstruction
 void JIT::emit_op_get_direct_pname(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetDirectPname>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int index = bytecode.index.offset();
-    int enumerator = bytecode.enumerator.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int index = bytecode.m_index.offset();
+    int enumerator = bytecode.m_enumerator.offset();
 
     // Check that base is a cell
     emitLoadPayload(base, regT0);
@@ -1219,9 +1219,9 @@ void JIT::emit_op_get_direct_pname(const Instruction* currentInstruction)
 void JIT::emit_op_enumerator_structure_pname(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEnumeratorStructurePname>();
-    int dst = bytecode.dst.offset();
-    int enumerator = bytecode.enumerator.offset();
-    int index = bytecode.index.offset();
+    int dst = bytecode.m_dst.offset();
+    int enumerator = bytecode.m_enumerator.offset();
+    int index = bytecode.m_index.offset();
 
     emitLoadPayload(index, regT0);
     emitLoadPayload(enumerator, regT1);
@@ -1244,9 +1244,9 @@ void JIT::emit_op_enumerator_structure_pname(const Instruction* currentInstructi
 void JIT::emit_op_enumerator_generic_pname(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpEnumeratorGenericPname>();
-    int dst = bytecode.dst.offset();
-    int enumerator = bytecode.enumerator.offset();
-    int index = bytecode.index.offset();
+    int dst = bytecode.m_dst.offset();
+    int enumerator = bytecode.m_enumerator.offset();
+    int index = bytecode.m_index.offset();
 
     emitLoadPayload(index, regT0);
     emitLoadPayload(enumerator, regT1);
@@ -1270,8 +1270,8 @@ void JIT::emit_op_profile_type(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpProfileType>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    TypeLocation* cachedTypeLocation = metadata.typeLocation;
-    int valueToProfile = bytecode.target.offset();
+    TypeLocation* cachedTypeLocation = metadata.m_typeLocation;
+    int valueToProfile = bytecode.m_target.offset();
 
     // Load payload in T0. Load tag in T3.
     emitLoadPayload(valueToProfile, regT0);
@@ -1344,7 +1344,7 @@ void JIT::emit_op_log_shadow_chicken_prologue(const Instruction* currentInstruct
     ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
 
     scratch1Reg = regT4;
-    emitLoadPayload(bytecode.scope.offset(), regT3);
+    emitLoadPayload(bytecode.m_scope.offset(), regT3);
     logShadowChickenProloguePacket(shadowPacketReg, scratch1Reg, regT3);
 }
 
@@ -1357,10 +1357,10 @@ void JIT::emit_op_log_shadow_chicken_tail(const Instruction* currentInstruction)
     GPRReg scratch1Reg = nonArgGPR0; // This must be a non-argument register.
     GPRReg scratch2Reg = regT2;
     ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
-    emitLoadPayload(bytecode.thisValue.offset(), regT2);
-    emitLoadTag(bytecode.thisValue.offset(), regT1);
+    emitLoadPayload(bytecode.m_thisValue.offset(), regT2);
+    emitLoadTag(bytecode.m_thisValue.offset(), regT1);
     JSValueRegs thisRegs(regT1, regT2);
-    emitLoadPayload(bytecode.scope.offset(), regT3);
+    emitLoadPayload(bytecode.m_scope.offset(), regT3);
     logShadowChickenTailPacket(shadowPacketReg, thisRegs, regT3, m_codeBlock, CallSiteIndex(currentInstruction));
 }
 
index d57b857..95bfb81 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -1661,7 +1661,7 @@ char* JIT_OPERATION operationTryOSREnterAtCatchAndValueProfile(ExecState* exec,
     codeBlock->ensureCatchLivenessIsComputedForBytecodeOffset(bytecodeIndex);
     auto bytecode = codeBlock->instructions().at(bytecodeIndex)->as<OpCatch>();
     auto& metadata = bytecode.metadata(codeBlock);
-    metadata.buffer->forEach([&] (ValueProfileAndOperand& profile) {
+    metadata.m_buffer->forEach([&] (ValueProfileAndOperand& profile) {
         profile.m_profile.m_buckets[0] = JSValue::encode(exec->uncheckedR(profile.m_operand).jsValue());
     });
 
@@ -2292,9 +2292,9 @@ EncodedJSValue JIT_OPERATION operationGetFromScope(ExecState* exec, const Instru
     CodeBlock* codeBlock = exec->codeBlock();
 
     auto bytecode = pc->as<OpGetFromScope>();
-    const Identifier& ident = codeBlock->identifier(bytecode.var);
-    JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.scope.offset()).jsValue());
-    GetPutInfo& getPutInfo = bytecode.metadata(codeBlock).getPutInfo;
+    const Identifier& ident = codeBlock->identifier(bytecode.m_var);
+    JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.m_scope.offset()).jsValue());
+    GetPutInfo& getPutInfo = bytecode.metadata(codeBlock).m_getPutInfo;
 
     // ModuleVar is always converted to ClosureVar for get_from_scope.
     ASSERT(getPutInfo.resolveType() != ModuleVar);
@@ -2334,18 +2334,18 @@ void JIT_OPERATION operationPutToScope(ExecState* exec, const Instruction* pc)
     auto bytecode = pc->as<OpPutToScope>();
     auto& metadata = bytecode.metadata(codeBlock);
 
-    const Identifier& ident = codeBlock->identifier(bytecode.var);
-    JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.scope.offset()).jsValue());
-    JSValue value = exec->r(bytecode.value.offset()).jsValue();
-    GetPutInfo& getPutInfo = metadata.getPutInfo;
+    const Identifier& ident = codeBlock->identifier(bytecode.m_var);
+    JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.m_scope.offset()).jsValue());
+    JSValue value = exec->r(bytecode.m_value.offset()).jsValue();
+    GetPutInfo& getPutInfo = metadata.m_getPutInfo;
 
     // ModuleVar does not keep the scope register value alive in DFG.
     ASSERT(getPutInfo.resolveType() != ModuleVar);
 
     if (getPutInfo.resolveType() == LocalClosureVar) {
         JSLexicalEnvironment* environment = jsCast<JSLexicalEnvironment*>(scope);
-        environment->variableAt(ScopeOffset(metadata.operand)).set(vm, environment, value);
-        if (WatchpointSet* set = metadata.watchpointSet)
+        environment->variableAt(ScopeOffset(metadata.m_operand)).set(vm, environment, value);
+        if (WatchpointSet* set = metadata.m_watchpointSet)
             set->touch(vm, "Executed op_put_scope<LocalClosureVar>");
         return;
     }
index 7be95f8..92f37ec 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -55,10 +55,10 @@ void JIT::emit_op_get_by_val(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetByVal>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
-    ArrayProfile* profile = &metadata.arrayProfile;
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
+    ArrayProfile* profile = &metadata.m_arrayProfile;
     ByValInfo* byValInfo = m_codeBlock->addByValInfo();
 
     emitGetVirtualRegister(base, regT0);
@@ -134,7 +134,7 @@ JITGetByIdGenerator JIT::emitGetByValWithCachedId(ByValInfo* byValInfo, OpGetByV
     // property: regT1
     // scratch: regT3
 
-    int dst = bytecode.dst.offset();
+    int dst = bytecode.m_dst.offset();
 
     slowCases.append(branchIfNotCell(regT1));
     emitByValIdentifierCheck(byValInfo, regT1, regT3, propertyName, slowCases);
@@ -159,9 +159,9 @@ JITGetByIdGenerator JIT::emitGetByValWithCachedId(ByValInfo* byValInfo, OpGetByV
 void JIT::emitSlow_op_get_by_val(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     auto bytecode = currentInstruction->as<OpGetByVal>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
     ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
     
     linkSlowCaseIfNotJSCell(iter, base); // base cell check
@@ -205,9 +205,9 @@ void JIT::emit_op_put_by_val(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<Op>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
-    ArrayProfile* profile = &metadata.arrayProfile;
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
+    ArrayProfile* profile = &metadata.m_arrayProfile;
     ByValInfo* byValInfo = m_codeBlock->addByValInfo();
 
     emitGetVirtualRegister(base, regT0);
@@ -265,8 +265,8 @@ template<typename Op>
 JIT::JumpList JIT::emitGenericContiguousPutByVal(Op bytecode, PatchableJump& badType, IndexingType indexingShape)
 {
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int value = bytecode.value.offset();
-    ArrayProfile* profile = &metadata.arrayProfile;
+    int value = bytecode.m_value.offset();
+    ArrayProfile* profile = &metadata.m_arrayProfile;
     
     JumpList slowCases;
 
@@ -296,7 +296,7 @@ JIT::JumpList JIT::emitGenericContiguousPutByVal(Op bytecode, PatchableJump& bad
     }
     case ContiguousShape:
         store64(regT3, BaseIndex(regT2, regT1, TimesEight));
-        emitWriteBarrier(bytecode.base.offset(), value, ShouldFilterValue);
+        emitWriteBarrier(bytecode.m_base.offset(), value, ShouldFilterValue);
         break;
     default:
         CRASH();
@@ -323,8 +323,8 @@ template<typename Op>
 JIT::JumpList JIT::emitArrayStoragePutByVal(Op bytecode, PatchableJump& badType)
 {
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int value = bytecode.value.offset();
-    ArrayProfile* profile = &metadata.arrayProfile;
+    int value = bytecode.m_value.offset();
+    ArrayProfile* profile = &metadata.m_arrayProfile;
     
     JumpList slowCases;
     
@@ -337,7 +337,7 @@ JIT::JumpList JIT::emitArrayStoragePutByVal(Op bytecode, PatchableJump& badType)
     Label storeResult(this);
     emitGetVirtualRegister(value, regT3);
     store64(regT3, BaseIndex(regT2, regT1, TimesEight, ArrayStorage::vectorOffset()));
-    emitWriteBarrier(bytecode.base.offset(), value, ShouldFilterValue);
+    emitWriteBarrier(bytecode.m_base.offset(), value, ShouldFilterValue);
     Jump end = jump();
     
     empty.link(this);
@@ -362,8 +362,8 @@ JITPutByIdGenerator JIT::emitPutByValWithCachedId(ByValInfo* byValInfo, Op bytec
     // property: regT1
     // scratch: regT2
 
-    int base = bytecode.base.offset();
-    int value = bytecode.value.offset();
+    int base = bytecode.m_base.offset();
+    int value = bytecode.m_value.offset();
 
     slowCases.append(branchIfNotCell(regT1));
     emitByValIdentifierCheck(byValInfo, regT1, regT1, propertyName, slowCases);
@@ -397,9 +397,9 @@ void JIT::emitSlow_op_put_by_val(const Instruction* currentInstruction, Vector<S
     int value;
 
     auto load = [&](auto bytecode) {
-        base = bytecode.base.offset();
-        property = bytecode.property.offset();
-        value = bytecode.value.offset();
+        base = bytecode.m_base.offset();
+        property = bytecode.m_property.offset();
+        value = bytecode.m_value.offset();
     };
 
     if (isDirect)
@@ -425,57 +425,57 @@ void JIT::emitSlow_op_put_by_val(const Instruction* currentInstruction, Vector<S
 void JIT::emit_op_put_getter_by_id(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpPutGetterById>();
-    emitGetVirtualRegister(bytecode.base.offset(), regT0);
-    int32_t options = bytecode.attributes;
-    emitGetVirtualRegister(bytecode.accessor.offset(), regT1);
-    callOperation(operationPutGetterById, regT0, m_codeBlock->identifier(bytecode.property).impl(), options, regT1);
+    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
+    int32_t options = bytecode.m_attributes;
+    emitGetVirtualRegister(bytecode.m_accessor.offset(), regT1);
+    callOperation(operationPutGetterById, regT0, m_codeBlock->identifier(bytecode.m_property).impl(), options, regT1);
 }
 
 void JIT::emit_op_put_setter_by_id(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpPutSetterById>();
-    emitGetVirtualRegister(bytecode.base.offset(), regT0);
-    int32_t options = bytecode.attributes;
-    emitGetVirtualRegister(bytecode.accessor.offset(), regT1);
-    callOperation(operationPutSetterById, regT0, m_codeBlock->identifier(bytecode.property).impl(), options, regT1);
+    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
+    int32_t options = bytecode.m_attributes;
+    emitGetVirtualRegister(bytecode.m_accessor.offset(), regT1);
+    callOperation(operationPutSetterById, regT0, m_codeBlock->identifier(bytecode.m_property).impl(), options, regT1);
 }
 
 void JIT::emit_op_put_getter_setter_by_id(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpPutGetterSetterById>();
-    emitGetVirtualRegister(bytecode.base.offset(), regT0);
-    int32_t attribute = bytecode.attributes;
-    emitGetVirtualRegister(bytecode.getter.offset(), regT1);
-    emitGetVirtualRegister(bytecode.setter.offset(), regT2);
-    callOperation(operationPutGetterSetter, regT0, m_codeBlock->identifier(bytecode.property).impl(), attribute, regT1, regT2);
+    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
+    int32_t attribute = bytecode.m_attributes;
+    emitGetVirtualRegister(bytecode.m_getter.offset(), regT1);
+    emitGetVirtualRegister(bytecode.m_setter.offset(), regT2);
+    callOperation(operationPutGetterSetter, regT0, m_codeBlock->identifier(bytecode.m_property).impl(), attribute, regT1, regT2);
 }
 
 void JIT::emit_op_put_getter_by_val(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpPutGetterByVal>();
-    emitGetVirtualRegister(bytecode.base.offset(), regT0);
-    emitGetVirtualRegister(bytecode.property.offset(), regT1);
-    int32_t attributes = bytecode.attributes;
-    emitGetVirtualRegister(bytecode.accessor, regT2);
+    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_property.offset(), regT1);
+    int32_t attributes = bytecode.m_attributes;
+    emitGetVirtualRegister(bytecode.m_accessor, regT2);
     callOperation(operationPutGetterByVal, regT0, regT1, attributes, regT2);
 }
 
 void JIT::emit_op_put_setter_by_val(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpPutSetterByVal>();
-    emitGetVirtualRegister(bytecode.base.offset(), regT0);
-    emitGetVirtualRegister(bytecode.property.offset(), regT1);
-    int32_t attributes = bytecode.attributes;
-    emitGetVirtualRegister(bytecode.accessor.offset(), regT2);
+    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
+    emitGetVirtualRegister(bytecode.m_property.offset(), regT1);
+    int32_t attributes = bytecode.m_attributes;
+    emitGetVirtualRegister(bytecode.m_accessor.offset(), regT2);
     callOperation(operationPutSetterByVal, regT0, regT1, attributes, regT2);
 }
 
 void JIT::emit_op_del_by_id(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpDelById>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property;
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property;
     emitGetVirtualRegister(base, regT0);
     callOperation(operationDeleteByIdJSResult, dst, regT0, m_codeBlock->identifier(property).impl());
 }
@@ -483,9 +483,9 @@ void JIT::emit_op_del_by_id(const Instruction* currentInstruction)
 void JIT::emit_op_del_by_val(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpDelByVal>();
-    int dst = bytecode.dst.offset();
-    int base = bytecode.base.offset();
-    int property = bytecode.property.offset();
+    int dst = bytecode.m_dst.offset();
+    int base = bytecode.m_base.offset();
+    int property = bytecode.m_property.offset();
     emitGetVirtualRegister(base, regT0);
     emitGetVirtualRegister(property, regT1);
     callOperation(operationDeleteByValJSResult, dst, regT0, regT1);
@@ -494,9 +494,9 @@ void JIT::emit_op_del_by_val(const Instruction* currentInstruction)
 void JIT::emit_op_try_get_by_id(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpTryGetById>();
-    int resultVReg = bytecode.dst.offset();
-    int baseVReg = bytecode.base.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    int baseVReg = bytecode.m_base.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     emitGetVirtualRegister(baseVReg, regT0);
 
@@ -518,8 +518,8 @@ void JIT::emitSlow_op_try_get_by_id(const Instruction* currentInstruction, Vecto
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpTryGetById>();
-    int resultVReg = bytecode.dst.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
 
@@ -533,9 +533,9 @@ void JIT::emitSlow_op_try_get_by_id(const Instruction* currentInstruction, Vecto
 void JIT::emit_op_get_by_id_direct(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetByIdDirect>();
-    int resultVReg = bytecode.dst.offset();
-    int baseVReg = bytecode.base.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    int baseVReg = bytecode.m_base.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     emitGetVirtualRegister(baseVReg, regT0);
 
@@ -557,8 +557,8 @@ void JIT::emitSlow_op_get_by_id_direct(const Instruction* currentInstruction, Ve
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpGetByIdDirect>();
-    int resultVReg = bytecode.dst.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
 
@@ -573,17 +573,17 @@ void JIT::emit_op_get_by_id(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetById>();
     auto& metadata = bytecode.metadata(m_codeBlock);
-    int resultVReg = bytecode.dst.offset();
-    int baseVReg = bytecode.base.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    int baseVReg = bytecode.m_base.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     emitGetVirtualRegister(baseVReg, regT0);
     
     emitJumpSlowCaseIfNotJSCell(regT0, baseVReg);
     
     if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
-        Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
-        emitArrayProfilingSiteWithCell(regT0, regT1, &metadata.modeMetadata.arrayLengthMode.arrayProfile);
+        Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.m_mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
+        emitArrayProfilingSiteWithCell(regT0, regT1, &metadata.m_modeMetadata.arrayLengthMode.arrayProfile);
         notArrayLengthMode.link(this);
     }
 
@@ -601,10 +601,10 @@ void JIT::emit_op_get_by_id(const Instruction* currentInstruction)
 void JIT::emit_op_get_by_id_with_this(const Instruction* currentInstruction)
 {
     auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
-    int resultVReg = bytecode.dst.offset();
-    int baseVReg = bytecode.base.offset();
-    int thisVReg = bytecode.thisValue.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    int baseVReg = bytecode.m_base.offset();
+    int thisVReg = bytecode.m_thisValue.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     emitGetVirtualRegister(baseVReg, regT0);
     emitGetVirtualRegister(thisVReg, regT1);
@@ -627,8 +627,8 @@ void JIT::emitSlow_op_get_by_id(const Instruction* currentInstruction, Vector<Sl
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpGetById>();
-    int resultVReg = bytecode.dst.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
     
@@ -644,8 +644,8 @@ void JIT::emitSlow_op_get_by_id_with_this(const Instruction* currentInstruction,
     linkAllSlowCases(iter);
 
     auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
-    int resultVReg = bytecode.dst.offset();
-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
+    int resultVReg = bytecode.m_dst.offset();
+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
 
     JITGetByIdWithThisGenerator& gen = m_getByIdsWithThis[m_getByIdWithThisIndex++];