[lldb] Guarantee the lifetimes of all strings returned from SBAPI

[bulbazord]

Summary

LLDB should guarantee that the strings returned by SBAPI methods
live forever. I went through every method that returns a string and made
sure that it was added to the ConstString StringPool before returning if
it wasn't obvious that it was already doing so.
I've also updated the docs to document this behavior.

[mib]

LGTM with nit.

lldb/source/API/SBFunction.cpp

181

nit: This threw me off, I thought you forgot to create a ConsString but it seems that ConstString has both a AsCString and a GetCString method. It would be good to stay consistent.

[bulbazord]

lldb/source/API/SBFunction.cpp

181

Yeah, maybe we should try to remove either GetCString or AsCString and be uniform everywhere. Let's plan on doing that later though.

[bulbazord]

Update SBModule::GetUUIDString -- I slightly changed behavior. Now the behavior matches the previous implementation exactly.

lldb/docs/design/sbapi.rst

 
 In this case, ``GetResourceCPPOnly`` will not be generated for Python or other
 scripting languages. If you wanted to add a resource specifically only for the
 SWIG case, you can invert the condition and use ``#ifdef SWIG`` instead. When
 building the LLDB framework for macOS, the headers are processed with
 ``unifdef`` prior to being copied into the framework bundle to remove macros
 involving SWIG.
 
+Lifetime
+--------
+Many SB API methods will return strings in the form of ``const char *`` values.
+Once created, these strings are guaranteed to live until the end of the
+debugging session. LLDB owns these strings, clients should not attempt to free
+them. Doing so may cause LLDB to crash.
+Note that this only affects the C++ API as scripting languages usually
+will usually create native string types from the ``const char *`` value.
+
 API Instrumentation
 -------------------
 
 The reproducer infrastructure requires API methods to be instrumented so that
 they can be captured and replayed. Instrumentation consists of two macros,
 ``LLDB_REGISTER`` and ``LLDB_RECORD``. Both can be automatically generated with
 the ``lldb-instr`` utility.
 

lldb/source/API/SBAttachInfo.cpp

void SBAttachInfo::SetResumeCount(uint32_t c) {
   LLDB_INSTRUMENT_VA(this, c);
 
   m_opaque_sp->SetResumeCount(c);
 }
 
 const char *SBAttachInfo::GetProcessPluginName() {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_sp->GetProcessPluginName();
+  return ConstString(m_opaque_sp->GetProcessPluginName()).GetCString();
 }
 
 void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
   LLDB_INSTRUMENT_VA(this, plugin_name);
 
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 

lldb/source/API/SBBreakpoint.cpp

if (bkpt_sp) {
     bkpt_sp->SetCondition(condition);
   }
 }
 
 const char *SBBreakpoint::GetCondition() {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
-  if (bkpt_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        bkpt_sp->GetTarget().GetAPIMutex());
-    return bkpt_sp->GetConditionText();
-  }
-  return nullptr;
+  if (!bkpt_sp)
+    return nullptr;
+
+  return ConstString(bkpt_sp->GetConditionText()).GetCString();
 }
 
 void SBBreakpoint::SetAutoContinue(bool auto_continue) {
   LLDB_INSTRUMENT_VA(this, auto_continue);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions().GetThreadSpec()->SetName(thread_name);
   }
 }
 
 const char *SBBreakpoint::GetThreadName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
-  if (bkpt_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        bkpt_sp->GetTarget().GetAPIMutex());
-    const ThreadSpec *thread_spec =
-        bkpt_sp->GetOptions().GetThreadSpecNoCreate();
-    if (thread_spec != nullptr)
-      name = thread_spec->GetName();
-  }
+  if (!bkpt_sp)
+    return nullptr;
+
+  if (const ThreadSpec *thread_spec =
+          bkpt_sp->GetOptions().GetThreadSpecNoCreate())
+    return ConstString(thread_spec->GetName()).GetCString();
 
-  return name;
+  return nullptr;
 }
 
 void SBBreakpoint::SetQueueName(const char *queue_name) {
   LLDB_INSTRUMENT_VA(this, queue_name);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
   }
 }
 
 const char *SBBreakpoint::GetQueueName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
-  if (bkpt_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        bkpt_sp->GetTarget().GetAPIMutex());
-    const ThreadSpec *thread_spec =
-        bkpt_sp->GetOptions().GetThreadSpecNoCreate();
-    if (thread_spec)
-      name = thread_spec->GetQueueName();
-  }
+  if (!bkpt_sp)
+    return nullptr;
+
+  if (const ThreadSpec *thread_spec =
+          bkpt_sp->GetOptions().GetThreadSpecNoCreate())
+    return ConstString(thread_spec->GetQueueName()).GetCString();
 
-  return name;
+  return nullptr;
 }
 
 size_t SBBreakpoint::GetNumResolvedLocations() const {
   LLDB_INSTRUMENT_VA(this);
 
   size_t num_resolved = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

lldb/source/API/SBBreakpointLocation.cpp

if (loc_sp) {
     loc_sp->SetCondition(condition);
   }
 }
 
 const char *SBBreakpointLocation::GetCondition() {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
-  if (loc_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        loc_sp->GetTarget().GetAPIMutex());
-    return loc_sp->GetConditionText();
-  }
-  return nullptr;
+  if (!loc_sp)
+    return nullptr;
+
+  return ConstString(loc_sp->GetConditionText()).GetCString();
 }
 
 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
   LLDB_INSTRUMENT_VA(this, auto_continue);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
