[lldb][NFCI] Change type of UnwindPlan::m_source_name

[bulbazord]

Summary

m_source_name is currently a ConstString. Comparing the source names are
not a performance-critical operation, so that portion isn't really
necessary. It may benefit from deduplication (since there are only
a handful of possible values) but this means they will stick around
forever in the StringPool, even if they are never used again. As such, I
think it would be reasonable to change its type to std::string
instead.

[jasonmolenda]

I'm fine with this. It does increase the size of the UnwindPlan object, and there are a couple of them for every function that we see on a stack during a program execution, but I believe that won't be more than a few hundred. These are short strings so they won't expand to use heap, they will fit inline. Strictly I think it is more memory efficient to leave these half-dozen strings in the constant string pool than to have an extra 24 bytes in each UnwindPlan with them duplicated, but it's not enough memory use for me to be actually worried about it.

[jasonmolenda]

(to say it more clearly: I'm fine if you'd like to reduce the places where ConstStrings are being used, but I don't think there's any good reason to remove this use of them. It will increase our memory footprint a bit.)

[jasonmolenda]

probably the real correct change is to have constant c-strings in as globals and have pointers to those. Then you're using the same space as a ConstString in each UnwindPlan (a pointer) but creation is cheaper. There's no dynamic aspect to the names when the UnwindPlans are created, each method creating them knows what the name will be.

[jasonmolenda]

I guess simplest is we can have all the UnwindPlan creators have a static g_unwindplan_name and save a pointer to that. Each one is unique, don't need anything fancier than that. There's the risk that someone will create a new UnwindPlan and forget to make it a static string, so unwind logging would try to print random memory, but it wouldn't break normal debugging.

[bulbazord]

In D154759#4487381, @jasonmolenda wrote:

I guess simplest is we can have all the UnwindPlan creators have a static g_unwindplan_name and save a pointer to that. Each one is unique, don't need anything fancier than that. There's the risk that someone will create a new UnwindPlan and forget to make it a static string, so unwind logging would try to print random memory, but it wouldn't break normal debugging.

I was thinking about this earlier, since we know what all the possible strings are going to be, we can create them all statically at compile time and just point to them. We can refactor a bit and then most of these source names just become static const char * or static constexpr llvm::StringLiteral or something like this.

lldb/include/lldb/Symbol/UnwindPlan.h

 //===-- UnwindPlan.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_UNWINDPLAN_H
 #define LLDB_SYMBOL_UNWINDPLAN_H
 
 #include <map>
 #include <memory>
+#include <string>
 #include <vector>
 
 #include "lldb/Core/AddressRange.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 // The UnwindPlan object specifies how to unwind out of a function - where this
 // function saves the caller's register values before modifying them (for non-
 // volatile aka saved registers) and how to find this frame's Canonical Frame
public:
   bool PlanValidAtAddress(Address addr);
 
   bool IsValidRowIndex(uint32_t idx) const;
 
   const UnwindPlan::RowSP GetRowAtIndex(uint32_t idx) const;
 
   const UnwindPlan::RowSP GetLastRow() const;
 
-  lldb_private::ConstString GetSourceName() const;
+  const std::string &GetSourceName() const;
 
-  void SetSourceName(const char *);
+  void SetSourceName(std::string name);
 
   // Was this UnwindPlan emitted by a compiler?
   lldb_private::LazyBool GetSourcedFromCompiler() const {
     return m_plan_is_sourced_from_compiler;
   }
 
   // Was this UnwindPlan emitted by a compiler?
   void SetSourcedFromCompiler(lldb_private::LazyBool from_compiler) {
public:
   }
 
   int GetRowCount() const;
 
   void Clear() {
     m_row_list.clear();
     m_plan_valid_address_range.Clear();
     m_register_kind = lldb::eRegisterKindDWARF;
-    m_source_name.Clear();
+    m_source_name.clear();
     m_plan_is_sourced_from_compiler = eLazyBoolCalculate;
     m_plan_is_valid_at_all_instruction_locations = eLazyBoolCalculate;
     m_plan_is_for_signal_trap = eLazyBoolCalculate;
     m_lsda_address.Clear();
     m_personality_func_addr.Clear();
   }
 
   const RegisterInfo *GetRegisterInfo(Thread *thread, uint32_t reg_num) const;
