Changeset 198252 in webkit


Ignore:
Timestamp:
Mar 15, 2016 6:02:32 PM (8 years ago)
Author:
oliver@apple.com
Message:

Rename performJITMemcpy to something more inline with our normal webkit function names
​https://bugs.webkit.org/show_bug.cgi?id=155525

Reviewed by Saam Barati.

Simple bulk search/replace with a better name.

  • assembler/ARM64Assembler.h:

(JSC::ARM64Assembler::fillNops):
(JSC::ARM64Assembler::replaceWithJump):
(JSC::ARM64Assembler::replaceWithLoad):
(JSC::ARM64Assembler::replaceWithAddressComputation):
(JSC::ARM64Assembler::setPointer):
(JSC::ARM64Assembler::repatchInt32):
(JSC::ARM64Assembler::repatchCompact):
(JSC::ARM64Assembler::linkJumpOrCall):
(JSC::ARM64Assembler::linkCompareAndBranch):
(JSC::ARM64Assembler::linkConditionalBranch):
(JSC::ARM64Assembler::linkTestAndBranch):

  • assembler/LinkBuffer.cpp:

(JSC::LinkBuffer::copyCompactAndLinkCode):

  • jit/ExecutableAllocator.h:

(JSC::writeToExecutableRegion):
(JSC::performJITMemcpy): Deleted.

