Changeset 202862 in webkit


Ignore:
Timestamp:
Jul 6, 2016 10:19:20 AM (8 years ago)
Author:
mark.lam@apple.com
Message:

Rename VM stack limit fields to better describe their purpose.
https://bugs.webkit.org/show_bug.cgi?id=159451

Reviewed by Keith Miller.

This is in preparation for an upcoming patch that changes what stack limit values
are used under various circumstances. This patch aims to do some minimal work to
rename the fields so that it will be easier to reason about the upcoming patch.

In this patch, we make the following changes:

  1. Rename VM::m_stackLimit to VM::m_jsCPUStackLimit.
  1. VM::m_jsStackLimit used to have an overloaded meaning:
    1. For JIT builds, m_jsStackLimit is synonymous with m_stackLimit.
    2. For C Loop builds, m_jsStackLimit is a separate pointer that points to the emulated JS stack that the C Loop uses.

In place of m_jsStackLimit, this patch introduces 2 new fields:
VM::m_jsEmulatedStackLimit and VM::m_llintStackLimit.

m_llintStackLimit is the limit that the LLInt assembly uses for its stack
check. m_llintStackLimit behaves like the old m_jsStackLimit in that:

  1. For JIT builds, m_llintStackLimit is synonymous with m_jsCPUStackLimit.
  2. For C Loop builds, m_llintStackLimit is synonymous with m_jsEmulatedStackLimit.

m_jsEmulatedStackLimit is used for the emulated stack that the C Loop uses.

  1. Rename the following methods to match the above:

VM::stackLimit() ==> VM::jsCPUStackLimit()
VM::addressOfStackLimit() ==> VM::addressOfJSCPUStackLimit()
VM::jsStackLimit() ==> VM::jsEmulatedStackLimit()
VM::setJSStackLimit() ==> VM::setJSEmulatedStackLimit()
JSStack::setStackLimit() ==> JSStack::setEmulatedStackLimit()

  1. With change (2) and (3), the limits will be used as follows:
    1. VM code doing stack recursion checks will only use m_jsCPUStackLimit.
    2. JIT code will only use m_jsCPUStackLimit.
    3. C Loop emulated stack code in JSStack will only use m_jsEmulatedStackLimit. Note: the part of JSStack that operates on a JIT build will use

m_jsCPUStackLimit as expected.

  1. LLINT assembly code will only use m_llintStackLimit.

This patch only contains the above refactoring changes. There is no behavior
change.

  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compile):
(JSC::DFG::JITCompiler::compileFunction):

  • ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::lower):

  • interpreter/JSStack.cpp:

(JSC::JSStack::JSStack):
(JSC::JSStack::growSlowCase):
(JSC::JSStack::lowAddress):
(JSC::JSStack::highAddress):

  • interpreter/JSStack.h:
  • interpreter/JSStackInlines.h:

(JSC::JSStack::ensureCapacityFor):
(JSC::JSStack::shrink):
(JSC::JSStack::grow):
(JSC::JSStack::setJSEmulatedStackLimit):
(JSC::JSStack::setStackLimit): Deleted.

  • jit/JIT.cpp:

(JSC::JIT::compileWithoutLinking):

  • jit/SetupVarargsFrame.cpp:

(JSC::emitSetupVarargsFrameFastCase):

  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • runtime/RegExp.cpp:

(JSC::RegExp::finishCreation):
(JSC::RegExp::compile):
(JSC::RegExp::compileMatchOnly):

  • runtime/VM.cpp:

(JSC::VM::VM):
(JSC::VM::updateStackLimit):

  • runtime/VM.h:

(JSC::VM::reservedZoneSize):
(JSC::VM::jsCPUStackLimit):
(JSC::VM::addressOfJSCPUStackLimit):
(JSC::VM::jsEmulatedStackLimit):
(JSC::VM::setJSEmulatedStackLimit):
(JSC::VM::isSafeToRecurse):
(JSC::VM::jsStackLimit): Deleted.
(JSC::VM::setJSStackLimit): Deleted.
(JSC::VM::stackLimit): Deleted.
(JSC::VM::addressOfStackLimit): Deleted.

  • wasm/WASMFunctionCompiler.h:

(JSC::WASMFunctionCompiler::startFunction):