private:
   collection m_row_list;
   AddressRange m_plan_valid_address_range;
   lldb::RegisterKind m_register_kind; // The RegisterKind these register numbers
                                       // are in terms of - will need to be
   // translated to lldb native reg nums at unwind time
   uint32_t m_return_addr_register; // The register that has the return address
                                    // for the caller frame
                                    // e.g. the lr on arm
-  lldb_private::ConstString
+  std::string
       m_source_name; // for logging, where this UnwindPlan originated from
   lldb_private::LazyBool m_plan_is_sourced_from_compiler;
   lldb_private::LazyBool m_plan_is_valid_at_all_instruction_locations;
   lldb_private::LazyBool m_plan_is_for_signal_trap;
 
   Address m_lsda_address; // Where the language specific data area exists in the
                           // module - used
                           // in exception handling.
   Address m_personality_func_addr; // The address of a pointer to the
                                    // personality function - used in
                                    // exception handling.
 };                                 // class UnwindPlan
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_UNWINDPLAN_H

lldb/source/Commands/CommandObjectTarget.cpp

for (const SymbolContext &sc : sc_list) {
 
       result.GetOutputStream().Printf("\n");
 
       UnwindPlanSP non_callsite_unwind_plan =
           func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread);
       if (non_callsite_unwind_plan) {
         result.GetOutputStream().Printf(
             "Asynchronous (not restricted to call-sites) UnwindPlan is '%s'\n",
-            non_callsite_unwind_plan->GetSourceName().AsCString());
+            non_callsite_unwind_plan->GetSourceName().c_str());
       }
       UnwindPlanSP callsite_unwind_plan =
           func_unwinders_sp->GetUnwindPlanAtCallSite(*target, *thread);
       if (callsite_unwind_plan) {
         result.GetOutputStream().Printf(
             "Synchronous (restricted to call-sites) UnwindPlan is '%s'\n",
-            callsite_unwind_plan->GetSourceName().AsCString());
+            callsite_unwind_plan->GetSourceName().c_str());
       }
       UnwindPlanSP fast_unwind_plan =
           func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread);
       if (fast_unwind_plan) {
         result.GetOutputStream().Printf(
             "Fast UnwindPlan is '%s'\n",
-            fast_unwind_plan->GetSourceName().AsCString());
+            fast_unwind_plan->GetSourceName().c_str());
       }
 
       result.GetOutputStream().Printf("\n");
 
       UnwindPlanSP assembly_sp =
           func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread);
       if (assembly_sp) {
         result.GetOutputStream().Printf(

lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

if (cfa_reg == m_lldb_sp_regnum) {
       // This must be hand-written assembly.
       // Just trust eh_frame and assume we have finished.
       break;
     }
   }
 
   unwind_plan.SetPlanValidAddressRange(func_range);
   if (unwind_plan_updated) {
-    std::string unwind_plan_source(unwind_plan.GetSourceName().AsCString());
+    std::string unwind_plan_source(unwind_plan.GetSourceName());
     unwind_plan_source += " plus augmentation from assembly parsing";
-    unwind_plan.SetSourceName(unwind_plan_source.c_str());
+    unwind_plan.SetSourceName(std::move(unwind_plan_source));
     unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
     unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
   }
   return true;
 }
 
 bool x86AssemblyInspectionEngine::FindFirstNonPrologueInstruction(
     uint8_t *data, size_t size, size_t &offset) {

lldb/source/Symbol/UnwindPlan.cpp

 //===-- UnwindPlan.cpp ----------------------------------------------------===//
 //
 // 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/Symbol/UnwindPlan.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include <optional>
 
 using namespace lldb;
 using namespace lldb_private;
bool UnwindPlan::PlanValidAtAddress(Address addr) {
   if (GetRowCount() == 0) {
     Log *log = GetLog(LLDBLog::Unwind);
     if (log) {
       StreamString s;
       if (addr.Dump(&s, nullptr, Address::DumpStyleSectionNameOffset)) {
         LLDB_LOGF(log,
                   "UnwindPlan is invalid -- no unwind rows for UnwindPlan "
                   "'%s' at address %s",
-                  m_source_name.GetCString(), s.GetData());
+                  m_source_name.c_str(), s.GetData());
       } else {
         LLDB_LOGF(log,
                   "UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s'",
-                  m_source_name.GetCString());
+                  m_source_name.c_str());
       }
     }
     return false;
   }
 
   // If the 0th Row of unwind instructions is missing, or if it doesn't provide
   // a register to use to find the Canonical Frame Address, this is not a valid
   // UnwindPlan.
   if (GetRowAtIndex(0).get() == nullptr ||
       GetRowAtIndex(0)->GetCFAValue().GetValueType() ==
           Row::FAValue::unspecified) {
     Log *log = GetLog(LLDBLog::Unwind);
     if (log) {
       StreamString s;
       if (addr.Dump(&s, nullptr, Address::DumpStyleSectionNameOffset)) {
         LLDB_LOGF(log,
                   "UnwindPlan is invalid -- no CFA register defined in row 0 "
                   "for UnwindPlan '%s' at address %s",
-                  m_source_name.GetCString(), s.GetData());
+                  m_source_name.c_str(), s.GetData());
       } else {
         LLDB_LOGF(log,
                   "UnwindPlan is invalid -- no CFA register defined in row 0 "
                   "for UnwindPlan '%s'",
-                  m_source_name.GetCString());
+                  m_source_name.c_str());
       }
     }
     return false;
   }
 
   if (!m_plan_valid_address_range.GetBaseAddress().IsValid() ||
       m_plan_valid_address_range.GetByteSize() == 0)
     return true;
 
   if (!addr.IsValid())
     return true;
 
   if (m_plan_valid_address_range.ContainsFileAddress(addr))
     return true;
 
   return false;
 }
 
 void UnwindPlan::Dump(Stream &s, Thread *thread, lldb::addr_t base_addr) const {
-  if (!m_source_name.IsEmpty()) {
+  if (!m_source_name.empty()) {
     s.Printf("This UnwindPlan originally sourced from %s\n",
-             m_source_name.GetCString());
+             m_source_name.c_str());
   }
   if (m_lsda_address.IsValid() && m_personality_func_addr.IsValid()) {
     TargetSP target_sp(thread->CalculateTarget());
     addr_t lsda_load_addr = m_lsda_address.GetLoadAddress(target_sp.get());
     addr_t personality_func_load_addr =
         m_personality_func_addr.GetLoadAddress(target_sp.get());
 
     if (lsda_load_addr != LLDB_INVALID_ADDRESS &&
collection::const_iterator pos, begin = m_row_list.begin(),
                                   end = m_row_list.end();
   for (pos = begin; pos != end; ++pos) {
     s.Printf("row[%u]: ", (uint32_t)std::distance(begin, pos));
     (*pos)->Dump(s, this, thread, base_addr);
     s.Printf("\n");
   }
 }
 
-void UnwindPlan::SetSourceName(const char *source) {
-  m_source_name = ConstString(source);
+void UnwindPlan::SetSourceName(std::string name) {
+  m_source_name = std::move(name);
 }
 
-ConstString UnwindPlan::GetSourceName() const { return m_source_name; }
+const std::string &UnwindPlan::GetSourceName() const { return m_source_name; }
 
 const RegisterInfo *UnwindPlan::GetRegisterInfo(Thread *thread,
                                                 uint32_t unwind_reg) const {
   if (thread) {
     RegisterContext *reg_ctx = thread->GetRegisterContext().get();
     if (reg_ctx) {
       uint32_t reg;
       if (m_register_kind == eRegisterKindLLDB)

lldb/source/Target/RegisterContextUnwind.cpp

UnwindLogMsg(
         "could not read CFA or AFA values for first frame, not valid.");
     m_frame_type = eNotAValidFrame;
     return;
   }
 
   UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64
                " afa is 0x%" PRIx64 " using %s UnwindPlan",
                (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
-               (uint64_t)m_cfa,
-               (uint64_t)m_afa,
-               m_full_unwind_plan_sp->GetSourceName().GetCString());
+               (uint64_t)m_cfa, (uint64_t)m_afa,
+               m_full_unwind_plan_sp->GetSourceName().c_str());
 }
 
 // Initialize a RegisterContextUnwind for the non-zeroth frame -- rely on the
 // RegisterContextUnwind "below" it to provide things like its current pc value.
 
 void RegisterContextUnwind::InitializeNonZerothFrame() {
   Log *log = GetLog(LLDBLog::Unwind);
   if (IsFrameZero()) {
active_row =
         m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
     row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
     PropagateTrapHandlerFlagFromUnwindPlan(m_fast_unwind_plan_sp);
     if (active_row.get() && log) {
       StreamString active_row_strm;
       active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
                        m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
       UnwindLogMsg("Using fast unwind plan '%s'",
-                   m_fast_unwind_plan_sp->GetSourceName().AsCString());
+                   m_fast_unwind_plan_sp->GetSourceName().c_str());
       UnwindLogMsg("active row: %s", active_row_strm.GetData());
     }
   } else {
     m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
     if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp)) {
       active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(
           m_current_offset_backed_up_one);
       row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
       PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
       if (active_row.get() && log) {
         StreamString active_row_strm;
         active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
                          &m_thread,
                          m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
         UnwindLogMsg("Using full unwind plan '%s'",
-                     m_full_unwind_plan_sp->GetSourceName().AsCString());
+                     m_full_unwind_plan_sp->GetSourceName().c_str());
         UnwindLogMsg("active row: %s", active_row_strm.GetData());
       }
     }
   }
 
   if (!active_row.get()) {
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("could not find unwind row for this pc");
if (process && process->GetDynamicLoader() &&
     unwind_plan_sp =
         func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
     if (!unwind_plan_sp)
       unwind_plan_sp =
           func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
       UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because the "
                           "DynamicLoader suggested we prefer it",
-                          unwind_plan_sp->GetSourceName().GetCString());
+                          unwind_plan_sp->GetSourceName().c_str());
       return unwind_plan_sp;
     }
   }
 
   // Typically the NonCallSite UnwindPlan is the unwind created by inspecting
   // the assembly language instructions
   if (m_behaves_like_zeroth_frame && process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
           m_fallback_unwind_plan_sp = call_site_unwind_plan;
         } else {
           m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
         }
       }
       UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because this "
                           "is the non-call site unwind plan and this is a "
                           "zeroth frame",
