ChangeLog

2014-06-23  peavo@outlook.com  <peavo@outlook.com>

        [Win64] ASM LLINT is not enabled.

        https://bugs.webkit.org/show_bug.cgi?id=130638

        This patch adds a new LLINT assembler backend for Win64, and implements it.

        It makes adjustments to follow the Win64 ABI spec. where it's found to be needed.

        Also, LLINT and JIT is enabled for Win64.

        Reviewed by NOBODY (OOPS!).

        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj: Added JITStubsMSVC64.asm.

        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters: Ditto.

        * JavaScriptCore/JavaScriptCore.vcxproj/jsc/jscCommon.props: Increased stack size to avoid stack overflow in tests.

        * JavaScriptCore.vcxproj/LLInt/LLIntAssembly/build-LLIntAssembly.sh: Generate assembler source file for Win64.

        * assembler/MacroAssemblerX86_64.h: 

        (JSC::MacroAssemblerX86_64::call): Follow Win64 ABI spec.

        * jit/CCallHelpers.h: Ditto.

        * jit/JITStubsMSVC64.asm: Added.

        * jit/Repatch.cpp:

        (JSC::emitPutTransitionStub): Compile fix.

        * jit/ThunkGenerators.cpp:

        (JSC::nativeForGenerator): Follow Win64 ABI spec.

        * llint/LLIntData.cpp:

        (JSC::LLInt::Data::performAssertions): Ditto.

        * llint/LLIntOfflineAsmConfig.h: Enable new llint backend for Win64.

        * llint/LowLevelInterpreter.asm: Implement new Win64 backend, and follow Win64 ABI spec.

        * llint/LowLevelInterpreter64.asm: Ditto.

        * offlineasm/asm.rb: Compile fix.

        * offlineasm/backends.rb: Add new llint backend for Win64.

        * offlineasm/settings.rb: Compile fix.

        * offlineasm/x86.rb: Implement new llint Win64 backend.

2014-06-20  Sam Weinig  <sam@webkit.org>

        Remove static tables for bindings that use eager reification

170309

Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

      <UseSafeExceptionHandlers Condition="'$(Configuration)|$(Platform)'=='Debug_WinCairo|Win32'">true</UseSafeExceptionHandlers>

      <UseSafeExceptionHandlers Condition="'$(Configuration)|$(Platform)'=='Release_WinCairo|Win32'">true</UseSafeExceptionHandlers>

    </MASM>

    <MASM Include="..\jit\JITStubsMSVC64.asm">

      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug_WinCairo|Win32'">true</ExcludedFromBuild>

      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>

      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugSuffix|Win32'">true</ExcludedFromBuild>

      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release_WinCairo|Win32'">true</ExcludedFromBuild>

      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|Win32'">true</ExcludedFromBuild>

      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>

    </MASM>

  </ItemGroup>

  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

  <ImportGroup Label="ExtensionTargets">

    <Import Project="$(VCTargetsPath)\BuildCustomizations\masm.targets" />

  </ImportGroup>

1599 </Project>

1607</Project>

170309

Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters

  </ItemGroup>

  <ItemGroup>

    <MASM Include="$(ConfigurationBuildDir)\obj$(PlatformArchitecture)\$(ProjectName)\DerivedSources\LowLevelInterpreterWin.asm" />

    <MASM Include="..\jit\JITStubsMSVC64.asm">

      <Filter>jit</Filter>

    </MASM>

37173720 </ItemGroup>

3718 </Project>

3721</Project>

170309

Source/JavaScriptCore/JavaScriptCore.vcxproj/LLInt/LLIntAssembly/build-LLIntAssembly.sh

@@cd "${BUILT_PRODUCTS_DIR}/JavaScriptCore

printf "END" > LowLevelInterpreterWin.asm

28 # Win32 is using the LLINT x86 backend, and should generate an assembler file.

29 # Win64 is using the LLINT C backend, and should generate a header file.

28# If you want to enable the LLINT C loop, set OUTPUTFILENAME to "LLIntAssembly.h"

3029

if [ "${PLATFORMARCHITECTURE}" == "32" ]; then

    OUTPUTFILENAME="LowLevelInterpreterWin.asm"

else

    OUTPUTFILENAME="LLIntAssembly.h"

fi

30OUTPUTFILENAME="LowLevelInterpreterWin.asm"

3631

3732/usr/bin/env ruby "${SRCROOT}/offlineasm/asm.rb" "-I." "${SRCROOT}/llint/LowLevelInterpreter.asm" "${BUILT_PRODUCTS_DIR}/LLIntOffsetsExtractor/LLIntOffsetsExtractor${3}.exe" "${OUTPUTFILENAME}" || exit 1

170309

Source/JavaScriptCore/JavaScriptCore.vcxproj/jsc/jscCommon.props

      <ModuleDefinitionFile>

      </ModuleDefinitionFile>

      <SubSystem>Console</SubSystem>