if (loc_sp) {
     loc_sp->SetThreadName(thread_name);
   }
 }
 
 const char *SBBreakpointLocation::GetThreadName() const {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
-  if (loc_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        loc_sp->GetTarget().GetAPIMutex());
-    return loc_sp->GetThreadName();
-  }
-  return nullptr;
+  if (!loc_sp)
+    return nullptr;
+
+  return ConstString(loc_sp->GetThreadName()).GetCString();
 }
 
 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
   LLDB_INSTRUMENT_VA(this, queue_name);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetQueueName(queue_name);
   }
 }
 
 const char *SBBreakpointLocation::GetQueueName() const {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
-  if (loc_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        loc_sp->GetTarget().GetAPIMutex());
-    return loc_sp->GetQueueName();
-  }
-  return nullptr;
+  if (!loc_sp)
+    return nullptr;
+
+  return ConstString(loc_sp->GetQueueName()).GetCString();
 }
 
 bool SBBreakpointLocation::IsResolved() {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

lldb/source/API/SBBreakpointName.cpp

SBBreakpointName::operator bool() const {
   return m_impl_up->IsValid();
 }
 
 const char *SBBreakpointName::GetName() const {
   LLDB_INSTRUMENT_VA(this);
 
   if (!m_impl_up)
     return "<Invalid Breakpoint Name Object>";
-  return m_impl_up->GetName();
+  return ConstString(m_impl_up->GetName()).GetCString();
 }
 
 void SBBreakpointName::SetEnabled(bool enable) {
   LLDB_INSTRUMENT_VA(this, enable);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;

 const char *SBBreakpointName::GetCondition() {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return nullptr;
 
   std::lock_guard<std::recursive_mutex> guard(
-        m_impl_up->GetTarget()->GetAPIMutex());
 
-  return bp_name->GetOptions().GetConditionText();
+  return ConstString(bp_name->GetOptions().GetConditionText()).GetCString();
 }
 
 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
   LLDB_INSTRUMENT_VA(this, auto_continue);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;

 const char *SBBreakpointName::GetThreadName() const {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return nullptr;
 
   std::lock_guard<std::recursive_mutex> guard(
-        m_impl_up->GetTarget()->GetAPIMutex());
 
-  return bp_name->GetOptions().GetThreadSpec()->GetName();
+  return ConstString(bp_name->GetOptions().GetThreadSpec()->GetName())
+      .GetCString();
 }
 
 void SBBreakpointName::SetQueueName(const char *queue_name) {
   LLDB_INSTRUMENT_VA(this, queue_name);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
   UpdateName(*bp_name);
 }
 
 const char *SBBreakpointName::GetQueueName() const {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return nullptr;
 
   std::lock_guard<std::recursive_mutex> guard(
-        m_impl_up->GetTarget()->GetAPIMutex());
 
-  return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
+  return ConstString(bp_name->GetOptions().GetThreadSpec()->GetQueueName())
+      .GetCString();
 }
 
 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
   LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;

 
 const char *SBBreakpointName::GetHelpString() const {
   LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return "";
 
-  return bp_name->GetHelp();
+  return ConstString(bp_name->GetHelp()).GetCString();
 }
 
 void SBBreakpointName::SetHelpString(const char *help_string) {
   LLDB_INSTRUMENT_VA(this, help_string);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;

lldb/source/API/SBCommandInterpreter.cpp

const char *SBCommandInterpreter::GetBroadcasterClass() {
 
   return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBCommandInterpreter::GetArgumentTypeAsCString(
     const lldb::CommandArgumentType arg_type) {
   LLDB_INSTRUMENT_VA(arg_type);
 
-  return CommandObject::GetArgumentTypeAsCString(arg_type);
+  return ConstString(CommandObject::GetArgumentTypeAsCString(arg_type))
+      .GetCString();
 }
 
 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
     const lldb::CommandArgumentType arg_type) {
   LLDB_INSTRUMENT_VA(arg_type);
 
-  return CommandObject::GetArgumentDescriptionAsCString(arg_type);
+  return ConstString(CommandObject::GetArgumentDescriptionAsCString(arg_type))
+      .GetCString();
 }
 
 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
     const lldb::SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
   return event.GetBroadcasterClass() ==
          SBCommandInterpreter::GetBroadcasterClass();

lldb/source/API/SBData.cpp

if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   return value;
 }
 
 const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
   LLDB_INSTRUMENT_VA(this, error, offset);
 
-  const char *value = nullptr;
-  if (!m_opaque_sp.get()) {
+  if (!m_opaque_sp) {
     error.SetErrorString("no value to read from");
-  } else {
-    uint32_t old_offset = offset;
-    value = m_opaque_sp->GetCStr(&offset);
-    if (offset == old_offset || (value == nullptr))
-      error.SetErrorString("unable to read data");
+    return nullptr;
+  }
+
+  lldb::offset_t old_offset = offset;
+  const char *value = m_opaque_sp->GetCStr(&offset);
+  if (offset == old_offset || value == nullptr) {
+    return nullptr;
   }
-  return value;
+
+  return ConstString(value).GetCString();
 }
 
 bool SBData::GetDescription(lldb::SBStream &description,
                             lldb::addr_t base_addr) {
   LLDB_INSTRUMENT_VA(this, description, base_addr);
 
   Stream &strm = description.ref();
 

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().data();
+      return ConstString(lldb_event->GetData()->GetFlavor()).GetCString();
   }
   return nullptr;
 }
 
 uint32_t SBEvent::GetType() const {
   LLDB_INSTRUMENT_VA(this);
 
   const Event *lldb_event = get();
SBEvent::operator bool() const {
   // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
   // See comments in SBEvent::get()....
   return SBEvent::get() != nullptr;
 }
 
 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
-  return static_cast<const char *>(
-      EventDataBytes::GetBytesFromEvent(event.get()));
+  return ConstString(static_cast<const char *>(
+                         EventDataBytes::GetBytesFromEvent(event.get())))
+      .GetCString();
 }
 
 bool SBEvent::GetDescription(SBStream &description) {
   LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
   if (get()) {

lldb/source/API/SBExpressionOptions.cpp

void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
   LLDB_INSTRUMENT_VA(this, b);
 
   return m_opaque_up->SetSuppressPersistentResult(b);
 }
 
 const char *SBExpressionOptions::GetPrefix() const {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_up->GetPrefix();
+  return ConstString(m_opaque_up->GetPrefix()).GetCString();
 }
 
 void SBExpressionOptions::SetPrefix(const char *prefix) {
   LLDB_INSTRUMENT_VA(this, prefix);
 
   return m_opaque_up->SetPrefix(prefix);
 }
 

lldb/source/API/SBFrame.cpp

SBThread SBFrame::GetThread() const {
   SBThread sb_thread(thread_sp);
 
   return sb_thread;
 }
 
 const char *SBFrame::Disassemble() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *disassembly = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
-
-  StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
-  if (target && process) {
-    Process::StopLocker stop_locker;
-    if (stop_locker.TryLock(&process->GetRunLock())) {
-      frame = exe_ctx.GetFramePtr();
-      if (frame) {
-        disassembly = frame->Disassemble();
-      }
-    }
+  if (!target || !process)
+    return nullptr;
+
+    if (auto *frame = exe_ctx.GetFramePtr())
+      return ConstString(frame->Disassemble()).GetCString();
   }
 
-  return disassembly;
+  return nullptr;
 }
 
 SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
                                   bool in_scope_only) {
   LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only);
 
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;

