| /**************************************************************************** |
| ** |
| ** Copyright (C) 2018 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtQml module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| #include "qv4arraybuffer_p.h" |
| #include "qv4typedarray_p.h" |
| #include "qv4atomics_p.h" |
| #include "qv4symbol_p.h" |
| |
| using namespace QV4; |
| |
| DEFINE_OBJECT_VTABLE(Atomics); |
| |
| void Heap::Atomics::init() |
| { |
| Object::init(); |
| Scope scope(internalClass->engine); |
| ScopedObject m(scope, this); |
| |
| m->defineDefaultProperty(QStringLiteral("add"), QV4::Atomics::method_add, 3); |
| m->defineDefaultProperty(QStringLiteral("and"), QV4::Atomics::method_and, 3); |
| m->defineDefaultProperty(QStringLiteral("compareExchange"), QV4::Atomics::method_compareExchange, 4); |
| m->defineDefaultProperty(QStringLiteral("exchange"), QV4::Atomics::method_exchange, 3); |
| m->defineDefaultProperty(QStringLiteral("isLockFree"), QV4::Atomics::method_isLockFree, 1); |
| m->defineDefaultProperty(QStringLiteral("load"), QV4::Atomics::method_load, 2); |
| m->defineDefaultProperty(QStringLiteral("or"), QV4::Atomics::method_or, 3); |
| m->defineDefaultProperty(QStringLiteral("store"), QV4::Atomics::method_store, 3); |
| m->defineDefaultProperty(QStringLiteral("sub"), QV4::Atomics::method_sub, 3); |
| m->defineDefaultProperty(QStringLiteral("wait"), QV4::Atomics::method_wait, 4); |
| m->defineDefaultProperty(QStringLiteral("wake"), QV4::Atomics::method_wake, 3); |
| m->defineDefaultProperty(QStringLiteral("xor"), QV4::Atomics::method_xor, 3); |
| |
| ScopedString name(scope, scope.engine->newString(QStringLiteral("Atomics"))); |
| m->defineReadonlyConfigurableProperty(scope.engine->symbol_toStringTag(), name); |
| } |
| |
| static SharedArrayBuffer *validateSharedIntegerTypedArray(Scope &scope, const Value &typedArray, bool onlyInt32 = false) |
| { |
| const TypedArray *a = typedArray.as<TypedArray>(); |
| if (!a) { |
| scope.engine->throwTypeError(); |
| return nullptr; |
| } |
| |
| TypedArrayType t(a->arrayType()); |
| if (!a->d()->type->atomicLoad || (onlyInt32 && t != TypedArrayType::Int32Array)) { |
| scope.engine->throwTypeError(); |
| return nullptr; |
| } |
| |
| Scoped<SharedArrayBuffer> buffer(scope, a->d()->buffer); |
| if (!buffer->isSharedArrayBuffer()) { |
| scope.engine->throwTypeError(); |
| return nullptr; |
| } |
| Q_ASSERT(!buffer->isDetachedBuffer()); |
| return buffer; |
| } |
| |
| static int validateAtomicAccess(Scope &scope, const TypedArray &typedArray, const Value &index) |
| { |
| const TypedArray &a = static_cast<const TypedArray &>(typedArray); |
| qint64 idx = index.toIndex(); |
| if (scope.hasException()) |
| return -1; |
| if (idx < 0 || idx >= a.length()) { |
| scope.engine->throwRangeError(QStringLiteral("index out of range.")); |
| return -1; |
| } |
| return static_cast<int>(idx); |
| } |
| |
| ReturnedValue atomicReadModifyWrite(const FunctionObject *f, const Value *argv, int argc, AtomicModifyOps modify) |
| { |
| Scope scope(f); |
| if (!argc) |
| return scope.engine->throwTypeError(); |
| |
| SharedArrayBuffer *buffer = validateSharedIntegerTypedArray(scope, argv[0]); |
| if (!buffer) |
| return Encode::undefined(); |
| const TypedArray &a = static_cast<const TypedArray &>(argv[0]); |
| int index = validateAtomicAccess(scope, a, argc > 1 ? argv[1] : Value::undefinedValue()); |
| if (index < 0) |
| return Encode::undefined(); |
| |
| Value v = Value::fromReturnedValue((argc > 2 ? argv[2] : Value::undefinedValue()).convertedToNumber()); |
| if (scope.hasException()) |
| return Encode::undefined(); |
| |
| int bytesPerElement = a.d()->type->bytesPerElement; |
| int byteOffset = a.d()->byteOffset + index * bytesPerElement; |
| |
| return a.d()->type->atomicModifyOps[modify](buffer->data() + byteOffset, v); |
| } |
| |
| ReturnedValue Atomics::method_add(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| return atomicReadModifyWrite(f, argv, argc, AtomicAdd); |
| } |
| |
| ReturnedValue Atomics::method_and(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| return atomicReadModifyWrite(f, argv, argc, AtomicAnd); |
| } |
| |
| ReturnedValue Atomics::method_compareExchange(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| Scope scope(f); |
| if (!argc) |
| return scope.engine->throwTypeError(); |
| |
| SharedArrayBuffer *buffer = validateSharedIntegerTypedArray(scope, argv[0]); |
| if (!buffer) |
| return Encode::undefined(); |
| const TypedArray &a = static_cast<const TypedArray &>(argv[0]); |
| int index = validateAtomicAccess(scope, a, argc > 1 ? argv[1] : Value::undefinedValue()); |
| if (index < 0) |
| return Encode::undefined(); |
| |
| Value expected = Value::fromReturnedValue((argc > 2 ? argv[2] : Value::undefinedValue()).convertedToNumber()); |
| if (scope.hasException()) |
| return Encode::undefined(); |
| Value v = Value::fromReturnedValue((argc > 3 ? argv[3] : Value::undefinedValue()).convertedToNumber()); |
| if (scope.hasException()) |
| return Encode::undefined(); |
| |
| int bytesPerElement = a.d()->type->bytesPerElement; |
| int byteOffset = a.d()->byteOffset + index * bytesPerElement; |
| |
| return a.d()->type->atomicCompareExchange(buffer->data() + byteOffset, expected, v); |
| } |
| |
| ReturnedValue Atomics::method_exchange(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| return atomicReadModifyWrite(f, argv, argc, AtomicExchange); |
| } |
| |
| ReturnedValue Atomics::method_isLockFree(const FunctionObject *, const Value *, const Value *argv, int argc) |
| { |
| if (!argc) |
| return Encode(false); |
| double n = argv[0].toInteger(); |
| if (n == 4.) |
| return Encode(true); |
| if (n == 2.) |
| return Encode(QAtomicOps<unsigned short>::isTestAndSetNative()); |
| #ifdef Q_ATOMIC_INT8_IS_SUPPORTED |
| if (n == 1.) |
| return Encode(QAtomicOps<unsigned char>::isTestAndSetNative()); |
| #endif |
| return Encode(false); |
| } |
| |
| ReturnedValue Atomics::method_load(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| Scope scope(f); |
| if (!argc) |
| return scope.engine->throwTypeError(); |
| |
| SharedArrayBuffer *buffer = validateSharedIntegerTypedArray(scope, argv[0]); |
| if (!buffer) |
| return Encode::undefined(); |
| const TypedArray &a = static_cast<const TypedArray &>(argv[0]); |
| int index = validateAtomicAccess(scope, a, argc > 1 ? argv[1] : Value::undefinedValue()); |
| if (index < 0) |
| return Encode::undefined(); |
| |
| int bytesPerElement = a.d()->type->bytesPerElement; |
| int byteOffset = a.d()->byteOffset + index * bytesPerElement; |
| |
| return a.d()->type->atomicLoad(buffer->data() + byteOffset); |
| } |
| |
| ReturnedValue Atomics::method_or(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| return atomicReadModifyWrite(f, argv, argc, AtomicOr); |
| } |
| |
| ReturnedValue Atomics::method_store(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| Scope scope(f); |
| if (!argc) |
| return scope.engine->throwTypeError(); |
| |
| SharedArrayBuffer *buffer = validateSharedIntegerTypedArray(scope, argv[0]); |
| if (!buffer) |
| return Encode::undefined(); |
| const TypedArray &a = static_cast<const TypedArray &>(argv[0]); |
| int index = validateAtomicAccess(scope, a, argc > 1 ? argv[1] : Value::undefinedValue()); |
| if (index < 0) |
| return Encode::undefined(); |
| |
| Value v = Value::fromReturnedValue((argc > 2 ? argv[2] : Value::undefinedValue()).convertedToNumber()); |
| if (scope.hasException()) |
| return Encode::undefined(); |
| |
| int bytesPerElement = a.d()->type->bytesPerElement; |
| int byteOffset = a.d()->byteOffset + index * bytesPerElement; |
| |
| return a.d()->type->atomicStore(buffer->data() + byteOffset, v); |
| } |
| |
| ReturnedValue Atomics::method_sub(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| return atomicReadModifyWrite(f, argv, argc, AtomicSub); |
| } |
| |
| ReturnedValue Atomics::method_wait(const FunctionObject *f, const Value *, const Value *, int) |
| { |
| return f->engine()->throwTypeError(); |
| } |
| |
| ReturnedValue Atomics::method_wake(const FunctionObject *f, const Value *, const Value *, int) |
| { |
| return f->engine()->throwTypeError(); |
| } |
| |
| ReturnedValue Atomics::method_xor(const FunctionObject *f, const Value *, const Value *argv, int argc) |
| { |
| return atomicReadModifyWrite(f, argv, argc, AtomicXor); |
| |
| } |