Location:
trunk/Source/JavaScriptCore
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r202847 r202862  
     12016-07-05  Mark Lam  <mark.lam@apple.com>
     2
     3        Rename VM stack limit fields to better describe their purpose.
     4        https://bugs.webkit.org/show_bug.cgi?id=159451
     5
     6        Reviewed by Keith Miller.
     7
     8        This is in preparation for an upcoming patch that changes what stack limit values
     9        are used under various circumstances.  This patch aims to do some minimal work to
     10        rename the fields so that it will be easier to reason about the upcoming patch.
     11   
     12        In this patch, we make the following changes:
     13
     14        1. Rename VM::m_stackLimit to VM::m_jsCPUStackLimit.
     15
     16        2. VM::m_jsStackLimit used to have an overloaded meaning:
     17           a. For JIT builds, m_jsStackLimit is synonymous with m_stackLimit.
     18           b. For C Loop builds, m_jsStackLimit is a separate pointer that points to the
     19              emulated JS stack that the C Loop uses.
     20
     21           In place of m_jsStackLimit, this patch introduces 2 new fields:
     22           VM::m_jsEmulatedStackLimit and VM::m_llintStackLimit.
     23
     24           m_llintStackLimit is the limit that the LLInt assembly uses for its stack
     25           check.  m_llintStackLimit behaves like the old m_jsStackLimit in that:
     26           a. For JIT builds, m_llintStackLimit is synonymous with m_jsCPUStackLimit.
     27           b. For C Loop builds, m_llintStackLimit is synonymous with m_jsEmulatedStackLimit.
     28
     29           m_jsEmulatedStackLimit is used for the emulated stack that the C Loop uses.
     30
     31        3. Rename the following methods to match the above:
     32             VM::stackLimit() ==> VM::jsCPUStackLimit()
     33             VM::addressOfStackLimit() ==> VM::addressOfJSCPUStackLimit()
     34             VM::jsStackLimit() ==> VM::jsEmulatedStackLimit()
     35             VM::setJSStackLimit() ==> VM::setJSEmulatedStackLimit()
     36             JSStack::setStackLimit() ==> JSStack::setEmulatedStackLimit()
     37
     38        4. With change (2) and (3), the limits will be used as follows:
     39           a. VM code doing stack recursion checks will only use m_jsCPUStackLimit.
     40           b. JIT code will only use m_jsCPUStackLimit.
     41           c. C Loop emulated stack code in JSStack will only use m_jsEmulatedStackLimit.
     42              Note: the part of JSStack that operates on a JIT build will use
     43                    m_jsCPUStackLimit as expected.
     44           d. LLINT assembly code will only use m_llintStackLimit.
     45
     46        This patch only contains the above refactoring changes.  There is no behavior
     47        change.
     48
     49        * dfg/DFGJITCompiler.cpp:
     50        (JSC::DFG::JITCompiler::compile):
     51        (JSC::DFG::JITCompiler::compileFunction):
     52        * ftl/FTLLowerDFGToB3.cpp:
     53        (JSC::FTL::DFG::LowerDFGToB3::lower):
     54        * interpreter/JSStack.cpp:
     55        (JSC::JSStack::JSStack):
     56        (JSC::JSStack::growSlowCase):
     57        (JSC::JSStack::lowAddress):
     58        (JSC::JSStack::highAddress):
     59        * interpreter/JSStack.h:
     60        * interpreter/JSStackInlines.h:
     61        (JSC::JSStack::ensureCapacityFor):
     62        (JSC::JSStack::shrink):
     63        (JSC::JSStack::grow):
     64        (JSC::JSStack::setJSEmulatedStackLimit):
     65        (JSC::JSStack::setStackLimit): Deleted.
     66        * jit/JIT.cpp:
     67        (JSC::JIT::compileWithoutLinking):
     68        * jit/SetupVarargsFrame.cpp:
     69        (JSC::emitSetupVarargsFrameFastCase):
     70        * llint/LLIntSlowPaths.cpp:
     71        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
     72        * llint/LowLevelInterpreter.asm:
     73        * llint/LowLevelInterpreter32_64.asm:
     74        * llint/LowLevelInterpreter64.asm:
     75        * runtime/RegExp.cpp:
     76        (JSC::RegExp::finishCreation):
     77        (JSC::RegExp::compile):
     78        (JSC::RegExp::compileMatchOnly):
     79        * runtime/VM.cpp:
     80        (JSC::VM::VM):
     81        (JSC::VM::updateStackLimit):
     82        * runtime/VM.h:
     83        (JSC::VM::reservedZoneSize):
     84        (JSC::VM::jsCPUStackLimit):
     85        (JSC::VM::addressOfJSCPUStackLimit):
     86        (JSC::VM::jsEmulatedStackLimit):
     87        (JSC::VM::setJSEmulatedStackLimit):
     88        (JSC::VM::isSafeToRecurse):
     89        (JSC::VM::jsStackLimit): Deleted.
     90        (JSC::VM::setJSStackLimit): Deleted.
     91        (JSC::VM::stackLimit): Deleted.
     92        (JSC::VM::addressOfStackLimit): Deleted.
     93        * wasm/WASMFunctionCompiler.h:
     94        (JSC::WASMFunctionCompiler::startFunction):
     95
    1962016-07-05  Saam Barati  <sbarati@apple.com>
    297
  • trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp

    r202242 r202862  
    11/*
    2  * Copyright (C) 2011, 2013-2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011, 2013-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    343343    // Plant a check that sufficient space is available in the JSStack.
    344344    addPtr(TrustedImm32(virtualRegisterForLocal(m_graph.requiredRegisterCountForExecutionAndExit() - 1).offset() * sizeof(Register)), GPRInfo::callFrameRegister, GPRInfo::regT1);
    345     Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfStackLimit()), GPRInfo::regT1);
     345    Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSCPUStackLimit()), GPRInfo::regT1);
    346346
    347347    addPtr(TrustedImm32(m_graph.stackPointerOffset() * sizeof(Register)), GPRInfo::callFrameRegister, stackPointerRegister);
     
    406406    // Plant a check that sufficient space is available in the JSStack.
    407407    addPtr(TrustedImm32(virtualRegisterForLocal(m_graph.requiredRegisterCountForExecutionAndExit() - 1).offset() * sizeof(Register)), GPRInfo::callFrameRegister, GPRInfo::regT1);
    408     Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfStackLimit()), GPRInfo::regT1);
     408    Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSCPUStackLimit()), GPRInfo::regT1);
    409409
    410410    // Move the stack pointer down to accommodate locals
  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

    r202792 r202862  
    190190        // Stack Overflow Check.
    191191        unsigned exitFrameSize = m_graph.requiredRegisterCountForExit() * sizeof(Register);
    192         MacroAssembler::AbsoluteAddress addressOfStackLimit(vm().addressOfStackLimit());
     192        MacroAssembler::AbsoluteAddress addressOfStackLimit(vm().addressOfJSCPUStackLimit());
    193193        PatchpointValue* stackOverflowHandler = m_out.patchpoint(Void);
    194194        CallSiteIndex callSiteIndex = callSiteIndexForCodeOrigin(m_ftlState, CodeOrigin(0));
  • trunk/Source/JavaScriptCore/interpreter/JSStack.cpp

    r193753 r202862  
    11/*
    2  * Copyright (C) 2008, 2013, 2014, 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008, 2013-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    6363
    6464    m_reservation = PageReservation::reserve(WTF::roundUpToMultipleOf(commitSize(), capacity), OSAllocator::JSVMStackPages);
    65     setStackLimit(highAddress());
     65    setJSEmulatedStackLimit(highAddress());
    6666    m_commitTop = highAddress();
    6767   
     
    8888    // just update the end pointer and return.
    8989    if (newTopOfStackWithReservedZone >= m_commitTop) {
    90         setStackLimit(newTopOfStack);
     90        setJSEmulatedStackLimit(newTopOfStack);
    9191        return true;
    9292    }
     
    105105    addToCommittedByteCount(delta);
    106106    m_commitTop = newCommitTop;
    107     setStackLimit(newTopOfStack);
     107    setJSEmulatedStackLimit(newTopOfStack);
    108108    return true;
    109109}
     
    157157{
    158158    ASSERT(wtfThreadData().stack().isGrowingDownward());
    159     return reinterpret_cast<Register*>(m_vm.stackLimit());
     159    return reinterpret_cast<Register*>(m_vm.jsCPUStackLimit());
    160160}
    161161
  • trunk/Source/JavaScriptCore/interpreter/JSStack.h

    r193648 r202862  
    11/*
    2  * Copyright (C) 2008, 2009, 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2009, 2013-2014, 2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    131131        void addToCommittedByteCount(long);
    132132
    133         void setStackLimit(Register* newTopOfStack);
     133        void setJSEmulatedStackLimit(Register* newTopOfStack);
    134134#endif // !ENABLE(JIT)
    135135
  • trunk/Source/JavaScriptCore/interpreter/JSStackInlines.h

    r170147 r202862  
    11/*
    2  * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2014, 2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    4040#else
    4141    ASSERT(wtfThreadData().stack().isGrowingDownward());
    42     return newTopOfStack >= m_vm.stackLimit();
     42    return newTopOfStack >= m_vm.jsCPUStackLimit();
    4343#endif
    4444}
     
    6363    if (newEnd >= m_end)
    6464        return;
    65     setStackLimit(newTopOfStack);
     65    setJSEmulatedStackLimit(newTopOfStack);
    6666    // Note: Clang complains of an unresolved linkage to maxExcessCapacity if
    6767    // invoke std::max() with it as an argument. To work around this, we first
     
    8181}
    8282
    83 inline void JSStack::setStackLimit(Register* newTopOfStack)
     83inline void JSStack::setJSEmulatedStackLimit(Register* newTopOfStack)
    8484{
    8585    Register* newEnd = newTopOfStack - 1;
    8686    m_end = newEnd;
    87     m_vm.setJSStackLimit(newTopOfStack);
     87    m_vm.setJSEmulatedStackLimit(newTopOfStack);
    8888}
    8989
  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r202633 r202862  
    600600
    601601    addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, regT1);
    602     Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfStackLimit()), regT1);
     602    Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSCPUStackLimit()), regT1);
    603603
    604604    move(regT1, stackPointerRegister);
  • trunk/Source/JavaScriptCore/jit/SetupVarargsFrame.cpp

    r189884 r202862  
    11/*
    2  * Copyright (C) 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    8383    emitSetVarargsFrame(jit, scratchGPR1, true, numUsedSlotsGPR, scratchGPR2);
    8484
    85     slowCase.append(jit.branchPtr(CCallHelpers::Above, CCallHelpers::AbsoluteAddress(jit.vm()->addressOfStackLimit()), scratchGPR2));
     85    slowCase.append(jit.branchPtr(CCallHelpers::Above, CCallHelpers::AbsoluteAddress(jit.vm()->addressOfJSCPUStackLimit()), scratchGPR2));
    8686
    8787    // Initialize ArgumentCount.
  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r202633 r202862  
    485485
    486486#if ENABLE(JIT)
    487     dataLogF("Current end is at %p.\n", exec->vm().stackLimit());
     487    dataLogF("Current end is at %p.\n", exec->vm().jsCPUStackLimit());
    488488#else
    489     dataLogF("Current end is at %p.\n", exec->vm().jsStackLimit());
     489    dataLogF("Current end is at %p.\n", exec->vm().jsEmulatedStackLimit());
    490490#endif
    491491
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r202633 r202862  
    952952    subp cfr, t0, t0
    953953    loadp CodeBlock::m_vm[t1], t2
    954     bpbeq VM::m_jsStackLimit[t2], t0, .stackHeightOK
     954    bpbeq VM::m_llintStackLimit[t2], t0, .stackHeightOK
    955955
    956956    # Stack height check failed - need to call a slow_path.
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r202680 r202862  
    153153    # and the frame for the JS code we're executing. We need to do this check
    154154    # before we start copying the args from the protoCallFrame below.
    155     bpaeq t3, VM::m_jsStackLimit[vm], .stackHeightOK
     155    bpaeq t3, VM::m_llintStackLimit[vm], .stackHeightOK
    156156
    157157    if C_LOOP
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r202680 r202862  
    141141    # and the frame for the JS code we're executing. We need to do this check
    142142    # before we start copying the args from the protoCallFrame below.
    143     bpaeq t3, VM::m_jsStackLimit[vm], .stackHeightOK
     143    bpaeq t3, VM::m_llintStackLimit[vm], .stackHeightOK
    144144
    145145    if C_LOOP
  • trunk/Source/JavaScriptCore/runtime/RegExp.cpp

    r201412 r202862  
    223223{
    224224    Base::finishCreation(vm);
    225     Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm.stackLimit());
     225    Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm.jsCPUStackLimit());
    226226    if (m_constructionError)
    227227        m_state = ParseError;
     
    265265    ConcurrentJITLocker locker(m_lock);
    266266   
    267     Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm->stackLimit());
     267    Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm->jsCPUStackLimit());
    268268    if (m_constructionError) {
    269269        RELEASE_ASSERT_NOT_REACHED();
     
    318318    ConcurrentJITLocker locker(m_lock);
    319319   
    320     Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm->stackLimit());
     320    Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm->jsCPUStackLimit());
    321321    if (m_constructionError) {
    322322        RELEASE_ASSERT_NOT_REACHED();
  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r202588 r202862  
    186186#endif
    187187    , m_stackPointerAtVMEntry(0)
    188     , m_stackLimit(0)
    189 #if !ENABLE(JIT)
    190     , m_jsStackLimit(0)
    191 #endif
    192188    , m_codeCache(std::make_unique<CodeCache>())
    193189    , m_builtinExecutables(std::make_unique<BuiltinExecutables>(*this))
     
    655651{
    656652#if PLATFORM(WIN)
    657     void* lastStackLimit = m_stackLimit;
     653    void* lastJSCPUStackLimit = m_jsCPUStackLimit;
    658654#endif
    659655
     
    661657        ASSERT(wtfThreadData().stack().isGrowingDownward());
    662658        char* startOfStack = reinterpret_cast<char*>(m_stackPointerAtVMEntry);
    663         m_stackLimit = wtfThreadData().stack().recursionLimit(startOfStack, Options::maxPerThreadStackUsage(), m_reservedZoneSize);
     659        m_jsCPUStackLimit = wtfThreadData().stack().recursionLimit(startOfStack, Options::maxPerThreadStackUsage(), m_reservedZoneSize);
    664660    } else {
    665         m_stackLimit = wtfThreadData().stack().recursionLimit(m_reservedZoneSize);
     661        m_jsCPUStackLimit = wtfThreadData().stack().recursionLimit(m_reservedZoneSize);
    666662    }
    667663
    668664#if PLATFORM(WIN)
    669     if (lastStackLimit != m_stackLimit)
    670         preCommitStackMemory(m_stackLimit);
     665    if (lastJSCPUStackLimit != m_jsCPUStackLimit)
     666        preCommitStackMemory(m_jsCPUStackLimit);
    671667#endif
    672668}
  • trunk/Source/JavaScriptCore/runtime/VM.h

    r202027 r202862  
    462462    size_t updateReservedZoneSize(size_t reservedZoneSize);
    463463
     464    void* jsCPUStackLimit() { return m_jsCPUStackLimit; }
     465    void** addressOfJSCPUStackLimit() { return &m_jsCPUStackLimit; }
    464466#if !ENABLE(JIT)
    465     void* jsStackLimit() { return m_jsStackLimit; }
    466     void setJSStackLimit(void* limit) { m_jsStackLimit = limit; }
    467 #endif
    468     void* stackLimit() { return m_stackLimit; }
    469     void** addressOfStackLimit() { return &m_stackLimit; }
     467    void* jsEmulatedStackLimit() { return m_jsEmulatedStackLimit; }
     468    void setJSEmulatedStackLimit(void* limit) { m_jsEmulatedStackLimit = limit; }
     469#endif
    470470
    471471    bool isSafeToRecurse(size_t neededStackInBytes = 0) const
     
    473473        ASSERT(wtfThreadData().stack().isGrowingDownward());
    474474        int8_t* curr = reinterpret_cast<int8_t*>(&curr);
    475         int8_t* limit = reinterpret_cast<int8_t*>(m_stackLimit);
     475        int8_t* limit = reinterpret_cast<int8_t*>(m_jsCPUStackLimit);
    476476        return curr >= limit && static_cast<size_t>(curr - limit) >= neededStackInBytes;
    477477    }
     
    643643    const ClassInfo* m_initializingObjectClass;
    644644#endif
     645
    645646    void* m_stackPointerAtVMEntry;
    646647    size_t m_reservedZoneSize;
    647 #if !ENABLE(JIT)
    648     struct {
    649         void* m_stackLimit;
    650         void* m_jsStackLimit;
     648#if ENABLE(JIT)
     649    union {
     650        void* m_jsCPUStackLimit { nullptr };
     651        void* m_llintStackLimit;
    651652    };
    652653#else
     654    void* m_jsCPUStackLimit { nullptr };
    653655    union {
    654         void* m_stackLimit;
    655         void* m_jsStackLimit;
     656        void* m_jsEmulatedStackLimit { nullptr };
     657        void* m_llintStackLimit;
    656658    };
    657659#endif
    658660    void* m_lastStackTop;
     661
    659662    Exception* m_exception { nullptr };
    660663    Exception* m_lastException { nullptr };
  • trunk/Source/JavaScriptCore/wasm/WASMFunctionCompiler.h

    r200879 r202862  
    11/*
    2  * Copyright (C) 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    136136
    137137        addPtr(TrustedImm32(-m_calleeSaveSpace - WTF::roundUpToMultipleOf(stackAlignmentRegisters(), m_stackHeight) * sizeof(StackSlot) - maxFrameExtentForSlowPathCall), GPRInfo::callFrameRegister, GPRInfo::regT1);
    138         m_stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfStackLimit()), GPRInfo::regT1);
     138        m_stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSCPUStackLimit()), GPRInfo::regT1);
    139139
    140140        move(GPRInfo::regT1, stackPointerRegister);
Note: See TracChangeset for help on using the changeset viewer.