lldb/source/API/SBFunction.cpp

SBFunction::operator bool() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 const char *SBFunction::GetName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   if (m_opaque_ptr)
-    cstr = m_opaque_ptr->GetName().AsCString();
+    return m_opaque_ptr->GetName().AsCString();
 
-  return cstr;
+  return nullptr;
 }
 
 const char *SBFunction::GetDisplayName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   if (m_opaque_ptr)
-    cstr = m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString();
+    return m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString();
 
-  return cstr;
+  return nullptr;
 }
 
 const char *SBFunction::GetMangledName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   if (m_opaque_ptr)
-    cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
-  return cstr;
+    return m_opaque_ptr->GetMangled().GetMangledName().AsCString();
+  return nullptr;
 }
 
 bool SBFunction::operator==(const SBFunction &rhs) const {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr == rhs.m_opaque_ptr;
 }
 
if (m_opaque_ptr) {
     }
   }
   return addr;
 }
 
 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
   LLDB_INSTRUMENT_VA(this, arg_idx);
 
-  if (m_opaque_ptr) {
-    Block &block = m_opaque_ptr->GetBlock(true);
-    VariableListSP variable_list_sp = block.GetBlockVariableList(true);
-    if (variable_list_sp) {
-      VariableList arguments;
-      variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
-                                                 arguments, true);
-      lldb::VariableSP variable_sp = arguments.GetVariableAtIndex(arg_idx);
-      if (variable_sp)
-        return variable_sp->GetName().GetCString();
-    }
-  }
+  if (!m_opaque_ptr)
+    return nullptr;
+
+  if (!variable_list_sp)
+    return nullptr;
+
+  if (!variable_sp)
     return nullptr;
+
+  return variable_sp->GetName().GetCString();
 }
 
 uint32_t SBFunction::GetPrologueByteSize() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetPrologueByteSize();
   return 0;

lldb/source/API/SBInstruction.cpp