Location:
trunk/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r198241 r198252  
     12016-03-15  Oliver Hunt  <oliver@apple.com>
     2
     3        Rename performJITMemcpy to something more inline with our normal webkit function names
     4        https://bugs.webkit.org/show_bug.cgi?id=155525
     5
     6        Reviewed by Saam Barati.
     7
     8        Simple bulk search/replace with a better name.
     9
     10        * assembler/ARM64Assembler.h:
     11        (JSC::ARM64Assembler::fillNops):
     12        (JSC::ARM64Assembler::replaceWithJump):
     13        (JSC::ARM64Assembler::replaceWithLoad):
     14        (JSC::ARM64Assembler::replaceWithAddressComputation):
     15        (JSC::ARM64Assembler::setPointer):
     16        (JSC::ARM64Assembler::repatchInt32):
     17        (JSC::ARM64Assembler::repatchCompact):
     18        (JSC::ARM64Assembler::linkJumpOrCall):
     19        (JSC::ARM64Assembler::linkCompareAndBranch):
     20        (JSC::ARM64Assembler::linkConditionalBranch):
     21        (JSC::ARM64Assembler::linkTestAndBranch):
     22        * assembler/LinkBuffer.cpp:
     23        (JSC::LinkBuffer::copyCompactAndLinkCode):
     24        * jit/ExecutableAllocator.h:
     25        (JSC::writeToExecutableRegion):
     26        (JSC::performJITMemcpy): Deleted.
     27
    1282016-03-15  Oliver Hunt  <oliver@apple.com>
    229

  • trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h

    r197816 r198252  
    14911491        for (int32_t* ptr = static_cast<int32_t*>(base); n--;) {
    14921492            int insn = nopPseudo();
    1493             performJITMemcpy(ptr++, &insn, sizeof(int));
     1493            writeToExecutableRegion(ptr++, &insn, sizeof(int));
    14941494        }
    14951495    }
    … …  
    25022502        ASSERT(static_cast<int>(offset) == offset);
    25032503        int insn = unconditionalBranchImmediate(false, static_cast<int>(offset));
    2504         performJITMemcpy(where, &insn, sizeof(int));
     2504        writeToExecutableRegion(where, &insn, sizeof(int));
    25052505        cacheFlush(where, sizeof(int));
    25062506    }
    … …  
    25272527            ASSERT(!(imm12 & ~0xff8));
    25282528            int insn = loadStoreRegisterUnsignedImmediate(MemOpSize_64, false, MemOp_LOAD, encodePositiveImmediate<64>(imm12), rn, rd);
    2529             performJITMemcpy(where, &insn, sizeof(int));
     2529            writeToExecutableRegion(where, &insn, sizeof(int));
    25302530            cacheFlush(where, sizeof(int));
    25312531        }
    … …  
    25612561            ASSERT(!(imm12 & ~0x1ff));
    25622562            int insn = addSubtractImmediate(Datasize_64, AddOp_ADD, DontSetFlags, 0, imm12 * sizeof(void*), rn, rt);
    2563             performJITMemcpy(where, &insn, sizeof(int));
     2563            writeToExecutableRegion(where, &insn, sizeof(int));
    25642564            cacheFlush(where, sizeof(int));
    25652565        }
    … …  
    25952595        buffer[1] = moveWideImediate(Datasize_64, MoveWideOp_K, 1, getHalfword(value, 1), rd);
    25962596        buffer[2] = moveWideImediate(Datasize_64, MoveWideOp_K, 2, getHalfword(value, 2), rd);
    2597         performJITMemcpy(address, buffer, sizeof(int) * 3);
     2597        writeToExecutableRegion(address, buffer, sizeof(int) * 3);
    25982598
    25992599        if (flush)
    … …  
    26222622            buffer[1] = moveWideImediate(Datasize_32, MoveWideOp_K, 1, getHalfword(value, 1), rd);
    26232623        }
    2624         performJITMemcpy(where, &buffer, sizeof(int) * 2);
     2624        writeToExecutableRegion(where, &buffer, sizeof(int) * 2);
    26252625
    26262626        cacheFlush(where, sizeof(int) * 2);
    … …  
    26872687            imm12 = encodePositiveImmediate<64>(value);
    26882688        int insn = loadStoreRegisterUnsignedImmediate(size, V, opc, imm12, rn, rt);
    2689         performJITMemcpy(where, &insn, sizeof(int));
     2689        writeToExecutableRegion(where, &insn, sizeof(int));
    26902690
    26912691        cacheFlush(where, sizeof(int));
    … …  
    28852885
    28862886        int insn = unconditionalBranchImmediate(isCall, static_cast<int>(offset));
    2887         performJITMemcpy(from, &insn, sizeof(int));
     2887        writeToExecutableRegion(from, &insn, sizeof(int));
    28882888    }
    28892889
    … …  
    29012901        if (useDirect || isDirect) {
    29022902            int insn = compareAndBranchImmediate(is64Bit ? Datasize_64 : Datasize_32, condition == ConditionNE, static_cast<int>(offset), rt);
    2903             performJITMemcpy(from, &insn, sizeof(int));
     2903            writeToExecutableRegion(from, &insn, sizeof(int));
    29042904            if (!isDirect) {
    29052905                insn = nopPseudo();
    2906                 performJITMemcpy(from + 1, &insn, sizeof(int));
     2906                writeToExecutableRegion(from + 1, &insn, sizeof(int));
    29072907            }
    29082908        } else {
    29092909            int insn = compareAndBranchImmediate(is64Bit ? Datasize_64 : Datasize_32, invert(condition) == ConditionNE, 2, rt);
    2910             performJITMemcpy(from, &insn, sizeof(int));
     2910            writeToExecutableRegion(from, &insn, sizeof(int));
    29112911            linkJumpOrCall<false>(from + 1, to);
    29122912        }
    … …  
    29262926        if (useDirect || isDirect) {
    29272927            int insn = conditionalBranchImmediate(static_cast<int>(offset), condition);
    2928             performJITMemcpy(from, &insn, sizeof(int));
     2928            writeToExecutableRegion(from, &insn, sizeof(int));
    29292929            if (!isDirect) {
    29302930                insn = nopPseudo();
    2931                 performJITMemcpy(from + 1, &insn, sizeof(int));
     2931                writeToExecutableRegion(from + 1, &insn, sizeof(int));
    29322932            }
    29332933        } else {
    29342934            int insn = conditionalBranchImmediate(2, invert(condition));
    2935             performJITMemcpy(from, &insn, sizeof(int));
     2935            writeToExecutableRegion(from, &insn, sizeof(int));
    29362936            linkJumpOrCall<false>(from + 1, to);
    29372937        }
    … …  
    29522952        if (useDirect || isDirect) {
    29532953            int insn = testAndBranchImmediate(condition == ConditionNE, static_cast<int>(bitNumber), static_cast<int>(offset), rt);
    2954             performJITMemcpy(from, &insn, sizeof(int));
     2954            writeToExecutableRegion(from, &insn, sizeof(int));
    29552955            if (!isDirect) {
    29562956                insn = nopPseudo();
    2957                 performJITMemcpy(from + 1, &insn, sizeof(int));
     2957                writeToExecutableRegion(from + 1, &insn, sizeof(int));
    29582958            }
    29592959        } else {
    29602960            int insn = testAndBranchImmediate(invert(condition) == ConditionNE, static_cast<int>(bitNumber), 2, rt);
    2961             performJITMemcpy(from, &insn, sizeof(int));
     2961            writeToExecutableRegion(from, &insn, sizeof(int));
    29622962            linkJumpOrCall<false>(from + 1, to);
    29632963        }

  • trunk/Source/JavaScriptCore/assembler/LinkBuffer.cpp

    r198235 r198252  
    164164    shrink(writePtr + m_initialSize - readPtr);
    165165
    166     performJITMemcpy(m_code, outBuffer.buffer(), m_size);
     166    writeToExecutableRegion(m_code, outBuffer.buffer(), m_size);
    167167
    168168#if DUMP_LINK_STATISTICS

  • trunk/Source/JavaScriptCore/jit/ExecutableAllocator.h

    r198235 r198252  
    9696extern JS_EXPORTDATA JITWriteFunction jitWriteFunction;
    9797
    98 static inline void* performJITMemcpy(void *dst, const void *src, size_t n)
     98static inline void* writeToExecutableRegion(void *dst, const void *src, size_t n)
    9999{
    100100    // Use execute-only write thunk for writes inside the JIT region. This is a variant of
    … …  
    111111
    112112#else // ENABLE(EXECUTABLE_ALLOCATOR_FIXED)
    113 static inline void* performJITMemcpy(void *dst, const void *src, size_t n)
     113static inline void* writeToExecutableRegion(void *dst, const void *src, size_t n)
    114114{
    115115    return memcpy(dst, src, n);
Note: See TracChangeset for help on using the changeset viewer.