AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

CTF: Move event metadata generation to the wrapper

Browse Source 
This fixes the metadata generation when cross compiling. The metadata
needs to be generated based on the type info of the target. Currently
the metadata is generated in the tool based on the host type info.

Task-number: QTBUG-110270
Pick-to: 6.5
Change-Id: Ibcdcbd690620afc532d6007cf036229342bdcc31
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
This commit is contained in:
Antti Määttä 2023-01-17 08:22:19 +02:00
parent b652d9753b
commit c5d4c9345b
8 changed files with 180 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/corelib/tracing/qctf_p.h
View File

@ -181,9 +181,9 @@ inline QByteArray toByteArrayFromFlags(QFlags<T> value)
} // trace
#define _DEFINE_EVENT(provider, event, metadata, size, varSize) \
static QCtfTracePointEvent _ctf_ ## event = QCtfTracePointEvent(_ctf_provider_ ## provider, QStringLiteral(QT_STRINGIFY(event)), QStringLiteral(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)), QStringLiteral(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)));

217
src/tools/tracegen/ctf.cpp
View File

@ -88,17 +88,94 @@ static void writeWrapper(QTextStream &stream,
<< "#endif // " << includeGuard << "\n\n";
}
static void writeMetadataGenerators(QTextStream &stream)
{
stream << R"CPP(
template <typename T>
inline QString integerToMetadata(const QString &name)
{
QString ret;
if (!std::is_signed<T>().value)
ret += QLatin1Char('u');
if (sizeof(T) == 8)
ret += QStringLiteral("int64_t ");
else if (sizeof(T) == 4)
ret += QStringLiteral("int32_t ");
else if (sizeof(T) == 2)
ret += QStringLiteral("int16_t ");
else if (sizeof(T) == 1)
ret += QStringLiteral("int8_t ");
ret += name + QLatin1Char(';');
return ret;
}
template <typename T>
inline QString integerArrayToMetadata(const QString &size, const QString &name)
{
QString ret;
if (!std::is_signed<T>().value)
ret += QLatin1Char('u');
if (sizeof(T) == 8)
ret += QStringLiteral("int64_t ");
else if (sizeof(T) == 4)
ret += QStringLiteral("int32_t ");
else if (sizeof(T) == 2)
ret += QStringLiteral("int16_t ");
else if (sizeof(T) == 1)
ret += QStringLiteral("int8_t ");
ret += name + QLatin1Char('[') + size + QStringLiteral("];");
return ret;
}
template <typename T>
inline QString floatToMetadata(const QString &name)
{
QString ret;
if (sizeof(T) == 8)
ret += QStringLiteral("double ");
else if (sizeof(T) == 4)
ret += QStringLiteral("float ");
ret += name + QLatin1Char(';');
return ret;
}
template <typename T>
inline QString floatArrayToMetadata(const QString &size, const QString &name)
{
QString ret;
if (sizeof(T) == 8)
ret += QStringLiteral("double ");
else if (sizeof(T) == 4)
ret += QStringLiteral("float ");
ret += name + QLatin1Char('[') + size + QStringLiteral("];");
return ret + QLatin1Char(';');
}
inline QString pointerToMetadata(const QString &name)
{
QString ret;
if (QT_POINTER_SIZE == 8)
ret += QStringLiteral("intptr64_t ");
else if (QT_POINTER_SIZE == 4)
ret += QStringLiteral("intptr32_t ");
ret += name + QLatin1Char(';');
return ret;
}
)CPP";
}
static void writeTracepoint(QTextStream &stream,
const Tracepoint &tracepoint, const QString &providerName)
{
stream << "TRACEPOINT_EVENT(\n"
<< " " << providerName << ",\n"
<< " " << tracepoint.name << ",\n";
stream << "\"";
const auto checkUnknownArgs = [](const Tracepoint &tracepoint) {
for (auto &field : tracepoint.fields) {
if (field.backendType.backendType == Tracepoint::Field::Unknown)
if (field.backendType == Tracepoint::Field::Unknown)
return true;
}
return false;
@ -110,114 +187,105 @@ static void writeTracepoint(QTextStream &stream,
ret = type.left(type.length() - 1).simplified();
if (ret.startsWith(QStringLiteral("const")))
ret = ret.right(ret.length() - 6).simplified();
return typeToName(ret);
return typeToTypeName(ret);
};
int eventSize = 0;
QString eventSize;
bool variableSize = false;
if (!checkUnknownArgs(tracepoint)) {
const bool emptyMetadata = checkUnknownArgs(tracepoint) || tracepoint.args.size() == 0;
if (!emptyMetadata) {
for (int i = 0; i < tracepoint.args.size(); i++) {
auto &arg = tracepoint.args[i];
auto &field = tracepoint.fields[i];
if (i > 0) {
stream << " \\n\\\n";
stream << " ";
stream << " + QStringLiteral(\"\\n\\\n \") + ";
eventSize += QStringLiteral(" + ");
}
const bool array = field.arrayLen > 0;
switch (field.backendType.backendType) {
switch (field.backendType) {
case Tracepoint::Field::Boolean: {
stream << "Boolean " << arg.name << ";";
eventSize += 8;
stream << "QStringLiteral(\"Boolean " << arg.name << ";\")";
eventSize += QStringLiteral("sizeof(bool)");
} break;
case Tracepoint::Field::Integer: {
if (!field.backendType.isSigned)
stream << "u";
stream << "int" << field.backendType.bits << "_t ";
if (array) {
stream << "integerArrayToMetadata<" << formatType(arg.type)
<< ">(QStringLiteral(\"" << field.arrayLen << "\"), QStringLiteral(\""
<< arg.name << "\"))";
} else {
stream << "integerToMetadata<" << formatType(arg.type) << ">(QStringLiteral(\""
<< arg.name << "\"))";
}
eventSize += QStringLiteral("sizeof(") + formatType(arg.type) + QStringLiteral(")");
if (array)
stream << arg.name << "[" << field.arrayLen << "];";
else
stream << arg.name << ";";
eventSize += field.backendType.bits * qMax(1, field.arrayLen);
} break;
case Tracepoint::Field::Pointer: {
if (QT_POINTER_SIZE == 8)
stream << "intptr64_t " << formatType(arg.type) << "_" << arg.name << ";";
else
stream << "intptr32_t " << formatType(arg.type) << "_" << arg.name << ";";
eventSize += QT_POINTER_SIZE * 8;
eventSize += QStringLiteral(" * ") + QString::number(field.arrayLen);
} break;
case Tracepoint::Field::Pointer:
case Tracepoint::Field::IntegerHex: {
if (field.backendType.bits == 64)
stream << "intptr64_t " << formatType(arg.name) << ";";
else
stream << "intptr32_t " << formatType(arg.name) << ";";
eventSize += field.backendType.bits;
stream << "pointerToMetadata(QStringLiteral(\"" << formatType(arg.type) << "_"
<< arg.name << "\"))";
eventSize += QStringLiteral("QT_POINTER_SIZE");
} break;
case Tracepoint::Field::Float: {
if (field.backendType.bits == 32)
stream << "float " << arg.name;
else
stream << "double " << arg.name;
if (array) {
stream << "[" << field.arrayLen << "];";
stream << "floatArrayToMetadata<" << formatType(arg.type)
<< ">(QStringLiteral(\"" << field.arrayLen << "\"), QStringLiteral(\""
<< arg.name << "\"))";
} else {
stream << ";";
stream << "floatToMetadata<" << formatType(arg.type) << ">(QStringLiteral(\""
<< arg.name << "\"))";
}
eventSize += field.backendType.bits * qMax(1, field.arrayLen);
eventSize += QStringLiteral("sizeof(") + formatType(arg.type) + QStringLiteral(")");
if (array)
eventSize += QStringLiteral(" * ") + QString::number(field.arrayLen);
} break;
case Tracepoint::Field::QtUrl:
case Tracepoint::Field::QtString:
case Tracepoint::Field::String: {
stream << "string " << arg.name << ";";
eventSize += 8;
variableSize = true;
} break;
case Tracepoint::Field::QtString: {
stream << "string " << arg.name << ";";
eventSize += 8;
variableSize = true;
} break;
case Tracepoint::Field::QtByteArray:
break;
case Tracepoint::Field::QtUrl: {
stream << "string " << arg.name << ";";
eventSize += 8;
stream << "QStringLiteral(\"string " << arg.name << ";\")";
eventSize += QStringLiteral("1");
variableSize = true;
} break;
case Tracepoint::Field::QtRect: {
stream << "int32_t QRect_" << arg.name << "_x;\\n\\\n ";
stream << "int32_t QRect_" << arg.name << "_y;\\n\\\n ";
stream << "int32_t QRect_" << arg.name << "_width;\\n\\\n ";
stream << "int32_t QRect_" << arg.name << "_height;";
eventSize += 32 * 4;
stream << "QStringLiteral(\"int32_t QRect_" << arg.name << "_x;\\n\\\n \")";
stream << " + QStringLiteral(\"int32_t QRect_" << arg.name << "_y;\\n\\\n \")";
stream << " + QStringLiteral(\"int32_t QRect_" << arg.name << "_width;\\n\\\n \")";
stream << " + QStringLiteral(\"int32_t QRect_" << arg.name << "_height;\\n\\\n \")";
eventSize += QStringLiteral("16");
} break;
case Tracepoint::Field::QtSize: {
stream << "int32_t QSize_" << arg.name << "_width;\\n\\\n ";
stream << "int32_t QSize_" << arg.name << "_height;";
eventSize += 32 * 2;
stream << "QStringLiteral(\"int32_t QSize_" << arg.name << "_width;\\n\\\n \")";
stream << " + QStringLiteral(\"int32_t QSize_" << arg.name << "_height;\\n\\\n \")";
eventSize += QStringLiteral("8");
} break;
case Tracepoint::Field::Unknown:
break;
case Tracepoint::Field::EnumeratedType: {
QString type = arg.type;
type.replace(QStringLiteral("::"), QStringLiteral("_"));
stream << type << " " << arg.name << ";";
eventSize += field.backendType.bits;
stream << "QStringLiteral(\"" << typeToTypeName(arg.type) << " " << arg.name << ";\")";
eventSize += QString::number(field.enumValueSize / 8);
variableSize = true;
} break;
case Tracepoint::Field::FlagType: {
QString type = arg.type;
type.replace(QStringLiteral("::"), QStringLiteral("_"));
stream << "uint8_t " << arg.name << "_length;\\n\\\n ";
stream << type << " " << arg.name << "[" << arg.name << "_length];";
eventSize += 16;
stream << "QStringLiteral(\"uint8_t " << arg.name << "_length;\\n\\\n ";
stream << typeToTypeName(arg.type) << " " << arg.name << "[" << arg.name << "_length];\")";
eventSize += QStringLiteral("2");
variableSize = true;
} break;
case Tracepoint::Field::QtByteArray:
case Tracepoint::Field::Sequence:
panic("Unhandled sequence '%s %s", qPrintable(arg.type), qPrintable(arg.name));
panic("Unhandled type '%s %s", qPrintable(arg.type), qPrintable(arg.name));
break;
}
}
}
stream << "\",\n";
stream << eventSize / 8 << ", \n";
if (emptyMetadata)
stream << "{},\n";
else
stream << ",\n";
if (eventSize.length())
stream << eventSize << ", \n";
else
stream << "0, \n";
stream << (variableSize ? "true" : "false") << "\n";
stream << ")\n\n";
}
@ -236,14 +304,14 @@ static void writeEnums(QTextStream &stream, const Provider &provider)
QString name = e.name;
name.replace(QStringLiteral("::"), QStringLiteral("_"));
stream << "TRACEPOINT_METADATA(" << provider.name << ", " << name << ", \n";
stream << "\"typealias enum : integer { size = " << e.valueSize << "; } {\\n\\\n";
stream << "QStringLiteral(\"typealias enum : integer { size = " << e.valueSize << "; } {\\n\\\n";
for (const auto &v : e.values) {
if (v.range)
stream << v.name << " = " << v.value << " ... " << v.range << ", \\n\\\n";
else
stream << v.name << " = " << v.value << ", \\n\\\n";
}
stream << "} := " << name << ";\\n\\n\");\n\n";
stream << "} := " << name << ";\\n\\n\"));\n\n";
}
stream << "\n";
}
@ -254,11 +322,11 @@ static void writeFlags(QTextStream &stream, const Provider &provider)
QString name = e.name;
name.replace(QStringLiteral("::"), QStringLiteral("_"));
stream << "TRACEPOINT_METADATA(" << provider.name << ", " << name << ", \n";
stream << "\"typealias enum : integer { size = 8; } {\\n\\\n";
stream << "QStringLiteral(\"typealias enum : integer { size = 8; } {\\n\\\n";
for (const auto &v : e.values) {
stream << v.name << " = " << v.value << ", \\n\\\n";
}
stream << "} := " << name << ";\\n\\n\");\n\n";
stream << "} := " << name << ";\\n\\n\"));\n\n";
}
stream << "\n";
}
@ -270,6 +338,7 @@ void writeCtf(QFile &file, const Provider &provider)
const QString fileName = QFileInfo(file.fileName()).fileName();
writePrologue(stream, fileName, provider);
writeMetadataGenerators(stream);
writeEnums(stream, provider);
writeFlags(stream, provider);
writeTracepoints(stream, provider);