if (inst_sp && inst_sp->GetAddress().IsValid())
     sb_addr.SetAddress(inst_sp->GetAddress());
   return sb_addr;
 }
 
 const char *SBInstruction::GetMnemonic(SBTarget target) {
   LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
-  if (inst_sp) {
-    ExecutionContext exe_ctx;
-    TargetSP target_sp(target.GetSP());
-    std::unique_lock<std::recursive_mutex> lock;
-    if (target_sp) {
-      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+  if (!inst_sp)
+    return nullptr;
+
 
-      target_sp->CalculateExecutionContext(exe_ctx);
-      exe_ctx.SetProcessSP(target_sp->GetProcessSP());
-    }
-    return inst_sp->GetMnemonic(&exe_ctx);
-  }
-  return nullptr;
+  return ConstString(inst_sp->GetMnemonic(&exe_ctx)).GetCString();
 }
 
 const char *SBInstruction::GetOperands(SBTarget target) {
   LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
-  if (inst_sp) {
-    ExecutionContext exe_ctx;
-    TargetSP target_sp(target.GetSP());
-    std::unique_lock<std::recursive_mutex> lock;
-    if (target_sp) {
-      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+  if (!inst_sp)
+    return nullptr;
+
 
-      target_sp->CalculateExecutionContext(exe_ctx);
-      exe_ctx.SetProcessSP(target_sp->GetProcessSP());
-    }
-    return inst_sp->GetOperands(&exe_ctx);
-  }
-  return nullptr;
+  return ConstString(inst_sp->GetOperands(&exe_ctx)).GetCString();
 }
 
 const char *SBInstruction::GetComment(SBTarget target) {
   LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
-  if (inst_sp) {
-    ExecutionContext exe_ctx;
-    TargetSP target_sp(target.GetSP());
-    std::unique_lock<std::recursive_mutex> lock;
-    if (target_sp) {
-      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+  if (!inst_sp)
+    return nullptr;
+
 
-      target_sp->CalculateExecutionContext(exe_ctx);
-      exe_ctx.SetProcessSP(target_sp->GetProcessSP());
-    }
-    return inst_sp->GetComment(&exe_ctx);
-  }
-  return nullptr;
+  return ConstString(inst_sp->GetComment(&exe_ctx)).GetCString();
 }
 
 lldb::InstructionControlFlowKind SBInstruction::GetControlFlowKind(lldb::SBTarget target) {
   LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     ExecutionContext exe_ctx;

lldb/source/API/SBLaunchInfo.cpp

uint32_t SBLaunchInfo::GetNumArguments() {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetArguments().GetArgumentCount();
 }
 
 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
-  return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
+  return ConstString(m_opaque_sp->GetArguments().GetArgumentAtIndex(idx))
+      .GetCString();
 }
 
 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
   LLDB_INSTRUMENT_VA(this, argv, append);
 
   if (append) {
     if (argv)
       m_opaque_sp->GetArguments().AppendArguments(argv);
uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
   return m_opaque_sp->GetEnvironment().size();
 }
 
 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   if (idx > GetNumEnvironmentEntries())
     return nullptr;
-  return m_opaque_sp->GetEnvp()[idx];
+  return ConstString(m_opaque_sp->GetEnvp()[idx]).GetCString();
 }
 
 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
   LLDB_INSTRUMENT_VA(this, envp, append);
   SetEnvironment(SBEnvironment(Environment(envp)), append);
 }
 
 void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
   LLDB_INSTRUMENT_VA(this, flags);
 
   m_opaque_sp->GetFlags().Reset(flags);
 }
 
 const char *SBLaunchInfo::GetProcessPluginName() {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_sp->GetProcessPluginName();
+  return ConstString(m_opaque_sp->GetProcessPluginName()).GetCString();
 }
 
 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
   LLDB_INSTRUMENT_VA(this, plugin_name);
 
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 
void SBLaunchInfo::SetLaunchEventData(const char *data) {
   LLDB_INSTRUMENT_VA(this, data);
 
   m_opaque_sp->SetLaunchEventData(data);
 }
 
 const char *SBLaunchInfo::GetLaunchEventData() const {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_sp->GetLaunchEventData();
+  return ConstString(m_opaque_sp->GetLaunchEventData()).GetCString();
 }
 
 void SBLaunchInfo::SetDetachOnError(bool enable) {
   LLDB_INSTRUMENT_VA(this, enable);
 
   m_opaque_sp->SetDetachOnError(enable);
 }
 

lldb/source/API/SBModule.cpp

if (module_sp)
     uuid_bytes = module_sp->GetUUID().GetBytes().data();
 
   return uuid_bytes;
 }
 
 const char *SBModule::GetUUIDString() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *uuid_cstr = nullptr;
   ModuleSP module_sp(GetSP());
-  if (module_sp) {
-    // We are going to return a "const char *" value through the public API, so
-    // we need to constify it so it gets added permanently the string pool and
-    // then we don't need to worry about the lifetime of the string as it will
-    // never go away once it has been put into the ConstString string pool
-    uuid_cstr = ConstString(module_sp->GetUUID().GetAsString()).GetCString();
-  }
-
-  if (uuid_cstr && uuid_cstr[0]) {
+  if (!module_sp)
+    return nullptr;
+
+  const char *uuid_cstr =
+      ConstString(module_sp->GetUUID().GetAsString()).GetCString();
+  // Note: SBModule::GetUUIDString's expected behavior is to return nullptr if
+  // the string we get is empty, so we must perform this check before returning.
+  if (uuid_cstr && uuid_cstr[0])
     return uuid_cstr;
-  }
-
   return nullptr;
 }
 
 bool SBModule::operator==(const SBModule &rhs) const {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   if (m_opaque_sp)
     return m_opaque_sp.get() == rhs.m_opaque_sp.get();
if (module_sp)
     return module_sp->GetArchitecture().GetByteOrder();
   return eByteOrderInvalid;
 }
 
 const char *SBModule::GetTriple() {
   LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
-  if (module_sp) {
-    std::string triple(module_sp->GetArchitecture().GetTriple().str());
-    // Unique the string so we don't run into ownership issues since the const
-    // strings put the string into the string pool once and the strings never
-    // comes out
-    ConstString const_triple(triple.c_str());
-    return const_triple.GetCString();
-  }
-  return nullptr;
-}
+  if (!module_sp)
+    return nullptr;
+
 
 uint32_t SBModule::GetAddressByteSize() {
   LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (module_sp)
     return module_sp->GetArchitecture().GetAddressByteSize();
   return sizeof(void *);

lldb/source/API/SBPlatform.cpp

SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
   return *this;
 }
 
 const char *SBPlatformConnectOptions::GetURL() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_url.empty())
     return nullptr;
