Remove redundant .c_str() and .get() calls

[MaskRay]

llvm/include/llvm/ProfileData/InstrProfReader.h

703

delete parens. ditto below

[gAlfonso-bit]

Done! @MaskRay

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[shafik]

lldb/source/API/SBPlatform.cpp

14

These redundant header removals looks unrelated and should be done as a separate NFC change.

clang-tools-extra/modularize/ModuleAssistant.cpp

bool createModuleMap(llvm::StringRef ModuleMapPath,
                      llvm::ArrayRef<std::string> ProblemFileNames,
                      DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
                      llvm::StringRef RootModuleName) {
   // Load internal representation of modules.
   std::unique_ptr<Module> RootModule(
     loadModuleDescriptions(
       RootModuleName, HeaderFileNames, ProblemFileNames, Dependencies,
       HeaderPrefix));
-  if (!RootModule.get())
+  if (!RootModule)
     return false;
 
   // Write module map file.
   return writeModuleMap(ModuleMapPath, HeaderPrefix, RootModule.get());
 }

clang/lib/Driver/OffloadBundler.cpp

Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
         CreateFileHandler(*CodeObjectBuffer, BundlerConfig);
     if (!FileHandlerOrErr)
       return FileHandlerOrErr.takeError();
 
     std::unique_ptr<FileHandler> &FileHandler = *FileHandlerOrErr;
     assert(FileHandler &&
            "FileHandle creation failed for file in the archive!");
 
-    if (Error ReadErr = FileHandler.get()->ReadHeader(*CodeObjectBuffer))
+    if (Error ReadErr = FileHandler->ReadHeader(*CodeObjectBuffer))
       return ReadErr;
 
     Expected<std::optional<StringRef>> CurBundleIDOrErr =
         FileHandler->ReadBundleStart(*CodeObjectBuffer);
     if (!CurBundleIDOrErr)
       return CurBundleIDOrErr.takeError();
 
     std::optional<StringRef> OptionalCurBundleID = *CurBundleIDOrErr;
     // No device code in this child, skip.
     if (!OptionalCurBundleID)
       continue;
     StringRef CodeObject = *OptionalCurBundleID;
 
     // Process all bundle entries (CodeObjects) found in this child of input
     // archive.
     while (!CodeObject.empty()) {
       SmallVector<StringRef> CompatibleTargets;
       auto CodeObjectInfo = OffloadTargetInfo(CodeObject, BundlerConfig);
       if (CodeObjectInfo.hasHostKind()) {
         // Do nothing, we don't extract host code yet.
       } else if (getCompatibleOffloadTargets(CodeObjectInfo, CompatibleTargets,
                                              BundlerConfig)) {
         std::string BundleData;
         raw_string_ostream DataStream(BundleData);
-        if (Error Err =
-                FileHandler.get()->ReadBundle(DataStream, *CodeObjectBuffer))
+        if (Error Err = FileHandler->ReadBundle(DataStream, *CodeObjectBuffer))
           return Err;
 
         for (auto &CompatibleTarget : CompatibleTargets) {
           SmallString<128> BundledObjectFileName;
           BundledObjectFileName.assign(BundledObjectFile);
           auto OutputBundleName =
               Twine(llvm::sys::path::stem(BundledObjectFileName) + "-" +
                     CodeObject +
while (!CodeObject.empty()) {
                                                std::move(ArchiveMembers));
           } else {
             OutputArchivesMap[CompatibleTarget].push_back(
                 NewArchiveMember(MemBufRef));
           }
         }
       }
 
-      if (Error Err = FileHandler.get()->ReadBundleEnd(*CodeObjectBuffer))
+      if (Error Err = FileHandler->ReadBundleEnd(*CodeObjectBuffer))
         return Err;
 
       Expected<std::optional<StringRef>> NextTripleOrErr =
           FileHandler->ReadBundleStart(*CodeObjectBuffer);
       if (!NextTripleOrErr)
         return NextTripleOrErr.takeError();
 
       CodeObject = ((*NextTripleOrErr).has_value()) ? **NextTripleOrErr : "";

clang/lib/Driver/ToolChain.cpp

 SanitizerArgs
 ToolChain::getSanitizerArgs(const llvm::opt::ArgList &JobArgs) const {
   SanitizerArgs SanArgs(*this, JobArgs, !SanitizerArgsChecked);
   SanitizerArgsChecked = true;
   return SanArgs;
 }
 
 const XRayArgs& ToolChain::getXRayArgs() const {
-  if (!XRayArguments.get())
+  if (!XRayArguments)
     XRayArguments.reset(new XRayArgs(*this, Args));
-  return *XRayArguments.get();
+  return *XRayArguments;
 }
 
 namespace {
 
 struct DriverSuffix {
   const char *Suffix;
   const char *ModeFlag;
 };

lld/ELF/Writer.cpp

 // time any references to these symbols are processed and is equivalent to
 // defining these symbols explicitly in the linker script.
 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
   if (ElfSym::globalOffsetTable) {
     // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually
     // to the start of the .got or .got.plt section.
     InputSection *sec = in.gotPlt.get();
     if (!target->gotBaseSymInGotPlt)
-      sec = in.mipsGot.get() ? cast<InputSection>(in.mipsGot.get())
-                             : cast<InputSection>(in.got.get());
+      sec = in.mipsGot ? cast<InputSection>(in.mipsGot.get())
     ElfSym::globalOffsetTable->section = sec;
   }
 
   // .rela_iplt_{start,end} mark the start and the end of in.relaIplt.
   if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) {
     ElfSym::relaIpltStart->section = in.relaIplt.get();
     ElfSym::relaIpltEnd->section = in.relaIplt.get();
     ElfSym::relaIpltEnd->value = in.relaIplt->getSize();

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

 #define LLDB_DATAFORMATTERS_DUMPVALUEOBJECTOPTIONS_H
 
 #include <string>
 
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
 #include <functional>
-#include <string>
 
 namespace lldb_private {
 
 class DumpValueObjectOptions {
 public:
   struct PointerDepth {
     enum class Mode { Always, Default, Never } m_mode;
     uint32_t m_count;

lldb/include/lldb/Host/Editline.h

 
 #if !defined(_WIN32) && !defined(__ANDROID__)
 #include <histedit.h>
 #endif
 
 #include <csignal>
 #include <mutex>
 #include <string>
-#include <vector>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/StringList.h"
 
 #include "llvm/ADT/FunctionExtras.h"

lldb/include/lldb/Target/Process.h

public:
     virtual const char *GetExitString() = 0;
     void RequestResume() { m_process->m_resume_requested = true; }
 
   protected:
     Process *m_process;
   };
 
   void SetNextEventAction(Process::NextEventAction *next_event_action) {
-    if (m_next_event_action_up.get())
+    if (m_next_event_action_up)
       m_next_event_action_up->HandleBeingUnshipped();
 
     m_next_event_action_up.reset(next_event_action);
   }
 
   // This is the completer for Attaching:
   class AttachCompletionHandler : public NextEventAction {
   public:

lldb/source/API/SBCommandReturnObject.cpp

 
 void SBCommandReturnObject::PutCString(const char *string, int len) {
   LLDB_INSTRUMENT_VA(this, string, len);
 
   if (len == 0 || string == nullptr || *string == 0) {
     return;
   } else if (len > 0) {
     std::string buffer(string, len);
-    ref().AppendMessage(buffer.c_str());
+    ref().AppendMessage(buffer);
   } else
     ref().AppendMessage(string);
 }
 
 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
   LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
 
   if (!only_if_no_immediate ||

lldb/source/API/SBExpressionOptions.cpp

m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy
                                         : eExecutionPolicyNever);
 }
 
 EvaluateExpressionOptions *SBExpressionOptions::get() const {
   return m_opaque_up.get();
 }
 
 EvaluateExpressionOptions &SBExpressionOptions::ref() const {
-  return *(m_opaque_up.get());
+  return *(m_opaque_up);
 }

lldb/source/API/SBInstruction.cpp

 //===-- SBInstruction.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/API/SBInstruction.h"
 #include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBFile.h"
 
-#include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/ExecutionContext.h"

lldb/source/API/SBPlatform.cpp

 //===-- SBPlatform.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/API/SBPlatform.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
-#include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBUnixSignals.h"
 #include "lldb/Host/File.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"

lldb/source/API/SBSourceManager.cpp

 }
 
 SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   if (&rhs == this)
     return;
 
-  m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
+  m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up));
 }
 
 const lldb::SBSourceManager &SBSourceManager::
 operator=(const lldb::SBSourceManager &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
-  m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
+  m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up));
   return *this;
 }
 
 SBSourceManager::~SBSourceManager() = default;
 
 size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
     const SBFileSpec &file, uint32_t line, uint32_t context_before,
     uint32_t context_after, const char *current_line_cstr, SBStream &s) {

lldb/source/Breakpoint/BreakpointResolverScripted.cpp

void BreakpointResolverScripted::GetDescription(Stream *s) {
   std::string short_help;
 
   if (m_implementation_sp) {
     ScriptInterpreter *interp = GetScriptInterpreter();
     interp->GetShortHelpForCommandObject(m_implementation_sp,
                                          short_help);
   }
   if (!short_help.empty())
-    s->PutCString(short_help.c_str());
+    s->PutCString(short_help);
   else
     s->Printf("python class = %s", m_class_name.c_str());
 }
 
 void BreakpointResolverScripted::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
 BreakpointResolverScripted::CopyForBreakpoint(BreakpointSP &breakpoint) {
   return std::make_shared<BreakpointResolverScripted>(breakpoint, m_class_name,
                                                       m_depth, m_args);
 }

lldb/source/Commands/CommandObjectBreakpoint.cpp

case 't': {
       } else if (option_arg.getAsInteger(0, thread_id)) {
         error.SetErrorStringWithFormat("invalid thread id string '%s'",
                                        option_arg.str().c_str());
       }
       if (thread_id != LLDB_INVALID_THREAD_ID)
         m_bp_opts.SetThreadID(thread_id);
     } break;
     case 'T':
-      m_bp_opts.GetThreadSpec()->SetName(option_arg.str().c_str());
+      m_bp_opts.GetThreadSpec()->SetName(option_arg.str());
       break;
     case 'q':
-      m_bp_opts.GetThreadSpec()->SetQueueName(option_arg.str().c_str());
+      m_bp_opts.GetThreadSpec()->SetQueueName(option_arg.str());
       break;
     case 'x': {
       uint32_t thread_index = UINT32_MAX;
       if (option_arg.getAsInteger(0, thread_index)) {
         error.SetErrorStringWithFormat("invalid thread index string '%s'",
                                        option_arg.str().c_str());
       } else {
         m_bp_opts.GetThreadSpec()->SetIndex(thread_index);

lldb/source/Commands/CommandObjectExpression.cpp

 void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler,
                                                      std::string &line) {
   io_handler.SetIsDone(true);
   StreamFileSP output_sp = io_handler.GetOutputStreamFileSP();
   StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
   CommandReturnObject return_obj(
       GetCommandInterpreter().GetDebugger().GetUseColor());
-  EvaluateExpression(line.c_str(), *output_sp, *error_sp, return_obj);
+  EvaluateExpression(line, *output_sp, *error_sp, return_obj);
   if (output_sp)
     output_sp->Flush();
   if (error_sp)
     error_sp->Flush();
 }
 
 bool CommandObjectExpression::IOHandlerIsInputComplete(IOHandler &io_handler,
                                                        StringList &lines) {

lldb/source/Commands/CommandObjectHelp.cpp

if (cmd_obj != nullptr) {
           for (size_t match_idx = 0; match_idx < num_matches; match_idx++) {
             s.Printf("\n\t%s", matches.GetStringAtIndex(match_idx));
           }
           s.Printf("\n");
           result.AppendError(s.GetString());
           return false;
         } else if (!sub_cmd_obj) {
           StreamString error_msg_stream;
-          GenerateAdditionalHelpAvenuesMessage(
-              &error_msg_stream, cmd_string.c_str(),
-              m_interpreter.GetCommandPrefix(), sub_command.c_str());
+          GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, cmd_string,
+                                               m_interpreter.GetCommandPrefix(),
+                                               sub_command);
           result.AppendError(error_msg_stream.GetString());
           return false;
         } else {
           GenerateAdditionalHelpAvenuesMessage(
-              &result.GetOutputStream(), cmd_string.c_str(),
-              m_interpreter.GetCommandPrefix(), sub_command.c_str());
+              &result.GetOutputStream(), cmd_string,
+              m_interpreter.GetCommandPrefix(), sub_command);
           result.GetOutputStream().Printf(
               "\nThe closest match is '%s'. Help on it follows.\n\n",
               sub_cmd_obj->GetCommandName().str().c_str());
         }
       }
 
       sub_cmd_obj->GenerateHelpText(result);
       std::string alias_full_name;