19 <StackReserveSize>2097152</StackReserveSize>

    </Link>

  </ItemDefinitionGroup>

  <ItemGroup />

170309

Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h

@@public:

    Call call()

    {

#if OS(WINDOWS)

        // JIT relies on the CallerFrame (frame pointer) being put on the stack,

        // On Win64 we need to manually copy the frame pointer to the stack, since MSVC may not maintain a frame pointer on 64-bit.

        // See http://msdn.microsoft.com/en-us/library/9z1stfyw.aspx where it's stated that rbp MAY be used as a frame pointer.

        store64(X86Registers::ebp, Address(X86Registers::esp, -16));

        // We also need to allocate the shadow space on the stack for the 4 parameter registers.

        // Also, we should allocate 16 bytes for the frame pointer, and return address (not populated).

        // In addition, we need to allocate 16 bytes for two more parameters, since the call can have up to 6 parameters.

        // Note: POKE_ARGUMENT_OFFSET is adjusted accordingly.

        sub64(TrustedImm32(8 * sizeof(int64_t)), X86Registers::esp);

#endif

156168 DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);

157169 Call result = Call(m_assembler.call(scratchRegister), Call::Linkable);

#if OS(WINDOWS)

        add64(TrustedImm32(8 * sizeof(int64_t)), X86Registers::esp);

#endif

        ASSERT_UNUSED(label, differenceBetween(label, result) == REPTACH_OFFSET_CALL_R11);

        return result;

    }

170309

Source/JavaScriptCore/jit/CCallHelpers.h

@@public:

        setupThreeStubArgsGPR<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg1, arg2, arg3);

    }

782 #if CPU(MIPS) ~~|| (OS(WINDOWS) && CPU(X86_64))~~

782#if CPU(MIPS)

783783#define POKE_ARGUMENT_OFFSET 4

784#elif CPU(X86_64) && OS(WINDOWS)

785#define POKE_ARGUMENT_OFFSET -4

#else

#define POKE_ARGUMENT_OFFSET 0

#endif

170309

Source/JavaScriptCore/jit/JITStubsMSVC64.asm

;/*

; Copyright (C) 2014 Apple Inc. All rights reserved.

;

; Redistribution and use in source and binary forms, with or without

; modification, are permitted provided that the following conditions

; are met:

; 1. Redistributions of source code must retain the above copyright

;    notice, this list of conditions and the following disclaimer.

; 2. Redistributions in binary form must reproduce the above copyright

;    notice, this list of conditions and the following disclaimer in the

;    documentation and/or other materials provided with the distribution.

;

; THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

; PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

; OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

;*/

EXTERN getHostCallReturnValueWithExecState : near

PUBLIC getHostCallReturnValue

_TEXT   SEGMENT

getHostCallReturnValue PROC

    mov rcx, rbp

    ; Allocate space for all 4 parameter registers, and align stack pointer to 16 bytes boundary by allocating another 8 bytes.

    ; The stack alignment is needed to fix a crash in the CRT library on a floating point instruction.

    sub rsp, 40

    call getHostCallReturnValueWithExecState

    add rsp, 40

    ret

getHostCallReturnValue ENDP

_TEXT   ENDS

END

0

Source/JavaScriptCore/jit/Repatch.cpp

@@static void emitPutTransitionStub(

    ASSERT(oldStructure->typeInfo().type() == structure->typeInfo().type());

    ASSERT(oldStructure->typeInfo().inlineTypeFlags() == structure->typeInfo().inlineTypeFlags());

    ASSERT(oldStructure->indexingType() == structure->indexingType());

1085 stubJit.store32(MacroAssembler::TrustedImm32(reinterpret_cast<uint32_t>(structure->id())), MacroAssembler::Address(baseGPR, JSCell::structureIDOffset()));

#if USE(JSVALUE64)

    uint32_t val = structure->id();

#else

    uint32_t val = reinterpret_cast<uint32_t>(structure->id());

#endif

    stubJit.store32(MacroAssembler::TrustedImm32(val), MacroAssembler::Address(baseGPR, JSCell::structureIDOffset()));

#if USE(JSVALUE64)

    if (isInlineOffset(slot.cachedOffset()))

        stubJit.store64(valueGPR, MacroAssembler::Address(baseGPR, JSObject::offsetOfInlineStorage() + offsetInInlineStorage(slot.cachedOffset()) * sizeof(JSValue)));

170309

Source/JavaScriptCore/jit/ThunkGenerators.cpp

@@static MacroAssemblerCodeRef nativeForGe

    // Host function signature: f(ExecState*);

    jit.move(JSInterfaceJIT::callFrameRegister, X86Registers::ecx);

318 // Leave space for the callee parameter home addresses and align the stack.

319 jit.subPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t) + 16 - sizeof(int64_t)), JSInterfaceJIT::stackPointerRegister);

    // Leave space for the callee parameter home addresses.

    // At this point the stack is aligned to 16 bytes, but if this changes at some point, we need to emit code to align it.

    jit.subPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t)), JSInterfaceJIT::stackPointerRegister);

    jit.emitGetFromCallFrameHeaderPtr(JSStack::Callee, X86Registers::edx);

    jit.loadPtr(JSInterfaceJIT::Address(X86Registers::edx, JSFunction::offsetOfExecutable()), X86Registers::r9);

    jit.call(JSInterfaceJIT::Address(X86Registers::r9, executableOffsetToFunction));

