Nanotrace: Fix dangling reference

As EventQueueData was derived from EventQueue the order of
initialization was inverted. So we got dangling pointer. Merging
EventQueueData into EventQueue fixes the dangling references.

Change-Id: I3d9cee492304132fa612d6d19324656df597ec99
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>

3 files changed, 31 insertions, 54 deletions

diff --git a/src/libs/nanotrace/nanotracehr.cpp b/src/libs/nanotrace/nanotracehr.cpp
index 2dd1806aaf..083c9da69c 100644
--- a/src/libs/nanotrace/nanotracehr.cpp
+++ b/src/libs/nanotrace/nanotracehr.cpp
@@ -73,17 +73,17 @@ void printEvent(std::ostream &out, const TraceEvent &event, qint64 processId, st
     out << "}";
 }
 
-void writeMetaEvent(TraceFile<Tracing::IsEnabled> *file, std::string_view key, std::string_view value)
+void writeMetaEvent(TraceFile<Tracing::IsEnabled> &file, std::string_view key, std::string_view value)
 {
-    std::lock_guard lock{file->fileMutex};
-    auto &out = file->out;
+    std::lock_guard lock{file.fileMutex};
+    auto &out = file.out;
 
     if (out.is_open()) {
-        file->out << R"({"name":")" << key << R"(","ph":"M", "pid":)"
-                  << getUnsignedIntegerHash(QCoreApplication::applicationPid()) << R"(,"tid":)"
-                  << getUnsignedIntegerHash(std::this_thread::get_id()) << R"(,"args":{"name":")"
-                  << value << R"("}})"
-                  << ",\n";
+        file.out << R"({"name":")" << key << R"(","ph":"M", "pid":)"
+                 << getUnsignedIntegerHash(QCoreApplication::applicationPid()) << R"(,"tid":)"
+                 << getUnsignedIntegerHash(std::this_thread::get_id()) << R"(,"args":{"name":")"
+                 << value << R"("}})"
+                 << ",\n";
     }
 }
 
