Changeset 237439 in webkit

Timestamp:

Oct 25, 2018, 5:11:33 PM (8 years ago)

Author:

Kocsen Chung

Message:

Revert r237373. rdar://problem/45567354

Location:

branches/safari-606-branch

Files:

• JSTests/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/assembler/ARM64Assembler.h (modified) (13 diffs)
• Source/JavaScriptCore/assembler/ARMAssembler.h (modified) (1 diff)
• Source/JavaScriptCore/assembler/ARMv7Assembler.h (modified) (4 diffs)
• Source/JavaScriptCore/assembler/AbstractMacroAssembler.h (modified) (4 diffs)
• Source/JavaScriptCore/assembler/AssemblerBuffer.h (modified) (10 diffs)
• Source/JavaScriptCore/assembler/LinkBuffer.cpp (modified) (3 diffs)
• Source/JavaScriptCore/assembler/MIPSAssembler.h (modified) (1 diff)
• Source/JavaScriptCore/assembler/MacroAssemblerARM64.h (modified) (1 diff)
• Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h (modified) (1 diff)
• Source/JavaScriptCore/assembler/X86Assembler.h (modified) (1 diff)
• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/PtrTag.h (modified) (2 diffs)

branches/safari-606-branch/JSTests/ChangeLog

@@ +1 @@
+2018-10-25  Kocsen Chung  <kocsen_chung@apple.com>
+
+        Revert r237373. rdar://problem/45285669
+
 2018-10-23  Kocsen Chung  <kocsen_chung@apple.com>
 

branches/safari-606-branch/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2018-10-25  Kocsen Chung  <kocsen_chung@apple.com>
+
+        Revert r237373. rdar://problem/45285669
+
 2018-10-25  Kocsen Chung  <kocsen_chung@apple.com>
 

branches/safari-606-branch/Source/JavaScriptCore/assembler/ARM64Assembler.h

@@ -319 +319 @@
 
 public:
-    ARM64Assembler(
-#if CPU(ARM64E)
-        unsigned randomNumber
-#endif 
-        )
+    ARM64Assembler()
         : m_indexOfLastWatchpoint(INT_MIN)
         , m_indexOfTailOfLastWatchpoint(INT_MIN)
-#if CPU(ARM64E)
-        , m_buffer(randomNumber)
-#endif
-        
     {
     }
@@ -1563 +1555 @@
     }
     
-    template <typename CopyFunction>
-    static void fillNops(void* base, size_t size, CopyFunction copy)
+    static void fillNops(void* base, size_t size, bool isCopyingToExecutableMemory)
     {
         RELEASE_ASSERT(!(size % sizeof(int32_t)));
@@ -1570 +1561 @@
         for (int32_t* ptr = static_cast<int32_t*>(base); n--;) {
             int insn = nopPseudo();
-            copy(ptr++, &insn, sizeof(int));
+            if (isCopyingToExecutableMemory)
+                performJITMemcpy(ptr++, &insn, sizeof(int));
+            else
+                memcpy(ptr++, &insn, sizeof(int));
         }
     }
@@ -2575 +2569 @@
     }
 
+    void* unlinkedCode() { return m_buffer.data(); }
     size_t codeSize() const { return m_buffer.codeSize(); }
 
@@ -2612 +2607 @@
     }
 
+    void linkJump(AssemblerLabel from, void* executableCode, AssemblerLabel to)
+    {
+        ASSERT(from.isSet());
+        ASSERT(to.isSet());
+        relinkJumpOrCall<false>(addressOf(from), addressOf(executableCode, from), addressOf(to));
+    }
+    
     static void linkJump(void* code, AssemblerLabel from, void* to)
     {
@@ -2964 +2966 @@
     }
 