325 jit.addPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t) ~~+ 16 - sizeof(int64_t)~~), JSInterfaceJIT::stackPointerRegister);

326 jit.addPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t)), JSInterfaceJIT::stackPointerRegister);

#endif

#elif CPU(ARM64)

@@static MacroAssemblerCodeRef nativeForGe

    jit.loadPtr(JSInterfaceJIT::Address(JSInterfaceJIT::callFrameRegister), JSInterfaceJIT::regT0);

    jit.push(JSInterfaceJIT::regT0);

#else

#if OS(WINDOWS)

    // Allocate space on stack for the 4 parameter registers.

    jit.subPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t)), JSInterfaceJIT::stackPointerRegister);

#endif

    jit.loadPtr(JSInterfaceJIT::Address(JSInterfaceJIT::callFrameRegister), JSInterfaceJIT::argumentGPR0);

#endif

    jit.move(JSInterfaceJIT::TrustedImmPtr(FunctionPtr(operationVMHandleException).value()), JSInterfaceJIT::regT3);

    jit.call(JSInterfaceJIT::regT3);

#if CPU(X86) && USE(JSVALUE32_64)

    jit.addPtr(JSInterfaceJIT::TrustedImm32(16), JSInterfaceJIT::stackPointerRegister);

412#elif OS(WINDOWS)

413 jit.addPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t)), JSInterfaceJIT::stackPointerRegister);

#endif

    jit.jumpToExceptionHandler();

170309

Source/JavaScriptCore/llint/LLIntData.cpp

@@void Data::performAssertions(VM& vm)

    ASSERT(ValueUndefined == (TagBitTypeOther | TagBitUndefined));

    ASSERT(ValueNull == TagBitTypeOther);

#endif

126 #if CPU(X86_64) || CPU(ARM64) || !ENABLE(JIT)

126#if (CPU(X86_64) && !OS(WINDOWS)) || CPU(ARM64) || !ENABLE(JIT)

    ASSERT(!maxFrameExtentForSlowPathCall);

#elif CPU(ARM) || CPU(SH4)

    ASSERT(maxFrameExtentForSlowPathCall == 24);

#elif CPU(X86) || CPU(MIPS)

    ASSERT(maxFrameExtentForSlowPathCall == 40);

132#elif CPU(X86_64) && OS(WINDOWS)

133 ASSERT(maxFrameExtentForSlowPathCall == 64);

#endif

    ASSERT(StringType == 5);

    ASSERT(ObjectType == 18);

170309

Source/JavaScriptCore/llint/LLIntOfflineAsmConfig.h

#define OFFLINE_ASM_ARMv7_TRADITIONAL 0

#define OFFLINE_ASM_ARM64 0

#define OFFLINE_ASM_X86_64 0

42#define OFFLINE_ASM_X86_64_WIN 0

#define OFFLINE_ASM_ARMv7s 0

#define OFFLINE_ASM_MIPS 0

#define OFFLINE_ASM_SH4 0

#define OFFLINE_ASM_ARM 0

#endif

87 #if CPU(X86_64)

88#if CPU(X86_64) && !PLATFORM(WIN)

#define OFFLINE_ASM_X86_64 1

#else

#define OFFLINE_ASM_X86_64 0

#endif

#if CPU(X86_64) && PLATFORM(WIN)

#define OFFLINE_ASM_X86_64_WIN 1

#else

#define OFFLINE_ASM_X86_64_WIN 0

#endif

#if CPU(MIPS)

#define OFFLINE_ASM_MIPS 1

#else

170309

Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

@@macro cCall2(function, arg1, arg2)

        move arg1, t4

        move arg2, t5

        call function

    elsif X86_64_WIN

        # Note: this implementation is only correct if the return type size is > 8 bytes.

        # See macro cCall2Void for an implementation when the return type <= 8 bytes.

        # On Win64, when the return type is larger than 8 bytes, we need to allocate space on the stack for the return value.

        # On entry rcx (t2), should contain a pointer to this stack space. The other parameters are shifted to the right,

        # rdx (t1) should contain the first argument, and r8 (t6) should contain the second argument.

        # On return, rax contains a pointer to this stack value, and we then need to copy the 16 byte return value into rax (t0) and rdx (t1)

        # since the return value is expected to be split between the two.

        # See http://msdn.microsoft.com/en-us/library/7572ztz4.aspx

        move arg1, t1

        move arg2, t6

        subp 48, sp

        move sp, t2

        addp 32, t2

        call function

        addp 48, sp

        move 8[t0], t1

        move [t0], t0

    elsif ARM64

        move arg1, t0

        move arg2, t1

