Revision control
++ // Copyright (C) 2022 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 reason:default
++
++ #ifndef Q_CTF_H
++ #define Q_CTF_H
++
++ //
++ // 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.
++ //
++ //
++
++ #include <qtcoreexports.h>
++ #include <qobject.h>
++
++ QT_BEGIN_NAMESPACE
++
++ struct QCtfTraceMetadata;
++ struct Q_CORE_EXPORT QCtfTracePointProvider
++ {
++ const QString provider;
++ QCtfTraceMetadata *metadata;
++ QCtfTracePointProvider(const QString &provider)
++ : provider(provider), metadata(nullptr)
++ {
++
++ }
++ };
++
++ struct Q_CORE_EXPORT QCtfTraceMetadata
++ {
++ const QString name;
++ const QString metadata;
++ QCtfTraceMetadata(QCtfTracePointProvider &provider, const QString &name, const QString &metadata)
++ : name(name), metadata(metadata)
++ {
++ next = provider.metadata;
++ provider.metadata = this;
++ }
++ QCtfTraceMetadata *next = nullptr;
++ };
++
++ struct QCtfTracePointPrivate;
++ struct Q_CORE_EXPORT QCtfTracePointEvent
++ {
++ const QCtfTracePointProvider &provider;
++ const QString eventName;
++ const QString metadata;
++ const int size;
++ const bool variableSize;
++
++ QCtfTracePointEvent(const QCtfTracePointProvider &provider, const QString &name, const QString &metadata, int size, bool variableSize)
++ : provider(provider), eventName(name), metadata(metadata), size(size), variableSize(variableSize)
++ {
++ }
++ QCtfTracePointPrivate *d = nullptr;
++ };
++
++
++
++ Q_CORE_EXPORT bool _tracepoint_enabled(const QCtfTracePointEvent &point);
++ Q_CORE_EXPORT void _do_tracepoint(const QCtfTracePointEvent &point, const QByteArray &arr);
++ Q_CORE_EXPORT QCtfTracePointPrivate *_initialize_tracepoint(const QCtfTracePointEvent &point);
++
++ #ifndef BUILD_LIBRARY
++ #include <QtCore/qbytearray.h>
++ #include <QtCore/qstring.h>
++ #include <QtCore/qurl.h>
++ namespace trace {
++ inline void toByteArray(QByteArray &)
++ {
++ }
++
++ inline void toByteArray(QByteArray &arr, const QString &value)
++ {
++ arr.append(value.toUtf8());
++ arr.append((char)0);
++ }
++
++ inline void toByteArray(QByteArray &arr, const QUrl &value)
++ {
++ arr.append(value.toString().toUtf8());
++ arr.append((char)0);
++ }
++
++ inline void toByteArray(QByteArray &arr, const QByteArray &data)
++ {
++ arr.append(data);
++ }
++
++ template <typename T>
++ inline void toByteArray(QByteArray &arr, T value)
++ {
++ arr.append((char *)&value, sizeof(value));
++ }
++
++ template <typename T, typename... Ts>
++ inline void toByteArray(QByteArray &arr, T value, Ts... args)
++ {
++ toByteArray(arr, value);
++ toByteArray(arr, args...);
++ }
++
++ inline QByteArray toByteArray()
++ {
++ return {};
++ }
++
++ template <typename... Ts>
++ inline QByteArray toByteArray(Ts... args)
++ {
++ QByteArray data;
++ toByteArray(data, args...);
++ return data;
++ }
++
++ template <typename T>
++ inline QByteArray toByteArrayFromArray(const T *values, int arraySize)
++ {
++ QByteArray data;
++ data.append((char *)values, arraySize * sizeof(T));
++ return data;
++ }
++
++ template <typename IntegerType, typename T>
++ inline QByteArray toByteArrayFromEnum(T value)
++ {
++ IntegerType e = static_cast<IntegerType>(value);
++ QByteArray data;
++ data.append((char *)&e, sizeof(e));
++ return data;
++ }
++
++ inline QByteArray toByteArrayFromCString(const char *str)
++ {
++ QByteArray data;
++ if (str && *str != 0)
++ data.append(str);
++ data.append((char)0);
++ return data;
++ }
++
++ static inline void appendFlags(QByteArray &data, quint8 &count, quint32 value)
++ {
++ count = 0;
++ quint8 d = 1;
++ while (value) {
++ if (value&1) {
++ data.append(d);
++ count++;
++ }
++ d++;
++ value >>= 1;
++ }
++ }
++
++ template <typename T>
++ inline QByteArray toByteArrayFromFlags(QFlags<T> value)
++ {
++ quint32 intValue = static_cast<quint32>(value.toInt());
++ quint8 count;
++ QByteArray data;
++ data.append((char)0);
++ if (intValue == 0) {
++ data.append((char)0);
++ data.data()[0] = 1;
++ } else {
++ appendFlags(data, count, intValue);
++ data.data()[0] = count;
++ }
++ return data;
++ }
++
++ } // trace
++
++ #define _DEFINE_EVENT(provider, event, metadata, size, varSize) \
++ static QCtfTracePointEvent _ctf_ ## event = QCtfTracePointEvent(_ctf_provider_ ## provider, QStringLiteral(QT_STRINGIFY(event)), metadata, size, varSize);
++ #define _DEFINE_METADATA(provider, name, metadata) \
++ static QCtfTraceMetadata _ctf_metadata_ ## name = QCtfTraceMetadata(_ctf_provider_ ## provider, QStringLiteral(QT_STRINGIFY(name)), metadata);
++ #define _DEFINE_TRACEPOINT_PROVIDER(provider) \
++ static QCtfTracePointProvider _ctf_provider_ ## provider = QCtfTracePointProvider(QStringLiteral(QT_STRINGIFY(provider)));
++
++ #define TRACEPOINT_EVENT(provider, event, metadata, size, varSize) \
++ _DEFINE_EVENT(provider, event, metadata, size, varSize)
++
++ #define TRACEPOINT_PROVIDER(provider) \
++ _DEFINE_TRACEPOINT_PROVIDER(provider)
++
++ #define TRACEPOINT_METADATA(provider, name, metadata) \
++ _DEFINE_METADATA(provider, name, metadata)
++
++ #define tracepoint_enabled(provider, event) \
++ _tracepoint_enabled(_ctf_ ## event)
++
++ #define do_tracepoint(provider, event, ...) \
++ { \
++ auto &tp = _ctf_ ## event; \
++ if (!tp.d) \
++ tp.d = _initialize_tracepoint(tp); \
++ if (tp.d) { \
++ QByteArray data(tp.size, 0); \
++ if (!tp.metadata.isEmpty()) \
++ data = trace::toByteArray(__VA_ARGS__); \
++ _do_tracepoint(tp, data); \
++ } \
++ }
++
++ #define tracepoint(provider, name, ...) \
++ do { \
++ if (tracepoint_enabled(provider, name)) \
++ do_tracepoint(provider, name, __VA_ARGS__); \
++ } while (0)
++
++ #endif
++
++ class Q_CORE_EXPORT QCtfLib : public QObject
++ {
++ Q_OBJECT
++ Q_DISABLE_COPY(QCtfLib)
++ public:
++ explicit QCtfLib(QObject *parent = nullptr) : QObject(parent) {}
++ virtual ~QCtfLib() = default;
++ virtual bool tracepointEnabled(const QCtfTracePointEvent &point) = 0;
++ virtual void doTracepoint(const QCtfTracePointEvent &point, const QByteArray &arr) = 0;
++ virtual bool sessionEnabled() = 0;
++ virtual QCtfTracePointPrivate *initializeTracepoint(const QCtfTracePointEvent &point) = 0;
++ virtual void shutdown(bool *shutdown) = 0;
++ };
++
++ QT_END_NAMESPACE
++
++ #endif