Revision control

++ // Copyright (C) 2017 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
++
++ #include "qqmlprofilerevent_p.h"
++ #include <QtCore/qdatastream.h>
++
++ QT_BEGIN_NAMESPACE
++
++ bool operator==(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2)
++ {
++ if (event1.timestamp() != event2.timestamp() || event1.typeIndex() != event2.typeIndex())
++ return false;
++
++ // This is not particularly efficient, but we also don't need to do this very often.
++ return event1.numbers<QVarLengthArray<qint64>>() == event2.numbers<QVarLengthArray<qint64>>();
++ }
++
++ bool operator!=(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2)
++ {
++ return !(event1 == event2);
++ }
++
++ enum SerializationType {
++ OneByte = 0,
++ TwoByte = 1,
++ FourByte = 2,
++ EightByte = 3,
++ TypeMask = 0x3
++ };
++
++ enum SerializationTypeOffset {
++ TimestampOffset = 0,
++ TypeIndexOffset = 2,
++ DataLengthOffset = 4,
++ DataOffset = 6
++ };
++
++ template<typename Number>
++ static inline void readNumbers(QDataStream &stream, Number *data, quint16 length)
++ {
++ for (quint16 i = 0; i != length; ++i)
++ stream >> data[i];
++ }
++
++ template<typename Number>
++ static inline Number readNumber(QDataStream &stream, qint8 type)
++ {
++ switch (type) {
++ case OneByte: {
++ qint8 value;
++ stream >> value;
++ return static_cast<Number>(value);
++ }
++ case TwoByte: {
++ qint16 value;
++ stream >> value;
++ return static_cast<Number>(value);
++ }
++ case FourByte: {
++ qint32 value;
++ stream >> value;
++ return static_cast<Number>(value);
++ }
++ case EightByte: {
++ qint64 value;
++ stream >> value;
++ return static_cast<Number>(value);
++ }
++ default:
++ Q_UNREACHABLE_RETURN(0);
++ }
++ }
++
++ QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event)
++ {
++ qint8 type;
++ stream >> type;
++
++ event.m_timestamp = readNumber<qint64>(stream, (type >> TimestampOffset) & TypeMask);
++ event.m_typeIndex = readNumber<qint32>(stream, (type >> TypeIndexOffset) & TypeMask);
++ event.m_dataLength = readNumber<quint16>(stream, (type >> DataLengthOffset) & TypeMask);
++
++ uint bytesPerNumber = 1 << ((type >> DataOffset) & TypeMask);
++
++ if (event.m_dataLength * bytesPerNumber > sizeof(event.m_data)) {
++ event.m_dataType = static_cast<QQmlProfilerEvent::Type>((bytesPerNumber * 8)
++ | QQmlProfilerEvent::External);
++ event.m_data.external = malloc(event.m_dataLength * bytesPerNumber);
++ } else {
++ event.m_dataType = static_cast<QQmlProfilerEvent::Type>(bytesPerNumber * 8);
++ }
++
++ switch (event.m_dataType) {
++ case QQmlProfilerEvent::Inline8Bit:
++ readNumbers<qint8>(stream, event.m_data.internal8bit, event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::External8Bit:
++ readNumbers<qint8>(stream, static_cast<qint8 *>(event.m_data.external),
++ event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::Inline16Bit:
++ readNumbers<qint16>(stream, event.m_data.internal16bit, event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::External16Bit:
++ readNumbers<qint16>(stream, static_cast<qint16 *>(event.m_data.external),
++ event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::Inline32Bit:
++ readNumbers<qint32>(stream, event.m_data.internal32bit, event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::External32Bit:
++ readNumbers<qint32>(stream, static_cast<qint32 *>(event.m_data.external),
++ event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::Inline64Bit:
++ readNumbers<qint64>(stream, event.m_data.internal64bit, event.m_dataLength);
++ break;
++ case QQmlProfilerEvent::External64Bit:
++ readNumbers<qint64>(stream, static_cast<qint64 *>(event.m_data.external),
++ event.m_dataLength);
++ break;
++ default:
++ Q_UNREACHABLE();
++ break;
++ }
++
++ return stream;
++ }
++
++ static inline qint8 minimumType(const QQmlProfilerEvent &event, quint16 length,
++ quint16 origBitsPerNumber)
++ {
++ qint8 type = OneByte;
++ bool ok = true;
++ for (quint16 i = 0; i < length;) {
++ if ((1 << type) == origBitsPerNumber / 8)
++ return type;
++ switch (type) {
++ case OneByte:
++ ok = (event.number<qint8>(i) == event.number<qint64>(i));
++ break;
++ case TwoByte:
++ ok = (event.number<qint16>(i) == event.number<qint64>(i));
++ break;
++ case FourByte:
++ ok = (event.number<qint32>(i) == event.number<qint64>(i));
++ break;
++ default:
++ // EightByte isn't possible, as (1 << type) == origBitsPerNumber / 8 then.
++ Q_UNREACHABLE();
++ break;
++ }
++
++ if (ok)
++ ++i;
++ else
++ ++type;
++ }
++ return type;
++ }
++
++ template<typename Number>
++ static inline qint8 minimumType(Number number)
++ {
++ if (static_cast<qint8>(number) == number)
++ return OneByte;
++ if (static_cast<qint16>(number) == number)
++ return TwoByte;
++ if (static_cast<qint32>(number) == number)
++ return FourByte;
++ return EightByte;
++ }
++
++ template<typename Number>
++ static inline void writeNumbers(QDataStream &stream, const QQmlProfilerEvent &event, quint16 length)
++ {
++ for (quint16 i = 0; i != length; ++i)
++ stream << event.number<Number>(i);
++ }
++
++ template<typename Number>
++ static inline void writeNumber(QDataStream &stream, Number number, qint8 type)
++ {
++ switch (type) {
++ case OneByte:
++ stream << static_cast<qint8>(number);
++ break;
++ case TwoByte:
++ stream << static_cast<qint16>(number);
++ break;
++ case FourByte:
++ stream << static_cast<qint32>(number);
++ break;
++ case EightByte:
++ stream << static_cast<qint64>(number);
++ break;
++ default:
++ Q_UNREACHABLE();
++ break;
++ }
++ }
++
++ QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event)
++ {
++ qint8 type = minimumType(event.m_timestamp); // << TimestampOffset;
++ type |= minimumType(event.m_typeIndex) << TypeIndexOffset;
++ type |= minimumType(event.m_dataLength) << DataLengthOffset;
++ type |= minimumType(event, event.m_dataLength, event.m_dataType) << DataOffset;
++ stream << type;
++
++ writeNumber(stream, event.m_timestamp, (type >> TimestampOffset) & TypeMask);
++ writeNumber(stream, event.m_typeIndex, (type >> TypeIndexOffset) & TypeMask);
++ writeNumber(stream, event.m_dataLength, (type >> DataLengthOffset) & TypeMask);
++
++ switch ((type >> DataOffset) & TypeMask) {
++ case OneByte:
++ writeNumbers<qint8>(stream, event, event.m_dataLength);
++ break;
++ case TwoByte:
++ writeNumbers<qint16>(stream, event, event.m_dataLength);
++ break;
++ case FourByte:
++ writeNumbers<qint32>(stream, event, event.m_dataLength);
++ break;
++ case EightByte:
++ writeNumbers<qint64>(stream, event, event.m_dataLength);
++ break;
++ default:
++ Q_UNREACHABLE();
++ break;
++ }
++
++ return stream;
++ }
++
++ QT_END_NAMESPACE