Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#ifndef QJSVALUE_P_H
#define QJSVALUE_P_H
#include <qjsvalue.h>
#include <private/qtqmlglobal_p.h>
#include <private/qv4value_p.h>
#include <private/qv4string_p.h>
#include <private/qv4engine_p.h>
#include <private/qv4mm_p.h>
#include <private/qv4persistent_p.h>
#include <QtCore/qthread.h>
QT_BEGIN_NAMESPACE
class QJSValuePrivate
{
static constexpr quint64 s_tagBits = 3; // 3 bits mask
static constexpr quint64 s_tagMask = (1 << s_tagBits) - 1;
static constexpr quint64 s_pointerBit = 0x1;
public:
enum class Kind {
Undefined = 0x0,
Null = 0x2,
IntValue = 0x4,
BoolValue = 0x6,
DoublePtr = 0x0 | s_pointerBit,
QV4ValuePtr = 0x2 | s_pointerBit,
QStringPtr = 0x4 | s_pointerBit,
};
static_assert(quint64(Kind::Undefined) <= s_tagMask);
static_assert(quint64(Kind::Null) <= s_tagMask);
static_assert(quint64(Kind::IntValue) <= s_tagMask);
static_assert(quint64(Kind::BoolValue) <= s_tagMask);
static_assert(quint64(Kind::DoublePtr) <= s_tagMask);
static_assert(quint64(Kind::QV4ValuePtr) <= s_tagMask);
static_assert(quint64(Kind::QStringPtr) <= s_tagMask);
static Kind tag(quint64 raw) { return Kind(raw & s_tagMask); }
#if QT_POINTER_SIZE == 4
static void *pointer(quint64 raw)
{
Q_ASSERT(quint64(tag(raw)) & s_pointerBit);
return reinterpret_cast<void *>(raw >> 32);
}
static quint64 encodePointer(void *pointer, Kind tag)
{
Q_ASSERT(quint64(tag) & s_pointerBit);
return (quint64(quintptr(pointer)) << 32) | quint64(tag);
}
#else
static constexpr quint64 s_minAlignment = 1 << s_tagBits;
static_assert(alignof(double) >= s_minAlignment);
static_assert(alignof(QV4::Value) >= s_minAlignment);
static_assert(alignof(QString) >= s_minAlignment);
static void *pointer(quint64 raw)
{
Q_ASSERT(quint64(tag(raw)) & s_pointerBit);
return reinterpret_cast<void *>(raw & ~s_tagMask);
}
static quint64 encodePointer(void *pointer, Kind tag)
{
Q_ASSERT(quint64(tag) & s_pointerBit);
return quintptr(pointer) | quint64(tag);
}
#endif
static quint64 encodeUndefined()
{
return quint64(Kind::Undefined);
}
static quint64 encodeNull()
{
return quint64(Kind::Null);
}
static int intValue(quint64 v)
{
Q_ASSERT(tag(v) == Kind::IntValue);
return v >> 32;
}
static quint64 encode(int intValue)
{
return (quint64(intValue) << 32) | quint64(Kind::IntValue);
}
static quint64 encode(uint uintValue)
{
return (uintValue < uint(std::numeric_limits<int>::max()))
? encode(int(uintValue))
: encode(double(uintValue));
}
static bool boolValue(quint64 v)
{
Q_ASSERT(tag(v) == Kind::BoolValue);
return v >> 32;
}
static quint64 encode(bool boolValue)
{
return (quint64(boolValue) << 32) | quint64(Kind::BoolValue);
}
static double *doublePtr(quint64 v)
{
Q_ASSERT(tag(v) == Kind::DoublePtr);
return static_cast<double *>(pointer(v));
}
static quint64 encode(double doubleValue)
{
return encodePointer(new double(doubleValue), Kind::DoublePtr);
}
static QV4::Value *qv4ValuePtr(quint64 v)
{
Q_ASSERT(tag(v) == Kind::QV4ValuePtr);
return static_cast<QV4::Value *>(pointer(v));
}
static quint64 encode(const QV4::Value &qv4Value)
{
switch (qv4Value.type()) {
case QV4::StaticValue::Boolean_Type:
return encode(qv4Value.booleanValue());
case QV4::StaticValue::Integer_Type:
return encode(qv4Value.integerValue());
case QV4::StaticValue::Managed_Type: {
auto managed = qv4Value.as<QV4::Managed>();
auto engine = managed->engine();
auto mm = engine->memoryManager;
QV4::Value *m = mm->m_persistentValues->allocate();
Q_ASSERT(m);
// we create a new strong reference to the heap managed object
// to avoid having to rescan the persistent values, we mark it here
QV4::WriteBarrier::markCustom(engine, [&](QV4::MarkStack *stack){
if constexpr (QV4::WriteBarrier::isInsertionBarrier)
managed->heapObject()->mark(stack);
});
*m = qv4Value;
return encodePointer(m, Kind::QV4ValuePtr);
}
case QV4::StaticValue::Double_Type:
return encode(qv4Value.doubleValue());
case QV4::StaticValue::Null_Type:
return encodeNull();
case QV4::StaticValue::Empty_Type:
Q_UNREACHABLE();
break;
case QV4::StaticValue::Undefined_Type:
break;
}
return encodeUndefined();
}
static QString *qStringPtr(quint64 v)
{
Q_ASSERT(tag(v) == Kind::QStringPtr);
return static_cast<QString *>(pointer(v));
}
static quint64 encode(QString stringValue)
{
return encodePointer(new QString(std::move(stringValue)), Kind::QStringPtr);
}
static quint64 encode(QLatin1String stringValue)
{
return encodePointer(new QString(std::move(stringValue)), Kind::QStringPtr);
}
static QJSValue fromReturnedValue(QV4::ReturnedValue d)
{
QJSValue result;
setValue(&result, QV4::Value::fromReturnedValue(d));
return result;
}
template<typename T>
static const T *asManagedType(const QJSValue *jsval)
{
if (tag(jsval->d) == Kind::QV4ValuePtr) {
if (const QV4::Value *value = qv4ValuePtr(jsval->d))
return value->as<T>();
}
return nullptr;
}
// This is a move operation and transfers ownership.
static QV4::Value *takeManagedValue(QJSValue *jsval)
{
if (tag(jsval->d) == Kind::QV4ValuePtr) {
if (QV4::Value *value = qv4ValuePtr(jsval->d)) {
jsval->d = encodeUndefined();
return value;
}
}
return nullptr;
}
static QV4::ReturnedValue asPrimitiveType(const QJSValue *jsval)
{
switch (tag(jsval->d)) {
case Kind::BoolValue:
return QV4::Encode(boolValue(jsval->d));
case Kind::IntValue:
return QV4::Encode(intValue(jsval->d));
case Kind::DoublePtr:
return QV4::Encode(*doublePtr(jsval->d));
case Kind::Null:
return QV4::Encode::null();
case Kind::Undefined:
case Kind::QV4ValuePtr:
case Kind::QStringPtr:
break;
}
return QV4::Encode::undefined();
}
// Beware: This only returns a non-null string if the QJSValue actually holds one.
// QV4::Strings are kept as managed values. Retrieve those with getValue().
static const QString *asQString(const QJSValue *jsval)
{
if (tag(jsval->d) == Kind::QStringPtr) {
if (const QString *string = qStringPtr(jsval->d))
return string;
}
return nullptr;
}
static QV4::ReturnedValue asReturnedValue(const QJSValue *jsval)
{
switch (tag(jsval->d)) {
case Kind::BoolValue:
return QV4::Encode(boolValue(jsval->d));
case Kind::IntValue:
return QV4::Encode(intValue(jsval->d));
case Kind::DoublePtr:
return QV4::Encode(*doublePtr(jsval->d));
case Kind::Null:
return QV4::Encode::null();
case Kind::QV4ValuePtr:
return qv4ValuePtr(jsval->d)->asReturnedValue();
case Kind::Undefined:
case Kind::QStringPtr:
break;
}
return QV4::Encode::undefined();
}
static void setString(QJSValue *jsval, QString s)
{
jsval->d = encode(std::move(s));
}
// Only use this with an existing persistent value.
// Ownership is transferred to the QJSValue.
static void adoptPersistentValue(QJSValue *jsval, QV4::Value *v)
{
jsval->d = encodePointer(v, Kind::QV4ValuePtr);
}
static void setValue(QJSValue *jsval, const QV4::Value &v)
{
jsval->d = encode(v);
}
// Moves any QString onto the V4 heap, changing the value to reflect that.
static void manageStringOnV4Heap(QV4::ExecutionEngine *e, QJSValue *jsval)
{
if (const QString *string = asQString(jsval)) {
jsval->d = encode(QV4::Value::fromHeapObject(e->newString(*string)));
delete string;
}
}
// Converts any QString on the fly, involving an allocation.
// Does not change the value.
static QV4::ReturnedValue convertToReturnedValue(QV4::ExecutionEngine *e,
const QJSValue &jsval)
{
if (const QString *string = asQString(&jsval))
return e->newString(*string)->asReturnedValue();
if (const QV4::Value *val = asManagedType<QV4::Managed>(&jsval)) {
if (QV4::PersistentValueStorage::getEngine(val) == e)
return val->asReturnedValue();
qWarning("JSValue can't be reassigned to another engine.");
return QV4::Encode::undefined();
}
return asPrimitiveType(&jsval);
}
static QV4::ExecutionEngine *engine(const QJSValue *jsval)
{
if (tag(jsval->d) == Kind::QV4ValuePtr) {
if (const QV4::Value *value = qv4ValuePtr(jsval->d))
return QV4::PersistentValueStorage::getEngine(value);
}
return nullptr;
}
static bool checkEngine(QV4::ExecutionEngine *e, const QJSValue &jsval)
{
QV4::ExecutionEngine *v4 = engine(&jsval);
return !v4 || v4 == e;
}
static void free(QJSValue *jsval)
{
switch (tag(jsval->d)) {
case Kind::Undefined:
case Kind::Null:
case Kind::IntValue:
case Kind::BoolValue:
return;
case Kind::DoublePtr:
delete doublePtr(jsval->d);
return;
case Kind::QStringPtr:
delete qStringPtr(jsval->d);
return;
case Kind::QV4ValuePtr:
break;
}
// We need a mutable value for free(). It needs to write to the actual memory.
QV4::Value *m = qv4ValuePtr(jsval->d);
Q_ASSERT(m); // Otherwise it would have been undefined above.
if (QV4::ExecutionEngine *e = QV4::PersistentValueStorage::getEngine(m)) {
if (QJSEngine *jsEngine = e->jsEngine()) {
if (jsEngine->thread() != QThread::currentThread()) {
QMetaObject::invokeMethod(
jsEngine, [m](){ QV4::PersistentValueStorage::free(m); });
return;
}
}
}
QV4::PersistentValueStorage::free(m);
}
};
QT_END_NAMESPACE
#endif