[lldb] Change return type of EventData::GetFlavor

[bulbazord]

Summary

There's no reason these strings need to be in the ConstString
StringPool, they're already string literals with static lifetime.

I plan on addressing other similar functions in follow up commits.

[jasonmolenda]

Am I missing something, how does this work when we have uses like event_data->GetFlavor() == TargetEventData::GetFlavorString() - is this changing from a one-time construction of a ConstString to a construction of a ConstString every time it's called by implicit construction?

[bulbazord]

In D147833#4252651, @jasonmolenda wrote:

Am I missing something, how does this work when we have uses like event_data->GetFlavor() == TargetEventData::GetFlavorString() - is this changing from a one-time construction of a ConstString to a construction of a ConstString every time it's called by implicit construction?

event_data->GetFlavor() == TargetEventData::GetFlavorString() would be just a straight pointer comparison, no ConstString in the picture. These strings don't need to be in the ConstString pool -- they only exist in one place each and are guaranteed to be there for the lifetime of a running lldb process. There are other places in lldb where I'd like to do this, but I figured I'd do it in a few smaller patches rather than one giant patch.

lldb/source/Utility/Event.cpp

183

Note: this is probably the wrong flavor string (i.e. a bug) but I'm just preserving existing behavior here, for better or worse.

[jasonmolenda]

In D147833#4252681, @bulbazord wrote:

In D147833#4252651, @jasonmolenda wrote:

Am I missing something, how does this work when we have uses like event_data->GetFlavor() == TargetEventData::GetFlavorString() - is this changing from a one-time construction of a ConstString to a construction of a ConstString every time it's called by implicit construction?

event_data->GetFlavor() == TargetEventData::GetFlavorString() would be just a straight pointer comparison, no ConstString in the picture. These strings don't need to be in the ConstString pool -- they only exist in one place each and are guaranteed to be there for the lifetime of a running lldb process. There are other places in lldb where I'd like to do this, but I figured I'd do it in a few smaller patches rather than one giant patch.

OK, I see. I saw the == and thought something must be constructed to an object for that operator to work, I didn't even think of address comparing constant data c-strings.

[jasonmolenda]

idk maybe I'm over-thinking it, but this does make me a little uncomfortable. We have at least one instance where someone did platform_sp->GetPluginName() == "ios-simulator" in ClangExpressionSourceCode.cpp (probably to avoid a dependency on an an apple platform plugin in generic code; the code should undoubtedly be done differently) and the mach-o linker on darwin today will unique identical c-strings from separate compilation units, but I doubt that's a guarantee on Darwin or on other platforms. Platform::GetPluginName is returning a StringRef here, and we naturally see code like this and assume the c-string will be converted to a StringRef or ConstString implicitly for the comparison operator. But if GetPluginName started returning a pointer to const c-string and the strings aren't uniqued, the comparison fails in a tricky to see way.

[jasonmolenda]

In D147833#4253416, @jasonmolenda wrote:

idk maybe I'm over-thinking it, but this does make me a little uncomfortable. We have at least one instance where someone did platform_sp->GetPluginName() == "ios-simulator" in ClangExpressionSourceCode.cpp

I only looked around for the first instance of this code pattern, there may be another place where we compare identification strings from objects. And I don't feel confident that I can anticipate what will be added to lldb in the future.

[bulbazord]

In D147833#4253416, @jasonmolenda wrote:

idk maybe I'm over-thinking it, but this does make me a little uncomfortable. We have at least one instance where someone did platform_sp->GetPluginName() == "ios-simulator" in ClangExpressionSourceCode.cpp (probably to avoid a dependency on an an apple platform plugin in generic code; the code should undoubtedly be done differently) and the mach-o linker on darwin today will unique identical c-strings from separate compilation units, but I doubt that's a guarantee on Darwin or on other platforms. Platform::GetPluginName is returning a StringRef here, and we naturally see code like this and assume the c-string will be converted to a StringRef or ConstString implicitly for the comparison operator. But if GetPluginName started returning a pointer to const c-string and the strings aren't uniqued, the comparison fails in a tricky to see way.

In D147833#4253422, @jasonmolenda wrote:

In D147833#4253416, @jasonmolenda wrote:

idk maybe I'm over-thinking it, but this does make me a little uncomfortable. We have at least one instance where someone did platform_sp->GetPluginName() == "ios-simulator" in ClangExpressionSourceCode.cpp