-    typedef void* (*CopyFunction)(void*, const void*, size_t);
-
-    static void ALWAYS_INLINE link(LinkRecord& record, uint8_t* from, const uint8_t* fromInstruction8, uint8_t* to, CopyFunction copy)
+    static void ALWAYS_INLINE link(LinkRecord& record, uint8_t* from, const uint8_t* fromInstruction8, uint8_t* to)
     {
         const int* fromInstruction = reinterpret_cast<const int*>(fromInstruction8);
         switch (record.linkType()) {
         case LinkJumpNoCondition:
-            linkJumpOrCall<false>(reinterpret_cast<int*>(from), fromInstruction, to, copy);
+            linkJumpOrCall<false>(reinterpret_cast<int*>(from), fromInstruction, to);
             break;
         case LinkJumpConditionDirect:
-            linkConditionalBranch<true>(record.condition(), reinterpret_cast<int*>(from), fromInstruction, to, copy);
+            linkConditionalBranch<true>(record.condition(), reinterpret_cast<int*>(from), fromInstruction, to);
             break;
         case LinkJumpCondition:
-            linkConditionalBranch<false>(record.condition(), reinterpret_cast<int*>(from) - 1, fromInstruction - 1, to, copy);
+            linkConditionalBranch<false>(record.condition(), reinterpret_cast<int*>(from) - 1, fromInstruction - 1, to);
             break;
         case LinkJumpCompareAndBranchDirect:
-            linkCompareAndBranch<true>(record.condition(), record.is64Bit(), record.compareRegister(), reinterpret_cast<int*>(from), fromInstruction, to, copy);
+            linkCompareAndBranch<true>(record.condition(), record.is64Bit(), record.compareRegister(), reinterpret_cast<int*>(from), fromInstruction, to);
             break;
         case LinkJumpCompareAndBranch:
-            linkCompareAndBranch<false>(record.condition(), record.is64Bit(), record.compareRegister(), reinterpret_cast<int*>(from) - 1, fromInstruction - 1, to, copy);
+            linkCompareAndBranch<false>(record.condition(), record.is64Bit(), record.compareRegister(), reinterpret_cast<int*>(from) - 1, fromInstruction - 1, to);
             break;
         case LinkJumpTestBitDirect:
-            linkTestAndBranch<true>(record.condition(), record.bitNumber(), record.compareRegister(), reinterpret_cast<int*>(from), fromInstruction, to, copy);
+            linkTestAndBranch<true>(record.condition(), record.bitNumber(), record.compareRegister(), reinterpret_cast<int*>(from), fromInstruction, to);
             break;
         case LinkJumpTestBit:
-            linkTestAndBranch<false>(record.condition(), record.bitNumber(), record.compareRegister(), reinterpret_cast<int*>(from) - 1, fromInstruction - 1, to, copy);
+            linkTestAndBranch<false>(record.condition(), record.bitNumber(), record.compareRegister(), reinterpret_cast<int*>(from) - 1, fromInstruction - 1, to);
             break;
         default:
@@ -3031 +3031 @@
 
     template<bool isCall>
-    static void linkJumpOrCall(int* from, const int* fromInstruction, void* to, CopyFunction copy = performJITMemcpy)
+    static void linkJumpOrCall(int* from, const int* fromInstruction, void* to)
     {
         bool link;
@@ -3047 +3047 @@
 
         int insn = unconditionalBranchImmediate(isCall, static_cast<int>(offset));
-        copy(from, &insn, sizeof(int));
+        performJITMemcpy(from, &insn, sizeof(int));
     }
 
     template<bool isDirect>
-    static void linkCompareAndBranch(Condition condition, bool is64Bit, RegisterID rt, int* from, const int* fromInstruction, void* to, CopyFunction copy = performJITMemcpy)
+    static void linkCompareAndBranch(Condition condition, bool is64Bit, RegisterID rt, int* from, const int* fromInstruction, void* to)
     {
         ASSERT(!(reinterpret_cast<intptr_t>(from) & 3));
@@ -3063 +3063 @@
         if (useDirect || isDirect) {
             int insn = compareAndBranchImmediate(is64Bit ? Datasize_64 : Datasize_32, condition == ConditionNE, static_cast<int>(offset), rt);
-            copy(from, &insn, sizeof(int));
+            performJITMemcpy(from, &insn, sizeof(int));
             if (!isDirect) {
                 insn = nopPseudo();
-                copy(from + 1, &insn, sizeof(int));
+                performJITMemcpy(from + 1, &insn, sizeof(int));
             }
         } else {
             int insn = compareAndBranchImmediate(is64Bit ? Datasize_64 : Datasize_32, invert(condition) == ConditionNE, 2, rt);
-            copy(from, &insn, sizeof(int));
-            linkJumpOrCall<false>(from + 1, fromInstruction + 1, to, copy);
+            performJITMemcpy(from, &insn, sizeof(int));
+            linkJumpOrCall<false>(from + 1, fromInstruction + 1, to);
         }
     }
 
     template<bool isDirect>
-    static void linkConditionalBranch(Condition condition, int* from, const int* fromInstruction, void* to, CopyFunction copy = performJITMemcpy)
+    static void linkConditionalBranch(Condition condition, int* from, const int* fromInstruction, void* to)
     {
         ASSERT(!(reinterpret_cast<intptr_t>(from) & 3));
@@ -3088 +3088 @@
         if (useDirect || isDirect) {
             int insn = conditionalBranchImmediate(static_cast<int>(offset), condition);
-            copy(from, &insn, sizeof(int));
+            performJITMemcpy(from, &insn, sizeof(int));
             if (!isDirect) {
                 insn = nopPseudo();
-                copy(from + 1, &insn, sizeof(int));
+                performJITMemcpy(from + 1, &insn, sizeof(int));
             }
         } else {
             int insn = conditionalBranchImmediate(2, invert(condition));
-            copy(from, &insn, sizeof(int));
-            linkJumpOrCall<false>(from + 1, fromInstruction + 1, to, copy);
+            performJITMemcpy(from, &insn, sizeof(int));
+            linkJumpOrCall<false>(from + 1, fromInstruction + 1, to);
         }
     }
 
     template<bool isDirect>
-    static void linkTestAndBranch(Condition condition, unsigned bitNumber, RegisterID rt, int* from, const int* fromInstruction, void* to, CopyFunction copy = performJITMemcpy)
+    static void linkTestAndBranch(Condition condition, unsigned bitNumber, RegisterID rt, int* from, const int* fromInstruction, void* to)
     {
         ASSERT(!(reinterpret_cast<intptr_t>(from) & 3));
@@ -3114 +3114 @@
         if (useDirect || isDirect) {
             int insn = testAndBranchImmediate(condition == ConditionNE, static_cast<int>(bitNumber), static_cast<int>(offset), rt);
-            copy(from, &insn, sizeof(int));
+            performJITMemcpy(from, &insn, sizeof(int));
             if (!isDirect) {
                 insn = nopPseudo();
-                copy(from + 1, &insn, sizeof(int));
+                performJITMemcpy(from + 1, &insn, sizeof(int));
             }
         } else {
             int insn = testAndBranchImmediate(invert(condition) == ConditionNE, static_cast<int>(bitNumber), 2, rt);
-            copy(from, &insn, sizeof(int));
-            linkJumpOrCall<false>(from + 1, fromInstruction + 1, to, copy);
+            performJITMemcpy(from, &insn, sizeof(int));
+            linkJumpOrCall<false>(from + 1, fromInstruction + 1, to);
         }
     }
@@ -3178 +3178 @@
     {
         return reinterpret_cast<int*>(static_cast<char*>(code) + label.m_offset);
+    }
+
+    int* addressOf(AssemblerLabel label)
+    {
+        return addressOf(m_buffer.data(), label);
     }
 
@@ -3755 +3760 @@
     }
 
+    AssemblerBuffer m_buffer;
     Vector<LinkRecord, 0, UnsafeVectorOverflow> m_jumpsToLink;
     int m_indexOfLastWatchpoint;
     int m_indexOfTailOfLastWatchpoint;
-    AssemblerBuffer m_buffer;
 
 public:

branches/safari-606-branch/Source/JavaScriptCore/assembler/ARMAssembler.h

@@ -751 +751 @@
         }
 