lldb/source/Commands/CommandObjectMultiword.cpp

bool CommandObjectMultiword::Execute(const char *args_string,
   if (num_subcmd_matches > 0) {
     error_msg.append(" Possible completions:");
     for (const std::string &match : matches) {
       error_msg.append("\n\t");
       error_msg.append(match);
     }
   }
   error_msg.append("\n");
-  result.AppendRawError(error_msg.c_str());
+  result.AppendRawError(error_msg);
   return false;
 }
 
 void CommandObjectMultiword::GenerateHelpText(Stream &output_stream) {
   // First time through here, generate the help text for the object and push it
   // to the return result object as well
 
   CommandObject::GenerateHelpText(output_stream);

lldb/source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
 
       if (symfile || remote_file) {
         ModuleSP module_sp(target_sp->GetExecutableModule());
         if (module_sp) {
           if (symfile)
             module_sp->SetSymbolFileFileSpec(symfile);
           if (remote_file) {
             std::string remote_path = remote_file.GetPath();
-            target_sp->SetArg0(remote_path.c_str());
+            target_sp->SetArg0(remote_path);
             module_sp->SetPlatformFileSpec(remote_file);
           }
         }
       }
 
       if (must_set_platform_path) {
         ModuleSpec main_module_spec(file_spec);
         ModuleSP module_sp =

lldb/source/Commands/CommandObjectThread.cpp

if (m_options.m_load_addr != LLDB_INVALID_ADDRESS) {
       Status err = thread->JumpToLine(file, line, m_options.m_force, &warnings);
 
       if (err.Fail()) {
         result.SetError(err);
         return false;
       }
 
       if (!warnings.empty())
-        result.AppendWarning(warnings.c_str());
+        result.AppendWarning(warnings);
     }
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
   CommandOptions m_options;
 };

lldb/source/Core/Disassembler.cpp

Disassembler::Disassembler(const ArchSpec &arch, const char *flavor)
   // instructions, force the arch triple to be "thumbv.." instead of "armv..."
   if (arch.IsAlwaysThumbInstructions()) {
     std::string thumb_arch_name(arch.GetTriple().getArchName().str());
     // Replace "arm" with "thumb" so we get all thumb variants correct
     if (thumb_arch_name.size() > 3) {
       thumb_arch_name.erase(0, 3);
       thumb_arch_name.insert(0, "thumb");
     }
-    m_arch.SetTriple(thumb_arch_name.c_str());
+    m_arch.SetTriple(thumb_arch_name);
   }
 }
 
 Disassembler::~Disassembler() = default;
 
 InstructionList &Disassembler::GetInstructionList() {
   return m_instruction_list;
 }

lldb/source/Core/FormatEntity.cpp

