webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 13 insertions, 641 deletions

diff --git a/Source/JavaScriptCore/jit/CCallHelpers.h b/Source/JavaScriptCore/jit/CCallHelpers.h
index e649d39e6..afcccd1ca 100644
--- a/Source/JavaScriptCore/jit/CCallHelpers.h
+++ b/Source/JavaScriptCore/jit/CCallHelpers.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011, 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -26,44 +26,21 @@
 #ifndef CCallHelpers_h
 #define CCallHelpers_h
 
+#include <wtf/Platform.h>
+
 #if ENABLE(JIT)
 
 #include "AssemblyHelpers.h"
 #include "GPRInfo.h"
-#include "StackAlignment.h"
 
 namespace JSC {
 
-#if CPU(MIPS) || (OS(WINDOWS) && CPU(X86_64))
-#define POKE_ARGUMENT_OFFSET 4
-#else
-#define POKE_ARGUMENT_OFFSET 0
-#endif
-
 class CCallHelpers : public AssemblyHelpers {
 public:
     CCallHelpers(VM* vm, CodeBlock* codeBlock = 0)
         : AssemblyHelpers(vm, codeBlock)
     {
     }
-    
-    // The most general helper for setting arguments that fit in a GPR, if you can compute each
-    // argument without using any argument registers. You usually want one of the setupArguments*()
-    // methods below instead of this. This thing is most useful if you have *a lot* of arguments.
-    template<typename Functor>
-    void setupArgument(unsigned argumentIndex, const Functor& functor)
-    {
-        unsigned numberOfRegs = GPRInfo::numberOfArgumentRegisters; // Disguise the constant from clang's tautological compare warning.
-        if (argumentIndex < numberOfRegs) {
-            functor(GPRInfo::toArgumentRegister(argumentIndex));
-            return;
-        }
-        
-        functor(GPRInfo::nonArgGPR0);
-        poke(GPRInfo::nonArgGPR0, POKE_ARGUMENT_OFFSET + argumentIndex - GPRInfo::numberOfArgumentRegisters);
-    }
-
-    void setupArgumentsWithExecState() { setupArgumentsExecState(); }
 
     // These methods used to sort arguments into the correct registers.
     // On X86 we use cdecl calling conventions, which pass all arguments on the
@@ -118,13 +95,6 @@ public:
         addCallArgument(arg2);
     }
     
-    ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
-    {
-        resetCallArguments();
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-    }
-    
     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
     {
         resetCallArguments();
@@ -212,15 +182,6 @@ public:
         addCallArgument(arg2);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-    }
-    
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2)
     {
         resetCallArguments();
@@ -314,16 +275,6 @@ public:
         addCallArgument(arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImmPtr arg3)
     {
         resetCallArguments();
@@ -333,58 +284,6 @@ public:
         addCallArgument(arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImm32 arg3)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    { 
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, TrustedImm32 arg6)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-        addCallArgument(arg6);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3)
     {
         resetCallArguments();
@@ -448,37 +347,6 @@ public:
         addCallArgument(arg3);
         addCallArgument(arg4);
     }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImm32 arg2, GPRReg arg3, TrustedImmPtr arg4)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-    }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-    }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-    }
 
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
     {
@@ -491,27 +359,6 @@ public:
         addCallArgument(arg5);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
     {
         resetCallArguments();
@@ -532,17 +379,6 @@ public:
         addCallArgument(arg4);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
     {
         resetCallArguments();
@@ -602,17 +438,6 @@ public:
         addCallArgument(arg4);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
     {
         resetCallArguments();
@@ -678,16 +503,6 @@ public:
         addCallArgument(arg4);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-    }
-    
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
     {
         resetCallArguments();
@@ -742,33 +557,8 @@ public:
         addCallArgument(arg4);
         addCallArgument(arg5);
     }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-        addCallArgument(arg6);
-    }
-    
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
-    {
-        resetCallArguments();
-        addCallArgument(GPRInfo::callFrameRegister);
-        addCallArgument(arg1);
-        addCallArgument(arg2);
-        addCallArgument(arg3);
-        addCallArgument(arg4);
-        addCallArgument(arg5);
-        addCallArgument(arg6);
-    }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, TrustedImmPtr arg7)
+    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6)
     {
         resetCallArguments();
         addCallArgument(GPRInfo::callFrameRegister);
@@ -778,7 +568,6 @@ public:
         addCallArgument(arg4);
         addCallArgument(arg5);
         addCallArgument(arg6);
-        addCallArgument(arg7);
     }
 
     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