-        template <typename CopyFunction>
-        static void fillNops(void* base, size_t size, CopyFunction copy)
-        {
-            UNUSED_PARAM(copy);
+        static void fillNops(void* base, size_t size, bool isCopyingToExecutableMemory)
+        {
+            UNUSED_PARAM(isCopyingToExecutableMemory);
             RELEASE_ASSERT(!(size % sizeof(int32_t)));
 

branches/safari-606-branch/Source/JavaScriptCore/assembler/ARMv7Assembler.h

@@ -2056 +2056 @@
     }
 
-    template <typename CopyFunction>
-    static void fillNops(void* base, size_t size, CopyFunction copy)
+    static void fillNops(void* base, size_t size, bool isCopyingToExecutableMemory)
     {
         RELEASE_ASSERT(!(size % sizeof(int16_t)));
@@ -2065 +2064 @@
         for (size_t i = 0; i < num32s; i++) {
             const int32_t insn = nopPseudo32();
-            copy(ptr, &insn, sizeof(int32_t));
+            if (isCopyingToExecutableMemory)
+                performJITMemcpy(ptr, &insn, sizeof(int32_t));
+            else
+                memcpy(ptr, &insn, sizeof(int32_t));
             ptr += sizeof(int32_t);
         }
@@ -2074 +2076 @@
         if (num16s) {
             const int16_t insn = nopPseudo16();
-            copy(ptr, &insn, sizeof(int16_t));
+            if (isCopyingToExecutableMemory)
+                performJITMemcpy(ptr, &insn, sizeof(int16_t));
+            else
+                memcpy(ptr, &insn, sizeof(int16_t));
         }
     }
@@ -2241 +2246 @@
     }
 