I only looked around for the first instance of this code pattern, there may be another place where we compare identification strings from objects. And I don't feel confident that I can anticipate what will be added to lldb in the future.

Yes, we definitely do that in many places. I see your point though, comparing const c-string pointers can get pretty tricky if somebody refactors this in the future. In that case, instead of GetFlavor returning a const char * or a ConstString, it could return a StringRef and this should be handled, no? Just like GetPluginName() in your example.

[jasonmolenda]

In D147833#4253499, @bulbazord wrote:

Yes, we definitely do that in many places. I see your point though, comparing const c-string pointers can get pretty tricky if somebody refactors this in the future. In that case, instead of GetFlavor returning a const char * or a ConstString, it could return a StringRef and this should be handled, no? Just like GetPluginName() in your example.

Yeah, that seems like a safer change.

[JDevlieghere]

In D147833#4253499, @bulbazord wrote:

Yes, we definitely do that in many places. I see your point though, comparing const c-string pointers can get pretty tricky if somebody refactors this in the future. In that case, instead of GetFlavor returning a const char * or a ConstString, it could return a StringRef and this should be handled, no? Just like GetPluginName() in your example.

I agree with Jason. Strong +1 on making that a StringRef. Comparing pointers is asking for trouble.

[bulbazord]

Change return type to llvm::StringRef

[JDevlieghere]

LGTM