@@ -941,6 +730,12 @@ public:
         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
     }
 
+#if CPU(MIPS) || (OS(WINDOWS) && CPU(X86_64))
+#define POKE_ARGUMENT_OFFSET 4
+#else
+#define POKE_ARGUMENT_OFFSET 0
+#endif
+
 #if CPU(X86_64) || CPU(ARM64)
     ALWAYS_INLINE void setupArguments(FPRReg arg1)
     {
@@ -954,27 +749,14 @@ public:
     
     ALWAYS_INLINE void setupArgumentsWithExecState(FPRReg arg1, GPRReg arg2)
     {
-#if OS(WINDOWS) && CPU(X86_64)
-        // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
-        // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
-        moveDouble(arg1, FPRInfo::argumentFPR1);
-        move(arg2, GPRInfo::argumentGPR2);
-#else
         moveDouble(arg1, FPRInfo::argumentFPR0);
         move(arg2, GPRInfo::argumentGPR1);
-#endif
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
 
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, FPRReg arg3)
     {
-#if OS(WINDOWS) && CPU(X86_64)
-        // On Windows, arguments map to designated registers based on the argument positions, even when there are interlaced scalar and floating point arguments.
-        // See http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
-        moveDouble(arg3, FPRInfo::argumentFPR3);
-#else
         moveDouble(arg3, FPRInfo::argumentFPR0);
-#endif
         setupStubArguments(arg1, arg2);
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
@@ -1108,12 +890,12 @@ public:
         poke(arg3, 4);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32, FPRReg arg2, GPRReg arg3)
+    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, FPRReg arg2, GPRReg arg3)
     {
         setupArgumentsWithExecState(arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32, FPRReg arg4)
+    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, FPRReg arg4)
     {
         setupArgumentsWithExecState(arg1, arg2, arg4);
     }
@@ -1157,12 +939,6 @@ public:
         move(arg1, GPRInfo::argumentGPR0);
     }
 
-    ALWAYS_INLINE void setupArguments(TrustedImmPtr arg1, GPRReg arg2)
-    {
-        move(arg2, GPRInfo::argumentGPR1);
-        move(arg1, GPRInfo::argumentGPR0);
-    }
-    
     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2)
     {
         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1>(arg1, arg2);
@@ -1180,12 +956,6 @@ public:
         move(arg4, GPRInfo::argumentGPR3);
     }
     