@@ -145,8 +145,8 @@ void flushEvents(const Utils::span<TraceEvent> events,
     if (events.empty())
         return;
 
-    std::lock_guard lock{eventQueue.file->fileMutex};
-    auto &out = eventQueue.file->out;
+    std::lock_guard lock{eventQueue.file.fileMutex};
+    auto &out = eventQueue.file.out;
 
     if (out.is_open()) {
         auto processId = QCoreApplication::applicationPid();
@@ -197,17 +197,17 @@ void finalizeFile(EnabledTraceFile &file)
 template<typename TraceEvent>
 void flushInThread(EnabledEventQueue<TraceEvent> &eventQueue)
 {
-    if (eventQueue.file->processing.valid())
-        eventQueue.file->processing.wait();
+    if (eventQueue.file.processing.valid())
+        eventQueue.file.processing.wait();
 
     auto flush = [&](const Utils::span<TraceEvent> &events, std::thread::id threadId) {
         flushEvents(events, threadId, eventQueue);
     };
 
-    eventQueue.file->processing = std::async(std::launch::async,
-                                             flush,
-                                             eventQueue.currentEvents.subspan(0, eventQueue.eventsIndex),
-                                             eventQueue.threadId);
+    eventQueue.file.processing = std::async(std::launch::async,
+                                            flush,
+                                            eventQueue.currentEvents.subspan(0, eventQueue.eventsIndex),
+                                            eventQueue.threadId);
     eventQueue.currentEvents = eventQueue.currentEvents.data() == eventQueue.eventsOne.data()
                                    ? eventQueue.eventsTwo
                                    : eventQueue.eventsOne;
@@ -220,10 +220,11 @@ template NANOTRACE_EXPORT void flushInThread(
     EnabledEventQueue<StringViewWithStringArgumentsTraceEvent> &eventQueue);
 
 template<typename TraceEvent>
-EventQueue<TraceEvent, Tracing::IsEnabled>::EventQueue(EnabledTraceFile *file)
+EventQueue<TraceEvent, Tracing::IsEnabled>::EventQueue(EnabledTraceFile &file)
     : file{file}
     , threadId{std::this_thread::get_id()}
 {
+    setEventsSpans(*eventArrayOne.get(), *eventArrayTwo.get());
     Internal::EventQueueTracker<TraceEvent>::get().addQueue(this);
     if (auto thread = QThread::currentThread()) {
         auto name = getThreadName();
diff --git a/src/libs/nanotrace/nanotracehr.h b/src/libs/nanotrace/nanotracehr.h
index 99eb43d49a..eee9bf2dae 100644
--- a/src/libs/nanotrace/nanotracehr.h
+++ b/src/libs/nanotrace/nanotracehr.h
@@ -430,6 +430,8 @@ class EventQueue
 {
 public:
     using IsActive = std::false_type;
+
+    template<typename TraceFile> EventQueue(TraceFile &) {}
 };
 
 namespace Internal {
@@ -506,11 +508,12 @@ template<typename TraceEvent>
 class EventQueue<TraceEvent, Tracing::IsEnabled>
 {
     using TraceEventsSpan = Utils::span<TraceEvent>;
+    using TraceEvents = std::array<TraceEvent, 100>;
 
 public:
     using IsActive = std::true_type;
 
-    EventQueue(EnabledTraceFile *file);
+    EventQueue(EnabledTraceFile &file);
 
     ~EventQueue();
 
@@ -523,7 +526,9 @@ public:
     EventQueue &operator=(const EventQueue &) = delete;
     EventQueue &operator=(EventQueue &&) = delete;
 
-    EnabledTraceFile *file = nullptr;
+    EnabledTraceFile &file;
+    std::unique_ptr<TraceEvents> eventArrayOne = std::make_unique<TraceEvents>();
+    std::unique_ptr<TraceEvents> eventArrayTwo = std::make_unique<TraceEvents>();
     TraceEventsSpan eventsOne;
     TraceEventsSpan eventsTwo;
     TraceEventsSpan currentEvents;
@@ -545,35 +550,6 @@ extern template class NANOTRACE_EXPORT_EXTERN_TEMPLATE EventQueue<StringTraceEve
 extern template class NANOTRACE_EXPORT_EXTERN_TEMPLATE
     EventQueue<StringViewWithStringArgumentsTraceEvent, Tracing::IsEnabled>;
 
-template<typename TraceEvent, std::size_t eventCount, Tracing isEnabled>
-class EventQueueData : public EventQueue<TraceEvent, isEnabled>
-{
-public:
-    using IsActive = std::true_type;
-
-    EventQueueData(TraceFile<Tracing::IsDisabled> &) {}
-};
-
-template<typename TraceEvent, std::size_t eventCount>
-class EventQueueData<TraceEvent, eventCount, Tracing::IsEnabled>
-    : public EventQueue<TraceEvent, Tracing::IsEnabled>
-{
-    using TraceEvents = std::array<TraceEvent, eventCount>;
-    using Base = EventQueue<TraceEvent, Tracing::IsEnabled>;
-
-public:
-    using IsActive = std::true_type;
-
-    EventQueueData(EnabledTraceFile &file)
-        : Base{&file}
-    {
-        Base::setEventsSpans(*eventsOne.get(), *eventsTwo.get());
-    }
-
-    std::unique_ptr<TraceEvents> eventsOne = std::make_unique<TraceEvents>();
-    std::unique_ptr<TraceEvents> eventsTwo = std::make_unique<TraceEvents>();
-};
-
 template<typename TraceEvent>
 TraceEvent &getTraceEvent(EnabledEventQueue<TraceEvent> &eventQueue)
 {
@@ -1517,7 +1493,7 @@ private:
             if (category.isEnabled == IsEnabled::Yes) {
                 auto duration = Clock::now() - m_start;
                 auto &traceEvent = getTraceEvent(category.eventQueue());
-                traceEvent.name = m_name;
+                traceEvent.name = std::move(m_name);
                 traceEvent.category = category.name();
                 traceEvent.time = m_start;
                 traceEvent.duration = duration;
@@ -1530,7 +1506,7 @@ private:
                                                                    std::forward<Arguments>(
                                                                        arguments)...);
                 } else {
-                    traceEvent.arguments = m_arguments;
+                    traceEvent.arguments = std::move(m_arguments);
                 }
             }
         }
diff --git a/src/libs/sqlite/sqlitebasestatement.cpp b/src/libs/sqlite/sqlitebasestatement.cpp
index 23466c0cea..c340c52a0e 100644
--- a/src/libs/sqlite/sqlitebasestatement.cpp
+++ b/src/libs/sqlite/sqlitebasestatement.cpp
@@ -31,13 +31,13 @@ using TraceFile = NanotraceHR::TraceFile<sqliteTracingStatus()>;
 
 TraceFile traceFile{"sqlite.json"};
 
-thread_local NanotraceHR::EventQueueData<NanotraceHR::StringViewTraceEvent, 10000, sqliteTracingStatus()>
-    eventQueueData(traceFile);
+thread_local NanotraceHR::EventQueue<NanotraceHR::StringViewTraceEvent, sqliteTracingStatus()> eventQueue(
+    traceFile);
 
 NanotraceHR::StringViewCategory<sqliteTracingStatus()> &sqliteLowLevelCategory();
 
 thread_local NanotraceHR::StringViewCategory<sqliteTracingStatus()> sqliteLowLevelCategory_{
-    "sqlite low level"_t, eventQueueData, sqliteLowLevelCategory};
+    "sqlite low level"_t, eventQueue, sqliteLowLevelCategory};
 
 NanotraceHR::StringViewCategory<sqliteTracingStatus()> &sqliteLowLevelCategory()
 {
@@ -45,7 +45,7 @@ NanotraceHR::StringViewCategory<sqliteTracingStatus()> &sqliteLowLevelCategory()
 }
 
 thread_local NanotraceHR::StringViewCategory<sqliteTracingStatus()> sqliteHighLevelCategory_{
-    "sqlite high level"_t, eventQueueData, sqliteHighLevelCategory};
+    "sqlite high level"_t, eventQueue, sqliteHighLevelCategory};
 } // namespace
 
 NanotraceHR::StringViewCategory<sqliteTracingStatus()> &sqliteHighLevelCategory()