-                          unwind_plan_sp->GetSourceName().GetCString());
+                          unwind_plan_sp->GetSourceName().c_str());
       return unwind_plan_sp;
     }
 
     // If we're on the first instruction of a function, and we have an
     // architectural default UnwindPlan for the initial instruction of a
     // function, use that.
     if (m_current_offset == 0) {
       unwind_plan_sp =
           func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry(
               m_thread);
       if (unwind_plan_sp) {
-        UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because we are at "
-                            "the first instruction of a function",
-                            unwind_plan_sp->GetSourceName().GetCString());
+        UnwindLogMsgVerbose(
+            "frame uses %s for full UnwindPlan because we are at "
+            unwind_plan_sp->GetSourceName().c_str());
         return unwind_plan_sp;
       }
     }
   }
 
   // Typically this is unwind info from an eh_frame section intended for
   // exception handling; only valid at call sites
   if (process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite(
         process->GetTarget(), m_thread);
   }
   if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
     UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because this "
                         "is the call-site unwind plan",
-                        unwind_plan_sp->GetSourceName().GetCString());
+                        unwind_plan_sp->GetSourceName().c_str());
     return unwind_plan_sp;
   }
 
   // We'd prefer to use an UnwindPlan intended for call sites when we're at a
   // call site but if we've struck out on that, fall back to using the non-
   // call-site assembly inspection UnwindPlan if possible.
   if (process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
if (call_site_unwind_plan &&
             unwind_plan_sp->GetSourceName()) {
       m_fallback_unwind_plan_sp = call_site_unwind_plan;
     } else {
       m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
     }
   }
 
   if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
