Attachment 359210 Details for Bug 193467 – proposed patch.

[patch] proposed patch.

bug-193467.patch (text/plain), 519.40 KB, created by Mark Lam on 2019-01-15 15:13:17 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Mark Lam

Created: 2019-01-15 15:13:17 PST

Size: 519.40 KB

patch

obsolete

>Index: Source/JavaScriptCore/ChangeLog
>===================================================================
>--- Source/JavaScriptCore/ChangeLog	(revision 240011)
>+++ Source/JavaScriptCore/ChangeLog	(working copy)
>@@ -1,3 +1,340 @@
>+2019-01-15  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 NOBODY (OOPS!).
>+
>+        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/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::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  Tomas Popela  <tpopela@redhat.com>
> 
>         Unreviewed: Fix the -Wformat compiler warnings
>Index: Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp	(working copy)
>@@ -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: Source/JavaScriptCore/bytecode/BytecodeUseDef.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/BytecodeUseDef.h	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/BytecodeUseDef.h	(working copy)
>@@ -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*
>         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*
> 
>     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: Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/CallLinkStatus.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/CallLinkStatus.cpp	(working copy)
>@@ -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::computeFr
>     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: Source/JavaScriptCore/bytecode/CodeBlock.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/CodeBlock.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/CodeBlock.cpp	(working copy)
>@@ -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, S
> 
>     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, S
>         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, S
>             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, S
>             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, S
>                 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, S
>             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(con
>             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::finalizeLLIntInlineCache
>     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::finalizeLLIntInlineCache
>         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::finalizeLLIntInlineCache
>         }
>         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::finalizeLLIntInlineCache
>             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::finalizeLLIntInlineCache
>             // 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::ensureCatchLivenessIsCom
>     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::ensureCatchLivenessIsCom
>     // 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
>     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
>     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::notifyLexicalBindingShad
>         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::notifyLexicalBindingShad
>         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::notifyLexicalBindingShad
>         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::tryGetValueProf
> 
> #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::arithProfileFor
> {
>     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::insertBasicBlockBoundari
>         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::insertBasicBlockBoundari
>         // 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::insertBasicBlockBoundari
>         for (const WriteBarrier<FunctionExecutable>& executable : m_functionExprs)
>             insertFunctionGaps(executable);
> 
>-        metadata.basicBlockLocation = basicBlockLocation;
>+        metadata.m_basicBlockLocation = basicBlockLocation;
>     }
> }
> 
>Index: Source/JavaScriptCore/bytecode/CodeBlockInlines.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/CodeBlockInlines.h	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/CodeBlockInlines.h	(working copy)
>@@ -39,7 +39,7 @@ void CodeBlock::forEachValueProfile(cons
> 
>     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(cons
> {
>     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::forEachArrayAllocationPr
> {
>     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::forEachObjectAllocationP
> {
>     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
> {
>     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: Source/JavaScriptCore/bytecode/GetByIdStatus.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/GetByIdStatus.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/GetByIdStatus.cpp	(working copy)
>@@ -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::computeFrom
>         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: Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp	(working copy)
>@@ -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 LLIntPrototypeLoadAdaptiveStructure
> 
> 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: Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h	(working copy)
>@@ -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 extractStoredJumpTargetsForI
>     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 updateStoredJumpTargetsForIn
> 
> #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: Source/JavaScriptCore/bytecode/PutByIdStatus.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/PutByIdStatus.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/PutByIdStatus.cpp	(working copy)
>@@ -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
>@@ -54,13 +54,13 @@ PutByIdStatus PutByIdStatus::computeFrom
>     auto instruction = profiledBlock->instructions().at(bytecodeIndex);
>     auto& metadata = instruction->as<OpPutById>().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))
>@@ -78,7 +78,7 @@ PutByIdStatus PutByIdStatus::computeFrom
>         return PutByIdStatus(NoInformation);
>     
>     ObjectPropertyConditionSet conditionSet;
>-    if (!(metadata.flags & PutByIdIsDirect)) {
>+    if (!(metadata.m_flags & PutByIdIsDirect)) {
>         conditionSet =
>             generateConditionsForPropertySetterMissConcurrently(
>                 vm, profiledBlock->globalObject(), structure, uid);
>Index: Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.cpp	(working copy)
>@@ -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 i
>     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: Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp	(revision 239990)
>+++ Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp	(working copy)
>@@ -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 JmpO
> 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::emitEqual
> {
>     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
>             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
>             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(Byt
>         // 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: Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp	(revision 239990)
>+++ Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp	(working copy)
>@@ -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 ByteCodePars
> 
>     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 ByteCodePars
>     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 ByteCodePars
>     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 ByteCodePars
>     }
> 
>     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;
> }
> 
>@@ -4596,8 +4596,8 @@ void ByteCodeParser::parseGetById(const 
>     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(
>@@ -4613,7 +4613,7 @@ void ByteCodeParser::parseGetById(const 
>         type = AccessType::GetDirect;
> 
>     handleGetById(
>-        bytecode.dst, prediction, base, identifierNumber, getByIdStatus, type, opcodeLength);
>+        bytecode.m_dst, prediction, base, identifierNumber, getByIdStatus, type, opcodeLength);
> 
> }
> 
>@@ -4750,8 +4750,8 @@ void ByteCodeParser::parseBlock(unsigned
>             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)
>@@ -4770,11 +4770,11 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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)) {
>@@ -4813,66 +4813,66 @@ void ByteCodeParser::parseBlock(unsigned
>                                 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);
>         }
>             
>@@ -4881,22 +4881,22 @@ void ByteCodeParser::parseBlock(unsigned
>             // 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);
>         }
> 
>@@ -4907,24 +4907,24 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
>             
>@@ -4932,74 +4932,74 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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));
>+                set(bytecode.m_dst, addToGraph(ValueBitXor, OpInfo(), OpInfo(prediction), op1, op2));
>             NEXT_OPCODE(op_bitor);
>         }
> 
>         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);
>         }
> 
>@@ -5007,15 +5007,15 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>         }
> 
>@@ -5023,53 +5023,53 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>         }
> 
>@@ -5077,20 +5077,20 @@ void ByteCodeParser::parseBlock(unsigned
>             // 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);
>         }
> 
>@@ -5105,14 +5105,14 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>         }
> 
>@@ -5120,18 +5120,18 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
> 
>@@ -5142,8 +5142,8 @@ void ByteCodeParser::parseBlock(unsigned
>                 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)
>@@ -5171,102 +5171,102 @@ void ByteCodeParser::parseBlock(unsigned
>                 
>                 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,
>@@ -5291,105 +5291,105 @@ void ByteCodeParser::parseBlock(unsigned
>                 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);
>         }
> 
>@@ -5399,8 +5399,8 @@ void ByteCodeParser::parseBlock(unsigned
>             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;
>@@ -5434,9 +5434,9 @@ void ByteCodeParser::parseBlock(unsigned
>             }
> 
>             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
>@@ -5445,7 +5445,7 @@ void ByteCodeParser::parseBlock(unsigned
>                 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);
>@@ -5455,11 +5455,11 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
>@@ -5475,10 +5475,10 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5491,10 +5491,10 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5507,11 +5507,11 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5539,21 +5539,21 @@ void ByteCodeParser::parseBlock(unsigned
>             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.metadata(codeBlock).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.metadata(codeBlock).m_flags & PutByIdIsDirect;
> 
>             PutByIdStatus putByIdStatus = PutByIdStatus::computeFor(
>                 m_inlineStackTop->m_profiledBlock,
>@@ -5566,10 +5566,10 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5585,11 +5585,11 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>         }
> 
>@@ -5603,31 +5603,31 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>         }
>@@ -5637,7 +5637,7 @@ void ByteCodeParser::parseBlock(unsigned
>         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();
>@@ -5646,24 +5646,24 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5672,8 +5672,8 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5682,9 +5682,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5692,9 +5692,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5702,9 +5702,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5712,9 +5712,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5722,9 +5722,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5732,9 +5732,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5742,9 +5742,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5752,9 +5752,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5762,9 +5762,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5772,9 +5772,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5782,9 +5782,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5792,9 +5792,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5802,9 +5802,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5812,9 +5812,9 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>@@ -5824,8 +5824,8 @@ void ByteCodeParser::parseBlock(unsigned
>             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])
>@@ -5835,7 +5835,7 @@ void ByteCodeParser::parseBlock(unsigned
>                     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);
>         }
>@@ -5844,8 +5844,8 @@ void ByteCodeParser::parseBlock(unsigned
>             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])
>@@ -5856,7 +5856,7 @@ void ByteCodeParser::parseBlock(unsigned
>                 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);
>         }
>@@ -5865,8 +5865,8 @@ void ByteCodeParser::parseBlock(unsigned
>             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();
>@@ -5877,7 +5877,7 @@ void ByteCodeParser::parseBlock(unsigned
>                 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);
>         }
>@@ -5887,14 +5887,14 @@ void ByteCodeParser::parseBlock(unsigned
>             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.
>@@ -5913,18 +5913,18 @@ void ByteCodeParser::parseBlock(unsigned
>         }
>         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);
>         }
>@@ -5944,7 +5944,7 @@ void ByteCodeParser::parseBlock(unsigned
> 
>             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.
>@@ -6117,21 +6117,21 @@ void ByteCodeParser::parseBlock(unsigned
>             
>         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);
>@@ -6151,8 +6151,8 @@ void ByteCodeParser::parseBlock(unsigned
>             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:
>@@ -6160,15 +6160,15 @@ void ByteCodeParser::parseBlock(unsigned
>                 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;
>@@ -6176,8 +6176,8 @@ void ByteCodeParser::parseBlock(unsigned
>             }
> 
>             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);
>             }
> 
>@@ -6189,7 +6189,7 @@ void ByteCodeParser::parseBlock(unsigned
>             // 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));
>                 }
>@@ -6204,21 +6204,21 @@ void ByteCodeParser::parseBlock(unsigned
>             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
>@@ -6227,26 +6227,26 @@ void ByteCodeParser::parseBlock(unsigned
>                     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:
>@@ -6257,9 +6257,9 @@ void ByteCodeParser::parseBlock(unsigned
>         }
>         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);
>         }
>@@ -6267,7 +6267,7 @@ void ByteCodeParser::parseBlock(unsigned
>         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;
>@@ -6277,20 +6277,20 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>             }
> 
>@@ -6312,21 +6312,21 @@ void ByteCodeParser::parseBlock(unsigned
>                 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));
>@@ -6382,7 +6382,7 @@ void ByteCodeParser::parseBlock(unsigned
>                     JSValue value = pointer->get();
>                     if (value) {
>                         m_graph.watchpoints().addLazily(watchpointSet);
>-                        set(bytecode.dst, weakJSConstant(value));
>+                        set(bytecode.m_dst, weakJSConstant(value));
>                         break;
>                     }
>                 }
>@@ -6396,13 +6396,13 @@ void ByteCodeParser::parseBlock(unsigned
>                 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:
>                 //
>@@ -6418,11 +6418,11 @@ void ByteCodeParser::parseBlock(unsigned
>                 // 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;
>             }
>@@ -6439,7 +6439,7 @@ void ByteCodeParser::parseBlock(unsigned
>         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;
>@@ -6455,13 +6455,13 @@ void ByteCodeParser::parseBlock(unsigned
>             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();
>@@ -6469,7 +6469,7 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>             }
> 
>@@ -6489,13 +6489,13 @@ void ByteCodeParser::parseBlock(unsigned
>                 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:
>@@ -6513,21 +6513,21 @@ void ByteCodeParser::parseBlock(unsigned
>                     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);
> 
>@@ -6591,28 +6591,28 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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);
>         }
>@@ -6629,14 +6629,14 @@ void ByteCodeParser::parseBlock(unsigned
>                 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);
>         }
> 
>@@ -6644,15 +6644,15 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
> 
>@@ -6660,18 +6660,18 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
>             
>@@ -6679,9 +6679,9 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
> 
>@@ -6689,7 +6689,7 @@ void ByteCodeParser::parseBlock(unsigned
>             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)
>@@ -6698,7 +6698,7 @@ void ByteCodeParser::parseBlock(unsigned
>                     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:
>@@ -6729,53 +6729,53 @@ void ByteCodeParser::parseBlock(unsigned
> 
>         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(
>@@ -6804,43 +6804,43 @@ void ByteCodeParser::parseBlock(unsigned
>                     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);
>         }
> 
>@@ -6848,52 +6848,52 @@ void ByteCodeParser::parseBlock(unsigned
>             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);
>         }
> 
>@@ -6903,7 +6903,7 @@ void ByteCodeParser::parseBlock(unsigned
>                 // 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);
>         }
>@@ -7167,9 +7167,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;
>     {
>@@ -7210,7 +7210,7 @@ void ByteCodeParser::handlePutByVal(Byte
>     }
> 
>     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);
>@@ -7224,28 +7224,28 @@ void ByteCodeParser::handlePutByVal(Byte
> 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
>@@ -7259,10 +7259,10 @@ void ByteCodeParser::handleNewFunc(NodeT
> 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: Source/JavaScriptCore/dfg/DFGOSREntry.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGOSREntry.cpp	(revision 239990)
>+++ Source/JavaScriptCore/dfg/DFGOSREntry.cpp	(working copy)
>@@ -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<ExceptionHandlerPt
> 
>     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: Source/JavaScriptCore/ftl/FTLOperations.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLOperations.cpp	(revision 239990)
>+++ Source/JavaScriptCore/ftl/FTLOperations.cpp	(working copy)
>@@ -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 operati
>         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 operati
>             // 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: Source/JavaScriptCore/generator/Argument.rb
>===================================================================
>--- Source/JavaScriptCore/generator/Argument.rb	(revision 239990)
>+++ Source/JavaScriptCore/generator/Argument.rb	(working copy)
>@@ -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} m_#{@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: Source/JavaScriptCore/generator/Metadata.rb
>===================================================================
>--- Source/JavaScriptCore/generator/Metadata.rb	(revision 239990)
>+++ Source/JavaScriptCore/generator/Metadata.rb	(working copy)
>@@ -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: Source/JavaScriptCore/generator/Opcode.rb
>===================================================================
>--- Source/JavaScriptCore/generator/Opcode.rb	(revision 239990)
>+++ Source/JavaScriptCore/generator/Opcode.rb	(working copy)
>@@ -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
>@@ -80,6 +80,12 @@ class Opcode
>         @args.map(&:name).unshift("").join(", ")
>     end
> 
>+    def untyped_params
>+        return if @args.nil?
>+
>+        @args.map(&:field_name).unshift("").join(", ")
>+    end
>+
>     def map_fields_with_size(prefix, size, &block)
>         args = [Argument.new("opcodeID", :unsigned, 0)]
>         args += @args.dup if @args
>@@ -164,7 +170,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 +231,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: Source/JavaScriptCore/jit/JITArithmetic32_64.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITArithmetic32_64.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITArithmetic32_64.cpp	(working copy)
>@@ -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 Inst
>     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 
> 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 Instruc
> 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*
> 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 Instr
> 
>     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*
> {
> #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: Source/JavaScriptCore/jit/JITArithmetic.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITArithmetic.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITArithmetic.cpp	(working copy)
>@@ -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 Instruc
> 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 Inst
>     // - 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 
> 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*
> 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*
> 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 Instruct
> 
> 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 SnippetGe
> 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 
> 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 getOpe
> 
> 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 Generato
> 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
> {
>     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<
>     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
> 
>     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*
> {
>     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*
> 
>     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*
> 
> 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 Instruct
> 
> 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: Source/JavaScriptCore/jit/JITCall32_64.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITCall32_64.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITCall32_64.cpp	(working copy)
>@@ -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 
>     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 Instructio
> {
>     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: Source/JavaScriptCore/jit/JITCall.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITCall.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITCall.cpp	(working copy)
>@@ -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 
>     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 Instructio
> {
>     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: Source/JavaScriptCore/jit/JITInlines.h
>===================================================================
>--- Source/JavaScriptCore/jit/JITInlines.h	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITInlines.h	(working copy)
>@@ -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
>@@ -341,7 +341,7 @@ inline void JIT::emitValueProfilingSite(
> {
>     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 
> 
> 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::copiedGetP
> 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: Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITOpcodes32_64.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITOpcodes32_64.cpp	(working copy)
>@@ -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*
> {
>     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*
> 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 Instr
> {
>     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 Instr
>         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 I
> 
>     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 I
> 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
> 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 I
>     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(
>     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(
> 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 Instruc
> 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 Ins
> 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(c
> 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 Instr
> 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 Instru
> 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(cons
> 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 Instru
> 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 Ins
> 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(cons
> 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*
> 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 Instructi
> 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 Instructio
> 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 Instruc
> 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 Instruc
> {
>     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* 
> {
>     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* 
> 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 Instructi
> 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<Slo
> 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*
> 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 Instruct
> 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
> 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 In
>     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 I
>     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 I
> 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 Instruct
> 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 Instructio
>     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 Instructio
> 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 Instru
> 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 Instru
> 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 Instructio
> 
>     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 Instructio
>     // 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(
> 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 Instr
> 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 Inst
> 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 Instructio
>     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 Instructio
> 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 Inst
> {
>     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 Inst
>     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 Instruct
> 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(c
> {
>     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_proper
>     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_proper
> 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
> 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_p
> 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 Ins
> {
>     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_pro
>     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_tai
>     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: Source/JavaScriptCore/jit/JITOpcodes.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITOpcodes.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITOpcodes.cpp	(working copy)
>@@ -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*
> {
>     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*
> 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 Instr
> {
>     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 Instr
>         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 I
> 
>     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 I
> 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
> 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 I
>     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(cons
> 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 Instruc
> 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 Ins
> 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(c
> 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 Instr
> 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 Instru
> 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(cons
> 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*
> 
>     // 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*
> 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 Ins
> 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*
>     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 Instruc
> 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 Instruc
> {
>     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 Instruc
> 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*
> 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 Instructio
>     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 In
>     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 I
>     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 I
> 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 Instru
> 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 Instructio
>     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 Instructio
>     // 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(
> 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 Instr
> 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 Inst
> 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 Instructio
>     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 Instruct
> 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 Instructio
> 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 Instruct
> {
>     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 Inst
> {
>     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 Inst
>     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 Instructi
>     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 Instruct
>     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 Instruct
>     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 Instruc
>     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(
>     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 
> 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 Instru
> {
>     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 Instru
> {
>     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(co
> 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(c
> {
>     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_proper
>     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_proper
> 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
> 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_p
> 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 Ins
> {
>     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_pro
>     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_tai
>     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(c
> {
>     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(c
> 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 I
> 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 
> 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: Source/JavaScriptCore/jit/JITOperations.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITOperations.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITOperations.cpp	(working copy)
>@@ -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 operationTryOSREnter
>     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 operationGe
>     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(E
>     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: Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp	(working copy)
>@@ -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
>@@ -50,10 +50,10 @@ namespace JSC {
> void JIT::emit_op_put_getter_by_id(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutGetterById>();
>-    int base = bytecode.base.offset();
>-    int property = bytecode.property;
>-    int options = bytecode.attributes;
>-    int getter = bytecode.accessor.offset();
>+    int base = bytecode.m_base.offset();
>+    int property = bytecode.m_property;
>+    int options = bytecode.m_attributes;
>+    int getter = bytecode.m_accessor.offset();
> 
>     emitLoadPayload(base, regT1);
>     emitLoadPayload(getter, regT3);
>@@ -63,10 +63,10 @@ void JIT::emit_op_put_getter_by_id(const
> void JIT::emit_op_put_setter_by_id(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutSetterById>();
>-    int base = bytecode.base.offset();
>-    int property = bytecode.property;
>-    int options = bytecode.attributes;
>-    int setter = bytecode.accessor.offset();
>+    int base = bytecode.m_base.offset();
>+    int property = bytecode.m_property;
>+    int options = bytecode.m_attributes;
>+    int setter = bytecode.m_accessor.offset();
> 
>     emitLoadPayload(base, regT1);
>     emitLoadPayload(setter, regT3);
>@@ -76,11 +76,11 @@ void JIT::emit_op_put_setter_by_id(const
> void JIT::emit_op_put_getter_setter_by_id(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutGetterSetterById>();
>-    int base = bytecode.base.offset();
>-    int property = bytecode.property;
>-    int attributes = bytecode.attributes;
>-    int getter = bytecode.getter.offset();
>-    int setter = bytecode.setter.offset();
>+    int base = bytecode.m_base.offset();
>+    int property = bytecode.m_property;
>+    int attributes = bytecode.m_attributes;
>+    int getter = bytecode.m_getter.offset();
>+    int setter = bytecode.m_setter.offset();
> 
>     emitLoadPayload(base, regT1);
>     emitLoadPayload(getter, regT3);
>@@ -91,10 +91,10 @@ void JIT::emit_op_put_getter_setter_by_i
> void JIT::emit_op_put_getter_by_val(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutGetterByVal>();
>-    int base = bytecode.base.offset();
>-    int property = bytecode.property.offset();
>-    int32_t attributes = bytecode.attributes;
>-    int getter = bytecode.accessor.offset();
>+    int base = bytecode.m_base.offset();
>+    int property = bytecode.m_property.offset();
>+    int32_t attributes = bytecode.m_attributes;
>+    int getter = bytecode.m_accessor.offset();
> 
>     emitLoadPayload(base, regT2);
>     emitLoad(property, regT1, regT0);
>@@ -105,10 +105,10 @@ void JIT::emit_op_put_getter_by_val(cons
> void JIT::emit_op_put_setter_by_val(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutSetterByVal>();
>-    int base = bytecode.base.offset();
>-    int property = bytecode.property.offset();
>-    int32_t attributes = bytecode.attributes;
>-    int setter = bytecode.accessor.offset();
>+    int base = bytecode.m_base.offset();
>+    int property = bytecode.m_property.offset();
>+    int32_t attributes = bytecode.m_attributes;
>+    int setter = bytecode.m_accessor.offset();
> 
>     emitLoadPayload(base, regT2);
>     emitLoad(property, regT1, regT0);
>@@ -119,9 +119,9 @@ void JIT::emit_op_put_setter_by_val(cons
> 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;
>     emitLoad(base, regT1, regT0);
>     callOperation(operationDeleteByIdJSResult, dst, JSValueRegs(regT1, regT0), m_codeBlock->identifier(property).impl());
> }
>@@ -129,9 +129,9 @@ void JIT::emit_op_del_by_id(const Instru
> 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();
>     emitLoad2(base, regT1, regT0, property, regT3, regT2);
>     callOperation(operationDeleteByValJSResult, dst, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
> }
>@@ -140,10 +140,10 @@ void JIT::emit_op_get_by_val(const Instr
> {
>     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();
> 
>     emitLoad2(base, regT1, regT0, property, regT3, regT2);
>@@ -200,7 +200,7 @@ JITGetByIdGenerator JIT::emitGetByValWit
>     // property: tag(regT3), payload(regT2)
>     // scratch: regT4
> 
>-    int dst = bytecode.dst.offset();
>+    int dst = bytecode.m_dst.offset();
> 
>     slowCases.append(branchIfNotCell(regT3));
>     emitByValIdentifierCheck(byValInfo, regT2, regT4, propertyName, slowCases);
>@@ -226,9 +226,9 @@ JITGetByIdGenerator JIT::emitGetByValWit
> 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
>@@ -271,9 +271,9 @@ void JIT::emit_op_put_by_val(const Instr
> {
>     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();
>     
>     emitLoad2(base, regT1, regT0, property, regT3, regT2);
>@@ -321,9 +321,9 @@ template <typename Op>
> JIT::JumpList JIT::emitGenericContiguousPutByVal(Op bytecode, PatchableJump& badType, IndexingType indexingShape)
> {
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int base = bytecode.base.offset();
>-    int value = bytecode.value.offset();
>-    ArrayProfile* profile = &metadata.arrayProfile;
>+    int base = bytecode.m_base.offset();
>+    int value = bytecode.m_value.offset();
>+    ArrayProfile* profile = &metadata.m_arrayProfile;
> 
>     JumpList slowCases;
>     
>@@ -382,9 +382,9 @@ template <typename Op>
> JIT::JumpList JIT::emitArrayStoragePutByVal(Op bytecode, PatchableJump& badType)
> {
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int base = bytecode.base.offset();
>-    int value = bytecode.value.offset();
>-    ArrayProfile* profile = &metadata.arrayProfile;
>+    int base = bytecode.m_base.offset();
>+    int value = bytecode.m_value.offset();
>+    ArrayProfile* profile = &metadata.m_arrayProfile;
> 
>     JumpList slowCases;
>     
>@@ -423,8 +423,8 @@ JITPutByIdGenerator JIT::emitPutByValWit
>     // base: tag(regT1), payload(regT0)
>     // property: tag(regT3), payload(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(regT3));
>     emitByValIdentifierCheck(byValInfo, regT2, regT2, propertyName, slowCases);
>@@ -463,9 +463,9 @@ void JIT::emitSlow_op_put_by_val(const I
>     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)
>@@ -493,9 +493,9 @@ void JIT::emitSlow_op_put_by_val(const I
> void JIT::emit_op_try_get_by_id(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpTryGetById>();
>-    int dst = bytecode.dst.offset();
>-    int base = bytecode.base.offset();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    int dst = bytecode.m_dst.offset();
>+    int base = bytecode.m_base.offset();
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
> 
>     emitLoad(base, regT1, regT0);
>     emitJumpSlowCaseIfNotJSCell(base, regT1);
>@@ -516,8 +516,8 @@ void JIT::emitSlow_op_try_get_by_id(cons
>     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++];
> 
>@@ -532,9 +532,9 @@ void JIT::emitSlow_op_try_get_by_id(cons
> void JIT::emit_op_get_by_id_direct(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpGetByIdDirect>();
>-    int dst = bytecode.dst.offset();
>-    int base = bytecode.base.offset();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    int dst = bytecode.m_dst.offset();
>+    int base = bytecode.m_base.offset();
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
> 
>     emitLoad(base, regT1, regT0);
>     emitJumpSlowCaseIfNotJSCell(base, regT1);
>@@ -555,8 +555,8 @@ void JIT::emitSlow_op_get_by_id_direct(c
>     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++];
> 
>@@ -572,16 +572,16 @@ void JIT::emit_op_get_by_id(const Instru
> {
>     auto bytecode = currentInstruction->as<OpGetById>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int dst = bytecode.dst.offset();
>-    int base = bytecode.base.offset();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    int dst = bytecode.m_dst.offset();
>+    int base = bytecode.m_base.offset();
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
>     
>     emitLoad(base, regT1, regT0);
>     emitJumpSlowCaseIfNotJSCell(base, regT1);
> 
>     if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
>-        Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
>-        emitArrayProfilingSiteWithCell(regT0, regT2, &metadata.modeMetadata.arrayLengthMode.arrayProfile);
>+        Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.m_mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
>+        emitArrayProfilingSiteWithCell(regT0, regT2, &metadata.m_modeMetadata.arrayLengthMode.arrayProfile);
>         notArrayLengthMode.link(this);
>     }
> 
>@@ -601,8 +601,8 @@ void JIT::emitSlow_op_get_by_id(const In
>     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++];
>     
>@@ -616,10 +616,10 @@ void JIT::emitSlow_op_get_by_id(const In
> void JIT::emit_op_get_by_id_with_this(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
>-    int dst = bytecode.dst.offset();
>-    int base = bytecode.base.offset();
>-    int thisVReg = bytecode.thisValue.offset();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    int dst = bytecode.m_dst.offset();
>+    int base = bytecode.m_base.offset();
>+    int thisVReg = bytecode.m_thisValue.offset();
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
>     
>     emitLoad(base, regT1, regT0);
>     emitLoad(thisVReg, regT4, regT3);
>@@ -642,8 +642,8 @@ void JIT::emitSlow_op_get_by_id_with_thi
>     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++];
>     
>@@ -662,9 +662,9 @@ void JIT::emit_op_put_by_id(const Instru
>     
>     auto bytecode = currentInstruction->as<OpPutById>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int base = bytecode.base.offset();
>-    int value = bytecode.value.offset();
>-    int direct = metadata.flags & PutByIdIsDirect;
>+    int base = bytecode.m_base.offset();
>+    int value = bytecode.m_value.offset();
>+    int direct = metadata.m_flags & PutByIdIsDirect;
>     
>     emitLoad2(base, regT1, regT0, value, regT3, regT2);
>     
>@@ -688,8 +688,8 @@ void JIT::emitSlow_op_put_by_id(const In
>     linkAllSlowCases(iter);
> 
>     auto bytecode = currentInstruction->as<OpPutById>();
>-    int base = bytecode.base.offset();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    int base = bytecode.m_base.offset();
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
> 
>     Label coldPathBegin(this);
> 
>@@ -707,9 +707,9 @@ void JIT::emitSlow_op_put_by_id(const In
> void JIT::emit_op_in_by_id(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpInById>();
>-    int dst = bytecode.dst.offset();
>-    int base = bytecode.base.offset();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    int dst = bytecode.m_dst.offset();
>+    int base = bytecode.m_base.offset();
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
> 
>     emitLoad(base, regT1, regT0);
>     emitJumpSlowCaseIfNotJSCell(base, regT1);
>@@ -729,8 +729,8 @@ void JIT::emitSlow_op_in_by_id(const Ins
>     linkAllSlowCases(iter);
> 
>     auto bytecode = currentInstruction->as<OpInById>();
>-    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));
> 
>     JITInByIdGenerator& gen = m_inByIds[m_inByIdIndex++];
> 
>@@ -762,10 +762,10 @@ void JIT::emit_op_resolve_scope(const In
> {
>     auto bytecode = currentInstruction->as<OpResolveScope>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int dst = bytecode.dst.offset();
>-    int scope = bytecode.scope.offset();
>-    ResolveType resolveType = metadata.resolveType;
>-    unsigned depth = metadata.localScopeDepth;
>+    int dst = bytecode.m_dst.offset();
>+    int scope = bytecode.m_scope.offset();
>+    ResolveType resolveType = metadata.m_resolveType;
>+    unsigned depth = metadata.m_localScopeDepth;
> 
>     auto emitCode = [&] (ResolveType resolveType) {
>         switch (resolveType) {
>@@ -789,7 +789,7 @@ void JIT::emit_op_resolve_scope(const In
>             break;
>         case ModuleVar:
>             move(TrustedImm32(JSValue::CellTag), regT1);
>-            move(TrustedImmPtr(metadata.lexicalEnvironment.get()), regT0);
>+            move(TrustedImmPtr(metadata.m_lexicalEnvironment.get()), regT0);
>             emitStore(dst, regT1, regT0);
>             break;
>         case Dynamic:
>@@ -805,7 +805,7 @@ void JIT::emit_op_resolve_scope(const In
>     case GlobalProperty:
>     case GlobalPropertyWithVarInjectionChecks: {
>         // Since these GlobalProperty can be changed to GlobalLexicalVar, we should load the value from metadata.
>-        JSScope** constantScopeSlot = metadata.constantScope.slot();
>+        JSScope** constantScopeSlot = metadata.m_constantScope.slot();
>         emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
>         move(TrustedImm32(JSValue::CellTag), regT1);
>         loadPtr(constantScopeSlot, regT0);
>@@ -815,7 +815,7 @@ void JIT::emit_op_resolve_scope(const In
>     case UnresolvedProperty:
>     case UnresolvedPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.resolveType, regT0);
>+        load32(&metadata.m_resolveType, regT0);
> 
>         Jump notGlobalProperty = branch32(NotEqual, regT0, TrustedImm32(GlobalProperty));
>         emitCode(GlobalProperty);
>@@ -879,11 +879,11 @@ void JIT::emit_op_get_from_scope(const I
> {
>     auto bytecode = currentInstruction->as<OpGetFromScope>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int dst = bytecode.dst.offset();
>-    int scope = bytecode.scope.offset();
>-    ResolveType resolveType = metadata.getPutInfo.resolveType();
>-    Structure** structureSlot = metadata.structure.slot();
>-    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
>+    int dst = bytecode.m_dst.offset();
>+    int scope = bytecode.m_scope.offset();
>+    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
>+    Structure** structureSlot = metadata.m_structure.slot();
>+    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
>     
>     auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
>         switch (resolveType) {
>@@ -940,7 +940,7 @@ void JIT::emit_op_get_from_scope(const I
>     case GlobalProperty:
>     case GlobalPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isNotGlobalProperty = branch32(NotEqual, regT0, TrustedImm32(resolveType));
>@@ -955,7 +955,7 @@ void JIT::emit_op_get_from_scope(const I
>     case UnresolvedProperty:
>     case UnresolvedPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isGlobalProperty = branch32(Equal, regT0, TrustedImm32(GlobalProperty));
>@@ -994,7 +994,7 @@ void JIT::emitSlow_op_get_from_scope(con
>     linkAllSlowCases(iter);
> 
>     auto bytecode = currentInstruction->as<OpGetFromScope>();
>-    int dst = bytecode.dst.offset();
>+    int dst = bytecode.m_dst.offset();
>     callOperationWithProfile(bytecode.metadata(m_codeBlock), operationGetFromScope, dst, currentInstruction);
> }
> 
>@@ -1030,12 +1030,12 @@ void JIT::emit_op_put_to_scope(const Ins
> {
>     auto bytecode = currentInstruction->as<OpPutToScope>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int scope = bytecode.scope.offset();
>-    int value = bytecode.value.offset();
>+    int scope = bytecode.m_scope.offset();
>+    int value = bytecode.m_value.offset();
>     GetPutInfo getPutInfo = copiedGetPutInfo(bytecode);
>     ResolveType resolveType = getPutInfo.resolveType();
>-    Structure** structureSlot = metadata.structure.slot();
>-    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
>+    Structure** structureSlot = metadata.m_structure.slot();
>+    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
>     
>     auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
>         switch (resolveType) {
>@@ -1069,9 +1069,9 @@ void JIT::emit_op_put_to_scope(const Ins
>                 addSlowCase(branchIfEmpty(regT1));
>             }
>             if (indirectLoadForOperand)
>-                emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.watchpointSet);
>+                emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.m_watchpointSet);
>             else
>-                emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.watchpointSet);
>+                emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.m_watchpointSet);
>             break;
>         }
>         case LocalClosureVar:
>@@ -1079,7 +1079,7 @@ void JIT::emit_op_put_to_scope(const Ins
>         case ClosureVarWithVarInjectionChecks:
>             emitWriteBarrier(scope, value, ShouldFilterValue);
>             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
>-            emitPutClosureVar(scope, *operandSlot, value, metadata.watchpointSet);
>+            emitPutClosureVar(scope, *operandSlot, value, metadata.m_watchpointSet);
>             break;
>         case ModuleVar:
>         case Dynamic:
>@@ -1095,7 +1095,7 @@ void JIT::emit_op_put_to_scope(const Ins
>     case GlobalProperty:
>     case GlobalPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isGlobalProperty = branch32(Equal, regT0, TrustedImm32(resolveType));
>@@ -1114,7 +1114,7 @@ void JIT::emit_op_put_to_scope(const Ins
>     case UnresolvedProperty:
>     case UnresolvedPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isGlobalProperty = branch32(Equal, regT0, TrustedImm32(GlobalProperty));
>@@ -1162,9 +1162,9 @@ void JIT::emitSlow_op_put_to_scope(const
> void JIT::emit_op_get_from_arguments(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpGetFromArguments>();
>-    int dst = bytecode.dst.offset();
>-    int arguments = bytecode.arguments.offset();
>-    int index = bytecode.index;
>+    int dst = bytecode.m_dst.offset();
>+    int arguments = bytecode.m_arguments.offset();
>+    int index = bytecode.m_index;
>     
>     emitLoadPayload(arguments, regT0);
>     load32(Address(regT0, DirectArguments::storageOffset() + index * sizeof(WriteBarrier<Unknown>) + TagOffset), regT1);
>@@ -1176,9 +1176,9 @@ void JIT::emit_op_get_from_arguments(con
> void JIT::emit_op_put_to_arguments(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutToArguments>();
>-    int arguments = bytecode.arguments.offset();
>-    int index = bytecode.index;
>-    int value = bytecode.value.offset();
>+    int arguments = bytecode.m_arguments.offset();
>+    int index = bytecode.m_index;
>+    int value = bytecode.m_value.offset();
>     
>     emitWriteBarrier(arguments, value, ShouldFilterValue);
>     
>Index: Source/JavaScriptCore/jit/JITPropertyAccess.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITPropertyAccess.cpp	(revision 239990)
>+++ Source/JavaScriptCore/jit/JITPropertyAccess.cpp	(working copy)
>@@ -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 Instr
> {
>     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::emitGetByValWit
>     // 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::emitGetByValWit
> 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 Instr
> {
>     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::emitGenericContiguous
>     }
>     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::emitArrayStoragePutBy
>     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::emitPutByValWit
>     // 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 I
>     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 I
> 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 Instru
> 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 Instr
> 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(cons
>     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(cons
> 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(c
>     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 Instru
> {
>     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 Instru
> 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 In
>     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_thi
>     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++];
>     
>@@ -660,9 +660,9 @@ void JIT::emit_op_put_by_id(const Instru
> {
>     auto bytecode = currentInstruction->as<OpPutById>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int baseVReg = bytecode.base.offset();
>-    int valueVReg = bytecode.value.offset();
>-    unsigned direct = metadata.flags & PutByIdIsDirect;
>+    int baseVReg = bytecode.m_base.offset();
>+    int valueVReg = bytecode.m_value.offset();
>+    unsigned direct = metadata.m_flags & PutByIdIsDirect;
> 
>     // In order to be able to patch both the Structure, and the object offset, we store one pointer,
>     // to just after the arguments have been loaded into registers 'hotPathBegin', and we generate code
>@@ -690,7 +690,7 @@ void JIT::emitSlow_op_put_by_id(const In
>     linkAllSlowCases(iter);
> 
>     auto bytecode = currentInstruction->as<OpPutById>();
>-    const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
>+    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
> 
>     Label coldPathBegin(this);
>     
>@@ -704,9 +704,9 @@ void JIT::emitSlow_op_put_by_id(const In
> void JIT::emit_op_in_by_id(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpInById>();
>-    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);
> 
>@@ -727,8 +727,8 @@ void JIT::emitSlow_op_in_by_id(const Ins
>     linkAllSlowCases(iter);
> 
>     auto bytecode = currentInstruction->as<OpInById>();
>-    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));
> 
>     JITInByIdGenerator& gen = m_inByIds[m_inByIdIndex++];
> 
>@@ -759,10 +759,10 @@ void JIT::emit_op_resolve_scope(const In
> {
>     auto bytecode = currentInstruction->as<OpResolveScope>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int dst = bytecode.dst.offset();
>-    int scope = bytecode.scope.offset();
>-    ResolveType resolveType = metadata.resolveType;
>-    unsigned depth = metadata.localScopeDepth;
>+    int dst = bytecode.m_dst.offset();
>+    int scope = bytecode.m_scope.offset();
>+    ResolveType resolveType = metadata.m_resolveType;
>+    unsigned depth = metadata.m_localScopeDepth;
> 
>     auto emitCode = [&] (ResolveType resolveType) {
>         switch (resolveType) {
>@@ -784,7 +784,7 @@ void JIT::emit_op_resolve_scope(const In
>             emitResolveClosure(dst, scope, needsVarInjectionChecks(resolveType), depth);
>             break;
>         case ModuleVar:
>-            move(TrustedImmPtr(metadata.lexicalEnvironment.get()), regT0);
>+            move(TrustedImmPtr(metadata.m_lexicalEnvironment.get()), regT0);
>             emitPutVirtualRegister(dst);
>             break;
>         case Dynamic:
>@@ -801,7 +801,7 @@ void JIT::emit_op_resolve_scope(const In
>     case GlobalProperty:
>     case GlobalPropertyWithVarInjectionChecks: {
>         // Since these GlobalProperty can be changed to GlobalLexicalVar, we should load the value from metadata.
>-        JSScope** constantScopeSlot = metadata.constantScope.slot();
>+        JSScope** constantScopeSlot = metadata.m_constantScope.slot();
>         emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
>         loadPtr(constantScopeSlot, regT0);
>         emitPutVirtualRegister(dst);
>@@ -810,7 +810,7 @@ void JIT::emit_op_resolve_scope(const In
>     case UnresolvedProperty:
>     case UnresolvedPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.resolveType, regT0);
>+        load32(&metadata.m_resolveType, regT0);
> 
>         Jump notGlobalProperty = branch32(NotEqual, regT0, TrustedImm32(GlobalProperty));
>         emitCode(GlobalProperty);
>@@ -873,11 +873,11 @@ void JIT::emit_op_get_from_scope(const I
> {
>     auto bytecode = currentInstruction->as<OpGetFromScope>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int dst = bytecode.dst.offset();
>-    int scope = bytecode.scope.offset();
>-    ResolveType resolveType = metadata.getPutInfo.resolveType();
>-    Structure** structureSlot = metadata.structure.slot();
>-    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
>+    int dst = bytecode.m_dst.offset();
>+    int scope = bytecode.m_scope.offset();
>+    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
>+    Structure** structureSlot = metadata.m_structure.slot();
>+    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
> 
>     auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
>         switch (resolveType) {
>@@ -937,7 +937,7 @@ void JIT::emit_op_get_from_scope(const I
>     case GlobalProperty:
>     case GlobalPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isNotGlobalProperty = branch32(NotEqual, regT0, TrustedImm32(resolveType));
>@@ -953,7 +953,7 @@ void JIT::emit_op_get_from_scope(const I
>     case UnresolvedProperty:
>     case UnresolvedPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isGlobalProperty = branch32(Equal, regT0, TrustedImm32(GlobalProperty));
>@@ -992,7 +992,7 @@ void JIT::emitSlow_op_get_from_scope(con
>     linkAllSlowCases(iter);
> 
>     auto bytecode = currentInstruction->as<OpGetFromScope>();
>-    int dst = bytecode.dst.offset();
>+    int dst = bytecode.m_dst.offset();
>     callOperationWithProfile(bytecode.metadata(m_codeBlock), operationGetFromScope, dst, currentInstruction);
> }
> 
>@@ -1023,12 +1023,12 @@ void JIT::emit_op_put_to_scope(const Ins
> {
>     auto bytecode = currentInstruction->as<OpPutToScope>();
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    int scope = bytecode.scope.offset();
>-    int value = bytecode.value.offset();
>+    int scope = bytecode.m_scope.offset();
>+    int value = bytecode.m_value.offset();
>     GetPutInfo getPutInfo = copiedGetPutInfo(bytecode);
>     ResolveType resolveType = getPutInfo.resolveType();
>-    Structure** structureSlot = metadata.structure.slot();
>-    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
>+    Structure** structureSlot = metadata.m_structure.slot();
>+    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
> 
>     auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
>         switch (resolveType) {
>@@ -1064,9 +1064,9 @@ void JIT::emit_op_put_to_scope(const Ins
>                 addSlowCase(branchIfEmpty(regT0));
>             }
>             if (indirectLoadForOperand)
>-                emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.watchpointSet);
>+                emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.m_watchpointSet);
>             else
>-                emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.watchpointSet);
>+                emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.m_watchpointSet);
>             emitWriteBarrier(constantScope, value, ShouldFilterValue);
>             break;
>         }
>@@ -1074,7 +1074,7 @@ void JIT::emit_op_put_to_scope(const Ins
>         case ClosureVar:
>         case ClosureVarWithVarInjectionChecks:
>             emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
>-            emitPutClosureVar(scope, *operandSlot, value, metadata.watchpointSet);
>+            emitPutClosureVar(scope, *operandSlot, value, metadata.m_watchpointSet);
>             emitWriteBarrier(scope, value, ShouldFilterValue);
>             break;
>         case ModuleVar:
>@@ -1092,7 +1092,7 @@ void JIT::emit_op_put_to_scope(const Ins
>     case GlobalProperty:
>     case GlobalPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isGlobalProperty = branch32(Equal, regT0, TrustedImm32(resolveType));
>@@ -1111,7 +1111,7 @@ void JIT::emit_op_put_to_scope(const Ins
>     case UnresolvedProperty:
>     case UnresolvedPropertyWithVarInjectionChecks: {
>         JumpList skipToEnd;
>-        load32(&metadata.getPutInfo, regT0);
>+        load32(&metadata.m_getPutInfo, regT0);
>         and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
> 
>         Jump isGlobalProperty = branch32(Equal, regT0, TrustedImm32(GlobalProperty));
>@@ -1159,9 +1159,9 @@ void JIT::emitSlow_op_put_to_scope(const
> void JIT::emit_op_get_from_arguments(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpGetFromArguments>();
>-    int dst = bytecode.dst.offset();
>-    int arguments = bytecode.arguments.offset();
>-    int index = bytecode.index;
>+    int dst = bytecode.m_dst.offset();
>+    int arguments = bytecode.m_arguments.offset();
>+    int index = bytecode.m_index;
>     
>     emitGetVirtualRegister(arguments, regT0);
>     load64(Address(regT0, DirectArguments::storageOffset() + index * sizeof(WriteBarrier<Unknown>)), regT0);
>@@ -1172,9 +1172,9 @@ void JIT::emit_op_get_from_arguments(con
> void JIT::emit_op_put_to_arguments(const Instruction* currentInstruction)
> {
>     auto bytecode = currentInstruction->as<OpPutToArguments>();
>-    int arguments = bytecode.arguments.offset();
>-    int index = bytecode.index;
>-    int value = bytecode.value.offset();
>+    int arguments = bytecode.m_arguments.offset();
>+    int index = bytecode.m_index;
>+    int value = bytecode.m_value.offset();
>     
>     emitGetVirtualRegister(arguments, regT0);
>     emitGetVirtualRegister(value, regT1);
>@@ -1738,10 +1738,10 @@ template<typename Op>
> JIT::JumpList JIT::emitIntTypedArrayPutByVal(Op bytecode, PatchableJump& badType, TypedArrayType type)
> {
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    ArrayProfile* profile = &metadata.arrayProfile;
>+    ArrayProfile* profile = &metadata.m_arrayProfile;
>     ASSERT(isInt(type));
>     
>-    int value = bytecode.value.offset();
>+    int value = bytecode.m_value.offset();
> 
> #if USE(JSVALUE64)
>     RegisterID base = regT0;
>@@ -1813,10 +1813,10 @@ template<typename Op>
> JIT::JumpList JIT::emitFloatTypedArrayPutByVal(Op bytecode, PatchableJump& badType, TypedArrayType type)
> {
>     auto& metadata = bytecode.metadata(m_codeBlock);
>-    ArrayProfile* profile = &metadata.arrayProfile;
>+    ArrayProfile* profile = &metadata.m_arrayProfile;
>     ASSERT(isFloat(type));
>     
>-    int value = bytecode.value.offset();
>+    int value = bytecode.m_value.offset();
> 
> #if USE(JSVALUE64)
>     RegisterID base = regT0;
>Index: Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
>===================================================================
>--- Source/JavaScriptCore/llint/LLIntSlowPaths.cpp	(revision 239990)
>+++ Source/JavaScriptCore/llint/LLIntSlowPaths.cpp	(working copy)
>@@ -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
>@@ -133,7 +133,7 @@ namespace JSC { namespace LLInt {
>         bool __b_condition = (condition);                         \
>         LLINT_CHECK_EXCEPTION();                                  \
>         if (__b_condition)                                        \
>-            JUMP_TO(JUMP_OFFSET(bytecode.target)); \
>+            JUMP_TO(JUMP_OFFSET(bytecode.m_target)); \
>         else                                                      \
>             JUMP_TO(pc->size()); \
>         LLINT_END_IMPL();                                         \
>@@ -142,20 +142,20 @@ namespace JSC { namespace LLInt {
> #define LLINT_RETURN(value) do {                \
>         JSValue __r_returnValue = (value);      \
>         LLINT_CHECK_EXCEPTION();                \
>-        LLINT_OP(bytecode.dst) = __r_returnValue;          \
>+        LLINT_OP(bytecode.m_dst) = __r_returnValue;          \
>         LLINT_END_IMPL();                       \
>     } while (false)
> 
> #define LLINT_RETURN_PROFILED(value) do {               \
>         JSValue __rp_returnValue = (value);                     \
>         LLINT_CHECK_EXCEPTION();                                \
>-        LLINT_OP(bytecode.dst) = __rp_returnValue;                         \
>+        LLINT_OP(bytecode.m_dst) = __rp_returnValue;                         \
>         LLINT_PROFILE_VALUE(__rp_returnValue);          \
>         LLINT_END_IMPL();                                       \
>     } while (false)
> 
> #define LLINT_PROFILE_VALUE(value) do { \
>-        bytecode.metadata(exec).profile.m_buckets[0] = JSValue::encode(value); \
>+        bytecode.metadata(exec).m_profile.m_buckets[0] = JSValue::encode(value); \
>     } while (false)
> 
> #define LLINT_CALL_END_IMPL(exec, callTarget, callTargetTag) \
>@@ -571,7 +571,7 @@ LLINT_SLOW_PATH_DECL(slow_path_new_objec
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewObject>();
>     auto& metadata = bytecode.metadata(exec);
>-    LLINT_RETURN(constructEmptyObject(exec, metadata.objectAllocationProfile.structure()));
>+    LLINT_RETURN(constructEmptyObject(exec, metadata.m_objectAllocationProfile.structure()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_new_array)
>@@ -579,7 +579,7 @@ LLINT_SLOW_PATH_DECL(slow_path_new_array
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewArray>();
>     auto& metadata = bytecode.metadata(exec);
>-    LLINT_RETURN(constructArrayNegativeIndexed(exec, &metadata.arrayAllocationProfile, bitwise_cast<JSValue*>(&LLINT_OP(bytecode.argv)), bytecode.argc));
>+    LLINT_RETURN(constructArrayNegativeIndexed(exec, &metadata.m_arrayAllocationProfile, bitwise_cast<JSValue*>(&LLINT_OP(bytecode.m_argv)), bytecode.m_argc));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_new_array_with_size)
>@@ -587,14 +587,14 @@ LLINT_SLOW_PATH_DECL(slow_path_new_array
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewArrayWithSize>();
>     auto& metadata = bytecode.metadata(exec);
>-    LLINT_RETURN(constructArrayWithSizeQuirk(exec, &metadata.arrayAllocationProfile, exec->lexicalGlobalObject(), LLINT_OP_C(bytecode.length).jsValue()));
>+    LLINT_RETURN(constructArrayWithSizeQuirk(exec, &metadata.m_arrayAllocationProfile, exec->lexicalGlobalObject(), LLINT_OP_C(bytecode.m_length).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_new_regexp)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewRegexp>();
>-    RegExp* regExp = jsCast<RegExp*>(LLINT_OP_C(bytecode.regexp).jsValue());
>+    RegExp* regExp = jsCast<RegExp*>(LLINT_OP_C(bytecode.m_regexp).jsValue());
>     ASSERT(regExp->isValid());
>     LLINT_RETURN(RegExpObject::create(vm, exec->lexicalGlobalObject()->regExpStructure(), regExp));
> }
>@@ -603,8 +603,8 @@ LLINT_SLOW_PATH_DECL(slow_path_instanceo
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpInstanceof>();
>-    JSValue value = LLINT_OP_C(bytecode.value).jsValue();
>-    JSValue proto = LLINT_OP_C(bytecode.prototype).jsValue();
>+    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
>+    JSValue proto = LLINT_OP_C(bytecode.m_prototype).jsValue();
>     LLINT_RETURN(jsBoolean(JSObject::defaultHasInstance(exec, value, proto)));
> }
> 
>@@ -613,9 +613,9 @@ LLINT_SLOW_PATH_DECL(slow_path_instanceo
>     LLINT_BEGIN();
> 
>     auto bytecode = pc->as<OpInstanceofCustom>();
>-    JSValue value = LLINT_OP_C(bytecode.value).jsValue();
>-    JSValue constructor = LLINT_OP_C(bytecode.constructor).jsValue();
>-    JSValue hasInstanceValue = LLINT_OP_C(bytecode.hasInstanceValue).jsValue();
>+    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
>+    JSValue constructor = LLINT_OP_C(bytecode.m_constructor).jsValue();
>+    JSValue hasInstanceValue = LLINT_OP_C(bytecode.m_hasInstanceValue).jsValue();
> 
>     ASSERT(constructor.isObject());
>     ASSERT(hasInstanceValue != exec->lexicalGlobalObject()->functionProtoHasInstanceSymbolFunction() || !constructor.getObject()->structure(vm)->typeInfo().implementsDefaultHasInstance());
>@@ -629,8 +629,8 @@ LLINT_SLOW_PATH_DECL(slow_path_try_get_b
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpTryGetById>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    const Identifier& ident = codeBlock->identifier(bytecode.property);
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>+    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>     PropertySlot slot(baseValue, PropertySlot::PropertySlot::InternalMethodType::VMInquiry);
> 
>     baseValue.getPropertySlot(exec, ident, slot);
>@@ -644,8 +644,8 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpGetByIdDirect>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    const Identifier& ident = codeBlock->identifier(bytecode.property);
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>+    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>     PropertySlot slot(baseValue, PropertySlot::PropertySlot::InternalMethodType::GetOwnProperty);
> 
>     bool found = baseValue.getOwnPropertySlot(exec, ident, slot);
>@@ -656,7 +656,7 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
>     if (!LLINT_ALWAYS_ACCESS_SLOW && slot.isCacheable()) {
>         auto& metadata = bytecode.metadata(exec);
>         {
>-            StructureID oldStructureID = metadata.structure;
>+            StructureID oldStructureID = metadata.m_structure;
>             if (oldStructureID) {
>                 Structure* a = vm.heap.structureIDTable().get(oldStructureID);
>                 Structure* b = baseValue.asCell()->structure(vm);
>@@ -672,8 +672,8 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
>         Structure* structure = baseCell->structure(vm);
>         if (slot.isValue()) {
>             // Start out by clearing out the old cache.
>-            metadata.structure = 0;
>-            metadata.offset = 0;
>+            metadata.m_structure = 0;
>+            metadata.m_offset = 0;
> 
>             if (structure->propertyAccessesAreCacheable()
>                 && !structure->needImpurePropertyWatchpoint()) {
>@@ -681,8 +681,8 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
> 
>                 ConcurrentJSLocker locker(codeBlock->m_lock);
> 
>-                metadata.structure = structure->id();
>-                metadata.offset = slot.cachedOffset();
>+                metadata.m_structure = structure->id();
>+                metadata.m_offset = slot.cachedOffset();
>             }
>         }
>     }
>@@ -735,19 +735,19 @@ static void setupGetByIdPrototypeCache(E
>     ConcurrentJSLocker locker(codeBlock->m_lock);
> 
>     if (slot.isUnset()) {
>-        metadata.mode = GetByIdMode::Unset;
>-        metadata.modeMetadata.unsetMode.structure = structure->id();
>+        metadata.m_mode = GetByIdMode::Unset;
>+        metadata.m_modeMetadata.unsetMode.structure = structure->id();
>         return;
>     }
>     ASSERT(slot.isValue());
> 
>-    metadata.mode = GetByIdMode::ProtoLoad;
>-    metadata.modeMetadata.protoLoadMode.structure = structure->id();
>-    metadata.modeMetadata.protoLoadMode.cachedOffset = offset;
>-    metadata.modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
>+    metadata.m_mode = GetByIdMode::ProtoLoad;
>+    metadata.m_modeMetadata.protoLoadMode.structure = structure->id();
>+    metadata.m_modeMetadata.protoLoadMode.cachedOffset = offset;
>+    metadata.m_modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
>     // We know that this pointer will remain valid because it will be cleared by either a watchpoint fire or
>     // during GC when we clear the LLInt caches.
>-    metadata.modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
>+    metadata.m_modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
> }
> 
> 
>@@ -757,29 +757,29 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
>     auto bytecode = pc->as<OpGetById>();
>     auto& metadata = bytecode.metadata(exec);
>     CodeBlock* codeBlock = exec->codeBlock();
>-    const Identifier& ident = codeBlock->identifier(bytecode.property);
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>+    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>     PropertySlot slot(baseValue, PropertySlot::PropertySlot::InternalMethodType::Get);
> 
>     JSValue result = baseValue.get(exec, ident, slot);
>     LLINT_CHECK_EXCEPTION();
>-    LLINT_OP(bytecode.dst) = result;
>+    LLINT_OP(bytecode.m_dst) = result;
>     
>     if (!LLINT_ALWAYS_ACCESS_SLOW
>         && baseValue.isCell()
>         && slot.isCacheable()) {
>         {
>             StructureID oldStructureID;
>-            auto mode = metadata.mode;
>+            auto mode = metadata.m_mode;
>             switch (mode) {
>             case GetByIdMode::Default:
>-                oldStructureID = metadata.modeMetadata.defaultMode.structure;
>+                oldStructureID = metadata.m_modeMetadata.defaultMode.structure;
>                 break;
>             case GetByIdMode::Unset:
>-                oldStructureID = metadata.modeMetadata.unsetMode.structure;
>+                oldStructureID = metadata.m_modeMetadata.unsetMode.structure;
>                 break;
>             case GetByIdMode::ProtoLoad:
>-                oldStructureID = metadata.modeMetadata.protoLoadMode.structure;
>+                oldStructureID = metadata.m_modeMetadata.protoLoadMode.structure;
>                 break;
>             default:
>                 oldStructureID = 0;
>@@ -799,12 +799,12 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
>         Structure* structure = baseCell->structure(vm);
>         if (slot.isValue() && slot.slotBase() == baseValue) {
>             // Start out by clearing out the old cache.
>-            metadata.mode = GetByIdMode::Default;
>-            metadata.modeMetadata.defaultMode.structure = 0;
>-            metadata.modeMetadata.defaultMode.cachedOffset = 0;
>+            metadata.m_mode = GetByIdMode::Default;
>+            metadata.m_modeMetadata.defaultMode.structure = 0;
>+            metadata.m_modeMetadata.defaultMode.cachedOffset = 0;
> 
>             // Prevent the prototype cache from ever happening.
>-            metadata.hitCountForLLIntCaching = 0;
>+            metadata.m_hitCountForLLIntCaching = 0;
>         
>             if (structure->propertyAccessesAreCacheable()
>                 && !structure->needImpurePropertyWatchpoint()) {
>@@ -812,24 +812,24 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id
>                 
>                 ConcurrentJSLocker locker(codeBlock->m_lock);
> 
>-                metadata.modeMetadata.defaultMode.structure = structure->id();
>-                metadata.modeMetadata.defaultMode.cachedOffset = slot.cachedOffset();
>+                metadata.m_modeMetadata.defaultMode.structure = structure->id();
>+                metadata.m_modeMetadata.defaultMode.cachedOffset = slot.cachedOffset();
>             }
>-        } else if (UNLIKELY(metadata.hitCountForLLIntCaching && (slot.isValue() || slot.isUnset()))) {
>+        } else if (UNLIKELY(metadata.m_hitCountForLLIntCaching && (slot.isValue() || slot.isUnset()))) {
>             ASSERT(slot.slotBase() != baseValue);
> 
>-            if (!(--metadata.hitCountForLLIntCaching))
>+            if (!(--metadata.m_hitCountForLLIntCaching))
>                 setupGetByIdPrototypeCache(exec, vm, pc, metadata, baseCell, slot, ident);
>         }
>     } else if (!LLINT_ALWAYS_ACCESS_SLOW
>         && isJSArray(baseValue)
>         && ident == vm.propertyNames->length) {
>-        metadata.mode = GetByIdMode::ArrayLength;
>-        new (&metadata.modeMetadata.arrayLengthMode.arrayProfile) ArrayProfile(codeBlock->bytecodeOffset(pc));
>-        metadata.modeMetadata.arrayLengthMode.arrayProfile.observeStructure(baseValue.asCell()->structure(vm));
>+        metadata.m_mode = GetByIdMode::ArrayLength;
>+        new (&metadata.m_modeMetadata.arrayLengthMode.arrayProfile) ArrayProfile(codeBlock->bytecodeOffset(pc));
>+        metadata.m_modeMetadata.arrayLengthMode.arrayProfile.observeStructure(baseValue.asCell()->structure(vm));
> 
>         // Prevent the prototype cache from ever happening.
>-        metadata.hitCountForLLIntCaching = 0;
>+        metadata.m_hitCountForLLIntCaching = 0;
>     }
> 
>     LLINT_PROFILE_VALUE(result);
>@@ -842,14 +842,14 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_id
>     auto bytecode = pc->as<OpPutById>();
>     auto& metadata = bytecode.metadata(exec);
>     CodeBlock* codeBlock = exec->codeBlock();
>-    const Identifier& ident = codeBlock->identifier(bytecode.property);
>+    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
>     
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>     PutPropertySlot slot(baseValue, codeBlock->isStrictMode(), codeBlock->putByIdContext());
>-    if (metadata.flags & PutByIdIsDirect)
>-        CommonSlowPaths::putDirectWithReify(vm, exec, asObject(baseValue), ident, LLINT_OP_C(bytecode.value).jsValue(), slot);
>+    if (metadata.m_flags & PutByIdIsDirect)
>+        CommonSlowPaths::putDirectWithReify(vm, exec, asObject(baseValue), ident, LLINT_OP_C(bytecode.m_value).jsValue(), slot);
>     else
>-        baseValue.putInline(exec, ident, LLINT_OP_C(bytecode.value).jsValue(), slot);
>+        baseValue.putInline(exec, ident, LLINT_OP_C(bytecode.m_value).jsValue(), slot);
>     LLINT_CHECK_EXCEPTION();
>     
>     if (!LLINT_ALWAYS_ACCESS_SLOW
>@@ -857,7 +857,7 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_id
>         && slot.isCacheablePut()) {
> 
>         {
>-            StructureID oldStructureID = metadata.oldStructure;
>+            StructureID oldStructureID = metadata.m_oldStructure;
>             if (oldStructureID) {
>                 Structure* a = vm.heap.structureIDTable().get(oldStructureID);
>                 Structure* b = baseValue.asCell()->structure(vm);
>@@ -872,11 +872,11 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_id
>         }
> 
>         // Start out by clearing out the old cache.
>-        metadata.oldStructure = 0;
>-        metadata.offset = 0;
>-        metadata.newStructure = 0;
>-        metadata.structureChain.clear();
>-        metadata.flags = static_cast<PutByIdFlags>(metadata.flags & PutByIdPersistentFlagsMask);
>+        metadata.m_oldStructure = 0;
>+        metadata.m_offset = 0;
>+        metadata.m_newStructure = 0;
>+        metadata.m_structureChain.clear();
>+        metadata.m_flags = static_cast<PutByIdFlags>(metadata.m_flags & PutByIdPersistentFlagsMask);
>         
>         JSCell* baseCell = baseValue.asCell();
>         Structure* structure = baseCell->structure(vm);
>@@ -897,25 +897,25 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_id
>                     auto result = normalizePrototypeChain(exec, baseCell, sawPolyProto);
>                     if (result != InvalidPrototypeChain && !sawPolyProto) {
>                         ASSERT(structure->previousID()->isObject());
>-                        metadata.oldStructure = structure->previousID()->id();
>-                        metadata.offset = slot.cachedOffset();
>-                        metadata.newStructure = structure->id();
>-                        if (!(metadata.flags & PutByIdIsDirect)) {
>+                        metadata.m_oldStructure = structure->previousID()->id();
>+                        metadata.m_offset = slot.cachedOffset();
>+                        metadata.m_newStructure = structure->id();
>+                        if (!(metadata.m_flags & PutByIdIsDirect)) {
>                             StructureChain* chain = structure->prototypeChain(exec, asObject(baseCell));
>                             ASSERT(chain);
>-                            metadata.structureChain.set(vm, codeBlock, chain);
>+                            metadata.m_structureChain.set(vm, codeBlock, chain);
>                         }
>-                        metadata.flags = static_cast<PutByIdFlags>(
>-                            metadata.flags |
>+                        metadata.m_flags = static_cast<PutByIdFlags>(
>+                            metadata.m_flags |
>                             structure->inferredTypeDescriptorFor(ident.impl()).putByIdFlags());
>                     }
>                 }
>             } else {
>                 structure->didCachePropertyReplacement(vm, slot.cachedOffset());
>-                metadata.oldStructure = structure->id();
>-                metadata.offset = slot.cachedOffset();
>-                metadata.flags = static_cast<PutByIdFlags>(
>-                    metadata.flags |
>+                metadata.m_oldStructure = structure->id();
>+                metadata.m_offset = slot.cachedOffset();
>+                metadata.m_flags = static_cast<PutByIdFlags>(
>+                    metadata.m_flags |
>                     structure->inferredTypeDescriptorFor(ident.impl()).putByIdFlags());
>             }
>         }
>@@ -929,9 +929,9 @@ LLINT_SLOW_PATH_DECL(slow_path_del_by_id
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpDelById>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSObject* baseObject = LLINT_OP_C(bytecode.base).jsValue().toObject(exec);
>+    JSObject* baseObject = LLINT_OP_C(bytecode.m_base).jsValue().toObject(exec);
>     LLINT_CHECK_EXCEPTION();
>-    bool couldDelete = baseObject->methodTable(vm)->deleteProperty(baseObject, exec, codeBlock->identifier(bytecode.property));
>+    bool couldDelete = baseObject->methodTable(vm)->deleteProperty(baseObject, exec, codeBlock->identifier(bytecode.m_property));
>     LLINT_CHECK_EXCEPTION();
>     if (!couldDelete && codeBlock->isStrictMode())
>         LLINT_THROW(createTypeError(exec, UnableToDeletePropertyError));
>@@ -940,8 +940,8 @@ LLINT_SLOW_PATH_DECL(slow_path_del_by_id
> 
> static ALWAYS_INLINE JSValue getByVal(VM& vm, ExecState* exec, OpGetByVal bytecode)
> {
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>-    JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>+    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
>     auto scope = DECLARE_THROW_SCOPE(vm);
> 
>     if (LIKELY(baseValue.isCell() && subscript.isString())) {
>@@ -957,7 +957,7 @@ static ALWAYS_INLINE JSValue getByVal(VM
>     if (subscript.isUInt32()) {
>         uint32_t i = subscript.asUInt32();
>         auto& metadata = bytecode.metadata(exec);
>-        ArrayProfile* arrayProfile = &metadata.arrayProfile;
>+        ArrayProfile* arrayProfile = &metadata.m_arrayProfile;
> 
>         if (isJSString(baseValue)) {
>             if (asString(baseValue)->canGetIndex(i)) {
>@@ -1007,9 +1007,9 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_va
>     LLINT_BEGIN();
>     
>     auto bytecode = pc->as<OpPutByVal>();
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>-    JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
>-    JSValue value = LLINT_OP_C(bytecode.value).jsValue();
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>+    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
>+    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
>     bool isStrictMode = exec->codeBlock()->isStrictMode();
>     
>     if (LIKELY(subscript.isUInt32())) {
>@@ -1038,9 +1038,9 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_va
>     LLINT_BEGIN();
>     
>     auto bytecode = pc->as<OpPutByValDirect>();
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>-    JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
>-    JSValue value = LLINT_OP_C(bytecode.value).jsValue();
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>+    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
>+    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
>     RELEASE_ASSERT(baseValue.isObject());
>     JSObject* baseObject = asObject(baseValue);
>     bool isStrictMode = exec->codeBlock()->isStrictMode();
>@@ -1078,11 +1078,11 @@ LLINT_SLOW_PATH_DECL(slow_path_del_by_va
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpDelByVal>();
>-    JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
>+    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
>     JSObject* baseObject = baseValue.toObject(exec);
>     LLINT_CHECK_EXCEPTION();
> 
>-    JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
>+    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
>     
>     bool couldDelete;
>     
>@@ -1107,15 +1107,15 @@ LLINT_SLOW_PATH_DECL(slow_path_put_gette
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpPutGetterById>();
>-    ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
>-    JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
>+    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
>+    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
> 
>-    unsigned options = bytecode.attributes;
>+    unsigned options = bytecode.m_attributes;
> 
>-    JSValue getter = LLINT_OP(bytecode.accessor).jsValue();
>+    JSValue getter = LLINT_OP(bytecode.m_accessor).jsValue();
>     ASSERT(getter.isObject());
> 
>-    baseObj->putGetter(exec, exec->codeBlock()->identifier(bytecode.property), asObject(getter), options);
>+    baseObj->putGetter(exec, exec->codeBlock()->identifier(bytecode.m_property), asObject(getter), options);
>     LLINT_END();
> }
> 
>@@ -1123,15 +1123,15 @@ LLINT_SLOW_PATH_DECL(slow_path_put_sette
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpPutSetterById>();
>-    ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
>-    JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
>+    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
>+    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
> 
>-    unsigned options = bytecode.attributes;
>+    unsigned options = bytecode.m_attributes;
> 
>-    JSValue setter = LLINT_OP(bytecode.accessor).jsValue();
>+    JSValue setter = LLINT_OP(bytecode.m_accessor).jsValue();
>     ASSERT(setter.isObject());
> 
>-    baseObj->putSetter(exec, exec->codeBlock()->identifier(bytecode.property), asObject(setter), options);
>+    baseObj->putSetter(exec, exec->codeBlock()->identifier(bytecode.m_property), asObject(setter), options);
>     LLINT_END();
> }
> 
>@@ -1139,15 +1139,15 @@ LLINT_SLOW_PATH_DECL(slow_path_put_gette
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpPutGetterSetterById>();
>-    ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
>-    JSObject* baseObject = asObject(LLINT_OP(bytecode.base).jsValue());
>+    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
>+    JSObject* baseObject = asObject(LLINT_OP(bytecode.m_base).jsValue());
> 
>-    JSValue getter = LLINT_OP(bytecode.getter).jsValue();
>-    JSValue setter = LLINT_OP(bytecode.setter).jsValue();
>+    JSValue getter = LLINT_OP(bytecode.m_getter).jsValue();
>+    JSValue setter = LLINT_OP(bytecode.m_setter).jsValue();
>     ASSERT(getter.isObject() || setter.isObject());
>     GetterSetter* accessor = GetterSetter::create(vm, exec->lexicalGlobalObject(), getter, setter);
> 
>-    CommonSlowPaths::putDirectAccessorWithReify(vm, exec, baseObject, exec->codeBlock()->identifier(bytecode.property), accessor, bytecode.attributes);
>+    CommonSlowPaths::putDirectAccessorWithReify(vm, exec, baseObject, exec->codeBlock()->identifier(bytecode.m_property), accessor, bytecode.m_attributes);
>     LLINT_END();
> }
> 
>@@ -1155,13 +1155,13 @@ LLINT_SLOW_PATH_DECL(slow_path_put_gette
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpPutGetterByVal>();
>-    ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
>-    JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
>-    JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
>+    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
>+    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
>+    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
> 
>-    unsigned options = bytecode.attributes;
>+    unsigned options = bytecode.m_attributes;
> 
>-    JSValue getter = LLINT_OP(bytecode.accessor).jsValue();
>+    JSValue getter = LLINT_OP(bytecode.m_accessor).jsValue();
>     ASSERT(getter.isObject());
> 
>     auto property = subscript.toPropertyKey(exec);
>@@ -1175,13 +1175,13 @@ LLINT_SLOW_PATH_DECL(slow_path_put_sette
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpPutSetterByVal>();
>-    ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
>-    JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
>-    JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
>+    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
>+    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
>+    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
> 
>-    unsigned options = bytecode.attributes;
>+    unsigned options = bytecode.m_attributes;
> 
>-    JSValue setter = LLINT_OP(bytecode.accessor).jsValue();
>+    JSValue setter = LLINT_OP(bytecode.m_accessor).jsValue();
>     ASSERT(setter.isObject());
> 
>     auto property = subscript.toPropertyKey(exec);
>@@ -1195,112 +1195,112 @@ LLINT_SLOW_PATH_DECL(slow_path_jtrue)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJtrue>();
>-    LLINT_BRANCH(LLINT_OP_C(bytecode.condition).jsValue().toBoolean(exec));
>+    LLINT_BRANCH(LLINT_OP_C(bytecode.m_condition).jsValue().toBoolean(exec));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jfalse)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJfalse>();
>-    LLINT_BRANCH(!LLINT_OP_C(bytecode.condition).jsValue().toBoolean(exec));
>+    LLINT_BRANCH(!LLINT_OP_C(bytecode.m_condition).jsValue().toBoolean(exec));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jless)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJless>();
>-    LLINT_BRANCH(jsLess<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(jsLess<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jnless)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJnless>();
>-    LLINT_BRANCH(!jsLess<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(!jsLess<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jgreater)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJgreater>();
>-    LLINT_BRANCH(jsLess<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
>+    LLINT_BRANCH(jsLess<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jngreater)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJngreater>();
>-    LLINT_BRANCH(!jsLess<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
>+    LLINT_BRANCH(!jsLess<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jlesseq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJlesseq>();
>-    LLINT_BRANCH(jsLessEq<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(jsLessEq<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jnlesseq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJnlesseq>();
>-    LLINT_BRANCH(!jsLessEq<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(!jsLessEq<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jgreatereq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJgreatereq>();
>-    LLINT_BRANCH(jsLessEq<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
>+    LLINT_BRANCH(jsLessEq<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jngreatereq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJngreatereq>();
>-    LLINT_BRANCH(!jsLessEq<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
>+    LLINT_BRANCH(!jsLessEq<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jeq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJeq>();
>-    LLINT_BRANCH(JSValue::equal(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(JSValue::equal(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jneq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJneq>();
>-    LLINT_BRANCH(!JSValue::equal(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(!JSValue::equal(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jstricteq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJstricteq>();
>-    LLINT_BRANCH(JSValue::strictEqual(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(JSValue::strictEqual(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_jnstricteq)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpJnstricteq>();
>-    LLINT_BRANCH(!JSValue::strictEqual(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
>+    LLINT_BRANCH(!JSValue::strictEqual(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_switch_imm)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpSwitchImm>();
>-    JSValue scrutinee = LLINT_OP_C(bytecode.scrutinee).jsValue();
>+    JSValue scrutinee = LLINT_OP_C(bytecode.m_scrutinee).jsValue();
>     ASSERT(scrutinee.isDouble());
>     double value = scrutinee.asDouble();
>     int32_t intValue = static_cast<int32_t>(value);
>-    int defaultOffset = JUMP_OFFSET(bytecode.defaultOffset);
>+    int defaultOffset = JUMP_OFFSET(bytecode.m_defaultOffset);
>     if (value == intValue) {
>         CodeBlock* codeBlock = exec->codeBlock();
>-        JUMP_TO(codeBlock->switchJumpTable(bytecode.tableIndex).offsetForValue(intValue, defaultOffset));
>+        JUMP_TO(codeBlock->switchJumpTable(bytecode.m_tableIndex).offsetForValue(intValue, defaultOffset));
>     } else
>         JUMP_TO(defaultOffset);
>     LLINT_END();
>@@ -1310,14 +1310,14 @@ LLINT_SLOW_PATH_DECL(slow_path_switch_ch
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpSwitchChar>();
>-    JSValue scrutinee = LLINT_OP_C(bytecode.scrutinee).jsValue();
>+    JSValue scrutinee = LLINT_OP_C(bytecode.m_scrutinee).jsValue();
>     ASSERT(scrutinee.isString());
>     JSString* string = asString(scrutinee);
>     ASSERT(string->length() == 1);
>-    int defaultOffset = JUMP_OFFSET(bytecode.defaultOffset);
>+    int defaultOffset = JUMP_OFFSET(bytecode.m_defaultOffset);
>     StringImpl* impl = string->value(exec).impl();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JUMP_TO(codeBlock->switchJumpTable(bytecode.tableIndex).offsetForValue((*impl)[0], defaultOffset));
>+    JUMP_TO(codeBlock->switchJumpTable(bytecode.m_tableIndex).offsetForValue((*impl)[0], defaultOffset));
>     LLINT_END();
> }
> 
>@@ -1325,13 +1325,13 @@ LLINT_SLOW_PATH_DECL(slow_path_switch_st
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpSwitchString>();
>-    JSValue scrutinee = LLINT_OP_C(bytecode.scrutinee).jsValue();
>-    int defaultOffset = JUMP_OFFSET(bytecode.defaultOffset);
>+    JSValue scrutinee = LLINT_OP_C(bytecode.m_scrutinee).jsValue();
>+    int defaultOffset = JUMP_OFFSET(bytecode.m_defaultOffset);
>     if (!scrutinee.isString())
>         JUMP_TO(defaultOffset);
>     else {
>         CodeBlock* codeBlock = exec->codeBlock();
>-        JUMP_TO(codeBlock->stringSwitchJumpTable(bytecode.tableIndex).offsetForValue(asString(scrutinee)->value(exec).impl(), defaultOffset));
>+        JUMP_TO(codeBlock->stringSwitchJumpTable(bytecode.m_tableIndex).offsetForValue(asString(scrutinee)->value(exec).impl(), defaultOffset));
>     }
>     LLINT_END();
> }
>@@ -1341,9 +1341,9 @@ LLINT_SLOW_PATH_DECL(slow_path_new_func)
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewFunc>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>     slowPathLogF("Creating function!\n");
>-    LLINT_RETURN(JSFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
>+    LLINT_RETURN(JSFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_new_generator_func)
>@@ -1351,9 +1351,9 @@ LLINT_SLOW_PATH_DECL(slow_path_new_gener
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewGeneratorFunc>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>     slowPathLogF("Creating function!\n");
>-    LLINT_RETURN(JSGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
>+    LLINT_RETURN(JSGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_new_async_func)
>@@ -1361,9 +1361,9 @@ LLINT_SLOW_PATH_DECL(slow_path_new_async
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewAsyncFunc>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>     slowPathLogF("Creating async function!\n");
>-    LLINT_RETURN(JSAsyncFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
>+    LLINT_RETURN(JSAsyncFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_new_async_generator_func)
>@@ -1371,9 +1371,9 @@ LLINT_SLOW_PATH_DECL(slow_path_new_async
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpNewAsyncGeneratorFunc>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>     slowPathLogF("Creating async generator function!\n");
>-    LLINT_RETURN(JSAsyncGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
>+    LLINT_RETURN(JSAsyncGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
> }
>     
> LLINT_SLOW_PATH_DECL(slow_path_new_func_exp)
>@@ -1382,8 +1382,8 @@ LLINT_SLOW_PATH_DECL(slow_path_new_func_
>     
>     auto bytecode = pc->as<OpNewFuncExp>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>-    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>+    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
>     
>     LLINT_RETURN(JSFunction::create(vm, executable, scope));
> }
>@@ -1394,8 +1394,8 @@ LLINT_SLOW_PATH_DECL(slow_path_new_gener
> 
>     auto bytecode = pc->as<OpNewGeneratorFuncExp>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>-    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>+    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
> 
>     LLINT_RETURN(JSGeneratorFunction::create(vm, executable, scope));
> }
>@@ -1406,8 +1406,8 @@ LLINT_SLOW_PATH_DECL(slow_path_new_async
>     
>     auto bytecode = pc->as<OpNewAsyncFuncExp>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>-    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>+    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
>     
>     LLINT_RETURN(JSAsyncFunction::create(vm, executable, scope));
> }
>@@ -1418,8 +1418,8 @@ LLINT_SLOW_PATH_DECL(slow_path_new_async
>         
>     auto bytecode = pc->as<OpNewAsyncGeneratorFuncExp>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>-    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>+    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
>         
>     LLINT_RETURN(JSAsyncGeneratorFunction::create(vm, executable, scope));
> }
>@@ -1428,8 +1428,8 @@ LLINT_SLOW_PATH_DECL(slow_path_set_funct
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpSetFunctionName>();
>-    JSFunction* func = jsCast<JSFunction*>(LLINT_OP(bytecode.function).Register::unboxedCell());
>-    JSValue name = LLINT_OP_C(bytecode.name).Register::jsValue();
>+    JSFunction* func = jsCast<JSFunction*>(LLINT_OP(bytecode.m_function).Register::unboxedCell());
>+    JSValue name = LLINT_OP_C(bytecode.m_name).Register::jsValue();
>     func->setFunctionName(exec, name);
>     LLINT_END();
> }
>@@ -1579,16 +1579,16 @@ inline SlowPathReturnType genericCall(Ex
>     // - If possible, link the call's inline cache.
>     // - Return a tuple of machine code address to call and the new call frame.
>     
>-    JSValue calleeAsValue = LLINT_OP_C(bytecode.callee).jsValue();
>+    JSValue calleeAsValue = LLINT_OP_C(bytecode.m_callee).jsValue();
>     
>-    ExecState* execCallee = exec - bytecode.argv;
>+    ExecState* execCallee = exec - bytecode.m_argv;
>     
>-    execCallee->setArgumentCountIncludingThis(bytecode.argc);
>+    execCallee->setArgumentCountIncludingThis(bytecode.m_argc);
>     execCallee->uncheckedR(CallFrameSlot::callee) = calleeAsValue;
>     execCallee->setCallerFrame(exec);
>     
>     auto& metadata = bytecode.metadata(exec);
>-    return setUpCall(execCallee, kind, calleeAsValue, &metadata.callLinkInfo);
>+    return setUpCall(execCallee, kind, calleeAsValue, &metadata.m_callLinkInfo);
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_call)
>@@ -1621,23 +1621,23 @@ LLINT_SLOW_PATH_DECL(slow_path_size_fram
>     switch (pc->opcodeID()) {
>     case op_call_varargs: {
>         auto bytecode = pc->as<OpCallVarargs>();
>-        numUsedStackSlots = -bytecode.firstFree.offset();
>-        arguments = LLINT_OP_C(bytecode.arguments).jsValue();
>-        firstVarArg = bytecode.firstVarArg;
>+        numUsedStackSlots = -bytecode.m_firstFree.offset();
>+        arguments = LLINT_OP_C(bytecode.m_arguments).jsValue();
>+        firstVarArg = bytecode.m_firstVarArg;
>         break;
>     }
>     case op_tail_call_varargs: {
>         auto bytecode = pc->as<OpTailCallVarargs>();
>-        numUsedStackSlots = -bytecode.firstFree.offset();
>-        arguments = LLINT_OP_C(bytecode.arguments).jsValue();
>-        firstVarArg = bytecode.firstVarArg;
>+        numUsedStackSlots = -bytecode.m_firstFree.offset();
>+        arguments = LLINT_OP_C(bytecode.m_arguments).jsValue();
>+        firstVarArg = bytecode.m_firstVarArg;
>         break;
>     }
>     case op_construct_varargs: {
>         auto bytecode = pc->as<OpConstructVarargs>();
>-        numUsedStackSlots = -bytecode.firstFree.offset();
>-        arguments = LLINT_OP_C(bytecode.arguments).jsValue();
>-        firstVarArg = bytecode.firstVarArg;
>+        numUsedStackSlots = -bytecode.m_firstFree.offset();
>+        arguments = LLINT_OP_C(bytecode.m_arguments).jsValue();
>+        firstVarArg = bytecode.m_firstVarArg;
>         break;
>     }
>     default:
>@@ -1660,7 +1660,7 @@ LLINT_SLOW_PATH_DECL(slow_path_size_fram
>     // - Set up a call frame with the same arguments as the current frame.
> 
>     auto bytecode = pc->as<OpTailCallForwardArguments>();
>-    unsigned numUsedStackSlots = -bytecode.firstFree.offset();
>+    unsigned numUsedStackSlots = -bytecode.m_firstFree.offset();
> 
>     unsigned arguments = sizeFrameForForwardArguments(exec, vm, numUsedStackSlots);
>     LLINT_CALL_CHECK_EXCEPTION(exec, exec);
>@@ -1687,15 +1687,15 @@ inline SlowPathReturnType varargsSetup(E
>     // - Return a tuple of machine code address to call and the new call frame.
> 
>     auto bytecode = pc->as<Op>();
>-    JSValue calleeAsValue = LLINT_OP_C(bytecode.callee).jsValue();
>+    JSValue calleeAsValue = LLINT_OP_C(bytecode.m_callee).jsValue();
> 
>     ExecState* execCallee = vm.newCallFrameReturnValue;
> 
>     if (set == SetArgumentsWith::Object) {
>-        setupVarargsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.thisValue).jsValue(), LLINT_OP_C(bytecode.arguments).jsValue(), bytecode.firstVarArg, vm.varargsLength);
>+        setupVarargsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.m_thisValue).jsValue(), LLINT_OP_C(bytecode.m_arguments).jsValue(), bytecode.m_firstVarArg, vm.varargsLength);
>         LLINT_CALL_CHECK_EXCEPTION(exec, exec);
>     } else
>-        setupForwardArgumentsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.thisValue).jsValue(), vm.varargsLength);
>+        setupForwardArgumentsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.m_thisValue).jsValue(), vm.varargsLength);
> 
>     execCallee->setCallerFrame(exec);
>     execCallee->uncheckedR(CallFrameSlot::callee) = calleeAsValue;
>@@ -1728,11 +1728,11 @@ inline SlowPathReturnType commonCallEval
> {
>     LLINT_BEGIN_NO_SET_PC();
>     auto bytecode = pc->as<OpCallEval>();
>-    JSValue calleeAsValue = LLINT_OP(bytecode.callee).jsValue();
>+    JSValue calleeAsValue = LLINT_OP(bytecode.m_callee).jsValue();
>     
>-    ExecState* execCallee = exec - bytecode.argv;
>+    ExecState* execCallee = exec - bytecode.m_argv;
>     
>-    execCallee->setArgumentCountIncludingThis(bytecode.argc);
>+    execCallee->setArgumentCountIncludingThis(bytecode.m_argc);
>     execCallee->setCallerFrame(exec);
>     execCallee->uncheckedR(CallFrameSlot::callee) = calleeAsValue;
>     execCallee->setReturnPC(returnPoint.executableAddress());
>@@ -1760,21 +1760,21 @@ LLINT_SLOW_PATH_DECL(slow_path_strcat)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpStrcat>();
>-    LLINT_RETURN(jsStringFromRegisterArray(exec, &LLINT_OP(bytecode.src), bytecode.count));
>+    LLINT_RETURN(jsStringFromRegisterArray(exec, &LLINT_OP(bytecode.m_src), bytecode.m_count));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_to_primitive)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpToPrimitive>();
>-    LLINT_RETURN(LLINT_OP_C(bytecode.src).jsValue().toPrimitive(exec));
>+    LLINT_RETURN(LLINT_OP_C(bytecode.m_src).jsValue().toPrimitive(exec));
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_throw)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpThrow>();
>-    LLINT_THROW(LLINT_OP_C(bytecode.value).jsValue());
>+    LLINT_THROW(LLINT_OP_C(bytecode.m_value).jsValue());
> }
> 
> LLINT_SLOW_PATH_DECL(slow_path_handle_traps)
>@@ -1790,7 +1790,7 @@ LLINT_SLOW_PATH_DECL(slow_path_debug)
> {
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpDebug>();
>-    vm.interpreter->debug(exec, bytecode.debugHookType);
>+    vm.interpreter->debug(exec, bytecode.m_debugHookType);
>     
>     LLINT_END();
> }
>@@ -1808,15 +1808,15 @@ LLINT_SLOW_PATH_DECL(slow_path_get_from_
>     LLINT_BEGIN();
>     auto bytecode = pc->as<OpGetFromScope>();
>     auto& metadata = bytecode.metadata(exec);
>-    const Identifier& ident = exec->codeBlock()->identifier(bytecode.var);
>-    JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.scope).jsValue());
>+    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_var);
>+    JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.m_scope).jsValue());
> 
>     // ModuleVar is always converted to ClosureVar for get_from_scope.
>-    ASSERT(metadata.getPutInfo.resolveType() != ModuleVar);
>+    ASSERT(metadata.m_getPutInfo.resolveType() != ModuleVar);
> 
>     LLINT_RETURN(scope->getPropertySlot(exec, ident, [&] (bool found, PropertySlot& slot) -> JSValue {
>         if (!found) {
>-            if (metadata.getPutInfo.resolveMode() == ThrowIfNotFound)
>+            if (metadata.m_getPutInfo.resolveMode() == ThrowIfNotFound)
>                 return throwException(exec, throwScope, createUndefinedVariableError(exec, ident));
>             return jsUndefined();
>         }
>@@ -1844,18 +1844,18 @@ LLINT_SLOW_PATH_DECL(slow_path_put_to_sc
>     auto bytecode = pc->as<OpPutToScope>();
>     auto& metadata = bytecode.metadata(exec);
>     CodeBlock* codeBlock = exec->codeBlock();
>-    const Identifier& ident = codeBlock->identifier(bytecode.var);
>-    JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.scope).jsValue());
>-    JSValue value = LLINT_OP_C(bytecode.value).jsValue();
>-    if (metadata.getPutInfo.resolveType() == LocalClosureVar) {
>+    const Identifier& ident = codeBlock->identifier(bytecode.m_var);
>+    JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.m_scope).jsValue());
>+    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
>+    if (metadata.m_getPutInfo.resolveType() == LocalClosureVar) {
>         JSLexicalEnvironment* environment = jsCast<JSLexicalEnvironment*>(scope);
>-        environment->variableAt(ScopeOffset(metadata.operand)).set(vm, environment, value);
>+        environment->variableAt(ScopeOffset(metadata.m_operand)).set(vm, environment, value);
>         
>         // Have to do this *after* the write, because if this puts the set into IsWatched, then we need
>         // to have already changed the value of the variable. Otherwise we might watch and constant-fold
>         // to the Undefined value from before the assignment.
>-        if (metadata.watchpointSet)
>-            metadata.watchpointSet->touch(vm, "Executed op_put_scope<LocalClosureVar>");
>+        if (metadata.m_watchpointSet)
>+            metadata.m_watchpointSet->touch(vm, "Executed op_put_scope<LocalClosureVar>");
>         LLINT_END();
>     }
> 
>@@ -1863,7 +1863,7 @@ LLINT_SLOW_PATH_DECL(slow_path_put_to_sc
>     LLINT_CHECK_EXCEPTION();
>     if (hasProperty
>         && scope->isGlobalLexicalEnvironment()
>-        && !isInitialization(metadata.getPutInfo.initializationMode())) {
>+        && !isInitialization(metadata.m_getPutInfo.initializationMode())) {
>         // When we can't statically prove we need a TDZ check, we must perform the check on the slow path.
>         PropertySlot slot(scope, PropertySlot::InternalMethodType::Get);
>         JSGlobalLexicalEnvironment::getOwnPropertySlot(scope, exec, ident, slot);
>@@ -1871,10 +1871,10 @@ LLINT_SLOW_PATH_DECL(slow_path_put_to_sc
>             LLINT_THROW(createTDZError(exec));
>     }
> 
>-    if (metadata.getPutInfo.resolveMode() == ThrowIfNotFound && !hasProperty)
>+    if (metadata.m_getPutInfo.resolveMode() == ThrowIfNotFound && !hasProperty)
>         LLINT_THROW(createUndefinedVariableError(exec, ident));
> 
>-    PutPropertySlot slot(scope, codeBlock->isStrictMode(), PutPropertySlot::UnknownContext, isInitialization(metadata.getPutInfo.initializationMode()));
>+    PutPropertySlot slot(scope, codeBlock->isStrictMode(), PutPropertySlot::UnknownContext, isInitialization(metadata.m_getPutInfo.initializationMode()));
>     scope->methodTable(vm)->put(scope, exec, ident, value, slot);
>     
>     CommonSlowPaths::tryCachePutToScopeGlobal(exec, codeBlock, bytecode, scope, slot, ident);
>@@ -1897,7 +1897,7 @@ LLINT_SLOW_PATH_DECL(slow_path_log_shado
>     LLINT_BEGIN();
>     
>     auto bytecode = pc->as<OpLogShadowChickenPrologue>();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>     vm.shadowChicken().log(vm, exec, ShadowChicken::Packet::prologue(exec->jsCallee(), exec, exec->callerFrame(), scope));
>     
>     LLINT_END();
>@@ -1908,8 +1908,8 @@ LLINT_SLOW_PATH_DECL(slow_path_log_shado
>     LLINT_BEGIN();
> 
>     auto bytecode = pc->as<OpLogShadowChickenTail>();
>-    JSValue thisValue = LLINT_OP(bytecode.thisValue).jsValue();
>-    JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
>+    JSValue thisValue = LLINT_OP(bytecode.m_thisValue).jsValue();
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
>     
> #if USE(JSVALUE64)
>     CallSiteIndex callSiteIndex(exec->codeBlock()->bytecodeOffset(pc));
>@@ -1929,7 +1929,7 @@ LLINT_SLOW_PATH_DECL(slow_path_profile_c
> 
>     auto bytecode = pc->as<OpCatch>();
>     auto& metadata = bytecode.metadata(exec);
>-    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());
>     });
> 
>Index: Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm
>===================================================================
>--- Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm	(revision 239990)
>+++ Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm	(working copy)
>@@ -1,4 +1,4 @@
>-# 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
>@@ -35,27 +35,27 @@ macro nextInstructionWide()
>     jmp [t1, t0, 4], BytecodePtrTag
> end
> 
>-macro getuOperandNarrow(op, field, dst)
>-    loadb constexpr %op%_%field%_index[PC], dst
>+macro getuOperandNarrow(op, fieldName, dst)
>+    loadb constexpr %op%_%fieldName%_index[PC], dst
> end
> 
>-macro getOperandNarrow(op, field, dst)
>-    loadbsp constexpr %op%_%field%_index[PC], dst
>+macro getOperandNarrow(op, fieldName, dst)
>+    loadbsp constexpr %op%_%fieldName%_index[PC], dst
> end
> 
>-macro getuOperandWide(op, field, dst)
>-    loadi constexpr %op%_%field%_index * 4 + 1[PC], dst
>+macro getuOperandWide(op, fieldName, dst)
>+    loadi constexpr %op%_%fieldName%_index * 4 + 1[PC], dst
> end
> 
>-macro getOperandWide(op, field, dst)
>-    loadis constexpr %op%_%field%_index * 4 + 1[PC], dst
>+macro getOperandWide(op, fieldName, dst)
>+    loadis constexpr %op%_%fieldName%_index * 4 + 1[PC], dst
> end
> 
> macro makeReturn(get, dispatch, fn)
>     fn(macro(tag, payload)
>         move tag, t5
>         move payload, t3
>-        get(dst, t2)
>+        get(m_dst, t2)
>         storei t5, TagOffset[cfr, t2, 8]
>         storei t3, PayloadOffset[cfr, t2, 8]
>         dispatch()
>@@ -69,7 +69,7 @@ macro makeReturnProfiled(op, get, metada
> 
>         metadata(t5, t2)
>         valueProfile(op, t5, t1, t0)
>-        get(dst, t2)
>+        get(m_dst, t2)
>         storei t1, TagOffset[cfr, t2, 8]
>         storei t0, PayloadOffset[cfr, t2, 8]
>         dispatch()
>@@ -79,7 +79,7 @@ end
> 
> macro dispatchAfterCall(size, op, dispatch)
>     loadi ArgumentCount + TagOffset[cfr], PC
>-    get(size, op, dst, t3)
>+    get(size, op, m_dst, t3)
>     storei r1, TagOffset[cfr, t3, 8]
>     storei r0, PayloadOffset[cfr, t3, 8]
>     metadata(size, op, t2, t3)
>@@ -438,10 +438,10 @@ macro checkSwitchToJITForLoop()
>         end)
> end
> 
>-macro loadVariable(get, operand, index, tag, payload)
>-    get(operand, index)
>-    loadi TagOffset[cfr, index, 8], tag
>-    loadi PayloadOffset[cfr, index, 8], payload
>+macro loadVariable(get, fieldName, indexReg, tagReg, payloadReg)
>+    get(fieldName, indexReg)
>+    loadi TagOffset[cfr, indexReg, 8], tagReg
>+    loadi PayloadOffset[cfr, indexReg, 8], payloadReg
> end
> 
> # Index, tag, and payload must be different registers. Index is not
>@@ -532,8 +532,8 @@ macro loadConstantOrVariablePayloadUnche
>         payload)
> end
> 
>-macro writeBarrierOnOperand(size, get, cellOperand)
>-    get(cellOperand, t1)
>+macro writeBarrierOnOperand(size, get, cellFieldName)
>+    get(cellFieldName, t1)
>     loadConstantOrVariablePayload(size, t1, CellTag, t2, .writeBarrierDone)
>     skipIfIsRememberedOrInEden(
>         t2, 
>@@ -550,21 +550,21 @@ macro writeBarrierOnOperand(size, get, c
> .writeBarrierDone:
> end
> 
>-macro writeBarrierOnOperands(size, get, cellOperand, valueOperand)
>-    get(valueOperand, t1)
>+macro writeBarrierOnOperands(size, get, cellFieldName, valueFieldName)
>+    get(valueFieldName, t1)
>     loadConstantOrVariableTag(size, t1, t0)
>     bineq t0, CellTag, .writeBarrierDone
> 
>-    writeBarrierOnOperand(size, get, cellOperand)
>+    writeBarrierOnOperand(size, get, cellFieldName)
> .writeBarrierDone:
> end
> 
>-macro writeBarrierOnGlobal(size, get, valueOperand, loadHelper)
>-    get(valueOperand, t1)
>+macro writeBarrierOnGlobal(size, get, valueFieldName, loadMacro)
>+    get(valueFieldName, t1)
>     loadConstantOrVariableTag(size, t1, t0)
>     bineq t0, CellTag, .writeBarrierDone
> 
>-    loadHelper(t3)
>+    loadMacro(t3)
> 
>     skipIfIsRememberedOrInEden(
>         t3,
>@@ -581,16 +581,16 @@ macro writeBarrierOnGlobal(size, get, va
> .writeBarrierDone:
> end
> 
>-macro writeBarrierOnGlobalObject(size, get, valueOperand)
>-    writeBarrierOnGlobal(size, get, valueOperand,
>+macro writeBarrierOnGlobalObject(size, get, valueFieldName)
>+    writeBarrierOnGlobal(size, get, valueFieldName,
>         macro(registerToStoreGlobal)
>             loadp CodeBlock[cfr], registerToStoreGlobal
>             loadp CodeBlock::m_globalObject[registerToStoreGlobal], registerToStoreGlobal
>         end)
> end
> 
>-macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueOperand)
>-    writeBarrierOnGlobal(size, get, valueOperand,
>+macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueFieldName)
>+    writeBarrierOnGlobal(size, get, valueFieldName,
>         macro(registerToStoreGlobal)
>             loadp CodeBlock[cfr], registerToStoreGlobal
>             loadp CodeBlock::m_globalObject[registerToStoreGlobal], registerToStoreGlobal
>@@ -599,8 +599,8 @@ macro writeBarrierOnGlobalLexicalEnviron
> end
> 
> macro valueProfile(op, metadata, tag, payload)
>-    storei tag, %op%::Metadata::profile.m_buckets + TagOffset[metadata]
>-    storei payload, %op%::Metadata::profile.m_buckets + PayloadOffset[metadata]
>+    storei tag, %op%::Metadata::m_profile.m_buckets + TagOffset[metadata]
>+    storei payload, %op%::Metadata::m_profile.m_buckets + PayloadOffset[metadata]
> end
> 
> 
>@@ -713,7 +713,7 @@ _llint_op_enter:
> 
> 
> llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)
>-    get(index, t2)
>+    get(m_index, t2)
>     loadi PayloadOffset + ArgumentCount[cfr], t0
>     bilteq t0, t2, .opGetArgumentOutOfBounds
>     loadi ThisArgumentOffset + TagOffset[cfr, t2, 8], t0
>@@ -740,12 +740,12 @@ end)
> 
> 
> llintOpWithMetadata(op_to_this, OpToThis, macro (size, get, dispatch, metadata, return)
>-    get(srcDst, t0)
>+    get(m_srcDst, t0)
>     bineq TagOffset[cfr, t0, 8], CellTag, .opToThisSlow
>     loadi PayloadOffset[cfr, t0, 8], t0
>     bbneq JSCell::m_type[t0], FinalObjectType, .opToThisSlow
>     metadata(t2, t3)
>-    loadp OpToThis::Metadata::cachedStructure[t2], t2
>+    loadp OpToThis::Metadata::m_cachedStructure[t2], t2
>     bpneq JSCell::m_structureID[t0], t2, .opToThisSlow
>     dispatch()
> 
>@@ -756,7 +756,7 @@ end)
> 
> 
> llintOp(op_check_tdz, OpCheckTdz, macro (size, get, dispatch)
>-    get(target, t0)
>+    get(m_target, t0)
>     loadConstantOrVariableTag(size, t0, t1)
>     bineq t1, EmptyValueTag, .opNotTDZ
>     callSlowPath(_slow_path_throw_tdz_error)
>@@ -767,14 +767,14 @@ end)
> 
> 
> llintOpWithReturn(op_mov, OpMov, macro (size, get, dispatch, return)
>-    get(src, t1)
>+    get(m_src, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>     return(t2, t3)
> end)
> 
> 
> llintOpWithReturn(op_not, OpNot, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2, t3)
>     bineq t2, BooleanTag, .opNotSlow
>     xori 1, t3
>@@ -788,8 +788,8 @@ end)
> 
> macro equalityComparisonOp(name, op, integerComparison)
>     llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         bineq t2, t3, .opEqSlow
>@@ -807,8 +807,8 @@ end
> 
> macro equalityJumpOp(name, op, integerComparison)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         bineq t2, t3, .slow
>@@ -818,7 +818,7 @@ macro equalityJumpOp(name, op, integerCo
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -829,7 +829,7 @@ end
> 
> macro equalNullComparisonOp(name, op, fn)
>     llintOpWithReturn(name, op, macro (size, get, dispatch, return)
>-        get(operand, t0)
>+        get(m_operand, t0)
>         assertNotConstant(size, t0)
>         loadi TagOffset[cfr, t0, 8], t1
>         loadi PayloadOffset[cfr, t0, 8], t0
>@@ -860,7 +860,7 @@ equalNullComparisonOp(op_neq_null, OpNeq
> 
> 
> llintOpWithReturn(op_is_undefined_or_null, OpIsUndefinedOrNull, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     assertNotConstant(size, t0)
>     loadi TagOffset[cfr, t0, 8], t1
>     ori 1, t1
>@@ -871,8 +871,8 @@ end)
> 
> macro strictEqOp(name, op, equalityOperation)
>     llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         bineq t2, t3, .slow
>@@ -893,8 +893,8 @@ end
> 
> macro strictEqualityJumpOp(name, op, equalityOperation)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         bineq t2, t3, .slow
>@@ -907,7 +907,7 @@ macro strictEqualityJumpOp(name, op, equ
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -934,7 +934,7 @@ strictEqualityJumpOp(jnstricteq, OpJnstr
> 
> macro preOp(name, op, operation)
>     llintOp(op_%name%, op, macro (size, get, dispatch)
>-        get(srcDst, t0)
>+        get(m_srcDst, t0)
>         bineq TagOffset[cfr, t0, 8], Int32Tag, .slow
>         loadi PayloadOffset[cfr, t0, 8], t1
>         operation(t1, .slow)
>@@ -949,7 +949,7 @@ end
> 
> 
> llintOpWithProfile(op_to_number, OpToNumber, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2, t3)
>     bieq t2, Int32Tag, .opToNumberIsInt
>     biaeq t2, LowestTag, .opToNumberSlow
>@@ -963,7 +963,7 @@ end)
> 
> 
> llintOpWithReturn(op_to_string, OpToString, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2, t3)
>     bineq t2, CellTag, .opToStringSlow
>     bbneq JSCell::m_type[t3], StringType, .opToStringSlow
>@@ -977,7 +977,7 @@ end)
> 
> 
> llintOpWithProfile(op_to_object, OpToObject, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2, t3)
>     bineq t2, CellTag, .opToObjectSlow
>     bbb JSCell::m_type[t3], ObjectType, .opToObjectSlow
>@@ -992,11 +992,11 @@ end)
> llintOpWithMetadata(op_negate, OpNegate, macro (size, get, dispatch, metadata, return)
> 
>     macro arithProfile(type)
>-        ori type, OpNegate::Metadata::arithProfile[t5]
>+        ori type, OpNegate::Metadata::m_arithProfile[t5]
>     end
> 
>     metadata(t5, t0)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t1, t2)
>     bineq t1, Int32Tag, .opNegateSrcNotInt
>     btiz t2, 0x7fffffff, .opNegateSlow
>@@ -1018,18 +1018,18 @@ end)
> macro binaryOpCustomStore(name, op, integerOperationAndStore, doubleOperation)
>     llintOpWithMetadata(op_%name%, op, macro (size, get, dispatch, metadata, return)
>         macro arithProfile(type)
>-            ori type, %op%::Metadata::arithProfile[t5]
>+            ori type, %op%::Metadata::m_arithProfile[t5]
>         end
> 
>         metadata(t5, t2)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         bineq t2, Int32Tag, .op1NotInt
>         bineq t3, Int32Tag, .op2NotInt
>         arithProfile(ArithProfileIntInt)
>-        get(dst, t2)
>+        get(m_dst, t2)
>         integerOperationAndStore(t3, t1, t0, .slow, t2)
>         dispatch()
> 
>@@ -1045,7 +1045,7 @@ macro binaryOpCustomStore(name, op, inte
>         fii2d t1, t3, ft1
>         arithProfile(ArithProfileNumberNumber)
>     .op1NotIntReady:
>-        get(dst, t1)
>+        get(m_dst, t1)
>         fii2d t0, t2, ft0
>         doubleOperation(ft1, ft0)
>         stored ft0, [cfr, t1, 8]
>@@ -1053,7 +1053,7 @@ macro binaryOpCustomStore(name, op, inte
> 
>     .op2NotInt:
>         # First operand is definitely an int, the second operand is definitely not.
>-        get(dst, t2)
>+        get(m_dst, t2)
>         bia t3, LowestTag, .slow
>         arithProfile(ArithProfileIntNumber)
>         ci2d t0, ft0
>@@ -1120,7 +1120,7 @@ binaryOpCustomStore(div, OpDiv,
> 
> 
> llintOpWithReturn(op_unsigned, OpUnsigned, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariablePayload(size, t1, Int32Tag, t2, .opUnsignedSlow)
>     bilt t2, 0, .opUnsignedSlow
>     return (Int32Tag, t2)
>@@ -1132,8 +1132,8 @@ end)
> 
> macro commonBitOp(opKind, name, op, operation)
>     opKind(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         bineq t3, Int32Tag, .slow
>@@ -1177,7 +1177,7 @@ bitOpProfiled(bitor, OpBitor,
>     macro (left, right) ori left, right end)
> 
> llintOpWithProfile(op_bitnot, OpBitnot, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2, t3)
>     bineq t2, Int32Tag, .opBitNotSlow
>     noti t3
>@@ -1189,11 +1189,11 @@ llintOpWithProfile(op_bitnot, OpBitnot, 
> end)
> 
> llintOp(op_overrides_has_instance, OpOverridesHasInstance, macro (size, get, dispatch)
>-    get(dst, t3)
>+    get(m_dst, t3)
>     storei BooleanTag, TagOffset[cfr, t3, 8]
> 
>     # First check if hasInstanceValue is the one on Function.prototype[Symbol.hasInstance]
>-    get(hasInstanceValue, t0)
>+    get(m_hasInstanceValue, t0)
>     loadConstantOrVariablePayload(size, t0, CellTag, t2, .opOverrideshasInstanceValueNotCell)
>     loadConstantOrVariable(size, t0, t1, t2)
>     bineq t1, CellTag, .opOverrideshasInstanceValueNotCell
>@@ -1205,7 +1205,7 @@ llintOp(op_overrides_has_instance, OpOve
>     bineq t1, t2, .opOverrideshasInstanceValueNotDefault
> 
>     # We know the constructor is a cell.
>-    get(constructor, t0)
>+    get(m_constructor, t0)
>     loadConstantOrVariablePayloadUnchecked(size, t0, t1)
>     tbz JSCell::m_flags[t1], ImplementsDefaultHasInstance, t0
>     storei t0, PayloadOffset[cfr, t3, 8]
>@@ -1219,7 +1219,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_empty, OpIsEmpty, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>     cieq t2, EmptyValueTag, t3
>     return(BooleanTag, t3)
>@@ -1227,7 +1227,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_undefined, OpIsUndefined, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>     bieq t2, CellTag, .opIsUndefinedCell
>     cieq t2, UndefinedTag, t3
>@@ -1245,7 +1245,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_boolean, OpIsBoolean, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariableTag(size, t1, t0)
>     cieq t0, BooleanTag, t0
>     return(BooleanTag, t0)
>@@ -1253,7 +1253,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_number, OpIsNumber, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariableTag(size, t1, t0)
>     addi 1, t0
>     cib t0, LowestTag + 1, t1
>@@ -1262,10 +1262,10 @@ end)
> 
> 
> llintOpWithReturn(op_is_cell_with_type, OpIsCellWithType, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0, t3)
>     bineq t0, CellTag, .notCellCase
>-    getu(size, OpIsCellWithType, type, t0)
>+    getu(size, OpIsCellWithType, m_type, t0)
>     cbeq JSCell::m_type[t3], t0, t1
>     return(BooleanTag, t1)
> .notCellCase:
>@@ -1274,7 +1274,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_object, OpIsObject, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0, t3)
>     bineq t0, CellTag, .opIsObjectNotCell
>     cbaeq JSCell::m_type[t3], ObjectType, t1
>@@ -1327,10 +1327,10 @@ end
> 
> llintOpWithMetadata(op_get_by_id_direct, OpGetByIdDirect, macro (size, get, dispatch, metadata, return)
>     metadata(t5, t0)
>-    get(base, t0)
>-    loadi OpGetByIdDirect::Metadata::structure[t5], t1
>+    get(m_base, t0)
>+    loadi OpGetByIdDirect::Metadata::m_structure[t5], t1
>     loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdDirectSlow)
>-    loadi OpGetByIdDirect::Metadata::offset[t5], t2
>+    loadi OpGetByIdDirect::Metadata::m_offset[t5], t2
>     bineq JSCell::m_structureID[t3], t1, .opGetByIdDirectSlow
>     loadPropertyAtVariableOffset(t2, t3, t0, t1)
>     valueProfile(OpGetByIdDirect, t5, t0, t1)
>@@ -1344,16 +1344,16 @@ end)
> 
> llintOpWithMetadata(op_get_by_id, OpGetById, macro (size, get, dispatch, metadata, return)
>     metadata(t5, t0)
>-    loadb OpGetById::Metadata::mode[t5], t1
>-    get(base, t0)
>+    loadb OpGetById::Metadata::m_mode[t5], t1
>+    get(m_base, t0)
> 
> .opGetByIdProtoLoad:
>     bbneq t1, constexpr GetByIdMode::ProtoLoad, .opGetByIdArrayLength
>-    loadi OpGetById::Metadata::modeMetadata.protoLoadMode.structure[t5], t1
>+    loadi OpGetById::Metadata::m_modeMetadata.protoLoadMode.structure[t5], t1
>     loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
>-    loadis OpGetById::Metadata::modeMetadata.protoLoadMode.cachedOffset[t5], t2
>+    loadis OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedOffset[t5], t2
>     bineq JSCell::m_structureID[t3], t1, .opGetByIdSlow
>-    loadp OpGetById::Metadata::modeMetadata.protoLoadMode.cachedSlot[t5], t3
>+    loadp OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedSlot[t5], t3
>     loadPropertyAtVariableOffset(t2, t3, t0, t1)
>     valueProfile(OpGetById, t5, t0, t1)
>     return(t0, t1)
>@@ -1362,7 +1362,7 @@ llintOpWithMetadata(op_get_by_id, OpGetB
>     bbneq t1, constexpr GetByIdMode::ArrayLength, .opGetByIdUnset
>     loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
>     move t3, t2
>-    arrayProfile(OpGetById::Metadata::modeMetadata.arrayLengthMode.arrayProfile, t2, t5, t0)
>+    arrayProfile(OpGetById::Metadata::m_modeMetadata.arrayLengthMode.arrayProfile, t2, t5, t0)
>     btiz t2, IsArray, .opGetByIdSlow
>     btiz t2, IndexingShapeMask, .opGetByIdSlow
>     loadp JSObject::m_butterfly[t3], t0
>@@ -1373,16 +1373,16 @@ llintOpWithMetadata(op_get_by_id, OpGetB
> 
> .opGetByIdUnset:
>     bbneq t1, constexpr GetByIdMode::Unset, .opGetByIdDefault
>-    loadi OpGetById::Metadata::modeMetadata.unsetMode.structure[t5], t1
>+    loadi OpGetById::Metadata::m_modeMetadata.unsetMode.structure[t5], t1
>     loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
>     bineq JSCell::m_structureID[t3], t1, .opGetByIdSlow
>     valueProfile(OpGetById, t5, UndefinedTag, 0)
>     return(UndefinedTag, 0)
> 
> .opGetByIdDefault:
>-    loadi OpGetById::Metadata::modeMetadata.defaultMode.structure[t5], t1
>+    loadi OpGetById::Metadata::m_modeMetadata.defaultMode.structure[t5], t1
>     loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
>-    loadis OpGetById::Metadata::modeMetadata.defaultMode.cachedOffset[t5], t2
>+    loadis OpGetById::Metadata::m_modeMetadata.defaultMode.cachedOffset[t5], t2
>     bineq JSCell::m_structureID[t3], t1, .opGetByIdSlow
>     loadPropertyAtVariableOffset(t2, t3, t0, t1)
>     valueProfile(OpGetById, t5, t0, t1)
>@@ -1395,12 +1395,12 @@ end)
> 
> 
> llintOpWithMetadata(op_put_by_id, OpPutById, macro (size, get, dispatch, metadata, return)
>-    writeBarrierOnOperands(size, get, base, value)
>+    writeBarrierOnOperands(size, get, m_base, m_value)
>     metadata(t5, t3)
>-    get(base, t3)
>+    get(m_base, t3)
>     loadConstantOrVariablePayload(size, t3, CellTag, t0, .opPutByIdSlow)
>     loadi JSCell::m_structureID[t0], t2
>-    bineq t2, OpPutById::Metadata::oldStructure[t5], .opPutByIdSlow
>+    bineq t2, OpPutById::Metadata::m_oldStructure[t5], .opPutByIdSlow
> 
>     # At this point, we have:
>     # t5 -> metadata
>@@ -1408,9 +1408,9 @@ llintOpWithMetadata(op_put_by_id, OpPutB
>     # t0 -> object base
>     # We will lose currentStructureID in the shenanigans below.
> 
>-    get(value, t1)
>+    get(m_value, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>-    loadi OpPutById::Metadata::flags[t5], t1
>+    loadi OpPutById::Metadata::m_flags[t5], t1
> 
>     # At this point, we have:
>     # t0 -> object base
>@@ -1485,16 +1485,16 @@ llintOpWithMetadata(op_put_by_id, OpPutB
>     bineq t1, JSCell::m_structureID[t3], .opPutByIdSlow
> 
> .opPutByIdDoneCheckingTypes:
>-    loadi OpPutById::Metadata::newStructure[t5], t1
>+    loadi OpPutById::Metadata::m_newStructure[t5], t1
> 
>     btiz t1, .opPutByIdNotTransition
> 
>     # This is the transition case. t1 holds the new Structure*. If we have a chain, we need to
>     # check it. t0 is the base. We may clobber t1 to use it as scratch.
>-    loadp OpPutById::Metadata::structureChain[t5], t3
>+    loadp OpPutById::Metadata::m_structureChain[t5], t3
>     btpz t3, .opPutByIdTransitionDirect
> 
>-    loadi OpPutById::Metadata::oldStructure[t5], t2 # Need old structure again.
>+    loadi OpPutById::Metadata::m_oldStructure[t5], t2 # Need old structure again.
>     loadp StructureChain::m_vector[t3], t3
>     assert(macro (ok) btpnz t3, ok end)
> 
>@@ -1508,22 +1508,22 @@ llintOpWithMetadata(op_put_by_id, OpPutB
>     btpnz t2, .opPutByIdTransitionChainLoop
> 
> .opPutByIdTransitionChainDone:
>-    loadi OpPutById::Metadata::newStructure[t5], t1
>+    loadi OpPutById::Metadata::m_newStructure[t5], t1
> 
> .opPutByIdTransitionDirect:
>     storei t1, JSCell::m_structureID[t0]
>-    get(value, t1)
>+    get(m_value, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>-    loadi OpPutById::Metadata::offset[t5], t1
>+    loadi OpPutById::Metadata::m_offset[t5], t1
>     storePropertyAtVariableOffset(t1, t0, t2, t3)
>-    writeBarrierOnOperand(size, get, base)
>+    writeBarrierOnOperand(size, get, m_base)
>     dispatch()
> 
> .opPutByIdNotTransition:
>     # The only thing live right now is t0, which holds the base.
>-    get(value, t1)
>+    get(m_value, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>-    loadi OpPutById::Metadata::offset[t5], t1
>+    loadi OpPutById::Metadata::m_offset[t5], t1
>     storePropertyAtVariableOffset(t1, t0, t2, t3)
>     dispatch()
> 
>@@ -1535,11 +1535,11 @@ end)
> 
> llintOpWithMetadata(op_get_by_val, OpGetByVal, macro (size, get, dispatch, metadata, return)
>     metadata(t5, t2)
>-    get(base, t2)
>+    get(m_base, t2)
>     loadConstantOrVariablePayload(size, t2, CellTag, t0, .opGetByValSlow)
>     move t0, t2
>-    arrayProfile(OpGetByVal::Metadata::arrayProfile, t2, t5, t1)
>-    get(property, t3)
>+    arrayProfile(OpGetByVal::Metadata::m_arrayProfile, t2, t5, t1)
>+    get(m_property, t3)
>     loadConstantOrVariablePayload(size, t3, Int32Tag, t1, .opGetByValSlow)
>     loadp JSObject::m_butterfly[t0], t3
>     andi IndexingShapeMask, t2
>@@ -1559,7 +1559,7 @@ llintOpWithMetadata(op_get_by_val, OpGet
>     bdnequn ft0, ft0, .opGetByValSlow
>     # FIXME: This could be massively optimized.
>     fd2ii ft0, t1, t2
>-    get(dst, t0)
>+    get(m_dst, t0)
>     jmp .opGetByValNotEmpty
> 
> .opGetByValNotDouble:
>@@ -1570,7 +1570,7 @@ llintOpWithMetadata(op_get_by_val, OpGet
>     loadi ArrayStorage::m_vector + PayloadOffset[t3, t1, 8], t1
> 
> .opGetByValDone:
>-    get(dst, t0)
>+    get(m_dst, t0)
>     bieq t2, EmptyValueTag, .opGetByValSlow
> .opGetByValNotEmpty:
>     storei t2, TagOffset[cfr, t0, 8]
>@@ -1589,25 +1589,25 @@ macro putByValOp(name, op)
>         macro contiguousPutByVal(storeCallback)
>             biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .outOfBounds
>         .storeResult:
>-            get(value, t2)
>+            get(m_value, t2)
>             storeCallback(t2, t1, t0, t3)
>             dispatch()
> 
>         .outOfBounds:
>             biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t0], .opPutByValOutOfBounds
>-            storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
>+            storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
>             addi 1, t3, t2
>             storei t2, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0]
>             jmp .storeResult
>         end
> 
>-        writeBarrierOnOperands(size, get, base, value)
>+        writeBarrierOnOperands(size, get, m_base, m_value)
>         metadata(t5, t0)
>-        get(base, t0)
>+        get(m_base, t0)
>         loadConstantOrVariablePayload(size, t0, CellTag, t1, .opPutByValSlow)
>         move t1, t2
>-        arrayProfile(%op%::Metadata::arrayProfile, t2, t5, t0)
>-        get(property, t0)
>+        arrayProfile(%op%::Metadata::m_arrayProfile, t2, t5, t0)
>+        get(m_property, t0)
>         loadConstantOrVariablePayload(size, t0, Int32Tag, t3, .opPutByValSlow)
>         loadp JSObject::m_butterfly[t1], t0
>         btinz t2, CopyOnWrite, .opPutByValSlow
>@@ -1653,14 +1653,14 @@ macro putByValOp(name, op)
>         biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t0], .opPutByValOutOfBounds
>         bieq ArrayStorage::m_vector + TagOffset[t0, t3, 8], EmptyValueTag, .opPutByValArrayStorageEmpty
>     .opPutByValArrayStorageStoreResult:
>-        get(value, t2)
>+        get(m_value, t2)
>         loadConstantOrVariable2Reg(size, t2, t1, t2)
>         storei t1, ArrayStorage::m_vector + TagOffset[t0, t3, 8]
>         storei t2, ArrayStorage::m_vector + PayloadOffset[t0, t3, 8]
>         dispatch()
> 
>     .opPutByValArrayStorageEmpty:
>-        storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
>+        storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
>         addi 1, ArrayStorage::m_numValuesInVector[t0]
>         bib t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .opPutByValArrayStorageStoreResult
>         addi 1, t3, t1
>@@ -1668,7 +1668,7 @@ macro putByValOp(name, op)
>         jmp .opPutByValArrayStorageStoreResult
> 
>     .opPutByValOutOfBounds:
>-        storeb 1, %op%::Metadata::arrayProfile.m_outOfBounds[t5]
>+        storeb 1, %op%::Metadata::m_arrayProfile.m_outOfBounds[t5]
>     .opPutByValSlow:
>         callSlowPath(_llint_slow_path_%name%)
>         dispatch()
>@@ -1683,13 +1683,13 @@ putByValOp(put_by_val_direct, OpPutByVal
> 
> macro llintJumpTrueOrFalseOp(name, op, conditionOp)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(condition, t1)
>+        get(m_condition, t1)
>         loadConstantOrVariablePayload(size, t1, BooleanTag, t0, .slow)
>         conditionOp(t0, .target)
>         dispatch()
> 
>     .target:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -1700,7 +1700,7 @@ end
> 
> macro equalNullJumpOp(name, op, cellHandler, immediateHandler)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(value, t0)
>+        get(m_value, t0)
>         assertNotConstant(size, t0)
>         loadi TagOffset[cfr, t0, 8], t1
>         loadi PayloadOffset[cfr, t0, 8], t0
>@@ -1710,7 +1710,7 @@ macro equalNullJumpOp(name, op, cellHand
>         dispatch()
> 
>     .target:
>-        jump(target)
>+        jump(m_target)
> 
>     .immediate:
>         ori 1, t1
>@@ -1741,8 +1741,8 @@ equalNullJumpOp(jneq_null, OpJneqNull,
> 
> 
> llintOpWithMetadata(op_jneq_ptr, OpJneqPtr, macro (size, get, dispatch, metadata, return)
>-    get(value, t0)
>-    get(specialPointer, t1)
>+    get(m_value, t0)
>+    get(m_specialPointer, t1)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_globalObject[t2], t2
>     bineq TagOffset[cfr, t0, 8], CellTag, .opJneqPtrBranch
>@@ -1750,8 +1750,8 @@ llintOpWithMetadata(op_jneq_ptr, OpJneqP
>     bpeq PayloadOffset[cfr, t0, 8], t1, .opJneqPtrFallThrough
> .opJneqPtrBranch:
>     metadata(t5, t2)
>-    storeb 1, OpJneqPtr::Metadata::hasJumped[t5]
>-    get(target, t0)
>+    storeb 1, OpJneqPtr::Metadata::m_hasJumped[t5]
>+    get(m_target, t0)
>     jumpImpl(t0)
> .opJneqPtrFallThrough:
>     dispatch()
>@@ -1760,23 +1760,23 @@ end)
> 
> macro compareUnsignedJumpOp(name, op, integerCompare)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(lhs, t2)
>-        get(rhs, t3)
>+        get(m_lhs, t2)
>+        get(m_rhs, t3)
>         loadConstantOrVariable(size, t2, t0, t1)
>         loadConstantOrVariable2Reg(size, t3, t2, t3)
>         integerCompare(t1, t3, .jumpTarget)
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
>     end)
> end
> 
> 
> macro compareUnsignedOp(name, op, integerCompareAndSet)
>     llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t2)
>-        get(lhs, t0)
>+        get(m_rhs, t2)
>+        get(m_lhs, t0)
>         loadConstantOrVariable(size, t2, t3, t1)
>         loadConstantOrVariable2Reg(size, t0, t2, t0)
>         integerCompareAndSet(t0, t1, t0)
>@@ -1787,8 +1787,8 @@ end
> 
> macro compareJumpOp(name, op, integerCompare, doubleCompare)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(lhs, t2)
>-        get(rhs, t3)
>+        get(m_lhs, t2)
>+        get(m_rhs, t3)
>         loadConstantOrVariable(size, t2, t0, t1)
>         loadConstantOrVariable2Reg(size, t3, t2, t3)
>         bineq t0, Int32Tag, .op1NotInt
>@@ -1817,7 +1817,7 @@ macro compareJumpOp(name, op, integerCom
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -1827,8 +1827,8 @@ end
> 
> 
> llintOpWithJump(op_switch_imm, OpSwitchImm, macro (size, get, jump, dispatch)
>-    get(scrutinee, t2)
>-    get(tableIndex, t3)
>+    get(m_scrutinee, t2)
>+    get(m_tableIndex, t3)
>     loadConstantOrVariable(size, t2, t1, t0)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_rareData[t2], t2
>@@ -1846,7 +1846,7 @@ llintOpWithJump(op_switch_imm, OpSwitchI
> .opSwitchImmNotInt:
>     bib t1, LowestTag, .opSwitchImmSlow  # Go to slow path if it's a double.
> .opSwitchImmFallThrough:
>-    jump(defaultOffset)
>+    jump(m_defaultOffset)
> 
> .opSwitchImmSlow:
>     callSlowPath(_llint_slow_path_switch_imm)
>@@ -1855,8 +1855,8 @@ end)
> 
> 
> llintOpWithJump(op_switch_char, OpSwitchChar, macro (size, get, jump, dispatch)
>-    get(scrutinee, t2)
>-    get(tableIndex, t3)
>+    get(m_scrutinee, t2)
>+    get(m_tableIndex, t3)
>     loadConstantOrVariable(size, t2, t1, t0)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_rareData[t2], t2
>@@ -1883,7 +1883,7 @@ llintOpWithJump(op_switch_char, OpSwitch
>     dispatchIndirect(t1)
> 
> .opSwitchCharFallThrough:
>-    jump(defaultOffset)
>+    jump(m_defaultOffset)
> 
> .opSwitchOnRope:
>     callSlowPath(_llint_slow_path_switch_char)
>@@ -1892,12 +1892,12 @@ end)
> 
> 
> macro arrayProfileForCall(op, getu)
>-    getu(argv, t3)
>+    getu(m_argv, t3)
>     negi t3
>     bineq ThisArgumentOffset + TagOffset[cfr, t3, 8], CellTag, .done
>     loadi ThisArgumentOffset + PayloadOffset[cfr, t3, 8], t0
>     loadp JSCell::m_structureID[t0], t0
>-    storep t0, %op%::Metadata::arrayProfile.m_lastSeenStructureID[t5]
>+    storep t0, %op%::Metadata::m_arrayProfile.m_lastSeenStructureID[t5]
> .done:
> end
> 
>@@ -1905,26 +1905,26 @@ macro commonCallOp(name, slowPath, op, p
>     llintOpWithMetadata(name, op, macro (size, get, dispatch, metadata, return)
>         metadata(t5, t0)
> 
>-        prologue(macro (field, dst)
>-            getu(size, op, field, dst)
>+        prologue(macro (fieldName, dst)
>+            getu(size, op, fieldName, dst)
>         end, metadata)
> 
>-        get(callee, t0)
>-        loadp %op%::Metadata::callLinkInfo.callee[t5], t2
>+        get(m_callee, t0)
>+        loadp %op%::Metadata::m_callLinkInfo.callee[t5], t2
>         loadConstantOrVariablePayload(size, t0, CellTag, t3, .opCallSlow)
>         bineq t3, t2, .opCallSlow
>-        getu(size, op, argv, t3)
>+        getu(size, op, m_argv, t3)
>         lshifti 3, t3
>         negi t3
>         addp cfr, t3  # t3 contains the new value of cfr
>         storei t2, Callee + PayloadOffset[t3]
>-        getu(size, op, argc, t2)
>+        getu(size, op, m_argc, t2)
>         storei PC, ArgumentCount + TagOffset[cfr]
>         storei t2, ArgumentCount + PayloadOffset[t3]
>         storei CellTag, Callee + TagOffset[t3]
>         move t3, sp
>-        prepareCall(%op%::Metadata::callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
>-        callTargetFunction(size, op, dispatch, %op%::Metadata::callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
>+        prepareCall(%op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
>+        callTargetFunction(size, op, dispatch, %op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
> 
>     .opCallSlow:
>         slowPathForCall(size, op, dispatch, slowPath, prepareCall)
>@@ -1933,14 +1933,14 @@ end
> 
> llintOp(op_ret, OpRet, macro (size, get, dispatch)
>     checkSwitchToJITForEpilogue()
>-    get(value, t2)
>+    get(m_value, t2)
>     loadConstantOrVariable(size, t2, t1, t0)
>     doReturn()
> end)
> 
> 
> llintOpWithReturn(op_to_primitive, OpToPrimitive, macro (size, get, dispatch, return)
>-    get(src, t2)
>+    get(m_src, t2)
>     loadConstantOrVariable(size, t2, t1, t0)
>     bineq t1, CellTag, .opToPrimitiveIsImm
>     bbaeq JSCell::m_type[t0], ObjectType, .opToPrimitiveSlowCase
>@@ -1984,13 +1984,13 @@ commonOp(llint_op_catch, macro() end, ma
> 
>     loadi VM::m_exception[t3], t0
>     storei 0, VM::m_exception[t3]
>-    get(size, OpCatch, exception, t2)
>+    get(size, OpCatch, m_exception, t2)
>     storei t0, PayloadOffset[cfr, t2, 8]
>     storei CellTag, TagOffset[cfr, t2, 8]
> 
>     loadi Exception::m_value + TagOffset[t0], t1
>     loadi Exception::m_value + PayloadOffset[t0], t0
>-    get(size, OpCatch, thrownValue, t2)
>+    get(size, OpCatch, m_thrownValue, t2)
>     storei t0, PayloadOffset[cfr, t2, 8]
>     storei t1, TagOffset[cfr, t2, 8]
> 
>@@ -2003,7 +2003,7 @@ end)
> 
> llintOp(op_end, OpEnd, macro (size, get, dispatch)
>     checkSwitchToJITForEpilogue()
>-    get(value, t0)
>+    get(m_value, t0)
>     assertNotConstant(size, t0)
>     loadi TagOffset[cfr, t0, 8], t1
>     loadi PayloadOffset[cfr, t0, 8], t0
>@@ -2170,13 +2170,13 @@ end
> llintOpWithMetadata(op_resolve_scope, OpResolveScope, macro (size, get, dispatch, metadata, return)
> 
>     macro getConstantScope()
>-        loadp OpResolveScope::Metadata::constantScope[t5],  t0
>+        loadp OpResolveScope::Metadata::m_constantScope[t5],  t0
>         return(CellTag, t0)
>     end
> 
>     macro resolveScope()
>-        loadi OpResolveScope::Metadata::localScopeDepth[t5], t2
>-        get(scope, t0)
>+        loadi OpResolveScope::Metadata::m_localScopeDepth[t5], t2
>+        get(m_scope, t0)
>         loadp PayloadOffset[cfr, t0, 8], t0
>         btiz t2, .resolveScopeLoopEnd
> 
>@@ -2190,7 +2190,7 @@ llintOpWithMetadata(op_resolve_scope, Op
>     end
> 
>     metadata(t5, t0)
>-    loadp OpResolveScope::Metadata::resolveType[t5], t0
>+    loadp OpResolveScope::Metadata::m_resolveType[t5], t0
> 
> #rGlobalProperty:
>     bineq t0, GlobalProperty, .rGlobalVar
>@@ -2239,23 +2239,23 @@ end)
> 
> 
> macro loadWithStructureCheck(op, get, operand, slowPath)
>-    get(scope, t0)
>+    get(m_scope, t0)
>     loadp PayloadOffset[cfr, t0, 8], t0
>-    loadp %op%::Metadata::structure[t5], t1
>+    loadp %op%::Metadata::m_structure[t5], t1
>     bpneq JSCell::m_structureID[t0], t1, slowPath
> end
> 
> 
> llintOpWithMetadata(op_get_from_scope, OpGetFromScope, macro (size, get, dispatch, metadata, return)
>     macro getProperty()
>-        loadp OpGetFromScope::Metadata::operand[t5], t3
>+        loadp OpGetFromScope::Metadata::m_operand[t5], t3
>         loadPropertyAtVariableOffset(t3, t0, t1, t2)
>         valueProfile(OpGetFromScope, t5, t1, t2)
>         return(t1, t2)
>     end
> 
>     macro getGlobalVar(tdzCheckIfNecessary)
>-        loadp OpGetFromScope::Metadata::operand[t5], t0
>+        loadp OpGetFromScope::Metadata::m_operand[t5], t0
>         loadp TagOffset[t0], t1
>         loadp PayloadOffset[t0], t2
>         tdzCheckIfNecessary(t1)
>@@ -2264,7 +2264,7 @@ llintOpWithMetadata(op_get_from_scope, O
>     end
> 
>     macro getClosureVar()
>-        loadp OpGetFromScope::Metadata::operand[t5], t3
>+        loadp OpGetFromScope::Metadata::m_operand[t5], t3
>         loadp JSLexicalEnvironment_variables + TagOffset[t0, t3, 8], t1
>         loadp JSLexicalEnvironment_variables + PayloadOffset[t0, t3, 8], t2
>         valueProfile(OpGetFromScope, t5, t1, t2)
>@@ -2272,7 +2272,7 @@ llintOpWithMetadata(op_get_from_scope, O
>     end
> 
>     metadata(t5, t0)
>-    loadi OpGetFromScope::Metadata::getPutInfo[t5], t0
>+    loadi OpGetFromScope::Metadata::m_getPutInfo[t5], t0
>     andi ResolveTypeMask, t0
> 
> #gGlobalProperty:
>@@ -2293,7 +2293,7 @@ llintOpWithMetadata(op_get_from_scope, O
> 
> .gClosureVar:
>     bineq t0, ClosureVar, .gGlobalPropertyWithVarInjectionChecks
>-    loadVariable(get, scope, t2, t1, t0)
>+    loadVariable(get, m_scope, t2, t1, t0)
>     getClosureVar()
> 
> .gGlobalPropertyWithVarInjectionChecks:
>@@ -2317,7 +2317,7 @@ llintOpWithMetadata(op_get_from_scope, O
> .gClosureVarWithVarInjectionChecks:
>     bineq t0, ClosureVarWithVarInjectionChecks, .gDynamic
>     varInjectionCheck(.gDynamic)
>-    loadVariable(get, scope, t2, t1, t0)
>+    loadVariable(get, m_scope, t2, t1, t0)
>     getClosureVar()
> 
> .gDynamic:
>@@ -2328,107 +2328,107 @@ end)
> 
> llintOpWithMetadata(op_put_to_scope, OpPutToScope, macro (size, get, dispatch, metadata, return)
>     macro putProperty()
>-        get(value, t1)
>+        get(m_value, t1)
>         loadConstantOrVariable(size, t1, t2, t3)
>-        loadis OpPutToScope::Metadata::operand[t5], t1
>+        loadis OpPutToScope::Metadata::m_operand[t5], t1
>         storePropertyAtVariableOffset(t1, t0, t2, t3)
>     end
> 
>     macro putGlobalVariable()
>-        get(value, t0)
>+        get(m_value, t0)
>         loadConstantOrVariable(size, t0, t1, t2)
>-        loadp OpPutToScope::Metadata::watchpointSet[t5], t3
>+        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t3
>         notifyWrite(t3, .pDynamic)
>-        loadp OpPutToScope::Metadata::operand[t5], t0
>+        loadp OpPutToScope::Metadata::m_operand[t5], t0
>         storei t1, TagOffset[t0]
>         storei t2, PayloadOffset[t0]
>     end
> 
>     macro putClosureVar()
>-        get(value, t1)
>+        get(m_value, t1)
>         loadConstantOrVariable(size, t1, t2, t3)
>-        loadis OpPutToScope::Metadata::operand[t5], t1
>+        loadis OpPutToScope::Metadata::m_operand[t5], t1
>         storei t2, JSLexicalEnvironment_variables + TagOffset[t0, t1, 8]
>         storei t3, JSLexicalEnvironment_variables + PayloadOffset[t0, t1, 8]
>     end
> 
>     macro putLocalClosureVar()
>-        get(value, t1)
>+        get(m_value, t1)
>         loadConstantOrVariable(size, t1, t2, t3)
>-        loadp OpPutToScope::Metadata::watchpointSet[t5], t1
>+        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t1
>         btpz t1, .noVariableWatchpointSet
>         notifyWrite(t1, .pDynamic)
>     .noVariableWatchpointSet:
>-        loadis OpPutToScope::Metadata::operand[t5], t1
>+        loadis OpPutToScope::Metadata::m_operand[t5], t1
>         storei t2, JSLexicalEnvironment_variables + TagOffset[t0, t1, 8]
>         storei t3, JSLexicalEnvironment_variables + PayloadOffset[t0, t1, 8]
>     end
> 
> 
>     metadata(t5, t0)
>-    loadi OpPutToScope::Metadata::getPutInfo[t5], t0
>+    loadi OpPutToScope::Metadata::m_getPutInfo[t5], t0
>     andi ResolveTypeMask, t0
> 
> #pLocalClosureVar:
>     bineq t0, LocalClosureVar, .pGlobalProperty
>-    loadVariable(get, scope, t2, t1, t0)
>+    loadVariable(get, m_scope, t2, t1, t0)
>     putLocalClosureVar()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalProperty:
>     bineq t0, GlobalProperty, .pGlobalVar
>     loadWithStructureCheck(OpPutToScope, get, scope, .pDynamic)
>     putProperty()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalVar:
>     bineq t0, GlobalVar, .pGlobalLexicalVar
>     putGlobalVariable()
>-    writeBarrierOnGlobalObject(size, get, value)
>+    writeBarrierOnGlobalObject(size, get, m_value)
>     dispatch()
> 
> .pGlobalLexicalVar:
>     bineq t0, GlobalLexicalVar, .pClosureVar
>     putGlobalVariable()
>-    writeBarrierOnGlobalLexicalEnvironment(size, get, value)
>+    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
>     dispatch()
> 
> .pClosureVar:
>     bineq t0, ClosureVar, .pGlobalPropertyWithVarInjectionChecks
>-    loadVariable(get, scope, t2, t1, t0)
>+    loadVariable(get, m_scope, t2, t1, t0)
>     putClosureVar()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalPropertyWithVarInjectionChecks:
>     bineq t0, GlobalPropertyWithVarInjectionChecks, .pGlobalVarWithVarInjectionChecks
>     loadWithStructureCheck(OpPutToScope, get, scope, .pDynamic)
>     putProperty()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalVarWithVarInjectionChecks:
>     bineq t0, GlobalVarWithVarInjectionChecks, .pGlobalLexicalVarWithVarInjectionChecks
>     varInjectionCheck(.pDynamic)
>     putGlobalVariable()
>-    writeBarrierOnGlobalObject(size, get, value)
>+    writeBarrierOnGlobalObject(size, get, m_value)
>     dispatch()
> 
> .pGlobalLexicalVarWithVarInjectionChecks:
>     bineq t0, GlobalLexicalVarWithVarInjectionChecks, .pClosureVarWithVarInjectionChecks
>     varInjectionCheck(.pDynamic)
>     putGlobalVariable()
>-    writeBarrierOnGlobalLexicalEnvironment(size, get, value)
>+    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
>     dispatch()
> 
> .pClosureVarWithVarInjectionChecks:
>     bineq t0, ClosureVarWithVarInjectionChecks, .pModuleVar
>     varInjectionCheck(.pDynamic)
>-    loadVariable(get, scope, t2, t1, t0)
>+    loadVariable(get, m_scope, t2, t1, t0)
>     putClosureVar()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pModuleVar:
>@@ -2443,9 +2443,9 @@ end)
> 
> 
> llintOpWithProfile(op_get_from_arguments, OpGetFromArguments, macro (size, get, dispatch, return)
>-    get(arguments, t0)
>+    get(m_arguments, t0)
>     loadi PayloadOffset[cfr, t0, 8], t0
>-    get(index, t1)
>+    get(m_index, t1)
>     loadi DirectArguments_storage + TagOffset[t0, t1, 8], t2
>     loadi DirectArguments_storage + PayloadOffset[t0, t1, 8], t3
>     return(t2, t3)
>@@ -2453,12 +2453,12 @@ end)
> 
> 
> llintOp(op_put_to_arguments, OpPutToArguments, macro (size, get, dispatch)
>-    writeBarrierOnOperands(size, get, arguments, value)
>-    get(arguments, t0)
>+    writeBarrierOnOperands(size, get, m_arguments, m_value)
>+    get(m_arguments, t0)
>     loadi PayloadOffset[cfr, t0, 8], t0
>-    get(value, t1)
>+    get(m_value, t1)
>     loadConstantOrVariable(size, t1, t2, t3)
>-    get(index, t1)
>+    get(m_index, t1)
>     storei t2, DirectArguments_storage + TagOffset[t0, t1, 8]
>     storei t3, DirectArguments_storage + PayloadOffset[t0, t1, 8]
>     dispatch()
>@@ -2466,7 +2466,7 @@ end)
> 
> 
> llintOpWithReturn(op_get_parent_scope, OpGetParentScope, macro (size, get, dispatch, return)
>-    get(scope, t0)
>+    get(m_scope, t0)
>     loadp PayloadOffset[cfr, t0, 8], t0
>     loadp JSScope::m_next[t0], t0
>     return(CellTag, t0)
>@@ -2481,7 +2481,7 @@ llintOpWithMetadata(op_profile_type, OpP
>     loadp VM::m_typeProfilerLog[t1], t1
> 
>     # t0 is holding the payload, t5 is holding the tag.
>-    get(target, t2)
>+    get(m_target, t2)
>     loadConstantOrVariable(size, t2, t5, t0)
> 
>     bieq t5, EmptyValueTag, .opProfileTypeDone
>@@ -2495,7 +2495,7 @@ llintOpWithMetadata(op_profile_type, OpP
>     storei t0, TypeProfilerLog::LogEntry::value + PayloadOffset[t2]
> 
>     # Store the TypeLocation onto the log entry.
>-    loadp OpProfileType::Metadata::typeLocation[t3], t3
>+    loadp OpProfileType::Metadata::m_typeLocation[t3], t3
>     storep t3, TypeProfilerLog::LogEntry::location[t2]
> 
>     bieq t5, CellTag, .opProfileTypeIsCell
>@@ -2521,7 +2521,7 @@ end)
> 
> llintOpWithMetadata(op_profile_control_flow, OpProfileControlFlow, macro (size, get, dispatch, metadata, return)
>     metadata(t5, t0)
>-    loadp OpProfileControlFlow::Metadata::basicBlockLocation[t5], t0
>+    loadp OpProfileControlFlow::Metadata::m_basicBlockLocation[t5], t0
>     loadi BasicBlockLocation::m_executionCount[t0], t1
>     baddio 1, t1, .done
>     storei t1, BasicBlockLocation::m_executionCount[t0]
>@@ -2533,7 +2533,7 @@ end)
> llintOpWithReturn(op_get_rest_length, OpGetRestLength, macro (size, get, dispatch, return)
>     loadi PayloadOffset + ArgumentCount[cfr], t0
>     subi 1, t0
>-    get(numParametersToSkip, t1)
>+    get(m_numParametersToSkip, t1)
>     bilteq t0, t1, .storeZero
>     subi t1, t0
>     jmp .finish
>@@ -2551,7 +2551,7 @@ llintOp(op_log_shadow_chicken_prologue, 
>     storep t1, ShadowChicken::Packet::callerFrame[t0]
>     loadp Callee + PayloadOffset[cfr], t1
>     storep t1, ShadowChicken::Packet::callee[t0]
>-    get(scope, t1)
>+    get(m_scope, t1)
>     loadi PayloadOffset[cfr, t1, 8], t1
>     storep t1, ShadowChicken::Packet::scope[t0]
>     dispatch()
>@@ -2565,10 +2565,10 @@ llintOp(op_log_shadow_chicken_tail, OpLo
>     acquireShadowChickenPacket(.opLogShadowChickenTailSlow)
>     storep cfr, ShadowChicken::Packet::frame[t0]
>     storep ShadowChickenTailMarker, ShadowChicken::Packet::callee[t0]
>-    loadVariable(get, thisValue, t3, t2, t1)
>+    loadVariable(get, m_thisValue, t3, t2, t1)
>     storei t2, TagOffset + ShadowChicken::Packet::thisValue[t0]
>     storei t1, PayloadOffset + ShadowChicken::Packet::thisValue[t0]
>-    get(scope, t1)
>+    get(m_scope, t1)
>     loadi PayloadOffset[cfr, t1, 8], t1
>     storep t1, ShadowChicken::Packet::scope[t0]
>     loadp CodeBlock[cfr], t1
>Index: Source/JavaScriptCore/llint/LowLevelInterpreter64.asm
>===================================================================
>--- Source/JavaScriptCore/llint/LowLevelInterpreter64.asm	(revision 239990)
>+++ Source/JavaScriptCore/llint/LowLevelInterpreter64.asm	(working copy)
>@@ -1,5 +1,4 @@
>-
>-# 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
>@@ -37,26 +36,26 @@ macro nextInstructionWide()
>     jmp [t1, t0, PtrSize], BytecodePtrTag
> end
> 
>-macro getuOperandNarrow(op, field, dst)
>-    loadb constexpr %op%_%field%_index[PB, PC, 1], dst
>+macro getuOperandNarrow(op, fieldName, dst)
>+    loadb constexpr %op%_%fieldName%_index[PB, PC, 1], dst
> end
> 
>-macro getOperandNarrow(op, field, dst)
>-    loadbsp constexpr %op%_%field%_index[PB, PC, 1], dst
>+macro getOperandNarrow(op, fieldName, dst)
>+    loadbsp constexpr %op%_%fieldName%_index[PB, PC, 1], dst
> end
> 
>-macro getuOperandWide(op, field, dst)
>-    loadi constexpr %op%_%field%_index * 4 + 1[PB, PC, 1], dst
>+macro getuOperandWide(op, fieldName, dst)
>+    loadi constexpr %op%_%fieldName%_index * 4 + 1[PB, PC, 1], dst
> end
> 
>-macro getOperandWide(op, field, dst)
>-    loadis constexpr %op%_%field%_index * 4 + 1[PB, PC, 1], dst
>+macro getOperandWide(op, fieldName, dst)
>+    loadis constexpr %op%_%fieldName%_index * 4 + 1[PB, PC, 1], dst
> end
> 
> macro makeReturn(get, dispatch, fn)
>     fn(macro (value)
>         move value, t2
>-        get(dst, t1)
>+        get(m_dst, t1)
>         storeq t2, [cfr, t1, 8]
>         dispatch()
>     end)
>@@ -67,14 +66,14 @@ macro makeReturnProfiled(op, get, metada
>         move value, t3
>         metadata(t1, t2)
>         valueProfile(op, t1, t3)
>-        get(dst, t1)
>+        get(m_dst, t1)
>         storeq t3, [cfr, t1, 8]
>         dispatch()
>     end)
> end
> 
> macro valueProfile(op, metadata, value)
>-    storeq value, %op%::Metadata::profile.m_buckets[metadata]
>+    storeq value, %op%::Metadata::m_profile.m_buckets[metadata]
> end
> 
> macro dispatchAfterCall(size, op, dispatch)
>@@ -82,7 +81,7 @@ macro dispatchAfterCall(size, op, dispat
>     loadp CodeBlock[cfr], PB
>     loadp CodeBlock::m_instructionsRawPointer[PB], PB
>     unpoison(_g_CodeBlockPoison, PB, t1)
>-    get(size, op, dst, t1)
>+    get(size, op, m_dst, t1)
>     storeq r0, [cfr, t1, 8]
>     metadata(size, op, t2, t1)
>     valueProfile(op, t2, r0)
>@@ -425,9 +424,9 @@ macro loadCaged(basePtr, mask, source, d
>     uncage(basePtr, mask, dest, scratch)
> end
> 
>-macro loadVariable(get, field, value)
>-    get(field, value)
>-    loadq [cfr, value, 8], value
>+macro loadVariable(get, fieldName, valueReg)
>+    get(fieldName, valueReg)
>+    loadq [cfr, valueReg, 8], valueReg
> end
> 
> # Index and value must be different registers. Index may be clobbered.
>@@ -468,8 +467,8 @@ macro loadConstantOrVariableCell(size, i
>     btqnz value, tagMask, slow
> end
> 
>-macro writeBarrierOnOperandWithReload(size, get, cellOperand, reloadAfterSlowPath)
>-    get(cellOperand, t1)
>+macro writeBarrierOnOperandWithReload(size, get, cellFieldName, reloadAfterSlowPath)
>+    get(cellFieldName, t1)
>     loadConstantOrVariableCell(size, t1, t2, .writeBarrierDone)
>     skipIfIsRememberedOrInEden(
>         t2,
>@@ -484,25 +483,25 @@ macro writeBarrierOnOperandWithReload(si
> .writeBarrierDone:
> end
> 
>-macro writeBarrierOnOperand(size, get, cellOperand)
>-    writeBarrierOnOperandWithReload(size, get, cellOperand, macro () end)
>+macro writeBarrierOnOperand(size, get, cellFieldName)
>+    writeBarrierOnOperandWithReload(size, get, cellFieldName, macro () end)
> end
> 
>-macro writeBarrierOnOperands(size, get, cellOperand, valueOperand)
>-    get(valueOperand, t1)
>+macro writeBarrierOnOperands(size, get, cellFieldName, valueFieldName)
>+    get(valueFieldName, t1)
>     loadConstantOrVariableCell(size, t1, t0, .writeBarrierDone)
>     btpz t0, .writeBarrierDone
> 
>-    writeBarrierOnOperand(size, get, cellOperand)
>+    writeBarrierOnOperand(size, get, cellFieldName)
> .writeBarrierDone:
> end
> 
>-macro writeBarrierOnGlobal(size, get, valueOperand, loadHelper)
>-    get(valueOperand, t1)
>+macro writeBarrierOnGlobal(size, get, valueFieldName, loadMacro)
>+    get(valueFieldName, t1)
>     loadConstantOrVariableCell(size, t1, t0, .writeBarrierDone)
>     btpz t0, .writeBarrierDone
> 
>-    loadHelper(t3)
>+    loadMacro(t3)
>     skipIfIsRememberedOrInEden(
>         t3,
>         macro()
>@@ -515,16 +514,16 @@ macro writeBarrierOnGlobal(size, get, va
> .writeBarrierDone:
> end
> 
>-macro writeBarrierOnGlobalObject(size, get, valueOperand)
>-    writeBarrierOnGlobal(size, get, valueOperand,
>+macro writeBarrierOnGlobalObject(size, get, valueFieldName)
>+    writeBarrierOnGlobal(size, get, valueFieldName,
>         macro(registerToStoreGlobal)
>             loadp CodeBlock[cfr], registerToStoreGlobal
>             loadp CodeBlock::m_globalObject[registerToStoreGlobal], registerToStoreGlobal
>         end)
> end
> 
>-macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueOperand)
>-    writeBarrierOnGlobal(size, get, valueOperand,
>+macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueFieldName)
>+    writeBarrierOnGlobal(size, get, valueFieldName,
>         macro(registerToStoreGlobal)
>             loadp CodeBlock[cfr], registerToStoreGlobal
>             loadp CodeBlock::m_globalObject[registerToStoreGlobal], registerToStoreGlobal
>@@ -667,7 +666,7 @@ _llint_op_enter:
> 
> 
> llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)
>-    get(index, t2)
>+    get(m_index, t2)
>     loadi PayloadOffset + ArgumentCount[cfr], t0
>     bilteq t0, t2, .opGetArgumentOutOfBounds
>     loadq ThisArgumentOffset[cfr, t2, 8], t0
>@@ -694,13 +693,13 @@ end)
> 
> 
> llintOpWithMetadata(op_to_this, OpToThis, macro (size, get, dispatch, metadata, return)
>-    get(srcDst, t0)
>+    get(m_srcDst, t0)
>     loadq [cfr, t0, 8], t0
>     btqnz t0, tagMask, .opToThisSlow
>     bbneq JSCell::m_type[t0], FinalObjectType, .opToThisSlow
>     loadStructureWithScratch(t0, t1, t2, t3)
>     metadata(t2, t3)
>-    loadp OpToThis::Metadata::cachedStructure[t2], t2
>+    loadp OpToThis::Metadata::m_cachedStructure[t2], t2
>     bpneq t1, t2, .opToThisSlow
>     dispatch()
> 
>@@ -711,7 +710,7 @@ end)
> 
> 
> llintOp(op_check_tdz, OpCheckTdz, macro (size, get, dispatch)
>-    get(target, t0)
>+    get(m_target, t0)
>     loadConstantOrVariable(size, t0, t1)
>     bqneq t1, ValueEmpty, .opNotTDZ
>     callSlowPath(_slow_path_throw_tdz_error)
>@@ -722,14 +721,14 @@ end)
> 
> 
> llintOpWithReturn(op_mov, OpMov, macro (size, get, dispatch, return)
>-    get(src, t1)
>+    get(m_src, t1)
>     loadConstantOrVariable(size, t1, t2)
>     return(t2)
> end)
> 
> 
> llintOpWithReturn(op_not, OpNot, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2)
>     xorq ValueFalse, t2
>     btqnz t2, ~1, .opNotSlow
>@@ -744,8 +743,8 @@ end)
> 
> macro equalityComparisonOp(name, op, integerComparison)
>     llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t0)
>-        get(lhs, t2)
>+        get(m_rhs, t0)
>+        get(m_lhs, t2)
>         loadConstantOrVariableInt32(size, t0, t1, .slow)
>         loadConstantOrVariableInt32(size, t2, t0, .slow)
>         integerComparison(t0, t1, t0)
>@@ -761,7 +760,7 @@ end
> 
> macro equalNullComparisonOp(name, op, fn)
>     llintOpWithReturn(name, op, macro (size, get, dispatch, return)
>-        get(operand, t0)
>+        get(m_operand, t0)
>         loadq [cfr, t0, 8], t0
>         btqnz t0, tagMask, .immediate
>         btbnz JSCell::m_flags[t0], MasqueradesAsUndefined, .masqueradesAsUndefined
>@@ -791,7 +790,7 @@ equalNullComparisonOp(op_neq_null, OpNeq
> 
> 
> llintOpWithReturn(op_is_undefined_or_null, OpIsUndefinedOrNull, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadq [cfr, t0, 8], t0
>     andq ~TagBitUndefined, t0
>     cqeq t0, ValueNull, t0
>@@ -802,8 +801,8 @@ end)
> 
> macro strictEqOp(name, op, equalityOperation)
>     llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t0)
>-        get(lhs, t2)
>+        get(m_rhs, t0)
>+        get(m_lhs, t2)
>         loadConstantOrVariable(size, t0, t1)
>         loadConstantOrVariable(size, t2, t0)
>         move t0, t2
>@@ -836,8 +835,8 @@ strictEqOp(nstricteq, OpNstricteq,
> 
> macro strictEqualityJumpOp(name, op, equalityOperation)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(lhs, t2)
>-        get(rhs, t3)
>+        get(m_lhs, t2)
>+        get(m_rhs, t3)
>         loadConstantOrVariable(size, t2, t0)
>         loadConstantOrVariable(size, t3, t1)
>         move t0, t2
>@@ -853,7 +852,7 @@ macro strictEqualityJumpOp(name, op, equ
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -872,7 +871,7 @@ strictEqualityJumpOp(jnstricteq, OpJnstr
> 
> macro preOp(name, op, arithmeticOperation)
>     llintOp(op_%name%, op, macro (size, get, dispatch)
>-        get(srcDst, t0)
>+        get(m_srcDst, t0)
>         loadq [cfr, t0, 8], t1
>         bqb t1, tagTypeNumber, .slow
>         arithmeticOperation(t1, .slow)
>@@ -886,7 +885,7 @@ macro preOp(name, op, arithmeticOperatio
> end
> 
> llintOpWithProfile(op_to_number, OpToNumber, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2)
>     bqaeq t2, tagTypeNumber, .opToNumberIsImmediate
>     btqz t2, tagTypeNumber, .opToNumberSlow
>@@ -900,7 +899,7 @@ end)
> 
> 
> llintOpWithReturn(op_to_string, OpToString, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0)
>     btqnz t0, tagMask, .opToStringSlow
>     bbneq JSCell::m_type[t0], StringType, .opToStringSlow
>@@ -914,7 +913,7 @@ end)
> 
> 
> llintOpWithProfile(op_to_object, OpToObject, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t2)
>     btqnz t2, tagMask, .opToObjectSlow
>     bbb JSCell::m_type[t2], ObjectType, .opToObjectSlow
>@@ -927,22 +926,22 @@ end)
> 
> 
> llintOpWithMetadata(op_negate, OpNegate, macro (size, get, dispatch, metadata, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariable(size, t0, t3)
>     metadata(t1, t2)
>-    loadis OpNegate::Metadata::arithProfile[t1], t2
>+    loadis OpNegate::Metadata::m_arithProfile[t1], t2
>     bqb t3, tagTypeNumber, .opNegateNotInt
>     btiz t3, 0x7fffffff, .opNegateSlow
>     negi t3
>     orq tagTypeNumber, t3
>     ori ArithProfileInt, t2
>-    storei t2, OpNegate::Metadata::arithProfile[t1]
>+    storei t2, OpNegate::Metadata::m_arithProfile[t1]
>     return(t3)
> .opNegateNotInt:
>     btqz t3, tagTypeNumber, .opNegateSlow
>     xorq 0x8000000000000000, t3
>     ori ArithProfileNumber, t2
>-    storei t2, OpNegate::Metadata::arithProfile[t1]
>+    storei t2, OpNegate::Metadata::m_arithProfile[t1]
>     return(t3)
> 
> .opNegateSlow:
>@@ -956,16 +955,16 @@ macro binaryOpCustomStore(name, op, inte
>         metadata(t5, t0)
> 
>         macro profile(type)
>-            ori type, %op%::Metadata::arithProfile[t5]
>+            ori type, %op%::Metadata::m_arithProfile[t5]
>         end
> 
>-        get(rhs, t0)
>-        get(lhs, t2)
>+        get(m_rhs, t0)
>+        get(m_lhs, t2)
>         loadConstantOrVariable(size, t0, t1)
>         loadConstantOrVariable(size, t2, t0)
>         bqb t0, tagTypeNumber, .op1NotInt
>         bqb t1, tagTypeNumber, .op2NotInt
>-        get(dst, t2)
>+        get(m_dst, t2)
>         integerOperationAndStore(t1, t0, .slow, t2)
> 
>         profile(ArithProfileIntInt)
>@@ -984,7 +983,7 @@ macro binaryOpCustomStore(name, op, inte
>         profile(ArithProfileNumberInt)
>         ci2d t1, ft1
>     .op1NotIntReady:
>-        get(dst, t2)
>+        get(m_dst, t2)
>         addq tagTypeNumber, t0
>         fq2d t0, ft0
>         doubleOperation(ft1, ft0)
>@@ -995,7 +994,7 @@ macro binaryOpCustomStore(name, op, inte
> 
>     .op2NotInt:
>         # First operand is definitely an int, the second is definitely not.
>-        get(dst, t2)
>+        get(m_dst, t2)
>         btqz t1, tagTypeNumber, .slow
>         profile(ArithProfileIntNumber)
>         ci2d t0, ft0
>@@ -1074,7 +1073,7 @@ binaryOp(sub, OpSub,
> 
> 
> llintOpWithReturn(op_unsigned, OpUnsigned, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t2)
>     bilt t2, 0, .opUnsignedSlow
>     return(t2)
>@@ -1086,8 +1085,8 @@ end)
> 
> macro commonBitOp(opKind, name, op, operation)
>     opKind(op_%name%, op, macro (size, get, dispatch, return)
>-        get(rhs, t0)
>-        get(lhs, t2)
>+        get(m_rhs, t0)
>+        get(m_lhs, t2)
>         loadConstantOrVariable(size, t0, t1)
>         loadConstantOrVariable(size, t2, t0)
>         bqb t0, tagTypeNumber, .slow
>@@ -1131,7 +1130,7 @@ bitOpProfiled(bitxor, OpBitxor,
>     macro (left, right) xori left, right end)
> 
> llintOpWithProfile(op_bitnot, OpBitnot, macro (size, get, dispatch, return)
>-    get(operand, t0)
>+    get(m_operand, t0)
>     loadConstantOrVariableInt32(size, t0, t3, .opBitNotSlow)
>     noti t3
>     orq tagTypeNumber, t3
>@@ -1143,16 +1142,16 @@ end)
> 
> 
> llintOp(op_overrides_has_instance, OpOverridesHasInstance, macro (size, get, dispatch)
>-    get(dst, t3)
>+    get(m_dst, t3)
> 
>-    get(hasInstanceValue, t1)
>+    get(m_hasInstanceValue, t1)
>     loadConstantOrVariable(size, t1, t0)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_globalObject[t2], t2
>     loadp JSGlobalObject::m_functionProtoHasInstanceSymbolFunction[t2], t2
>     bqneq t0, t2, .opOverridesHasInstanceNotDefaultSymbol
> 
>-    get(constructor, t1)
>+    get(m_constructor, t1)
>     loadConstantOrVariable(size, t1, t0)
>     tbz JSCell::m_flags[t0], ImplementsDefaultHasInstance, t1
>     orq ValueFalse, t1
>@@ -1166,7 +1165,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_empty, OpIsEmpty, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0)
>     cqeq t0, ValueEmpty, t3
>     orq ValueFalse, t3
>@@ -1175,7 +1174,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_undefined, OpIsUndefined, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0)
>     btqz t0, tagMask, .opIsUndefinedCell
>     cqeq t0, ValueUndefined, t3
>@@ -1196,7 +1195,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_boolean, OpIsBoolean, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0)
>     xorq ValueFalse, t0
>     tqz t0, ~1, t0
>@@ -1206,7 +1205,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_number, OpIsNumber, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0)
>     tqnz t0, tagTypeNumber, t1
>     orq ValueFalse, t1
>@@ -1215,8 +1214,8 @@ end)
> 
> 
> llintOpWithReturn(op_is_cell_with_type, OpIsCellWithType, macro (size, get, dispatch, return)
>-    getu(size, OpIsCellWithType, type, t0)
>-    get(operand, t1)
>+    getu(size, OpIsCellWithType, m_type, t0)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t3)
>     btqnz t3, tagMask, .notCellCase
>     cbeq JSCell::m_type[t3], t0, t1
>@@ -1228,7 +1227,7 @@ end)
> 
> 
> llintOpWithReturn(op_is_object, OpIsObject, macro (size, get, dispatch, return)
>-    get(operand, t1)
>+    get(m_operand, t1)
>     loadConstantOrVariable(size, t1, t0)
>     btqnz t0, tagMask, .opIsObjectNotCell
>     cbaeq JSCell::m_type[t0], ObjectType, t1
>@@ -1267,12 +1266,12 @@ end
> 
> llintOpWithMetadata(op_get_by_id_direct, OpGetByIdDirect, macro (size, get, dispatch, metadata, return)
>     metadata(t2, t0)
>-    get(base, t0)
>+    get(m_base, t0)
>     loadConstantOrVariableCell(size, t0, t3, .opGetByIdDirectSlow)
>     loadi JSCell::m_structureID[t3], t1
>-    loadi OpGetByIdDirect::Metadata::structure[t2], t0
>+    loadi OpGetByIdDirect::Metadata::m_structure[t2], t0
>     bineq t0, t1, .opGetByIdDirectSlow
>-    loadi OpGetByIdDirect::Metadata::offset[t2], t1
>+    loadi OpGetByIdDirect::Metadata::m_offset[t2], t1
>     loadPropertyAtVariableOffset(t1, t3, t0)
>     valueProfile(OpGetByIdDirect, t2, t0)
>     return(t0)
>@@ -1285,16 +1284,16 @@ end)
> 
> llintOpWithMetadata(op_get_by_id, OpGetById, macro (size, get, dispatch, metadata, return)
>     metadata(t2, t1)
>-    loadb OpGetById::Metadata::mode[t2], t1
>-    get(base, t0)
>+    loadb OpGetById::Metadata::m_mode[t2], t1
>+    get(m_base, t0)
>     loadConstantOrVariableCell(size, t0, t3, .opGetByIdSlow)
> 
> .opGetByIdDefault:
>     bbneq t1, constexpr GetByIdMode::Default, .opGetByIdProtoLoad
>     loadi JSCell::m_structureID[t3], t1
>-    loadi OpGetById::Metadata::modeMetadata.defaultMode.structure[t2], t0
>+    loadi OpGetById::Metadata::m_modeMetadata.defaultMode.structure[t2], t0
>     bineq t0, t1, .opGetByIdSlow
>-    loadis OpGetById::Metadata::modeMetadata.defaultMode.cachedOffset[t2], t1
>+    loadis OpGetById::Metadata::m_modeMetadata.defaultMode.cachedOffset[t2], t1
>     loadPropertyAtVariableOffset(t1, t3, t0)
>     valueProfile(OpGetById, t2, t0)
>     return(t0)
>@@ -1302,10 +1301,10 @@ llintOpWithMetadata(op_get_by_id, OpGetB
> .opGetByIdProtoLoad:
>     bbneq t1, constexpr GetByIdMode::ProtoLoad, .opGetByIdArrayLength
>     loadi JSCell::m_structureID[t3], t1
>-    loadi OpGetById::Metadata::modeMetadata.protoLoadMode.structure[t2], t3
>+    loadi OpGetById::Metadata::m_modeMetadata.protoLoadMode.structure[t2], t3
>     bineq t3, t1, .opGetByIdSlow
>-    loadis OpGetById::Metadata::modeMetadata.protoLoadMode.cachedOffset[t2], t1
>-    loadp OpGetById::Metadata::modeMetadata.protoLoadMode.cachedSlot[t2], t3
>+    loadis OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedOffset[t2], t1
>+    loadp OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedSlot[t2], t3
>     loadPropertyAtVariableOffset(t1, t3, t0)
>     valueProfile(OpGetById, t2, t0)
>     return(t0)
>@@ -1313,7 +1312,7 @@ llintOpWithMetadata(op_get_by_id, OpGetB
> .opGetByIdArrayLength:
>     bbneq t1, constexpr GetByIdMode::ArrayLength, .opGetByIdUnset
>     move t3, t0
>-    arrayProfile(OpGetById::Metadata::modeMetadata.arrayLengthMode.arrayProfile, t0, t2, t5)
>+    arrayProfile(OpGetById::Metadata::m_modeMetadata.arrayLengthMode.arrayProfile, t0, t2, t5)
>     btiz t0, IsArray, .opGetByIdSlow
>     btiz t0, IndexingShapeMask, .opGetByIdSlow
>     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr JSVALUE_GIGACAGE_MASK, JSObject::m_butterfly[t3], t0, t1)
>@@ -1325,7 +1324,7 @@ llintOpWithMetadata(op_get_by_id, OpGetB
> 
> .opGetByIdUnset:
>     loadi JSCell::m_structureID[t3], t1
>-    loadi OpGetById::Metadata::modeMetadata.unsetMode.structure[t2], t0
>+    loadi OpGetById::Metadata::m_modeMetadata.unsetMode.structure[t2], t0
>     bineq t0, t1, .opGetByIdSlow
>     valueProfile(OpGetById, t2, ValueUndefined)
>     return(ValueUndefined)
>@@ -1337,10 +1336,10 @@ end)
> 
> 
> llintOpWithMetadata(op_put_by_id, OpPutById, macro (size, get, dispatch, metadata, return)
>-    get(base, t3)
>+    get(m_base, t3)
>     loadConstantOrVariableCell(size, t3, t0, .opPutByIdSlow)
>     metadata(t5, t2)
>-    loadis OpPutById::Metadata::oldStructure[t5], t2
>+    loadis OpPutById::Metadata::m_oldStructure[t5], t2
>     bineq t2, JSCell::m_structureID[t0], .opPutByIdSlow
> 
>     # At this point, we have:
>@@ -1348,10 +1347,10 @@ llintOpWithMetadata(op_put_by_id, OpPutB
>     # t2 -> current structure ID
>     # t0 -> object base
> 
>-    get(value, t1)
>+    get(m_value, t1)
>     loadConstantOrVariable(size, t1, t3)
> 
>-    loadi OpPutById::Metadata::flags[t5], t1
>+    loadi OpPutById::Metadata::m_flags[t5], t1
> 
>     # At this point, we have:
>     # t0 -> object base
>@@ -1428,20 +1427,20 @@ llintOpWithMetadata(op_put_by_id, OpPutB
>     bineq t1, JSCell::m_structureID[t3], .opPutByIdSlow
> 
> .opPutByIdDoneCheckingTypes:
>-    loadi OpPutById::Metadata::newStructure[t5], t1
>+    loadi OpPutById::Metadata::m_newStructure[t5], t1
>     
>     btiz t1, .opPutByIdNotTransition
> 
>     # This is the transition case. t1 holds the new structureID. t2 holds the old structure ID.
>     # If we have a chain, we need to check it. t0 is the base. We may clobber t1 to use it as
>     # scratch.
>-    loadp OpPutById::Metadata::structureChain[t5], t3
>+    loadp OpPutById::Metadata::m_structureChain[t5], t3
>     btpz t3, .opPutByIdTransitionDirect
> 
>     structureIDToStructureWithScratch(t2, t1, t3)
> 
>     # reload the StructureChain since we used t3 as a scratch above
>-    loadp OpPutById::Metadata::structureChain[t5], t3
>+    loadp OpPutById::Metadata::m_structureChain[t5], t3
> 
>     loadp StructureChain::m_vector[t3], t3
>     assert(macro (ok) btpnz t3, ok end)
>@@ -1462,25 +1461,25 @@ llintOpWithMetadata(op_put_by_id, OpPutB
> 
> .opPutByIdTransitionChainDone:
>     # Reload the new structure, since we clobbered it above.
>-    loadi OpPutById::Metadata::newStructure[t5], t1
>+    loadi OpPutById::Metadata::m_newStructure[t5], t1
> 
> .opPutByIdTransitionDirect:
>     storei t1, JSCell::m_structureID[t0]
>-    writeBarrierOnOperandWithReload(size, get, base, macro ()
>+    writeBarrierOnOperandWithReload(size, get, m_base, macro ()
>         # Reload metadata into t5
>         metadata(t5, t1)
>         # Reload base into t0
>-        get(base, t1)
>+        get(m_base, t1)
>         loadConstantOrVariable(size, t1, t0)
>     end)
> 
> .opPutByIdNotTransition:
>     # The only thing live right now is t0, which holds the base.
>-    get(value, t1)
>+    get(m_value, t1)
>     loadConstantOrVariable(size, t1, t2)
>-    loadi OpPutById::Metadata::offset[t5], t1
>+    loadi OpPutById::Metadata::m_offset[t5], t1
>     storePropertyAtVariableOffset(t1, t0, t2)
>-    writeBarrierOnOperands(size, get, base, value)
>+    writeBarrierOnOperands(size, get, m_base, m_value)
>     dispatch()
> 
> .opPutByIdSlow:
>@@ -1491,7 +1490,7 @@ end)
> 
> llintOpWithMetadata(op_get_by_val, OpGetByVal, macro (size, get, dispatch, metadata, return)
>     macro finishGetByVal(result, scratch)
>-        get(dst, scratch)
>+        get(m_dst, scratch)
>         storeq result, [cfr, scratch, 8]
>         valueProfile(OpGetByVal, t5, result)
>         dispatch()
>@@ -1510,13 +1509,13 @@ llintOpWithMetadata(op_get_by_val, OpGet
> 
>     metadata(t5, t2)
> 
>-    get(base, t2)
>+    get(m_base, t2)
>     loadConstantOrVariableCell(size, t2, t0, .opGetByValSlow)
> 
>     move t0, t2
>-    arrayProfile(OpGetByVal::Metadata::arrayProfile, t2, t5, t1)
>+    arrayProfile(OpGetByVal::Metadata::m_arrayProfile, t2, t5, t1)
> 
>-    get(property, t3)
>+    get(m_property, t3)
>     loadConstantOrVariableInt32(size, t3, t1, .opGetByValSlow)
>     sxi2q t1, t1
> 
>@@ -1529,7 +1528,7 @@ llintOpWithMetadata(op_get_by_val, OpGet
> 
> .opGetByValIsContiguous:
>     biaeq t1, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t3], .opGetByValSlow
>-    get(dst, t0)
>+    get(m_dst, t0)
>     loadq [t3, t1, 8], t2
>     btqz t2, .opGetByValSlow
>     jmp .opGetByValDone
>@@ -1537,7 +1536,7 @@ llintOpWithMetadata(op_get_by_val, OpGet
> .opGetByValNotContiguous:
>     bineq t2, DoubleShape, .opGetByValNotDouble
>     biaeq t1, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t3], .opGetByValSlow
>-    get(dst, t0)
>+    get(m_dst, t0)
>     loadd [t3, t1, 8], ft0
>     bdnequn ft0, ft0, .opGetByValSlow
>     fd2q ft0, t2
>@@ -1548,7 +1547,7 @@ llintOpWithMetadata(op_get_by_val, OpGet
>     subi ArrayStorageShape, t2
>     bia t2, SlowPutArrayStorageShape - ArrayStorageShape, .opGetByValNotIndexedStorage
>     biaeq t1, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t3], .opGetByValSlow
>-    get(dst, t0)
>+    get(m_dst, t0)
>     loadq ArrayStorage::m_vector[t3, t1, 8], t2
>     btqz t2, .opGetByValSlow
> 
>@@ -1661,24 +1660,24 @@ macro putByValOp(name, op)
>         macro contiguousPutByVal(storeCallback)
>             biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .outOfBounds
>         .storeResult:
>-            get(value, t2)
>+            get(m_value, t2)
>             storeCallback(t2, t1, [t0, t3, 8])
>             dispatch()
> 
>         .outOfBounds:
>             biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t0], .opPutByValOutOfBounds
>-            storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
>+            storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
>             addi 1, t3, t2
>             storei t2, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0]
>             jmp .storeResult
>         end
> 
>-        get(base, t0)
>+        get(m_base, t0)
>         loadConstantOrVariableCell(size, t0, t1, .opPutByValSlow)
>         move t1, t2
>         metadata(t5, t0)
>-        arrayProfile(%op%::Metadata::arrayProfile, t2, t5, t0)
>-        get(property, t0)
>+        arrayProfile(%op%::Metadata::m_arrayProfile, t2, t5, t0)
>+        get(m_property, t0)
>         loadConstantOrVariableInt32(size, t0, t3, .opPutByValSlow)
>         sxi2q t3, t3
>         loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr JSVALUE_GIGACAGE_MASK, JSObject::m_butterfly[t1], t0, tagTypeNumber)
>@@ -1691,7 +1690,7 @@ macro putByValOp(name, op)
>                 loadConstantOrVariable(size, operand, scratch)
>                 bqb scratch, tagTypeNumber, .opPutByValSlow
>                 storeq scratch, address
>-                writeBarrierOnOperands(size, get, base, value)
>+                writeBarrierOnOperands(size, get, m_base, m_value)
>             end)
> 
>     .opPutByValNotInt32:
>@@ -1708,7 +1707,7 @@ macro putByValOp(name, op)
>                 bdnequn ft0, ft0, .opPutByValSlow
>             .ready:
>                 stored ft0, address
>-                writeBarrierOnOperands(size, get, base, value)
>+                writeBarrierOnOperands(size, get, m_base, m_value)
>             end)
> 
>     .opPutByValNotDouble:
>@@ -1717,7 +1716,7 @@ macro putByValOp(name, op)
>             macro (operand, scratch, address)
>                 loadConstantOrVariable(size, operand, scratch)
>                 storeq scratch, address
>-                writeBarrierOnOperands(size, get, base, value)
>+                writeBarrierOnOperands(size, get, m_base, m_value)
>             end)
> 
>     .opPutByValNotContiguous:
>@@ -1725,14 +1724,14 @@ macro putByValOp(name, op)
>         biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t0], .opPutByValOutOfBounds
>         btqz ArrayStorage::m_vector[t0, t3, 8], .opPutByValArrayStorageEmpty
>     .opPutByValArrayStorageStoreResult:
>-        get(value, t2)
>+        get(m_value, t2)
>         loadConstantOrVariable(size, t2, t1)
>         storeq t1, ArrayStorage::m_vector[t0, t3, 8]
>-        writeBarrierOnOperands(size, get, base, value)
>+        writeBarrierOnOperands(size, get, m_base, m_value)
>         dispatch()
> 
>     .opPutByValArrayStorageEmpty:
>-        storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
>+        storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
>         addi 1, ArrayStorage::m_numValuesInVector[t0]
>         bib t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .opPutByValArrayStorageStoreResult
>         addi 1, t3, t1
>@@ -1740,7 +1739,7 @@ macro putByValOp(name, op)
>         jmp .opPutByValArrayStorageStoreResult
> 
>     .opPutByValOutOfBounds:
>-        storeb 1, %op%::Metadata::arrayProfile.m_outOfBounds[t5]
>+        storeb 1, %op%::Metadata::m_arrayProfile.m_outOfBounds[t5]
>     .opPutByValSlow:
>         callSlowPath(_llint_slow_path_%name%)
>         dispatch()
>@@ -1754,14 +1753,14 @@ putByValOp(put_by_val_direct, OpPutByVal
> 
> macro llintJumpTrueOrFalseOp(name, op, conditionOp)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(condition, t1)
>+        get(m_condition, t1)
>         loadConstantOrVariable(size, t1, t0)
>         btqnz t0, ~0xf, .slow
>         conditionOp(t0, .target)
>         dispatch()
> 
>     .target:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -1772,7 +1771,7 @@ end
> 
> macro equalNullJumpOp(name, op, cellHandler, immediateHandler)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(value, t0)
>+        get(m_value, t0)
>         assertNotConstant(size, t0)
>         loadq [cfr, t0, 8], t0
>         btqnz t0, tagMask, .immediate
>@@ -1781,7 +1780,7 @@ macro equalNullJumpOp(name, op, cellHand
>         dispatch()
> 
>     .target:
>-        jump(target)
>+        jump(m_target)
> 
>     .immediate:
>         andq ~TagBitUndefined, t0
>@@ -1812,8 +1811,8 @@ equalNullJumpOp(jneq_null, OpJneqNull,
> 
> 
> llintOpWithMetadata(op_jneq_ptr, OpJneqPtr, macro (size, get, dispatch, metadata, return)
>-    get(value, t0)
>-    get(specialPointer, t1)
>+    get(m_value, t0)
>+    get(m_specialPointer, t1)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_globalObject[t2], t2
>     loadp JSGlobalObject::m_specialPointers[t2, t1, PtrSize], t1
>@@ -1822,16 +1821,16 @@ llintOpWithMetadata(op_jneq_ptr, OpJneqP
> 
> .opJneqPtrTarget:
>     metadata(t5, t0)
>-    storeb 1, OpJneqPtr::Metadata::hasJumped[t5]
>-    get(target, t0)
>+    storeb 1, OpJneqPtr::Metadata::m_hasJumped[t5]
>+    get(m_target, t0)
>     jumpImpl(t0)
> end)
> 
> 
> macro compareJumpOp(name, op, integerCompare, doubleCompare)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(lhs, t2)
>-        get(rhs, t3)
>+        get(m_lhs, t2)
>+        get(m_rhs, t3)
>         loadConstantOrVariable(size, t2, t0)
>         loadConstantOrVariable(size, t3, t1)
>         bqb t0, tagTypeNumber, .op1NotInt
>@@ -1863,7 +1862,7 @@ macro compareJumpOp(name, op, integerCom
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -1874,15 +1873,15 @@ end
> 
> macro equalityJumpOp(name, op, integerComparison)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(lhs, t2)
>-        get(rhs, t3)
>+        get(m_lhs, t2)
>+        get(m_rhs, t3)
>         loadConstantOrVariableInt32(size, t2, t0, .slow)
>         loadConstantOrVariableInt32(size, t3, t1, .slow)
>         integerComparison(t0, t1, .jumpTarget)
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
> 
>     .slow:
>         callSlowPath(_llint_slow_path_%name%)
>@@ -1891,25 +1890,25 @@ macro equalityJumpOp(name, op, integerCo
> end
> 
> 
>-macro compareUnsignedJumpOp(name, op, integerCompare)
>+macro compareUnsignedJumpOp(name, op, integerCompareMacro)
>     llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
>-        get(lhs, t2)
>-        get(rhs, t3)
>+        get(m_lhs, t2)
>+        get(m_rhs, t3)
>         loadConstantOrVariable(size, t2, t0)
>         loadConstantOrVariable(size, t3, t1)
>-        integerCompare(t0, t1, .jumpTarget)
>+        integerCompareMacro(t0, t1, .jumpTarget)
>         dispatch()
> 
>     .jumpTarget:
>-        jump(target)
>+        jump(m_target)
>     end)
> end
> 
> 
> macro compareUnsignedOp(name, op, integerCompareAndSet)
>     llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
>-        get(lhs, t2)
>-        get(rhs,  t0)
>+        get(m_lhs, t2)
>+        get(m_rhs,  t0)
>         loadConstantOrVariable(size, t0, t1)
>         loadConstantOrVariable(size, t2, t0)
>         integerCompareAndSet(t0, t1, t0)
>@@ -1920,8 +1919,8 @@ end
> 
> 
> llintOpWithJump(op_switch_imm, OpSwitchImm, macro (size, get, jump, dispatch)
>-    get(scrutinee, t2)
>-    get(tableIndex, t3)
>+    get(m_scrutinee, t2)
>+    get(m_tableIndex, t3)
>     loadConstantOrVariable(size, t2, t1)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_rareData[t2], t2
>@@ -1939,7 +1938,7 @@ llintOpWithJump(op_switch_imm, OpSwitchI
> .opSwitchImmNotInt:
>     btqnz t1, tagTypeNumber, .opSwitchImmSlow   # Go slow if it's a double.
> .opSwitchImmFallThrough:
>-    jump(defaultOffset)
>+    jump(m_defaultOffset)
> 
> .opSwitchImmSlow:
>     callSlowPath(_llint_slow_path_switch_imm)
>@@ -1948,8 +1947,8 @@ end)
> 
> 
> llintOpWithJump(op_switch_char, OpSwitchChar, macro (size, get, jump, dispatch)
>-    get(scrutinee, t2)
>-    get(tableIndex, t3)
>+    get(m_scrutinee, t2)
>+    get(m_tableIndex, t3)
>     loadConstantOrVariable(size, t2, t1)
>     loadp CodeBlock[cfr], t2
>     loadp CodeBlock::m_rareData[t2], t2
>@@ -1976,7 +1975,7 @@ llintOpWithJump(op_switch_char, OpSwitch
>     dispatchIndirect(t1)
> 
> .opSwitchCharFallThrough:
>-    jump(defaultOffset)
>+    jump(m_defaultOffset)
> 
> .opSwitchOnRope:
>     callSlowPath(_llint_slow_path_switch_char)
>@@ -1986,12 +1985,12 @@ end)
> 
> # we assume t5 contains the metadata, and we should not scratch that
> macro arrayProfileForCall(op, getu)
>-    getu(argv, t3)
>+    getu(m_argv, t3)
>     negp t3
>     loadq ThisArgumentOffset[cfr, t3, 8], t0
>     btqnz t0, tagMask, .done
>     loadi JSCell::m_structureID[t0], t3
>-    storei t3, %op%::Metadata::arrayProfile.m_lastSeenStructureID[t5]
>+    storei t3, %op%::Metadata::m_arrayProfile.m_lastSeenStructureID[t5]
> .done:
> end
> 
>@@ -1999,31 +1998,31 @@ macro commonCallOp(name, slowPath, op, p
>     llintOpWithMetadata(name, op, macro (size, get, dispatch, metadata, return)
>         metadata(t5, t0)
> 
>-        prologue(macro (field, dst)
>-            getu(size, op, field, dst)
>+        prologue(macro (fieldName, dst)
>+            getu(size, op, fieldName, dst)
>         end, metadata)
> 
>-        get(callee, t0)
>-        loadp %op%::Metadata::callLinkInfo.callee[t5], t2
>+        get(m_callee, t0)
>+        loadp %op%::Metadata::m_callLinkInfo.callee[t5], t2
>         loadConstantOrVariable(size, t0, t3)
>         bqneq t3, t2, .opCallSlow
>-        getu(size, op, argv, t3)
>+        getu(size, op, m_argv, t3)
>         lshifti 3, t3
>         negp t3
>         addp cfr, t3
>         storeq t2, Callee[t3]
>-        getu(size, op, argc, t2)
>+        getu(size, op, m_argc, t2)
>         storei PC, ArgumentCount + TagOffset[cfr]
>         storei t2, ArgumentCount + PayloadOffset[t3]
>         move t3, sp
>         if POISON
>             loadp _g_JITCodePoison, t2
>-            xorp %op%::Metadata::callLinkInfo.machineCodeTarget[t5], t2
>+            xorp %op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], t2
>             prepareCall(t2, t1, t3, t4, JSEntryPtrTag)
>             callTargetFunction(size, op, dispatch, t2, JSEntryPtrTag)
>         else
>-            prepareCall(%op%::Metadata::callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
>-            callTargetFunction(size, op, dispatch, %op%::Metadata::callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
>+            prepareCall(%op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
>+            callTargetFunction(size, op, dispatch, %op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
>         end
> 
>     .opCallSlow:
>@@ -2033,14 +2032,14 @@ end
> 
> llintOp(op_ret, OpRet, macro (size, get, dispatch)
>     checkSwitchToJITForEpilogue()
>-    get(value, t2)
>+    get(m_value, t2)
>     loadConstantOrVariable(size, t2, r0)
>     doReturn()
> end)
> 
> 
> llintOpWithReturn(op_to_primitive, OpToPrimitive, macro (size, get, dispatch, return)
>-    get(src, t2)
>+    get(m_src, t2)
>     loadConstantOrVariable(size, t2, t0)
>     btqnz t0, tagMask, .opToPrimitiveIsImm
>     bbaeq JSCell::m_type[t0], ObjectType, .opToPrimitiveSlowCase
>@@ -2085,11 +2084,11 @@ commonOp(llint_op_catch, macro() end, ma
> 
>     loadp VM::m_exception[t3], t0
>     storep 0, VM::m_exception[t3]
>-    get(size, OpCatch, exception, t2)
>+    get(size, OpCatch, m_exception, t2)
>     storeq t0, [cfr, t2, 8]
> 
>     loadq Exception::m_value[t0], t3
>-    get(size, OpCatch, thrownValue, t2)
>+    get(size, OpCatch, m_thrownValue, t2)
>     storeq t3, [cfr, t2, 8]
> 
>     traceExecution()
>@@ -2102,7 +2101,7 @@ end)
> 
> llintOp(op_end, OpEnd, macro (size, get, dispatch)
>     checkSwitchToJITForEpilogue()
>-    get(value, t0)
>+    get(m_value, t0)
>     assertNotConstant(size, t0)
>     loadq [cfr, t0, 8], r0
>     doReturn()
>@@ -2233,13 +2232,13 @@ llintOpWithMetadata(op_resolve_scope, Op
>     metadata(t5, t0)
> 
>     macro getConstantScope()
>-        loadp OpResolveScope::Metadata::constantScope[t5],  t0
>+        loadp OpResolveScope::Metadata::m_constantScope[t5],  t0
>         return(t0)
>     end
> 
>     macro resolveScope()
>-        loadi OpResolveScope::Metadata::localScopeDepth[t5], t2
>-        get(scope, t0)
>+        loadi OpResolveScope::Metadata::m_localScopeDepth[t5], t2
>+        get(m_scope, t0)
>         loadq [cfr, t0, 8], t0
>         btiz t2, .resolveScopeLoopEnd
> 
>@@ -2252,7 +2251,7 @@ llintOpWithMetadata(op_resolve_scope, Op
>         return(t0)
>     end
> 
>-    loadp OpResolveScope::Metadata::resolveType[t5], t0
>+    loadp OpResolveScope::Metadata::m_resolveType[t5], t0
> 
> #rGlobalProperty:
>     bineq t0, GlobalProperty, .rGlobalVar
>@@ -2301,10 +2300,10 @@ end)
> 
> 
> macro loadWithStructureCheck(op, get, slowPath)
>-    get(scope, t0)
>+    get(m_scope, t0)
>     loadq [cfr, t0, 8], t0
>     loadStructureWithScratch(t0, t2, t1, t3)
>-    loadp %op%::Metadata::structure[t5], t1
>+    loadp %op%::Metadata::m_structure[t5], t1
>     bpneq t2, t1, slowPath
> end
> 
>@@ -2312,14 +2311,14 @@ llintOpWithMetadata(op_get_from_scope, O
>     metadata(t5, t0)
> 
>     macro getProperty()
>-        loadp OpGetFromScope::Metadata::operand[t5], t1
>+        loadp OpGetFromScope::Metadata::m_operand[t5], t1
>         loadPropertyAtVariableOffset(t1, t0, t2)
>         valueProfile(OpGetFromScope, t5, t2)
>         return(t2)
>     end
> 
>     macro getGlobalVar(tdzCheckIfNecessary)
>-        loadp OpGetFromScope::Metadata::operand[t5], t0
>+        loadp OpGetFromScope::Metadata::m_operand[t5], t0
>         loadq [t0], t0
>         tdzCheckIfNecessary(t0)
>         valueProfile(OpGetFromScope, t5, t0)
>@@ -2327,13 +2326,13 @@ llintOpWithMetadata(op_get_from_scope, O
>     end
> 
>     macro getClosureVar()
>-        loadp OpGetFromScope::Metadata::operand[t5], t1
>+        loadp OpGetFromScope::Metadata::m_operand[t5], t1
>         loadq JSLexicalEnvironment_variables[t0, t1, 8], t0
>         valueProfile(OpGetFromScope, t5, t0)
>         return(t0)
>     end
> 
>-    loadi OpGetFromScope::Metadata::getPutInfo[t5], t0
>+    loadi OpGetFromScope::Metadata::m_getPutInfo[t5], t0
>     andi ResolveTypeMask, t0
> 
> #gGlobalProperty:
>@@ -2354,7 +2353,7 @@ llintOpWithMetadata(op_get_from_scope, O
> 
> .gClosureVar:
>     bineq t0, ClosureVar, .gGlobalPropertyWithVarInjectionChecks
>-    loadVariable(get, scope, t0)
>+    loadVariable(get, m_scope, t0)
>     getClosureVar()
> 
> .gGlobalPropertyWithVarInjectionChecks:
>@@ -2378,7 +2377,7 @@ llintOpWithMetadata(op_get_from_scope, O
> .gClosureVarWithVarInjectionChecks:
>     bineq t0, ClosureVarWithVarInjectionChecks, .gDynamic
>     varInjectionCheck(.gDynamic, t2)
>-    loadVariable(get, scope, t0)
>+    loadVariable(get, m_scope, t0)
>     getClosureVar()
> 
> .gDynamic:
>@@ -2389,100 +2388,100 @@ end)
> 
> llintOpWithMetadata(op_put_to_scope, OpPutToScope, macro (size, get, dispatch, metadata, return)
>     macro putProperty()
>-        get(value, t1)
>+        get(m_value, t1)
>         loadConstantOrVariable(size, t1, t2)
>-        loadis OpPutToScope::Metadata::operand[t5], t1
>+        loadis OpPutToScope::Metadata::m_operand[t5], t1
>         storePropertyAtVariableOffset(t1, t0, t2)
>     end
> 
>     macro putGlobalVariable()
>-        get(value, t0)
>+        get(m_value, t0)
>         loadConstantOrVariable(size, t0, t1)
>-        loadp OpPutToScope::Metadata::watchpointSet[t5], t2
>-        loadp OpPutToScope::Metadata::operand[t5], t0
>+        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t2
>+        loadp OpPutToScope::Metadata::m_operand[t5], t0
>         notifyWrite(t2, .pDynamic)
>         storeq t1, [t0]
>     end
> 
>     macro putClosureVar()
>-        get(value, t1)
>+        get(m_value, t1)
>         loadConstantOrVariable(size, t1, t2)
>-        loadis OpPutToScope::Metadata::operand[t5], t1
>+        loadis OpPutToScope::Metadata::m_operand[t5], t1
>         storeq t2, JSLexicalEnvironment_variables[t0, t1, 8]
>     end
> 
>     macro putLocalClosureVar()
>-        get(value, t1)
>+        get(m_value, t1)
>         loadConstantOrVariable(size, t1, t2)
>-        loadp OpPutToScope::Metadata::watchpointSet[t5], t3
>+        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t3
>         btpz t3, .noVariableWatchpointSet
>         notifyWrite(t3, .pDynamic)
>     .noVariableWatchpointSet:
>-        loadis OpPutToScope::Metadata::operand[t5], t1
>+        loadis OpPutToScope::Metadata::m_operand[t5], t1
>         storeq t2, JSLexicalEnvironment_variables[t0, t1, 8]
>     end
> 
>     macro checkTDZInGlobalPutToScopeIfNecessary()
>-        loadis OpPutToScope::Metadata::getPutInfo[t5], t0
>+        loadis OpPutToScope::Metadata::m_getPutInfo[t5], t0
>         andi InitializationModeMask, t0
>         rshifti InitializationModeShift, t0
>         bineq t0, NotInitialization, .noNeedForTDZCheck
>-        loadp OpPutToScope::Metadata::operand[t5], t0
>+        loadp OpPutToScope::Metadata::m_operand[t5], t0
>         loadq [t0], t0
>         bqeq t0, ValueEmpty, .pDynamic
>     .noNeedForTDZCheck:
>     end
> 
>     metadata(t5, t0)
>-    loadi OpPutToScope::Metadata::getPutInfo[t5], t0
>+    loadi OpPutToScope::Metadata::m_getPutInfo[t5], t0
>     andi ResolveTypeMask, t0
> 
> #pLocalClosureVar:
>     bineq t0, LocalClosureVar, .pGlobalProperty
>-    loadVariable(get, scope, t0)
>+    loadVariable(get, m_scope, t0)
>     putLocalClosureVar()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalProperty:
>     bineq t0, GlobalProperty, .pGlobalVar
>     loadWithStructureCheck(OpPutToScope, get, .pDynamic)
>     putProperty()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalVar:
>     bineq t0, GlobalVar, .pGlobalLexicalVar
>     putGlobalVariable()
>-    writeBarrierOnGlobalObject(size, get, value)
>+    writeBarrierOnGlobalObject(size, get, m_value)
>     dispatch()
> 
> .pGlobalLexicalVar:
>     bineq t0, GlobalLexicalVar, .pClosureVar
>     checkTDZInGlobalPutToScopeIfNecessary()
>     putGlobalVariable()
>-    writeBarrierOnGlobalLexicalEnvironment(size, get, value)
>+    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
>     dispatch()
> 
> .pClosureVar:
>     bineq t0, ClosureVar, .pGlobalPropertyWithVarInjectionChecks
>-    loadVariable(get, scope, t0)
>+    loadVariable(get, m_scope, t0)
>     putClosureVar()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalPropertyWithVarInjectionChecks:
>     bineq t0, GlobalPropertyWithVarInjectionChecks, .pGlobalVarWithVarInjectionChecks
>     loadWithStructureCheck(OpPutToScope, get, .pDynamic)
>     putProperty()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pGlobalVarWithVarInjectionChecks:
>     bineq t0, GlobalVarWithVarInjectionChecks, .pGlobalLexicalVarWithVarInjectionChecks
>     varInjectionCheck(.pDynamic, t2)
>     putGlobalVariable()
>-    writeBarrierOnGlobalObject(size, get, value)
>+    writeBarrierOnGlobalObject(size, get, m_value)
>     dispatch()
> 
> .pGlobalLexicalVarWithVarInjectionChecks:
>@@ -2490,15 +2489,15 @@ llintOpWithMetadata(op_put_to_scope, OpP
>     varInjectionCheck(.pDynamic, t2)
>     checkTDZInGlobalPutToScopeIfNecessary()
>     putGlobalVariable()
>-    writeBarrierOnGlobalLexicalEnvironment(size, get, value)
>+    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
>     dispatch()
> 
> .pClosureVarWithVarInjectionChecks:
>     bineq t0, ClosureVarWithVarInjectionChecks, .pModuleVar
>     varInjectionCheck(.pDynamic, t2)
>-    loadVariable(get, scope, t0)
>+    loadVariable(get, m_scope, t0)
>     putClosureVar()
>-    writeBarrierOnOperands(size, get, scope, value)
>+    writeBarrierOnOperands(size, get, m_scope, m_value)
>     dispatch()
> 
> .pModuleVar:
>@@ -2513,26 +2512,26 @@ end)
> 
> 
> llintOpWithProfile(op_get_from_arguments, OpGetFromArguments, macro (size, get, dispatch, return)
>-    loadVariable(get, arguments, t0)
>-    getu(size, OpGetFromArguments, index, t1)
>+    loadVariable(get, m_arguments, t0)
>+    getu(size, OpGetFromArguments, m_index, t1)
>     loadq DirectArguments_storage[t0, t1, 8], t0
>     return(t0)
> end)
> 
> 
> llintOp(op_put_to_arguments, OpPutToArguments, macro (size, get, dispatch)
>-    loadVariable(get, arguments, t0)
>-    getu(size, OpPutToArguments, index, t1)
>-    get(value, t3)
>+    loadVariable(get, m_arguments, t0)
>+    getu(size, OpPutToArguments, m_index, t1)
>+    get(m_value, t3)
>     loadConstantOrVariable(size, t3, t2)
>     storeq t2, DirectArguments_storage[t0, t1, 8]
>-    writeBarrierOnOperands(size, get, arguments, value)
>+    writeBarrierOnOperands(size, get, m_arguments, m_value)
>     dispatch()
> end)
> 
> 
> llintOpWithReturn(op_get_parent_scope, OpGetParentScope, macro (size, get, dispatch, return)
>-    loadVariable(get, scope, t0)
>+    loadVariable(get, m_scope, t0)
>     loadp JSScope::m_next[t0], t0
>     return(t0)
> end)
>@@ -2548,7 +2547,7 @@ llintOpWithMetadata(op_profile_type, OpP
>     loadp TypeProfilerLog::m_currentLogEntryPtr[t1], t2
> 
>     # t0 is holding the JSValue argument.
>-    get(target, t3)
>+    get(m_target, t3)
>     loadConstantOrVariable(size, t3, t0)
> 
>     bqeq t0, ValueEmpty, .opProfileTypeDone
>@@ -2557,7 +2556,7 @@ llintOpWithMetadata(op_profile_type, OpP
>     
>     # Store the TypeLocation onto the log entry.
>     metadata(t5, t3)
>-    loadp OpProfileType::Metadata::typeLocation[t5], t3
>+    loadp OpProfileType::Metadata::m_typeLocation[t5], t3
>     storep t3, TypeProfilerLog::LogEntry::location[t2]
> 
>     btqz t0, tagMask, .opProfileTypeIsCell
>@@ -2583,7 +2582,7 @@ end)
> 
> llintOpWithMetadata(op_profile_control_flow, OpProfileControlFlow, macro (size, get, dispatch, metadata, return)
>     metadata(t5, t0)
>-    loadp OpProfileControlFlow::Metadata::basicBlockLocation[t5], t0
>+    loadp OpProfileControlFlow::Metadata::m_basicBlockLocation[t5], t0
>     addq 1, BasicBlockLocation::m_executionCount[t0]
>     dispatch()
> end)
>@@ -2592,7 +2591,7 @@ end)
> llintOpWithReturn(op_get_rest_length, OpGetRestLength, macro (size, get, dispatch, return)
>     loadi PayloadOffset + ArgumentCount[cfr], t0
>     subi 1, t0
>-    getu(size, OpGetRestLength, numParametersToSkip, t1)
>+    getu(size, OpGetRestLength, m_numParametersToSkip, t1)
>     bilteq t0, t1, .storeZero
>     subi t1, t0
>     jmp .boxUp
>@@ -2611,7 +2610,7 @@ llintOp(op_log_shadow_chicken_prologue, 
>     storep t1, ShadowChicken::Packet::callerFrame[t0]
>     loadp Callee[cfr], t1
>     storep t1, ShadowChicken::Packet::callee[t0]
>-    loadVariable(get, scope, t1)
>+    loadVariable(get, m_scope, t1)
>     storep t1, ShadowChicken::Packet::scope[t0]
>     dispatch()
> .opLogShadowChickenPrologueSlow:
>@@ -2624,9 +2623,9 @@ llintOp(op_log_shadow_chicken_tail, OpLo
>     acquireShadowChickenPacket(.opLogShadowChickenTailSlow)
>     storep cfr, ShadowChicken::Packet::frame[t0]
>     storep ShadowChickenTailMarker, ShadowChicken::Packet::callee[t0]
>-    loadVariable(get, thisValue, t1)
>+    loadVariable(get, m_thisValue, t1)
>     storep t1, ShadowChicken::Packet::thisValue[t0]
>-    loadVariable(get, scope, t1)
>+    loadVariable(get, m_scope, t1)
>     storep t1, ShadowChicken::Packet::scope[t0]
>     loadp CodeBlock[cfr], t1
>     storep t1, ShadowChicken::Packet::codeBlock[t0]
>Index: Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>===================================================================
>--- Source/JavaScriptCore/llint/LowLevelInterpreter.asm	(revision 239990)
>+++ Source/JavaScriptCore/llint/LowLevelInterpreter.asm	(working copy)
>@@ -1,4 +1,4 @@
>-# 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
>@@ -323,15 +323,15 @@ macro dispatchOp(size, op)
>     size(dispatchNarrow, dispatchWide, macro (dispatch) dispatch() end)
> end
> 
>-macro getu(size, op, field, dst)
>+macro getu(size, op, fieldName, dst)
>     size(getuOperandNarrow, getuOperandWide, macro (getu)
>-        getu(op, field, dst)
>+        getu(op, fieldName, dst)
>     end)
> end
> 
>-macro get(size, op, field, dst)
>+macro get(size, op, fieldName, dst)
>     size(getOperandNarrow, getOperandWide, macro (get)
>-        get(op, field, dst)
>+        get(op, fieldName, dst)
>     end)
> end
> 
>@@ -345,7 +345,7 @@ end
> 
> macro metadata(size, opcode, dst, scratch)
>     loadi constexpr %opcode%::opcodeID * 4[metadataTable], dst # offset = metadataTable<unsigned*>[opcodeID]
>-    getu(size, opcode, metadataID, scratch) # scratch = bytecode.metadataID
>+    getu(size, opcode, m_metadataID, scratch) # scratch = bytecode.m_metadataID
>     muli sizeof %opcode%::Metadata, scratch # scratch *= sizeof(Op::Metadata)
>     addi scratch, dst # offset += scratch
>     addp metadataTable, dst # return &metadataTable[offset]
>@@ -377,8 +377,8 @@ end
> 
> macro llintOp(name, op, fn)
>     commonOp(llint_%name%, traceExecution, macro(size)
>-        macro getImpl(field, dst)
>-            get(size, op, field, dst)
>+        macro getImpl(fieldName, dst)
>+            get(size, op, fieldName, dst)
>         end
> 
>         macro dispatchImpl()
>@@ -408,8 +408,8 @@ end
> 
> macro llintOpWithJump(name, op, impl)
>     llintOpWithMetadata(name, op, macro(size, get, dispatch, metadata, return)
>-        macro jump(field)
>-            get(field, t0)
>+        macro jump(fieldName)
>+            get(fieldName, t0)
>             jumpImpl(t0)
>         end
> 
>@@ -854,10 +854,10 @@ macro preserveReturnAddressAfterCall(des
>     end
> end
> 
>-macro unpoison(poison, field, scratch)
>+macro unpoison(poison, fieldReg, scratch)
>     if POISON
>         loadp poison, scratch
>-        xorp scratch, field
>+        xorp scratch, fieldReg
>     end
> end
> 
>@@ -1555,7 +1555,7 @@ compareUnsignedOp(beloweq, OpBeloweq,
> 
> 
> llintOpWithJump(op_jmp, OpJmp, macro (size, get, jump, dispatch)
>-    jump(target)
>+    jump(m_target)
> end)
> 
> 
>Index: Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/CommonSlowPaths.cpp	(revision 239990)
>+++ Source/JavaScriptCore/runtime/CommonSlowPaths.cpp	(working copy)
>@@ -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
>@@ -125,8 +125,8 @@ namespace JSC {
>         bool bCondition = (condition);                         \
>         CHECK_EXCEPTION();                                  \
>         if (bCondition)                                        \
>-            pc = bytecode.target \
>-                ? reinterpret_cast<const Instruction*>(reinterpret_cast<const uint8_t*>(pc) + bytecode.target) \
>+            pc = bytecode.m_target \
>+                ? reinterpret_cast<const Instruction*>(reinterpret_cast<const uint8_t*>(pc) + bytecode.m_target) \
>                 : exec->codeBlock()->outOfLineJumpTarget(pc);                              \
>         else                                                      \
>             pc = reinterpret_cast<const Instruction*>(reinterpret_cast<const uint8_t*>(pc) + pc->size()); \
>@@ -141,7 +141,7 @@ namespace JSC {
>         END_IMPL();                         \
>     } while (false)
> 
>-#define RETURN_WITH_PROFILING(value__, profilingAction__) RETURN_WITH_PROFILING_CUSTOM(bytecode.dst, value__, profilingAction__)
>+#define RETURN_WITH_PROFILING(value__, profilingAction__) RETURN_WITH_PROFILING_CUSTOM(bytecode.m_dst, value__, profilingAction__)
> 
> #define RETURN(value) \
>     RETURN_WITH_PROFILING(value, { })
>@@ -150,7 +150,7 @@ namespace JSC {
>     RETURN_WITH_PROFILING(value__, PROFILE_VALUE(returnValue__))
> 
> #define PROFILE_VALUE(value) do { \
>-        bytecode.metadata(exec).profile.m_buckets[0] = JSValue::encode(value); \
>+        bytecode.metadata(exec).m_profile.m_buckets[0] = JSValue::encode(value); \
>     } while (false)
> 
> #define CALL_END_IMPL(exec, callTarget, callTargetTag) \
>@@ -215,7 +215,7 @@ SLOW_PATH_DECL(slow_path_create_scoped_a
> {
>     BEGIN();
>     auto bytecode = pc->as<OpCreateScopedArguments>();
>-    JSLexicalEnvironment* scope = jsCast<JSLexicalEnvironment*>(GET(bytecode.scope).jsValue());
>+    JSLexicalEnvironment* scope = jsCast<JSLexicalEnvironment*>(GET(bytecode.m_scope).jsValue());
>     ScopedArgumentsTable* table = scope->symbolTable()->arguments();
>     RETURN(ScopedArguments::createByCopying(exec, table, scope));
> }
>@@ -232,16 +232,16 @@ SLOW_PATH_DECL(slow_path_create_this)
>     BEGIN();
>     auto bytecode = pc->as<OpCreateThis>();
>     JSObject* result;
>-    JSObject* constructorAsObject = asObject(GET(bytecode.callee).jsValue());
>+    JSObject* constructorAsObject = asObject(GET(bytecode.m_callee).jsValue());
>     if (constructorAsObject->type() == JSFunctionType && jsCast<JSFunction*>(constructorAsObject)->canUseAllocationProfile()) {
>         JSFunction* constructor = jsCast<JSFunction*>(constructorAsObject);
>-        WriteBarrier<JSCell>& cachedCallee = bytecode.metadata(exec).cachedCallee;
>+        WriteBarrier<JSCell>& cachedCallee = bytecode.metadata(exec).m_cachedCallee;
>         if (!cachedCallee)
>             cachedCallee.set(vm, exec->codeBlock(), constructor);
>         else if (cachedCallee.unvalidatedGet() != JSCell::seenMultipleCalleeObjects() && cachedCallee.get() != constructor)
>             cachedCallee.setWithoutWriteBarrier(JSCell::seenMultipleCalleeObjects());
> 
>-        size_t inlineCapacity = bytecode.inlineCapacity;
>+        size_t inlineCapacity = bytecode.m_inlineCapacity;
>         ObjectAllocationProfile* allocationProfile = constructor->ensureRareDataAndAllocationProfile(exec, inlineCapacity)->objectAllocationProfile();
>         Structure* structure = allocationProfile->structure();
>         result = constructEmptyObject(exec, structure);
>@@ -269,18 +269,18 @@ SLOW_PATH_DECL(slow_path_to_this)
>     BEGIN();
>     auto bytecode = pc->as<OpToThis>();
>     auto& metadata = bytecode.metadata(exec);
>-    JSValue v1 = GET(bytecode.srcDst).jsValue();
>+    JSValue v1 = GET(bytecode.m_srcDst).jsValue();
>     if (v1.isCell()) {
>         Structure* myStructure = v1.asCell()->structure(vm);
>-        Structure* otherStructure = metadata.cachedStructure.get();
>+        Structure* otherStructure = metadata.m_cachedStructure.get();
>         if (myStructure != otherStructure) {
>             if (otherStructure)
>-                metadata.toThisStatus = ToThisConflicted;
>-            metadata.cachedStructure.set(vm, exec->codeBlock(), myStructure);
>+                metadata.m_toThisStatus = ToThisConflicted;
>+            metadata.m_cachedStructure.set(vm, exec->codeBlock(), myStructure);
>         }
>     } else {
>-        metadata.toThisStatus = ToThisConflicted;
>-        metadata.cachedStructure.clear();
>+        metadata.m_toThisStatus = ToThisConflicted;
>+        metadata.m_cachedStructure.clear();
>     }
>     // Note: We only need to do this value profiling here on the slow path. The fast path
>     // just returns the input to to_this if the structure check succeeds. If the structure
>@@ -289,7 +289,7 @@ SLOW_PATH_DECL(slow_path_to_this)
>     // the same SpeculatedType. Therefore, we don't need to worry about value profiling on the
>     // fast path.
>     auto value = v1.toThis(exec, exec->codeBlock()->isStrictMode() ? StrictMode : NotStrictMode);
>-    RETURN_WITH_PROFILING_CUSTOM(bytecode.srcDst, value, PROFILE_VALUE(value));
>+    RETURN_WITH_PROFILING_CUSTOM(bytecode.m_srcDst, value, PROFILE_VALUE(value));
> }
> 
> SLOW_PATH_DECL(slow_path_throw_tdz_error)
>@@ -314,90 +314,90 @@ SLOW_PATH_DECL(slow_path_not)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpNot>();
>-    RETURN(jsBoolean(!GET_C(bytecode.operand).jsValue().toBoolean(exec)));
>+    RETURN(jsBoolean(!GET_C(bytecode.m_operand).jsValue().toBoolean(exec)));
> }
> 
> SLOW_PATH_DECL(slow_path_eq)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpEq>();
>-    RETURN(jsBoolean(JSValue::equal(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
>+    RETURN(jsBoolean(JSValue::equal(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_neq)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpNeq>();
>-    RETURN(jsBoolean(!JSValue::equal(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
>+    RETURN(jsBoolean(!JSValue::equal(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_stricteq)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpStricteq>();
>-    RETURN(jsBoolean(JSValue::strictEqual(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
>+    RETURN(jsBoolean(JSValue::strictEqual(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_nstricteq)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpNstricteq>();
>-    RETURN(jsBoolean(!JSValue::strictEqual(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
>+    RETURN(jsBoolean(!JSValue::strictEqual(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_less)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpLess>();
>-    RETURN(jsBoolean(jsLess<true>(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
>+    RETURN(jsBoolean(jsLess<true>(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_lesseq)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpLesseq>();
>-    RETURN(jsBoolean(jsLessEq<true>(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
>+    RETURN(jsBoolean(jsLessEq<true>(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_greater)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpGreater>();
>-    RETURN(jsBoolean(jsLess<false>(exec, GET_C(bytecode.rhs).jsValue(), GET_C(bytecode.lhs).jsValue())));
>+    RETURN(jsBoolean(jsLess<false>(exec, GET_C(bytecode.m_rhs).jsValue(), GET_C(bytecode.m_lhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_greatereq)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpGreatereq>();
>-    RETURN(jsBoolean(jsLessEq<false>(exec, GET_C(bytecode.rhs).jsValue(), GET_C(bytecode.lhs).jsValue())));
>+    RETURN(jsBoolean(jsLessEq<false>(exec, GET_C(bytecode.m_rhs).jsValue(), GET_C(bytecode.m_lhs).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_inc)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpInc>();
>-    RETURN_WITH_PROFILING_CUSTOM(bytecode.srcDst, jsNumber(GET(bytecode.srcDst).jsValue().toNumber(exec) + 1), { });
>+    RETURN_WITH_PROFILING_CUSTOM(bytecode.m_srcDst, jsNumber(GET(bytecode.m_srcDst).jsValue().toNumber(exec) + 1), { });
> }
> 
> SLOW_PATH_DECL(slow_path_dec)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpDec>();
>-    RETURN_WITH_PROFILING_CUSTOM(bytecode.srcDst, jsNumber(GET(bytecode.srcDst).jsValue().toNumber(exec) - 1), { });
>+    RETURN_WITH_PROFILING_CUSTOM(bytecode.m_srcDst, jsNumber(GET(bytecode.m_srcDst).jsValue().toNumber(exec) - 1), { });
> }
> 
> SLOW_PATH_DECL(slow_path_to_string)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpToString>();
>-    RETURN(GET_C(bytecode.operand).jsValue().toString(exec));
>+    RETURN(GET_C(bytecode.m_operand).jsValue().toString(exec));
> }
> 
> #if ENABLE(JIT)
> static void updateArithProfileForUnaryArithOp(OpNegate::Metadata& metadata, JSValue result, JSValue operand)
> {
>-    ArithProfile& profile = metadata.arithProfile;
>+    ArithProfile& profile = metadata.m_arithProfile;
>     profile.observeLHS(operand);
>     ASSERT(result.isNumber() || result.isBigInt());
>     if (result.isNumber()) {
>@@ -434,7 +434,7 @@ SLOW_PATH_DECL(slow_path_negate)
>     BEGIN();
>     auto bytecode = pc->as<OpNegate>();
>     auto& metadata = bytecode.metadata(exec);
>-    JSValue operand = GET_C(bytecode.operand).jsValue();
>+    JSValue operand = GET_C(bytecode.m_operand).jsValue();
>     JSValue primValue = operand.toPrimitive(exec, PreferNumber);
>     CHECK_EXCEPTION();
> 
>@@ -491,7 +491,7 @@ SLOW_PATH_DECL(slow_path_to_number)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpToNumber>();
>-    JSValue argument = GET_C(bytecode.operand).jsValue();
>+    JSValue argument = GET_C(bytecode.m_operand).jsValue();
>     JSValue result = jsNumber(argument.toNumber(exec));
>     RETURN_PROFILED(result);
> }
>@@ -500,9 +500,9 @@ SLOW_PATH_DECL(slow_path_to_object)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpToObject>();
>-    JSValue argument = GET_C(bytecode.operand).jsValue();
>+    JSValue argument = GET_C(bytecode.m_operand).jsValue();
>     if (UNLIKELY(argument.isUndefinedOrNull())) {
>-        const Identifier& ident = exec->codeBlock()->identifier(bytecode.message);
>+        const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_message);
>         if (!ident.isEmpty())
>             THROW(createTypeError(exec, ident.impl()));
>     }
>@@ -514,8 +514,8 @@ SLOW_PATH_DECL(slow_path_add)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpAdd>();
>-    JSValue v1 = GET_C(bytecode.lhs).jsValue();
>-    JSValue v2 = GET_C(bytecode.rhs).jsValue();
>+    JSValue v1 = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue v2 = GET_C(bytecode.m_rhs).jsValue();
>     JSValue result;
> 
>     ArithProfile& arithProfile = *exec->codeBlock()->arithProfileForPC(pc);
>@@ -543,8 +543,8 @@ SLOW_PATH_DECL(slow_path_mul)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpMul>();
>-    JSValue left = GET_C(bytecode.lhs).jsValue();
>-    JSValue right = GET_C(bytecode.rhs).jsValue();
>+    JSValue left = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue right = GET_C(bytecode.m_rhs).jsValue();
>     JSValue result = jsMul(exec, left, right);
>     CHECK_EXCEPTION();
>     RETURN_WITH_PROFILING(result, {
>@@ -556,8 +556,8 @@ SLOW_PATH_DECL(slow_path_sub)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpSub>();
>-    JSValue left = GET_C(bytecode.lhs).jsValue();
>-    JSValue right = GET_C(bytecode.rhs).jsValue();
>+    JSValue left = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue right = GET_C(bytecode.m_rhs).jsValue();
>     auto leftNumeric = left.toNumeric(exec);
>     CHECK_EXCEPTION();
>     auto rightNumeric = right.toNumeric(exec);
>@@ -585,8 +585,8 @@ SLOW_PATH_DECL(slow_path_div)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpDiv>();
>-    JSValue left = GET_C(bytecode.lhs).jsValue();
>-    JSValue right = GET_C(bytecode.rhs).jsValue();
>+    JSValue left = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue right = GET_C(bytecode.m_rhs).jsValue();
>     auto leftNumeric = left.toNumeric(exec);
>     CHECK_EXCEPTION();
>     auto rightNumeric = right.toNumeric(exec);
>@@ -616,8 +616,8 @@ SLOW_PATH_DECL(slow_path_mod)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpMod>();
>-    JSValue left = GET_C(bytecode.lhs).jsValue();
>-    JSValue right = GET_C(bytecode.rhs).jsValue();
>+    JSValue left = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue right = GET_C(bytecode.m_rhs).jsValue();
>     auto leftNumeric = left.toNumeric(exec);
>     CHECK_EXCEPTION();
>     auto rightNumeric = right.toNumeric(exec);
>@@ -642,10 +642,10 @@ SLOW_PATH_DECL(slow_path_pow)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpPow>();
>-    double a = GET_C(bytecode.lhs).jsValue().toNumber(exec);
>+    double a = GET_C(bytecode.m_lhs).jsValue().toNumber(exec);
>     if (UNLIKELY(throwScope.exception()))
>         RETURN(JSValue());
>-    double b = GET_C(bytecode.rhs).jsValue().toNumber(exec);
>+    double b = GET_C(bytecode.m_rhs).jsValue().toNumber(exec);
>     if (UNLIKELY(throwScope.exception()))
>         RETURN(JSValue());
>     RETURN(jsNumber(operationMathPow(a, b)));
>@@ -655,8 +655,8 @@ SLOW_PATH_DECL(slow_path_lshift)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpLshift>();
>-    JSValue left = GET_C(bytecode.lhs).jsValue();
>-    JSValue right = GET_C(bytecode.rhs).jsValue();
>+    JSValue left = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue right = GET_C(bytecode.m_rhs).jsValue();
>     auto leftNumeric = left.toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>     auto rightNumeric = right.toBigIntOrInt32(exec);
>@@ -679,8 +679,8 @@ SLOW_PATH_DECL(slow_path_rshift)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpRshift>();
>-    JSValue left = GET_C(bytecode.lhs).jsValue();
>-    JSValue right = GET_C(bytecode.rhs).jsValue();
>+    JSValue left = GET_C(bytecode.m_lhs).jsValue();
>+    JSValue right = GET_C(bytecode.m_rhs).jsValue();
>     auto leftNumeric = left.toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>     auto rightNumeric = right.toBigIntOrInt32(exec);
>@@ -703,10 +703,10 @@ SLOW_PATH_DECL(slow_path_urshift)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpUrshift>();
>-    uint32_t a = GET_C(bytecode.lhs).jsValue().toUInt32(exec);
>+    uint32_t a = GET_C(bytecode.m_lhs).jsValue().toUInt32(exec);
>     if (UNLIKELY(throwScope.exception()))
>         RETURN(JSValue());
>-    uint32_t b = GET_C(bytecode.rhs).jsValue().toUInt32(exec);
>+    uint32_t b = GET_C(bytecode.m_rhs).jsValue().toUInt32(exec);
>     RETURN(jsNumber(static_cast<int32_t>(a >> (b & 31))));
> }
> 
>@@ -714,7 +714,7 @@ SLOW_PATH_DECL(slow_path_unsigned)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpUnsigned>();
>-    uint32_t a = GET_C(bytecode.operand).jsValue().toUInt32(exec);
>+    uint32_t a = GET_C(bytecode.m_operand).jsValue().toUInt32(exec);
>     RETURN(jsNumber(a));
> }
> 
>@@ -722,7 +722,7 @@ SLOW_PATH_DECL(slow_path_bitnot)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpBitnot>();
>-    int32_t operand = GET_C(bytecode.operand).jsValue().toInt32(exec);
>+    int32_t operand = GET_C(bytecode.m_operand).jsValue().toInt32(exec);
>     CHECK_EXCEPTION();
>     RETURN_PROFILED(jsNumber(~operand));
> }
>@@ -731,9 +731,9 @@ SLOW_PATH_DECL(slow_path_bitand)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpBitand>();
>-    auto leftNumeric = GET_C(bytecode.lhs).jsValue().toBigIntOrInt32(exec);
>+    auto leftNumeric = GET_C(bytecode.m_lhs).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>-    auto rightNumeric = GET_C(bytecode.rhs).jsValue().toBigIntOrInt32(exec);
>+    auto rightNumeric = GET_C(bytecode.m_rhs).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>         if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>@@ -752,9 +752,9 @@ SLOW_PATH_DECL(slow_path_bitor)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpBitor>();
>-    auto leftNumeric = GET_C(bytecode.lhs).jsValue().toBigIntOrInt32(exec);
>+    auto leftNumeric = GET_C(bytecode.m_lhs).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>-    auto rightNumeric = GET_C(bytecode.rhs).jsValue().toBigIntOrInt32(exec);
>+    auto rightNumeric = GET_C(bytecode.m_rhs).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>         if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>@@ -773,9 +773,9 @@ SLOW_PATH_DECL(slow_path_bitxor)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpBitxor>();
>-    auto leftNumeric = GET_C(bytecode.lhs).jsValue().toBigIntOrInt32(exec);
>+    auto leftNumeric = GET_C(bytecode.m_lhs).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>-    auto rightNumeric = GET_C(bytecode.rhs).jsValue().toBigIntOrInt32(exec);
>+    auto rightNumeric = GET_C(bytecode.m_rhs).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>         if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>@@ -794,21 +794,21 @@ SLOW_PATH_DECL(slow_path_typeof)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpTypeof>();
>-    RETURN(jsTypeStringForValue(exec, GET_C(bytecode.value).jsValue()));
>+    RETURN(jsTypeStringForValue(exec, GET_C(bytecode.m_value).jsValue()));
> }
> 
> SLOW_PATH_DECL(slow_path_is_object_or_null)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpIsObjectOrNull>();
>-    RETURN(jsBoolean(jsIsObjectTypeOrNull(exec, GET_C(bytecode.operand).jsValue())));
>+    RETURN(jsBoolean(jsIsObjectTypeOrNull(exec, GET_C(bytecode.m_operand).jsValue())));
> }
> 
> SLOW_PATH_DECL(slow_path_is_function)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpIsFunction>();
>-    RETURN(jsBoolean(GET_C(bytecode.operand).jsValue().isFunction(vm)));
>+    RETURN(jsBoolean(GET_C(bytecode.m_operand).jsValue().isFunction(vm)));
> }
> 
> SLOW_PATH_DECL(slow_path_in_by_val)
>@@ -816,7 +816,7 @@ SLOW_PATH_DECL(slow_path_in_by_val)
>     BEGIN();
>     auto bytecode = pc->as<OpInByVal>();
>     auto& metadata = bytecode.metadata(exec);
>-    RETURN(jsBoolean(CommonSlowPaths::opInByVal(exec, GET_C(bytecode.base).jsValue(), GET_C(bytecode.property).jsValue(), &metadata.arrayProfile)));
>+    RETURN(jsBoolean(CommonSlowPaths::opInByVal(exec, GET_C(bytecode.m_base).jsValue(), GET_C(bytecode.m_property).jsValue(), &metadata.m_arrayProfile)));
> }
> 
> SLOW_PATH_DECL(slow_path_in_by_id)
>@@ -824,22 +824,22 @@ SLOW_PATH_DECL(slow_path_in_by_id)
>     BEGIN();
> 
>     auto bytecode = pc->as<OpInById>();
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>     if (!baseValue.isObject())
>         THROW(createInvalidInParameterError(exec, baseValue));
> 
>-    RETURN(jsBoolean(asObject(baseValue)->hasProperty(exec, exec->codeBlock()->identifier(bytecode.property))));
>+    RETURN(jsBoolean(asObject(baseValue)->hasProperty(exec, exec->codeBlock()->identifier(bytecode.m_property))));
> }
> 
> SLOW_PATH_DECL(slow_path_del_by_val)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpDelByVal>();
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>     JSObject* baseObject = baseValue.toObject(exec);
>     CHECK_EXCEPTION();
>     
>-    JSValue subscript = GET_C(bytecode.property).jsValue();
>+    JSValue subscript = GET_C(bytecode.m_property).jsValue();
>     
>     bool couldDelete;
>     
>@@ -863,14 +863,14 @@ SLOW_PATH_DECL(slow_path_strcat)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpStrcat>();
>-    RETURN(jsStringFromRegisterArray(exec, &GET(bytecode.src), bytecode.count));
>+    RETURN(jsStringFromRegisterArray(exec, &GET(bytecode.m_src), bytecode.m_count));
> }
> 
> SLOW_PATH_DECL(slow_path_to_primitive)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpToPrimitive>();
>-    RETURN(GET_C(bytecode.src).jsValue().toPrimitive(exec));
>+    RETURN(GET_C(bytecode.m_src).jsValue().toPrimitive(exec));
> }
> 
> SLOW_PATH_DECL(slow_path_enter)
>@@ -885,7 +885,7 @@ SLOW_PATH_DECL(slow_path_get_enumerable_
> {
>     BEGIN();
>     auto bytecode = pc->as<OpGetEnumerableLength>();
>-    JSValue enumeratorValue = GET(bytecode.base).jsValue();
>+    JSValue enumeratorValue = GET(bytecode.m_base).jsValue();
>     if (enumeratorValue.isUndefinedOrNull())
>         RETURN(jsNumber(0));
> 
>@@ -899,10 +899,10 @@ SLOW_PATH_DECL(slow_path_has_indexed_pro
>     BEGIN();
>     auto bytecode = pc->as<OpHasIndexedProperty>();
>     auto& metadata = bytecode.metadata(exec);
>-    JSObject* base = GET(bytecode.base).jsValue().toObject(exec);
>+    JSObject* base = GET(bytecode.m_base).jsValue().toObject(exec);
>     CHECK_EXCEPTION();
>-    JSValue property = GET(bytecode.property).jsValue();
>-    metadata.arrayProfile.observeStructure(base->structure(vm));
>+    JSValue property = GET(bytecode.m_property).jsValue();
>+    metadata.m_arrayProfile.observeStructure(base->structure(vm));
>     ASSERT(property.isUInt32());
>     RETURN(jsBoolean(base->hasPropertyGeneric(exec, property.asUInt32(), PropertySlot::InternalMethodType::GetOwnProperty)));
> }
>@@ -911,11 +911,11 @@ SLOW_PATH_DECL(slow_path_has_structure_p
> {
>     BEGIN();
>     auto bytecode = pc->as<OpHasStructureProperty>();
>-    JSObject* base = GET(bytecode.base).jsValue().toObject(exec);
>+    JSObject* base = GET(bytecode.m_base).jsValue().toObject(exec);
>     CHECK_EXCEPTION();
>-    JSValue property = GET(bytecode.property).jsValue();
>+    JSValue property = GET(bytecode.m_property).jsValue();
>     ASSERT(property.isString());
>-    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.enumerator).jsValue().asCell());
>+    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.m_enumerator).jsValue().asCell());
>     if (base->structure(vm)->id() == enumerator->cachedStructureID())
>         RETURN(jsBoolean(true));
>     JSString* string = asString(property);
>@@ -928,9 +928,9 @@ SLOW_PATH_DECL(slow_path_has_generic_pro
> {
>     BEGIN();
>     auto bytecode = pc->as<OpHasGenericProperty>();
>-    JSObject* base = GET(bytecode.base).jsValue().toObject(exec);
>+    JSObject* base = GET(bytecode.m_base).jsValue().toObject(exec);
>     CHECK_EXCEPTION();
>-    JSValue property = GET(bytecode.property).jsValue();
>+    JSValue property = GET(bytecode.m_property).jsValue();
>     ASSERT(property.isString());
>     JSString* string = asString(property);
>     auto propertyName = string->toIdentifier(exec);
>@@ -942,8 +942,8 @@ SLOW_PATH_DECL(slow_path_get_direct_pnam
> {
>     BEGIN();
>     auto bytecode = pc->as<OpGetDirectPname>();
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>-    JSValue property = GET(bytecode.property).jsValue();
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>+    JSValue property = GET(bytecode.m_property).jsValue();
>     ASSERT(property.isString());
>     JSString* string = asString(property);
>     auto propertyName = string->toIdentifier(exec);
>@@ -955,7 +955,7 @@ SLOW_PATH_DECL(slow_path_get_property_en
> {
>     BEGIN();
>     auto bytecode = pc->as<OpGetPropertyEnumerator>();
>-    JSValue baseValue = GET(bytecode.base).jsValue();
>+    JSValue baseValue = GET(bytecode.m_base).jsValue();
>     if (baseValue.isUndefinedOrNull())
>         RETURN(JSPropertyNameEnumerator::create(vm));
> 
>@@ -969,8 +969,8 @@ SLOW_PATH_DECL(slow_path_enumerator_stru
> {
>     BEGIN();
>     auto bytecode = pc->as<OpEnumeratorStructurePname>();
>-    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.enumerator).jsValue().asCell());
>-    uint32_t index = GET(bytecode.index).jsValue().asUInt32();
>+    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.m_enumerator).jsValue().asCell());
>+    uint32_t index = GET(bytecode.m_index).jsValue().asUInt32();
> 
>     JSString* propertyName = nullptr;
>     if (index < enumerator->endStructurePropertyIndex())
>@@ -982,8 +982,8 @@ SLOW_PATH_DECL(slow_path_enumerator_gene
> {
>     BEGIN();
>     auto bytecode = pc->as<OpEnumeratorGenericPname>();
>-    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.enumerator).jsValue().asCell());
>-    uint32_t index = GET(bytecode.index).jsValue().asUInt32();
>+    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.m_enumerator).jsValue().asCell());
>+    uint32_t index = GET(bytecode.m_index).jsValue().asUInt32();
> 
>     JSString* propertyName = nullptr;
>     if (enumerator->endStructurePropertyIndex() <= index && index < enumerator->endGenericPropertyIndex())
>@@ -995,7 +995,7 @@ SLOW_PATH_DECL(slow_path_to_index_string
> {
>     BEGIN();
>     auto bytecode = pc->as<OpToIndexString>();
>-    RETURN(jsString(exec, Identifier::from(exec, GET(bytecode.index).jsValue().asUInt32()).string()));
>+    RETURN(jsString(exec, Identifier::from(exec, GET(bytecode.m_index).jsValue().asUInt32()).string()));
> }
> 
> SLOW_PATH_DECL(slow_path_profile_type_clear_log)
>@@ -1016,10 +1016,10 @@ SLOW_PATH_DECL(slow_path_create_lexical_
> {
>     BEGIN();
>     auto bytecode = pc->as<OpCreateLexicalEnvironment>();
>-    int scopeReg = bytecode.scope.offset();
>+    int scopeReg = bytecode.m_scope.offset();
>     JSScope* currentScope = exec->uncheckedR(scopeReg).Register::scope();
>-    SymbolTable* symbolTable = jsCast<SymbolTable*>(GET_C(bytecode.symbolTable).jsValue());
>-    JSValue initialValue = GET_C(bytecode.initialValue).jsValue();
>+    SymbolTable* symbolTable = jsCast<SymbolTable*>(GET_C(bytecode.m_symbolTable).jsValue());
>+    JSValue initialValue = GET_C(bytecode.m_initialValue).jsValue();
>     ASSERT(initialValue == jsUndefined() || initialValue == jsTDZValue());
>     JSScope* newScope = JSLexicalEnvironment::create(vm, exec->lexicalGlobalObject(), currentScope, symbolTable, initialValue);
>     RETURN(newScope);
>@@ -1029,10 +1029,10 @@ SLOW_PATH_DECL(slow_path_push_with_scope
> {
>     BEGIN();
>     auto bytecode = pc->as<OpPushWithScope>();
>-    JSObject* newScope = GET_C(bytecode.newScope).jsValue().toObject(exec);
>+    JSObject* newScope = GET_C(bytecode.m_newScope).jsValue().toObject(exec);
>     CHECK_EXCEPTION();
> 
>-    int scopeReg = bytecode.currentScope.offset();
>+    int scopeReg = bytecode.m_currentScope.offset();
>     JSScope* currentScope = exec->uncheckedR(scopeReg).Register::scope();
>     RETURN(JSWithScope::create(vm, exec->lexicalGlobalObject(), currentScope, newScope));
> }
>@@ -1041,8 +1041,8 @@ SLOW_PATH_DECL(slow_path_resolve_scope_f
> {
>     BEGIN();
>     auto bytecode = pc->as<OpResolveScopeForHoistingFuncDeclInEval>();
>-    const Identifier& ident = exec->codeBlock()->identifier(bytecode.property);
>-    JSScope* scope = exec->uncheckedR(bytecode.scope.offset()).Register::scope();
>+    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_property);
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope.offset()).Register::scope();
>     JSValue resolvedScope = JSScope::resolveScopeForHoistingFuncDeclInEval(exec, scope, ident);
> 
>     CHECK_EXCEPTION();
>@@ -1055,13 +1055,13 @@ SLOW_PATH_DECL(slow_path_resolve_scope)
>     BEGIN();
>     auto bytecode = pc->as<OpResolveScope>();
>     auto& metadata = bytecode.metadata(exec);
>-    const Identifier& ident = exec->codeBlock()->identifier(bytecode.var);
>-    JSScope* scope = exec->uncheckedR(bytecode.scope.offset()).Register::scope();
>+    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_var);
>+    JSScope* scope = exec->uncheckedR(bytecode.m_scope.offset()).Register::scope();
>     JSObject* resolvedScope = JSScope::resolve(exec, scope, ident);
>     // Proxy can throw an error here, e.g. Proxy in with statement's @unscopables.
>     CHECK_EXCEPTION();
> 
>-    ResolveType resolveType = metadata.resolveType;
>+    ResolveType resolveType = metadata.m_resolveType;
> 
>     // ModuleVar does not keep the scope register value alive in DFG.
>     ASSERT(resolveType != ModuleVar);
>@@ -1074,20 +1074,20 @@ SLOW_PATH_DECL(slow_path_resolve_scope)
>             if (hasProperty) {
>                 ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
>                 if (resolveType == UnresolvedProperty)
>-                    metadata.resolveType = GlobalProperty;
>+                    metadata.m_resolveType = GlobalProperty;
>                 else
>-                    metadata.resolveType = GlobalPropertyWithVarInjectionChecks;
>+                    metadata.m_resolveType = GlobalPropertyWithVarInjectionChecks;
> 
>-                metadata.globalObject = globalObject;
>+                metadata.m_globalObject = globalObject;
>             }
>         } else if (resolvedScope->isGlobalLexicalEnvironment()) {
>             JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(resolvedScope);
>             ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
>             if (resolveType == UnresolvedProperty)
>-                metadata.resolveType = GlobalLexicalVar;
>+                metadata.m_resolveType = GlobalLexicalVar;
>             else
>-                metadata.resolveType = GlobalLexicalVarWithVarInjectionChecks;
>-            metadata.globalLexicalEnvironment = globalLexicalEnvironment;
>+                metadata.m_resolveType = GlobalLexicalVarWithVarInjectionChecks;
>+            metadata.m_globalLexicalEnvironment = globalLexicalEnvironment;
>         }
>     }
> 
>@@ -1098,10 +1098,10 @@ SLOW_PATH_DECL(slow_path_create_rest)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpCreateRest>();
>-    unsigned arraySize = GET_C(bytecode.arraySize).jsValue().asUInt32();
>+    unsigned arraySize = GET_C(bytecode.m_arraySize).jsValue().asUInt32();
>     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
>     Structure* structure = globalObject->restParameterStructure();
>-    unsigned numParamsToSkip = bytecode.numParametersToSkip;
>+    unsigned numParamsToSkip = bytecode.m_numParametersToSkip;
>     JSValue* argumentsToCopyRegion = exec->addressOfArgumentsStart() + numParamsToSkip;
>     RETURN(constructArray(exec, structure, argumentsToCopyRegion, arraySize));
> }
>@@ -1110,9 +1110,9 @@ SLOW_PATH_DECL(slow_path_get_by_id_with_
> {
>     BEGIN();
>     auto bytecode = pc->as<OpGetByIdWithThis>();
>-    const Identifier& ident = exec->codeBlock()->identifier(bytecode.property);
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>-    JSValue thisVal = GET_C(bytecode.thisValue).jsValue();
>+    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_property);
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>+    JSValue thisVal = GET_C(bytecode.m_thisValue).jsValue();
>     PropertySlot slot(thisVal, PropertySlot::PropertySlot::InternalMethodType::Get);
>     JSValue result = baseValue.get(exec, ident, slot);
>     RETURN_PROFILED(result);
>@@ -1123,9 +1123,9 @@ SLOW_PATH_DECL(slow_path_get_by_val_with
>     BEGIN();
> 
>     auto bytecode = pc->as<OpGetByValWithThis>();
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>-    JSValue thisValue = GET_C(bytecode.thisValue).jsValue();
>-    JSValue subscript = GET_C(bytecode.property).jsValue();
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>+    JSValue thisValue = GET_C(bytecode.m_thisValue).jsValue();
>+    JSValue subscript = GET_C(bytecode.m_property).jsValue();
> 
>     if (LIKELY(baseValue.isCell() && subscript.isString())) {
>         Structure& structure = *baseValue.asCell()->structure(vm);
>@@ -1158,10 +1158,10 @@ SLOW_PATH_DECL(slow_path_put_by_id_with_
>     BEGIN();
>     auto bytecode = pc->as<OpPutByIdWithThis>();
>     CodeBlock* codeBlock = exec->codeBlock();
>-    const Identifier& ident = codeBlock->identifier(bytecode.property);
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>-    JSValue thisVal = GET_C(bytecode.thisValue).jsValue();
>-    JSValue putValue = GET_C(bytecode.value).jsValue();
>+    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>+    JSValue thisVal = GET_C(bytecode.m_thisValue).jsValue();
>+    JSValue putValue = GET_C(bytecode.m_value).jsValue();
>     PutPropertySlot slot(thisVal, codeBlock->isStrictMode(), codeBlock->putByIdContext());
>     baseValue.putInline(exec, ident, putValue, slot);
>     END();
>@@ -1171,10 +1171,10 @@ SLOW_PATH_DECL(slow_path_put_by_val_with
> {
>     BEGIN();
>     auto bytecode = pc->as<OpPutByValWithThis>();
>-    JSValue baseValue = GET_C(bytecode.base).jsValue();
>-    JSValue thisValue = GET_C(bytecode.thisValue).jsValue();
>-    JSValue subscript = GET_C(bytecode.property).jsValue();
>-    JSValue value = GET_C(bytecode.value).jsValue();
>+    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
>+    JSValue thisValue = GET_C(bytecode.m_thisValue).jsValue();
>+    JSValue subscript = GET_C(bytecode.m_property).jsValue();
>+    JSValue value = GET_C(bytecode.m_value).jsValue();
>     
>     auto property = subscript.toPropertyKey(exec);
>     CHECK_EXCEPTION();
>@@ -1187,10 +1187,10 @@ SLOW_PATH_DECL(slow_path_define_data_pro
> {
>     BEGIN();
>     auto bytecode = pc->as<OpDefineDataProperty>();
>-    JSObject* base = asObject(GET_C(bytecode.base).jsValue());
>-    JSValue property = GET_C(bytecode.property).jsValue();
>-    JSValue value = GET_C(bytecode.value).jsValue();
>-    JSValue attributes = GET_C(bytecode.attributes).jsValue();
>+    JSObject* base = asObject(GET_C(bytecode.m_base).jsValue());
>+    JSValue property = GET_C(bytecode.m_property).jsValue();
>+    JSValue value = GET_C(bytecode.m_value).jsValue();
>+    JSValue attributes = GET_C(bytecode.m_attributes).jsValue();
>     ASSERT(attributes.isInt32());
> 
>     auto propertyName = property.toPropertyKey(exec);
>@@ -1205,11 +1205,11 @@ SLOW_PATH_DECL(slow_path_define_accessor
> {
>     BEGIN();
>     auto bytecode = pc->as<OpDefineAccessorProperty>();
>-    JSObject* base = asObject(GET_C(bytecode.base).jsValue());
>-    JSValue property = GET_C(bytecode.property).jsValue();
>-    JSValue getter = GET_C(bytecode.getter).jsValue();
>-    JSValue setter = GET_C(bytecode.setter).jsValue();
>-    JSValue attributes = GET_C(bytecode.attributes).jsValue();
>+    JSObject* base = asObject(GET_C(bytecode.m_base).jsValue());
>+    JSValue property = GET_C(bytecode.m_property).jsValue();
>+    JSValue getter = GET_C(bytecode.m_getter).jsValue();
>+    JSValue setter = GET_C(bytecode.m_setter).jsValue();
>+    JSValue attributes = GET_C(bytecode.m_attributes).jsValue();
>     ASSERT(attributes.isInt32());
> 
>     auto propertyName = property.toPropertyKey(exec);
>@@ -1224,10 +1224,10 @@ SLOW_PATH_DECL(slow_path_throw_static_er
> {
>     BEGIN();
>     auto bytecode = pc->as<OpThrowStaticError>();
>-    JSValue errorMessageValue = GET_C(bytecode.message).jsValue();
>+    JSValue errorMessageValue = GET_C(bytecode.m_message).jsValue();
>     RELEASE_ASSERT(errorMessageValue.isString());
>     String errorMessage = asString(errorMessageValue)->value(exec);
>-    ErrorType errorType = bytecode.errorType;
>+    ErrorType errorType = bytecode.m_errorType;
>     THROW(createError(exec, errorType, errorMessage));
> }
> 
>@@ -1235,11 +1235,11 @@ SLOW_PATH_DECL(slow_path_new_array_with_
> {
>     BEGIN();
>     auto bytecode = pc->as<OpNewArrayWithSpread>();
>-    int numItems = bytecode.argc;
>+    int numItems = bytecode.m_argc;
>     ASSERT(numItems >= 0);
>-    const BitVector& bitVector = exec->codeBlock()->unlinkedCodeBlock()->bitVector(bytecode.bitVector);
>+    const BitVector& bitVector = exec->codeBlock()->unlinkedCodeBlock()->bitVector(bytecode.m_bitVector);
> 
>-    JSValue* values = bitwise_cast<JSValue*>(&GET(bytecode.argv));
>+    JSValue* values = bitwise_cast<JSValue*>(&GET(bytecode.m_argv));
> 
>     Checked<unsigned, RecordOverflow> checkedArraySize = 0;
>     for (int i = 0; i < numItems; i++) {
>@@ -1289,9 +1289,9 @@ SLOW_PATH_DECL(slow_path_new_array_buffe
> {
>     BEGIN();
>     auto bytecode = pc->as<OpNewArrayBuffer>();
>-    ASSERT(exec->codeBlock()->isConstantRegisterIndex(bytecode.immutableButterfly.offset()));
>-    JSImmutableButterfly* immutableButterfly = bitwise_cast<JSImmutableButterfly*>(GET_C(bytecode.immutableButterfly).jsValue().asCell());
>-    auto& profile = bytecode.metadata(exec).arrayAllocationProfile;
>+    ASSERT(exec->codeBlock()->isConstantRegisterIndex(bytecode.m_immutableButterfly.offset()));
>+    JSImmutableButterfly* immutableButterfly = bitwise_cast<JSImmutableButterfly*>(GET_C(bytecode.m_immutableButterfly).jsValue().asCell());
>+    auto& profile = bytecode.metadata(exec).m_arrayAllocationProfile;
> 
>     IndexingType indexingMode = profile.selectIndexingType();
>     Structure* structure = exec->lexicalGlobalObject()->arrayStructureForIndexingTypeDuringAllocation(indexingMode);
>@@ -1309,7 +1309,7 @@ SLOW_PATH_DECL(slow_path_new_array_buffe
>         // 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(bytecode.immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
>+        codeBlock->constantRegister(bytecode.m_immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
>         WTF::storeStoreFence();
>     }
> 
>@@ -1324,7 +1324,7 @@ SLOW_PATH_DECL(slow_path_spread)
>     BEGIN();
> 
>     auto bytecode = pc->as<OpSpread>();
>-    JSValue iterable = GET_C(bytecode.argument).jsValue();
>+    JSValue iterable = GET_C(bytecode.m_argument).jsValue();
> 
>     if (iterable.isCell() && isJSArray(iterable.asCell())) {
>         JSArray* array = jsCast<JSArray*>(iterable);
>Index: Source/JavaScriptCore/runtime/CommonSlowPaths.h
>===================================================================
>--- Source/JavaScriptCore/runtime/CommonSlowPaths.h	(revision 239990)
>+++ Source/JavaScriptCore/runtime/CommonSlowPaths.h	(working copy)
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2011-2017 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
>@@ -123,7 +123,7 @@ inline void tryCachePutToScopeGlobal(
> {
>     // Covers implicit globals. Since they don't exist until they first execute, we didn't know how to cache them at compile time.
>     auto& metadata = bytecode.metadata(exec);
>-    ResolveType resolveType = metadata.getPutInfo.resolveType();
>+    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
>     if (resolveType != GlobalProperty && resolveType != GlobalPropertyWithVarInjectionChecks 
>         && resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
>         return;
>@@ -133,16 +133,16 @@ inline void tryCachePutToScopeGlobal(
>             ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalProperty : GlobalPropertyWithVarInjectionChecks;
>             resolveType = newResolveType;
>             ConcurrentJSLocker locker(codeBlock->m_lock);
>-            metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
>+            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
>         } else if (scope->isGlobalLexicalEnvironment()) {
>             JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
>             ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalLexicalVar : GlobalLexicalVarWithVarInjectionChecks;
>-            metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
>+            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
>             SymbolTableEntry entry = globalLexicalEnvironment->symbolTable()->get(ident.impl());
>             ASSERT(!entry.isNull());
>             ConcurrentJSLocker locker(codeBlock->m_lock);
>-            metadata.watchpointSet = entry.watchpointSet();
>-            metadata.operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
>+            metadata.m_watchpointSet = entry.watchpointSet();
>+            metadata.m_operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
>         }
>     }
>     
>@@ -165,8 +165,8 @@ inline void tryCachePutToScopeGlobal(
>         scope->structure(vm)->didCachePropertyReplacement(vm, slot.cachedOffset());
> 
>         ConcurrentJSLocker locker(codeBlock->m_lock);
>-        metadata.structure.set(vm, codeBlock, scope->structure(vm));
>-        metadata.operand = slot.cachedOffset();
>+        metadata.m_structure.set(vm, codeBlock, scope->structure(vm));
>+        metadata.m_operand = slot.cachedOffset();
>     }
> }
> 
>@@ -174,23 +174,23 @@ inline void tryCacheGetFromScopeGlobal(
>     ExecState* exec, VM& vm, OpGetFromScope& bytecode, JSObject* scope, PropertySlot& slot, const Identifier& ident)
> {
>     auto& metadata = bytecode.metadata(exec);
>-    ResolveType resolveType = metadata.getPutInfo.resolveType();
>+    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
> 
>     if (resolveType == UnresolvedProperty || resolveType == UnresolvedPropertyWithVarInjectionChecks) {
>         if (scope->isGlobalObject()) {
>             ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalProperty : GlobalPropertyWithVarInjectionChecks;
>             resolveType = newResolveType; // Allow below caching mechanism to kick in.
>             ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
>-            metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
>+            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
>         } else if (scope->isGlobalLexicalEnvironment()) {
>             JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
>             ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalLexicalVar : GlobalLexicalVarWithVarInjectionChecks;
>             SymbolTableEntry entry = globalLexicalEnvironment->symbolTable()->get(ident.impl());
>             ASSERT(!entry.isNull());
>             ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
>-            metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
>-            metadata.watchpointSet = entry.watchpointSet();
>-            metadata.operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
>+            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
>+            metadata.m_watchpointSet = entry.watchpointSet();
>+            metadata.m_operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
>         }
>     }
> 
>@@ -203,8 +203,8 @@ inline void tryCacheGetFromScopeGlobal(
>             Structure* structure = scope->structure(vm);
>             {
>                 ConcurrentJSLocker locker(codeBlock->m_lock);
>-                metadata.structure.set(vm, codeBlock, structure);
>-                metadata.operand = slot.cachedOffset();
>+                metadata.m_structure.set(vm, codeBlock, structure);
>+                metadata.m_operand = slot.cachedOffset();
>             }
>             structure->startWatchingPropertyForReplacements(vm, slot.cachedOffset());
>         }

Flags:

saam: review+
ews-watchlist: commit-queue-

Actions: View | Formatted Diff | Diff

Attachments on bug 193467: 359210 | 359230 | 359243