+    void* unlinkedCode() { return m_formatter.data(); }
     size_t codeSize() const { return m_formatter.codeSize(); }
 

branches/safari-606-branch/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h

@@ -863 +863 @@
     }
 
+    AssemblerType m_assembler;
+    
     template<PtrTag tag>
     static void linkJump(void* code, Jump jump, CodeLocationLabel<tag> target)
@@ -961 +963 @@
     void emitNops(size_t memoryToFillWithNopsInBytes)
     {
-#if CPU(ARM64)
-        RELEASE_ASSERT(memoryToFillWithNopsInBytes % 4 == 0);
-        for (unsigned i = 0; i < memoryToFillWithNopsInBytes / 4; ++i)
-            m_assembler.nop();
-#else
         AssemblerBuffer& buffer = m_assembler.buffer();
         size_t startCodeSize = buffer.codeSize();
         size_t targetCodeSize = startCodeSize + memoryToFillWithNopsInBytes;
         buffer.ensureSpace(memoryToFillWithNopsInBytes);
-        AssemblerType::fillNops(static_cast<char*>(buffer.data()) + startCodeSize, memoryToFillWithNopsInBytes, memcpy);
+        bool isCopyingToExecutableMemory = false;
+        AssemblerType::fillNops(static_cast<char*>(buffer.data()) + startCodeSize, memoryToFillWithNopsInBytes, isCopyingToExecutableMemory);
         buffer.setCodeSize(targetCodeSize);
-#endif
     }
 
@@ -987 +984 @@
     AbstractMacroAssembler()
         : m_randomSource(0)
-#if CPU(ARM64E)
-        , m_assembler(random())
-#else
-        , m_assembler()
-#endif
     {
         invalidateAllTempRegisters();
@@ -1007 +999 @@
     bool m_randomSourceIsInitialized { false };
     WeakRandom m_randomSource;
-public:
-    AssemblerType m_assembler;
-protected:
 
 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)

branches/safari-606-branch/Source/JavaScriptCore/assembler/AssemblerBuffer.h

@@ -34 +34 @@
 #include <wtf/Assertions.h>
 #include <wtf/FastMalloc.h>
-#if CPU(ARM64E)
-#include <wtf/PtrTag.h>
-#endif
 #include <wtf/StdLibExtras.h>
 
 namespace JSC {
-
-    class LinkBuffer;
 
     struct AssemblerLabel {
@@ -146 +141 @@
     };
 
-#if CPU(ARM64E)
-    class ARM64EHash {
-    public:
-        ARM64EHash(unsigned randomNumber)
-            : m_hash(randomNumber)
-            , m_randomSeed(randomNumber)
-        { }
-        ALWAYS_INLINE void update(unsigned value, uintptr_t index)
-        {
-            m_hash = tagInt((static_cast<uintptr_t>(value) + m_hash) ^ (m_hash >> 32), static_cast<PtrTag>(index));
-        }
-        uintptr_t hash() const { return m_hash; }
-        unsigned randomSeed() const { return m_randomSeed; }
-    private:
-        uintptr_t m_hash;
-        unsigned m_randomSeed;
-    };
-#endif
-
     class AssemblerBuffer {
     public:
-        AssemblerBuffer(
-#if CPU(ARM64E)
-            unsigned randomNumber
-#endif
-        )
+        AssemblerBuffer()
             : m_storage()
             , m_index(0)
-#if CPU(ARM64E)
-            , m_hash(randomNumber)
-#endif
         {
         }
@@ -196 +165 @@
         }
 
-#if !CPU(ARM64)
         void putByteUnchecked(int8_t value) { putIntegralUnchecked(value); }
         void putByte(int8_t value) { putIntegral(value); }
         void putShortUnchecked(int16_t value) { putIntegralUnchecked(value); }
         void putShort(int16_t value) { putIntegral(value); }
+        void putIntUnchecked(int32_t value) { putIntegralUnchecked(value); }
+        void putInt(int32_t value) { putIntegral(value); }
         void putInt64Unchecked(int64_t value) { putIntegralUnchecked(value); }
         void putInt64(int64_t value) { putIntegral(value); }
-#endif
-        void putIntUnchecked(int32_t value) { putIntegralUnchecked(value); }
-        void putInt(int32_t value) { putIntegral(value); }
+
+        void* data() const
+        {
+            return m_storage.buffer();
+        }
 
         size_t codeSize() const
@@ -212 +184 @@
         }
 
