Attachment 341641 Details for Bug 186123 – Patch

[patch] Patch

bug-186123-20180530200204.patch (text/plain), 79.23 KB, created by Keith Miller on 2018-05-30 20:02:05 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Keith Miller

Created: 2018-05-30 20:02:05 PDT

Size: 79.23 KB

patch

obsolete

>Subversion Revision: 232326
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 2873e04e9224815d9beda548aa9d01486fd7c29d..04cfb8624253f1e266cb4d9ea3a0e5ac47672938 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,68 @@
>+2018-05-30  Keith Miller  <keith_miller@apple.com>
>+
>+        move should only emit the move if it's actually needed
>+        https://bugs.webkit.org/show_bug.cgi?id=186123
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch relpaces move with moveToDestinationIfNeeded. This
>+        will prevent us from emiting moves to the same location. The old
>+        move, has been renamed to emitMove and made private.
>+
>+        * bytecompiler/BytecodeGenerator.cpp:
>+        (JSC::BytecodeGenerator::BytecodeGenerator):
>+        (JSC::BytecodeGenerator::emitMove):
>+        (JSC::BytecodeGenerator::emitGetGlobalPrivate):
>+        (JSC::BytecodeGenerator::emitGetAsyncIterator):
>+        (JSC::BytecodeGenerator::move): Deleted.
>+        * bytecompiler/BytecodeGenerator.h:
>+        (JSC::BytecodeGenerator::move):
>+        (JSC::BytecodeGenerator::moveToDestinationIfNeeded): Deleted.
>+        * bytecompiler/NodesCodegen.cpp:
>+        (JSC::ThisNode::emitBytecode):
>+        (JSC::SuperNode::emitBytecode):
>+        (JSC::NewTargetNode::emitBytecode):
>+        (JSC::ResolveNode::emitBytecode):
>+        (JSC::TaggedTemplateNode::emitBytecode):
>+        (JSC::ArrayNode::emitBytecode):
>+        (JSC::ObjectLiteralNode::emitBytecode):
>+        (JSC::EvalFunctionCallNode::emitBytecode):
>+        (JSC::FunctionCallResolveNode::emitBytecode):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_putByIdDirect):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_putByIdDirectPrivate):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_putByValDirect):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_toNumber):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_toString):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_toObject):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_idWithProfile):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isJSArray):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isProxyObject):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isRegExpObject):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isObject):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isDerivedArray):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isMap):
>+        (JSC::BytecodeIntrinsicNode::emit_intrinsic_isSet):
>+        (JSC::CallFunctionCallDotNode::emitBytecode):
>+        (JSC::ApplyFunctionCallDotNode::emitBytecode):
>+        (JSC::emitPostIncOrDec):
>+        (JSC::PostfixNode::emitBracket):
>+        (JSC::PostfixNode::emitDot):
>+        (JSC::PrefixNode::emitResolve):
>+        (JSC::PrefixNode::emitBracket):
>+        (JSC::PrefixNode::emitDot):
>+        (JSC::LogicalOpNode::emitBytecode):
>+        (JSC::ReadModifyResolveNode::emitBytecode):
>+        (JSC::AssignResolveNode::emitBytecode):
>+        (JSC::AssignDotNode::emitBytecode):
>+        (JSC::AssignBracketNode::emitBytecode):
>+        (JSC::FunctionNode::emitBytecode):
>+        (JSC::ClassExprNode::emitBytecode):
>+        (JSC::DestructuringAssignmentNode::emitBytecode):
>+        (JSC::ArrayPatternNode::emitDirectBinding):
>+        (JSC::ObjectPatternNode::bindValue const):
>+        (JSC::AssignmentElementNode::bindValue const):
>+        (JSC::ObjectSpreadExpressionNode::emitBytecode):
>+
> 2018-05-30  Daniel Bates  <dabates@apple.com>
> 
>         Web Inspector: Annotate Same-Site cookies
>diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>index 651759f24ef331fe44f18cbbb06289b301e17612..eb7da976afb118bc086c842fd6833bc4b484550d 100644
>--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>@@ -138,7 +138,7 @@ ParserError BytecodeGenerator::generate()
>                     // Therefore, we're guaranteed to have this resolve to a top level variable.
>                     RefPtr<RegisterID> tolLevelObjectScope = emitResolveScope(nullptr, Variable(metadata->ident()));
>                     tolLevelScope = newBlockScopeVariable();
>-                    emitMove(tolLevelScope.get(), tolLevelObjectScope.get());
>+                    move(tolLevelScope.get(), tolLevelObjectScope.get());
>                 }
>                 emitPutToScope(tolLevelScope.get(), Variable(metadata->ident()), temp.get(), ThrowIfNotFound, InitializationMode::NotInitialization);
>             } else
>@@ -590,7 +590,7 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>         // https://bugs.webkit.org/show_bug.cgi?id=151586
>         emitToThis();
> 
>-        emitMove(m_generatorRegister, &m_calleeRegister);
>+        move(m_generatorRegister, &m_calleeRegister);
>         emitCreateThis(m_generatorRegister);
>         break;
>     }
>@@ -614,14 +614,14 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>         // let promiseCapability be @newPromiseCapability(@Promise)
>         auto varNewPromiseCapability = variable(propertyNames().builtinNames().newPromiseCapabilityPrivateName());
>         RefPtr<RegisterID> scope = newTemporary();
>-        moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), varNewPromiseCapability));
>+        move(scope.get(), emitResolveScope(scope.get(), varNewPromiseCapability));
>         RefPtr<RegisterID> newPromiseCapability = emitGetFromScope(newTemporary(), scope.get(), varNewPromiseCapability, ThrowIfNotFound);
> 
>         CallArguments args(*this, nullptr, 1);
>         emitLoad(args.thisRegister(), jsUndefined());
> 
>         auto varPromiseConstructor = variable(propertyNames().builtinNames().PromisePrivateName());
>-        moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), varPromiseConstructor));
>+        move(scope.get(), emitResolveScope(scope.get(), varPromiseConstructor));
>         emitGetFromScope(args.argumentRegister(0), scope.get(), varPromiseConstructor, ThrowIfNotFound);
> 
>         // JSTextPosition(int _line, int _offset, int _lineStartOffset)
>@@ -642,9 +642,9 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>     default: {
>         if (SourceParseMode::ArrowFunctionMode != parseMode) {
>             if (isConstructor()) {
>-                emitMove(m_newTargetRegister, &m_thisRegister);
>+                move(m_newTargetRegister, &m_thisRegister);
>                 if (constructorKind() == ConstructorKind::Extends) {
>-                    emitMoveEmptyValue(&m_thisRegister);
>+                    moveEmptyValue(&m_thisRegister);
>                 } else
>                     emitCreateThis(&m_thisRegister);
>             } else if (constructorKind() != ConstructorKind::None)
>@@ -723,7 +723,7 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
> 
>         CallArguments args(*this, nullptr, 1);
>         emitLoad(args.thisRegister(), jsUndefined());
>-        emitMove(args.argumentRegister(0), thrownValue.get());
>+        move(args.argumentRegister(0), thrownValue.get());
> 
>         JSTextPosition divot(functionNode->firstLine(), functionNode->startOffset(), functionNode->lineStartOffset());
> 
>@@ -750,7 +750,7 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>         ASSERT(m_lexicalEnvironmentRegister);
>         m_generatorFrameSymbolTable.set(*m_vm, functionSymbolTable);
>         m_generatorFrameSymbolTableIndex = symbolTableConstantIndex;
>-        emitMove(generatorFrameRegister(), m_lexicalEnvironmentRegister);
>+        move(generatorFrameRegister(), m_lexicalEnvironmentRegister);
>         emitPutById(generatorRegister(), propertyNames().builtinNames().generatorFramePrivateName(), generatorFrameRegister());
>     }
> 
>@@ -1011,7 +1011,7 @@ void BytecodeGenerator::initializeDefaultParameterValuesAndSetupFunctionScopeSta
>             if (parameter.first->isRestParameter())
>                 continue;
>             if ((i + 1) < m_parameters.size())
>-                emitMove(temp.get(), &m_parameters[i + 1]);
>+                move(temp.get(), &m_parameters[i + 1]);
>             else
>                 emitGetArgument(temp.get(), i);
>             if (parameter.second) {
>@@ -1632,7 +1632,7 @@ RegisterID* BytecodeGenerator::addConstantValue(JSValue v, SourceCodeRepresentat
>     return &m_constantPoolRegisters[index];
> }
> 
>-RegisterID* BytecodeGenerator::emitMoveLinkTimeConstant(RegisterID* dst, LinkTimeConstant type)
>+RegisterID* BytecodeGenerator::moveLinkTimeConstant(RegisterID* dst, LinkTimeConstant type)
> {
>     unsigned constantIndex = static_cast<unsigned>(type);
>     if (!m_linkTimeConstantRegisters[constantIndex]) {
>@@ -1656,7 +1656,7 @@ unsigned BytecodeGenerator::addRegExp(RegExp* r)
>     return m_codeBlock->addRegExp(r);
> }
> 
>-RegisterID* BytecodeGenerator::emitMoveEmptyValue(RegisterID* dst)
>+RegisterID* BytecodeGenerator::moveEmptyValue(RegisterID* dst)
> {
>     RefPtr<RegisterID> emptyValue = addConstantEmptyValue();
> 
>@@ -1953,7 +1953,7 @@ RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue v, SourceCodeRe
> {
>     RegisterID* constantID = addConstantValue(v, sourceCodeRepresentation);
>     if (dst)
>-        return emitMove(dst, constantID);
>+        return move(dst, constantID);
>     return constantID;
> }
> 
>@@ -1971,7 +1971,7 @@ RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, IdentifierSet& set)
>     RegisterID* m_setRegister = &m_constantPoolRegisters[index];
>     
>     if (dst)
>-        return emitMove(dst, m_setRegister);
>+        return move(dst, m_setRegister);
>     
>     return m_setRegister;
> }
>@@ -1985,7 +1985,7 @@ RegisterID* BytecodeGenerator::emitLoadGlobalObject(RegisterID* dst)
>         m_codeBlock->setGlobalObjectRegister(VirtualRegister(index));
>     }
>     if (dst)
>-        emitMove(dst, m_globalObjectRegister);
>+        move(dst, m_globalObjectRegister);
>     return m_globalObjectRegister;
> }
> 
>@@ -2052,7 +2052,7 @@ void BytecodeGenerator::emitPrefillStackTDZVariables(const VariableEnvironment&
>             continue;
> 
>         ASSERT(offset.isStack());
>-        emitMoveEmptyValue(&registerFor(offset.stackOffset()));
>+        moveEmptyValue(&registerFor(offset.stackOffset()));
>     }
> }
> 
>@@ -2127,7 +2127,7 @@ void BytecodeGenerator::pushLexicalScopeInternal(VariableEnvironment& environmen
>         instructions().append(constantSymbolTable->index());
>         instructions().append(addConstantValue(tdzRequirement == TDZRequirement::UnderTDZ ? jsTDZValue() : jsUndefined())->index());
> 
>-        emitMove(scopeRegister(), newScope);
>+        move(scopeRegister(), newScope);
> 
>         pushLocalControlFlowScope();
>     }
>@@ -2355,7 +2355,7 @@ void BytecodeGenerator::prepareLexicalScopeForNextForLoopIteration(VariableEnvir
>     // the assumption that the scope's register index is constant even
>     // though the value in that register will change on each loop iteration.
>     RefPtr<RegisterID> parentScope = emitGetParentScope(newTemporary(), loopScope);
>-    emitMove(scopeRegister(), parentScope.get());
>+    move(scopeRegister(), parentScope.get());
> 
>     emitOpcode(op_create_lexical_environment);
>     instructions().append(loopScope->index());
>@@ -2363,7 +2363,7 @@ void BytecodeGenerator::prepareLexicalScopeForNextForLoopIteration(VariableEnvir
>     instructions().append(loopSymbolTable->index());
>     instructions().append(addConstantValue(jsTDZValue())->index());
> 
>-    emitMove(scopeRegister(), loopScope);
>+    move(scopeRegister(), loopScope);
> 
>     {
>         for (auto pair : activationValuesToCopyOver) {
>@@ -2572,7 +2572,7 @@ RegisterID* BytecodeGenerator::emitGetFromScope(RegisterID* dst, RegisterID* sco
> {
>     switch (variable.offset().kind()) {
>     case VarKind::Stack:
>-        return emitMove(dst, variable.local());
>+        return move(dst, variable.local());
>         
>     case VarKind::DirectArgument: {
>         UnlinkedValueProfile profile = emitProfiledOpcode(op_get_from_arguments);
>@@ -2606,7 +2606,7 @@ RegisterID* BytecodeGenerator::emitPutToScope(RegisterID* scope, const Variable&
> {
>     switch (variable.offset().kind()) {
>     case VarKind::Stack:
>-        emitMove(variable.local(), value);
>+        move(variable.local(), value);
>         return value;
>         
>     case VarKind::DirectArgument:
>@@ -3511,13 +3511,13 @@ RegisterID* BytecodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, Regi
>                     instructions().append(argumentRegister.get()->index());
>                     instructions().append(argumentRegister.get()->index());
> 
>-                    RefPtr<RegisterID> thisRegister = emitMove(newTemporary(), callArguments.thisRegister());
>+                    RefPtr<RegisterID> thisRegister = move(newTemporary(), callArguments.thisRegister());
>                     return emitCallVarargs(opcodeID == op_tail_call ? op_tail_call_varargs : op_call_varargs, dst, func, callArguments.thisRegister(), argumentRegister.get(), newTemporary(), 0, divot, divotStart, divotEnd, debuggableCall);
>                 }
>             }
>             RefPtr<RegisterID> argumentRegister;
>             argumentRegister = expression->emitBytecode(*this, callArguments.argumentRegister(0));
>-            RefPtr<RegisterID> thisRegister = emitMove(newTemporary(), callArguments.thisRegister());
>+            RefPtr<RegisterID> thisRegister = move(newTemporary(), callArguments.thisRegister());
>             return emitCallVarargs(opcodeID == op_tail_call ? op_tail_call_varargs : op_call_varargs, dst, func, callArguments.thisRegister(), argumentRegister.get(), newTemporary(), 0, divot, divotStart, divotEnd, debuggableCall);
>         }
>         for (; n; n = n->m_next)
>@@ -3652,7 +3652,7 @@ void BytecodeGenerator::emitCallDefineProperty(RegisterID* newObj, RegisterID* p
>     if (attributes.hasGet() || attributes.hasSet()) {
>         RefPtr<RegisterID> throwTypeErrorFunction;
>         if (!attributes.hasGet() || !attributes.hasSet())
>-            throwTypeErrorFunction = emitMoveLinkTimeConstant(nullptr, LinkTimeConstant::ThrowTypeErrorFunction);
>+            throwTypeErrorFunction = moveLinkTimeConstant(nullptr, LinkTimeConstant::ThrowTypeErrorFunction);
> 
>         RefPtr<RegisterID> getter;
>         if (attributes.hasGet())
>@@ -3737,14 +3737,14 @@ RegisterID* BytecodeGenerator::emitConstruct(RegisterID* dst, RegisterID* func,
>                     instructions().append(argumentRegister.get()->index());
>                     instructions().append(argumentRegister.get()->index());
> 
>-                    emitMove(callArguments.thisRegister(), lazyThis);
>-                    RefPtr<RegisterID> thisRegister = emitMove(newTemporary(), callArguments.thisRegister());
>+                    move(callArguments.thisRegister(), lazyThis);
>+                    RefPtr<RegisterID> thisRegister = move(newTemporary(), callArguments.thisRegister());
>                     return emitConstructVarargs(dst, func, callArguments.thisRegister(), argumentRegister.get(), newTemporary(), 0, divot, divotStart, divotEnd, DebuggableCall::No);
>                 }
>             }
>             RefPtr<RegisterID> argumentRegister;
>             argumentRegister = expression->emitBytecode(*this, callArguments.argumentRegister(0));
>-            emitMove(callArguments.thisRegister(), lazyThis);
>+            move(callArguments.thisRegister(), lazyThis);
>             return emitConstructVarargs(dst, func, callArguments.thisRegister(), argumentRegister.get(), newTemporary(), 0, divot, divotStart, divotEnd, DebuggableCall::No);
>         }
>         
>@@ -3752,7 +3752,7 @@ RegisterID* BytecodeGenerator::emitConstruct(RegisterID* dst, RegisterID* func,
>             emitNode(callArguments.argumentRegister(argument++), n);
>     }
>     
>-    emitMove(callArguments.thisRegister(), lazyThis);
>+    move(callArguments.thisRegister(), lazyThis);
>     
>     // Reserve space for call frame.
>     Vector<RefPtr<RegisterID>, CallFrame::headerSizeInRegisters, UnsafeVectorOverflow> callFrame;
>@@ -3815,7 +3815,7 @@ RegisterID* BytecodeGenerator::emitPushWithScope(RegisterID* objectScope)
>     instructions().append(scopeRegister()->index());
>     instructions().append(objectScope->index());
> 
>-    emitMove(scopeRegister(), newScope);
>+    move(scopeRegister(), newScope);
>     m_lexicalScopeStack.append({ nullptr, newScope, true, 0 });
> 
>     return newScope;
>@@ -3832,7 +3832,7 @@ RegisterID* BytecodeGenerator::emitGetParentScope(RegisterID* dst, RegisterID* s
> void BytecodeGenerator::emitPopScope(RegisterID* dst, RegisterID* scope)
> {
>     RefPtr<RegisterID> parentScope = emitGetParentScope(newTemporary(), scope);
>-    emitMove(dst, parentScope.get());
>+    move(dst, parentScope.get());
> }
> 
> void BytecodeGenerator::emitPopWithScope()
>@@ -3979,7 +3979,7 @@ void BytecodeGenerator::allocateAndEmitScope()
>     m_codeBlock->setScopeRegister(scopeRegister()->virtualRegister());
>     emitGetScope();
>     m_topMostScope = addVar();
>-    emitMove(m_topMostScope, scopeRegister());
>+    move(m_topMostScope, scopeRegister());
> }
> 
> TryData* BytecodeGenerator::pushTry(Label& start, Label& handlerLabel, HandlerType handlerType)
>@@ -4024,14 +4024,14 @@ void BytecodeGenerator::restoreScopeRegister(int lexicalScopeIndex)
>         int endIndex = lexicalScopeIndex + 1;
>         for (size_t i = endIndex; i--; ) {
>             if (m_lexicalScopeStack[i].m_scope) {
>-                emitMove(scopeRegister(), m_lexicalScopeStack[i].m_scope);
>+                move(scopeRegister(), m_lexicalScopeStack[i].m_scope);
>                 return;
>             }
>         }
>     }
>     // Note that if we don't find a local scope in the current function/program,
>     // we must grab the outer-most scope of this bytecode generation.
>-    emitMove(scopeRegister(), m_topMostScope);
>+    move(scopeRegister(), m_topMostScope);
> }
> 
> void BytecodeGenerator::restoreScopeRegister()
>@@ -4344,11 +4344,11 @@ void BytecodeGenerator::emitEnumeration(ThrowableExpressionData* node, Expressio
> 
>             emitCatch(completionValueRegister(), unused, tryData);
>             emitSetCompletionType(CompletionType::Throw);
>-            emitMove(finallyExceptionRegister.get(), completionValueRegister());
>+            move(finallyExceptionRegister.get(), completionValueRegister());
>             emitJump(finallyBodyLabel.get());
> 
>             emitLabel(finallyLabel.get());
>-            emitMoveEmptyValue(finallyExceptionRegister.get());
>+            moveEmptyValue(finallyExceptionRegister.get());
> 
>             emitLabel(finallyBodyLabel.get());
>             restoreScopeRegister();
>@@ -4363,7 +4363,7 @@ void BytecodeGenerator::emitEnumeration(ThrowableExpressionData* node, Expressio
>             TryData* returnCallTryData = pushTry(returnCallTryStart.get(), catchLabel.get(), HandlerType::SynthesizedCatch);
> 
>             CallArguments returnArguments(*this, nullptr);
>-            emitMove(returnArguments.thisRegister(), iterator.get());
>+            move(returnArguments.thisRegister(), iterator.get());
>             emitCall(value.get(), returnMethod.get(), NoExpectedFunction, returnArguments, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
> 
>             if (isForAwait)
>@@ -4393,7 +4393,7 @@ void BytecodeGenerator::emitEnumeration(ThrowableExpressionData* node, Expressio
> 
>                 Ref<Label> throwLabel = newLabel();
>                 emitJumpIfTrue(emitIsEmpty(newTemporary(), finallyExceptionRegister.get()), throwLabel.get());
>-                emitMove(exceptionRegister.get(), finallyExceptionRegister.get());
>+                move(exceptionRegister.get(), finallyExceptionRegister.get());
> 
>                 emitLabel(throwLabel.get());
>                 emitThrow(exceptionRegister.get());
>@@ -4447,7 +4447,7 @@ RegisterID* BytecodeGenerator::emitGetTemplateObject(RegisterID* dst, TaggedTemp
>     RefPtr<RegisterID> constant = addTemplateObjectConstant(TemplateObjectDescriptor::create(WTFMove(rawStrings), WTFMove(cookedStrings)));
>     if (!dst)
>         return constant.get();
>-    return emitMove(dst, constant.get());
>+    return move(dst, constant.get());
> }
> 
> RegisterID* BytecodeGenerator::emitGetGlobalPrivate(RegisterID* dst, const Identifier& property)
>@@ -4455,10 +4455,10 @@ RegisterID* BytecodeGenerator::emitGetGlobalPrivate(RegisterID* dst, const Ident
>     dst = tempDestination(dst);
>     Variable var = variable(property);
>     if (RegisterID* local = var.local())
>-        return emitMove(dst, local);
>+        return move(dst, local);
> 
>     RefPtr<RegisterID> scope = newTemporary();
>-    moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), var));
>+    move(scope.get(), emitResolveScope(scope.get(), var));
>     return emitGetFromScope(dst, scope.get(), var, ThrowIfNotFound);
> }
> 
>@@ -4579,7 +4579,7 @@ RegisterID* BytecodeGenerator::emitIteratorNext(RegisterID* dst, RegisterID* nex
> {
>     {
>         CallArguments nextArguments(*this, nullptr);
>-        emitMove(nextArguments.thisRegister(), iterator);
>+        move(nextArguments.thisRegister(), iterator);
>         emitCall(dst, nextMethod, NoExpectedFunction, nextArguments, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
> 
>         if (doEmitAwait == EmitAwait::Yes)
>@@ -4598,8 +4598,8 @@ RegisterID* BytecodeGenerator::emitIteratorNextWithValue(RegisterID* dst, Regist
> {
>     {
>         CallArguments nextArguments(*this, nullptr, 1);
>-        emitMove(nextArguments.thisRegister(), iterator);
>-        emitMove(nextArguments.argumentRegister(0), value);
>+        move(nextArguments.thisRegister(), iterator);
>+        move(nextArguments.argumentRegister(0), value);
>         emitCall(dst, nextMethod, NoExpectedFunction, nextArguments, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
>     }
> 
>@@ -4614,7 +4614,7 @@ void BytecodeGenerator::emitIteratorClose(RegisterID* iterator, const ThrowableE
> 
>     RefPtr<RegisterID> value = newTemporary();
>     CallArguments returnArguments(*this, nullptr);
>-    emitMove(returnArguments.thisRegister(), iterator);
>+    move(returnArguments.thisRegister(), iterator);
>     emitCall(value.get(), returnMethod.get(), NoExpectedFunction, returnArguments, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
> 
>     if (doEmitAwait == EmitAwait::Yes)
>@@ -4869,7 +4869,7 @@ RegisterID* BytecodeGenerator::emitYield(RegisterID* argument, JSAsyncGeneratorF
> RegisterID* BytecodeGenerator::emitCallIterator(RegisterID* iterator, RegisterID* argument, ThrowableExpressionData* node)
> {
>     CallArguments args(*this, nullptr);
>-    emitMove(args.thisRegister(), argument);
>+    move(args.thisRegister(), argument);
>     emitCall(iterator, iterator, NoExpectedFunction, args, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
> 
>     return iterator;
>@@ -4878,7 +4878,7 @@ RegisterID* BytecodeGenerator::emitCallIterator(RegisterID* iterator, RegisterID
> void BytecodeGenerator::emitAwait(RegisterID* value)
> {
>     emitYield(value, JSAsyncGeneratorFunction::AsyncGeneratorSuspendReason::Await);
>-    emitMove(value, generatorValueRegister());
>+    move(value, generatorValueRegister());
> }
> 
> RegisterID* BytecodeGenerator::emitGetIterator(RegisterID* argument, ThrowableExpressionData* node)
>@@ -4902,20 +4902,20 @@ RegisterID* BytecodeGenerator::emitGetAsyncIterator(RegisterID* argument, Throwa
>     emitLabel(asyncIteratorNotFound.get());
> 
>     RefPtr<RegisterID> commonIterator = emitGetIterator(argument, node);
>-    emitMove(iterator.get(), commonIterator.get());
>+    move(iterator.get(), commonIterator.get());
> 
>     RefPtr<RegisterID> nextMethod = emitGetById(newTemporary(), iterator.get(), propertyNames().next);
> 
>     auto varCreateAsyncFromSyncIterator = variable(propertyNames().builtinNames().createAsyncFromSyncIteratorPrivateName());
>     RefPtr<RegisterID> scope = newTemporary();
>-    moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), varCreateAsyncFromSyncIterator));
>+    move(scope.get(), emitResolveScope(scope.get(), varCreateAsyncFromSyncIterator));
>     RefPtr<RegisterID> createAsyncFromSyncIterator = emitGetFromScope(newTemporary(), scope.get(), varCreateAsyncFromSyncIterator, ThrowIfNotFound);
> 
>     CallArguments args(*this, nullptr, 2);
>     emitLoad(args.thisRegister(), jsUndefined());
> 
>-    emitMove(args.argumentRegister(0), iterator.get());
>-    emitMove(args.argumentRegister(1), nextMethod.get());
>+    move(args.argumentRegister(0), iterator.get());
>+    move(args.argumentRegister(1), nextMethod.get());
> 
>     JSTextPosition divot(m_scopeNode->firstLine(), m_scopeNode->startOffset(), m_scopeNode->lineStartOffset());
>     emitCall(iterator.get(), createAsyncFromSyncIterator.get(), NoExpectedFunction, args, divot, divot, divot, DebuggableCall::No);
>@@ -4977,8 +4977,8 @@ RegisterID* BytecodeGenerator::emitDelegateYield(RegisterID* argument, Throwable
> 
>                     emitLabel(throwMethodFound.get());
>                     CallArguments throwArguments(*this, nullptr, 1);
>-                    emitMove(throwArguments.thisRegister(), iterator.get());
>-                    emitMove(throwArguments.argumentRegister(0), generatorValueRegister());
>+                    move(throwArguments.thisRegister(), iterator.get());
>+                    move(throwArguments.argumentRegister(0), generatorValueRegister());
>                     emitCall(value.get(), throwMethod.get(), NoExpectedFunction, throwArguments, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
> 
>                     emitJump(branchOnResult.get());
>@@ -4991,15 +4991,15 @@ RegisterID* BytecodeGenerator::emitDelegateYield(RegisterID* argument, Throwable
>                     RefPtr<RegisterID> returnMethod = emitGetById(newTemporary(), iterator.get(), propertyNames().returnKeyword);
>                     emitJumpIfFalse(emitIsUndefined(newTemporary(), returnMethod.get()), returnMethodFound.get());
> 
>-                    emitMove(value.get(), generatorValueRegister());
>+                    move(value.get(), generatorValueRegister());
> 
>                     Ref<Label> returnSequence = newLabel();
>                     emitJump(returnSequence.get());
> 
>                     emitLabel(returnMethodFound.get());
>                     CallArguments returnArguments(*this, nullptr, 1);
>-                    emitMove(returnArguments.thisRegister(), iterator.get());
>-                    emitMove(returnArguments.argumentRegister(0), generatorValueRegister());
>+                    move(returnArguments.thisRegister(), iterator.get());
>+                    move(returnArguments.argumentRegister(0), generatorValueRegister());
>                     emitCall(value.get(), returnMethod.get(), NoExpectedFunction, returnArguments, node->divot(), node->divotStart(), node->divotEnd(), DebuggableCall::No);
> 
>                     if (parseMode() == SourceParseMode::AsyncGeneratorBodyMode)
>@@ -5028,7 +5028,7 @@ RegisterID* BytecodeGenerator::emitDelegateYield(RegisterID* argument, Throwable
> 
>                 // Normal.
>                 emitLabel(normalLabel.get());
>-                emitMove(value.get(), generatorValueRegister());
>+                move(value.get(), generatorValueRegister());
>             }
> 
>             emitLabel(nextElement.get());
>@@ -5177,7 +5177,7 @@ bool BytecodeGenerator::allocateCompletionRecordRegisters()
>     m_completionValueRegister = newTemporary();
> 
>     emitSetCompletionType(CompletionType::Normal);
>-    emitMoveEmptyValue(m_completionValueRegister.get());
>+    moveEmptyValue(m_completionValueRegister.get());
>     return true;
> }
> 
>diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>index a9bcb45aab3e5f6e6ebf1d7e68e8c79c3ea5d181..f57a47c324b76f29925f3acd376b238de415aafd 100644
>--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>@@ -467,9 +467,9 @@ namespace JSC {
>         }
> 
>         // Moves src to dst if dst is not null and is different from src, otherwise just returns src.
>-        RegisterID* moveToDestinationIfNeeded(RegisterID* dst, RegisterID* src)
>+        RegisterID* move(RegisterID* dst, RegisterID* src)
>         {
>-            return dst == ignoredResult() ? 0 : (dst && dst != src) ? emitMove(dst, src) : src;
>+            return dst == ignoredResult() ? nullptr : (dst && dst != src) ? emitMove(dst, src) : src;
>         }
> 
>         Ref<LabelScope> newLabelScope(LabelScope::Type, const Identifier* = 0);
>@@ -682,9 +682,8 @@ namespace JSC {
> 
>         void emitSetFunctionNameIfNeeded(ExpressionNode* valueNode, RegisterID* value, RegisterID* name);
> 
>-        RegisterID* emitMoveLinkTimeConstant(RegisterID* dst, LinkTimeConstant);
>-        RegisterID* emitMoveEmptyValue(RegisterID* dst);
>-        RegisterID* emitMove(RegisterID* dst, RegisterID* src);
>+        RegisterID* moveLinkTimeConstant(RegisterID* dst, LinkTimeConstant);
>+        RegisterID* moveEmptyValue(RegisterID* dst);
> 
>         RegisterID* emitToNumber(RegisterID* dst, RegisterID* src) { return emitUnaryOpProfiled(op_to_number, dst, src); }
>         RegisterID* emitToString(RegisterID* dst, RegisterID* src) { return emitUnaryOp(op_to_string, dst, src); }
>@@ -912,7 +911,7 @@ namespace JSC {
>         }
>         void emitSetCompletionValue(RegisterID* reg)
>         {
>-            emitMove(completionValueRegister(), reg);
>+            move(completionValueRegister(), reg);
>         }
> 
>         void emitJumpIf(OpcodeID compareOpcode, RegisterID* completionTypeRegister, CompletionType, Label& jumpTarget);
>@@ -992,6 +991,8 @@ namespace JSC {
> 
>         void emitToThis();
> 
>+        RegisterID* emitMove(RegisterID* dst, RegisterID* src);
>+
>     public:
>         bool isSuperUsedInInnerArrowFunction();
>         bool isSuperCallUsedInInnerArrowFunction();
>diff --git a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
>index 84e2548bcbef6eb837df673b179f8252dda9ae1e..21e1499b29e40fca8cc20e7632abf2c5d16c2560 100644
>--- a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
>+++ b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
>@@ -160,7 +160,7 @@ RegisterID* ThisNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst
>     if (dst == generator.ignoredResult())
>         return 0;
> 
>-    RegisterID* result = generator.moveToDestinationIfNeeded(dst, generator.thisRegister());
>+    RegisterID* result = generator.move(dst, generator.thisRegister());
>     static const unsigned thisLength = 4;
>     generator.emitProfileType(generator.thisRegister(), position(), JSTextPosition(-1, position().offset + thisLength, -1));
>     return result;
>@@ -199,7 +199,7 @@ static RegisterID* emitGetSuperFunctionForConstruct(BytecodeGenerator& generator
> RegisterID* SuperNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
> {
>     RegisterID* result = emitSuperBaseForCallee(generator);
>-    return generator.moveToDestinationIfNeeded(generator.finalDestination(dst), result);
>+    return generator.move(generator.finalDestination(dst), result);
> }
> 
> // ------------------------------ ImportNode -------------------------------------
>@@ -220,7 +220,7 @@ RegisterID* NewTargetNode::emitBytecode(BytecodeGenerator& generator, RegisterID
>     if (dst == generator.ignoredResult())
>         return nullptr;
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.newTarget());
>+    return generator.move(dst, generator.newTarget());
> }
> 
> // ------------------------------ ImportMetaNode ---------------------------------
>@@ -246,7 +246,7 @@ RegisterID* ResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
>             return nullptr;
> 
>         generator.emitProfileType(local, var, m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
>-        return generator.moveToDestinationIfNeeded(dst, local);
>+        return generator.move(dst, local);
>     }
>     
>     JSTextPosition divot = m_start + m_ident.length();
>@@ -256,7 +256,7 @@ RegisterID* ResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
>     RefPtr<RegisterID> uncheckedResult = generator.newTemporary();
>     generator.emitGetFromScope(uncheckedResult.get(), scope.get(), var, ThrowIfNotFound);
>     generator.emitTDZCheckIfNecessary(var, uncheckedResult.get(), nullptr);
>-    generator.emitMove(finalDest, uncheckedResult.get());
>+    generator.move(finalDest, uncheckedResult.get());
>     generator.emitProfileType(finalDest, var, m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
>     return finalDest;
> }
>@@ -330,14 +330,14 @@ RegisterID* TaggedTemplateNode::emitBytecode(BytecodeGenerator& generator, Regis
>         Variable var = generator.variable(identifier);
>         if (RegisterID* local = var.local()) {
>             generator.emitTDZCheckIfNecessary(var, local, nullptr);
>-            tag = generator.emitMove(generator.newTemporary(), local);
>+            tag = generator.move(generator.newTemporary(), local);
>         } else {
>             tag = generator.newTemporary();
>             base = generator.newTemporary();
> 
>             JSTextPosition newDivot = divotStart() + identifier.length();
>             generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
>-            generator.moveToDestinationIfNeeded(base.get(), generator.emitResolveScope(base.get(), var));
>+            generator.move(base.get(), generator.emitResolveScope(base.get(), var));
>             generator.emitGetFromScope(tag.get(), base.get(), var, ThrowIfNotFound);
>             generator.emitTDZCheckIfNecessary(var, tag.get(), nullptr);
>         }
>@@ -371,12 +371,12 @@ RegisterID* TaggedTemplateNode::emitBytecode(BytecodeGenerator& generator, Regis
> 
>     CallArguments callArguments(generator, nullptr, 1 + expressionsCount);
>     if (base)
>-        generator.emitMove(callArguments.thisRegister(), base.get());
>+        generator.move(callArguments.thisRegister(), base.get());
>     else
>         generator.emitLoad(callArguments.thisRegister(), jsUndefined());
> 
>     unsigned argumentIndex = 0;
>-    generator.emitMove(callArguments.argumentRegister(argumentIndex++), templateObject.get());
>+    generator.move(callArguments.argumentRegister(argumentIndex++), templateObject.get());
>     for (TemplateExpressionListNode* templateExpression = m_templateLiteral->templateExpressions(); templateExpression; templateExpression = templateExpression->next())
>         generator.emitNode(callArguments.argumentRegister(argumentIndex++), templateExpression->value());
> 
>@@ -452,7 +452,7 @@ RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds
>         generator.emitPutById(array.get(), generator.propertyNames().length, value);
>     }
> 
>-    return generator.moveToDestinationIfNeeded(dst, array.get());
>+    return generator.move(dst, array.get());
>     
> handleSpread:
>     RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(length));
>@@ -477,7 +477,7 @@ handleSpread:
>         generator.emitBinaryOp(op_add, index.get(), index.get(), generator.emitLoad(0, jsNumber(m_elision)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
>         generator.emitPutById(array.get(), generator.propertyNames().length, index.get());
>     }
>-    return generator.moveToDestinationIfNeeded(dst, array.get());
>+    return generator.move(dst, array.get());
> }
> 
> bool ArrayNode::isSimpleArray() const
>@@ -523,7 +523,7 @@ RegisterID* ObjectLiteralNode::emitBytecode(BytecodeGenerator& generator, Regist
>     }
>     RefPtr<RegisterID> newObj = generator.emitNewObject(generator.tempDestination(dst));
>     generator.emitNode(newObj.get(), m_list);
>-    return generator.moveToDestinationIfNeeded(dst, newObj.get());
>+    return generator.move(dst, newObj.get());
> }
> 
> // ------------------------------ PropertyListNode -----------------------------
>@@ -845,7 +845,7 @@ RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, Reg
>     Variable var = generator.variable(generator.propertyNames().eval);
>     if (RegisterID* local = var.local()) {
>         generator.emitTDZCheckIfNecessary(var, local, nullptr);
>-        RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local);
>+        RefPtr<RegisterID> func = generator.move(generator.tempDestination(dst), local);
>         CallArguments callArguments(generator, m_args);
>         generator.emitLoad(callArguments.thisRegister(), jsUndefined());
>         return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::No);
>@@ -855,7 +855,7 @@ RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, Reg
>     CallArguments callArguments(generator, m_args);
>     JSTextPosition newDivot = divotStart() + 4;
>     generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
>-    generator.moveToDestinationIfNeeded(
>+    generator.move(
>         callArguments.thisRegister(),
>         generator.emitResolveScope(callArguments.thisRegister(), var));
>     generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound);
>@@ -887,7 +887,7 @@ RegisterID* FunctionCallValueNode::emitBytecode(BytecodeGenerator& generator, Re
>         generator.emitThrowReferenceError(ASCIILiteral("'super()' can't be called more than once in a constructor."));
>         generator.emitLabel(thisIsEmptyLabel.get());
> 
>-        generator.emitMove(generator.thisRegister(), ret);
>+        generator.move(generator.thisRegister(), ret);
>         
>         if (generator.isDerivedConstructorContext() || doWeUseArrowFunctionInConstructor)
>             generator.emitPutThisToArrowFunctionContextScope();
>@@ -909,7 +909,7 @@ RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator,
> {
>     if (UNLIKELY(m_ident == generator.vm()->propertyNames->builtinNames().assertPrivateName())) {
>         if (ASSERT_DISABLED)
>-            return generator.moveToDestinationIfNeeded(dst, generator.emitLoad(nullptr, jsUndefined()));
>+            return generator.move(dst, generator.emitLoad(nullptr, jsUndefined()));
>     }
> 
>     ExpectedFunction expectedFunction = generator.expectedFunctionForIdentifier(m_ident);
>@@ -917,7 +917,7 @@ RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator,
>     Variable var = generator.variable(m_ident);
>     if (RegisterID* local = var.local()) {
>         generator.emitTDZCheckIfNecessary(var, local, nullptr);
>-        RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local);
>+        RefPtr<RegisterID> func = generator.move(generator.tempDestination(dst), local);
>         RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
>         CallArguments callArguments(generator, m_args);
>         generator.emitLoad(callArguments.thisRegister(), jsUndefined());
>@@ -934,7 +934,7 @@ RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator,
> 
>     JSTextPosition newDivot = divotStart() + m_ident.length();
>     generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
>-    generator.moveToDestinationIfNeeded(
>+    generator.move(
>         callArguments.thisRegister(),
>         generator.emitResolveScope(callArguments.thisRegister(), var));
>     generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound);
>@@ -1010,7 +1010,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByIdDirect(BytecodeGenerato
> 
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitDirectPutById(base.get(), ident, value.get(), PropertyNode::KnownDirect));
>+    return generator.move(dst, generator.emitDirectPutById(base.get(), ident, value.get(), PropertyNode::KnownDirect));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByIdDirectPrivate(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1026,7 +1026,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByIdDirectPrivate(BytecodeG
> 
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitDirectPutById(base.get(), *ident, value.get(), PropertyNode::KnownDirect));
>+    return generator.move(dst, generator.emitDirectPutById(base.get(), *ident, value.get(), PropertyNode::KnownDirect));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByValDirect(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1040,7 +1040,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByValDirect(BytecodeGenerat
> 
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitDirectPutByVal(base.get(), index.get(), value.get()));
>+    return generator.move(dst, generator.emitDirectPutByVal(base.get(), index.get(), value.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_tailCallForwardArguments(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1113,7 +1113,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toNumber(BytecodeGenerator& ge
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitToNumber(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitToNumber(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toString(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1122,7 +1122,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toString(BytecodeGenerator& ge
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitToString(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitToString(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toObject(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1136,9 +1136,9 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toObject(BytecodeGenerator& ge
>         ASSERT(node->m_expr->isString());
>         const Identifier& message = static_cast<StringNode*>(node->m_expr)->value();
>         ASSERT(!node->m_next);
>-        return generator.moveToDestinationIfNeeded(dst, generator.emitToObject(temp.get(), src.get(), message));
>+        return generator.move(dst, generator.emitToObject(temp.get(), src.get(), message));
>     }
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitToObject(temp.get(), src.get(), generator.vm()->propertyNames->emptyIdentifier));
>+    return generator.move(dst, generator.emitToObject(temp.get(), src.get(), generator.vm()->propertyNames->emptyIdentifier));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_idWithProfile(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1154,7 +1154,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_idWithProfile(BytecodeGenerato
>         speculation |= speculationFromString(ident.utf8().data());
>     }
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIdWithProfile(idValue.get(), speculation));
>+    return generator.move(dst, generator.emitIdWithProfile(idValue.get(), speculation));
> }
>     
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isJSArray(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1163,7 +1163,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isJSArray(JSC::BytecodeGenerat
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsJSArray(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsJSArray(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isProxyObject(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1172,7 +1172,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isProxyObject(JSC::BytecodeGen
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsProxyObject(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsProxyObject(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isRegExpObject(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1181,7 +1181,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isRegExpObject(JSC::BytecodeGe
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsRegExpObject(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsRegExpObject(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isObject(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1190,7 +1190,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isObject(BytecodeGenerator& ge
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsObject(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsObject(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isDerivedArray(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1199,7 +1199,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isDerivedArray(JSC::BytecodeGe
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsDerivedArray(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsDerivedArray(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isMap(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1208,7 +1208,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isMap(JSC::BytecodeGenerator&
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsMap(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsMap(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isSet(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1217,7 +1217,7 @@ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isSet(JSC::BytecodeGenerator&
>     RefPtr<RegisterID> src = generator.emitNode(node);
>     ASSERT(!node->m_next);
> 
>-    return generator.moveToDestinationIfNeeded(dst, generator.emitIsSet(generator.tempDestination(dst), src.get()));
>+    return generator.move(dst, generator.emitIsSet(generator.tempDestination(dst), src.get()));
> }
> 
> RegisterID* BytecodeIntrinsicNode::emit_intrinsic_newArrayWithSize(JSC::BytecodeGenerator& generator, JSC::RegisterID* dst)
>@@ -1299,9 +1299,9 @@ RegisterID* FunctionCallBracketNode::emitBytecode(BytecodeGenerator& generator,
>     CallArguments callArguments(generator, m_args);
>     if (baseIsSuper) {
>         generator.emitTDZCheck(generator.thisRegister());
>-        generator.emitMove(callArguments.thisRegister(), thisRegister.get());
>+        generator.move(callArguments.thisRegister(), thisRegister.get());
>     } else
>-        generator.emitMove(callArguments.thisRegister(), base.get());
>+        generator.move(callArguments.thisRegister(), base.get());
>     RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>     generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
>     return ret;
>@@ -1316,7 +1316,7 @@ RegisterID* FunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, Regi
>     CallArguments callArguments(generator, m_args);
>     bool baseIsSuper = m_base->isSuperNode();
>     if (baseIsSuper)
>-        generator.emitMove(callArguments.thisRegister(), generator.ensureThis());
>+        generator.move(callArguments.thisRegister(), generator.ensureThis());
>     else
>         generator.emitNode(callArguments.thisRegister(), m_base);
>     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
>@@ -1351,9 +1351,9 @@ RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>     if (m_distanceToInnermostCallOrApply > maxDistanceToInnermostCallOrApply && emitCallCheck) {
>         makeFunction();
>         CallArguments callArguments(generator, m_args);
>-        generator.emitMove(callArguments.thisRegister(), base.get());
>+        generator.move(callArguments.thisRegister(), base.get());
>         generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>-        generator.moveToDestinationIfNeeded(dst, returnValue.get());
>+        generator.move(dst, returnValue.get());
>         return returnValue.get();
>     }
> 
>@@ -1377,13 +1377,13 @@ RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>             ArgumentListNode* oldList = m_args->m_listNode;
>             m_args->m_listNode = m_args->m_listNode->m_next;
> 
>-            RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
>+            RefPtr<RegisterID> realFunction = generator.move(generator.tempDestination(dst), base.get());
>             CallArguments callArguments(generator, m_args);
>             generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
>             generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>             m_args->m_listNode = oldList;
>         } else {
>-            RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
>+            RefPtr<RegisterID> realFunction = generator.move(generator.tempDestination(dst), base.get());
>             CallArguments callArguments(generator, m_args);
>             generator.emitLoad(callArguments.thisRegister(), jsUndefined());
>             generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>@@ -1394,7 +1394,7 @@ RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>         generator.emitLabel(realCall.get());
>         {
>             CallArguments callArguments(generator, m_args);
>-            generator.emitMove(callArguments.thisRegister(), base.get());
>+            generator.move(callArguments.thisRegister(), base.get());
>             generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>         }
>         generator.emitLabel(end.get());
>@@ -1431,9 +1431,9 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>     if (m_distanceToInnermostCallOrApply > maxDistanceToInnermostCallOrApply && emitCallCheck) {
>         makeFunction();
>         CallArguments callArguments(generator, m_args);
>-        generator.emitMove(callArguments.thisRegister(), base.get());
>+        generator.move(callArguments.thisRegister(), base.get());
>         generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>-        generator.moveToDestinationIfNeeded(dst, returnValue.get());
>+        generator.move(dst, returnValue.get());
>         return returnValue.get();
>     }
> 
>@@ -1449,7 +1449,7 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>             ArgumentListNode* oldList = m_args->m_listNode;
>             if (m_args->m_listNode->m_expr->isSpreadExpression()) {
>                 SpreadExpressionNode* spread = static_cast<SpreadExpressionNode*>(m_args->m_listNode->m_expr);
>-                RefPtr<RegisterID> realFunction = generator.emitMove(generator.newTemporary(), base.get());
>+                RefPtr<RegisterID> realFunction = generator.move(generator.newTemporary(), base.get());
>                 RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(0));
>                 RefPtr<RegisterID> thisRegister = generator.emitLoad(generator.newTemporary(), jsUndefined());
>                 RefPtr<RegisterID> argumentsRegister = generator.emitLoad(generator.newTemporary(), jsUndefined());
>@@ -1461,13 +1461,13 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>                     RefPtr<RegisterID> compareResult = generator.newTemporary();
>                     RefPtr<RegisterID> indexZeroCompareResult = generator.emitBinaryOp(op_eq, compareResult.get(), index.get(), generator.emitLoad(0, jsNumber(0)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
>                     generator.emitJumpIfFalse(indexZeroCompareResult.get(), haveThis.get());
>-                    generator.emitMove(thisRegister.get(), value);
>+                    generator.move(thisRegister.get(), value);
>                     generator.emitLoad(index.get(), jsNumber(1));
>                     generator.emitJump(end.get());
>                     generator.emitLabel(haveThis.get());
>                     RefPtr<RegisterID> indexOneCompareResult = generator.emitBinaryOp(op_eq, compareResult.get(), index.get(), generator.emitLoad(0, jsNumber(1)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
>                     generator.emitJumpIfFalse(indexOneCompareResult.get(), end.get());
>-                    generator.emitMove(argumentsRegister.get(), value);
>+                    generator.move(argumentsRegister.get(), value);
>                     generator.emitLoad(index.get(), jsNumber(2));
>                     generator.emitLabel(end.get());
>                 };
>@@ -1477,27 +1477,27 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>                 ASSERT(m_args->m_listNode->m_next->m_expr->isSimpleArray());
>                 ASSERT(!m_args->m_listNode->m_next->m_next);
>                 m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.parserArena(), 0, 0);
>-                RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
>+                RefPtr<RegisterID> realFunction = generator.move(generator.tempDestination(dst), base.get());
>                 CallArguments callArguments(generator, m_args);
>                 generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
>                 generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>             } else {
>                 m_args->m_listNode = m_args->m_listNode->m_next;
>-                RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
>+                RefPtr<RegisterID> realFunction = generator.move(generator.tempDestination(dst), base.get());
>                 CallArguments callArguments(generator, m_args);
>                 generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
>                 generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>             }
>             m_args->m_listNode = oldList;
>         } else {
>-            RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
>+            RefPtr<RegisterID> realFunction = generator.move(generator.tempDestination(dst), base.get());
>             CallArguments callArguments(generator, m_args);
>             generator.emitLoad(callArguments.thisRegister(), jsUndefined());
>             generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>         }
>     } else {
>         ASSERT(m_args->m_listNode && m_args->m_listNode->m_next);
>-        RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
>+        RefPtr<RegisterID> realFunction = generator.move(generator.tempDestination(dst), base.get());
>         RefPtr<RegisterID> thisRegister = generator.emitNode(m_args->m_listNode->m_expr);
>         RefPtr<RegisterID> argsRegister;
>         ArgumentListNode* args = m_args->m_listNode->m_next;
>@@ -1514,7 +1514,7 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
>         generator.emitJump(end.get());
>         generator.emitLabel(realCall.get());
>         CallArguments callArguments(generator, m_args);
>-        generator.emitMove(callArguments.thisRegister(), base.get());
>+        generator.move(callArguments.thisRegister(), base.get());
>         generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd(), DebuggableCall::Yes);
>         generator.emitLabel(end.get());
>     }
>@@ -1535,7 +1535,7 @@ static RegisterID* emitPostIncOrDec(BytecodeGenerator& generator, RegisterID* ds
>         return generator.emitToNumber(generator.finalDestination(dst), srcDst);
>     RefPtr<RegisterID> tmp = generator.emitToNumber(generator.tempDestination(dst), srcDst);
>     emitIncOrDec(generator, srcDst, oper);
>-    return generator.moveToDestinationIfNeeded(dst, tmp.get());
>+    return generator.move(dst, tmp.get());
> }
> 
> RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1553,7 +1553,7 @@ RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* d
>         RefPtr<RegisterID> localReg = local;
>         if (var.isReadOnly()) {
>             generator.emitReadOnlyExceptionIfNeeded(var);
>-            localReg = generator.emitMove(generator.tempDestination(dst), local);
>+            localReg = generator.move(generator.tempDestination(dst), local);
>         }
>         generator.invalidateForInContextForLocal(local);
>         RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), localReg.get(), m_operator);
>@@ -1607,7 +1607,7 @@ RegisterID* PostfixNode::emitBracket(BytecodeGenerator& generator, RegisterID* d
>     else
>         generator.emitPutByVal(base.get(), property.get(), value.get());
>     generator.emitProfileType(value.get(), divotStart(), divotEnd());
>-    return generator.moveToDestinationIfNeeded(dst, oldValue);
>+    return generator.move(dst, oldValue);
> }
> 
> RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1638,7 +1638,7 @@ RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
>     else
>         generator.emitPutById(base.get(), ident, value.get());
>     generator.emitProfileType(value.get(), divotStart(), divotEnd());
>-    return generator.moveToDestinationIfNeeded(dst, oldValue);
>+    return generator.move(dst, oldValue);
> }
> 
> RegisterID* PostfixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1766,19 +1766,19 @@ RegisterID* PrefixNode::emitResolve(BytecodeGenerator& generator, RegisterID* ds
>         RefPtr<RegisterID> localReg = local;
>         if (var.isReadOnly()) {
>             generator.emitReadOnlyExceptionIfNeeded(var);
>-            localReg = generator.emitMove(generator.tempDestination(dst), localReg.get());
>+            localReg = generator.move(generator.tempDestination(dst), localReg.get());
>         } else if (generator.vm()->typeProfiler()) {
>             generator.invalidateForInContextForLocal(local);
>             RefPtr<RegisterID> tempDst = generator.tempDestination(dst);
>-            generator.emitMove(tempDst.get(), localReg.get());
>+            generator.move(tempDst.get(), localReg.get());
>             emitIncOrDec(generator, tempDst.get(), m_operator);
>-            generator.emitMove(localReg.get(), tempDst.get());
>+            generator.move(localReg.get(), tempDst.get());
>             generator.emitProfileType(localReg.get(), var, divotStart(), divotEnd());
>-            return generator.moveToDestinationIfNeeded(dst, tempDst.get());
>+            return generator.move(dst, tempDst.get());
>         }
>         generator.invalidateForInContextForLocal(local);
>         emitIncOrDec(generator, localReg.get(), m_operator);
>-        return generator.moveToDestinationIfNeeded(dst, localReg.get());
>+        return generator.move(dst, localReg.get());
>     }
> 
>     generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
>@@ -1796,7 +1796,7 @@ RegisterID* PrefixNode::emitResolve(BytecodeGenerator& generator, RegisterID* ds
>         generator.emitPutToScope(scope.get(), var, value.get(), ThrowIfNotFound, InitializationMode::NotInitialization);
>         generator.emitProfileType(value.get(), var, divotStart(), divotEnd());
>     }
>-    return generator.moveToDestinationIfNeeded(dst, value.get());
>+    return generator.move(dst, value.get());
> }
> 
> RegisterID* PrefixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1825,7 +1825,7 @@ RegisterID* PrefixNode::emitBracket(BytecodeGenerator& generator, RegisterID* ds
>     else
>         generator.emitPutByVal(base.get(), property.get(), value);
>     generator.emitProfileType(value, divotStart(), divotEnd());
>-    return generator.moveToDestinationIfNeeded(dst, propDst.get());
>+    return generator.move(dst, propDst.get());
> }
> 
> RegisterID* PrefixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
>@@ -1853,7 +1853,7 @@ RegisterID* PrefixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
>     else
>         generator.emitPutById(base.get(), ident, value);
>     generator.emitProfileType(value, divotStart(), divotEnd());
>-    return generator.moveToDestinationIfNeeded(dst, propDst.get());
>+    return generator.move(dst, propDst.get());
> }
> 
> RegisterID* PrefixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
>@@ -2315,7 +2315,7 @@ RegisterID* LogicalOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID
>     generator.emitNodeInTailPosition(temp.get(), m_expr2);
>     generator.emitLabel(target.get());
> 
>-    return generator.moveToDestinationIfNeeded(dst, temp.get());
>+    return generator.move(dst, temp.get());
> }
> 
> void LogicalOpNode::emitBytecodeInConditionContext(BytecodeGenerator& generator, Label& trueTarget, Label& falseTarget, FallThroughMode fallThroughMode)
>@@ -2437,18 +2437,18 @@ RegisterID* ReadModifyResolveNode::emitBytecode(BytecodeGenerator& generator, Re
>         
>         if (generator.leftHandSideNeedsCopy(m_rightHasAssignments, m_right->isPure(generator))) {
>             RefPtr<RegisterID> result = generator.newTemporary();
>-            generator.emitMove(result.get(), local);
>+            generator.move(result.get(), local);
>             emitReadModifyAssignment(generator, result.get(), result.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
>-            generator.emitMove(local, result.get());
>+            generator.move(local, result.get());
>             generator.invalidateForInContextForLocal(local);
>             generator.emitProfileType(local, divotStart(), divotEnd());
>-            return generator.moveToDestinationIfNeeded(dst, result.get());
>+            return generator.move(dst, result.get());
>         }
>         
>         RegisterID* result = emitReadModifyAssignment(generator, local, local, m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
>         generator.invalidateForInContextForLocal(local);
>         generator.emitProfileType(result, divotStart(), divotEnd());
>-        return generator.moveToDestinationIfNeeded(dst, result);
>+        return generator.move(dst, result);
>     }
> 
>     generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
>@@ -2502,15 +2502,15 @@ RegisterID* AssignResolveNode::emitBytecode(BytecodeGenerator& generator, Regist
>         } else if (var.isSpecial()) {
>             RefPtr<RegisterID> tempDst = generator.tempDestination(dst);
>             generator.emitNode(tempDst.get(), m_right);
>-            generator.emitMove(local, tempDst.get());
>+            generator.move(local, tempDst.get());
>             generator.emitProfileType(local, var, divotStart(), divotEnd());
>             generator.invalidateForInContextForLocal(local);
>-            result = generator.moveToDestinationIfNeeded(dst, tempDst.get());
>+            result = generator.move(dst, tempDst.get());
>         } else {
>             RegisterID* right = generator.emitNode(local, m_right);
>             generator.emitProfileType(right, var, divotStart(), divotEnd());
>             generator.invalidateForInContextForLocal(local);
>-            result = generator.moveToDestinationIfNeeded(dst, right);
>+            result = generator.move(dst, right);
>         }
> 
>         if (m_assignmentContext == AssignmentContext::DeclarationStatement || m_assignmentContext == AssignmentContext::ConstDeclarationStatement)
>@@ -2552,14 +2552,14 @@ RegisterID* AssignDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID
>     RefPtr<RegisterID> value = generator.destinationForAssignResult(dst);
>     RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right);
>     generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
>-    RefPtr<RegisterID> forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.moveToDestinationIfNeeded(generator.tempDestination(result.get()), result.get());
>+    RefPtr<RegisterID> forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.move(generator.tempDestination(result.get()), result.get());
>     if (m_base->isSuperNode()) {
>         RefPtr<RegisterID> thisValue = generator.ensureThis();
>         generator.emitPutById(base.get(), thisValue.get(), m_ident, forwardResult.get());
>     } else
>         generator.emitPutById(base.get(), m_ident, forwardResult.get());
>     generator.emitProfileType(forwardResult.get(), divotStart(), divotEnd());
>-    return generator.moveToDestinationIfNeeded(dst, forwardResult.get());
>+    return generator.move(dst, forwardResult.get());
> }
> 
> // ------------------------------ ReadModifyDotNode -----------------------------------
>@@ -2605,7 +2605,7 @@ RegisterID* AssignBracketNode::emitBytecode(BytecodeGenerator& generator, Regist
>     RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right);
> 
>     generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
>-    RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.moveToDestinationIfNeeded(generator.tempDestination(result.get()), result.get());
>+    RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.move(generator.tempDestination(result.get()), result.get());
> 
>     if (isNonIndexStringElement(*m_subscript)) {
>         if (m_base->isSuperNode()) {
>@@ -2622,7 +2622,7 @@ RegisterID* AssignBracketNode::emitBytecode(BytecodeGenerator& generator, Regist
>     }
> 
>     generator.emitProfileType(forwardResult, divotStart(), divotEnd());
>-    return generator.moveToDestinationIfNeeded(dst, forwardResult);
>+    return generator.move(dst, forwardResult);
> }
> 
> // ------------------------------ ReadModifyBracketNode -----------------------------------
>@@ -2964,7 +2964,7 @@ void ForInNode::emitLoopHeader(BytecodeGenerator& generator, RegisterID* propert
>         if (RegisterID* local = var.local()) {
>             if (var.isReadOnly())
>                 generator.emitReadOnlyExceptionIfNeeded(var);
>-            generator.emitMove(local, propertyName);
>+            generator.move(local, propertyName);
>             generator.invalidateForInContextForLocal(local);
>         } else {
>             if (generator.isStrictMode())
>@@ -3032,7 +3032,7 @@ void ForInNode::emitLoopHeader(BytecodeGenerator& generator, RegisterID* propert
>             assignNode->bindings()->bindValue(generator, propertyName);
>             return;
>         }
>-        generator.emitMove(var.local(), propertyName);
>+        generator.move(var.local(), propertyName);
>         generator.invalidateForInContextForLocal(var.local());
>         generator.emitProfileType(propertyName, var, simpleBinding->divotStart(), simpleBinding->divotEnd());
>         return;
>@@ -3223,7 +3223,7 @@ void ForOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
>             if (RegisterID* local = var.local()) {
>                 if (var.isReadOnly())
>                     generator.emitReadOnlyExceptionIfNeeded(var);
>-                generator.emitMove(local, value);
>+                generator.move(local, value);
>                 generator.invalidateForInContextForLocal(local);
>             } else {
>                 if (generator.isStrictMode())
>@@ -3350,7 +3350,7 @@ void ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
>     bool hasFinally = generator.emitReturnViaFinallyIfNeeded(returnRegister.get());
>     if (!hasFinally) {
>         if (generator.parseMode() == SourceParseMode::AsyncGeneratorBodyMode) {
>-            returnRegister = generator.emitMove(generator.newTemporary(), returnRegister.get());
>+            returnRegister = generator.move(generator.newTemporary(), returnRegister.get());
>             generator.emitAwait(returnRegister.get());
>         }
> 
>@@ -3686,7 +3686,7 @@ void TryNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
>         generator.restoreScopeRegister();
> 
>         RefPtr<RegisterID> savedCompletionTypeRegister = generator.newTemporary();
>-        generator.emitMove(savedCompletionTypeRegister.get(), generator.completionTypeRegister());
>+        generator.move(savedCompletionTypeRegister.get(), generator.completionTypeRegister());
> 
>         int finallyStartOffset = m_catchBlock ? m_catchBlock->endOffset() + 1 : m_tryBlock->endOffset() + 1;
>         generator.emitProfileControlFlow(finallyStartOffset);
>@@ -3828,14 +3828,14 @@ void FunctionNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
>         // load and call @asyncFunctionResume
>         auto var = generator.variable(generator.propertyNames().builtinNames().asyncFunctionResumePrivateName());
>         RefPtr<RegisterID> scope = generator.newTemporary();
>-        generator.moveToDestinationIfNeeded(scope.get(), generator.emitResolveScope(scope.get(), var));
>+        generator.move(scope.get(), generator.emitResolveScope(scope.get(), var));
>         RefPtr<RegisterID> asyncFunctionResume = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
> 
>         CallArguments args(generator, nullptr, 4);
>         unsigned argumentCount = 0;
>         generator.emitLoad(args.thisRegister(), jsUndefined());
>-        generator.emitMove(args.argumentRegister(argumentCount++), generator.generatorRegister());
>-        generator.emitMove(args.argumentRegister(argumentCount++), generator.promiseCapabilityRegister());
>+        generator.move(args.argumentRegister(argumentCount++), generator.generatorRegister());
>+        generator.move(args.argumentRegister(argumentCount++), generator.promiseCapabilityRegister());
>         generator.emitLoad(args.argumentRegister(argumentCount++), jsUndefined());
>         generator.emitLoad(args.argumentRegister(argumentCount++), jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::NormalMode)));
>         // JSTextPosition(int _line, int _offset, int _lineStartOffset)
>@@ -3949,14 +3949,14 @@ RegisterID* YieldExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID
>         RefPtr<RegisterID> value = generator.emitYield(arg.get(), JSAsyncGeneratorFunction::AsyncGeneratorSuspendReason::Yield);
>         if (dst == generator.ignoredResult())
>             return nullptr;
>-        return generator.emitMove(generator.finalDestination(dst), value.get());
>+        return generator.move(generator.finalDestination(dst), value.get());
>     }
>     RefPtr<RegisterID> arg = generator.newTemporary();
>     generator.emitNode(arg.get(), argument());
>     RefPtr<RegisterID> value = generator.emitDelegateYield(arg.get(), this);
>     if (dst == generator.ignoredResult())
>         return nullptr;
>-    return generator.emitMove(generator.finalDestination(dst), value.get());
>+    return generator.move(generator.finalDestination(dst), value.get());
> }
> 
> // ------------------------------ AwaitExprNode --------------------------------
>@@ -3968,7 +3968,7 @@ RegisterID* AwaitExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID
>     RefPtr<RegisterID> value = generator.emitYield(arg.get(), JSAsyncGeneratorFunction::AsyncGeneratorSuspendReason::Await);
>     if (dst == generator.ignoredResult())
>         return nullptr;
>-    return generator.emitMove(generator.finalDestination(dst), value.get());
>+    return generator.move(generator.finalDestination(dst), value.get());
> }
> 
> // ------------------------------ ClassDeclNode ---------------------------------
>@@ -4059,7 +4059,7 @@ RegisterID* ClassExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID
>         generator.popLexicalScope(this);
>     }
> 
>-    return generator.moveToDestinationIfNeeded(dst, constructor.get());
>+    return generator.move(dst, constructor.get());
> }
> 
> // ------------------------------ ImportDeclarationNode -----------------------
>@@ -4107,7 +4107,7 @@ RegisterID* DestructuringAssignmentNode::emitBytecode(BytecodeGenerator& generat
>     RefPtr<RegisterID> initializer = generator.tempDestination(dst);
>     generator.emitNode(initializer.get(), m_initializer);
>     m_bindings->bindValue(generator, initializer.get());
>-    return generator.moveToDestinationIfNeeded(dst, initializer.get());
>+    return generator.move(dst, initializer.get());
> }
> 
> static void assignDefaultValueIfUndefined(BytecodeGenerator& generator, RegisterID* maybeUndefined, ExpressionNode* defaultValue)
>@@ -4125,7 +4125,7 @@ void ArrayPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs)
>     {
>         generator.emitGetById(iterator.get(), rhs, generator.propertyNames().iteratorSymbol);
>         CallArguments args(generator, nullptr);
>-        generator.emitMove(args.thisRegister(), rhs);
>+        generator.move(args.thisRegister(), rhs);
>         generator.emitCall(iterator.get(), iterator.get(), NoExpectedFunction, args, divot(), divotStart(), divotEnd(), DebuggableCall::No);
>     }
>     RefPtr<RegisterID> nextMethod = generator.emitGetById(generator.newTemporary(), iterator.get(), generator.propertyNames().next);
>@@ -4242,7 +4242,7 @@ RegisterID* ArrayPatternNode::emitDirectBinding(BytecodeGenerator& generator, Re
>             m_targetPatterns[i].pattern->bindValue(generator, registers[i].get());
>     }
>     if (resultRegister)
>-        return generator.moveToDestinationIfNeeded(dst, resultRegister.get());
>+        return generator.move(dst, resultRegister.get());
>     return generator.emitLoad(generator.finalDestination(dst), jsUndefined());
> }
> 
>@@ -4307,7 +4307,7 @@ void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs)
>         auto var = generator.variable(generator.propertyNames().builtinNames().SetPrivateName());
> 
>         RefPtr<RegisterID> scope = generator.newTemporary();
>-        generator.moveToDestinationIfNeeded(scope.get(), generator.emitResolveScope(scope.get(), var));
>+        generator.move(scope.get(), generator.emitResolveScope(scope.get(), var));
>         RefPtr<RegisterID> setConstructor = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
> 
>         CallArguments args(generator, nullptr, 0);
>@@ -4340,8 +4340,8 @@ void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs)
>                         propertyName = generator.emitLoad(nullptr, target.propertyName);
> 
>                     CallArguments args(generator, nullptr, 1);
>-                    generator.emitMove(args.thisRegister(), excludedList.get());
>-                    generator.emitMove(args.argumentRegister(0), propertyName.get());
>+                    generator.move(args.thisRegister(), excludedList.get());
>+                    generator.move(args.argumentRegister(0), propertyName.get());
>                     generator.emitCall(generator.newTemporary(), addMethod.get(), NoExpectedFunction, args, divot(), divotStart(), divotEnd(), DebuggableCall::No);
>                 } else
>                     excludedSet.add(target.propertyName.impl());
>@@ -4359,18 +4359,18 @@ void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs)
>             auto var = generator.variable(generator.propertyNames().builtinNames().copyDataPropertiesPrivateName());
>             
>             RefPtr<RegisterID> scope = generator.newTemporary();
>-            generator.moveToDestinationIfNeeded(scope.get(), generator.emitResolveScope(scope.get(), var));
>+            generator.move(scope.get(), generator.emitResolveScope(scope.get(), var));
>             RefPtr<RegisterID> copyDataProperties = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
>             
>             CallArguments args(generator, nullptr, 3);
>             generator.emitLoad(args.thisRegister(), jsUndefined());
>-            generator.emitMove(args.argumentRegister(0), newObject.get());
>-            generator.emitMove(args.argumentRegister(1), rhs);
>+            generator.move(args.argumentRegister(0), newObject.get());
>+            generator.move(args.argumentRegister(1), rhs);
>             if (m_containsComputedProperty)
>-                generator.emitMove(args.argumentRegister(2), excludedList.get());
>+                generator.move(args.argumentRegister(2), excludedList.get());
>             else {
>                 RefPtr<RegisterID> excludedSetReg = generator.emitLoad(generator.newTemporary(), excludedSet);
>-                generator.emitMove(args.argumentRegister(2), excludedSetReg.get());
>+                generator.move(args.argumentRegister(2), excludedSetReg.get());
>             }
> 
>             RefPtr<RegisterID> result = generator.newTemporary();
>@@ -4397,7 +4397,7 @@ void BindingNode::bindValue(BytecodeGenerator& generator, RegisterID* value) con
>             generator.emitReadOnlyExceptionIfNeeded(var);
>             return;
>         }
>-        generator.emitMove(local, value);
>+        generator.move(local, value);
>         generator.invalidateForInContextForLocal(local);
>         generator.emitProfileType(local, var, divotStart(), divotEnd());
>         if (m_bindingContext == AssignmentContext::DeclarationStatement || m_bindingContext == AssignmentContext::ConstDeclarationStatement)
>@@ -4448,7 +4448,7 @@ void AssignmentElementNode::bindValue(BytecodeGenerator& generator, RegisterID*
>                 generator.emitReadOnlyExceptionIfNeeded(var);
>             else {
>                 generator.invalidateForInContextForLocal(local);
>-                generator.moveToDestinationIfNeeded(local, value);
>+                generator.move(local, value);
>                 generator.emitProfileType(local, divotStart(), divotEnd());
>             }
>             return;
>@@ -4536,13 +4536,13 @@ RegisterID* ObjectSpreadExpressionNode::emitBytecode(BytecodeGenerator& generato
>     auto var = generator.variable(generator.propertyNames().builtinNames().copyDataPropertiesNoExclusionsPrivateName());
>     
>     RefPtr<RegisterID> scope = generator.newTemporary();
>-    generator.moveToDestinationIfNeeded(scope.get(), generator.emitResolveScope(scope.get(), var));
>+    generator.move(scope.get(), generator.emitResolveScope(scope.get(), var));
>     RefPtr<RegisterID> copyDataProperties = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
>     
>     CallArguments args(generator, nullptr, 2);
>     generator.emitLoad(args.thisRegister(), jsUndefined());
>-    generator.emitMove(args.argumentRegister(0), dst);
>-    generator.emitMove(args.argumentRegister(1), src.get());
>+    generator.move(args.argumentRegister(0), dst);
>+    generator.move(args.argumentRegister(1), src.get());
>     
>     generator.emitCall(generator.newTemporary(), copyDataProperties.get(), NoExpectedFunction, args, divot(), divotStart(), divotEnd(), DebuggableCall::No);
>

Actions: View | Formatted Diff | Diff

Attachments on bug 186123: 341637 | 341641 | 341642 | 341711