-    ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
-    {
-        setupThreeStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2, arg3);
-        move(arg4, GPRInfo::argumentGPR3);
-    }
-    
     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImmPtr arg4)
     {
         setupTwoStubArgsGPR<GPRInfo::argumentGPR0, GPRInfo::argumentGPR2>(arg1, arg3);
@@ -1230,14 +1000,6 @@ public:
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
 
-#if OS(WINDOWS) && CPU(X86_64)
-    ALWAYS_INLINE void setupArgumentsWithExecStateForCallWithSlowPathReturnType(TrustedImm32 arg1)
-    {
-        move(arg1, GPRInfo::argumentGPR2);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR1);
-    }
-#endif
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2)
     {
         setupStubArguments(arg1, arg2);
@@ -1371,14 +1133,6 @@ public:
         move(arg3, GPRInfo::argumentGPR3);
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, TrustedImm32 arg3)
-    {
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg2, GPRInfo::argumentGPR2);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
 
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImmPtr arg3)
     {
@@ -1403,14 +1157,6 @@ public:
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, GPRReg arg3)
-    {
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg2, GPRInfo::argumentGPR2);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3)
     {
         move(arg3, GPRInfo::argumentGPR3);
@@ -1419,14 +1165,6 @@ public:
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3)
-    {
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg2, GPRInfo::argumentGPR2);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3)
     {
         move(arg2, GPRInfo::argumentGPR2);
@@ -1506,20 +1244,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3,  GPRReg arg4)
     {
         poke(arg4, POKE_ARGUMENT_OFFSET);
@@ -1544,55 +1268,12 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
-    {
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-#if CPU(X86_64)
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm64 arg4)
-    {
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-#endif
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
     {
         poke(arg4, POKE_ARGUMENT_OFFSET);
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
-    {
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImmPtr arg5)
     {
         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
@@ -1675,24 +1356,6 @@ public:
         poke(arg4, POKE_ARGUMENT_OFFSET);
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImmPtr arg4)
-    {
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
-    {
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImm32 arg2, GPRReg arg3, GPRReg arg4)
-    {
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
 
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
     {
@@ -1722,40 +1385,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
-    {
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImm32 arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
     {
         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
@@ -1763,13 +1392,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
     {
         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
@@ -1792,14 +1414,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
-    {
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5, TrustedImm32 arg6)
     {
         poke(arg6, POKE_ARGUMENT_OFFSET + 2);
@@ -1808,15 +1422,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, TrustedImmPtr arg7)
-    {
-        poke(arg7, POKE_ARGUMENT_OFFSET + 3);
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, GPRReg arg4, GPRReg arg5)
     {
         poke(arg5, POKE_ARGUMENT_OFFSET + 1);
@@ -1864,22 +1469,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, GPRReg arg5, TrustedImm32 arg6)
-    {
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, TrustedImmPtr arg6)
-    {
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7)
     {
         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
@@ -1898,16 +1487,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5, GPRReg arg6, GPRReg arg7, TrustedImmPtr arg8)
-    {
-        poke(arg8, POKE_ARGUMENT_OFFSET + 4);
-        poke(arg7, POKE_ARGUMENT_OFFSET + 3);
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5, GPRReg arg6, GPRReg arg7)
     {
         poke(arg7, POKE_ARGUMENT_OFFSET + 3);
@@ -1917,15 +1496,6 @@ public:
         setupArgumentsWithExecState(arg1, arg2, arg3);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, TrustedImm32 arg5, GPRReg arg6, GPRReg arg7)
-    {
-        poke(arg7, POKE_ARGUMENT_OFFSET + 3);
-        poke(arg6, POKE_ARGUMENT_OFFSET + 2);
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
-
     ALWAYS_INLINE void setupArguments(GPRReg arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, GPRReg arg5)
     {
         poke(arg5, POKE_ARGUMENT_OFFSET);
@@ -1933,13 +1503,6 @@ public:
         move(arg3, GPRInfo::argumentGPR2);
         move(arg4, GPRInfo::argumentGPR3);
     }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
-    {
-        poke(arg5, POKE_ARGUMENT_OFFSET + 1);
-        poke(arg4, POKE_ARGUMENT_OFFSET);
-        setupArgumentsWithExecState(arg1, arg2, arg3);
-    }
 #endif // NUMBER_OF_ARGUMENT_REGISTERS == 4
 
 #if NUMBER_OF_ARGUMENT_REGISTERS >= 5
@@ -1948,13 +1511,6 @@ public:
         setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3, GPRInfo::argumentGPR4>(arg1, arg3, arg4);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImmPtr arg4)
-    {
-        setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4)
     {
         setupTwoStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR4>(arg1, arg4);
@@ -1963,14 +1519,6 @@ public:
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
 
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, TrustedImm32 arg3, GPRReg arg4, GPRReg arg5)
-    {
-        setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR4, GPRInfo::argumentGPR5>(arg1, arg4, arg5);
-        move(arg2, GPRInfo::argumentGPR2);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
     ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4)
     {
         setupStubArguments134(arg1, arg3, arg4);
@@ -1985,76 +1533,6 @@ public:
         move(arg4, GPRInfo::argumentGPR4);
         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     }
-    
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImm32 arg3, TrustedImm32 arg4)
-    {
-        move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm64 arg4)
-    {
-        move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, TrustedImmPtr arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        move(arg2, GPRInfo::argumentGPR2); // In case arg2 is argumentGPR1.
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(arg5, GPRInfo::argumentGPR5);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, TrustedImmPtr arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg2, GPRInfo::argumentGPR2);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(arg5, GPRInfo::argumentGPR5);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImm32 arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4, TrustedImm32 arg5)
-    {
-        setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR4>(arg2, arg4);
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(arg5, GPRInfo::argumentGPR5);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(TrustedImmPtr arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4, TrustedImm32 arg5)
-    {
-        setupTwoStubArgsGPR<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
-        move(arg1, GPRInfo::argumentGPR1);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(arg5, GPRInfo::argumentGPR5);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, GPRReg arg3, TrustedImm32 arg4)
-    {
-        setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);
-        move(arg4, GPRInfo::argumentGPR4);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
-
-    ALWAYS_INLINE void setupArgumentsWithExecState(GPRReg arg1, GPRReg arg2, TrustedImm32 arg3, GPRReg arg4)
-    {
-        setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR4>(arg1, arg2, arg4);
-        move(arg3, GPRInfo::argumentGPR3);
-        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
-    }
 
     ALWAYS_INLINE void setupArguments(GPRReg arg1, TrustedImmPtr arg2, GPRReg arg3, GPRReg arg4, TrustedImmPtr arg5)
     {
@@ -2070,15 +1548,6 @@ public:
         move(arg4, GPRInfo::argumentGPR3);
     }
 #endif
-    
-    void setupArguments(JSValueRegs arg1)
-    {
-#if USE(JSVALUE64)
-        setupArguments(arg1.gpr());
-#else
-        setupArguments(arg1.payloadGPR(), arg1.tagGPR());
-#endif
-    }
 
     void setupResults(GPRReg destA, GPRReg destB)
     {
@@ -2101,110 +1570,13 @@ public:
             swap(destA, destB);
     }
     
-    void setupResults(JSValueRegs regs)
-    {
-#if USE(JSVALUE64)
-        move(GPRInfo::returnValueGPR, regs.gpr());
-#else
-        setupResults(regs.payloadGPR(), regs.tagGPR());
-#endif
-    }
-    
     void jumpToExceptionHandler()
     {
-        // genericUnwind() leaves the handler CallFrame* in vm->callFrameForCatch,
+        // genericUnwind() leaves the handler CallFrame* in vm->callFrameForThrow,
         // and the address of the handler in vm->targetMachinePCForThrow.
         loadPtr(&vm()->targetMachinePCForThrow, GPRInfo::regT1);
         jump(GPRInfo::regT1);
     }
-
-    void prepareForTailCallSlow(GPRReg calleeGPR = InvalidGPRReg)
-    {
-        GPRReg temp1 = calleeGPR == GPRInfo::regT0 ? GPRInfo::regT3 : GPRInfo::regT0;
-        GPRReg temp2 = calleeGPR == GPRInfo::regT1 ? GPRInfo::regT3 : GPRInfo::regT1;
-        GPRReg temp3 = calleeGPR == GPRInfo::regT2 ? GPRInfo::regT3 : GPRInfo::regT2;
-
-        GPRReg newFramePointer = temp1;
-        GPRReg newFrameSizeGPR = temp2;
-        {
-            // The old frame size is its number of arguments (or number of
-            // parameters in case of arity fixup), plus the frame header size,
-            // aligned
-            GPRReg oldFrameSizeGPR = temp2;
-            {
-                GPRReg argCountGPR = oldFrameSizeGPR;
-                load32(Address(framePointerRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset), argCountGPR);
-
-                {
-                    GPRReg numParametersGPR = temp1;
-                    {
-                        GPRReg codeBlockGPR = numParametersGPR;
-                        loadPtr(Address(framePointerRegister, JSStack::CodeBlock * static_cast<int>(sizeof(Register))), codeBlockGPR);
-                        load32(Address(codeBlockGPR, CodeBlock::offsetOfNumParameters()), numParametersGPR);
-                    }
-
-                    ASSERT(numParametersGPR != argCountGPR);
-                    Jump argumentCountWasNotFixedUp = branch32(BelowOrEqual, numParametersGPR, argCountGPR);
-                    move(numParametersGPR, argCountGPR);
-                    argumentCountWasNotFixedUp.link(this);
-                }
-
-                add32(TrustedImm32(stackAlignmentRegisters() + JSStack::CallFrameHeaderSize - 1), argCountGPR, oldFrameSizeGPR);
-                and32(TrustedImm32(-stackAlignmentRegisters()), oldFrameSizeGPR);
-                // We assume < 2^28 arguments
-                mul32(TrustedImm32(sizeof(Register)), oldFrameSizeGPR, oldFrameSizeGPR);
-            }
-
-            // The new frame pointer is at framePointer + oldFrameSize - newFrameSize
-            ASSERT(newFramePointer != oldFrameSizeGPR);
-            addPtr(framePointerRegister, oldFrameSizeGPR, newFramePointer);
-
-            // The new frame size is just the number of arguments plus the
-            // frame header size, aligned
-            ASSERT(newFrameSizeGPR != newFramePointer);
-            load32(Address(stackPointerRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset - sizeof(CallerFrameAndPC)),
-                newFrameSizeGPR);
-            add32(TrustedImm32(stackAlignmentRegisters() + JSStack::CallFrameHeaderSize - 1), newFrameSizeGPR);
-            and32(TrustedImm32(-stackAlignmentRegisters()), newFrameSizeGPR);
-            // We assume < 2^28 arguments
-            mul32(TrustedImm32(sizeof(Register)), newFrameSizeGPR, newFrameSizeGPR);
-        }
-
-        GPRReg tempGPR = temp3;
-        ASSERT(tempGPR != newFramePointer && tempGPR != newFrameSizeGPR);
-
-        // We don't need the current frame beyond this point. Masquerade as our
-        // caller.
-#if CPU(ARM) || CPU(SH4) || CPU(ARM64)
-        loadPtr(Address(framePointerRegister, sizeof(void*)), linkRegister);
-        subPtr(TrustedImm32(2 * sizeof(void*)), newFrameSizeGPR);
-#elif CPU(MIPS)
-        loadPtr(Address(framePointerRegister, sizeof(void*)), returnAddressRegister);
-        subPtr(TrustedImm32(2 * sizeof(void*)), newFrameSizeGPR);
-#elif CPU(X86) || CPU(X86_64)
-        loadPtr(Address(framePointerRegister, sizeof(void*)), tempGPR);
-        push(tempGPR);
-        subPtr(TrustedImm32(sizeof(void*)), newFrameSizeGPR);
-#else
-        UNREACHABLE_FOR_PLATFORM();
-#endif
-        subPtr(newFrameSizeGPR, newFramePointer);
-        loadPtr(Address(framePointerRegister), framePointerRegister);
-
-
-        // We need to move the newFrameSizeGPR slots above the stack pointer by
-        // newFramePointer registers. We use pointer-sized chunks.
-        MacroAssembler::Label copyLoop(label());
-
-        subPtr(TrustedImm32(sizeof(void*)), newFrameSizeGPR);
-        loadPtr(BaseIndex(stackPointerRegister, newFrameSizeGPR, TimesOne), tempGPR);
-        storePtr(tempGPR, BaseIndex(newFramePointer, newFrameSizeGPR, TimesOne));
-
-        branchTest32(MacroAssembler::NonZero, newFrameSizeGPR).linkTo(copyLoop, this);
-
-        // Ready for a jump!
-        move(newFramePointer, stackPointerRegister);
-    }
 };
 
 } // namespace JSC