-#if !CPU(ARM64)
         void setCodeSize(size_t index)
         {
@@ -221 +192 @@
             ASSERT(m_index <= m_storage.capacity());
         }
-#endif
 
         AssemblerLabel label() const
@@ -239 +209 @@
         // LocalWriter *CANNOT* be mixed with other types of access to AssemblerBuffer.
         // AssemblerBuffer cannot be used until its LocalWriter goes out of scope.
-#if !CPU(ARM64) // If we ever need to use this on arm64e, we would need to make the checksum aware of this.
         class LocalWriter {
         public:
@@ -282 +251 @@
 #endif
         };
-#endif // !CPU(ARM64)
-
-#if CPU(ARM64E)
-        ARM64EHash hash() const { return m_hash; }
-#endif
-
-#if !CPU(ARM64) // If we were to define this on arm64e, we'd need a way to update the hash as we write directly into the buffer.
-        void* data() const { return m_storage.buffer(); }
-#endif
-
 
     protected:
@@ -308 +267 @@
         void putIntegralUnchecked(IntegralType value)
         {
-#if CPU(ARM64)
-            static_assert(sizeof(value) == 4, "");
-#if CPU(ARM64E)
-            m_hash.update(value, m_index);
-#endif
-#endif
             ASSERT(isAvailable(sizeof(IntegralType)));
             *reinterpret_cast_ptr<IntegralType*>(m_storage.buffer() + m_index) = value;
@@ -319 +272 @@
         }
 
+        void append(const char* data, int size)
+        {
+            if (!isAvailable(size))
+                grow(size);
+
+            memcpy(m_storage.buffer() + m_index, data, size);
+            m_index += size;
+        }
+
+        void grow(int extraCapacity = 0)
+        {
+            m_storage.grow(extraCapacity);
+        }
+
     private:
-        void grow(int extraCapacity = 0)
-        {
-            m_storage.grow(extraCapacity);
-        }
-
         NEVER_INLINE void outOfLineGrow()
         {
@@ -330 +292 @@
         }
 
-#if !CPU(ARM64)
         friend LocalWriter;
-#endif
-        friend LinkBuffer;
 
         AssemblerData m_storage;
         unsigned m_index;
-#if CPU(ARM64E)
-        ARM64EHash m_hash;
-#endif
     };
 

branches/safari-606-branch/Source/JavaScriptCore/assembler/LinkBuffer.cpp

@@ -110 +110 @@
     uint8_t* inData = reinterpret_cast<uint8_t*>(m_assemblerStorage.buffer());
 
+    AssemblerData outBuffer(m_size);
+
+    uint8_t* outData = reinterpret_cast<uint8_t*>(outBuffer.buffer());
     uint8_t* codeOutData = m_code.dataLocation<uint8_t*>();
-#if CPU(ARM64E)
-    const ARM64EHash assemblerBufferHash = macroAssembler.m_assembler.buffer().hash();
-    ARM64EHash verifyUncompactedHash(assemblerBufferHash.randomSeed());
-    uint8_t* outData = codeOutData;
-#else
-    AssemblerData outBuffer(m_size);
-    uint8_t* outData = reinterpret_cast<uint8_t*>(outBuffer.buffer());
-#endif
 
     int readPtr = 0;
     int writePtr = 0;
     unsigned jumpCount = jumpsToLink.size();
