Imported QtWebKit TP3 (git b57bc6801f1876c3220d5a4bfea33d620d477443)

Change-Id: I3b1d8a2808782c9f34d50240000e20cb38d3680f
Reviewed-by: Konstantin Tokarev <annulen@yandex.ru>

1 files changed, 249 insertions, 0 deletions

diff --git a/Source/JavaScriptCore/wasm/WASMReader.cpp b/Source/JavaScriptCore/wasm/WASMReader.cpp
new file mode 100644
index 000000000..f6ac8e2fc
--- /dev/null
+++ b/Source/JavaScriptCore/wasm/WASMReader.cpp
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2015 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.
+ *
+ * =========================================================================
+ *
+ * Copyright (c) 2015 by the repository authors of
+ * WebAssembly/polyfill-prototype-1.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "config.h"
+#include "WASMReader.h"
+
+#if ENABLE(WEBASSEMBLY)
+
+#include <wtf/text/StringBuilder.h>
+
+#define CHECK_READ(length) do { if (m_cursor + length > m_buffer.end()) return false; } while (0)
+
+namespace JSC {
+
+bool WASMReader::readUInt32(uint32_t& result)
+{
+    CHECK_READ(4);
+    result = m_cursor[0] | m_cursor[1] << 8 | m_cursor[2] << 16 | m_cursor[3] << 24;
+    m_cursor += 4;
+    return true;
+}
+
+bool WASMReader::readFloat(float& result)
+{
+    CHECK_READ(4);
+    union {
+        uint8_t bytes[4];
+        float floatValue;
+    } u = {
+#if CPU(BIG_ENDIAN)
+        { m_cursor[3], m_cursor[2], m_cursor[1], m_cursor[0] }
+#else
+        { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3] }
+#endif
+    };
+    result = u.floatValue;
+    m_cursor += 4;
+    return true;
+}
+
+bool WASMReader::readDouble(double& result)
+{
+    CHECK_READ(8);
+    union {
+        uint8_t bytes[8];
+        double doubleValue;
+    } u = {
+#if CPU(BIG_ENDIAN)
+        { m_cursor[7], m_cursor[6], m_cursor[5], m_cursor[4], m_cursor[3], m_cursor[2], m_cursor[1], m_cursor[0] }
+#else
+        { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3], m_cursor[4], m_cursor[5], m_cursor[6], m_cursor[7] }
+#endif
+    };
+    result = u.doubleValue;
+    m_cursor += 8;
+    return true;
+}
+
+bool WASMReader::readCompactInt32(uint32_t& result)
+{
+    uint32_t sum = 0;
+    unsigned shift = 0;
+    do {
+        CHECK_READ(1);
+        uint8_t byte = *m_cursor++;
+        if (byte < 0x80) {
+            sum |= byte << shift;
+            int signExtend = (32 - 7) - shift;
+            if (signExtend > 0)
+                result = int32_t(sum) << signExtend >> signExtend;
+            else
+                result = int32_t(sum);
+            return true;
+        }
+        sum |= (byte & firstSevenBitsMask) << shift;
+        shift += 7;
+    } while (shift < 35);
+    return false;
+}
+
+bool WASMReader::readCompactUInt32(uint32_t& result)
+{
+    uint32_t sum = 0;
+    unsigned shift = 0;
+    do {
+        CHECK_READ(1);
+        uint32_t byte = *m_cursor++;
+        if (byte < 0x80) {
+            if ((shift == 28 && byte >= 0x10) || (shift && !byte))
+                return false;
+            result = sum | (byte << shift);
+            return true;
+        }
+        sum |= (byte & firstSevenBitsMask) << shift;
+        shift += 7;
+    } while (shift < 35);
+    return false;
+}
+
+bool WASMReader::readString(String& result)
+{
+    StringBuilder builder;
+    while (true) {
+        CHECK_READ(1);
+        char c = *m_cursor++;
+        if (!c)
+            break;
+        builder.append(c);
+    }
+    result = builder.toString();
+    return true;
+}
+
+bool WASMReader::readType(WASMType& result)
+{
+    return readByte<WASMType>(result, static_cast<uint8_t>(WASMType::NumberOfTypes));
+}
+
+bool WASMReader::readExpressionType(WASMExpressionType& result)
+{
+    return readByte<WASMExpressionType>(result, static_cast<uint8_t>(WASMExpressionType::NumberOfExpressionTypes));
+}
+
+bool WASMReader::readExportFormat(WASMExportFormat& result)
+{
+    return readByte<WASMExportFormat>(result, static_cast<uint8_t>(WASMExportFormat::NumberOfExportFormats));
+}
+
+template <class T> bool WASMReader::readByte(T& result, uint8_t numberOfValues)
+{
+    CHECK_READ(1);
+    uint8_t byte = *m_cursor++;
+    if (byte >= numberOfValues)
+        return false;
+    result = T(byte);
+    return true;
+}
+
+bool WASMReader::readOpStatement(bool& hasImmediate, WASMOpStatement& op, WASMOpStatementWithImmediate& opWithImmediate, uint8_t& immediate)
+{
+    return readOp(hasImmediate, op, opWithImmediate, immediate,
+        static_cast<uint8_t>(WASMOpStatement::NumberOfWASMOpStatements),
+        static_cast<uint8_t>(WASMOpStatementWithImmediate::NumberOfWASMOpStatementWithImmediates));
+}
+
+bool WASMReader::readOpExpressionI32(bool& hasImmediate, WASMOpExpressionI32& op, WASMOpExpressionI32WithImmediate& opWithImmediate, uint8_t& immediate)
+{
+    return readOp(hasImmediate, op, opWithImmediate, immediate,
+        static_cast<uint8_t>(WASMOpExpressionI32::NumberOfWASMOpExpressionI32s),
+        static_cast<uint8_t>(WASMOpExpressionI32WithImmediate::NumberOfWASMOpExpressionI32WithImmediates));
+}
+
+bool WASMReader::readOpExpressionF32(bool& hasImmediate, WASMOpExpressionF32& op, WASMOpExpressionF32WithImmediate& opWithImmediate, uint8_t& immediate)
+{
+    return readOp(hasImmediate, op, opWithImmediate, immediate,
+        static_cast<uint8_t>(WASMOpExpressionF32::NumberOfWASMOpExpressionF32s),
+        static_cast<uint8_t>(WASMOpExpressionF32WithImmediate::NumberOfWASMOpExpressionF32WithImmediates));
+}
+
+bool WASMReader::readOpExpressionF64(bool& hasImmediate, WASMOpExpressionF64& op, WASMOpExpressionF64WithImmediate& opWithImmediate, uint8_t& immediate)
+{
+    return readOp(hasImmediate, op, opWithImmediate, immediate,
+        static_cast<uint8_t>(WASMOpExpressionF64::NumberOfWASMOpExpressionF64s),
+        static_cast<uint8_t>(WASMOpExpressionF64WithImmediate::NumberOfWASMOpExpressionF64WithImmediates));
+}
+
+bool WASMReader::readOpExpressionVoid(WASMOpExpressionVoid& op)
+{
+    return readByte<WASMOpExpressionVoid>(op,
+        static_cast<uint8_t>(WASMOpExpressionVoid::NumberOfWASMOpExpressionVoids));
+}
+
+bool WASMReader::readVariableTypes(bool& hasImmediate, WASMVariableTypes& variableTypes, WASMVariableTypesWithImmediate& variableTypesWithImmediate, uint8_t& immediate)
+{
+    return readOp(hasImmediate, variableTypes, variableTypesWithImmediate, immediate,
+        static_cast<uint8_t>(WASMVariableTypes::NumberOfVariableTypes),
+        static_cast<uint8_t>(WASMVariableTypesWithImmediate::NumberOfVariableTypesWithImmediates));
+}
+
+template <class T, class TWithImmediate>
+bool WASMReader::readOp(bool& hasImmediate, T& op, TWithImmediate& opWithImmediate, uint8_t& immediate, uint8_t numberOfValues, uint8_t numberOfValuesWithImmediate)
+{
+    CHECK_READ(1);
+    uint8_t byte = *m_cursor++;
+
+    if (!(byte & hasImmediateInOpFlag)) {
+        if (byte >= numberOfValues)
+            return false;
+        hasImmediate = false;
+        op = T(byte);
+        return true;
+    }
+
+    uint8_t byteWithoutImmediate = (byte >> immediateBits) & (opWithImmediateLimit - 1);
+    if (byteWithoutImmediate >= numberOfValuesWithImmediate)
+        return false;
+    hasImmediate = true;
+    opWithImmediate = TWithImmediate(byteWithoutImmediate);
+    immediate = byte & (immediateLimit - 1);
+    return true;
+}
+
+bool WASMReader::readSwitchCase(WASMSwitchCase& result)
+{
+    return readByte<WASMSwitchCase>(result, static_cast<uint8_t>(WASMSwitchCase::NumberOfSwitchCases));
+}
+
+} // namespace JSC
+
+#endif // ENABLE(WEBASSEMBLY)