Revision control
Copy as Markdown
// Copyright (C) 2026 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
#include <private/qhitrace_p.h>
#include <private/qtools_p.h>
#include <QtCore/qlogging.h>
#include <hitrace/trace.h>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <type_traits>
QT_BEGIN_NAMESPACE
namespace {
constexpr char elidedMark[] = "...";
constexpr char16_t firstPrintable = 0x20;
constexpr char16_t lastPrintable = 0x7e;
constexpr char escapeMark = '\\';
constexpr char unicodeEscape = 'u';
constexpr char separatorReplacement = ' ';
constexpr int escapeDigits = 2 * sizeof(char16_t);
constexpr int bitsPerHexDigit = 4;
constexpr qsizetype shortEscapeSize = 2;
constexpr qsizetype unicodeEscapeSize = 2 + escapeDigits;
constexpr int32_t unregisteredListener = -1;
Q_CONSTINIT int32_t qtHiTraceListener = unregisteredListener;
bool isSeparator(QChar unit)
{
return unit == u',' || unit == u'=' || unit == u'|';
}
bool isWrittenVerbatim(QChar unit)
{
return unit.unicode() >= firstPrintable && unit.unicode() <= lastPrintable
&& unit != QLatin1Char(escapeMark);
}
char shortEscape(QChar unit)
{
switch (unit.unicode()) {
case '\\':
return '\\';
case '\b':
return 'b';
case '\f':
return 'f';
case '\n':
return 'n';
case '\r':
return 'r';
case '\t':
return 't';
default:
return 0;
}
}
qsizetype escapedSize(QChar unit)
{
if (isWrittenVerbatim(unit))
return 1;
return shortEscape(unit) ? shortEscapeSize : unicodeEscapeSize;
}
QByteArray escaped(QStringView text)
{
QByteArray result;
result.reserve(text.size());
for (const QChar unit : text) {
if (isSeparator(unit)) {
result += separatorReplacement;
continue;
}
if (isWrittenVerbatim(unit)) {
result += char(unit.unicode());
continue;
}
result += escapeMark;
if (const char shortForm = shortEscape(unit)) {
result += shortForm;
continue;
}
result += unicodeEscape;
for (int digit = escapeDigits - 1; digit >= 0; --digit)
result += QtMiscUtils::toHexLower(unit.unicode() >> (digit * bitsPerHexDigit));
}
return result;
}
struct FittingUnits
{
qsizetype count = 0;
qsizetype escapedSize = 0;
};
template <typename Iterator>
bool startsSurrogatePair(Iterator unit, Iterator end)
{
constexpr bool isReversed = std::is_same_v<Iterator, QStringView::const_reverse_iterator>;
if (unit + 1 == end)
return false;
const QChar high = isReversed ? unit[1] : unit[0];
const QChar low = isReversed ? unit[0] : unit[1];
return high.isHighSurrogate() && low.isLowSurrogate();
}
template <typename Iterator>
FittingUnits fittingUnits(Iterator unit, Iterator end, qsizetype maximumSize)
{
FittingUnits fitting;
while (unit != end) {
const qsizetype step = startsSurrogatePair(unit, end) ? 2 : 1;
qsizetype stepSize = escapedSize(unit[0]);
if (step == 2)
stepSize += escapedSize(unit[1]);
if (fitting.escapedSize + stepSize > maximumSize)
break;
fitting.escapedSize += stepSize;
fitting.count += step;
unit += step;
}
return fitting;
}
QByteArray elided(QStringView value, qsizetype maximumSize)
{
Q_ASSERT(maximumSize >= qtHiTraceSmallestValueBudget);
if (fittingUnits(value.cbegin(), value.cend(), maximumSize).count == value.size())
return escaped(value);
const qsizetype kept = maximumSize - (qsizetype(sizeof(elidedMark)) - 1);
const FittingUnits head = fittingUnits(value.cbegin(), value.cend(), kept / 2);
const FittingUnits tail =
fittingUnits(value.crbegin(), value.crend(), kept - head.escapedSize);
return escaped(value.first(head.count)) + elidedMark + escaped(value.last(tail.count));
}
void qtHiTraceStatusChanged(bool enabled)
{
qtHiTraceEnabled.storeRelaxed(enabled);
}
void qtHiTraceWatchStatus()
{
const int32_t listener = OH_HiTrace_RegisterTraceListener(qtHiTraceStatusChanged);
if (listener < 0) {
qtHiTraceEnabled.storeRelaxed(true);
qWarning("Qt tracing: OH_HiTrace_RegisterTraceListener() failed with %d, so tracepoint "
"arguments are rendered whether or not a capture is running",
listener);
return;
}
qtHiTraceListener = listener;
if (OH_HiTrace_IsTraceEnabled())
qtHiTraceEnabled.storeRelaxed(true);
}
void qtHiTraceUnwatchStatus()
{
if (qtHiTraceListener != unregisteredListener)
OH_HiTrace_UnregisterTraceListener(qtHiTraceListener);
}
} // namespace
QByteArray qtHiTraceArgument(const char *value, qsizetype maximumSize)
{
return elided(QString::fromUtf8(value), maximumSize);
}
QByteArray qtHiTraceArgument(const QString &value, qsizetype maximumSize)
{
return elided(value, maximumSize);
}
const char *qtHiTraceFormatArguments(int sliceNameSize, const char *format, ...)
{
Q_CONSTINIT static thread_local char renderedArguments[qtHiTraceRecordBudget] = {};
const int budget = qtHiTraceRecordBudget - sliceNameSize;
if (budget <= int(sizeof(elidedMark)))
return "";
va_list values;
va_start(values, format);
const int renderedSize = std::vsnprintf(renderedArguments, budget, format, values);
va_end(values);
if (renderedSize < 0)
return "";
if (renderedSize >= budget) {
std::memcpy(renderedArguments + budget - sizeof(elidedMark), elidedMark,
sizeof(elidedMark));
}
return renderedArguments;
}
Q_CONSTINIT QBasicAtomicInteger<bool> qtHiTraceEnabled = Q_BASIC_ATOMIC_INITIALIZER(false);
Q_CONSTRUCTOR_FUNCTION(qtHiTraceWatchStatus)
Q_DESTRUCTOR_FUNCTION(qtHiTraceUnwatchStatus)
QT_END_NAMESPACE