-
-#if CPU(ARM64E)
-    os_thread_self_restrict_rwx_to_rw();
-#endif
-
     if (m_shouldPerformBranchCompaction) {
         for (unsigned i = 0; i < jumpCount; ++i) {
@@ -141 +131 @@
             ASSERT(!(readPtr % 2));
             ASSERT(!(writePtr % 2));
-#if CPU(ARM64E)
-            unsigned index = readPtr;
-#endif
-            while (copySource != copyEnd) {
-                InstructionType insn = *copySource++;
-#if CPU(ARM64E)
-                static_assert(sizeof(InstructionType) == 4, "");
-                verifyUncompactedHash.update(insn, index);
-                index += sizeof(InstructionType);
-#endif
-                *copyDst++ = insn;
-            }
+            while (copySource != copyEnd)
+                *copyDst++ = *copySource++;
             recordLinkOffsets(m_assemblerStorage, readPtr, jumpsToLink[i].from(), offset);
             readPtr += regionSize;
@@ -183 +163 @@
         }
     }
-
     // Copy everything after the last jump
-    {
-        InstructionType* dst = bitwise_cast<InstructionType*>(outData + writePtr);
-        InstructionType* src = bitwise_cast<InstructionType*>(inData + readPtr);
-        size_t bytes = initialSize - readPtr;
-
-        RELEASE_ASSERT(bitwise_cast<uintptr_t>(dst) % sizeof(InstructionType) == 0);
-        RELEASE_ASSERT(bitwise_cast<uintptr_t>(src) % sizeof(InstructionType) == 0);
-        RELEASE_ASSERT(bytes % sizeof(InstructionType) == 0);
-
-#if CPU(ARM64E)
-        unsigned index = readPtr;
-#endif
-
-        for (size_t i = 0; i < bytes; i += sizeof(InstructionType)) {
-            InstructionType insn = *src++;
-#if CPU(ARM64E)
-            verifyUncompactedHash.update(insn, index);
-            index += sizeof(InstructionType);
-#endif
-            *dst++ = insn;
-        }
-    }
-
-#if CPU(ARM64E)
-    if (verifyUncompactedHash.hash() != assemblerBufferHash.hash()) {
-        dataLogLn("Hashes don't match: ", RawPointer(bitwise_cast<void*>(verifyUncompactedHash.hash())), " ", RawPointer(bitwise_cast<void*>(assemblerBufferHash.hash())));
-        dataLogLn("Crashing!");
-        CRASH();
-    }
-#endif
-
+    memcpy(outData + writePtr, inData + readPtr, initialSize - readPtr);
     recordLinkOffsets(m_assemblerStorage, readPtr, initialSize, readPtr - writePtr);
         
     for (unsigned i = 0; i < jumpCount; ++i) {
-#if CPU(ARM64E)
-        auto memcpyFunction = memcpy;
-#else
-        auto memcpyFunction = performJITMemcpy;
-#endif
-
         uint8_t* location = codeOutData + jumpsToLink[i].from();
         uint8_t* target = codeOutData + jumpsToLink[i].to() - executableOffsetFor(jumpsToLink[i].to());
-        MacroAssembler::link(jumpsToLink[i], outData + jumpsToLink[i].from(), location, target, memcpyFunction);
-    }
+        MacroAssembler::link(jumpsToLink[i], outData + jumpsToLink[i].from(), location, target);
+    }
+
+    jumpsToLink.clear();
 
     size_t compactSize = writePtr + initialSize - readPtr;
-    if (!m_executableMemory) {
-        size_t nopSizeInBytes = initialSize - compactSize;
-        MacroAssembler::AssemblerType_T::fillNops(outData + compactSize, nopSizeInBytes, memcpy);
-    }
-
-#if CPU(ARM64E)
-    os_thread_self_restrict_rwx_to_rx();
-#endif
-
     if (m_executableMemory) {
         m_size = compactSize;
         m_executableMemory->shrink(m_size);
-    }
-
-#if !CPU(ARM64E)
-    ASSERT(codeOutData != outData);
+    } else {
+        size_t nopSizeInBytes = initialSize - compactSize;
+        bool isCopyingToExecutableMemory = false;
+        MacroAssembler::AssemblerType_T::fillNops(outData + compactSize, nopSizeInBytes, isCopyingToExecutableMemory);
+    }
+
     performJITMemcpy(codeOutData, outData, m_size);