-  return m_opaque_ptr->m_url.c_str();
+  return ConstString(m_opaque_ptr->m_url.c_str()).GetCString();
 }
 
 void SBPlatformConnectOptions::SetURL(const char *url) {
   LLDB_INSTRUMENT_VA(this, url);
 
   if (url && url[0])
     m_opaque_ptr->m_url = url;
   else
void SBPlatformShellCommand::Clear() {
   m_opaque_ptr->m_signo = 0;
 }
 
 const char *SBPlatformShellCommand::GetShell() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_shell.empty())
     return nullptr;
-  return m_opaque_ptr->m_shell.c_str();
+  return ConstString(m_opaque_ptr->m_shell.c_str()).GetCString();
 }
 
 void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
   LLDB_INSTRUMENT_VA(this, shell_interpreter);
 
   if (shell_interpreter && shell_interpreter[0])
     m_opaque_ptr->m_shell = shell_interpreter;
   else
     m_opaque_ptr->m_shell.clear();
 }
 
 const char *SBPlatformShellCommand::GetCommand() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_command.empty())
     return nullptr;
-  return m_opaque_ptr->m_command.c_str();
+  return ConstString(m_opaque_ptr->m_command.c_str()).GetCString();
 }
 
 void SBPlatformShellCommand::SetCommand(const char *shell_command) {
   LLDB_INSTRUMENT_VA(this, shell_command);
 
   if (shell_command && shell_command[0])
     m_opaque_ptr->m_command = shell_command;
   else
     m_opaque_ptr->m_command.clear();
 }
 
 const char *SBPlatformShellCommand::GetWorkingDirectory() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_working_dir.empty())
     return nullptr;
-  return m_opaque_ptr->m_working_dir.c_str();
+  return ConstString(m_opaque_ptr->m_working_dir.c_str()).GetCString();
 }
 
 void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
   LLDB_INSTRUMENT_VA(this, path);
 
   if (path && path[0])
     m_opaque_ptr->m_working_dir = path;
   else
int SBPlatformShellCommand::GetStatus() {
   return m_opaque_ptr->m_status;
 }
 
 const char *SBPlatformShellCommand::GetOutput() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_output.empty())
     return nullptr;
-  return m_opaque_ptr->m_output.c_str();
+  return ConstString(m_opaque_ptr->m_output.c_str()).GetCString();
 }
 
 // SBPlatform
 SBPlatform::SBPlatform() { LLDB_INSTRUMENT_VA(this); }
 
 SBPlatform::SBPlatform(const char *platform_name) {
   LLDB_INSTRUMENT_VA(this, platform_name);
 
const char *SBPlatform::GetOSDescription() {
   return nullptr;
 }
 
 const char *SBPlatform::GetHostname() {
   LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
-    return platform_sp->GetHostname();
+    return ConstString(platform_sp->GetHostname()).GetCString();
   return nullptr;
 }
 
 uint32_t SBPlatform::GetOSMajorVersion() {
   LLDB_INSTRUMENT_VA(this);
 
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())

lldb/source/API/SBProcess.cpp

int SBProcess::GetExitStatus() {
   }
 
   return exit_status;
 }
 
 const char *SBProcess::GetExitDescription() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *exit_desc = nullptr;
   ProcessSP process_sp(GetSP());
-  if (process_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        process_sp->GetTarget().GetAPIMutex());
-    exit_desc = process_sp->GetExitDescription();
-  }
-  return exit_desc;
+  if (!process_sp)
+    return nullptr;
+
+  return ConstString(process_sp->GetExitDescription()).GetCString();
 }
 
 lldb::pid_t SBProcess::GetProcessID() {
   LLDB_INSTRUMENT_VA(this);
 
   lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
   ProcessSP process_sp(GetSP());
   if (process_sp)
size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
   return Process::ProcessEventData::GetNumRestartedReasons(event.get());
 }
 
 const char *
 SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
                                               size_t idx) {
   LLDB_INSTRUMENT_VA(event, idx);
 
-  return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
+  return ConstString(Process::ProcessEventData::GetRestartedReasonAtIndex(
+                         event.get(), idx))
+      .GetCString();
 }
 
 SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
   ProcessSP process_sp =
       Process::ProcessEventData::GetProcessFromEvent(event.get());
   if (!process_sp) {

lldb/source/API/SBProcessInfo.cpp

SBProcessInfo::operator bool() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr;
 }
 
 const char *SBProcessInfo::GetName() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
-  if (m_opaque_up) {
-    name = m_opaque_up->GetName();
-  }
-  return name;
+  if (!m_opaque_up)
+    return nullptr;
+
+  return ConstString(m_opaque_up->GetName()).GetCString();
 }
 
 SBFileSpec SBProcessInfo::GetExecutableFile() {
   LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec file_spec;
   if (m_opaque_up) {
     file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
if (m_opaque_up) {
     proc_id = m_opaque_up->GetParentProcessID();
   }
   return proc_id;
 }
 
 const char *SBProcessInfo::GetTriple() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *triple = nullptr;
-  if (m_opaque_up) {
-    const auto &arch = m_opaque_up->GetArchitecture();
-    if (arch.IsValid()) {
-      // Const-ify the string so we don't need to worry about the lifetime of
-      // the string
-      triple = ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
-    }
-  }
-  return triple;
+  if (!m_opaque_up)
+    return nullptr;
+
+  if (!arch.IsValid())
+    return nullptr;
+
+  return ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
 }