static ValueObjectSP ExpandIndexedExpression(ValueObject *valobj, size_t index,
   LLDB_LOGF(log, "[ExpandIndexedExpression] name to deref: %s",
             ptr_deref_buffer.c_str());
   ValueObject::GetValueForExpressionPathOptions options;
   ValueObject::ExpressionPathEndResultType final_value_type;
   ValueObject::ExpressionPathScanEndReason reason_to_stop;
   ValueObject::ExpressionPathAftermath what_next =
       (deref_pointer ? ValueObject::eExpressionPathAftermathDereference
                      : ValueObject::eExpressionPathAftermathNothing);
-  ValueObjectSP item = valobj->GetValueForExpressionPath(
-      ptr_deref_buffer.c_str(), &reason_to_stop, &final_value_type, options,
-      &what_next);
+  ValueObjectSP item =
+      valobj->GetValueForExpressionPath(ptr_deref_buffer, &reason_to_stop,
+                                        &final_value_type, options, &what_next);
   if (!item) {
     LLDB_LOGF(log,
               "[ExpandIndexedExpression] ERROR: why stopping = %d,"
               " final_value_type %d",
               reason_to_stop, final_value_type);
   } else {
     LLDB_LOGF(log,
               "[ExpandIndexedExpression] ALL RIGHT: why stopping = %d,"
if (entry.string.empty()) {
 
     const std::string &expr_path = entry.string;
 
     LLDB_LOGF(log, "[Debugger::FormatPrompt] symbol to expand: %s",
               expr_path.c_str());
 
     target =
         valobj
-            ->GetValueForExpressionPath(expr_path.c_str(), &reason_to_stop,
+            ->GetValueForExpressionPath(expr_path, &reason_to_stop,
                                         &final_value_type, options, &what_next)
             .get();
 
     if (!target) {
       LLDB_LOGF(log,
                 "[Debugger::FormatPrompt] ERROR: why stopping = %d,"
                 " final_value_type %d",
                 reason_to_stop, final_value_type);

lldb/source/Core/IOHandlerCursesGUI.cpp

public:
   int GetNumberOfMatches() override { return m_matches.GetSize(); }
 
   const std::string &GetMatchTextAtIndex(int index) override {
     return m_matches[index];
   }
 
   void UpdateMatches(const std::string &text) override {
     CompletionResult result;
-    CompletionRequest request(text.c_str(), text.size(), result);
+    CompletionRequest request(text, text.size(), result);
     CommandCompletions::InvokeCommonCompletionCallbacks(
         m_debugger.GetCommandInterpreter(), m_completion_mask, request,
         nullptr);
     result.GetMatches(m_matches);
   }
 
   void ExecuteCallback(int match_index) override {
     m_callback(m_matches[match_index]);

lldb/source/Core/ValueObject.cpp

 #include <memory>
 #include <tuple>
 
 #include <cassert>
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
 
-#include <lldb/Core/ValueObject.h>
-
 namespace lldb_private {
 class ExecutionContextScope;
 }
 namespace lldb_private {
 class SymbolContextScope;
 }
 
 using namespace lldb;

lldb/source/Expression/REPL.cpp

if (code[0] == ':') {
       if (!persistent_state)
         return;
 
       const size_t var_count_before = persistent_state->GetSize();
 
       const char *expr_prefix = nullptr;
       lldb::ValueObjectSP result_valobj_sp;
       Status error;
-      lldb::ExpressionResults execution_results =
-          UserExpression::Evaluate(exe_ctx, expr_options, code.c_str(),
-                                   expr_prefix, result_valobj_sp, error,
-                                   nullptr); // fixed expression
+      lldb::ExpressionResults execution_results = UserExpression::Evaluate(
+          exe_ctx, expr_options, code, expr_prefix, result_valobj_sp, error,
 
       // CommandInterpreter &ci = debugger.GetCommandInterpreter();
 
       if (process_sp && process_sp->IsAlive()) {
         bool add_to_code = true;
         bool handled = false;
         if (result_valobj_sp) {
           lldb::Format format = m_format_options.GetFormat();

lldb/source/Host/common/ProcessLaunchInfo.cpp

 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 
-#if !defined(_WIN32)
-#include <climits>
-#endif
-
 using namespace lldb;
 using namespace lldb_private;
 
 // ProcessLaunchInfo member functions
 
 ProcessLaunchInfo::ProcessLaunchInfo()
     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
       m_file_actions(), m_pty(new PseudoTerminal), m_monitor_callback(nullptr),

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

 #include <sstream>
 
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/ErrorHandling.h"
 #if defined(__APPLE__)
 #include "llvm/ADT/SmallVector.h"
 #endif
 #include "lldb/Host/Host.h"
-#include "lldb/Host/Socket.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Host/common/UDPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/source/Interpreter/CommandInterpreter.cpp

if (start != std::string::npos) {
 
       if (cmd_obj == nullptr)
         // Since cmd_obj is NULL we are on our first time through this loop.
         // Check to see if cmd_word is a valid command or alias.
         cmd_obj = GetCommandObject(cmd_word);
       else if (cmd_obj->IsMultiwordObject()) {
         // Our current object is a multi-word object; see if the cmd_word is a
         // valid sub-command for our object.
-        CommandObject *sub_cmd_obj =
-            cmd_obj->GetSubcommandObject(cmd_word.c_str());
+        CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject(cmd_word);
         if (sub_cmd_obj)
           cmd_obj = sub_cmd_obj;
         else // cmd_word was not a valid sub-command word, so we are done
           done = true;
       } else
         // We have a cmd_obj and it is not a multi-word object, so we are done.
         done = true;
 
while ((start_backtick = command.find('`', pos)) != std::string::npos) {
     EvaluateExpressionOptions options;
     options.SetCoerceToId(false);
     options.SetUnwindOnError(true);
     options.SetIgnoreBreakpoints(true);
     options.SetKeepInMemory(false);
     options.SetTryAllThreads(true);
     options.SetTimeout(std::nullopt);
 
-    ExpressionResults expr_result =
-        target.EvaluateExpression(expr_str.c_str(), exe_ctx.GetFramePtr(),
-                                  expr_result_valobj_sp, options);
+    ExpressionResults expr_result = target.EvaluateExpression(
+        expr_str, exe_ctx.GetFramePtr(), expr_result_valobj_sp, options);
 
     if (expr_result == eExpressionCompleted) {
       Scalar scalar;
       if (expr_result_valobj_sp)
         expr_result_valobj_sp =
             expr_result_valobj_sp->GetQualifiedRepresentationIfAvailable(
                 expr_result_valobj_sp->GetDynamicValueType(), true);
       if (expr_result_valobj_sp->ResolveValue(scalar)) {
if (cmd_obj == nullptr) {
           revised_command_line.Printf("%s", cmd_name.str().c_str());
           wants_raw_input = cmd_obj->WantsRawCommandString();
         } else {
           revised_command_line.Printf("%s", next_word.c_str());
         }
       }
     } else {
       if (cmd_obj->IsMultiwordObject()) {
-        CommandObject *sub_cmd_obj =
-            cmd_obj->GetSubcommandObject(next_word.c_str());
+        CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject(next_word);
         if (sub_cmd_obj) {
           // The subcommand's name includes the parent command's name, so
           // restart rather than append to the revised_command_line.
           llvm::StringRef sub_cmd_name = sub_cmd_obj->GetCommandName();
           revised_command_line.Clear();
           revised_command_line.Printf("%s", sub_cmd_name.str().c_str());
           cmd_obj = sub_cmd_obj;
           wants_raw_input = cmd_obj->WantsRawCommandString();

lldb/source/Interpreter/CommandObject.cpp

 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Interpreter/CommandOptionArgumentTable.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // CommandObject
 
 CommandObject::CommandObject(CommandInterpreter &interpreter,

lldb/source/Interpreter/OptionArgParser.cpp

if (expr_result == eExpressionCompleted) {
     llvm::SmallVector<llvm::StringRef, 4> matches;
     if (g_symbol_plus_offset_regex.Execute(sref, &matches)) {
       uint64_t offset = 0;
       std::string name = matches[1].str();
       std::string sign = matches[2].str();
       std::string str_offset = matches[3].str();
       if (!llvm::StringRef(str_offset).getAsInteger(0, offset)) {
         Status error;
-        addr = ToAddress(exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS, &error);
+        addr = ToAddress(exe_ctx, name, LLDB_INVALID_ADDRESS, &error);
         if (addr != LLDB_INVALID_ADDRESS) {
           if (sign[0] == '+')
             return addr + offset;
           else
             return addr - offset;
         }
       }
     }

lldb/source/Interpreter/OptionValueArch.cpp

Status OptionValueArch::SetValueFromString(llvm::StringRef value,
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
     std::string value_str = value.trim().str();
-    if (m_current_value.SetTriple(value_str.c_str())) {
+    if (m_current_value.SetTriple(value_str)) {
       m_value_was_set = true;
       NotifyValueChanged();
     } else
       error.SetErrorStringWithFormat("unsupported architecture '%s'",
                                      value_str.c_str());
     break;
   }
   case eVarSetOperationInsertBefore:

lldb/source/Interpreter/ScriptInterpreter.cpp

 lldb::DataExtractorSP
 ScriptInterpreter::GetDataExtractorFromSBData(const lldb::SBData &data) const {
   return data.m_opaque_sp;
 }
 
 Status
 ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
   if (error.m_opaque_up)
-    return *error.m_opaque_up.get();
+    return *error.m_opaque_up;
 
   return Status();
 }
 
 llvm::Optional<MemoryRegionInfo>
 ScriptInterpreter::GetOpaqueTypeFromSBMemoryRegionInfo(
     const lldb::SBMemoryRegionInfo &mem_region) const {
   if (!mem_region.m_opaque_up)

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 bool DynamicLoaderDarwinKernel::KextImageInfo::ReadMemoryModule(
     Process *process) {
   Log *log = GetLog(LLDBLog::Host);
   if (m_memory_module_sp.get() != nullptr)
     return true;
   if (m_load_address == LLDB_INVALID_ADDRESS)
     return false;
 
-  FileSpec file_spec(m_name.c_str());
+  FileSpec file_spec(m_name);
 
   llvm::MachO::mach_header mh;
   size_t size_to_read = 512;
   if (ReadMachHeader(m_load_address, process, mh)) {
     if (mh.magic == llvm::MachO::MH_CIGAM || mh.magic == llvm::MachO::MH_MAGIC)
       size_to_read = sizeof(llvm::MachO::mach_header) + mh.sizeofcmds;
     if (mh.magic == llvm::MachO::MH_CIGAM_64 ||
         mh.magic == llvm::MachO::MH_MAGIC_64)
if (!m_module_sp && m_uuid.IsValid()) {
       // PlatformDarwinKernel does a special scan for kexts on the local
       // system.
       PlatformSP platform_sp(target.GetPlatform());
       if (!m_module_sp && platform_sp) {
         static ConstString g_platform_name(
             PlatformDarwinKernel::GetPluginNameStatic());
         if (platform_sp->GetPluginName() == g_platform_name.GetStringRef()) {
           ModuleSpec kext_bundle_module_spec(module_spec);
-          FileSpec kext_filespec(m_name.c_str());
+          FileSpec kext_filespec(m_name);
           FileSpecList search_paths = target.GetExecutableSearchPaths();
           kext_bundle_module_spec.GetFileSpec() = kext_filespec;
           platform_sp->GetSharedModule(kext_bundle_module_spec, process,
                                        m_module_sp, &search_paths, nullptr,
                                        nullptr);
         }
       }
 

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp

 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
 
 #include "HexagonDYLDRendezvous.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 /// Locates the address of the rendezvous structure.  Returns the address on
 /// success and LLDB_INVALID_ADDRESS on failure.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 #include "llvm/Support/Signals.h"
 
 #include "ClangDiagnostic.h"
 #include "ClangExpressionParser.h"
 #include "ClangUserExpression.h"
 
 #include "ASTUtils.h"
 #include "ClangASTSource.h"
-#include "ClangDiagnostic.h"
 #include "ClangExpressionDeclMap.h"
 #include "ClangExpressionHelper.h"
-#include "ClangExpressionParser.h"
 #include "ClangHost.h"
 #include "ClangModulesDeclVendor.h"
 #include "ClangPersistentVariables.h"
 #include "IRDynamicChecks.h"
 #include "IRForTarget.h"
 #include "ModuleDependencyCollector.h"
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"

lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

ClangPersistentVariables::GetClangASTImporter() {
   }
   return m_ast_importer_sp;
 }
 
 std::shared_ptr<ClangModulesDeclVendor>
 ClangPersistentVariables::GetClangModulesDeclVendor() {
   if (!m_modules_decl_vendor_sp) {
     m_modules_decl_vendor_sp.reset(
-        ClangModulesDeclVendor::Create(*m_target_sp.get()));
+        ClangModulesDeclVendor::Create(*m_target_sp));
   }
   return m_modules_decl_vendor_sp;
 }
 
 ConstString
 ClangPersistentVariables::GetNextPersistentVariableName(bool is_error) {
   llvm::SmallString<64> name;
   {
     llvm::raw_svector_ostream os(name);
     os << GetPersistentVariablePrefix(is_error)
        << m_next_persistent_variable_id++;
   }
   return ConstString(name);
 }

lldb/source/Plugins/ExpressionParser/Clang/NameSearchContext.cpp

clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
 
   // If this is an operator (e.g. operator new or operator==), only insert the
   // declaration we inferred from the symbol if we can provide the correct
   // number of arguments. We shouldn't really inject random decl(s) for
   // functions that are analyzed semantically in a special way, otherwise we
   // will crash in clang.
   clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
   if (func_proto_type &&
-      TypeSystemClang::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
+      TypeSystemClang::IsOperator(decl_name.getAsString(), op_kind)) {
     if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
             false, op_kind, func_proto_type->getNumParams()))
       return nullptr;
   }
   m_decls.push_back(func_decl);
 
   return func_decl;
 }

lldb/source/Plugins/InstrumentationRuntime/TSan/InstrumentationRuntimeTSan.cpp

 t;
 )";
 
 static StructuredData::ArraySP
 CreateStackTrace(ValueObjectSP o,
                  const std::string &trace_item_name = ".trace") {
   auto trace_sp = std::make_shared<StructuredData::Array>();
   ValueObjectSP trace_value_object =
-      o->GetValueForExpressionPath(trace_item_name.c_str());
+      o->GetValueForExpressionPath(trace_item_name);
   size_t count = trace_value_object->GetNumChildren();
   for (size_t j = 0; j < count; j++) {
     addr_t trace_addr =
         trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
     if (trace_addr == 0)
       break;
     trace_sp->AddItem(std::make_shared<StructuredData::Integer>(trace_addr));
   }
   return trace_sp;
 }
 
 static StructuredData::ArraySP ConvertToStructuredArray(
     ValueObjectSP return_value_sp, const std::string &items_name,
     const std::string &count_name,
     std::function<void(const ValueObjectSP &o,
                        const StructuredData::DictionarySP &dict)> const
         &callback) {
   auto array_sp = std::make_shared<StructuredData::Array>();
-  unsigned int count =
-      return_value_sp->GetValueForExpressionPath(count_name.c_str())
+  unsigned int count = return_value_sp->GetValueForExpressionPath(count_name)
                            ->GetValueAsUnsigned(0);
   ValueObjectSP objects =
-      return_value_sp->GetValueForExpressionPath(items_name.c_str());
+      return_value_sp->GetValueForExpressionPath(items_name);
   for (unsigned int i = 0; i < count; i++) {
     ValueObjectSP o = objects->GetChildAtIndex(i, true);
     auto dict_sp = std::make_shared<StructuredData::Dictionary>();
 
     callback(o, dict_sp);
 
     array_sp->AddItem(dict_sp);
   }
   return array_sp;
 }
 
 static std::string RetrieveString(ValueObjectSP return_value_sp,
                                   ProcessSP process_sp,
                                   const std::string &expression_path) {
-  addr_t ptr =
-      return_value_sp->GetValueForExpressionPath(expression_path.c_str())
+  addr_t ptr = return_value_sp->GetValueForExpressionPath(expression_path)
                    ->GetValueAsUnsigned(0);
   std::string str;
   Status error;
   process_sp->ReadCStringFromMemory(ptr, str, error);
   return str;
 }
 
 static void
 GetRenumberedThreadIds(ProcessSP process_sp, ValueObjectSP data,

lldb/source/Plugins/InstrumentationRuntime/UBSan/InstrumentationRuntimeUBSan.cpp

 __ubsan_get_current_report_data(&t.issue_kind, &t.message, &t.filename, &t.line,
                                 &t.col, &t.memory_addr);
 t;
 )";
 
 static addr_t RetrieveUnsigned(ValueObjectSP return_value_sp,
                                ProcessSP process_sp,
                                const std::string &expression_path) {
-  return return_value_sp->GetValueForExpressionPath(expression_path.c_str())
+  return return_value_sp->GetValueForExpressionPath(expression_path)
       ->GetValueAsUnsigned(0);
 }
 
 static std::string RetrieveString(ValueObjectSP return_value_sp,
                                   ProcessSP process_sp,
                                   const std::string &expression_path) {
   addr_t ptr = RetrieveUnsigned(return_value_sp, process_sp, expression_path);
   std::string str;

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

static void NSNumber_FormatInt128(ValueObject &valobj, Stream &stream,
   if (Language *language = Language::FindPlugin(lang)) {
     if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
                                             suffix)) {
       prefix.clear();
       suffix.clear();
     }
   }
 
-  stream.PutCString(prefix.c_str());
+  stream.PutCString(prefix);
   const int radix = 10;
   const bool isSigned = true;
   std::string str = llvm::toString(value, radix, isSigned);
-  stream.PutCString(str.c_str());
-  stream.PutCString(suffix.c_str());
+  stream.PutCString(str);
+  stream.PutCString(suffix);
 }
 
 static void NSNumber_FormatFloat(ValueObject &valobj, Stream &stream,
                                  float value, lldb::LanguageType lang) {
   static ConstString g_TypeHint("NSNumber:float");
 
   std::string prefix, suffix;
   if (Language *language = Language::FindPlugin(lang)) {

lldb/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

static void CreateHistoryThreadFromValueObject(ProcessSP process_sp,
                                                const char *type,
                                                const char *thread_name,
                                                HistoryThreads &result) {
   std::string count_path = "." + std::string(type) + "_count";
   std::string tid_path = "." + std::string(type) + "_tid";
   std::string trace_path = "." + std::string(type) + "_trace";
 
   ValueObjectSP count_sp =
-      return_value_sp->GetValueForExpressionPath(count_path.c_str());
-  ValueObjectSP tid_sp =
-      return_value_sp->GetValueForExpressionPath(tid_path.c_str());
+      return_value_sp->GetValueForExpressionPath(count_path);
+  ValueObjectSP tid_sp = return_value_sp->GetValueForExpressionPath(tid_path);
 
   if (!count_sp || !tid_sp)
     return;
 
   int count = count_sp->GetValueAsUnsigned(0);
   tid_t tid = tid_sp->GetValueAsUnsigned(0) + 1;
 
   if (count <= 0)
     return;
 
   ValueObjectSP trace_sp =
-      return_value_sp->GetValueForExpressionPath(trace_path.c_str());
+      return_value_sp->GetValueForExpressionPath(trace_path);
 
   if (!trace_sp)
     return;
 
   std::vector<lldb::addr_t> pcs;
   for (int i = 0; i < count; i++) {
     addr_t pc = trace_sp->GetChildAtIndex(i, true)->GetValueAsUnsigned(0);
     if (pc == 0 || pc == 1 || pc == LLDB_INVALID_ADDRESS)

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 #include "ObjectFileMachO.h"
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
 // GetLLDBSharedCacheUUID() needs to call dlsym()
 #include <dlfcn.h>
 #include <mach/mach_init.h>
 #include <mach/vm_map.h>
-#include <lldb/Host/SafeMachO.h>
 #endif
 
 #ifndef __APPLE__
 #include "Utility/UuidCompatibility.h"
 #else
 #include <uuid/uuid.h>
 #endif
 
for (MachOCorefileImageEntry &image : image_infos.all_image_infos) {
     // Try to find the binary by UUID or filename on the local
     // filesystem or in lldb's global module cache.
     if (!module_sp) {
       Status error;
       ModuleSpec module_spec;
       if (image.uuid.IsValid())
         module_spec.GetUUID() = image.uuid;
       if (!image.filename.empty())
-        module_spec.GetFileSpec() = FileSpec(image.filename.c_str());
+        module_spec.GetFileSpec() = FileSpec(image.filename);
       module_sp =
           process.GetTarget().GetOrCreateModule(module_spec, false, &error);
       process.GetTarget().GetImages().AppendIfNeeded(module_sp,
                                                      false /* notify */);
     }
 
     // We have a ModuleSP to load in the Target.  Load it at the
     // correct address/slide and notify/load scripting resources.

lldb/source/Plugins/Platform/Android/AdbClient.cpp

 Status AdbClient::Connect() {
   Status error;
   m_conn = std::make_unique<ConnectionFileDescriptor>();
   std::string port = "5037";
   if (const char *env_port = std::getenv("ANDROID_ADB_SERVER_PORT")) {
     port = env_port;
   }
   std::string uri = "connect://127.0.0.1:" + port;
-  m_conn->Connect(uri.c_str(), &error);
+  m_conn->Connect(uri, &error);
 
   return error;
 }
 
 Status AdbClient::GetDevices(DeviceIDList &device_list) {
   device_list.clear();
 
   auto error = SendMessage("host:devices");

 
 Status AdbClient::GetResponseError(const char *response_id) {
   if (strcmp(response_id, kFAIL) != 0)
     return Status("Got unexpected response id from adb: \"%s\"", response_id);
 
   std::vector<char> error_message;
   auto error = ReadMessage(error_message);
   if (error.Success())
-    error.SetErrorString(
-        std::string(&error_message[0], error_message.size()).c_str());
+    error.SetErrorString(std::string(&error_message[0], error_message.size()));
 
   return error;
 }
 
 Status AdbClient::SwitchDeviceTransport() {
   std::ostringstream msg;
   msg << "host:transport:" << m_device_id;
 

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

bool PlatformAndroidRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid,
 
   Log *log = GetLog(LLDBLog::Platform);
 
   uint16_t local_port = 0;
   const char *gdbstub_port = std::getenv("ANDROID_PLATFORM_LOCAL_GDB_PORT");
   if (gdbstub_port)
     local_port = std::stoi(gdbstub_port);
 
-  auto error = MakeConnectURL(pid, local_port, remote_port, socket_name.c_str(),
-                              connect_url);
+  auto error =
+      MakeConnectURL(pid, local_port, remote_port, socket_name, connect_url);
   if (error.Success() && log)
     LLDB_LOGF(log, "gdbserver connect URL: %s", connect_url.c_str());
 
   return error.Success();
 }
 
 bool PlatformAndroidRemoteGDBServer::KillSpawnedProcess(lldb::pid_t pid) {
   assert(IsConnected());

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinDevice.cpp

if (device_support_dir) {
           }
         }
       }
 
       const uint32_t num_installed = m_sdk_directory_infos.size();
       llvm::StringRef dirname = GetDeviceSupportDirectoryName();
       std::string local_sdk_cache_str = "~/Library/Developer/Xcode/";
       local_sdk_cache_str += std::string(dirname);
-      FileSpec local_sdk_cache(local_sdk_cache_str.c_str());
+      FileSpec local_sdk_cache(local_sdk_cache_str);
       FileSystem::Instance().Resolve(local_sdk_cache);
       if (FileSystem::Instance().Exists(local_sdk_cache)) {
         if (log) {
           LLDB_LOGF(log,
                     "PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
                     "searching %s for additional SDKs",
                     local_sdk_cache.GetPath().c_str());
         }

 }
 
 const char *PlatformDarwinDevice::GetDeviceSupportDirectory() {
   std::string platform_dir =
       ("/Platforms/" + GetPlatformName() + "/DeviceSupport").str();
   if (m_device_support_directory.empty()) {
     if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
       m_device_support_directory = fspec.GetPath();
-      m_device_support_directory.append(platform_dir.c_str());
+      m_device_support_directory.append(platform_dir);
     } else {
       // Assign a single NULL character so we know we tried to find the device
       // support directory and we don't keep trying to find it over and over.
       m_device_support_directory.assign(1, '\0');
     }
   }
   // We should have put a single NULL character into m_device_support_directory
   // or it should have a valid path if the code gets here

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 
 // Given a directory path dir, look for any subdirs named *.kdk and *.sdk
 void PlatformDarwinKernel::AddSDKSubdirsToSearchPaths(const std::string &dir) {
   // Look for *.kdk and *.sdk in dir
   const bool find_directories = true;
   const bool find_files = false;
   const bool find_other = false;
   FileSystem::Instance().EnumerateDirectory(
-      dir.c_str(), find_directories, find_files, find_other,
+      dir, find_directories, find_files, find_other,
       FindKDKandSDKDirectoriesInDirectory, this);
 }
 
 // Helper function to find *.sdk and *.kdk directories in a given directory.
 FileSystem::EnumerateDirectoryResult
 PlatformDarwinKernel::FindKDKandSDKDirectoriesInDirectory(
     void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
   static ConstString g_sdk_suffix = ConstString(".sdk");

 void PlatformDarwinKernel::SearchForKextsAndKernelsRecursively() {
   const uint32_t num_dirs = m_search_directories.size();
   for (uint32_t i = 0; i < num_dirs; i++) {
     const FileSpec &dir = m_search_directories[i];
     const bool find_directories = true;
     const bool find_files = true;
     const bool find_other = true; // I think eFileTypeSymbolicLink are "other"s.
     FileSystem::Instance().EnumerateDirectory(
-        dir.GetPath().c_str(), find_directories, find_files, find_other,
+        dir.GetPath(), find_directories, find_files, find_other,
         GetKernelsAndKextsInDirectoryWithRecursion, this);
   }
   const uint32_t num_dirs_no_recurse = m_search_directories_no_recursing.size();
   for (uint32_t i = 0; i < num_dirs_no_recurse; i++) {
     const FileSpec &dir = m_search_directories_no_recursing[i];
     const bool find_directories = true;
     const bool find_files = true;
     const bool find_other = true; // I think eFileTypeSymbolicLink are "other"s.
     FileSystem::Instance().EnumerateDirectory(
-        dir.GetPath().c_str(), find_directories, find_files, find_other,
+        dir.GetPath(), find_directories, find_files, find_other,
         GetKernelsAndKextsInDirectoryNoRecursion, this);
   }
 }
 
 // We're only doing a filename match here.  We won't try opening the file to
 // see if it's really a kernel or not until we need to find a kernel of a given
 // UUID.  There's no cheap way to find the UUID of a file (or if it's a Mach-O
 // binary at all) without creating a whole Module for the file and throwing it
if (ft == llvm::sys::fs::file_type::directory_file) {
           }
         }
 
         if (!search_here_too.empty()) {
           const bool find_directories = true;
           const bool find_files = false;
           const bool find_other = false;
           FileSystem::Instance().EnumerateDirectory(
-              search_here_too.c_str(), find_directories, find_files, find_other,
+              search_here_too, find_directories, find_files, find_other,
               recurse ? GetKernelsAndKextsInDirectoryWithRecursion
                       : GetKernelsAndKextsInDirectoryNoRecursion,
               baton);
         }
         return FileSystem::eEnumerateDirectoryResultNext;
       }
       // Do we have a kernel dSYM with no kernel binary?
       if (is_kernel_filename && file_spec_extension == g_dsym_suffix) {
Status PlatformDarwinKernel::GetSharedModuleKernel(
 
   return error;
 }
 
 std::vector<lldb_private::FileSpec>
 PlatformDarwinKernel::SearchForExecutablesRecursively(const std::string &dir) {
   std::vector<FileSpec> executables;
   std::error_code EC;
-  for (llvm::sys::fs::recursive_directory_iterator it(dir.c_str(), EC),
-       end;
+  for (llvm::sys::fs::recursive_directory_iterator it(dir, EC), end;
        it != end && !EC; it.increment(EC)) {
     auto status = it->status();
     if (!status)
       break;
     if (llvm::sys::fs::is_regular_file(*status) &&
         llvm::sys::fs::can_execute(it->path()))
       executables.emplace_back(it->path());
   }

lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.h

public:
   ModelIdentifier();
 
   explicit operator bool() const { return !m_versions.empty(); }
 
   size_t GetNumVersions() const { return m_versions.size(); }
 
   unsigned int GetVersionAtIndex(size_t idx) const { return m_versions[idx]; }
 
-  std::string GetFamily() const { return m_family.c_str(); }
+  std::string GetFamily() const { return m_family; }
 
 private:
   std::string m_family;
   std::vector<unsigned int> m_versions;
 };
 
 class DeviceType {
 public:

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 llvm::StringRef PlatformRemoteGDBServer::GetDescription() {
   if (m_platform_description.empty()) {
     if (IsConnected()) {
       // Send the get description packet
     }
   }
 
   if (!m_platform_description.empty())
-    return m_platform_description.c_str();
+    return m_platform_description;
   return GetDescriptionStatic();
 }
 
 bool PlatformRemoteGDBServer::GetModuleSpec(const FileSpec &module_file_spec,
                                             const ArchSpec &arch,
                                             ModuleSpec &module_spec) {
   Log *log = GetLog(LLDBLog::Platform);
 
if (IsConnected()) {
         // The darwin always currently uses the GDB remote debugger plug-in
         // so even when debugging locally we are debugging remotely!
         process_sp = target.CreateProcess(launch_info.GetListener(),
                                           "gdb-remote", nullptr, true);
 
         if (process_sp) {
           process_sp->HijackProcessEvents(launch_info.GetHijackListener());
 
-          error = process_sp->ConnectRemote(connect_url.c_str());
+          error = process_sp->ConnectRemote(connect_url);
           // Retry the connect remote one time...
           if (error.Fail())
-            error = process_sp->ConnectRemote(connect_url.c_str());
+            error = process_sp->ConnectRemote(connect_url);
           if (error.Success())
             error = process_sp->Launch(launch_info);
           else if (debugserver_pid != LLDB_INVALID_PROCESS_ID) {
             printf("error: connect remote failed (%s)\n", error.AsCString());
             KillSpawnedProcess(debugserver_pid);
           }
         }
       }
if (IsConnected()) {
 
         if (target && error.Success()) {
           // The darwin always currently uses the GDB remote debugger plug-in
           // so even when debugging locally we are debugging remotely!
           process_sp =
               target->CreateProcess(attach_info.GetListenerForProcess(debugger),
                                     "gdb-remote", nullptr, true);
           if (process_sp) {
-            error = process_sp->ConnectRemote(connect_url.c_str());
+            error = process_sp->ConnectRemote(connect_url);
             if (error.Success()) {
               ListenerSP listener_sp = attach_info.GetHijackListener();
               if (listener_sp)
                 process_sp->HijackProcessEvents(listener_sp);
               error = process_sp->Attach(attach_info);
             }
 
             if (error.Fail() && debugserver_pid != LLDB_INVALID_PROCESS_ID) {

 }
 
 size_t PlatformRemoteGDBServer::ConnectToWaitingProcesses(Debugger &debugger,
                                                           Status &error) {
   std::vector<std::string> connection_urls;
   GetPendingGdbServerList(connection_urls);
 
   for (size_t i = 0; i < connection_urls.size(); ++i) {
-    ConnectProcess(connection_urls[i].c_str(), "gdb-remote", debugger, nullptr, error);
+    ConnectProcess(connection_urls[i], "gdb-remote", debugger, nullptr, error);
     if (error.Fail())
       return i; // We already connected to i process successfully
   }
   return connection_urls.size();
 }
 
 size_t PlatformRemoteGDBServer::GetPendingGdbServerList(
     std::vector<std::string> &connection_urls) {

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 lldb::thread_result_t GDBRemoteCommunication::ListenThread() {
   Status error;
   ConnectionFileDescriptor *connection =
       (ConnectionFileDescriptor *)GetConnection();
 
   if (connection) {
     // Do the listen on another thread so we can continue on...
     if (connection->Connect(
-            m_listen_url.c_str(),
+            m_listen_url,
             [this](llvm::StringRef port_str) {
               uint16_t port = 0;
               llvm::to_integer(port_str, port, 10);
               m_port_promise.set_value(port);
             },
             &error) != eConnectionStatusSuccess)
       SetConnection(nullptr);
   }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (SendPacketAndWaitForResponse("qHostInfo", response) ==
               else
                 triple += vendor_name;
               triple += '-';
               if (os_name.empty())
                 triple += "unknown";
               else
                 triple += os_name;
             }
-            m_host_arch.SetTriple(triple.c_str());
+            m_host_arch.SetTriple(triple);
 
             llvm::Triple &host_triple = m_host_arch.GetTriple();
             if (host_triple.getVendor() == llvm::Triple::Apple &&
                 host_triple.getOS() == llvm::Triple::Darwin) {
               switch (m_host_arch.GetMachine()) {
               case llvm::Triple::aarch64:
               case llvm::Triple::aarch64_32:
               case llvm::Triple::arm:
               case llvm::Triple::thumb:
                 host_triple.setOS(llvm::Triple::IOS);
                 break;
               default:
                 host_triple.setOS(llvm::Triple::MacOSX);
                 break;
               }
             }
             if (pointer_byte_size) {
               assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
             }
             if (byte_order != eByteOrderInvalid) {
               assert(byte_order == m_host_arch.GetByteOrder());
             }
           }
         } else {
-          m_host_arch.SetTriple(triple.c_str());
+          m_host_arch.SetTriple(triple);
           if (pointer_byte_size) {
             assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
           }
           if (byte_order != eByteOrderInvalid) {
             assert(byte_order == m_host_arch.GetByteOrder());
           }
 
           LLDB_LOGF(log,
if (SendPacketAndWaitForResponse(packet, response) ==
           if (comma_sep_str == "stack") {
             region_info.SetIsStackMemory(MemoryRegionInfo::eYes);
           }
         } else if (name.equals("error")) {
           StringExtractorGDBRemote error_extractor(value);
           std::string error_string;
           // Now convert the HEX bytes into a string value
           error_extractor.GetHexByteString(error_string);
-          error.SetErrorString(error_string.c_str());
+          error.SetErrorString(error_string);
         } else if (name.equals("dirty-pages")) {
           std::vector<addr_t> dirty_page_list;
           for (llvm::StringRef x : llvm::split(value, ',')) {
             addr_t page;
             x.consume_front("0x");
             if (llvm::to_integer(x, page, 16))
               dirty_page_list.push_back(page);
           }
while (response.GetNameColonValue(name, value)) {
       } else if (name.equals("egid")) {
         uint32_t gid = UINT32_MAX;
         value.getAsInteger(0, gid);
         process_info.SetEffectiveGroupID(gid);
       } else if (name.equals("triple")) {
         StringExtractor extractor(value);
         std::string triple;
         extractor.GetHexByteString(triple);
-        process_info.GetArchitecture().SetTriple(triple.c_str());
+        process_info.GetArchitecture().SetTriple(triple);
       } else if (name.equals("name")) {
         StringExtractor extractor(value);
         // The process name from ASCII hex bytes since we can't control the
         // characters in a process name
         std::string name;
         extractor.GetHexByteString(name);
         process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
       } else if (name.equals("args")) {
if (response.IsNormalResponse()) {
         m_qProcessInfo_is_valid = eLazyBoolYes;
       if (pid != LLDB_INVALID_PROCESS_ID) {
         m_curr_pid_is_valid = eLazyBoolYes;
         m_curr_pid_run = m_curr_pid = pid;
       }
 
       // Set the ArchSpec from the triple if we have it.
       if (!triple.empty()) {
-        m_process_arch.SetTriple(triple.c_str());
+        m_process_arch.SetTriple(triple);
         m_process_arch.SetFlags(elf_abi);
         if (pointer_byte_size) {
           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
         }
       } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() &&
                  !vendor_name.empty()) {
         llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
         if (!environment.empty())
if (name == "uuid" || name == "md5") {
       StringExtractor extractor(value);
       std::string uuid;
       extractor.GetHexByteString(uuid);
       module_spec.GetUUID().SetFromStringRef(uuid);
     } else if (name == "triple") {
       StringExtractor extractor(value);
       std::string triple;
       extractor.GetHexByteString(triple);
-      module_spec.GetArchitecture().SetTriple(triple.c_str());
+      module_spec.GetArchitecture().SetTriple(triple);
     } else if (name == "file_offset") {
       uint64_t ival = 0;
       if (!value.getAsInteger(16, ival))
         module_spec.SetObjectOffset(ival);
     } else if (name == "file_size") {
       uint64_t ival = 0;
       if (!value.getAsInteger(16, ival))
         module_spec.SetObjectSize(ival);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

if (packet.GetChar() == ',') {
       // FIXME: add timeout to qPlatform_shell packet
       // uint32_t timeout = packet.GetHexMaxU32(false, 32);
       if (packet.GetChar() == ',')
         packet.GetHexByteString(working_dir);
       int status, signo;
       std::string output;
       FileSpec working_spec(working_dir);
       FileSystem::Instance().Resolve(working_spec);
-      Status err =
-          Host::RunShellCommand(path.c_str(), working_spec, &status, &signo,
+      Status err = Host::RunShellCommand(path, working_spec, &status, &signo,
                                          &output, std::chrono::seconds(10));
       StreamGDBRemote response;
       if (err.Fail()) {
         response.PutCString("F,");
         response.PutHex32(UINT32_MAX);
       } else {
         response.PutCString("F,");
         response.PutHex32(status);
         response.PutChar(',');
GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
   response.PutChar(';');
 
   const auto &module_arch = matched_module_spec.GetArchitecture();
   response.PutCString("triple:");
   response.PutStringAsRawHex8(module_arch.GetTriple().getTriple());
   response.PutChar(';');
 
   response.PutCString("file_path:");
-  response.PutStringAsRawHex8(
-        matched_module_spec.GetFileSpec().GetPath().c_str());
+  response.PutStringAsRawHex8(matched_module_spec.GetFileSpec().GetPath());
   response.PutChar(';');
   response.PutCString("file_offset:");
   response.PutHex64(file_offset);
   response.PutChar(';');
   response.PutCString("file_size:");
   response.PutHex64(file_size);
   response.PutChar(';');
 

 void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse(
     const ProcessInstanceInfo &proc_info, StreamString &response) {
   response.Printf(
       "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
       proc_info.GetProcessID(), proc_info.GetParentProcessID(),
       proc_info.GetUserID(), proc_info.GetGroupID(),
       proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
   response.PutCString("name:");
-  response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetPath().c_str());
+  response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetPath());
 
   response.PutChar(';');
   response.PutCString("args:");
   response.PutStringAsRawHex8(proc_info.GetArg0());
   for (auto &arg : proc_info.GetArguments()) {
     response.PutChar('-');
     response.PutStringAsRawHex8(arg.ref());
   }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
     StringExtractorGDBRemote &packet) {
   FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
   if (working_dir) {
     StreamString response;
-    response.PutStringAsRawHex8(working_dir.GetPath().c_str());
+    response.PutStringAsRawHex8(working_dir.GetPath());
     return SendPacketNoLock(response.GetString());
   }
 
   return SendErrorResponse(14);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QThreadSuffixSupported(
if (object == "libraries-svr4") {
     auto library_list = m_current_process->GetLoadedSVR4Libraries();
     if (!library_list)
       return library_list.takeError();
 
     StreamString response;
     response.Printf("<library-list-svr4 version=\"1.0\">");
     for (auto const &library : *library_list) {
       response.Printf("<library name=\"%s\" ",
-                      XMLEncodeAttributeValue(library.name.c_str()).c_str());
+                      XMLEncodeAttributeValue(library.name).c_str());
       response.Printf("lm=\"0x%" PRIx64 "\" ", library.link_map);
       response.Printf("l_addr=\"0x%" PRIx64 "\" ", library.base_addr);
       response.Printf("l_ld=\"0x%" PRIx64 "\" />", library.ld_addr);
     }
     response.Printf("</library-list-svr4>");
     return MemoryBuffer::getMemBufferCopy(response.GetString(), __FUNCTION__);
   }
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

GDBRemoteCommunicationServerPlatform::Handle_qPathComplete(
   response.PutChar('M');
   llvm::StringRef separator;
   std::sort(matches.begin(), matches.end());
   for (const auto &match : matches) {
     response << separator;
     separator = ",";
     // encode result strings into hex bytes to avoid unexpected error caused by
     // special characters like '$'.
-    response.PutStringAsRawHex8(match.c_str());
+    response.PutStringAsRawHex8(match);
   }
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir(
     StringExtractorGDBRemote &packet) {

 GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char *prefix) {
   llvm::SmallString<128> socket_path;
   llvm::SmallString<128> socket_name(
       (llvm::StringRef(prefix) + ".%%%%%%").str());
 
   FileSpec socket_path_spec(GetDomainSocketDir());
   socket_path_spec.AppendPathComponent(socket_name.c_str());
 
-  llvm::sys::fs::createUniqueFile(socket_path_spec.GetPath().c_str(),
-                                  socket_path);
+  llvm::sys::fs::createUniqueFile(socket_path_spec.GetPath(), socket_path);
   return FileSpec(socket_path.c_str());
 }
 
 void GDBRemoteCommunicationServerPlatform::SetPortOffset(uint16_t port_offset) {
   m_port_offset = port_offset;
 }
 
 void GDBRemoteCommunicationServerPlatform::SetPendingGdbServer(
     lldb::pid_t pid, uint16_t port, const std::string &socket_name) {
   m_pending_gdb_server.pid = pid;
   m_pending_gdb_server.port = port;
   m_pending_gdb_server.socket_name = socket_name;
 }

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Debugger has no Script Interpreter");
     return;
   }
 
   ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
 
   StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
-      m_scripted_process_info.GetClassName().c_str(), exe_ctx,
+      m_scripted_process_info.GetClassName(), exe_ctx,
       m_scripted_process_info.GetArgsSP());
 
   if (!object_sp || !object_sp->IsValid()) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Failed to create valid script object");
     return;
   }

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (pos != m_oso_map.end()) {
       // Only adopt the architecture from the module (not the vendor or OS)
       // since .o files for "i386-apple-ios" will historically show up as "i386
       // -apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX or
       // LC_VERSION_MIN_IPHONEOS load command...
       oso_arch.SetTriple(m_objfile_sp->GetModule()
                              ->GetArchitecture()
                              .GetTriple()
                              .getArchName()
-                             .str()
-                             .c_str());
+                             .str());
       comp_unit_info->oso_sp->module_sp = std::make_shared<DebugMapModule>(
           obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
           oso_arch, oso_object ? &oso_object : nullptr, 0,
           oso_object ? comp_unit_info->oso_mod_time : llvm::sys::TimePoint<>());
 
       if (!comp_unit_info->oso_sp->module_sp || !comp_unit_info->oso_sp->module_sp->GetObjectFile()) {
         if (oso_object && FileSystem::Instance().Exists(oso_file)) {
           // If we are loading a .o file from a .a file the "oso_object" will

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

PDBASTParser::AddRecordMethod(lldb_private::SymbolFile &symbol_file,
   }
 
   AccessType access = TranslateMemberAccess(method.getAccess());
   if (access == eAccessNone)
     access = eAccessPublic;
 
   // TODO: get mangled name for the method.
   return m_ast.AddMethodToCXXRecordType(
-      record_type.GetOpaqueQualType(), name.c_str(),
+      record_type.GetOpaqueQualType(), name,
       /*mangled_name*/ nullptr, method_comp_type, access, method.isVirtual(),
       method.isStatic(), method.hasInlineAttribute(),
       /*is_explicit*/ false, // FIXME: Need this field in CodeView.
       /*is_attr_used*/ false,
       /*is_artificial*/ method.isCompilerGenerated());
 }

lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

if (dsym_fspec) {
                               // With version 2 of DBGSourcePathRemapping, we
                               // can chop off the last two filename parts
                               // from the source remapping and get a more
                               // general source remapping that still works.
                               // Add this as another option in addition to
                               // the full source path remap.
                               if (do_truncate_remapping_names) {
                                 FileSpec build_path(key.AsCString());
-                                FileSpec source_path(DBGSourcePath.c_str());
+                                FileSpec source_path(DBGSourcePath);
                                 build_path.RemoveLastPathComponent();
                                 build_path.RemoveLastPathComponent();
                                 source_path.RemoveLastPathComponent();
                                 source_path.RemoveLastPathComponent();
                                 module_sp->GetSourceMappingList().Append(
                                     build_path.GetPath(), source_path.GetPath(),
                                     true);
                               }

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/PDB/PDBASTParser.h"
 #include "Plugins/SymbolFile/NativePDB/PdbAstBuilder.h"
 
 #include <cstdio>
 
-#include <mutex>
-
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::dwarf;
 using namespace clang;
 using llvm::StringSwitch;
 
 LLDB_PLUGIN_DEFINE(TypeSystemClang)
 

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

private:
   // Call CreateInstance to get an instance of this class
   UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch,
                               lldb_private::EmulateInstruction *inst_emulator)
       : UnwindAssembly(arch), m_inst_emulator_up(inst_emulator),
         m_range_ptr(nullptr), m_unwind_plan_ptr(nullptr), m_curr_row(),
         m_initial_sp(0), m_cfa_reg_info(), m_fp_is_cfa(false),
         m_register_values(), m_pushed_regs(), m_curr_row_modified(false),
         m_forward_branch_offset(0) {
-    if (m_inst_emulator_up.get()) {
+    if (m_inst_emulator_up) {
       m_inst_emulator_up->SetBaton(this);
       m_inst_emulator_up->SetCallbacks(ReadMemory, WriteMemory, ReadRegister,
                                        WriteRegister);
     }
   }
 
   static size_t
   ReadMemory(lldb_private::EmulateInstruction *instruction, void *baton,

lldb/source/Symbol/LocateSymbolFileMacOSX.cpp

if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
         error.SetErrorString(str);
       }
     }
 
     cf_str = (CFStringRef)CFDictionaryGetValue(
         (CFDictionaryRef)uuid_dict, CFSTR("DBGSymbolRichExecutable"));
     if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
       if (CFCString::FileSystemRepresentation(cf_str, str)) {
-        module_spec.GetFileSpec().SetFile(str.c_str(), FileSpec::Style::native);
+        module_spec.GetFileSpec().SetFile(str, FileSpec::Style::native);
         FileSystem::Instance().Resolve(module_spec.GetFileSpec());
         LLDB_LOGF(log,
                   "From dsymForUUID plist: Symbol rich executable is at '%s'",
                   str.c_str());
       }
     }
 
     cf_str = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)uuid_dict,
                                                CFSTR("DBGDSYMPath"));
     if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
       if (CFCString::FileSystemRepresentation(cf_str, str)) {
-        module_spec.GetSymbolFileSpec().SetFile(str.c_str(),
-                                                FileSpec::Style::native);
+        module_spec.GetSymbolFileSpec().SetFile(str, FileSpec::Style::native);
         FileSystem::Instance().Resolve(module_spec.GetFileSpec());
         success = true;
         LLDB_LOGF(log, "From dsymForUUID plist: dSYM is at '%s'", str.c_str());
       }
     }
 
     std::string DBGBuildSourcePath;
     std::string DBGSourcePath;
if (cf_dict && CFGetTypeID(cf_dict) == CFDictionaryGetTypeID()) {
             // DBGSourcePath values (the "values" half of key-value path pairs)
             // were wrong.  Ignore them and use the universal DBGSourcePath
             // string from earlier.
             if (new_style_source_remapping_dictionary &&
                 !original_DBGSourcePath_value.empty()) {
               DBGSourcePath = original_DBGSourcePath_value;
             }
             if (DBGSourcePath[0] == '~') {
-              FileSpec resolved_source_path(DBGSourcePath.c_str());
+              FileSpec resolved_source_path(DBGSourcePath);
               FileSystem::Instance().Resolve(resolved_source_path);
               DBGSourcePath = resolved_source_path.GetPath();
             }
             // With version 2 of DBGSourcePathRemapping, we can chop off the
             // last two filename parts from the source remapping and get a more
             // general source remapping that still works. Add this as another
             // option in addition to the full source path remap.
             module_spec.GetSourceMappingList().Append(DBGBuildSourcePath,
                                                       DBGSourcePath, true);
             if (do_truncate_remapping_names) {
-              FileSpec build_path(DBGBuildSourcePath.c_str());
-              FileSpec source_path(DBGSourcePath.c_str());
+              FileSpec build_path(DBGBuildSourcePath);
+              FileSpec source_path(DBGSourcePath);
               build_path.RemoveLastPathComponent();
               build_path.RemoveLastPathComponent();
               source_path.RemoveLastPathComponent();
               source_path.RemoveLastPathComponent();
               module_spec.GetSourceMappingList().Append(
                   build_path.GetPath(), source_path.GetPath(), true);
             }
           }
if (uuid_dict != NULL && CFGetTypeID(uuid_dict) == CFDictionaryGetTypeID()) {
     cf_str = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)uuid_dict,
                                                CFSTR("DBGSourcePath"));
     if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
       CFCString::FileSystemRepresentation(cf_str, DBGSourcePath);
     }
 
     if (!DBGBuildSourcePath.empty() && !DBGSourcePath.empty()) {
       if (DBGSourcePath[0] == '~') {
-        FileSpec resolved_source_path(DBGSourcePath.c_str());
+        FileSpec resolved_source_path(DBGSourcePath);
         FileSystem::Instance().Resolve(resolved_source_path);
         DBGSourcePath = resolved_source_path.GetPath();
       }
       module_spec.GetSourceMappingList().Append(DBGBuildSourcePath,
                                                 DBGSourcePath, true);
     }
   }
   return success;

lldb/source/Symbol/SymbolFile.cpp

 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-private.h"
 
 #include <future>
+#include <utility>
 
 using namespace lldb_private;
 using namespace lldb;
 
 char SymbolFile::ID;
 char SymbolFileCommon::ID;
 
 void SymbolFile::PreloadSymbols() {
for (uint32_t idx = 0;
               idx)) != nullptr;
          ++idx) {
       std::unique_ptr<SymbolFile> curr_symfile_up(create_callback(objfile_sp));
 
       if (curr_symfile_up) {
         const uint32_t sym_file_abilities = curr_symfile_up->GetAbilities();
         if (sym_file_abilities > best_symfile_abilities) {
           best_symfile_abilities = sym_file_abilities;
-          best_symfile_up.reset(curr_symfile_up.release());
+          best_symfile_up = std::move(curr_symfile_up);
           // If any symbol file parser has all of the abilities, then we should
           // just stop looking.
           if ((kAllAbilities & sym_file_abilities) == kAllAbilities)
             break;
         }
       }
     }
     if (best_symfile_up) {

lldb/source/Target/LanguageRuntime.cpp

if (LanguageRuntimeGetCommandObject command_callback =
             PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(idx)) {
       CommandObjectSP command =
           command_callback(parent->GetCommandInterpreter());
       if (command) {
         // the CommandObject vended by a Language plugin cannot be created once
         // and cached because we may create multiple debuggers and need one
         // instance of the command each - the implementing function is meant to
         // create a new instance of the command each time it is invoked.
-        parent->LoadSubCommand(command->GetCommandName().str().c_str(), command);
+        parent->LoadSubCommand(command->GetCommandName().str(), command);
       }
     }
   }
 }

lldb/source/Target/TargetList.cpp

Status TargetList::CreateTargetInternal(Debugger &debugger,
   // bundle that was resolved and we need to use the resolved bundle path
   if (!user_exe_path.empty()) {
     // Use exactly what the user typed as the first argument when we exec or
     // posix_spawn
     if (user_exe_path_is_bundle && resolved_bundle_exe_path[0]) {
       target_sp->SetArg0(resolved_bundle_exe_path);
     } else {
       // Use resolved path
-      target_sp->SetArg0(file.GetPath().c_str());
+      target_sp->SetArg0(file.GetPath());
     }
   }
   if (file.GetDirectory()) {
     FileSpec file_dir;
     file_dir.SetDirectory(file.GetDirectory());
     target_sp->AppendExecutableSearchPaths(file_dir);
   }
 

lldb/source/Target/Thread.cpp

ThreadPlanStack &Thread::GetPlans() const {
   // History threads don't have a thread plan, but they do ask get asked to
   // describe themselves, which usually involves pulling out the stop reason.
   // That in turn will check for a completed plan on the ThreadPlanStack.
   // Instead of special-casing at that point, we return a Stack with a
   // ThreadPlanNull as its base plan.  That will give the right answers to the
   // queries GetDescription makes, and only assert if you try to run the thread.
   if (!m_null_plan_stack_up)
     m_null_plan_stack_up = std::make_unique<ThreadPlanStack>(*this, true);
-  return *(m_null_plan_stack_up.get());
+  return *(m_null_plan_stack_up);
 }
 
 void Thread::PushPlan(ThreadPlanSP thread_plan_sp) {
   assert(thread_plan_sp && "Don't push an empty thread plan.");
 
   Log *log = GetLog(LLDBLog::Step);
   if (log) {
     StreamString s;

lldb/source/Target/ThreadPlanPython.cpp

 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
-#include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanPython.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/source/Target/ThreadPlanStack.cpp

void ThreadPlanStackMap::Update(ThreadList &current_threads,
                                 bool check_for_new) {
 
   std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   // Now find all the new threads and add them to the map:
   if (check_for_new) {
     for (auto thread : current_threads.Threads()) {
       lldb::tid_t cur_tid = thread->GetID();
       if (!Find(cur_tid)) {
-        AddThread(*thread.get());
+        AddThread(*thread);
         thread->QueueBasePlan(true);
       }
     }
   }
 
   // If we aren't reaping missing threads at this point,
   // we are done.
   if (!delete_missing)

lldb/tools/debugserver/source/DNBTimer.h

DNBTimer &operator=(const DNBTimer &rhs) {
     if (rhs.IsThreadSafe())
       m_mutexAP.reset(new PThreadMutex(PTHREAD_MUTEX_RECURSIVE));
     m_timeval = rhs.m_timeval;
     return *this;
   }
 
   ~DNBTimer() {}
 
-  bool IsThreadSafe() const { return m_mutexAP.get() != NULL; }
+  bool IsThreadSafe() const { return m_mutexAP != NULL; }
   // Reset the time value to now
   void Reset() {
     PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
     gettimeofday(&m_timeval, NULL);
   }
   // Get the total microseconds since Jan 1, 1970
   uint64_t TotalMicroSeconds() const {
     PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());

lldb/tools/debugserver/source/RNBRemote.cpp

 #endif
 
 #include "DNB.h"
 #include "DNBDataRef.h"
 #include "DNBLog.h"
 #include "DNBThreadResumeActions.h"
 #include "JSON.h"
 #include "JSONGenerator.h"
-#include "JSONGenerator.h"
 #include "MacOSX/Genealogy.h"
 #include "OsLogger.h"
 #include "RNBContext.h"
 #include "RNBServices.h"
 #include "RNBSocket.h"
 #include "StdStringExtractor.h"
 
 #include <compression.h>
bool RNBRemote::InitializeRegisters(bool force) {
   return true;
 }
 
 /* The inferior has stopped executing; send a packet
  to gdb to let it know.  */
 
 void RNBRemote::NotifyThatProcessStopped(void) {
   RNBRemote::HandlePacket_last_signal(NULL);
-  return;
 }
 
 /* 'A arglen,argnum,arg,...'
  Update the inferior context CTX with the program name and arg
  list.
  The documentation for this packet is underwhelming but my best reading
  of this is that it is a series of (len, position #, arg)'s, one for
  each argument with "arg" hex encoded (two 0-9a-f chars?).
if (strcmp(p, "vCont;c") == 0) {
 
     if (attach_pid == INVALID_NUB_PROCESS_ARCH) {
       DNBLogError("debugserver is x86_64 binary running in translation, attach "
                   "failed.");
       std::string return_message = "E96;";
       return_message +=
           cstring_to_asciihex_string("debugserver is x86_64 binary running in "
                                      "translation, attach failed.");
-      SendPacket(return_message.c_str());
+      SendPacket(return_message);
       return rnb_err;
     }
 
     if (attach_pid != INVALID_NUB_PROCESS) {
       if (m_ctx.ProcessID() != attach_pid)
         m_ctx.SetProcessID(attach_pid);
       DNBLog("Successfully attached to pid %d", attach_pid);
       // Send a stop reply packet to indicate we successfully attached!
if (sep) {
                   // Retrieving target XML in chunks
                   if (offset < g_target_xml.size()) {
                     std::string chunk(g_target_xml, offset, length);
                     if (chunk.size() < length)
                       xml_out << 'l'; // No more data
                     else
                       xml_out << 'm'; // More data needs to be read with a
                                       // subsequent call
-                    xml_out << binary_encode_string(chunk.data());
+                    xml_out << binary_encode_string(chunk);
                   }
                 }
                 return SendPacket(xml_out.str());
               }
               // Well formed, put not supported
               return HandlePacket_UNIMPLEMENTED(command);
             }
           }

lldb/tools/lldb-vscode/BreakpointBase.cpp

if (messagePart.is_expr) {
       if (expr_val)
         output += expr_val;
     } else {
       output += messagePart.text;
     }
   }
   if (!output.empty() && output.back() != '\n')
     output.push_back('\n'); // Ensure log message has line break.
-  g_vsc.SendOutput(OutputType::Console, output.c_str());
+  g_vsc.SendOutput(OutputType::Console, output);
 
   // Do not stop.
   return false;
 }
 
 void BreakpointBase::UpdateBreakpoint(const BreakpointBase &request_bp) {
   if (condition != request_bp.condition) {
     condition = request_bp.condition;

llvm/include/llvm/Analysis/RegionInfoImpl.h

void RegionInfoBase<Tr>::print(raw_ostream &OS) const {
   OS << "End region tree\n";
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 template <class Tr>
 void RegionInfoBase<Tr>::dump() const { print(dbgs()); }
 #endif
 
-template <class Tr>
-void RegionInfoBase<Tr>::releaseMemory() {
+template <class Tr> void RegionInfoBase<Tr>::releaseMemory() {
   BBtoRegion.clear();
-  if (TopLevelRegion)
+  if (TopLevelRegion) {
     delete TopLevelRegion;
     TopLevelRegion = nullptr;
   }
+}
 
 template <class Tr>
 void RegionInfoBase<Tr>::verifyAnalysis() const {
   // Do only verify regions if explicitely activated using EXPENSIVE_CHECKS or
   // -verify-region-info
   if (!RegionInfoBase<Tr>::VerifyRegionInfo)
     return;
 

llvm/include/llvm/MC/MCContext.h

private:
   /// catch errors if .secure_log_unique appears twice without
   /// .secure_log_reset appearing between them.
   bool SecureLogUsed = false;
 
   /// The compilation directory to use for DW_AT_comp_dir.
   SmallString<128> CompilationDir;
 
   /// Prefix replacement map for source file information.
-  std::map<std::string, const std::string, std::greater<std::string>>
-      DebugPrefixMap;
+  std::map<std::string, const std::string, std::greater<>> DebugPrefixMap;
 
   /// The main file name if passed in explicitly.
   std::string MainFileName;
 
   /// The dwarf file and directory tables from the dwarf .file directive.
   /// We now emit a line table for each compile unit. To reduce the prologue
   /// size of each line table, the files and directories used by each compile
   /// unit are separated.

llvm/include/llvm/ProfileData/InstrProfReader.h

public:
 
   /// Read the header.
   Error readHeader() override;
 
   /// Read a single record.
   Error readNextRecord(NamedInstrProfRecord &Record) override;
 
   InstrProfSymtab &getSymtab() override {
-    assert(Symtab.get());
-    return *Symtab.get();
+    assert(Symtab);
+    return *Symtab;
   }
 };
 
 /// Reader for the raw instrprof binary format from runtime.
 ///
 /// This format is a raw memory dump of the instrumentation-based profiling data
 /// from the runtime.  It has no index.
 ///
public:
   // the client is the compiler.
   InstrProfSymtab &getSymtab() override;
 
   /// Return the profile summary.
   /// \c UseCS indicates whether to use the context-sensitive summary.
   ProfileSummary &getSummary(bool UseCS) {
     if (UseCS) {
       assert(CS_Summary && "No context sensitive summary");
-      return *(CS_Summary.get());
+      return *CS_Summary;
     } else {
       assert(Summary && "No profile summary");
-      return *(Summary.get());
+      return *Summary;
     }
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFREADER_H

llvm/include/llvm/Support/YAMLParser.h

if (!(*Doc)->skip()) {
       Doc->reset(nullptr);
     } else {
       Stream &S = (*Doc)->stream;
       Doc->reset(new Document(S));
     }
     return *this;
   }
 
-  Document &operator*() { return *Doc->get(); }
+  Document &operator*() { return **Doc; }
 
   std::unique_ptr<Document> &operator->() { return *Doc; }
 
 private:
   bool isAtEnd() const { return !Doc || !*Doc; }
 
   std::unique_ptr<Document> *Doc = nullptr;
 };
 
 } // end namespace yaml
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_YAMLPARSER_H

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
   // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
   // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   return Error::success();
 }
 
 bool DWARFUnit::parseDWO(StringRef DWOAlternativeLocation) {
   if (IsDWO)
     return false;
-  if (DWO.get())
+  if (DWO)
     return false;
   DWARFDie UnitDie = getUnitDIE();
   if (!UnitDie)
     return false;
   auto DWOFileName = getVersion() >= 5
                          ? dwarf::toString(UnitDie.find(DW_AT_dwo_name))
                          : dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name));
   if (!DWOFileName)

llvm/lib/DebugInfo/LogicalView/Core/LVElement.cpp

void LVElement::resolveFullname(LVElement *BaseType, StringRef Name) {
   }
 
   // For a better and consistent layout, check if the generated name
   // contains double space sequences.
   assert((Fullname.find("  ", 0) == std::string::npos) &&
          "Extra double spaces in name.");
 
   LLVM_DEBUG({ dbgs() << "Fullname = '" << Fullname << "'\n"; });
-  setName(Fullname.c_str());
+  setName(Fullname);
 }
 
 void LVElement::setFile(LVElement *Reference) {
   if (!options().getAttributeAnySource())
     return;
 
   // At this point, any existing reference to another element, have been
   // resolved and the file ID extracted from the DI entry.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

void LVScope::resolveTemplate() {
   // Check if we need to encode the template arguments.
   if (options().getAttributeEncoded()) {
     LVTypes Params;
     if (getTemplateParameterTypes(Params)) {
       std::string EncodedArgs;
       // Encode the arguments as part of the template name and update the
       // template name, to reflect the encoded parameters.
       encodeTemplateArguments(EncodedArgs, &Params);
-      setEncodedArgs(EncodedArgs.c_str());
+      setEncodedArgs(EncodedArgs);
     }
   }
 }
 
 // Get the qualified name for the template.
 void LVScope::getQualifiedName(std::string &QualifiedName) const {
   if (getIsRoot() || getIsCompileUnit())
     return;
for (LVSymbol *Symbol : *Symbols)
         Name.append(std::string(Symbol->getTypeName()));
         AddComma = true;
       }
   }
 
   Name.append(")");
 
   // Update the scope name, to reflect the encoded parameters.
-  setName(Name.c_str());
+  setName(Name);
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF namespace (DW_TAG_namespace).
 //===----------------------------------------------------------------------===//
 bool LVScopeNamespace::equals(const LVScope *Scope) const {
   if (!LVScope::equals(Scope))
     return false;

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

case MCDisassembler::Fail:
       break;
     case MCDisassembler::SoftFail:
       LLVM_DEBUG({ dbgs() << "Potentially undefined instruction:"; });
       LLVM_FALLTHROUGH;
     case MCDisassembler::Success: {
       std::string Buffer;
       raw_string_ostream Stream(Buffer);
       StringRef AnnotationsStr = Annotations.str();
-      MIP.get()->printInst(&Instruction, Address, AnnotationsStr, *STI, Stream);
+      MIP->printInst(&Instruction, Address, AnnotationsStr, *STI, Stream);
       LLVM_DEBUG({
         std::string BufferCodes;
         raw_string_ostream StreamCodes(BufferCodes);
         StreamCodes << format_bytes(
             ArrayRef<uint8_t>(Begin, Begin + BytesConsumed), std::nullopt, 16,
             16);
         dbgs() << "[" << hexValue((uint64_t)Begin) << "] "
                << "Size: " << format_decimal(BytesConsumed, 2) << " ("

llvm/lib/ObjCopy/MachO/MachOObjcopy.cpp

auto FoundSec = llvm::find_if(FoundSeg->Sections,
                                   return Sec->Sectname == SecName;
                                 });
   if (FoundSec == FoundSeg->Sections.end())
     return createStringError(errc::invalid_argument,
                              "could not find section with name '%s'",
                              SecName.str().c_str());
 
   assert(FoundSec->get()->CanonicalName == (SegName + "," + SecName).str());
-  return *FoundSec->get();
+  return **FoundSec;
 }
 
 static Error updateSection(const NewSectionInfo &NewSection, Object &O) {
   Expected<Section &> SecToUpdateOrErr = findSection(NewSection.SectionName, O);
 
   if (!SecToUpdateOrErr)
     return SecToUpdateOrErr.takeError();
   Section &Sec = *SecToUpdateOrErr;

llvm/lib/Target/BPF/BTFDebug.cpp

if (!DL || PrevInstLoc == DL) {
     return;
   }
 
   // Create a temporary label to remember the insn for lineinfo.
   MCSymbol *LineSym = OS.getContext().createTempSymbol();
   OS.emitLabel(LineSym);
 
   // Construct the lineinfo.
-  auto SP = DL.get()->getScope()->getSubprogram();
+  auto SP = DL->getScope()->getSubprogram();
   constructLineInfo(SP, LineSym, DL.getLine(), DL.getCol());
 
   LineInfoGenerated = true;
   PrevInstLoc = DL;
 }
 
 void BTFDebug::processGlobals(bool ProcessingMapDef) {
   // Collect all types referenced by globals.

llvm/tools/dsymutil/BinaryHolder.cpp

BinaryHolder::ArchiveEntry::getObjectEntry(StringRef Filename,
   StringRef ArchiveFilename;
   StringRef ObjectFilename;
   std::tie(ArchiveFilename, ObjectFilename) = getArchiveAndObjectName(Filename);
   KeyTy Key = {ObjectFilename, Timestamp};
 
   // Try the cache first.
   std::lock_guard<std::mutex> Lock(MemberCacheMutex);
   if (MemberCache.count(Key))
-    return *MemberCache[Key].get();
+    return *MemberCache[Key];
 
   // Create a new ObjectEntry, but don't add it to the cache yet. Loading of
   // the archive members might fail and we don't want to lock the whole archive
   // during this operation.
   auto OE = std::make_unique<ObjectEntry>();
 
   for (const auto &Archive : Archives) {
     Error Err = Error::success();

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

for (const auto &Branch : Graph.ConditionalBranchNodes) {
     }
   }
 
   return Graph.BaseAddress;
 }
 
 void FileAnalysis::printInstruction(const Instr &InstrMeta,
                                     raw_ostream &OS) const {
-  Printer->printInst(&InstrMeta.Instruction, 0, "", *SubtargetInfo.get(), OS);
+  Printer->printInst(&InstrMeta.Instruction, 0, "", *SubtargetInfo, OS);
 }
 
 Error FileAnalysis::initialiseDisassemblyMembers() {
   std::string TripleName = ObjectTriple.getTriple();
   ArchName = "";
   MCPU = "";
   std::string ErrorString;
 

llvm/tools/llvm-cov/CodeCoverage.cpp

int CodeCoverageTool::doShow(int argc, const char **argv,
   }
 
   if (!Filters.empty()) {
     // Build the map of filenames to functions.
     std::map<llvm::StringRef, std::vector<const FunctionRecord *>>
         FilenameFunctionMap;
     for (const auto &SourceFile : SourceFiles)
       for (const auto &Function : Coverage->getCoveredFunctions(SourceFile))
-        if (Filters.matches(*Coverage.get(), Function))
+        if (Filters.matches(*Coverage, Function))
           FilenameFunctionMap[SourceFile].push_back(&Function);
 
     // Only print filter matching functions for each file.
     for (const auto &FileFunc : FilenameFunctionMap) {
       StringRef File = FileFunc.first;
       const auto &Functions = FileFunc.second;
 
       auto OSOrErr = Printer->createViewFile(File, /*InToplevel=*/false);
if (std::error_code EC = sys::fs::status(PGOFilename, Status)) {
     error("Could not read profile data!" + EC.message(), PGOFilename);
     return 1;
   }
 
   auto Coverage = load();
   if (!Coverage)
     return 1;
 
-  CoverageReport Report(ViewOpts, *Coverage.get());
+  CoverageReport Report(ViewOpts, *Coverage);
   if (!ShowFunctionSummaries) {
     if (SourceFiles.empty())
       Report.renderFileReports(llvm::outs(), IgnoreFilenameFilters);
     else
       Report.renderFileReports(llvm::outs(), SourceFiles);
   } else {
     if (SourceFiles.empty()) {
       error("Source files must be specified when -show-functions=true is "
if (!Coverage) {
     error("Could not load coverage information");
     return 1;
   }
 
   std::unique_ptr<CoverageExporter> Exporter;
 
   switch (ViewOpts.Format) {
   case CoverageViewOptions::OutputFormat::Text:
-    Exporter = std::make_unique<CoverageExporterJson>(*Coverage.get(),
-                                                       ViewOpts, outs());
+    Exporter =
+        std::make_unique<CoverageExporterJson>(*Coverage, ViewOpts, outs());
     break;
   case CoverageViewOptions::OutputFormat::HTML:
     // Unreachable because we should have gracefully terminated with an error
     // above.
     llvm_unreachable("Export in HTML is not supported!");
   case CoverageViewOptions::OutputFormat::Lcov:
-    Exporter = std::make_unique<CoverageExporterLcov>(*Coverage.get(),
-                                                       ViewOpts, outs());
+    Exporter =
+        std::make_unique<CoverageExporterLcov>(*Coverage, ViewOpts, outs());
     break;
   }
 
   if (SourceFiles.empty())
     Exporter->renderRoot(IgnoreFilenameFilters);
   else
     Exporter->renderRoot(SourceFiles);
 

llvm/tools/llvm-pdbutil/PrettyClassLayoutGraphicalDumper.cpp

 //===- PrettyClassLayoutGraphicalDumper.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 "PrettyClassLayoutGraphicalDumper.h"
 
 #include "PrettyClassDefinitionDumper.h"
 #include "PrettyEnumDumper.h"
 #include "PrettyFunctionDumper.h"
 #include "PrettyTypedefDumper.h"
 #include "PrettyVariableDumper.h"
-#include "PrettyVariableDumper.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
 #include "llvm/DebugInfo/PDB/UDTLayout.h"

llvm/tools/obj2yaml/elf2yaml.cpp

std::unique_ptr<ELFYAML::SectionHeaderTable> SHT =
         std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/false);
     SHT->Sections.emplace();
     for (ELFYAML::Section *S : OriginalOrder)
       SHT->Sections->push_back({S->Name});
     Chunks.push_back(std::move(SHT));
   }
 
   llvm::erase_if(Chunks, [this, &Y](const std::unique_ptr<ELFYAML::Chunk> &C) {
-    if (isa<ELFYAML::SectionHeaderTable>(*C.get()))
+    if (isa<ELFYAML::SectionHeaderTable>(*C))
       return false;
 
-    const ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
+    const ELFYAML::Section &S = cast<ELFYAML::Section>(*C);
     return !shouldPrintSection(S, Sections[S.OriginalSecNdx], Y->DWARF);
   });
 
   // The section header string table by default is assumed to be called
   // ".shstrtab" and be in its own unique section. However, it's possible for it
   // to be called something else and shared with another section. If the name
   // isn't the default, provide this in the YAML.
   if (ShStrTabIndex && *ShStrTabIndex != ELF::SHN_UNDEF &&
for (const typename ELFT::Phdr &Phdr : *PhdrsOrErr) {
     // We do not print the default alignment to reduce noise in the output.
     if (Phdr.p_align != 1)
       PH.Align = static_cast<llvm::yaml::Hex64>(Phdr.p_align);
 
     // Here we match sections with segments.
     // It is not possible to have a non-Section chunk, because
     // obj2yaml does not create Fill chunks.
     for (const std::unique_ptr<ELFYAML::Chunk> &C : Chunks) {
-      ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
+      ELFYAML::Section &S = cast<ELFYAML::Section>(*C);
       if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr)) {
         if (!PH.FirstSec)
           PH.FirstSec = S.Name;
         PH.LastSec = S.Name;
         PH.Chunks.push_back(C.get());
       }
     }
 
if (ELFYAML::RawContentSection *RawSec =
       // name, which defeats this attempt to skip reading a section header
       // string table with the same name as a DWARF section.
       if (ShStrTabIndex && RawSec->OriginalSecNdx == *ShStrTabIndex)
         continue;
       Error Err = Error::success();
       cantFail(std::move(Err));
 
       if (RawSec->Name == ".debug_aranges")
-        Err = dumpDebugARanges(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugARanges(*DWARFCtx, DWARF);
       else if (RawSec->Name == ".debug_str")
-        Err = dumpDebugStrings(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugStrings(*DWARFCtx, DWARF);
       else if (RawSec->Name == ".debug_ranges")
-        Err = dumpDebugRanges(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugRanges(*DWARFCtx, DWARF);
       else if (RawSec->Name == ".debug_addr")
-        Err = dumpDebugAddr(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugAddr(*DWARFCtx, DWARF);
       else
         continue;
 
       // If the DWARF section cannot be successfully parsed, emit raw content
       // instead of an entry in the DWARF section of the YAML.
       if (Err)
         consumeError(std::move(Err));
       else

llvm/tools/obj2yaml/macho2yaml.cpp

if (Expected<MachOYAML::Section> S =
       if ((RawSegment & ::RawSegments::data) &&
           StringRef(S->segname).startswith("__DATA"))
         S->content =
             yaml::BinaryRef(Obj.getSectionContents(Sec.offset, Sec.size));
 
       if (SecName.startswith("__debug_")) {
         // If the DWARF section cannot be successfully parsed, emit raw content
         // instead of an entry in the DWARF section of the YAML.
-        if (Error Err = dumpDebugSection(SecName, *DWARFCtx.get(), Y.DWARF))
+        if (Error Err = dumpDebugSection(SecName, *DWARFCtx, Y.DWARF))
           consumeError(std::move(Err));
         else
           S->content.reset();
       }
       Sections.push_back(std::move(*S));
     } else
       return S.takeError();
   }
for (auto LoadCmd : Obj.load_commands()) {
     const char *EndPtr = LoadCmd.Ptr;
     switch (LoadCmd.C.cmd) {
     default:
       memcpy((void *)&(LC.Data.load_command_data), LoadCmd.Ptr,
              sizeof(MachO::load_command));
       if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
         MachO::swapStruct(LC.Data.load_command_data);
       if (Expected<const char *> ExpectedEndPtr =
-              processLoadCommandData<MachO::load_command>(LC, LoadCmd,
-                                                          *Y.get()))
+              processLoadCommandData<MachO::load_command>(LC, LoadCmd, *Y))
         EndPtr = *ExpectedEndPtr;
       else
         return ExpectedEndPtr.takeError();
       break;
 #include "llvm/BinaryFormat/MachO.def"
     }
     auto RemainingBytes = LoadCmd.C.cmdsize - (EndPtr - LoadCmd.Ptr);
     if (!std::all_of(EndPtr, &EndPtr[RemainingBytes],