diff --git a/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp b/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp
index 36fba88..4952a41 100644
--- a/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp
+++ b/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp
@@ -42,11 +42,7 @@
 
 using namespace DFG;
 
-// This implements two flavors of OSR exit: one that involves having LLVM intrinsics to help
-// OSR exit, and one that doesn't. The one that doesn't will get killed off, so we don't attempt
-// to share code between the two.
-
-static void compileStubWithOSRExitStackmap(
+static void compileStub(
     unsigned exitID, JITCode* jitCode, OSRExit& exit, VM* vm, CodeBlock* codeBlock)
 {
     StackMaps::Record* record;
@@ -178,169 +174,6 @@
             toCString(*record).data()));
 }
 
-static void compileStubWithoutOSRExitStackmap(
-    unsigned exitID, OSRExit& exit, VM* vm, CodeBlock* codeBlock)
-{
-    CCallHelpers jit(vm, codeBlock);
-    
-    // Make ourselves look like a real C function.
-    jit.push(MacroAssembler::framePointerRegister);
-    jit.move(MacroAssembler::stackPointerRegister, MacroAssembler::framePointerRegister);
-    
-    // This is actually fairly easy, even though it is horribly gross. We know that
-    // LLVM would have passes us all of the state via arguments. We know how to get
-    // the arguments. And, we know how to pop stack back to the JIT stack frame, sort
-    // of: we know that it's two frames beneath us. This is terrible and I feel
-    // ashamed of it, but it will work for now.
-    
-    CArgumentGetter arguments(jit, 2);
-    
-    // First recover our call frame and tag thingies.
-    arguments.loadNextPtr(GPRInfo::callFrameRegister);
-    jit.move(MacroAssembler::TrustedImm64(TagTypeNumber), GPRInfo::tagTypeNumberRegister);
-    jit.move(MacroAssembler::TrustedImm64(TagMask), GPRInfo::tagMaskRegister);
-    
-    // Do some value profiling.
-    if (exit.m_profileValueFormat != InvalidValueFormat) {
-        arguments.loadNextAndBox(exit.m_profileValueFormat, GPRInfo::nonArgGPR0);
-        
-        if (exit.m_kind == BadCache || exit.m_kind == BadIndexingType) {
-            CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
-            if (ArrayProfile* arrayProfile = jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex)) {
-                jit.loadPtr(MacroAssembler::Address(GPRInfo::nonArgGPR0, JSCell::structureOffset()), GPRInfo::nonArgGPR1);
-                jit.storePtr(GPRInfo::nonArgGPR1, arrayProfile->addressOfLastSeenStructure());
-                jit.load8(MacroAssembler::Address(GPRInfo::nonArgGPR1, Structure::indexingTypeOffset()), GPRInfo::nonArgGPR1);
-                jit.move(MacroAssembler::TrustedImm32(1), GPRInfo::nonArgGPR2);
-                jit.lshift32(GPRInfo::nonArgGPR1, GPRInfo::nonArgGPR2);
-                jit.or32(GPRInfo::nonArgGPR2, MacroAssembler::AbsoluteAddress(arrayProfile->addressOfArrayModes()));
-            }
-        }
-        
-        if (!!exit.m_valueProfile)
-            jit.store64(GPRInfo::nonArgGPR0, exit.m_valueProfile.getSpecFailBucket(0));
-    }
-    
-    // Use a scratch buffer to transfer all values.
-    ScratchBuffer* scratchBuffer = vm->scratchBufferForSize(sizeof(EncodedJSValue) * exit.m_values.size());
-    EncodedJSValue* scratch = scratchBuffer ? static_cast<EncodedJSValue*>(scratchBuffer->dataBuffer()) : 0;
-    
-    // Start by dumping all argument exit values to the stack.
-    
-    Vector<ExitArgumentForOperand, 16> sortedArguments;
-    for (unsigned i = exit.m_values.size(); i--;) {
-        ExitValue value = exit.m_values[i];
-        int operand = exit.m_values.operandForIndex(i);
-        
-        if (!value.isArgument())
-            continue;
-        
-        sortedArguments.append(ExitArgumentForOperand(value.exitArgument(), VirtualRegister(operand)));
-    }
-    std::sort(sortedArguments.begin(), sortedArguments.end(), lesserArgumentIndex);
-    
-    for (unsigned i = 0; i < sortedArguments.size(); ++i) {
-        ExitArgumentForOperand argument = sortedArguments[i];
-        
-        arguments.loadNextAndBox(argument.exitArgument().format(), GPRInfo::nonArgGPR0);
-        jit.store64(
-            GPRInfo::nonArgGPR0, scratch + exit.m_values.indexForOperand(argument.operand()));
-    }
-    
-    // All temp registers are free at this point.
-    
-    // Move anything on the stack into the appropriate place in the scratch buffer.
-    
-    for (unsigned i = exit.m_values.size(); i--;) {
-        ExitValue value = exit.m_values[i];
-        
-        switch (value.kind()) {
-        case ExitValueInJSStack:
-            jit.load64(AssemblyHelpers::addressFor(value.virtualRegister()), GPRInfo::regT0);
-            break;
-        case ExitValueInJSStackAsInt32:
-            jit.load32(
-                AssemblyHelpers::addressFor(value.virtualRegister()).withOffset(
-                    OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)),
-                GPRInfo::regT0);
-            jit.or64(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
-            break;
-        case ExitValueInJSStackAsInt52:
-            jit.load64(AssemblyHelpers::addressFor(value.virtualRegister()), GPRInfo::regT0);
-            jit.rshift64(
-                AssemblyHelpers::TrustedImm32(JSValue::int52ShiftAmount), GPRInfo::regT0);
-            jit.boxInt52(GPRInfo::regT0, GPRInfo::regT0, GPRInfo::regT1, FPRInfo::fpRegT0);
-            break;
-        case ExitValueInJSStackAsDouble:
-            jit.loadDouble(AssemblyHelpers::addressFor(value.virtualRegister()), FPRInfo::fpRegT0);
-            jit.boxDouble(FPRInfo::fpRegT0, GPRInfo::regT0);
-            break;
-        case ExitValueDead:
-        case ExitValueConstant:
-        case ExitValueArgument:
-            // Don't do anything for these.
-            continue;
-        default:
-            RELEASE_ASSERT_NOT_REACHED();
-            break;
-        }
-        
-        jit.store64(GPRInfo::regT0, scratch + i);
-    }
-    
-    // Move everything from the scratch buffer to the stack; this also reifies constants.
-    
-    for (unsigned i = exit.m_values.size(); i--;) {
-        ExitValue value = exit.m_values[i];
-        int operand = exit.m_values.operandForIndex(i);
-        
-        MacroAssembler::Address address = AssemblyHelpers::addressFor(operand);
-        
-        switch (value.kind()) {
-        case ExitValueDead:
-            jit.store64(MacroAssembler::TrustedImm64(JSValue::encode(jsUndefined())), address);
-            break;
-        case ExitValueConstant:
-            jit.store64(MacroAssembler::TrustedImm64(JSValue::encode(value.constant())), address);
-            break;
-        case ExitValueInJSStack:
-        case ExitValueInJSStackAsInt32:
-        case ExitValueInJSStackAsInt52:
-        case ExitValueInJSStackAsDouble:
-        case ExitValueArgument:
-            jit.load64(scratch + i, GPRInfo::regT0);
-            jit.store64(GPRInfo::regT0, address);
-            break;
-        default:
-            RELEASE_ASSERT_NOT_REACHED();
-            break;
-        }
-    }
-    
-    handleExitCounts(jit, exit);
-    reifyInlinedCallFrames(jit, exit);
-    
-    jit.pop(MacroAssembler::framePointerRegister);
-    jit.move(MacroAssembler::framePointerRegister, MacroAssembler::stackPointerRegister);
-    jit.pop(MacroAssembler::framePointerRegister);
-    jit.pop(GPRInfo::nonArgGPR0); // ignore the result.
-    
-    if (exit.m_lastSetOperand.isValid()) {
-        jit.load64(
-            AssemblyHelpers::addressFor(exit.m_lastSetOperand), GPRInfo::cachedResultRegister);
-    }
-    
-    adjustAndJumpToTarget(jit, exit);
-    
-    LinkBuffer patchBuffer(*vm, &jit, codeBlock);
-    exit.m_code = FINALIZE_CODE_IF(
-        shouldShowDisassembly(),
-        patchBuffer,
-        ("FTL OSR exit #%u (bc#%u, %s) from %s, with operands = %s",
-            exitID, exit.m_codeOrigin.bytecodeIndex,
-            exitKindToString(exit.m_kind), toCString(*codeBlock).data(),
-            toCString(ignoringContext<DumpContext>(exit.m_values)).data()));
-}
-
 extern "C" void* compileFTLOSRExit(ExecState* exec, unsigned exitID)
 {
     SamplingRegion samplingRegion("FTL OSR Exit Compilation");
@@ -361,10 +194,7 @@
     
     prepareCodeOriginForOSRExit(exec, exit.m_codeOrigin);
     
-    if (Options::ftlUsesStackmaps())
-        compileStubWithOSRExitStackmap(exitID, jitCode, exit, vm, codeBlock);
-    else
-        compileStubWithoutOSRExitStackmap(exitID, exit, vm, codeBlock);
+    compileStub(exitID, jitCode, exit, vm, codeBlock);
     
     RepatchBuffer repatchBuffer(codeBlock);
     repatchBuffer.relink(