lldb/source/API/SBQueue.cpp

uint32_t GetIndexID() const {
     lldb::QueueSP queue_sp = m_queue_wp.lock();
     if (queue_sp) {
       result = queue_sp->GetIndexID();
     }
     return result;
   }
 
   const char *GetName() const {
-    const char *name = nullptr;
     lldb::QueueSP queue_sp = m_queue_wp.lock();
-    if (queue_sp.get()) {
-      name = queue_sp->GetName();
-    }
-    return name;
+    if (!queue_sp)
+      return nullptr;
+    return ConstString(queue_sp->GetName()).GetCString();
   }
 
   void FetchThreads() {
     if (!m_thread_list_fetched) {
       lldb::QueueSP queue_sp = m_queue_wp.lock();
       if (queue_sp) {
         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {

lldb/source/API/SBStream.cpp

 // If this stream is not redirected to a file, it will maintain a local cache
 // for the stream data which can be accessed using this accessor.
 const char *SBStream::GetData() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_is_file || m_opaque_up == nullptr)
     return nullptr;
 
-  return static_cast<StreamString *>(m_opaque_up.get())->GetData();
+  return ConstString(static_cast<StreamString *>(m_opaque_up.get())->GetData())
+      .GetCString();
 }
 
 // If this stream is not redirected to a file, it will maintain a local cache
 // for the stream output whose length can be accessed using this accessor.
 size_t SBStream::GetSize() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_is_file || m_opaque_up == nullptr)

lldb/source/API/SBStringList.cpp

uint32_t SBStringList::GetSize() const {
   }
   return 0;
 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid()) {
-    return m_opaque_up->GetStringAtIndex(idx);
+    return ConstString(m_opaque_up->GetStringAtIndex(idx)).GetCString();
   }
   return nullptr;
 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) const {
   LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid()) {
-    return m_opaque_up->GetStringAtIndex(idx);
+    return ConstString(m_opaque_up->GetStringAtIndex(idx)).GetCString();
   }
   return nullptr;
 }
 
 void SBStringList::Clear() {
   LLDB_INSTRUMENT_VA(this);
 
   if (IsValid()) {
     m_opaque_up->Clear();
   }
 }

lldb/source/API/SBTarget.cpp

if (target_sp)
     return target_sp->GetArchitecture().GetByteOrder();
   return eByteOrderInvalid;
 }
 
 const char *SBTarget::GetTriple() {
   LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
-  if (target_sp) {
-    std::string triple(target_sp->GetArchitecture().GetTriple().str());
-    // Unique the string so we don't run into ownership issues since the const
-    // strings put the string into the string pool once and the strings never
-    // comes out
-    ConstString const_triple(triple.c_str());
-    return const_triple.GetCString();
-  }
-  return nullptr;
-}
+  if (!target_sp)
+    return nullptr;
+
 
 const char *SBTarget::GetABIName() {
   LLDB_INSTRUMENT_VA(this);
   
   TargetSP target_sp(GetSP());
-  if (target_sp) {
-    std::string abi_name(target_sp->GetABIName().str());
-    ConstString const_name(abi_name.c_str());
-    return const_name.GetCString();
-  }
-  return nullptr;
-}
+  if (!target_sp)
+    return nullptr;
+
 
 uint32_t SBTarget::GetDataByteSize() {
   LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     return target_sp->GetArchitecture().GetDataByteSize();
   }

lldb/source/API/SBThread.cpp

uint32_t SBThread::GetIndexID() const {
   if (thread_sp)
     return thread_sp->GetIndexID();
   return LLDB_INVALID_INDEX32;
 }
 
 const char *SBThread::GetName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (exe_ctx.HasThreadScope()) {
-    Process::StopLocker stop_locker;
-    if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
-      name = exe_ctx.GetThreadPtr()->GetName();
-    }
-  }
+  if (!exe_ctx.HasThreadScope())
+    return nullptr;
+
+  if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
+    return ConstString(exe_ctx.GetThreadPtr()->GetName()).GetCString();
 
-  return name;
+  return nullptr;
 }
 
 const char *SBThread::GetQueueName() const {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (exe_ctx.HasThreadScope()) {
-    Process::StopLocker stop_locker;
-    if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
-      name = exe_ctx.GetThreadPtr()->GetQueueName();
-    }
-  }
+  if (!exe_ctx.HasThreadScope())
+    return nullptr;
+
+  if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
+    return ConstString(exe_ctx.GetThreadPtr()->GetQueueName()).GetCString();
 