10
src/tools/tracegen/etw.cpp
View File

@ -31,7 +31,7 @@ static void writeEtwMacro(QTextStream &stream, const Tracepoint::Field &field)
return;
}
switch (field.backendType.backendType) {
switch (field.backendType) {
case Tracepoint::Field::QtString:
stream << "TraceLoggingCountedWideString(reinterpret_cast<LPCWSTR>("
<< name << ".utf16()), static_cast<ULONG>(" << name << ".size()), \""
@ -66,7 +66,7 @@ static void writeEtwMacro(QTextStream &stream, const Tracepoint::Field &field)
return;
case Tracepoint::Field::EnumeratedType:
case Tracepoint::Field::FlagType:
stream << "TraceLoggingString(trace_convert_" << typeToName(field.paramType) << "(" << name << ").toUtf8().constData(), \"" << name << "\")";
stream << "TraceLoggingString(trace_convert_" << typeToTypeName(field.paramType) << "(" << name << ").toUtf8().constData(), \"" << name << "\")";
return;
default:
break;
@ -177,7 +177,7 @@ static void writeWrapper(QTextStream &stream, const Provider &provider, const Tr
// Convert all unknown types to QString's using QDebug.
// Note the naming convention: it's field.name##Str
for (const Tracepoint::Field &field : tracepoint.fields) {
if (field.backendType.backendType == Tracepoint::Field::Unknown) {
if (field.backendType == Tracepoint::Field::Unknown) {
stream << " const QString " << field.name << "Str = QDebug::toString(" << field.name
<< ");\n";
}
@ -206,7 +206,7 @@ static void writeWrapper(QTextStream &stream, const Provider &provider, const Tr
static void writeEnumConverter(QTextStream &stream, const TraceEnum &enumeration)
{
stream << "inline QString trace_convert_" << typeToName(enumeration.name) << "(" << enumeration.name << " val)\n";
stream << "inline QString trace_convert_" << typeToTypeName(enumeration.name) << "(" << enumeration.name << " val)\n";
stream << "{\n";
for (const auto &v : enumeration.values) {
if (v.range != 0) {
@ -225,7 +225,7 @@ static void writeEnumConverter(QTextStream &stream, const TraceEnum &enumeration
static void writeFlagConverter(QTextStream &stream, const TraceFlags &flag)
{
stream << "inline QString trace_convert_" << typeToName(flag.name) << "(" << flag.name << " val)\n";
stream << "inline QString trace_convert_" << typeToTypeName(flag.name) << "(" << flag.name << " val)\n";
stream << "{\n QString ret;\n";
for (const auto &v : flag.values) {
if (v.value == 0) {

12
src/tools/tracegen/helpers.cpp
View File

@ -6,7 +6,7 @@
using namespace Qt::StringLiterals;
QString typeToName(const QString &name)
QString typeToTypeName(const QString &name)
{
QString ret = name;
return ret.replace(QStringLiteral("::"), QStringLiteral("_"));
@ -57,8 +57,8 @@ QString formatParameterList(const Provider &provider, const QList<Tracepoint::Ar
for (int i = 0; i < args.size(); i++) {
const Tracepoint::Argument &arg = args[i];
const Tracepoint::Field &field = fields[i];
if (field.backendType.backendType == Tracepoint::Field::FlagType)
ret += ", trace_convert_"_L1 + typeToName(arg.type) + "("_L1 + arg.name + ")"_L1;
if (field.backendType == Tracepoint::Field::FlagType)
ret += ", trace_convert_"_L1 + typeToTypeName(arg.type) + "("_L1 + arg.name + ")"_L1;
else
ret += ", "_L1 + arg.name;
}
@ -81,7 +81,7 @@ QString formatParameterList(const Provider &provider, const QList<Tracepoint::Ar
const Tracepoint::Field &field = fields[i];
if (arg.arrayLen > 1) {
ret += ", trace::toByteArrayFromArray("_L1 + arg.name + ", "_L1 + QString::number(arg.arrayLen) + ") "_L1;
} else if (field.backendType.backendType == Tracepoint::Field::EnumeratedType) {
} else if (field.backendType == Tracepoint::Field::EnumeratedType) {
const TraceEnum &e = findEnumeration(provider.enumerations, arg.type);
QString integerType;
if (e.valueSize == 8)
@ -91,9 +91,9 @@ QString formatParameterList(const Provider &provider, const QList<Tracepoint::Ar
else
integerType = QStringLiteral("quint32");
ret += ", trace::toByteArrayFromEnum<"_L1 + integerType + ">("_L1 + arg.name + ")"_L1;
} else if (field.backendType.backendType == Tracepoint::Field::FlagType) {
} else if (field.backendType == Tracepoint::Field::FlagType) {
ret += ", trace::toByteArrayFromFlags("_L1 + arg.name + ")"_L1;
} else if (field.backendType.backendType == Tracepoint::Field::String) {
} else if (field.backendType == Tracepoint::Field::String) {
ret += ", trace::toByteArrayFromCString("_L1 + arg.name + ")"_L1;
} else {
ret += ", "_L1 + arg.name;

2
src/tools/tracegen/helpers.h
View File

@ -15,7 +15,7 @@ enum ParamType {
CTF
};
QString typeToName(const QString &name);
QString typeToTypeName(const QString &type);
QString includeGuard(const QString &filename);
QString formatFunctionSignature(const QList<Tracepoint::Argument> &args);
QString formatParameterList(const Provider &provider, const QList<Tracepoint::Argument> &args, const QList<Tracepoint::Field> &fields, ParamType type);

12
src/tools/tracegen/lttng.cpp
View File

@ -25,7 +25,7 @@ static void writeCtfMacro(QTextStream &stream, const Provider &provider, const T
return;
}
switch (field.backendType.backendType) {
switch (field.backendType) {
case Tracepoint::Field::Sequence:
stream << "ctf_sequence(" << paramType
<< ", " << name << ", " << name
@ -66,7 +66,7 @@ static void writeCtfMacro(QTextStream &stream, const Provider &provider, const T
<< "ctf_integer(int, height, " << name << ".height()) ";
return;
case Tracepoint::Field::EnumeratedType:
stream << "ctf_enum(" << provider.name << ", " << typeToName(paramType) << ", int, " << name << ", " << name << ") ";
stream << "ctf_enum(" << provider.name << ", " << typeToTypeName(paramType) << ", int, " << name << ", " << name << ") ";
return;
case Tracepoint::Field::FlagType:
stream << "ctf_sequence(const char , " << name << ", "
@ -170,7 +170,7 @@ static void writeTracepoint(QTextStream &stream, const Provider &provider,
for (int i = 0; i < tracepoint.args.size(); i++) {
const auto &arg = tracepoint.args[i];
const auto &field = tracepoint.fields[i];
if (field.backendType.backendType == Tracepoint::Field::FlagType)
if (field.backendType == Tracepoint::Field::FlagType)
stream << comma << "QByteArray, " << arg.name;
else
stream << comma << arg.type << ", " << arg.name;
@ -196,7 +196,7 @@ static void writeEnums(QTextStream &stream, const Provider &provider)
for (const auto &e : provider.enumerations) {
stream << "TRACEPOINT_ENUM(\n"
<< " " << provider.name << ",\n"
<< " " << typeToName(e.name) << ",\n"
<< " " << typeToTypeName(e.name) << ",\n"
<< " TP_ENUM_VALUES(\n";
for (const auto &v : e.values) {
if (v.range > 0)
@ -213,7 +213,7 @@ static void writeFlags(QTextStream &stream, const Provider &provider)
for (const auto &f : provider.flags) {
stream << "TRACEPOINT_ENUM(\n"
<< " " << provider.name << ",\n"
<< " " << typeToName(f.name) << ",\n"
<< " " << typeToTypeName(f.name) << ",\n"
<< " TP_ENUM_VALUES(\n";
for (const auto &v : f.values)
stream << " ctf_enum_value(\"" << v.name << "\", " << v.value << ")\n";
@ -228,7 +228,7 @@ static void writeFlags(QTextStream &stream, const Provider &provider)
stream << "QT_BEGIN_NAMESPACE\n";
stream << "namespace QtPrivate {\n";
for (const auto &f : provider.flags) {
stream << "inline QByteArray trace_convert_" << typeToName(f.name) << "(" << f.name << " val)\n";
stream << "inline QByteArray trace_convert_" << typeToTypeName(f.name) << "(" << f.name << " val)\n";
stream << "{\n";
stream << " QByteArray ret;\n";
stream << " if (val == 0) { ret.append((char)0); return ret; }\n";

33
src/tools/tracegen/provider.cpp
View File

@ -97,17 +97,14 @@ static QString removeBraces(QString type)
}
#define TYPEDATA_ENTRY(type, backendType) \
{ QT_STRINGIFY(type), backendType, sizeof(type) * 8, std::is_signed<type>::value }
{ QT_STRINGIFY(type), backendType }
static Tracepoint::Field::BackendType backendType(QString rawType)
static Tracepoint::Field::Type backendType(QString rawType)
{
static const struct TypeData {
const char *type;
Tracepoint::Field::Type backendType;
int bits;
bool isSigned;
} typeTable[] = {
#ifdef UNDERSCORE_TYPES_DEFINED
TYPEDATA_ENTRY(short_int, Tracepoint::Field::Integer),
TYPEDATA_ENTRY(signed_short, Tracepoint::Field::Integer),
TYPEDATA_ENTRY(signed_short_int, Tracepoint::Field::Integer),
@ -125,7 +122,6 @@ static Tracepoint::Field::BackendType backendType(QString rawType)
TYPEDATA_ENTRY(signed_long_long, Tracepoint::Field::Integer),
TYPEDATA_ENTRY(signed_long_long_int, Tracepoint::Field::Integer),
TYPEDATA_ENTRY(unsigned_long_long, Tracepoint::Field::Integer),
#endif
TYPEDATA_ENTRY(bool, Tracepoint::Field::Boolean),
TYPEDATA_ENTRY(int, Tracepoint::Field::Integer),
TYPEDATA_ENTRY(signed, Tracepoint::Field::Integer),
@ -140,11 +136,11 @@ static Tracepoint::Field::BackendType backendType(QString rawType)
TYPEDATA_ENTRY(float, Tracepoint::Field::Float),
TYPEDATA_ENTRY(double, Tracepoint::Field::Float),
TYPEDATA_ENTRY(long double, Tracepoint::Field::Float),
{ "QString", Tracepoint::Field::QtString , 0, false},
{ "QByteArray", Tracepoint::Field::QtByteArray , 0, false},
{ "QUrl", Tracepoint::Field::QtUrl , 0, false},
{ "QRect", Tracepoint::Field::QtRect , 0, false},
{ "QSize", Tracepoint::Field::QtSize , 0, false}
TYPEDATA_ENTRY(QString, Tracepoint::Field::QtString),
TYPEDATA_ENTRY(QByteArray, Tracepoint::Field::QtByteArray),
TYPEDATA_ENTRY(QUrl, Tracepoint::Field::QtUrl),
TYPEDATA_ENTRY(QRect, Tracepoint::Field::QtRect),
TYPEDATA_ENTRY(QSize, Tracepoint::Field::QtSize)
};
auto backendType = [](const QString &rawType) {
@ -155,7 +151,7 @@ static Tracepoint::Field::BackendType backendType(QString rawType)
return typeTable[i];
}
TypeData unknown = { nullptr, Tracepoint::Field::Unknown, 0, false };
TypeData unknown = { nullptr, Tracepoint::Field::Unknown };
return unknown;
};
@ -164,7 +160,7 @@ static Tracepoint::Field::BackendType backendType(QString rawType)
rawType = removeBraces(rawType);
if (!sequenceLength(rawType).isNull())
return { Tracepoint::Field::Sequence, 0, false };
return Tracepoint::Field::Sequence;
static const QRegularExpression constMatch(QStringLiteral("\\bconst\\b"));
rawType.remove(constMatch);
@ -176,13 +172,13 @@ static Tracepoint::Field::BackendType backendType(QString rawType)
rawType.replace(QStringLiteral(" "), QStringLiteral("_"));
if (rawType == "char_ptr"_L1)
return { Tracepoint::Field::String, 0, false };
return Tracepoint::Field::String;
if (rawType.endsWith("_ptr"_L1))
return {Tracepoint::Field::Pointer, QT_POINTER_SIZE, false };
return Tracepoint::Field::Pointer;
TypeData d = backendType(rawType);
return { d.backendType, d.bits, d.isSigned };
return d.backendType;
}
static Tracepoint parseTracepoint(const Provider &provider, const QString &name, const QStringList &args,
@ -246,9 +242,10 @@ static Tracepoint parseTracepoint(const Provider &provider, const QString &name,
const TraceEnum &e = findEnumeration(provider.enumerations, type);
const TraceFlags &f = findFlags(provider.flags, type);
if (!e.name.isEmpty()) {
field.backendType = { Tracepoint::Field::EnumeratedType, e.valueSize, false };
field.backendType = Tracepoint::Field::EnumeratedType;
field.enumValueSize = e.valueSize;
} else if (!f.name.isEmpty()) {
field.backendType = { Tracepoint::Field::FlagType, 0, false };
field.backendType = Tracepoint::Field::FlagType;
} else {
field.backendType = backendType(type);
}

9
src/tools/tracegen/provider.h
View File

@ -37,15 +37,11 @@ struct Tracepoint
FlagType,
Unknown
};
struct BackendType {
Type backendType;
int bits;
bool isSigned;
};
BackendType backendType;
Type backendType;
QString paramType;
QString name;
int arrayLen;
int enumValueSize;
QString seqLen;
};
@ -77,7 +73,6 @@ struct TraceFlags {
Q_DECLARE_TYPEINFO(TraceEnum, Q_RELOCATABLE_TYPE);
Q_DECLARE_TYPEINFO(TraceFlags, Q_RELOCATABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracepoint::Argument, Q_RELOCATABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracepoint::Field::BackendType, Q_RELOCATABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracepoint::Field, Q_RELOCATABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracepoint, Q_RELOCATABLE_TYPE);