Attachment 370177 Details for Bug 197910 – Patch

[patch] Patch

bug-197910-20190517193122.patch (text/plain), 21.31 KB, created by Yusuke Suzuki on 2019-05-17 19:31:23 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2019-05-17 19:31:23 PDT

Size: 21.31 KB

patch

obsolete

>Subversion Revision: 245487
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 82d5cfe1649d48ad4137e843432cf12c91cf4514..6f18d5d44e1c5e5d502af19c3742ba8613ac3eb4 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,40 @@
>+2019-05-17  Yusuke Suzuki  <ysuzuki@apple.com>
>+
>+        [JSC] UnlinkedMetadataTable's offset table should be small
>+        https://bugs.webkit.org/show_bug.cgi?id=197910
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * JavaScriptCore.xcodeproj/project.pbxproj:
>+        * Sources.txt:
>+        * bytecode/MetadataTable.h:
>+        (JSC::MetadataTable::buffer):
>+        (JSC::MetadataTable::is32Bit const):
>+        (JSC::MetadataTable::offsetTable16 const):
>+        (JSC::MetadataTable::offsetTable32 const):
>+        (JSC::MetadataTable::totalSize const):
>+        (JSC::MetadataTable::getImpl):
>+        * bytecode/UnlinkedMetadataTable.cpp: Added.
>+        (JSC::UnlinkedMetadataTable::finalize):
>+        * bytecode/UnlinkedMetadataTable.h:
>+        (JSC::UnlinkedMetadataTable::create):
>+        (JSC::UnlinkedMetadataTable::preprocessBuffer const):
>+        (JSC::UnlinkedMetadataTable::buffer const):
>+        (JSC::UnlinkedMetadataTable::offsetTable16 const):
>+        (JSC::UnlinkedMetadataTable::offsetTable32 const):
>+        * bytecode/UnlinkedMetadataTableInlines.h:
>+        (JSC::UnlinkedMetadataTable::UnlinkedMetadataTable):
>+        (JSC::UnlinkedMetadataTable::addEntry):
>+        (JSC::UnlinkedMetadataTable::sizeInBytes):
>+        (JSC::UnlinkedMetadataTable::metadataTableSize const):
>+        (JSC::UnlinkedMetadataTable::link):
>+        (JSC::UnlinkedMetadataTable::unlink):
>+        (JSC::UnlinkedMetadataTable::finalize): Deleted.
>+        * llint/LowLevelInterpreter.asm:
>+        * runtime/CachedTypes.cpp:
>+        (JSC::CachedMetadataTable::encode):
>+        (JSC::CachedMetadataTable::decode const):
>+
> 2019-05-17  Keith Rollin  <krollin@apple.com>
> 
>         Re-enable generate-xcfilelists
>diff --git a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>index 7e21e0b07c532cc7a81b7510041ab2224c9d2e71..8a946248d2fd78eed9782f217f9a82df3b5a2802 100644
>--- a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>+++ b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>@@ -4723,6 +4723,7 @@
> 		E178636C0D9BEEC300D74E75 /* InitializeThreading.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InitializeThreading.cpp; sourceTree = "<group>"; };
> 		E18E3A560DF9278C00D90B34 /* VM.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = VM.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
> 		E18E3A570DF9278C00D90B34 /* VM.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = VM.cpp; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
>+		E3060128228F978100FAABDF /* UnlinkedMetadataTable.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = UnlinkedMetadataTable.cpp; sourceTree = "<group>"; };
> 		E30677971B8BC6F5003F87F0 /* ModuleLoader.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = ModuleLoader.js; sourceTree = "<group>"; };
> 		E31179A92288385D00514B2C /* SymbolTableOrScopeDepth.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SymbolTableOrScopeDepth.h; sourceTree = "<group>"; };
> 		E31618101EC5FE080006A218 /* DOMAnnotation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DOMAnnotation.h; sourceTree = "<group>"; };
>@@ -8065,6 +8066,7 @@
> 				14142E541B7973C000F4BF4B /* UnlinkedFunctionExecutable.cpp */,
> 				14142E501B796ECE00F4BF4B /* UnlinkedFunctionExecutable.h */,
> 				14AD911C1DCA9FA40014F9FE /* UnlinkedGlobalCodeBlock.h */,
>+				E3060128228F978100FAABDF /* UnlinkedMetadataTable.cpp */,
> 				142D52BE21762958002DB086 /* UnlinkedMetadataTable.h */,
> 				142D52BD21762957002DB086 /* UnlinkedMetadataTableInlines.h */,
> 				14AD912A1DCAAAB00014F9FE /* UnlinkedModuleProgramCodeBlock.cpp */,
>diff --git a/Source/JavaScriptCore/Sources.txt b/Source/JavaScriptCore/Sources.txt
>index 2196c97bbb129e2abdbc30c8f5ccb414d6528fb8..43d7ef475822a83afaf9a12e8cf9e11a9d7db87b 100644
>--- a/Source/JavaScriptCore/Sources.txt
>+++ b/Source/JavaScriptCore/Sources.txt
>@@ -273,6 +273,7 @@ bytecode/UnlinkedCodeBlock.cpp
> bytecode/UnlinkedEvalCodeBlock.cpp
> bytecode/UnlinkedFunctionCodeBlock.cpp
> bytecode/UnlinkedFunctionExecutable.cpp
>+bytecode/UnlinkedMetadataTable.cpp
> bytecode/UnlinkedModuleProgramCodeBlock.cpp
> bytecode/UnlinkedProgramCodeBlock.cpp
> bytecode/ValueRecovery.cpp
>diff --git a/Source/JavaScriptCore/bytecode/MetadataTable.h b/Source/JavaScriptCore/bytecode/MetadataTable.h
>index a5d4121b1d41d161bf26542e09286cfbd99395b8..b81c2d8b02f7d844cf3ade61a8cbe81ec3e722e7 100644
>--- a/Source/JavaScriptCore/bytecode/MetadataTable.h
>+++ b/Source/JavaScriptCore/bytecode/MetadataTable.h
>@@ -88,14 +88,23 @@ class MetadataTable {
>         return refCount() == 1;
>     }
> 
>-    UnlinkedMetadataTable::Offset* buffer()
>-    {
>-        return bitwise_cast<UnlinkedMetadataTable::Offset*>(this);
>-    }
>+    void* buffer() { return this; }
>+
>+    bool is32Bit() const { return !offsetTable16()[0]; }
> 
> private:
>     MetadataTable(UnlinkedMetadataTable&);
> 
>+    uint16_t* offsetTable16() const { return bitwise_cast<uint16_t*>(this); }
>+    uint32_t* offsetTable32() const { return bitwise_cast<uint32_t*>(bitwise_cast<uint8_t*>(this) + UnlinkedMetadataTable::s_offset16TableSize); }
>+
>+    size_t totalSize() const
>+    {
>+        if (is32Bit())
>+            return offsetTable32()[UnlinkedMetadataTable::s_offsetTableEntries - 1];
>+        return offsetTable16()[UnlinkedMetadataTable::s_offsetTableEntries - 1];
>+    }
>+
>     UnlinkedMetadataTable::LinkingData& linkingData() const
>     {
>         return *bitwise_cast<UnlinkedMetadataTable::LinkingData*>((bitwise_cast<uint8_t*>(this) - sizeof(UnlinkedMetadataTable::LinkingData)));
>@@ -103,7 +112,10 @@ class MetadataTable {
> 
>     ALWAYS_INLINE uint8_t* getImpl(unsigned i)
>     {
>-        return bitwise_cast<uint8_t*>(this) + buffer()[i];
>+        unsigned offset = offsetTable16()[i];
>+        if (!offset)
>+            offset = offsetTable32()[i];
>+        return bitwise_cast<uint8_t*>(this) + offset;
>     }
> };
> 
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.cpp b/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..a1dd79837e4d8786da39a21820c7e82d74c5aad2
>--- /dev/null
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.cpp
>@@ -0,0 +1,83 @@
>+/*
>+ * Copyright (C) 2019 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.
>+ */
>+
>+#include "config.h"
>+#include "UnlinkedMetadataTable.h"
>+
>+#include "CodeBlock.h"
>+#include "JSCInlines.h"
>+#include "OpcodeInlines.h"
>+#include "UnlinkedMetadataTableInlines.h"
>+#include <wtf/FastMalloc.h>
>+
>+namespace JSC {
>+
>+void UnlinkedMetadataTable::finalize()
>+{
>+    ASSERT(!m_isFinalized);
>+    m_isFinalized = true;
>+    if (!m_hasMetadata) {
>+        fastFree(m_rawBuffer);
>+        m_rawBuffer = nullptr;
>+        return;
>+    }
>+
>+    unsigned offset = s_offset16TableSize;
>+    {
>+        Offset32* buffer = preprocessBuffer();
>+        for (unsigned i = 0; i < s_offsetTableEntries - 1; i++) {
>+            unsigned numberOfEntries = buffer[i];
>+            if (!numberOfEntries) {
>+                buffer[i] = offset;
>+                continue;
>+            }
>+            offset = roundUpToMultipleOf(metadataAlignment(static_cast<OpcodeID>(i)), offset);
>+            buffer[i] = offset;
>+            offset += numberOfEntries * metadataSize(static_cast<OpcodeID>(i));
>+            if (offset > UINT16_MAX)
>+                m_is32Bit = true;
>+        }
>+        buffer[s_offsetTableEntries - 1] = offset;
>+    }
>+
>+    if (m_is32Bit) {
>+        m_rawBuffer = reinterpret_cast<uint8_t*>(fastRealloc(m_rawBuffer, s_offset16TableSize + s_offset32TableSize + sizeof(LinkingData)));
>+        memmove(m_rawBuffer + sizeof(LinkingData) + s_offset16TableSize, m_rawBuffer + sizeof(LinkingData), s_offset32TableSize);
>+        memset(m_rawBuffer + sizeof(LinkingData), 0, s_offset16TableSize);
>+        uint32_t* buffer = bitwise_cast<uint32_t*>(m_rawBuffer + sizeof(LinkingData) + s_offset16TableSize);
>+        for (unsigned i = 0; i < s_offsetTableEntries; i++)
>+            buffer[i] += s_offset32TableSize;
>+    } else {
>+        auto* oldRawBuffer = m_rawBuffer;
>+        m_rawBuffer = static_cast<uint8_t*>(fastMalloc(s_offset16TableSize + sizeof(LinkingData)));
>+        uint32_t* oldBuffer = bitwise_cast<uint32_t*>(oldRawBuffer + sizeof(LinkingData));
>+        uint16_t* buffer = bitwise_cast<uint16_t*>(m_rawBuffer + sizeof(LinkingData));
>+        for (unsigned i = 0; i < s_offsetTableEntries; i++)
>+            buffer[i] = oldBuffer[i];
>+        fastFree(oldRawBuffer);
>+    }
>+}
>+
>+} // namespace JSC
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.h b/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.h
>index 4991c158ba023f247f3b979222449605bd9f5c66..9e6f30eeeba977351074740a139a4d4b5f72946d 100644
>--- a/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.h
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.h
>@@ -61,22 +61,37 @@ class UnlinkedMetadataTable : public RefCounted<UnlinkedMetadataTable> {
> 
> private:
>     UnlinkedMetadataTable();
>+    UnlinkedMetadataTable(bool is32Bit);
>+
>+    static Ref<UnlinkedMetadataTable> create(bool is32Bit)
>+    {
>+        return adoptRef(*new UnlinkedMetadataTable(is32Bit));
>+    }
> 
>     void unlink(MetadataTable&);
> 
>     size_t sizeInBytes(MetadataTable&);
> 
>-    using Offset = unsigned;
>+    size_t metadataTableSize() const;
>+
>+    using Offset32 = uint32_t;
>+    using Offset16 = uint16_t;
> 
>     static constexpr unsigned s_offsetTableEntries = NUMBER_OF_BYTECODE_WITH_METADATA + 1; // one extra entry for the "end" offset;
>-    static constexpr unsigned s_offsetTableSize = s_offsetTableEntries * sizeof(UnlinkedMetadataTable::Offset);
>+    static constexpr unsigned s_offset16TableSize = roundUpToMultipleOf<sizeof(uint32_t)>(s_offsetTableEntries * sizeof(uint16_t));
>+    static constexpr unsigned s_offset32TableSize = s_offsetTableEntries * sizeof(uint32_t);
>+
>+    Offset32* preprocessBuffer() const { return bitwise_cast<Offset32*>(m_rawBuffer + sizeof(LinkingData)); }
>+    void* buffer() const { return m_rawBuffer + sizeof(LinkingData); }
> 
>-    Offset* buffer() const { return bitwise_cast<Offset*>(bitwise_cast<uint8_t*>(m_rawBuffer) + sizeof(LinkingData)); }
>+    uint16_t* offsetTable16() const { return bitwise_cast<uint16_t*>(m_rawBuffer + sizeof(LinkingData)); }
>+    uint32_t* offsetTable32() const { return bitwise_cast<uint32_t*>(m_rawBuffer + sizeof(LinkingData) + s_offset16TableSize); }
> 
>     bool m_hasMetadata : 1;
>     bool m_isFinalized : 1;
>     bool m_isLinked : 1;
>-    void* m_rawBuffer;
>+    bool m_is32Bit : 1;
>+    uint8_t* m_rawBuffer;
> };
> 
> } // namespace JSC
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedMetadataTableInlines.h b/Source/JavaScriptCore/bytecode/UnlinkedMetadataTableInlines.h
>index 3353922ca83c31d6697ea5e6ba5238c16386938a..d92996c452ea60ec1e0dda276f27973651c86d6a 100644
>--- a/Source/JavaScriptCore/bytecode/UnlinkedMetadataTableInlines.h
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedMetadataTableInlines.h
>@@ -35,10 +35,21 @@ ALWAYS_INLINE UnlinkedMetadataTable::UnlinkedMetadataTable()
>     : m_hasMetadata(false)
>     , m_isFinalized(false)
>     , m_isLinked(false)
>-    , m_rawBuffer(fastZeroedMalloc(sizeof(LinkingData) + s_offsetTableSize))
>+    , m_is32Bit(false)
>+    , m_rawBuffer(static_cast<uint8_t*>(fastZeroedMalloc(sizeof(LinkingData) + s_offset32TableSize)))
> {
> }
> 
>+ALWAYS_INLINE UnlinkedMetadataTable::UnlinkedMetadataTable(bool is32Bit)
>+    : m_hasMetadata(false)
>+    , m_isFinalized(false)
>+    , m_isLinked(false)
>+    , m_is32Bit(is32Bit)
>+    , m_rawBuffer(static_cast<uint8_t*>(fastZeroedMalloc(sizeof(LinkingData) + (is32Bit ? s_offset16TableSize + s_offset32TableSize : s_offset16TableSize))))
>+{
>+    memset(offsetTable16(), 0, UnlinkedMetadataTable::s_offsetTableEntries * sizeof(Offset16));
>+}
>+
> ALWAYS_INLINE UnlinkedMetadataTable::~UnlinkedMetadataTable()
> {
>     ASSERT(!m_isLinked);
>@@ -50,7 +61,7 @@ ALWAYS_INLINE unsigned UnlinkedMetadataTable::addEntry(OpcodeID opcodeID)
> {
>     ASSERT(!m_isFinalized && opcodeID < s_offsetTableEntries - 1);
>     m_hasMetadata = true;
>-    return buffer()[opcodeID]++;
>+    return preprocessBuffer()[opcodeID]++;
> }
> 
> ALWAYS_INLINE size_t UnlinkedMetadataTable::sizeInBytes()
>@@ -58,7 +69,18 @@ ALWAYS_INLINE size_t UnlinkedMetadataTable::sizeInBytes()
>     if (m_isFinalized && !m_hasMetadata)
>         return 0;
> 
>-    return s_offsetTableSize;
>+    if (m_is32Bit)
>+        return s_offset16TableSize + s_offset32TableSize;
>+    return s_offset16TableSize;
>+}
>+
>+inline size_t UnlinkedMetadataTable::metadataTableSize() const
>+{
>+    if (m_isFinalized && !m_hasMetadata)
>+        return 0;
>+    if (m_is32Bit)
>+        return offsetTable32()[s_offsetTableEntries - 1];
>+    return offsetTable16()[s_offsetTableEntries - 1];
> }
> 
> ALWAYS_INLINE size_t UnlinkedMetadataTable::sizeInBytes(MetadataTable& metadataTable)
>@@ -67,36 +89,14 @@ ALWAYS_INLINE size_t UnlinkedMetadataTable::sizeInBytes(MetadataTable& metadataT
> 
>     // In this case, we return the size of the table minus the offset table,
>     // which was already accounted for in the UnlinkedCodeBlock.
>+    size_t result = metadataTable.totalSize();
>     if (metadataTable.buffer() == buffer()) {
>         ASSERT(m_isLinked);
>-        return buffer()[s_offsetTableEntries - 1] - s_offsetTableSize;
>-    }
>-
>-    return metadataTable.buffer()[s_offsetTableEntries - 1];
>-}
>-
>-ALWAYS_INLINE void UnlinkedMetadataTable::finalize()
>-{
>-    ASSERT(!m_isFinalized);
>-    m_isFinalized = true;
>-    if (!m_hasMetadata) {
>-        fastFree(m_rawBuffer);
>-        m_rawBuffer = nullptr;
>-        return;
>+        if (m_is32Bit)
>+            return result - (s_offset16TableSize + s_offset32TableSize);
>+        return result - s_offset16TableSize;
>     }
>-
>-    unsigned offset = s_offsetTableSize;
>-    for (unsigned i = 0; i < s_offsetTableEntries - 1; i++) {
>-        unsigned numberOfEntries = buffer()[i];
>-
>-        if (numberOfEntries > 0) {
>-            offset = roundUpToMultipleOf(metadataAlignment(static_cast<OpcodeID>(i)), offset);
>-            buffer()[i] = offset;
>-            offset += numberOfEntries * metadataSize(static_cast<OpcodeID>(i));
>-        } else
>-            buffer()[i] = offset;
>-    }
>-    buffer()[s_offsetTableEntries - 1] = offset;
>+    return result;
> }
> 
> ALWAYS_INLINE RefPtr<MetadataTable> UnlinkedMetadataTable::link()
>@@ -106,16 +106,25 @@ ALWAYS_INLINE RefPtr<MetadataTable> UnlinkedMetadataTable::link()
>     if (!m_hasMetadata)
>         return nullptr;
> 
>-    unsigned totalSize = buffer()[s_offsetTableEntries - 1];
>+    unsigned totalSize = 0;
>+    if (m_is32Bit)
>+        totalSize = offsetTable32()[s_offsetTableEntries - 1];
>+    else
>+        totalSize = offsetTable16()[s_offsetTableEntries - 1];
>+
>+    unsigned offsetTableSize = s_offset16TableSize;
>+    if (m_is32Bit)
>+        offsetTableSize += s_offset32TableSize;
>+
>     uint8_t* buffer;
>     if (!m_isLinked) {
>         m_isLinked = true;
>         m_rawBuffer = buffer = reinterpret_cast<uint8_t*>(fastRealloc(m_rawBuffer, sizeof(LinkingData) + totalSize));
>     } else {
>         buffer = reinterpret_cast<uint8_t*>(fastMalloc(sizeof(LinkingData) + totalSize));
>-        memcpy(buffer, m_rawBuffer, sizeof(LinkingData) + s_offsetTableSize);
>+        memcpy(buffer, m_rawBuffer, sizeof(LinkingData) + offsetTableSize);
>     }
>-    memset(buffer + sizeof(LinkingData) + s_offsetTableSize, 0, totalSize - s_offsetTableSize);
>+    memset(buffer + sizeof(LinkingData) + offsetTableSize, 0, totalSize - offsetTableSize);
>     return adoptRef(*new (buffer + sizeof(LinkingData)) MetadataTable(*this));
> }
> 
>@@ -125,10 +134,14 @@ ALWAYS_INLINE void UnlinkedMetadataTable::unlink(MetadataTable& metadataTable)
>     if (!m_hasMetadata)
>         return;
> 
>+    unsigned offsetTableSize = s_offset16TableSize;
>+    if (m_is32Bit)
>+        offsetTableSize += s_offset32TableSize;
>+
>     if (metadataTable.buffer() == buffer()) {
>         ASSERT(m_isLinked);
>         m_isLinked = false;
>-        m_rawBuffer = fastRealloc(m_rawBuffer, sizeof(LinkingData) + s_offsetTableSize);
>+        m_rawBuffer = static_cast<uint8_t*>(fastRealloc(m_rawBuffer, sizeof(LinkingData) + offsetTableSize));
>         return;
>     }
>     fastFree(&metadataTable.linkingData());
>diff --git a/Source/JavaScriptCore/llint/LowLevelInterpreter.asm b/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>index bc419ed617900013344e615dae86fb4611f71902..1525a5431d039cac05db2b9aa54f5e2ed09ffbdc 100644
>--- a/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>+++ b/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>@@ -181,6 +181,9 @@ const ThisArgumentOffset = ArgumentCount + SlotSize
> const FirstArgumentOffset = ThisArgumentOffset + SlotSize
> const CallFrameHeaderSize = ThisArgumentOffset
> 
>+const MetadataOffsetTable16 = 0
>+const MetadataOffsetTable32 = constexpr UnlinkedMetadataTable::s_offset16TableSize
>+
> # Some value representation constants.
> if JSVALUE64
>     const TagBitTypeOther = constexpr TagBitTypeOther
>@@ -336,7 +339,10 @@ macro wide(narrowFn, wideFn, k)
> end
> 
> macro metadata(size, opcode, dst, scratch)
>-    loadi constexpr %opcode%::opcodeID * 4[metadataTable], dst # offset = metadataTable<unsigned*>[opcodeID]
>+    loadh (constexpr %opcode%::opcodeID * 2 + MetadataOffsetTable16)[metadataTable], dst # offset = metadataTable<uint16_t*>[opcodeID]
>+    btinz dst, .setUpOffset
>+    loadi (constexpr %opcode%::opcodeID * 4 + MetadataOffsetTable32)[metadataTable], dst # offset = metadataTable<uint32_t*>[opcodeID]
>+.setUpOffset:
>     getu(size, opcode, m_metadataID, scratch) # scratch = bytecode.m_metadataID
>     muli sizeof %opcode%::Metadata, scratch # scratch *= sizeof(Op::Metadata)
>     addi scratch, dst # offset += scratch
>diff --git a/Source/JavaScriptCore/runtime/CachedTypes.cpp b/Source/JavaScriptCore/runtime/CachedTypes.cpp
>index 3b610a8d7778a7d7b81ba0be6c137a4bd7636a3d..140551dcf708308debab86f3acd13f49de953e2e 100644
>--- a/Source/JavaScriptCore/runtime/CachedTypes.cpp
>+++ b/Source/JavaScriptCore/runtime/CachedTypes.cpp
>@@ -1331,23 +1331,35 @@ class CachedMetadataTable : public CachedObject<UnlinkedMetadataTable> {
>         m_hasMetadata = metadataTable.m_hasMetadata;
>         if (!m_hasMetadata)
>             return;
>-        for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)
>-            m_metadata[i] = metadataTable.buffer()[i];
>+        m_is32Bit = metadataTable.m_is32Bit;
>+        if (m_is32Bit) {
>+            for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)
>+                m_metadata[i] = metadataTable.offsetTable32()[i];
>+        } else {
>+            for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)
>+                m_metadata[i] = metadataTable.offsetTable16()[i];
>+        }
>     }
> 
>     Ref<UnlinkedMetadataTable> decode(Decoder&) const
>     {
>-        Ref<UnlinkedMetadataTable> metadataTable = UnlinkedMetadataTable::create();
>+        Ref<UnlinkedMetadataTable> metadataTable = UnlinkedMetadataTable::create(m_is32Bit);
>         metadataTable->m_isFinalized = true;
>         metadataTable->m_isLinked = false;
>         metadataTable->m_hasMetadata = m_hasMetadata;
>-        for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)
>-            metadataTable->buffer()[i] = m_metadata[i];
>+        if (m_is32Bit) {
>+            for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)
>+                metadataTable->offsetTable32()[i] = m_metadata[i];
>+        } else {
>+            for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)
>+                metadataTable->offsetTable16()[i] = m_metadata[i];
>+        }
>         return metadataTable;
>     }
> 
> private:
>     bool m_hasMetadata;
>+    bool m_is32Bit;
>     std::array<unsigned, UnlinkedMetadataTable::s_offsetTableEntries> m_metadata;
> };
>

Actions: View | Formatted Diff | Diff

Attachments on bug 197910: 370177 | 370185 | 370189 | 370190