-  return name;
+  return nullptr;
 }
 
 lldb::queue_id_t SBThread::GetQueueID() const {
   LLDB_INSTRUMENT_VA(this);
 
   queue_id_t id = LLDB_INVALID_QUEUE_ID;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

lldb/source/API/SBTrace.cpp

SBFileSpec SBTrace::SaveToDisk(SBError &error, const SBFileSpec &bundle_dir,
   else
     error.SetErrorString(llvm::toString(desc_file.takeError()).c_str());
 
   return file_spec;
 }
 
 const char *SBTrace::GetStartConfigurationHelp() {
   LLDB_INSTRUMENT_VA(this);
-  return m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr;
+  if (!m_opaque_sp)
+    return nullptr;
+
+  return ConstString(m_opaque_sp->GetStartConfigurationHelp()).GetCString();
 }
 
 SBError SBTrace::Start(const SBStructuredData &configuration) {
   LLDB_INSTRUMENT_VA(this, configuration);
   SBError error;
   if (!m_opaque_sp)
     error.SetErrorString("error: invalid trace");
   else if (llvm::Error err =

lldb/source/API/SBTraceCursor.cpp

bool SBTraceCursor::IsError() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->IsError();
 }
 
 const char *SBTraceCursor::GetError() const {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_sp->GetError();
+  return ConstString(m_opaque_sp->GetError()).GetCString();
 }
 
 bool SBTraceCursor::IsEvent() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->IsEvent();
 }
 
 lldb::TraceEvent SBTraceCursor::GetEventType() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetEventType();
 }
 
 const char *SBTraceCursor::GetEventTypeAsString() const {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_sp->GetEventTypeAsString();
+  return ConstString(m_opaque_sp->GetEventTypeAsString()).GetCString();
 }
 
 bool SBTraceCursor::IsInstruction() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->IsInstruction();
 }
 

lldb/source/API/SBType.cpp

const char *SBTypeMemberFunction::GetName() {
   if (m_opaque_sp)
     return m_opaque_sp->GetName().GetCString();
   return nullptr;
 }
 
 const char *SBTypeMemberFunction::GetDemangledName() {
   LLDB_INSTRUMENT_VA(this);
 
-  if (m_opaque_sp) {
-    ConstString mangled_str = m_opaque_sp->GetMangledName();
-    if (mangled_str) {
-      Mangled mangled(mangled_str);
-      return mangled.GetDemangledName().GetCString();
-    }
-  }
-  return nullptr;
-}
+  if (!m_opaque_sp)
+    return nullptr;
+
+  if (!mangled_str)
+    return nullptr;
+
 
 const char *SBTypeMemberFunction::GetMangledName() {
   LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetMangledName().GetCString();
   return nullptr;
 }

lldb/source/API/SBTypeCategory.cpp

else
     DataVisualization::Categories::Disable(m_opaque_sp);
 }
 
 const char *SBTypeCategory::GetName() {
   LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
-  return m_opaque_sp->GetName();
+  return ConstString(m_opaque_sp->GetName()).GetCString();
 }
 
 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid())
     return m_opaque_sp->GetLanguageAtIndex(idx);
   return lldb::eLanguageTypeUnknown;

lldb/source/API/SBTypeFilter.cpp

uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
   if (IsValid())
     return m_opaque_sp->GetCount();
   return 0;
 }
 
 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
   LLDB_INSTRUMENT_VA(this, i);
 
-  if (IsValid()) {
-    const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
-    if (item && *item == '.')
-      item++;
-    return item;
-  }
-  return nullptr;
+  if (!IsValid())
+    return nullptr;
+
+  return ConstString(item).GetCString();
 }
 
 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
   LLDB_INSTRUMENT_VA(this, i, item);
 
   if (CopyOnWrite_Impl())
     return m_opaque_sp->SetExpressionPathAtIndex(i, item);
   else

lldb/source/API/SBTypeNameSpecifier.cpp

 }
 
 const char *SBTypeNameSpecifier::GetName() {
   LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
 
-  return m_opaque_sp->GetName();
+  return ConstString(m_opaque_sp->GetName()).GetCString();
 }
 
 SBType SBTypeNameSpecifier::GetType() {
   LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return SBType();
   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();

lldb/source/API/SBTypeSummary.cpp

const char *SBTypeSummary::GetData() {
 
   if (!IsValid())
     return nullptr;
   if (ScriptSummaryFormat *script_summary_ptr =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
     const char *fname = script_summary_ptr->GetFunctionName();
     const char *ftext = script_summary_ptr->GetPythonScript();
     if (ftext && *ftext)
-      return ftext;
-    return fname;
+      return ConstString(ftext).GetCString();
+    return ConstString(fname).GetCString();
   } else if (StringSummaryFormat *string_summary_ptr =
                  llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get()))
-    return string_summary_ptr->GetSummaryString();
+    return ConstString(string_summary_ptr->GetSummaryString()).GetCString();
   return nullptr;
 }
 
 uint32_t SBTypeSummary::GetOptions() {
   LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return lldb::eTypeOptionNone;

lldb/source/API/SBTypeSynthetic.cpp

 }
 
 const char *SBTypeSynthetic::GetData() {
   LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
   if (IsClassCode())
-    return m_opaque_sp->GetPythonCode();
-  else
-    return m_opaque_sp->GetPythonClassName();
+    return ConstString(m_opaque_sp->GetPythonCode()).GetCString();
+
+  return ConstString(m_opaque_sp->GetPythonClassName()).GetCString();
 }
 
 void SBTypeSynthetic::SetClassName(const char *data) {
   LLDB_INSTRUMENT_VA(this, data);
 
   if (IsValid() && data && *data)
     m_opaque_sp->SetPythonClassName(data);
 }

lldb/source/API/SBUnixSignals.cpp

SBUnixSignals::operator bool() const {
 
   return static_cast<bool>(GetSP());
 }
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
   LLDB_INSTRUMENT_VA(this, signo);
 
   if (auto signals_sp = GetSP())