lldb/include/lldb/Breakpoint/Breakpoint.h

 public:
   class BreakpointEventData : public EventData {
   public:
     BreakpointEventData(lldb::BreakpointEventType sub_type,
                         const lldb::BreakpointSP &new_breakpoint_sp);
 
     ~BreakpointEventData() override;
 
-    static ConstString GetFlavorString();
-    
+    static const char *GetFlavorString();
     Log *GetLogChannel() override;
 
-    ConstString GetFlavor() const override;
+    const char *GetFlavor() const override;
 
     lldb::BreakpointEventType GetBreakpointEventType() const;
 
     lldb::BreakpointSP GetBreakpoint() const;
 
     BreakpointLocationCollection &GetBreakpointLocationCollection() {
       return m_locations;
     }

lldb/include/lldb/Breakpoint/Watchpoint.h

 public:
   class WatchpointEventData : public EventData {
   public:
     WatchpointEventData(lldb::WatchpointEventType sub_type,
                         const lldb::WatchpointSP &new_watchpoint_sp);
 
     ~WatchpointEventData() override;
 
-    static ConstString GetFlavorString();
+    static const char *GetFlavorString();
 
-    ConstString GetFlavor() const override;
+    const char *GetFlavor() const override;
 
     lldb::WatchpointEventType GetWatchpointEventType() const;
 
     lldb::WatchpointSP &GetWatchpoint();
 
     void Dump(Stream *s) const override;
 
     static lldb::WatchpointEventType

lldb/include/lldb/Core/DebuggerEvents.h

 //===-- DebuggerEvents.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include <string>
 
 #ifndef LLDB_CORE_DEBUGGER_EVENTS_H
 #define LLDB_CORE_DEBUGGER_EVENTS_H
 
 namespace lldb_private {
 class Stream;
 
 class ProgressEventData : public EventData {
 public:
   ProgressEventData(uint64_t progress_id, std::string title, std::string update,
                     uint64_t completed, uint64_t total, bool debugger_specific)
       : m_title(std::move(title)), m_details(std::move(update)),
         m_id(progress_id), m_completed(completed), m_total(total),
         m_debugger_specific(debugger_specific) {}
 
-  static ConstString GetFlavorString();
+  static const char *GetFlavorString();
 
-  ConstString GetFlavor() const override;
+  const char *GetFlavor() const override;
 
   void Dump(Stream *s) const override;
 
   static const ProgressEventData *GetEventDataFromEvent(const Event *event_ptr);
 
   static StructuredData::DictionarySP
   GetAsStructuredData(const Event *event_ptr);
 
public:
   const std::string &GetMessage() const { return m_message; }
   bool IsDebuggerSpecific() const { return m_debugger_specific; }
   Type GetType() const { return m_type; }
 
   llvm::StringRef GetPrefix() const;
 
   void Dump(Stream *s) const override;
 
-  static ConstString GetFlavorString();
-  ConstString GetFlavor() const override;
+  static const char *GetFlavorString();
+  const char *GetFlavor() const override;
 
   static const DiagnosticEventData *
   GetEventDataFromEvent(const Event *event_ptr);
 
   static StructuredData::DictionarySP
   GetAsStructuredData(const Event *event_ptr);
 
 protected:
   std::string m_message;
   Type m_type;
   const bool m_debugger_specific;
 
   DiagnosticEventData(const DiagnosticEventData &) = delete;
   const DiagnosticEventData &operator=(const DiagnosticEventData &) = delete;
 };
 
 class SymbolChangeEventData : public EventData {
 public:
   SymbolChangeEventData(lldb::DebuggerWP debugger_wp, ModuleSpec module_spec)
       : m_debugger_wp(debugger_wp), m_module_spec(std::move(module_spec)) {}
 
-  static ConstString GetFlavorString();
-  ConstString GetFlavor() const override;
+  static const char *GetFlavorString();
+  const char *GetFlavor() const override;
 
   static const SymbolChangeEventData *
   GetEventDataFromEvent(const Event *event_ptr);
 
   void DoOnRemoval(Event *event_ptr) override;
 
 private:
   lldb::DebuggerWP m_debugger_wp;

lldb/include/lldb/Target/Process.h

class ProcessEventData : public EventData {
     friend class Process;
 
   public:
     ProcessEventData();
     ProcessEventData(const lldb::ProcessSP &process, lldb::StateType state);
 
     ~ProcessEventData() override;
 
-    static ConstString GetFlavorString();
+    static const char *GetFlavorString();
 
-    ConstString GetFlavor() const override;
+    const char *GetFlavor() const override;
 
     lldb::ProcessSP GetProcessSP() const { return m_process_wp.lock(); }
 
     lldb::StateType GetState() const { return m_state; }
     bool GetRestarted() const { return m_restarted; }
 
     size_t GetNumRestartedReasons() { return m_restarted_reasons.size(); }
 

lldb/include/lldb/Target/Target.h

public:
   public:
     TargetEventData(const lldb::TargetSP &target_sp);
 
     TargetEventData(const lldb::TargetSP &target_sp,
                     const ModuleList &module_list);
 
     ~TargetEventData() override;
 
-    static ConstString GetFlavorString();
+    static const char *GetFlavorString();
 
-    ConstString GetFlavor() const override {
+    const char *GetFlavor() const override {
       return TargetEventData::GetFlavorString();
     }
 
     void Dump(Stream *s) const override;
 
     static const TargetEventData *GetEventDataFromEvent(const Event *event_ptr);
 
     static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr);

lldb/include/lldb/Target/Thread.h

public:
     ThreadEventData(const lldb::ThreadSP thread_sp);
 
     ThreadEventData(const lldb::ThreadSP thread_sp, const StackID &stack_id);
 
     ThreadEventData();
 
     ~ThreadEventData() override;
 
-    static ConstString GetFlavorString();
+    static const char *GetFlavorString();
 
-    ConstString GetFlavor() const override {
+    const char *GetFlavor() const override {
       return ThreadEventData::GetFlavorString();
     }
 
     void Dump(Stream *s) const override;
 
     static const ThreadEventData *GetEventDataFromEvent(const Event *event_ptr);
 
     static lldb::ThreadSP GetThreadFromEvent(const Event *event_ptr);

lldb/include/lldb/Utility/Event.h

 class EventData {
   friend class Event;
 
 public:
   EventData();
 
   virtual ~EventData();
 
-  virtual ConstString GetFlavor() const = 0;
-  
+  virtual const char *GetFlavor() const = 0;
   virtual Log *GetLogChannel() { return nullptr; }
   
   virtual void Dump(Stream *s) const;
 
 private:
   virtual void DoOnRemoval(Event *event_ptr) {}
 
   EventData(const EventData &) = delete;
public:
 
   EventDataBytes(llvm::StringRef str);
 
   EventDataBytes(const void *src, size_t src_len);
 
   ~EventDataBytes() override;
 
   // Member functions
-  ConstString GetFlavor() const override;
+  const char *GetFlavor() const override;
 
   void Dump(Stream *s) const override;
 
   const void *GetBytes() const;
 
   size_t GetByteSize() const;
 
   void SetBytes(const void *src, size_t src_len);
 
   void SwapBytes(std::string &new_bytes);
 
   void SetBytesFromCString(const char *cstr);
 
   // Static functions
   static const EventDataBytes *GetEventDataFromEvent(const Event *event_ptr);
 
   static const void *GetBytesFromEvent(const Event *event_ptr);
 
   static size_t GetByteSizeFromEvent(const Event *event_ptr);
 
-  static ConstString GetFlavorString();
+  static const char *GetFlavorString();
 
 private:
   std::string m_bytes;
 
   EventDataBytes(const EventDataBytes &) = delete;
   const EventDataBytes &operator=(const EventDataBytes &) = delete;
 };
 
 class EventDataReceipt : public EventData {
 public:
   EventDataReceipt() : m_predicate(false) {}
 
   ~EventDataReceipt() override = default;
 
-  static ConstString GetFlavorString() {
-    static ConstString g_flavor("Process::ProcessEventData");
-    return g_flavor;
-  }
+  static const char *GetFlavorString();
 
-  ConstString GetFlavor() const override { return GetFlavorString(); }
+  const char *GetFlavor() const override { return GetFlavorString(); }
 
   bool WaitForEventReceived(const Timeout<std::micro> &timeout = std::nullopt) {
     return m_predicate.WaitForValueEqualTo(true, timeout);
   }
 
 private:
   Predicate<bool> m_predicate;
 
public:
 
   EventDataStructuredData(const lldb::ProcessSP &process_sp,
                           const StructuredData::ObjectSP &object_sp,
                           const lldb::StructuredDataPluginSP &plugin_sp);
 
   ~EventDataStructuredData() override;
 
   // Member functions
-  ConstString GetFlavor() const override;
+  const char *GetFlavor() const override;
 
   void Dump(Stream *s) const override;
 
   const lldb::ProcessSP &GetProcess() const;
 
   const StructuredData::ObjectSP &GetObject() const;
 
   const lldb::StructuredDataPluginSP &GetStructuredDataPlugin() const;
public:
 
   static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr);
 
   static StructuredData::ObjectSP GetObjectFromEvent(const Event *event_ptr);
 
   static lldb::StructuredDataPluginSP
   GetPluginFromEvent(const Event *event_ptr);
 
-  static ConstString GetFlavorString();
+  static const char *GetFlavorString();
 
 private:
   lldb::ProcessSP m_process_sp;
   StructuredData::ObjectSP m_object_sp;
   lldb::StructuredDataPluginSP m_plugin_sp;
 
   EventDataStructuredData(const EventDataStructuredData &) = delete;
   const EventDataStructuredData &

lldb/source/API/SBEvent.cpp

 
 const char *SBEvent::GetDataFlavor() {
   LLDB_INSTRUMENT_VA(this);
 
   Event *lldb_event = get();
   if (lldb_event) {
     EventData *event_data = lldb_event->GetData();
     if (event_data)
-      return lldb_event->GetData()->GetFlavor().AsCString();
+      return lldb_event->GetData()->GetFlavor();
   }
   return nullptr;
 }
 
 uint32_t SBEvent::GetType() const {
   LLDB_INSTRUMENT_VA(this);
 
   const Event *lldb_event = get();

lldb/source/Breakpoint/Breakpoint.cpp

 }
 
 Breakpoint::BreakpointEventData::BreakpointEventData(
     BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp)
     : m_breakpoint_event(sub_type), m_new_breakpoint_sp(new_breakpoint_sp) {}
 
 Breakpoint::BreakpointEventData::~BreakpointEventData() = default;
 
-ConstString Breakpoint::BreakpointEventData::GetFlavorString() {
-  static ConstString g_flavor("Breakpoint::BreakpointEventData");
-  return g_flavor;
+const char *Breakpoint::BreakpointEventData::GetFlavorString() {
+  return "Breakpoint::BreakpointEventData";
 }
 
-ConstString Breakpoint::BreakpointEventData::GetFlavor() const {
+const char *Breakpoint::BreakpointEventData::GetFlavor() const {
   return BreakpointEventData::GetFlavorString();
 }
 
 BreakpointSP Breakpoint::BreakpointEventData::GetBreakpoint() const {
   return m_new_breakpoint_sp;
 }
 
 BreakpointEventType

lldb/source/Breakpoint/Watchpoint.cpp

 }
 
 Watchpoint::WatchpointEventData::WatchpointEventData(
     WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
     : m_watchpoint_event(sub_type), m_new_watchpoint_sp(new_watchpoint_sp) {}
 
 Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
 
-ConstString Watchpoint::WatchpointEventData::GetFlavorString() {
-  static ConstString g_flavor("Watchpoint::WatchpointEventData");
-  return g_flavor;
+const char *Watchpoint::WatchpointEventData::GetFlavorString() {
+  return "Watchpoint::WatchpointEventData";
 }
 
-ConstString Watchpoint::WatchpointEventData::GetFlavor() const {
+const char *Watchpoint::WatchpointEventData::GetFlavor() const {
   return WatchpointEventData::GetFlavorString();
 }
 
 WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
   return m_new_watchpoint_sp;
 }
 
 WatchpointEventType

lldb/source/Core/DebuggerEvents.cpp

 static const T *GetEventDataFromEventImpl(const Event *event_ptr) {
   if (event_ptr)
     if (const EventData *event_data = event_ptr->GetData())
       if (event_data->GetFlavor() == T::GetFlavorString())
         return static_cast<const T *>(event_ptr->GetData());
   return nullptr;
 }
 
-ConstString ProgressEventData::GetFlavorString() {
-  static ConstString g_flavor("ProgressEventData");
-  return g_flavor;
-}
+const char *ProgressEventData::GetFlavorString() { return "ProgressEventData"; }
 
-ConstString ProgressEventData::GetFlavor() const {
+const char *ProgressEventData::GetFlavor() const {
   return ProgressEventData::GetFlavorString();
 }
 
 void ProgressEventData::Dump(Stream *s) const {
   s->Printf(" id = %" PRIu64 ", title = \"%s\"", m_id, m_title.c_str());
   if (!m_details.empty())
     s->Printf(", details = \"%s\"", m_details.c_str());
   if (m_completed == 0 || m_completed == m_total)
llvm::HighlightColor color = m_type == Type::Warning
                                    ? llvm::HighlightColor::Warning
                                    : llvm::HighlightColor::Error;
   llvm::WithColor(s->AsRawOstream(), color, llvm::ColorMode::Enable)
       << GetPrefix();
   *s << ": " << GetMessage() << '\n';
   s->Flush();
 }
 
-ConstString DiagnosticEventData::GetFlavorString() {
-  static ConstString g_flavor("DiagnosticEventData");
-  return g_flavor;
+const char *DiagnosticEventData::GetFlavorString() {
+  return "DiagnosticEventData";
 }
 
-ConstString DiagnosticEventData::GetFlavor() const {
+const char *DiagnosticEventData::GetFlavor() const {
   return DiagnosticEventData::GetFlavorString();
 }
 
 const DiagnosticEventData *
 DiagnosticEventData::GetEventDataFromEvent(const Event *event_ptr) {
   return GetEventDataFromEventImpl<DiagnosticEventData>(event_ptr);
 }
 
 StructuredData::DictionarySP
 DiagnosticEventData::GetAsStructuredData(const Event *event_ptr) {
   const DiagnosticEventData *diagnostic_data =
       DiagnosticEventData::GetEventDataFromEvent(event_ptr);
 
   if (!diagnostic_data)
     return {};
 
   auto dictionary_sp = std::make_shared<StructuredData::Dictionary>();
   dictionary_sp->AddStringItem("message", diagnostic_data->GetMessage());
   dictionary_sp->AddStringItem("type", diagnostic_data->GetPrefix());
   dictionary_sp->AddBooleanItem("debugger_specific",
                                 diagnostic_data->IsDebuggerSpecific());
   return dictionary_sp;
 }
 
-ConstString SymbolChangeEventData::GetFlavorString() {
-  static ConstString g_flavor("SymbolChangeEventData");
-  return g_flavor;
+const char *SymbolChangeEventData::GetFlavorString() {
+  return "SymbolChangeEventData";
 }
 
-ConstString SymbolChangeEventData::GetFlavor() const {
+const char *SymbolChangeEventData::GetFlavor() const {
   return SymbolChangeEventData::GetFlavorString();
 }
 
 const SymbolChangeEventData *
 SymbolChangeEventData::GetEventDataFromEvent(const Event *event_ptr) {
   return GetEventDataFromEventImpl<SymbolChangeEventData>(event_ptr);
 }
 

lldb/source/Target/Process.cpp

Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
                                             StateType state)
     : EventData(), m_process_wp(), m_state(state) {
   if (process_sp)
     m_process_wp = process_sp;
 }
 
 Process::ProcessEventData::~ProcessEventData() = default;
 
-ConstString Process::ProcessEventData::GetFlavorString() {
-  static ConstString g_flavor("Process::ProcessEventData");
-  return g_flavor;
+const char *Process::ProcessEventData::GetFlavorString() {
+  return "Process::ProcessEventData";
 }
 
-ConstString Process::ProcessEventData::GetFlavor() const {
+const char *Process::ProcessEventData::GetFlavor() const {
   return ProcessEventData::GetFlavorString();
 }
 
 bool Process::ProcessEventData::ShouldStop(Event *event_ptr,
                                            bool &found_valid_stopinfo) {
   found_valid_stopinfo = false;
 
   ProcessSP process_sp(m_process_wp.lock());

lldb/source/Target/Target.cpp

Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp)
     : EventData(), m_target_sp(target_sp), m_module_list() {}
 
 Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
                                          const ModuleList &module_list)
     : EventData(), m_target_sp(target_sp), m_module_list(module_list) {}
 
 Target::TargetEventData::~TargetEventData() = default;
 
-ConstString Target::TargetEventData::GetFlavorString() {
-  static ConstString g_flavor("Target::TargetEventData");
-  return g_flavor;
+const char *Target::TargetEventData::GetFlavorString() {
+  return "Target::TargetEventData";
 }
 
 void Target::TargetEventData::Dump(Stream *s) const {
   for (size_t i = 0; i < m_module_list.GetSize(); ++i) {
     if (i != 0)
       *s << ", ";
     m_module_list.GetModuleAtIndex(i)->GetDescription(
         s->AsRawOstream(), lldb::eDescriptionLevelBrief);

lldb/source/Target/Thread.cpp

 uint64_t ThreadProperties::GetMaxBacktraceDepth() const {
   const uint32_t idx = ePropertyMaxBacktraceDepth;
   return m_collection_sp->GetPropertyAtIndexAsUInt64(
       nullptr, idx, g_thread_properties[idx].default_uint_value != 0);
 }
 
 // Thread Event Data
 
-ConstString Thread::ThreadEventData::GetFlavorString() {
-  static ConstString g_flavor("Thread::ThreadEventData");
-  return g_flavor;
+const char *Thread::ThreadEventData::GetFlavorString() {
+  return "Thread::ThreadEventData";
 }
 
 Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp)
     : m_thread_sp(thread_sp), m_stack_id() {}
 
 Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp,
                                          const StackID &stack_id)
     : m_thread_sp(thread_sp), m_stack_id(stack_id) {}

lldb/source/Utility/Event.cpp

 }
 
 EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
   SetBytes(src, src_len);
 }
 
 EventDataBytes::~EventDataBytes() = default;
 
-ConstString EventDataBytes::GetFlavorString() {
-  static ConstString g_flavor("EventDataBytes");
-  return g_flavor;
-}
+const char *EventDataBytes::GetFlavorString() { return "EventDataBytes"; }
 
-ConstString EventDataBytes::GetFlavor() const {
+const char *EventDataBytes::GetFlavor() const {
   return EventDataBytes::GetFlavorString();
 }
 
 void EventDataBytes::Dump(Stream *s) const {
   if (llvm::all_of(m_bytes, llvm::isPrint))
     s->Format("\"{0}\"", m_bytes);
   else
     s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) {
   }
   return nullptr;
 }
 
 void EventDataBytes::SwapBytes(std::string &new_bytes) {
   m_bytes.swap(new_bytes);
 }
 
+const char *EventDataReceipt::GetFlavorString() {
+  return "Process::ProcessEventData";
+}
+
 #pragma mark -
 #pragma mark EventStructuredData
 
 // EventDataStructuredData definitions
 
 EventDataStructuredData::EventDataStructuredData()
     : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
 
 EventDataStructuredData::EventDataStructuredData(
     const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
     const lldb::StructuredDataPluginSP &plugin_sp)
     : EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
       m_plugin_sp(plugin_sp) {}
 
 EventDataStructuredData::~EventDataStructuredData() = default;
 
 // EventDataStructuredData member functions
 
-ConstString EventDataStructuredData::GetFlavor() const {
+const char *EventDataStructuredData::GetFlavor() const {
   return EventDataStructuredData::GetFlavorString();
 }
 
 void EventDataStructuredData::Dump(Stream *s) const {
   if (!s)
     return;
 
   if (m_object_sp)

 EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
   if (event_data)
     return event_data->GetStructuredDataPlugin();
   else
     return StructuredDataPluginSP();
 }
 
-ConstString EventDataStructuredData::GetFlavorString() {
-  static ConstString s_flavor("EventDataStructuredData");
-  return s_flavor;
+const char *EventDataStructuredData::GetFlavorString() {
+  return "EventDataStructuredData";
 }