-#else
-    ASSERT(codeOutData == outData);
-#endif
-
-    jumpsToLink.clear();
 
 #if DUMP_LINK_STATISTICS

branches/safari-606-branch/Source/JavaScriptCore/assembler/MIPSAssembler.h

@@ -265 +265 @@
     }
     
-    template <typename CopyFunction>
-    static void fillNops(void* base, size_t size, CopyFunction copy)
-    {
-        UNUSED_PARAM(copy);
+    static void fillNops(void* base, size_t size, bool isCopyingToExecutableMemory)
+    {
+        UNUSED_PARAM(isCopyingToExecutableMemory);
         RELEASE_ASSERT(!(size % sizeof(int32_t)));
 

branches/safari-606-branch/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

@@ -80 +80 @@
 
     Vector<LinkRecord, 0, UnsafeVectorOverflow>& jumpsToLink() { return m_assembler.jumpsToLink(); }
+    void* unlinkedCode() { return m_assembler.unlinkedCode(); }
     static bool canCompact(JumpType jumpType) { return Assembler::canCompact(jumpType); }
     static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from, const uint8_t* to) { return Assembler::computeJumpType(jumpType, from, to); }
     static JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* from, const uint8_t* to) { return Assembler::computeJumpType(record, from, to); }
     static int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { return Assembler::jumpSizeDelta(jumpType, jumpLinkType); }
-    template <typename CopyFunction>
-    static void link(LinkRecord& record, uint8_t* from, const uint8_t* fromInstruction, uint8_t* to, CopyFunction copy) { return Assembler::link(record, from, fromInstruction, to, copy); }
+    static void link(LinkRecord& record, uint8_t* from, const uint8_t* fromInstruction, uint8_t* to) { return Assembler::link(record, from, fromInstruction, to); }
 
     static const Scale ScalePtr = TimesEight;

branches/safari-606-branch/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

@@ -66 +66 @@
 
     Vector<LinkRecord, 0, UnsafeVectorOverflow>& jumpsToLink() { return m_assembler.jumpsToLink(); }
+    void* unlinkedCode() { return m_assembler.unlinkedCode(); }
     static bool canCompact(JumpType jumpType) { return ARMv7Assembler::canCompact(jumpType); }
     static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from, const uint8_t* to) { return ARMv7Assembler::computeJumpType(jumpType, from, to); }

branches/safari-606-branch/Source/JavaScriptCore/assembler/X86Assembler.h

@@ -3903 +3903 @@
     }
 
-    template <typename CopyFunction>
-    static void fillNops(void* base, size_t size, CopyFunction copy)
-    {
-        UNUSED_PARAM(copy);
+    static void fillNops(void* base, size_t size, bool isCopyingToExecutableMemory)
+    {
+        UNUSED_PARAM(isCopyingToExecutableMemory);
 #if CPU(X86_64)
         static const uint8_t nops[10][10] = {

branches/safari-606-branch/Source/WTF/ChangeLog

@@ +1 @@
+2018-10-25  Kocsen Chung  <kocsen_chung@apple.com>
+
+        Revert r237373. rdar://problem/45285669
+
 2018-10-23  Kocsen Chung  <kocsen_chung@apple.com>
 

branches/safari-606-branch/Source/WTF/wtf/PtrTag.h

@@ -148 +148 @@
 inline PtrType untagCFunctionPtr(PtrType ptr) { return ptr; }
 
-template <typename IntType>
-inline IntType tagInt(IntType ptrInt, PtrTag)
-{
-    static_assert(sizeof(IntType) == sizeof(uintptr_t), "");
-    return ptrInt;
-}
-
 template<typename PtrType> void assertIsCFunctionPtr(PtrType) { }
 template<typename PtrType> void assertIsNullOrCFunctionPtr(PtrType) { }
@@ -192 +185 @@
 using WTF::tagCFunctionPtr;
 using WTF::untagCFunctionPtr;
-using WTF::tagInt;
 
 using WTF::assertIsCFunctionPtr;