@@end

macro cCall2Void(function, arg1, arg2)

    if C_LOOP

        cloopCallSlowPathVoid function, arg1, arg2

    elsif X86_64_WIN

        # Note: we cannot use the cCall2 macro for Win64 in this case,

        # as the Win64 cCall2 implemenation is only correct when the return type size is > 8 bytes.

        # On Win64, rcx and rdx are used for passing the first two parameters.

        # We also need to make room on the stack for all four parameter registers.

        # See http://msdn.microsoft.com/en-us/library/ms235286.aspx

        move arg2, t1

        move arg1, t2

        subp 32, sp 

        call function

        addp 32, sp

    else

        cCall2(function, arg1, arg2)

    end

@@macro cCall4(function, arg1, arg2, arg3,

        move arg3, t1

        move arg4, t2

        call function

    elsif X86_64_WIN

        # On Win64, rcx, rdx, r8, and r9 are used for passing the first four parameters.

        # We also need to make room on the stack for all four parameter registers.

        # See http://msdn.microsoft.com/en-us/library/ms235286.aspx

        move arg1, t2

        move arg2, t1

        move arg3, t6

        move arg4, t7

        subp 32, sp 

        call function

        addp 32, sp

    elsif ARM64

        move arg1, t0

        move arg2, t1

@@macro doCallToJavaScript(makeCall)

        const temp1 = t0

        const temp2 = t3

        const temp3 = t6

    elsif X86_64_WIN

        const entry = t2

        const vm = t1

        const protoCallFrame = t6

        const previousCFR = t0

        const previousPC = t4

        const temp1 = t0

        const temp2 = t3

        const temp3 = t7

    elsif ARM64 or C_LOOP

        const entry = a0

        const vm = a1

@@macro doCallToJavaScript(makeCall)

    if X86_64

        loadp 7*8[sp], previousPC

        move 6*8[sp], previousCFR

    elsif X86_64_WIN

        # Win64 pushes two more registers

        loadp 9*8[sp], previousPC

        move 8*8[sp], previousCFR

    elsif ARM64

        move cfr, previousCFR

    end

@@macro doCallToJavaScript(makeCall)

    loadp VM::topCallFrame[vm], temp2

    storep temp2, ScopeChain[cfr]

    storep 1, CodeBlock[cfr]

    if X86_64

        loadp 7*8[sp], previousPC

        loadp 6*8[sp], previousCFR

    end

199

    storep previousPC, ReturnPC[cfr]

    storep previousCFR, CallerFrame[cfr]

@@macro doCallToJavaScript(makeCall)

    checkStackPointerAlignment(temp3, 0xbad0dc04)

241 if X86_64

292 if X86_64 or X86_64_WIN

        pop t5

    end

    callToJavaScriptEpilogue()

@@macro makeHostFunctionCall(entry, temp)

    move entry, temp

    if X86_64

        move sp, t4

316 elsif X86_64_WIN

317 move sp, t2

    elsif ARM64 or C_LOOP

        move sp, a0

    end

@@macro makeHostFunctionCall(entry, temp)

        storep cfr, [sp]

        storep lr, 8[sp]

        cloopCallNative temp

    elsif X86_64_WIN

        # For a host function call, JIT relies on that the CallerFrame (frame pointer) is put on the stack,

        # On Win64 we need to manually copy the frame pointer to the stack, since MSVC may not maintain a frame pointer on 64-bit.

        # See http://msdn.microsoft.com/en-us/library/9z1stfyw.aspx where it's stated that rbp MAY be used as a frame pointer.

        storep cfr, [sp]

        # We need to allocate 32 bytes on the stack for the shadow space.

        subp 32, sp

        call temp

        addp 32, sp

272335 else

273 addp 16, sp

336 addp 16, sp

        call temp

        subp 16, sp

    end

@@_llint_op_sub:

_llint_op_div:

    traceExecution()

960 if X86_64

1023 if X86_64 or X86_64_WIN

        binaryOpCustomStore(

            macro (left, right, slow, index)

                # Assume t3 is scratchable.

@@macro putById(getPropertyStorage)

            storeq scratch, [propertyStorage, t1]

            dispatch(9)

        end)

    .opPutByIdSlow:

        callSlowPath(_llint_slow_path_put_by_id)

        dispatch(9)

end

_llint_op_put_by_id:

    putById(withInlineStorage)

.opPutByIdSlow:

    callSlowPath(_llint_slow_path_put_by_id)

    dispatch(9)

_llint_op_put_by_id_out_of_line:

    putById(withOutOfLineStorage)

@@macro putByIdTransition(additionalChecks

    loadConstantOrVariableCell(t3, t0, .opPutByIdSlow)

    loadStructureWithScratch(t0, t2, t3)

    bpneq t2, t1, .opPutByIdSlow

1321 additionalChecks(t1, t3, t2)

1385 additionalChecks(t1, t3, t2, .opPutByIdSlow)

    loadisFromInstruction(3, t2)

    loadisFromInstruction(5, t1)

    getPropertyStorage(

@@macro putByIdTransition(additionalChecks

            storei t1, JSCell::m_structureID[t0]

            dispatch(9)

        end)

    .opPutByIdSlow:

        callSlowPath(_llint_slow_path_put_by_id)

        dispatch(9)

13361405end

13371406

1338 macro noAdditionalChecks(oldStructure, scratch, scratch2)

1407macro noAdditionalChecks(oldStructure, scratch, scratch2, slowPath)

13391408end

13401409

1341 macro structureChainChecks(oldStructure, scratch, scratch2)

1410macro structureChainChecks(oldStructure, scratch, scratch2, slowPath)

    const protoCell = oldStructure    # Reusing the oldStructure register for the proto

    loadpFromInstruction(7, scratch)

    assert(macro (ok) btpnz scratch, ok end)

@@macro structureChainChecks(oldStructure,

    loadq Structure::m_prototype[oldStructure], protoCell

    loadStructureAndClobberFirstArg(protoCell, scratch2)

    move scratch2, oldStructure

1352 bpneq oldStructure, [scratch], ~~.opPutByIdS~~low

1421 bpneq oldStructure, [scratch], slowPath

    addp 8, scratch

    bqneq Structure::m_prototype[oldStructure], ValueNull, .loop

.done:

@@macro nativeCallTrampoline(executableOff

    functionPrologue()

    storep 0, CodeBlock[cfr]

1971 if X86_64

    if X86_64 or X86_64_WIN

        if X86_64

            const arg1 = t4  # t4 = rdi

            const arg2 = t5  # t5 = rsi

            const temp = t1

        elsif X86_64_WIN

            const arg1 = t2  # t2 = rcx

            const arg2 = t1  # t1 = rdx

            const temp = t0

        end

        loadp ScopeChain[cfr], t0

        andp MarkedBlockMask, t0

        loadp MarkedBlock::m_weakSet + WeakSet::m_vm[t0], t0

@@macro nativeCallTrampoline(executableOff

        loadp CallerFrame[cfr], t0

        loadq ScopeChain[t0], t1

        storeq t1, ScopeChain[cfr]

        move cfr, t4  # t4 = rdi

        loadp Callee[cfr], t5 # t5 = rsi

        loadp JSFunction::m_executable[t5], t1

        move cfr, arg1

        loadp Callee[cfr], arg2

        loadp JSFunction::m_executable[arg2], temp

19822060 checkStackPointerAlignment(t3, 0xdead0001)

1983 call executableOffsetToFunction[t1]

        if X86_64_WIN

            subp 32, sp

        end

        call executableOffsetToFunction[temp]

        if X86_64_WIN

            addp 32, sp

        end

        loadp ScopeChain[cfr], t3

        andp MarkedBlockMask, t3

        loadp MarkedBlock::m_weakSet + WeakSet::m_vm[t3], t3

170309

Source/JavaScriptCore/llint/LowLevelInterpreter.asm

@@elsif X86 or X86_WIN

const maxFrameExtentForSlowPathCall = 40

elsif MIPS

const maxFrameExtentForSlowPathCall = 40

87elsif X86_64_WIN

88const maxFrameExtentForSlowPathCall = 64

end

# Watchpoint states

@@macro preserveCallerPCAndCFR()

    if C_LOOP or ARM or ARMv7 or ARMv7_TRADITIONAL or MIPS or SH4

        push lr

        push cfr

251 elsif X86 or X86_WIN or X86_64

253 elsif X86 or X86_WIN or X86_64 or X86_64_WIN

        push cfr

    elsif ARM64

        pushLRAndFP

@@macro restoreCallerPCAndCFR()

    if C_LOOP or ARM or ARMv7 or ARMv7_TRADITIONAL or MIPS or SH4

        pop cfr

        pop lr

266 elsif X86 or X86_WIN or X86_64

268 elsif X86 or X86_WIN or X86_64 or X86_64_WIN

        pop cfr

    elsif ARM64

        popLRAndFP

@@macro preserveReturnAddressAfterCall(des

    if C_LOOP or ARM or ARMv7 or ARMv7_TRADITIONAL or ARM64 or MIPS or SH4

        # In C_LOOP case, we're only preserving the bytecode vPC.

        move lr, destinationRegister

277 elsif X86 or X86_WIN or X86_64

279 elsif X86 or X86_WIN or X86_64 or X86_64_WIN

        pop destinationRegister

    else

        error

@@macro restoreReturnAddressBeforeReturn(s

    if C_LOOP or ARM or ARMv7 or ARMv7_TRADITIONAL or ARM64 or MIPS or SH4

        # In C_LOOP case, we're only restoring the bytecode vPC.

        move sourceRegister, lr

288 elsif X86 or X86_WIN or X86_64

290 elsif X86 or X86_WIN or X86_64 or X86_64_WIN

        push sourceRegister

    else

        error

@@macro restoreReturnAddressBeforeReturn(s

end

macro functionPrologue()

296 if X86 or X86_WIN or X86_64

298 if X86 or X86_WIN or X86_64 or X86_64_WIN

        push cfr

    elsif ARM64

        pushLRAndFP

@@macro functionPrologue()

end

macro functionEpilogue()

308 if X86 or X86_WIN or X86_64

310 if X86 or X86_WIN or X86_64 or X86_64_WIN

        pop cfr

    elsif ARM64

        popLRAndFP

@@macro functionEpilogue()

end

macro callToJavaScriptPrologue()

319 if X86_64

321 if X86_64 or X86_64_WIN

        push cfr

        push t0

    elsif X86 or X86_WIN

@@macro callToJavaScriptEpilogue()

    end

    popCalleeSaves

374 if X86_64

376 if X86_64 or X86_64_WIN

        pop t2

        pop cfr

    elsif X86 or X86_WIN

@@_sanitizeStackForVMImpl:

        const vm = t4

        const address = t1

        const zeroValue = t0

    elsif X86_64_WIN

        const vm = t2

        const address = t1

        const zeroValue = t0

    elsif X86 or X86_WIN

        const vm = t2

        const address = t1

@@_llint_entry:

    crash()

else

macro initPCRelative(pcBase)

695 if X86_64

701 if X86_64 or X86_64_WIN

        call _relativePCBase

    _relativePCBase:

        pop pcBase

@@macro setEntryAddress(index, label)

        leap (label - _relativePCBase)[t1], t0

        move index, t2

        storep t0, [t4, t2, 8]

    elsif X86_64_WIN

        leap (label - _relativePCBase)[t1], t0

        move index, t4

        storep t0, [t2, t4, 8]

    elsif X86 or X86_WIN

        leap (label - _relativePCBase)[t1], t0

        move index, t2

170309

Source/JavaScriptCore/offlineasm/asm.rb

@@class Assembler

            @codeOrigin = nil

            @commentState = :many

        when :many

265 @outp.puts ~~"//~~ #{text}" if $enableCodeOriginComments

265 @outp.puts $commentPrefix + " #{text}" if $enableCodeOriginComments

        else

            raise

        end

170309

Source/JavaScriptCore/offlineasm/backends.rb

@@BACKENDS =

     "X86",

     "X86_WIN",

     "X86_64",

38 "X86_64_WIN",

     "ARM",

     "ARMv7",

     "ARMv7_TRADITIONAL",

@@WORKING_BACKENDS =

     "X86",

     "X86_WIN",

     "X86_64",

58 "X86_64_WIN",

     "ARM",

     "ARMv7",

     "ARMv7_TRADITIONAL",

170309

Source/JavaScriptCore/offlineasm/settings.rb

@@def emitCodeInConfiguration(concreteSett

    if !$emitWinAsm

        $output.puts cppSettingsTest(concreteSettings)

    else

180 $output.puts ".MODEL FLAT, C"

        if backend == "X86_WIN"

            $output.puts ".MODEL FLAT, C"

        end

        $output.puts "INCLUDE #{File.basename($output.path)}.sym"

        $output.puts "_TEXT SEGMENT"

    end

170309

Source/JavaScriptCore/offlineasm/x86.rb

@@def isX64

        false

    when "X86_64"

        true

35 when "X86_64_WIN"

36 true

    else

        raise "bad value for $activeBackend: #{$activeBackend}"

    end

@@def useX87

        true

    when "X86_64"

        false

50 when "X86_64_WIN"

51 false

    else

        raise "bad value for $activeBackend: #{$activeBackend}"

    end

@@def getSizeString(kind)

    when :int

        size = "dword"

    when :ptr

103 size = "dword"

107 size = isX64 ? "qword" : "dword"

104108 when :double

105109 size = "qword"

110 when :quad

111 size = "qword"

106112 else

107 raise

113 raise "Invalid kind #{kind}"

    end

    return size + " " + "ptr" + " ";

@@class SpecialRegister < NoChildren

        raise unless isX64

        case kind

        when :half

119 ~~"%" +~~ @name + "w"

125 register(@name + "w")

120126 when :int

121 ~~"%" +~~ @name + "d"

127 register(@name + "d")

122128 when :ptr

123 ~~"%" +~~ @name

129 register(@name)

124130 when :quad

125 ~~"%" +~~ @name

131 register(@name)

        else

            raise

        end

@@class RegisterID

            raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

            case kind

            when :half

287 "%r8w"

293 register("r8w")

288294 when :int

289 "%r8d"

295 register("r8d")

290296 when :ptr

291 "%r8"

297 register("r8")

292298 when :quad

293 "%r8"

299 register("r8")

            end

        when "t7"

            raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

            case kind

            when :half

299 "%r9w"

305 register("r9w")

300306 when :int

301 "%r9d"

307 register("r9d")

302308 when :ptr

303 "%r9"

309 register("r9")

304310 when :quad

305 "%r9"

311 register("r9")

            end

        when "csr1"

            raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

            case kind

            when :half

311 "%r14w"

317 register("r14w")

312318 when :int

313 "%r14d"

319 register("r14d")

314320 when :ptr

315 "%r14"

321 register("r14")

316322 when :quad

317 "%r14"

323 register("r14")

            end

        when "csr2"

            raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

            case kind

            when :half

323 "%r15w"

329 register("r15w")

324330 when :int

325 "%r15d"

331 register("r15d")

326332 when :ptr

327 "%r15"

333 register("r15")

328334 when :quad

329 "%r15"

335 register("r15")

            end

        else

            raise "Bad register #{name} for X86 at #{codeOriginString}"

@@class FPRegisterID

        raise if useX87

        case name

        when "ft0", "fa0", "fr"

346 "%xmm0"

352 register("xmm0")

347353 when "ft1", "fa1"

348 "%xmm1"

354 register("xmm1")

349355 when "ft2", "fa2"

350 "%xmm2"

356 register("xmm2")

351357 when "ft3", "fa3"

352 "%xmm3"

358 register("xmm3")

353359 when "ft4"

354 "%xmm4"

360 register("xmm4")

355361 when "ft5"

356 "%xmm5"

362 register("xmm5")

        else

            raise "Bad register #{name} for X86 at #{codeOriginString}"

        end

@@class Sequence

        
        return newList

    end

    def getModifiedListX86_64_WIN

        getModifiedListX86_64

    end

end

class Instruction

@@class Instruction

        else

            case mode

            when :normal

607 $asm.puts "ucomisd #{operands[1].x86Operand(:double)}~~, #{~~operands[0].x86Operand(:double)}"

616 $asm.puts "ucomisd #{orderOperands(operands[1].x86Operand(:double), operands[0].x86Operand(:double))}"

608617 when :reverse

609 $asm.puts "ucomisd #{operands[0].x86Operand(:double)}~~, #{~~operands[1].x86Operand(:double)}"

618 $asm.puts "ucomisd #{orderOperands(operands[0].x86Operand(:double), operands[1].x86Operand(:double))}"

            else

                raise mode.inspect

            end

@@class Instruction

        lowerX86Common

    end

    def lowerX86_64_WIN

        raise unless $activeBackend == "X86_64_WIN"

        lowerX86Common

    end

    def lowerX86Common

        $asm.codeOrigin codeOriginString if $enableCodeOriginComments

        $asm.annotation annotation if $enableInstrAnnotations

@@class Instruction

            $asm.puts "mov#{x86Suffix(:int)} #{x86Operands(:int, :int)}"

        when "loadis"

            if isX64

922 $asm.puts "movslq #{x86Operands(:int, :quad)}"

                if !isIntelSyntax

                    $asm.puts "movslq #{x86Operands(:int, :quad)}"

                else

                    $asm.puts "movsxd #{x86Operands(:int, :quad)}"

                end

            else

                $asm.puts "mov#{x86Suffix(:int)} #{x86Operands(:int, :int)}"

            end

@@class Instruction

                $asm.puts "fild#{x86Suffix(:ptr)} #{getSizeString(:ptr)}#{offsetRegister(-4, sp.x86Operand(:ptr))}"

                $asm.puts "fstp #{operands[1].x87Operand(1)}"

            else

1024 $asm.puts "cvtsi2sd #{operands[0].x86Operand(:int)}~~, #{~~operands[1].x86Operand(:double)}"

1042 $asm.puts "cvtsi2sd #{orderOperands(operands[0].x86Operand(:int), operands[1].x86Operand(:double))}"

            end

        when "bdeq"

            if useX87

                handleX87Compare(:normal)

            else

1030 $asm.puts "ucomisd #{operands[0].x86Operand(:double)}~~, #{~~operands[1].x86Operand(:double)}"

1048 $asm.puts "ucomisd #{orderOperands(operands[0].x86Operand(:double), operands[1].x86Operand(:double))}"

            end

            if operands[0] == operands[1]

                # This is just a jump ordered, which is a jnp.

@@class Instruction

            if useX87

                handleX87Compare(:normal)

            else

1057 $asm.puts "ucomisd #{operands[0].x86Operand(:double)}~~, #{~~operands[1].x86Operand(:double)}"

1075 $asm.puts "ucomisd #{orderOperands(operands[0].x86Operand(:double), operands[1].x86Operand(:double))}"

            end

            if operands[0] == operands[1]

                # This is just a jump unordered, which is a jp.

@@class Instruction

            }

        when "popCalleeSaves"

            if isX64

                $asm.puts "pop %rbx"

                $asm.puts "pop %r15"

                $asm.puts "pop %r14"

                $asm.puts "pop %r13"

                $asm.puts "pop %r12"

                if isMSVC

                    $asm.puts "pop " + register("rsi")

                    $asm.puts "pop " + register("rdi")

                end

                $asm.puts "pop " + register("rbx")

                $asm.puts "pop " + register("r15")

                $asm.puts "pop " + register("r14")

                $asm.puts "pop " + register("r13")

                $asm.puts "pop " + register("r12")

            else

                $asm.puts "pop " + register("ebx")

                $asm.puts "pop " + register("edi")

@@class Instruction

            end

        when "pushCalleeSaves"

            if isX64

                $asm.puts "push %r12"

                $asm.puts "push %r13"

                $asm.puts "push %r14"

                $asm.puts "push %r15"

                $asm.puts "push %rbx"

                $asm.puts "push " + register("r12")

                $asm.puts "push " + register("r13")

                $asm.puts "push " + register("r14")

                $asm.puts "push " + register("r15")

                $asm.puts "push " + register("rbx")

                if isMSVC

                    $asm.puts "push " + register("rdi")

                    $asm.puts "push " + register("rsi")

                end

            else

                $asm.puts "push " + register("esi")

                $asm.puts "push " + register("edi")

@@class Instruction

        when "move"

            handleMove

        when "sxi2q"

1158 $asm.puts "movslq #{operands[0].x86Operand(:int)}, #{operands[1].x86Operand(:quad)}"

            if !isIntelSyntax

                $asm.puts "movslq #{operands[0].x86Operand(:int)}, #{operands[1].x86Operand(:quad)}"

            else

                $asm.puts "movsxd #{orderOperands(operands[0].x86Operand(:int), operands[1].x86Operand(:quad))}"

            end

        when "zxi2q"

            $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(operands[0].x86Operand(:int), operands[1].x86Operand(:int))}"

        when "nop"

@@class Instruction

        when "cdqi"

            $asm.puts "cdq"

        when "idivi"

1444 $asm.puts "idivl #{operands[0].x86Operand(:int)}"

1474 $asm.puts "idiv#{x86Suffix(:int)} #{operands[0].x86Operand(:int)}"

        when "fii2d"

            if useX87

                sp = RegisterID.new(nil, "sp")

@@class Instruction

                $asm.puts "fldl -8(#{sp.x86Operand(:ptr)})"

                $asm.puts "fstp #{operands[1].x87Operand(1)}"

            else

1482 $asm.puts "movq #{operands[0].x86Operand(:quad)}, #{operands[1].x86Operand(:double)}"

                if !isIntelSyntax

                    $asm.puts "movq #{operands[0].x86Operand(:quad)}, #{operands[1].x86Operand(:double)}"

                else

                    # MASM does not accept register operands with movq.

                    # Debugging shows that movd actually moves a qword when using MASM.

                    $asm.puts "movd #{operands[1].x86Operand(:double)}, #{operands[0].x86Operand(:quad)}"

                end

            end

        when "fd2q"

            if useX87

@@class Instruction

                end

                $asm.puts "movq -8(#{sp.x86Operand(:ptr)}), #{operands[1].x86Operand(:quad)}"

            else

1495 $asm.puts "movq #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:quad)}"

                if !isIntelSyntax

                    $asm.puts "movq #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:quad)}"

                else

                    # MASM does not accept register operands with movq.

                    # Debugging shows that movd actually moves a qword when using MASM.

                    $asm.puts "movd #{operands[1].x86Operand(:quad)}, #{operands[0].x86Operand(:double)}"

                end

            end

        when "bo"

            $asm.puts "jo #{operands[0].asmLabel}"

170309

Source/WTF/ChangeLog

2014-06-23  peavo@outlook.com  <peavo@outlook.com>

        [Win64] ASM LLINT is not enabled.

        https://bugs.webkit.org/show_bug.cgi?id=130638

        Reviewed by NOBODY (OOPS!).

        * wtf/Platform.h: Enable LLINT and JIT for Win64.

2014-06-21  Brady Eidson  <beidson@apple.com>

        Gamepad API - Deprecate the existing implementation

170309

Source/WTF/wtf/Platform.h

#if !defined(ENABLE_JIT) \

    && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)) \

    && !CPU(APPLE_ARMV7K)                                                           \

643 && !OS(WINCE) \

644 && !(OS(WINDOWS) && CPU(X86_64))

643 && !OS(WINCE)

#define ENABLE_JIT 1

#endif

170309