-    return signals_sp->GetSignalAsCString(signo);
+    return ConstString(signals_sp->GetSignalAsCString(signo)).GetCString();
 
   return nullptr;
 }
 
 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
   LLDB_INSTRUMENT_VA(this, name);
 
   if (auto signals_sp = GetSP())

lldb/source/API/SBValue.cpp

user_id_t SBValue::GetID() {
   if (value_sp)
     return value_sp->GetID();
   return LLDB_INVALID_UID;
 }
 
 const char *SBValue::GetName() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp)
-    name = value_sp->GetName().GetCString();
+  if (!value_sp)
+    return nullptr;
 
-  return name;
+  return value_sp->GetName().GetCString();
 }
 
 const char *SBValue::GetTypeName() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    name = value_sp->GetQualifiedTypeName().GetCString();
-  }
+  if (!value_sp)
+    return nullptr;
 
-  return name;
+  return value_sp->GetQualifiedTypeName().GetCString();
 }
 
 const char *SBValue::GetDisplayTypeName() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *name = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    name = value_sp->GetDisplayTypeName().GetCString();
-  }
+  if (!value_sp)
+    return nullptr;
 
-  return name;
+  return value_sp->GetDisplayTypeName().GetCString();
 }
 
 size_t SBValue::GetByteSize() {
   LLDB_INSTRUMENT_VA(this);
 
   size_t result = 0;
 
   ValueLocker locker;
bool SBValue::IsInScope() {
   }
 
   return result;
 }
 
 const char *SBValue::GetValue() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    cstr = value_sp->GetValueAsCString();
-  }
-
-  return cstr;
+  if (!value_sp)
+    return nullptr;
+  return ConstString(value_sp->GetValueAsCString()).GetCString();
 }
 
 ValueType SBValue::GetValueType() {
   LLDB_INSTRUMENT_VA(this);
 
   ValueType result = eValueTypeInvalid;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     result = value_sp->GetValueType();
 
   return result;
 }
 
 const char *SBValue::GetObjectDescription() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    cstr = value_sp->GetObjectDescription();
-  }
+  if (!value_sp)
+    return nullptr;
 
-  return cstr;
+  return ConstString(value_sp->GetObjectDescription()).GetCString();
 }
 
 SBType SBValue::GetType() {
   LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
bool SBValue::GetValueDidChange() {
   }
 
   return result;
 }
 
 const char *SBValue::GetSummary() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    cstr = value_sp->GetSummaryAsCString();
-  }
+  if (!value_sp)
+    return nullptr;
 
-  return cstr;
+  return ConstString(value_sp->GetSummaryAsCString()).GetCString();
 }
 
 const char *SBValue::GetSummary(lldb::SBStream &stream,
                                 lldb::SBTypeSummaryOptions &options) {
   LLDB_INSTRUMENT_VA(this, stream, options);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     std::string buffer;
     if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
       stream.Printf("%s", buffer.c_str());
   }
-  const char *cstr = stream.GetData();
-  return cstr;
+  return ConstString(stream.GetData()).GetCString();
 }
 
 const char *SBValue::GetLocation() {
   LLDB_INSTRUMENT_VA(this);
 
-  const char *cstr = nullptr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    cstr = value_sp->GetLocationAsCString();
-  }
-  return cstr;
+  if (!value_sp)
+    return nullptr;
+
+  return ConstString(value_sp->GetLocationAsCString()).GetCString();
 }
 
 // Deprecated - use the one that takes an lldb::SBError
 bool SBValue::SetValueFromCString(const char *value_str) {
   LLDB_INSTRUMENT_VA(this, value_str);
 
   lldb::SBError dummy;
   return SetValueFromCString(value_str, dummy);

lldb/source/API/SBWatchpoint.cpp

if (watchpoint_sp) {
     watchpoint_sp->SetIgnoreCount(n);
   }
 }
 
 const char *SBWatchpoint::GetCondition() {
   LLDB_INSTRUMENT_VA(this);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
-  if (watchpoint_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        watchpoint_sp->GetTarget().GetAPIMutex());
-    return watchpoint_sp->GetConditionText();
-  }
-  return nullptr;
+  if (!watchpoint_sp)
+    return nullptr;
+
+  return ConstString(watchpoint_sp->GetConditionText()).GetCString();
 }
 
 void SBWatchpoint::SetCondition(const char *condition) {
   LLDB_INSTRUMENT_VA(this, condition);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
WatchpointValueKind SBWatchpoint::GetWatchValueKind() {
   }
   return WatchpointValueKind::eWatchPointValueKindInvalid;
 }
 
 const char *SBWatchpoint::GetWatchSpec() {
   LLDB_INSTRUMENT_VA(this);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
-  if (watchpoint_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        watchpoint_sp->GetTarget().GetAPIMutex());
-    // Store the result of `GetWatchSpec()` as a ConstString
-    // so that the C string we return has a sufficiently long
-    // lifetime. Note this a memory leak but should be fairly
-    // low impact.
-    return ConstString(watchpoint_sp->GetWatchSpec()).AsCString();
-  }
-  return nullptr;
-}
+  if (!watchpoint_sp)
+    return nullptr;
+
 
 bool SBWatchpoint::IsWatchingReads() {
   LLDB_INSTRUMENT_VA(this);
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());