-    UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because we "
-                        "failed to find a call-site unwind plan that would work",
-                        unwind_plan_sp->GetSourceName().GetCString());
+    UnwindLogMsgVerbose(
+        "frame uses %s for full UnwindPlan because we "
+        unwind_plan_sp->GetSourceName().c_str());
     return unwind_plan_sp;
   }
 
   // If nothing else, use the architectural default UnwindPlan and hope that
   // does the job.
   if (arch_default_unwind_plan_sp)
     UnwindLogMsgVerbose(
         "frame uses %s for full UnwindPlan because we are falling back "
         "to the arch default plan",
-        arch_default_unwind_plan_sp->GetSourceName().GetCString());
+        arch_default_unwind_plan_sp->GetSourceName().c_str());
   else
     UnwindLogMsg(
         "Unable to find any UnwindPlan for full unwind of this frame.");
 
   return arch_default_unwind_plan_sp;
 }
 
 void RegisterContextUnwind::InvalidateAllRegisters() {
if (m_full_unwind_plan_sp) {
 
       if (got_new_full_unwindplan && active_row.get() && log) {
         StreamString active_row_strm;
         ExecutionContext exe_ctx(m_thread.shared_from_this());
         active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
                          &m_thread,
                          m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
         UnwindLogMsg("Using full unwind plan '%s'",
-                     m_full_unwind_plan_sp->GetSourceName().AsCString());
+                     m_full_unwind_plan_sp->GetSourceName().c_str());
         UnwindLogMsg("active row: %s", active_row_strm.GetData());
       }
       RegisterNumber return_address_reg;
 
       // If we're fetching the saved pc and this UnwindPlan defines a
       // ReturnAddress register (e.g. lr on arm), look for the return address
       // register number in the UnwindPlan's row.
       if (pc_regnum.IsValid() && pc_regnum == regnum &&
if (m_full_unwind_plan_sp) {
 
       if (regnum.IsValid() &&
           active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
                                       unwindplan_regloc)) {
         have_unwindplan_regloc = true;
         UnwindLogMsg(
             "supplying caller's saved %s (%d)'s location using %s UnwindPlan",
             regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
-            m_full_unwind_plan_sp->GetSourceName().GetCString());
+            m_full_unwind_plan_sp->GetSourceName().c_str());
       }
 
       // This is frame 0 and we're retrieving the PC and it's saved in a Return
       // Address register and it hasn't been saved anywhere yet -- that is,
       // it's still live in the actual register. Handle this specially.
 
       if (!have_unwindplan_regloc && return_address_reg.IsValid() &&
           IsFrameZero()) {
if (m_full_unwind_plan_sp) {
               LLDB_INVALID_REGNUM &&
           pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() &&
           unwindplan_regloc.GetRegisterNumber() ==
               arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) &&
           m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
           !m_all_registers_available) {
         UnwindLogMsg("%s UnwindPlan tried to restore the pc from the link "
                      "register but this is a non-zero frame",
-                     m_full_unwind_plan_sp->GetSourceName().GetCString());
+                     m_full_unwind_plan_sp->GetSourceName().c_str());
 
         // Throw away the full unwindplan; install the arch default unwindplan
         if (ForceSwitchToFallbackUnwindPlan()) {
           // Update for the possibly new unwind plan
           unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
           UnwindPlan::RowSP active_row =
               m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 
if (IsFrameZero()) {
       m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
       regloc = new_regloc;
       UnwindLogMsg("supplying caller's register %s (%d) from the live "
                    "RegisterContext at frame 0",
                    regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
       return UnwindLLDB::RegisterSearchResult::eRegisterFound;
     } else {
       std::string unwindplan_name;
-      if (m_full_unwind_plan_sp) {
-        unwindplan_name += "via '";
-        unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
-        unwindplan_name += "'";
-      }
+      if (m_full_unwind_plan_sp)
+        unwindplan_name +=
+            "via '" + m_full_unwind_plan_sp->GetSourceName() + "'";
       UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(),
                    regnum.GetAsKind(eRegisterKindLLDB),
                    unwindplan_name.c_str());
     }
     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
   }
 
   // unwindplan_regloc has valid contents about where to retrieve the register
if (old_caller_pc_value == new_caller_pc_value &&
                    "CFA and caller frame pc, not using");
       m_fallback_unwind_plan_sp.reset();
       m_full_unwind_plan_sp = original_full_unwind_plan_sp;
       return false;
     }
 
     UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' "
                  "because UnwindPlan '%s' failed.",
-                 m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
-                 original_full_unwind_plan_sp->GetSourceName().GetCString());
+                 m_fallback_unwind_plan_sp->GetSourceName().c_str(),
+                 original_full_unwind_plan_sp->GetSourceName().c_str());
 
     // We've copied the fallback unwind plan into the full - now clear the
     // fallback.
     m_fallback_unwind_plan_sp.reset();
     PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
   }
 
   return true;
if (active_row &&
 
     m_registers.clear();
 
     m_cfa = new_cfa;
 
     PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
 
     UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
-                 m_full_unwind_plan_sp->GetSourceName().GetCString());
+                 m_full_unwind_plan_sp->GetSourceName().c_str());
     return true;
   }
   return false;
 }
 
 void RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan(
     lldb::UnwindPlanSP unwind_plan) {
   if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {