Fix Clang-tidy readability-redundant-string-cstr warnings

[zturner]

Nice improvement. I assume you ran the test suite and everything passed?

[malcolm.parsons]

In D26233#586005, @zturner wrote:

Nice improvement. I assume you ran the test suite and everything passed?

I think a change like this would fail to compile if it was wrong.

check-lldb passed:

Issue Details

UNEXPECTED SUCCESS: test_continue_in_watchpoint_command_dwarf (functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py)
UNEXPECTED SUCCESS: test_continue_in_watchpoint_command_dwo (functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py)
UNEXPECTED SUCCESS: test_dwarf (functionalities/thread/exit_during_break/TestExitDuringBreak.py)
UNEXPECTED SUCCESS: test_dwo (functionalities/thread/exit_during_break/TestExitDuringBreak.py)
UNEXPECTED SUCCESS: test_sb_api_listener_resume_dwarf (api/multithreaded/TestMultithreaded.py)
UNEXPECTED SUCCESS: test_sb_api_listener_resume_dwo (api/multithreaded/TestMultithreaded.py)
UNEXPECTED SUCCESS: test_with_dwarf (lang/cpp/printf/TestPrintf.py)
UNEXPECTED SUCCESS: test_with_dwo (lang/cpp/printf/TestPrintf.py)

Test Result Summary

Test Methods: 1868
Reruns: 0
Success: 1099
Expected Failure: 116
Failure: 0
Error: 0
Exceptional Exit: 0
Unexpected Success: 8
Skip: 645
Timeout: 0
Expected Timeout: 0
[100%] Built target check-lldb

[labath]

nice

lldb/trunk/source/Breakpoint/BreakpointResolverAddress.cpp

BreakpointResolver *BreakpointResolverAddress::CreateFromStructuredData(
   success = options_dict.HasKey(GetKey(OptionNames::ModuleName));
   if (success) {
     success = options_dict.GetValueForKeyAsString(
         GetKey(OptionNames::ModuleName), module_name);
     if (!success) {
       error.SetErrorString("BRA::CFSD: Couldn't read module name entry.");
       return nullptr;
     }
-    module_filespec.SetFile(module_name.c_str(), false);
+    module_filespec.SetFile(module_name, false);
   }
   return new BreakpointResolverAddress(bkpt, address, module_filespec);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverAddress::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());

lldb/trunk/source/Breakpoint/BreakpointResolverFileLine.cpp

BreakpointResolver *BreakpointResolverFileLine::CreateFromStructuredData(
 
   success = options_dict.GetValueForKeyAsBoolean(
       GetKey(OptionNames::ExactMatch), exact_match);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find exact match entry.");
     return nullptr;
   }
 
-  FileSpec file_spec(filename.c_str(), false);
+  FileSpec file_spec(filename, false);
 
   return new BreakpointResolverFileLine(bkpt, file_spec, line_no, offset,
                                         check_inlines, skip_prologue,
                                         exact_match);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverFileLine::SerializeToStructuredData() {

lldb/trunk/source/Commands/CommandCompletions.cpp

 CommandCompletions::SourceFileCompleter::SourceFileCompleter(
     CommandInterpreter &interpreter, bool include_support_files,
     const char *completion_str, int match_start_point, int max_return_elements,
     StringList &matches)
     : CommandCompletions::Completer(interpreter, completion_str,
                                     match_start_point, max_return_elements,
                                     matches),
       m_include_support_files(include_support_files), m_matching_files() {
-  FileSpec partial_spec(m_completion_str.c_str(), false);
+  FileSpec partial_spec(m_completion_str, false);
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 Searcher::Depth CommandCompletions::SourceFileCompleter::GetDepth() {
   return eDepthCompUnit;
 }
 

 // ModuleCompleter
 //----------------------------------------------------------------------
 CommandCompletions::ModuleCompleter::ModuleCompleter(
     CommandInterpreter &interpreter, const char *completion_str,
     int match_start_point, int max_return_elements, StringList &matches)
     : CommandCompletions::Completer(interpreter, completion_str,
                                     match_start_point, max_return_elements,
                                     matches) {
-  FileSpec partial_spec(m_completion_str.c_str(), false);
+  FileSpec partial_spec(m_completion_str, false);
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 Searcher::Depth CommandCompletions::ModuleCompleter::GetDepth() {
   return eDepthModule;
 }
 

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

if (!command.empty()) {
           command, target, result, &valid_bp_ids);
 
       if (!result.Succeeded()) {
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
     Error error = target->SerializeBreakpointsToFile(
-        FileSpec(m_options.m_filename.c_str(), true), valid_bp_ids,
-        m_options.m_append);
+        FileSpec(m_options.m_filename, true), valid_bp_ids, m_options.m_append);
     if (!error.Success()) {
       result.AppendErrorWithFormat("error serializing breakpoints: %s.",
                                    error.AsCString());
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 

lldb/trunk/source/Commands/CommandObjectCommands.cpp

if (pos == 0) {
         raw_command_string = raw_command_string.substr(pos);
     } else {
       result.AppendError("Error parsing command string.  No alias created.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // Verify that the command is alias-able.
-    if (m_interpreter.CommandExists(alias_command.c_str())) {
+    if (m_interpreter.CommandExists(alias_command)) {
       result.AppendErrorWithFormat(
           "'%s' is a permanent debugger command and cannot be redefined.\n",
           alias_command.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // Get CommandObject that is being aliased. The command name is read from
bool HandleAliasingNormalCommand(Args &args, CommandReturnObject &result) {
     const std::string actual_command = args.GetArgumentAtIndex(1);
 
     args.Shift(); // Shift the alias command word off the argument vector.
     args.Shift(); // Shift the old command word off the argument vector.
 
     // Verify that the command is alias'able, and get the appropriate command
     // object.
 
-    if (m_interpreter.CommandExists(alias_command.c_str())) {
+    if (m_interpreter.CommandExists(alias_command)) {
       result.AppendErrorWithFormat(
           "'%s' is a permanent debugger command and cannot be redefined.\n",
           alias_command.c_str());
       result.SetStatus(eReturnStatusFailed);
     } else {
       CommandObjectSP command_obj_sp(
           m_interpreter.GetCommandSPExact(actual_command, true));
       CommandObjectSP subcommand_obj_sp;
if (m_interpreter.CommandExists(alias_command)) {
               m_interpreter.GetCommandSPExact(cmd_obj->GetCommandName(), false);
           if (use_subcommand)
             tmp_sp = m_interpreter.GetCommandSPExact(
                 sub_cmd_obj->GetCommandName(), false);
 
           args.GetCommandString(args_string);
         }
 
-        if (m_interpreter.AliasExists(alias_command.c_str()) ||
-            m_interpreter.UserCommandExists(alias_command.c_str())) {
+        if (m_interpreter.AliasExists(alias_command) ||
+            m_interpreter.UserCommandExists(alias_command)) {
           result.AppendWarningWithFormat(
               "Overwriting existing definition for '%s'.\n",
               alias_command.c_str());
         }
 
         if (CommandAlias *alias = m_interpreter.AddAlias(
-                alias_command.c_str(),
+                alias_command,
                 use_subcommand ? subcommand_obj_sp : command_obj_sp,
-                args_string.c_str())) {
+                args_string)) {
           if (m_command_options.m_help.OptionWasSet())
             alias->SetHelp(m_command_options.m_help.GetCurrentValue());
           if (m_command_options.m_long_help.OptionWasSet())
             alias->SetHelpLong(m_command_options.m_long_help.GetCurrentValue());
           result.SetStatus(eReturnStatusSuccessFinishNoResult);
         } else {
           result.AppendError("Unable to create requested alias.\n");
           result.SetStatus(eReturnStatusFailed);
if (interpreter) {
           if (funct_name_str.empty()) {
             error_sp->Printf("error: unable to obtain a function name, didn't "
                              "add python command.\n");
             error_sp->Flush();
           } else {
             // everything should be fine now, let's add this alias
 
             CommandObjectSP command_obj_sp(new CommandObjectPythonFunction(
-                m_interpreter, m_cmd_name, funct_name_str.c_str(), m_short_help,
+                m_interpreter, m_cmd_name, funct_name_str, m_short_help,
                 m_synchronicity));
 
             if (!m_interpreter.AddUserCommand(m_cmd_name, command_obj_sp,
                                               true)) {
               error_sp->Printf("error: unable to add selected command, didn't "
                                "add python command.\n");
               error_sp->Flush();
             }

lldb/trunk/source/Commands/CommandObjectFrame.cpp

if (variable_list) {
                       //                                                valobj_sp->SetFormat
                       //                                                (format);
 
                       std::string scope_string;
                       if (m_option_variable.show_scope)
                         scope_string = GetScopeString(var_sp).str();
 
                       if (!scope_string.empty())
-                        s.PutCString(scope_string.c_str());
+                        s.PutCString(scope_string);
 
                       if (m_option_variable.show_decl &&
                           var_sp->GetDeclaration().GetFile()) {
                         bool show_fullpaths = false;
                         bool show_module = true;
                         if (var_sp->DumpDeclaration(&s, show_fullpaths,
                                                     show_module))
                           s.PutCString(": ");
if (variable_list) {
                 name_cstr, m_varobj_options.use_dynamic, expr_path_options,
                 var_sp, error);
             if (valobj_sp) {
               std::string scope_string;
               if (m_option_variable.show_scope)
                 scope_string = GetScopeString(var_sp).str();
 
               if (!scope_string.empty())
-                s.PutCString(scope_string.c_str());
+                s.PutCString(scope_string);
 
               //                            if (format != eFormatDefault)
               //                                valobj_sp->SetFormat (format);
               if (m_option_variable.show_decl && var_sp &&
                   var_sp->GetDeclaration().GetFile()) {
                 var_sp->GetDeclaration().DumpStopContext(&s, false);
                 s.PutCString(": ");
               }
if (variable_list) {
                 // that are not in scope to avoid extra unneeded output
                 if (valobj_sp->IsInScope()) {
                   if (!valobj_sp->GetTargetSP()
                            ->GetDisplayRuntimeSupportValues() &&
                       valobj_sp->IsRuntimeSupportValue())
                     continue;
 
                   if (!scope_string.empty())
-                    s.PutCString(scope_string.c_str());
+                    s.PutCString(scope_string);
 
                   if (m_option_variable.show_decl &&
                       var_sp->GetDeclaration().GetFile()) {
                     var_sp->GetDeclaration().DumpStopContext(&s, false);
                     s.PutCString(": ");
                   }
 
                   options.SetFormat(format);

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

if (platform_sp) {
       const OptionPermissions *options_permissions =
           (const OptionPermissions *)m_options.GetGroupWithOption('r');
       if (options_permissions)
         perms = options_permissions->m_permissions;
       else
         perms = lldb::eFilePermissionsUserRW | lldb::eFilePermissionsGroupRW |
                 lldb::eFilePermissionsWorldRead;
       lldb::user_id_t fd = platform_sp->OpenFile(
-          FileSpec(cmd_line.c_str(), false),
+          FileSpec(cmd_line, false),
           File::eOpenOptionRead | File::eOpenOptionWrite |
               File::eOpenOptionAppend | File::eOpenOptionCanCreate,
           perms, error);
       if (error.Success()) {
         result.AppendMessageWithFormat("File Descriptor = %" PRIu64 "\n", fd);
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendError(error.AsCString());
if (args.GetArgumentCount() != 1) {
       return false;
     }
 
     PlatformSP platform_sp(
         m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       std::string remote_file_path(args.GetArgumentAtIndex(0));
       user_id_t size =
-          platform_sp->GetFileSize(FileSpec(remote_file_path.c_str(), false));
+          platform_sp->GetFileSize(FileSpec(remote_file_path, false));
       if (size != UINT64_MAX) {
         result.AppendMessageWithFormat("File size of %s (remote): %" PRIu64
                                        "\n",
                                        remote_file_path.c_str(), size);
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendMessageWithFormat(
             "Error getting file size of %s (remote)\n",
bool DoExecute(const char *raw_command_line,
     if (platform_sp) {
       FileSpec working_dir{};
       std::string output;
       int status = -1;
       int signo = -1;
       error = (platform_sp->RunShellCommand(expr, working_dir, &status, &signo,
                                             &output, m_options.timeout));
       if (!output.empty())
-        result.GetOutputStream().PutCString(output.c_str());
+        result.GetOutputStream().PutCString(output);
       if (status > 0) {
         if (signo > 0) {
           const char *signo_cstr = Host::GetSignalAsCString(signo);
           if (signo_cstr)
             result.GetOutputStream().Printf(
                 "error: command returned with status %i and signal %s\n",
                 status, signo_cstr);
           else

lldb/trunk/source/Commands/CommandObjectSource.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
     result.GetOutputStream().SetAddressByteSize(addr_byte_size);
     result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
     // Collect the list of modules to search.
     m_module_list.Clear();
     if (!m_options.modules.empty()) {
       for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
-        FileSpec module_file_spec(m_options.modules[i].c_str(), false);
+        FileSpec module_file_spec(m_options.modules[i], false);
         if (module_file_spec) {
           ModuleSpec module_spec(module_file_spec);
           if (target->GetImages().FindModules(module_spec, m_module_list) == 0)
             result.AppendWarningWithFormat("No module found for '%s'.\n",
                                            m_options.modules[i].c_str());
         }
       }
       if (!m_module_list.GetSize()) {
size_t FindMatchingFunctions(Target *target, const ConstString &name,
 
     if (m_options.num_lines == 0)
       m_options.num_lines = 10;
 
     const size_t num_modules = m_options.modules.size();
     if (num_modules > 0) {
       ModuleList matching_modules;
       for (size_t i = 0; i < num_modules; ++i) {
-        FileSpec module_file_spec(m_options.modules[i].c_str(), false);
+        FileSpec module_file_spec(m_options.modules[i], false);
         if (module_file_spec) {
           ModuleSpec module_spec(module_file_spec);
           matching_modules.Clear();
           target->GetImages().FindModules(module_spec, matching_modules);
           num_matches += matching_modules.FindFunctions(
               name, eFunctionNameTypeAuto, include_symbols, include_inlines,
               append, sc_list);
         }
       }
     } else {
       num_matches = target->GetImages().FindFunctions(
           name, eFunctionNameTypeAuto, include_symbols, include_inlines, append,
           sc_list);
     }
     return num_matches;
   }
 
   size_t FindMatchingFunctionSymbols(Target *target, const ConstString &name,
                                      SymbolContextList &sc_list) {
     size_t num_matches = 0;
     const size_t num_modules = m_options.modules.size();
     if (num_modules > 0) {
       ModuleList matching_modules;
       for (size_t i = 0; i < num_modules; ++i) {
-        FileSpec module_file_spec(m_options.modules[i].c_str(), false);
+        FileSpec module_file_spec(m_options.modules[i], false);
         if (module_file_spec) {
           ModuleSpec module_spec(module_file_spec);
           matching_modules.Clear();
           target->GetImages().FindModules(module_spec, matching_modules);
           num_matches += matching_modules.FindFunctionSymbols(
               name, eFunctionNameTypeAuto, sc_list);
         }
       }
if (!m_options.symbol_name.empty()) {
 
       bool check_inlines = false;
       SymbolContextList sc_list;
       size_t num_matches = 0;
 
       if (!m_options.modules.empty()) {
         ModuleList matching_modules;
         for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
-          FileSpec module_file_spec(m_options.modules[i].c_str(), false);
+          FileSpec module_file_spec(m_options.modules[i], false);
           if (module_file_spec) {
             ModuleSpec module_spec(module_file_spec);
             matching_modules.Clear();
             target->GetImages().FindModules(module_spec, matching_modules);
             num_matches += matching_modules.ResolveSymbolContextForFilePath(
                 filename, 0, check_inlines,
                 eSymbolContextModule | eSymbolContextCompUnit, sc_list);
           }

lldb/trunk/source/Commands/CommandObjectTarget.cpp

if (full_triple)
       module->GetArchitecture().DumpTriple(arch_strm);
     else
       arch_strm.PutCString(module->GetArchitecture().GetArchitectureName());
     std::string arch_str = arch_strm.GetString();
 
     if (width)
       strm.Printf("%-*s", width, arch_str.c_str());
     else
-      strm.PutCString(arch_str.c_str());
+      strm.PutCString(arch_str);
   }
 }
 
 static void DumpModuleUUID(Stream &strm, Module *module) {
   if (module && module->GetUUID().IsValid())
     module->GetUUID().Dump(&strm);
   else
     strm.PutCString("                                    ");

lldb/trunk/source/Core/Broadcaster.cpp

for (uint32_t bit = 1u, mask = event_mask; mask != 0 && bit != 0;
         if (pos != end) {
           if (num_names_added > 0)
             s.PutCString(", ");
 
           if (prefix_with_broadcaster_name) {
             s.PutCString(GetBroadcasterName());
             s.PutChar('.');
           }
-          s.PutCString(pos->second.c_str());
+          s.PutCString(pos->second);
           ++num_names_added;
         }
       }
     }
   }
   return num_names_added > 0;
 }
 

lldb/trunk/source/Core/Debugger.cpp

Error Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
   Error error(Properties::SetPropertyValue(exe_ctx, op, property_path, value));
   if (error.Success()) {
     // FIXME it would be nice to have "on-change" callbacks for properties
     if (strcmp(property_path, g_properties[ePropertyPrompt].name) == 0) {
       llvm::StringRef new_prompt = GetPrompt();
       std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes(
           new_prompt, GetUseColor());
       if (str.length())
-        new_prompt = str.c_str();
+        new_prompt = str;
       GetCommandInterpreter().UpdatePrompt(new_prompt);
       EventSP prompt_change_event_sp(
           new Event(CommandInterpreter::eBroadcastBitResetPrompt,
                     new EventDataBytes(new_prompt)));
       GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
     } else if (strcmp(property_path, g_properties[ePropertyUseColor].name) ==
                0) {
       // use-color changed. Ping the prompt so it can reset the ansi terminal

 
 void Debugger::SetPrompt(llvm::StringRef p) {
   const uint32_t idx = ePropertyPrompt;
   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
   llvm::StringRef new_prompt = GetPrompt();
   std::string str =
       lldb_utility::ansi::FormatAnsiTerminalCodes(new_prompt, GetUseColor());
   if (str.length())
-    new_prompt = str.c_str();
+    new_prompt = str;
   GetCommandInterpreter().UpdatePrompt(new_prompt);
 }
 
 const FormatEntity::Entry *Debugger::GetThreadFormat() const {
   const uint32_t idx = ePropertyThreadFormat;
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
if (got_structured_data) {
               plugin_sp->GetDescription(structured_data_sp, content_stream);
           if (error.Success()) {
             if (!content_stream.GetString().empty()) {
               // Add newline.
               content_stream.PutChar('\n');
               content_stream.Flush();
 
               // Print it.
-              output_stream_sp->PutCString(content_stream.GetString().c_str());
+              output_stream_sp->PutCString(content_stream.GetString());
             }
           } else {
             error_stream_sp->Printf("Failed to print structured "
                                     "data with plugin %s: %s",
                                     plugin_sp->GetPluginName().AsCString(),
                                     error.AsCString());
           }
         }

lldb/trunk/source/Core/Disassembler.cpp

void Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size,
 
   // The default opcode size of 7 characters is plenty for most architectures
   // but some like arm can pull out the occasional vqrshrun.s16.  We won't get
   // consistent column spacing in these cases, unfortunately.
   if (m_opcode_name.length() >= opcode_column_width) {
     opcode_column_width = m_opcode_name.length() + 1;
   }
 
-  ss.PutCString(m_opcode_name.c_str());
+  ss.PutCString(m_opcode_name);
   ss.FillLastLineToColumn(opcode_pos + opcode_column_width, ' ');
-  ss.PutCString(m_mnemonics.c_str());
+  ss.PutCString(m_mnemonics);
 
   if (!m_comment.empty()) {
     ss.FillLastLineToColumn(
         opcode_pos + opcode_column_width + operand_column_width, ' ');
     ss.PutCString(" ; ");
-    ss.PutCString(m_comment.c_str());
+    ss.PutCString(m_comment);
   }
   s->Write(ss.GetData(), ss.GetSize());
 }
 
 bool Instruction::DumpEmulation(const ArchSpec &arch) {
   std::unique_ptr<EmulateInstruction> insn_emulator_ap(
       EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr));
   if (insn_emulator_ap) {

lldb/trunk/source/Core/FormatEntity.cpp

for (const auto &child : entry.children) {
       if (!Format(child, s, sc, exe_ctx, addr, valobj, function_changed,
                   initial_function)) {
         return false; // If any item of root fails, then the formatting fails
       }
     }
     return true; // Only return true if all items succeeded
 
   case Entry::Type::String:
-    s.PutCString(entry.string.c_str());
+    s.PutCString(entry.string);
     return true;
 
   case Entry::Type::Scope: {
     StreamString scope_stream;
     bool success = false;
     for (const auto &child : entry.children) {
       success = Format(child, scope_stream, sc, exe_ctx, addr, valobj,
                        function_changed, initial_function);

lldb/trunk/source/Core/Log.cpp

if (stream_sp) {
     header.PrintfVarArg(format, args);
     header.PutCString("\n");
 
     if (m_options.Test(LLDB_LOG_OPTION_BACKTRACE)) {
       std::string back_trace;
       llvm::raw_string_ostream stream(back_trace);
       llvm::sys::PrintStackTrace(stream);
       stream.flush();
-      header.PutCString(back_trace.c_str());
+      header.PutCString(back_trace);
     }
 
     if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE)) {
       static std::recursive_mutex g_LogThreadedMutex;
       std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
-      stream_sp->PutCString(header.GetString().c_str());
+      stream_sp->PutCString(header.GetString());
       stream_sp->Flush();
     } else {
-      stream_sp->PutCString(header.GetString().c_str());
+      stream_sp->PutCString(header.GetString());
       stream_sp->Flush();
     }
   }
 }
 
 //----------------------------------------------------------------------
 // Print debug strings if and only if the global debug option is set to
 // a non-zero value.

lldb/trunk/source/Core/Module.cpp

if (log != nullptr) {
     va_list args;
     va_start(args, format);
     log_message.PrintfVarArg(format, args);
     va_end(args);
     if (log->GetVerbose()) {
       std::string back_trace;
       llvm::raw_string_ostream stream(back_trace);
       llvm::sys::PrintStackTrace(stream);
-      log_message.PutCString(back_trace.c_str());
+      log_message.PutCString(back_trace);
     }
     log->PutCString(log_message.GetString().c_str());
   }
 }
 
 void Module::Dump(Stream *s) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);

lldb/trunk/source/Core/Scalar.cpp

void Scalar::GetValue(Stream *s, bool show_type) const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_slong:
   case e_slonglong:
   case e_sint128:
   case e_sint256:
-    s->PutCString(m_integer.toString(10, true).c_str());
+    s->PutCString(m_integer.toString(10, true));
     break;
   case e_uint:
   case e_ulong:
   case e_ulonglong:
   case e_uint128:
   case e_uint256:
-    s->PutCString(m_integer.toString(10, false).c_str());
+    s->PutCString(m_integer.toString(10, false));
     break;
   case e_float:
   case e_double:
   case e_long_double:
     llvm::SmallString<24> string;
     m_float.toString(string);
     s->Printf("%s", string.c_str());
     break;

lldb/trunk/source/Core/SearchFilter.cpp

SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
   }
 
   std::string module;
   success = modules_array->GetItemAtIndexAsString(0, module);
   if (!success) {
     error.SetErrorString("SFBM::CFSD: filter module item not a string.");
     return nullptr;
   }
-  FileSpec module_spec(module.c_str(), false);
+  FileSpec module_spec(module, false);
 
   return SearchFilterSP(
       new SearchFilterByModule(target.shared_from_this(), module_spec));
 }
 
 StructuredData::ObjectSP SearchFilterByModule::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());
if (success) {
     for (size_t i = 0; i < num_modules; i++) {
       std::string module;
       success = modules_array->GetItemAtIndexAsString(i, module);
       if (!success) {
         error.SetErrorStringWithFormat(
             "SFBM::CFSD: filter module item %zu not a string.", i);
         return nullptr;
       }
-      modules.Append(FileSpec(module.c_str(), false));
+      modules.Append(FileSpec(module, false));
     }
   }
 
   return SearchFilterSP(
       new SearchFilterByModuleList(target.shared_from_this(), modules));
 }
 
 void SearchFilterByModuleList::SerializeUnwrapped(
if (success) {
     for (size_t i = 0; i < num_modules; i++) {
       std::string module;
       success = modules_array->GetItemAtIndexAsString(i, module);
       if (!success) {
         error.SetErrorStringWithFormat(
             "SFBM::CFSD: filter module item %zu not a string.", i);
         return result_sp;
       }
-      modules.Append(FileSpec(module.c_str(), false));
+      modules.Append(FileSpec(module, false));
     }
   }
 
   StructuredData::Array *cus_array = nullptr;
   success =
       data_dict.GetValueForKeyAsArray(GetKey(OptionNames::CUList), cus_array);
   if (!success) {
     error.SetErrorString("SFBM::CFSD: Could not find the CU list key.");
     return result_sp;
   }
 
   size_t num_cus = cus_array->GetSize();
   FileSpecList cus;
   for (size_t i = 0; i < num_cus; i++) {
     std::string cu;
     success = cus_array->GetItemAtIndexAsString(i, cu);
     if (!success) {
       error.SetErrorStringWithFormat(
           "SFBM::CFSD: filter cu item %zu not a string.", i);
       return nullptr;
     }
-    cus.Append(FileSpec(cu.c_str(), false));
+    cus.Append(FileSpec(cu, false));
   }
 
   return SearchFilterSP(new SearchFilterByModuleListAndCU(
       target.shared_from_this(), modules, cus));
 }
 
 StructuredData::ObjectSP
 SearchFilterByModuleListAndCU::SerializeToStructuredData() {

lldb/trunk/source/Core/StructuredData.cpp

StructuredData::ObjectSP StructuredData::ParseJSON(std::string json_text) {
   return object_sp;
 }
 
 StructuredData::ObjectSP
 StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
   if (this->GetType() == Type::eTypeDictionary) {
     std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.');
     std::string key = match.first.str();
-    ObjectSP value = this->GetAsDictionary()->GetValueForKey(key.c_str());
+    ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
     if (value.get()) {
       // Do we have additional words to descend?  If not, return the
       // value we're at right now.
       if (match.second.empty()) {
         return value;
       } else {
         return value->GetObjectForDotSeparatedPath(match.second);
       }

lldb/trunk/source/Core/ValueObject.cpp

bool parent_had_base_class =
         GetParent() && GetParent()->GetBaseClassPath(s);
     CompilerType compiler_type = GetCompilerType();
     std::string cxx_class_name;
     bool this_had_base_class =
         ClangASTContext::GetCXXClassName(compiler_type, cxx_class_name);
     if (this_had_base_class) {
       if (parent_had_base_class)
         s.PutCString("::");
-      s.PutCString(cxx_class_name.c_str());
+      s.PutCString(cxx_class_name);
     }
     return parent_had_base_class || this_had_base_class;
   }
   return false;
 }
 
 ValueObject *ValueObject::GetNonBaseClassParent() {
   if (GetParent()) {

lldb/trunk/source/DataFormatters/TypeSummary.cpp

sstr.Printf("%s%s%s%s%s%s%s\n  ", Cascades() ? "" : " (not cascading)",
               IsOneLiner() ? " (one-line printout)" : "",
               SkipsPointers() ? " (skip pointers)" : "",
               SkipsReferences() ? " (skip references)" : "",
               HideNames(nullptr) ? " (hide member names)" : "");
   if (m_python_script.empty()) {
     if (m_function_name.empty()) {
       sstr.PutCString("no backing script");
     } else {
-      sstr.PutCString(m_function_name.c_str());
+      sstr.PutCString(m_function_name);
     }
   } else {
-    sstr.PutCString(m_python_script.c_str());
+    sstr.PutCString(m_python_script);
   }
   return sstr.GetString();
 }

lldb/trunk/source/Expression/IRDynamicChecks.cpp

IRDynamicChecks::IRDynamicChecks(DynamicCheckerFunctions &checker_functions,
     : ModulePass(ID), m_func_name(func_name),
       m_checker_functions(checker_functions) {}
 
 IRDynamicChecks::~IRDynamicChecks() = default;
 
 bool IRDynamicChecks::runOnModule(llvm::Module &M) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  llvm::Function *function = M.getFunction(StringRef(m_func_name.c_str()));
+  llvm::Function *function = M.getFunction(StringRef(m_func_name));
 
   if (!function) {
     if (log)
       log->Printf("Couldn't find %s() in the module", m_func_name.c_str());
 
     return false;
   }
 

lldb/trunk/source/Expression/REPL.cpp

if (code[0] == ':') {
             std::string code(m_code.CopyList());
             code.append(1, '\n');
             size_t bytes_written = code.size();
             file.Write(code.c_str(), bytes_written);
             file.Close();
 
             // Now set the default file and line to the REPL source file
             m_target.GetSourceManager().SetDefaultFileAndLine(
-                FileSpec(m_repl_source_path.c_str(), false), new_default_line);
+                FileSpec(m_repl_source_path, false), new_default_line);
           }
           static_cast<IOHandlerEditline &>(io_handler)
               .SetBaseLineNumber(m_code.GetSize() + 1);
         }
         if (extra_line) {
           fprintf(output_sp->GetFile().GetStream(), "\n");
         }
       }

lldb/trunk/source/Host/common/FileSpec.cpp

 //------------------------------------------------------------------
 // Dump the object to the supplied stream. If the object contains
 // a valid directory name, it will be displayed followed by a
 // directory delimiter, and the filename.
 //------------------------------------------------------------------
 void FileSpec::Dump(Stream *s) const {
   if (s) {
     std::string path{GetPath(true)};
-    s->PutCString(path.c_str());
+    s->PutCString(path);
     char path_separator = GetPreferredPathSeparator(m_syntax);
     if (!m_filename && !path.empty() && path.back() != path_separator)
       s->PutChar(path_separator);
   }
 }
 
 //------------------------------------------------------------------
 // Returns true if the file exists.

lldb/trunk/source/Host/common/Host.cpp

Error Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
 
   if (command_output_ptr) {
     // Create a temporary file to get the stdout/stderr and redirect the
     // output of the command into this file. We will later read this file
     // if all goes well and fill the data into "command_output_ptr"
     FileSpec tmpdir_file_spec;
     if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) {
       tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
-      llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath().c_str(),
+      llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
                                       output_file_path);
     } else {
       llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "",
                                          output_file_path);
     }
   }
 
   FileSpec output_file_spec{output_file_path.c_str(), false};

lldb/trunk/source/Host/common/HostNativeThreadBase.cpp

lldb::thread_t HostNativeThreadBase::Release() {
 
   return result;
 }
 
 lldb::thread_result_t
 HostNativeThreadBase::ThreadCreateTrampoline(lldb::thread_arg_t arg) {
   ThreadLauncher::HostThreadCreateInfo *info =
       (ThreadLauncher::HostThreadCreateInfo *)arg;
-  ThisThread::SetName(info->thread_name.c_str(),
-                      HostInfo::GetMaxThreadNameLength());
+  ThisThread::SetName(info->thread_name, HostInfo::GetMaxThreadNameLength());
 
   thread_func_t thread_fptr = info->thread_fptr;
   thread_arg_t thread_arg = info->thread_arg;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Printf("thread created");
 
   delete info;
   return thread_fptr(thread_arg);
 }

lldb/trunk/source/Host/common/Symbols.cpp

for (size_t idx = 0; idx < num_directories; ++idx) {
       // Some debug files may stored in the module directory like this:
       //   /usr/lib/debug/usr/lib/library.so.debug
       if (!file_dir.IsEmpty())
         files.push_back(dirname + file_dir.AsCString() + "/" + symbol_filename);
 
       const uint32_t num_files = files.size();
       for (size_t idx_file = 0; idx_file < num_files; ++idx_file) {
         const std::string &filename = files[idx_file];
-        FileSpec file_spec(filename.c_str(), true);
+        FileSpec file_spec(filename, true);
 
         if (llvm::sys::fs::equivalent(file_spec.GetPath(),
                                       module_spec.GetFileSpec().GetPath()))
           continue;
 
         if (file_spec.Exists()) {
           lldb_private::ModuleSpecList specs;
           const size_t num_specs =

lldb/trunk/source/Host/common/ThisThread.cpp

if (end - begin > static_cast<size_t>(max_length)) {
 
       end = std::min(end, begin + max_length);
     }
 
     std::string::size_type count = end - begin + 1;
     truncated_name = truncated_name.substr(begin, count);
   }
 
-  SetName(truncated_name.c_str());
+  SetName(truncated_name);
 }

lldb/trunk/source/Host/linux/HostInfoLinux.cpp

for (size_t exe_index = 0;
                       get_distribution_id_command.c_str());
       }
 
       // clean up the file
       pclose(file);
     }
   });
 
-  return g_fields->m_distribution_id.c_str();
+  return g_fields->m_distribution_id;
 }
 
 FileSpec HostInfoLinux::GetProgramFileSpec() {
   static FileSpec g_program_filespec;
 
   if (!g_program_filespec) {
     char exe_path[PATH_MAX];
     ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1);

lldb/trunk/source/Host/posix/PipePosix.cpp

if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) {
     tmpdir_file_spec.AppendPathComponent(pipe_spec.c_str());
   }
 
   // It's possible that another process creates the target path after we've
   // verified it's available but before we create it, in which case we
   // should try again.
   Error error;
   do {
-    llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath().c_str(),
+    llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
                                     named_pipe_path);
     error = CreateNew(named_pipe_path, child_process_inherit);
   } while (error.GetError() == EEXIST);
 
   if (error.Success())
     name = named_pipe_path;
   return error;
 }

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

bool CommandInterpreter::HandleCommand(const char *command_line,
 
   if (cmd_obj != nullptr) {
     if (add_to_history) {
       Args command_args(command_string);
       const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0);
       if (repeat_command != nullptr)
         m_repeat_command.assign(repeat_command);
       else
-        m_repeat_command.assign(original_command_string.c_str());
+        m_repeat_command.assign(original_command_string);
 
       m_command_history.AppendString(original_command_string);
     }
 
     std::string remainder;
     const std::size_t actual_cmd_name_len = cmd_obj->GetCommandName().size();
     if (actual_cmd_name_len < command_string.length())
       remainder = command_string.substr(actual_cmd_name_len);
if (m_skip_app_init_files == false) {
                    "%s-%s", init_file_path.c_str(), program_name);
         init_file.SetFile(program_init_file_name, true);
         if (!init_file.Exists())
           init_file.Clear();
       }
     }
 
     if (!init_file && !m_skip_lldbinit_files)
-      init_file.SetFile(init_file_path.c_str(), false);
+      init_file.SetFile(init_file_path, false);
   }
 
   // If the file exists, tell HandleCommand to 'source' it; this will do the
   // actual broadcasting
   // of the commands back to any appropriate listener (see
   // CommandObjectSource::Execute for more details).
 
   if (init_file.Exists()) {
CommandInterpreter::ResolveCommandImpl(std::string &command_line,
   StringList matches;
   bool done = false;
   while (!done) {
     char quote_char = '\0';
     std::string suffix;
     ExtractCommand(scratch_command, next_word, suffix, quote_char);
     if (cmd_obj == nullptr) {
       std::string full_name;
-      bool is_alias = GetAliasFullName(next_word.c_str(), full_name);
+      bool is_alias = GetAliasFullName(next_word, full_name);
       cmd_obj = GetCommandObject(next_word, &matches);
       bool is_real_command =
           (is_alias == false) ||
           (cmd_obj != nullptr && cmd_obj->IsAlias() == false);
       if (!is_real_command) {
         matches.Clear();
         std::string alias_result;
-        cmd_obj = BuildAliasResult(full_name.c_str(), scratch_command,
-                                   alias_result, result);
+        cmd_obj =
+            BuildAliasResult(full_name, scratch_command, alias_result, result);
         revised_command_line.Printf("%s", alias_result.c_str());
         if (cmd_obj) {
           wants_raw_input = cmd_obj->WantsRawCommandString();
           actual_cmd_name_len = cmd_obj->GetCommandName().size();
         }
       } else {
         if (!cmd_obj)
           cmd_obj = GetCommandObject(next_word, &matches);

lldb/trunk/source/Interpreter/OptionValueArray.cpp

for (uint32_t i = 0; i < size; ++i) {
         strm.EOL();
     }
     strm.IndentLess();
   }
 }
 
 Error OptionValueArray::SetValueFromString(llvm::StringRef value,
                                            VarSetOperationType op) {
-  Args args(value.str().c_str());
+  Args args(value.str());
   Error error = SetArgs(args, op);
   if (error.Success())
     NotifyValueChanged();
   return error;
 }
 
 lldb::OptionValueSP
 OptionValueArray::GetSubValue(const ExecutionContext *exe_ctx, const char *name,

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

case eVarSetOperationInvalid:
     error = OptionValue::SetValueFromString(llvm::StringRef(), op);
     break;
   }
   return error;
 }
 
 Error OptionValueDictionary::SetValueFromString(llvm::StringRef value,
                                                 VarSetOperationType op) {
-  Args args(value.str().c_str());
+  Args args(value.str());
   Error error = SetArgs(args, op);
   if (error.Success())
     NotifyValueChanged();
   return error;
 }
 
 lldb::OptionValueSP
 OptionValueDictionary::GetSubValue(const ExecutionContext *exe_ctx,

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

if (value.size() > 0) {
       // from the start and end of the file path - we aren't doing any word //
       // breaking here so
       // the quoting is unnecessary.  NB this will cause a problem if someone
       // tries to specify
       // a file path that legitimately begins or ends with a " or ' character,
       // or whitespace.
       value = value.trim("\"' \t");
       m_value_was_set = true;
-      m_current_value.SetFile(value.str().c_str(), m_resolve);
+      m_current_value.SetFile(value.str(), m_resolve);
       m_data_sp.reset();
       m_data_mod_time.Clear();
       NotifyValueChanged();
     } else {
       error.SetErrorString("invalid value string");
     }
     break;
 

lldb/trunk/source/Interpreter/OptionValueFileSpecLIst.cpp

if (dump_mask & eDumpOptionValue) {
     }
     strm.IndentLess();
   }
 }
 
 Error OptionValueFileSpecList::SetValueFromString(llvm::StringRef value,
                                                   VarSetOperationType op) {
   Error error;
-  Args args(value.str().c_str());
+  Args args(value.str());
   const size_t argc = args.GetArgumentCount();
 
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 

lldb/trunk/source/Interpreter/OptionValuePathMappings.cpp

if (dump_mask & eDumpOptionType)
       strm.Printf(" =%s", (m_path_mappings.GetSize() > 0) ? "\n" : "");
     m_path_mappings.Dump(&strm);
   }
 }
 
 Error OptionValuePathMappings::SetValueFromString(llvm::StringRef value,
                                                   VarSetOperationType op) {
   Error error;
-  Args args(value.str().c_str());
+  Args args(value.str());
   const size_t argc = args.GetArgumentCount();
 
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 

lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

static void DumpOperand(const Operand &op, Stream &s) {
     case Operand::Type::Dereference:
       s.PutCString("*");
       DumpOperand(op.m_children[0], s);
       break;
     case Operand::Type::Immediate:
       if (op.m_negative) {
         s.PutCString("-");
       }
-      s.PutCString(llvm::to_string(op.m_immediate).c_str());
+      s.PutCString(llvm::to_string(op.m_immediate));
       break;
     case Operand::Type::Invalid:
       s.PutCString("Invalid");
       break;
     case Operand::Type::Product:
       s.PutCString("(");
       DumpOperand(op.m_children[0], s);
       s.PutCString("*");
if (triple.getArch() == llvm::Triple::arm) {
     std::string thumb_arch_name(thumb_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");
     } else {
       thumb_arch_name = "thumbv8.2a";
     }
-    thumb_arch.GetTriple().setArchName(
-        llvm::StringRef(thumb_arch_name.c_str()));
+    thumb_arch.GetTriple().setArchName(llvm::StringRef(thumb_arch_name));
   }
 
   // If no sub architecture specified then use the most recent arm architecture
   // so the
   // disassembler will return all instruction. Without it we will see a lot of
   // unknow opcode
   // in case the code uses instructions which are not available in the oldest
   // arm version

lldb/trunk/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

void DynamicLoaderHexagonDYLD::RefreshModules() {
 
   ModuleList &loaded_modules = m_process->GetTarget().GetImages();
 
   if (m_rendezvous.ModulesDidLoad()) {
     ModuleList new_modules;
 
     E = m_rendezvous.loaded_end();
     for (I = m_rendezvous.loaded_begin(); I != E; ++I) {
-      FileSpec file(I->path.c_str(), true);
+      FileSpec file(I->path, true);
       ModuleSP module_sp =
           LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
       if (module_sp.get()) {
         loaded_modules.AppendIfNeeded(module_sp);
         new_modules.Append(module_sp);
       }
 
       if (log) {
         log->Printf("Target is loading '%s'", I->path.c_str());
         if (!module_sp.get())
           log->Printf("LLDB failed to load '%s'", I->path.c_str());
         else
           log->Printf("LLDB successfully loaded '%s'", I->path.c_str());
       }
     }
     m_process->GetTarget().ModulesDidLoad(new_modules);
   }
 
   if (m_rendezvous.ModulesDidUnload()) {
     ModuleList old_modules;
 
     E = m_rendezvous.unloaded_end();
     for (I = m_rendezvous.unloaded_begin(); I != E; ++I) {
-      FileSpec file(I->path.c_str(), true);
+      FileSpec file(I->path, true);
       ModuleSpec module_spec(file);
       ModuleSP module_sp = loaded_modules.FindFirstModule(module_spec);
 
       if (module_sp.get()) {
         old_modules.Append(module_sp);
         UnloadSections(module_sp);
       }
 

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (image->HasKey("load_address") == false ||
         image->HasKey("uuid") == false) {
       return false;
     }
     image_infos[i].address =
         image->GetValueForKey("load_address")->GetAsInteger()->GetValue();
     image_infos[i].mod_date =
         image->GetValueForKey("mod_date")->GetAsInteger()->GetValue();
     image_infos[i].file_spec.SetFile(
-        image->GetValueForKey("pathname")->GetAsString()->GetValue().c_str(),
-        false);
+        image->GetValueForKey("pathname")->GetAsString()->GetValue(), false);
 
     StructuredData::Dictionary *mh =
         image->GetValueForKey("mach_header")->GetAsDictionary();
     image_infos[i].header.magic =
         mh->GetValueForKey("magic")->GetAsInteger()->GetValue();
     image_infos[i].header.cputype =
         mh->GetValueForKey("cputype")->GetAsInteger()->GetValue();
     image_infos[i].header.cpusubtype =

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

if (m_process) {
 
     // {"shared_cache_base_address":140735683125248,"shared_cache_uuid":"DDB8D70C-C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
 
     if (info_dict && info_dict->HasKey("shared_cache_uuid") &&
         info_dict->HasKey("no_shared_cache") &&
         info_dict->HasKey("shared_cache_base_address")) {
       base_address = info_dict->GetValueForKey("shared_cache_base_address")
                          ->GetIntegerValue(LLDB_INVALID_ADDRESS);
-      std::string uuid_str = info_dict->GetValueForKey("shared_cache_uuid")
-                                 ->GetStringValue()
-                                 .c_str();
+      std::string uuid_str =
+          info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue();
       if (!uuid_str.empty())
         uuid.SetFromCString(uuid_str.c_str());
       if (info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue() ==
           false)
         using_shared_cache = eLazyBoolYes;
       else
         using_shared_cache = eLazyBoolNo;
       if (info_dict->GetValueForKey("shared_cache_private_cache")

lldb/trunk/source/Plugins/ExpressionParser/Clang/ASTDumper.cpp

while (end) {
     end = strchr(str, '\n');
   }
 
   log->Printf("%s%s", prefix, str);
 
   free(alloc);
 }
 
-void ASTDumper::ToStream(lldb::StreamSP &stream) {
-  stream->PutCString(m_dump.c_str());
-}
+void ASTDumper::ToStream(lldb::StreamSP &stream) { stream->PutCString(m_dump); }

lldb/trunk/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.cpp

void ASTStructExtractor::ExtractFromFunctionDecl(FunctionDecl *F) {
   Stmt *body_stmt = F->getBody();
   CompoundStmt *body_compound_stmt = dyn_cast<CompoundStmt>(body_stmt);
 
   if (!body_compound_stmt)
     return; // do we have to handle this?
 
   RecordDecl *struct_decl = NULL;
 
-  StringRef desired_name(m_struct_name.c_str());
+  StringRef desired_name(m_struct_name);
 
   for (CompoundStmt::const_body_iterator bi = body_compound_stmt->body_begin(),
                                          be = body_compound_stmt->body_end();
        bi != be; ++bi) {
     Stmt *curr_stmt = *bi;
     DeclStmt *curr_decl_stmt = dyn_cast<DeclStmt>(curr_stmt);
     if (!curr_decl_stmt)
       continue;
for (decl_iterator = linkage_spec_decl->decls_begin();
       ExtractFromTopLevelDecl(*decl_iterator);
     }
   }
 
   FunctionDecl *function_decl = dyn_cast<FunctionDecl>(D);
 
   if (m_ast_context && function_decl &&
       !m_function.m_wrapper_function_name.compare(
-          function_decl->getNameAsString().c_str())) {
+          function_decl->getNameAsString())) {
     ExtractFromFunctionDecl(function_decl);
   }
 }
 
 bool ASTStructExtractor::HandleTopLevelDecl(DeclGroupRef D) {
   DeclGroupRef::iterator decl_iterator;
 
   for (decl_iterator = D.begin(); decl_iterator != D.end(); ++decl_iterator) {

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

static bool FindObjCMethodDeclsWithOrigin(
   if (decl_name.isObjCZeroArgSelector()) {
     IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString());
     original_selector = original_ctx->Selectors.getSelector(0, &ident);
   } else if (decl_name.isObjCOneArgSelector()) {
     const std::string &decl_name_string = decl_name.getAsString();
     std::string decl_name_string_without_colon(decl_name_string.c_str(),
                                                decl_name_string.length() - 1);
     IdentifierInfo *ident =
-        &original_ctx->Idents.get(decl_name_string_without_colon.c_str());
+        &original_ctx->Idents.get(decl_name_string_without_colon);
     original_selector = original_ctx->Selectors.getSelector(1, &ident);
   } else {
     SmallVector<IdentifierInfo *, 4> idents;
 
     clang::Selector sel = decl_name.getObjCSelector();
 
     unsigned num_args = sel.getNumArgs();
 
static bool FindObjCPropertyAndIvarDeclsWithOrigin(
     clang::ASTContext &ast_context, ClangASTImporter *ast_importer,
     DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (origin_iface_decl.IsInvalid())
     return false;
 
   std::string name_str = context.m_decl_name.getAsString();
-  StringRef name(name_str.c_str());
+  StringRef name(name_str);
   IdentifierInfo &name_identifier(
       origin_iface_decl->getASTContext().Idents.get(name));
 
   DeclFromUser<ObjCPropertyDecl> origin_property_decl(
       origin_iface_decl->FindPropertyDeclaration(
           &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance));
 
   bool found = false;

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 }
 
 void StoringDiagnosticConsumer::ClearDiagnostics() { m_diagnostics.clear(); }
 
 void StoringDiagnosticConsumer::DumpDiagnostics(Stream &error_stream) {
   for (IDAndDiagnostic &diag : m_diagnostics) {
     switch (diag.first) {
     default:
-      error_stream.PutCString(diag.second.c_str());
+      error_stream.PutCString(diag.second);
       error_stream.PutChar('\n');
       break;
     case clang::DiagnosticsEngine::Level::Ignored:
       break;
     }
   }
 }
 
for (clang::ModuleMacro *module_macro :
           macro_info = module_macro->getMacroInfo();
           found_priority = pi->second;
         }
       }
     }
 
     if (macro_info) {
       std::string macro_expansion = "#define ";
-      macro_expansion.append(mi->first->getName().str().c_str());
+      macro_expansion.append(mi->first->getName().str());
 
       {
         if (macro_info->isFunctionLike()) {
           macro_expansion.append("(");
 
           bool first_arg = true;
 
           for (clang::MacroInfo::arg_iterator ai = macro_info->arg_begin(),

lldb/trunk/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

lldb_private::ConstString persistent_variable_name(decl_name.data(),
                                                      decl_name.size());
   if (!m_decl_map->AddPersistentVariable(decl, persistent_variable_name,
                                          result_decl_type, false, false))
     return false;
 
   GlobalVariable *persistent_global = new GlobalVariable(
       (*m_module), alloc->getType(), false, /* not constant */
       GlobalValue::ExternalLinkage, NULL,   /* no initializer */
-      alloc->getName().str().c_str());
+      alloc->getName().str());
 
   // What we're going to do here is make believe this was a regular old external
   // variable.  That means we need to make the metadata valid.
 
   NamedMDNode *named_metadata =
       m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
 
   llvm::Metadata *values[2];

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

bool AddressSanitizerRuntime::NotifyBreakpointHit(
   }
   ProcessSP process_sp = instance->GetProcessSP();
   // Make sure this is the right process
   if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
     ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
     if (thread_sp)
       thread_sp->SetStopInfo(InstrumentationRuntimeStopInfo::
                                  CreateStopReasonWithInstrumentationData(
-                                     *thread_sp, description.c_str(), report));
+                                     *thread_sp, description, report));
 
     StreamFileSP stream_sp(
         process_sp->GetTarget().GetDebugger().GetOutputFile());
     if (stream_sp) {
       stream_sp->Printf("AddressSanitizer report breakpoint hit. Use 'thread "
                         "info -s' to get extended information about the "
                         "report.\n");
     }

lldb/trunk/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

bool ThreadSanitizerRuntime::NotifyBreakpointHit(
   ProcessSP process_sp = instance->GetProcessSP();
   // Make sure this is the right process
   if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
     ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
     if (thread_sp)
       thread_sp->SetStopInfo(
           InstrumentationRuntimeStopInfo::
               CreateStopReasonWithInstrumentationData(
-                  *thread_sp, stop_reason_description.c_str(), report));
+                  *thread_sp, stop_reason_description, report));
 
     StreamFileSP stream_sp(
         process_sp->GetTarget().GetDebugger().GetOutputFile());
     if (stream_sp) {
       stream_sp->Printf("ThreadSanitizer report breakpoint hit. Use 'thread "
                         "info -s' to get extended information about the "
                         "report.\n");
     }

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
 
   return false;
 }
 
 lldb_private::FileSpecList ObjectFileELF::GetDebugSymbolFilePaths() {
   FileSpecList file_spec_list;
 
   if (!m_gnu_debuglink_file.empty()) {
-    FileSpec file_spec(m_gnu_debuglink_file.c_str(), false);
+    FileSpec file_spec(m_gnu_debuglink_file, false);
     file_spec_list.Append(file_spec);
   }
   return file_spec_list;
 }
 
 uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) {
   size_t num_modules = ParseDependentModules();
   uint32_t num_specs = 0;

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

if (error.Success())
     sync_service.reset(new SyncService(std::move(m_conn)));
 
   return sync_service;
 }
 
 Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
                                                const FileSpec &local_file) {
   const auto local_file_path = local_file.GetPath();
-  llvm::FileRemover local_file_remover(local_file_path.c_str());
+  llvm::FileRemover local_file_remover(local_file_path);
 
   std::ofstream dst(local_file_path, std::ios::out | std::ios::binary);
   if (!dst.is_open())
     return Error("Unable to open local file %s", local_file_path.c_str());
 
   const auto remote_file_path = remote_file.GetPath(false);
   auto error = SendSyncRequest(kRECV, remote_file_path.length(),
                                remote_file_path.c_str());

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

tmpdir_remover(&tmpdir, [this, &adb](std::string *s) {
     command.Printf("rm -rf %s", s->c_str());
     Error error = adb.Shell(command.GetData(), 5000 /* ms */, nullptr);
 
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
     if (log && error.Fail())
       log->Printf("Failed to remove temp directory: %s", error.AsCString());
   });
 
-  FileSpec symfile_platform_filespec(tmpdir.c_str(), false);
+  FileSpec symfile_platform_filespec(tmpdir, false);
   symfile_platform_filespec.AppendPathComponent("symbolized.oat");
 
   // Execute oatdump on the remote device to generate a file with symtab
   StreamString command;
   command.Printf("oatdump --symbolize=%s --output=%s",
                  module_sp->GetPlatformFileSpec().GetCString(false),
                  symfile_platform_filespec.GetCString(false));
   error = adb.Shell(command.GetData(), 60000 /* ms */, nullptr);

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (module_sp)
     return err;
 
   if (!IsHost()) {
     std::string cache_path(GetLocalCacheDirectory());
     // Only search for a locally cached file if we have a valid cache path
     if (!cache_path.empty()) {
       std::string module_path(module_spec.GetFileSpec().GetPath());
       cache_path.append(module_path);
-      FileSpec module_cache_spec(cache_path.c_str(), false);
+      FileSpec module_cache_spec(cache_path, false);
 
       // if rsync is supported, always bring in the file - rsync will be very
       // efficient
       // when files are the same on the local and remote end of the connection
       if (this->GetSupportsRSync()) {
         err = BringInRemoteFile(this, module_spec, module_cache_spec);
         if (err.Fail())
           return err;
if (m_developer_directory.empty()) {
     }
 
     if (!developer_dir_path_valid) {
       std::string xcode_dir_path;
       const char *xcode_select_prefix_dir = getenv("XCODE_SELECT_PREFIX_DIR");
       if (xcode_select_prefix_dir)
         xcode_dir_path.append(xcode_select_prefix_dir);
       xcode_dir_path.append("/usr/share/xcode-select/xcode_dir_path");
-      temp_file_spec.SetFile(xcode_dir_path.c_str(), false);
+      temp_file_spec.SetFile(xcode_dir_path, false);
       size_t bytes_read = temp_file_spec.ReadFileContents(
           0, developer_dir_path, sizeof(developer_dir_path), NULL);
       if (bytes_read > 0) {
         developer_dir_path[bytes_read] = '\0';
         while (developer_dir_path[bytes_read - 1] == '\r' ||
                developer_dir_path[bytes_read - 1] == '\n')
           developer_dir_path[--bytes_read] = '\0';
         developer_dir_path_valid = true;

 static FileSpec CheckPathForXcode(const FileSpec &fspec) {
   if (fspec.Exists()) {
     const char substr[] = ".app/Contents/";
 
     std::string path_to_shlib = fspec.GetPath();
     size_t pos = path_to_shlib.rfind(substr);
     if (pos != std::string::npos) {
       path_to_shlib.erase(pos + strlen(substr));
-      FileSpec ret(path_to_shlib.c_str(), false);
+      FileSpec ret(path_to_shlib, false);
 
       FileSpec xcode_binary_path = ret;
       xcode_binary_path.AppendPathComponent("MacOS");
       xcode_binary_path.AppendPathComponent("Xcode");
 
       if (xcode_binary_path.Exists()) {
         return ret;
       }
if (!g_xcode_filespec) {
             3);      // Timeout in seconds to wait for shell program to finish
         if (status == 0 && !output.empty()) {
           size_t first_non_newline = output.find_last_not_of("\r\n");
           if (first_non_newline != std::string::npos) {
             output.erase(first_non_newline + 1);
           }
           output.append("/..");
 
-          g_xcode_filespec = CheckPathForXcode(FileSpec(output.c_str(), false));
+          g_xcode_filespec = CheckPathForXcode(FileSpec(output, false));
         }
       }
     }
   });
 
   return g_xcode_filespec;
 }
 
FileSpec PlatformDarwin::FindSDKInXcodeForModules(SDKType sdk_type,
   const bool find_directories = true;
   const bool find_files = false;
   const bool find_other = true; // include symlinks
 
   SDKEnumeratorInfo enumerator_info;
 
   enumerator_info.sdk_type = sdk_type;
 
-  FileSpec::EnumerateDirectory(sdks_spec.GetPath().c_str(), find_directories,
+  FileSpec::EnumerateDirectory(sdks_spec.GetPath(), find_directories,
                                find_files, find_other, DirectoryEnumerator,
                                &enumerator_info);
 
   if (enumerator_info.found_path.IsDirectory())
     return enumerator_info.found_path;
   else
     return FileSpec();
 }
if (sdk_type == SDKType::MacOSX) {
     if (HostInfo::GetOSVersion(major, minor, micro)) {
       if (SDKSupportsModules(SDKType::MacOSX, major, minor, micro)) {
         // We slightly prefer the exact SDK for this machine.  See if it is
         // there.
 
         FileSpec native_sdk_spec = sdks_spec;
         StreamString native_sdk_name;
         native_sdk_name.Printf("MacOSX%u.%u.sdk", major, minor);
-        native_sdk_spec.AppendPathComponent(
-            native_sdk_name.GetString().c_str());
+        native_sdk_spec.AppendPathComponent(native_sdk_name.GetString());
 
         if (native_sdk_spec.Exists()) {
           return native_sdk_spec;
         }
       }
     }
   }
 
if (versions_valid && versions[0] != UINT32_MAX) {
     if (versions[2] == UINT32_MAX)
       versions[2] = 0;
 
     switch (sdk_type) {
     case SDKType::iPhoneOS:
       minimum_version_option.PutCString("-mios-version-min=");
       minimum_version_option.PutCString(
           clang::VersionTuple(versions[0], versions[1], versions[2])
-              .getAsString()
-              .c_str());
+              .getAsString());
       break;
     case SDKType::iPhoneSimulator:
       minimum_version_option.PutCString("-mios-simulator-version-min=");
       minimum_version_option.PutCString(
           clang::VersionTuple(versions[0], versions[1], versions[2])
-              .getAsString()
-              .c_str());
+              .getAsString());
       break;
     case SDKType::MacOSX:
       minimum_version_option.PutCString("-mmacosx-version-min=");
       minimum_version_option.PutCString(
           clang::VersionTuple(versions[0], versions[1], versions[2])
-              .getAsString()
-              .c_str());
+              .getAsString());
     }
     options.push_back(minimum_version_option.GetString());
   }
 
   FileSpec sysroot_spec;
   // Scope for mutex locker below
   {
     std::lock_guard<std::mutex> guard(m_mutex);

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

if (objfile) {
         }
 
         if (!xcode_contents_path.empty()) {
           StreamString sdk_path;
           sdk_path.Printf("%sDeveloper/Platforms/MacOSX.platform/Developer/"
                           "SDKs/MacOSX%u.%u.sdk",
                           xcode_contents_path.c_str(), versions[0],
                           versions[1]);
-          fspec.SetFile(sdk_path.GetString().c_str(), false);
+          fspec.SetFile(sdk_path.GetString(), false);
           if (fspec.Exists())
             return ConstString(sdk_path.GetString().c_str());
         }
 
         if (!default_xcode_sdk.empty()) {
-          fspec.SetFile(default_xcode_sdk.c_str(), false);
+          fspec.SetFile(default_xcode_sdk, false);
           if (fspec.Exists())
             return ConstString(default_xcode_sdk.c_str());
         }
       }
     }
   }
   return ConstString();
 }
if (local_os_build.compare(remote_os_build) == 0) {
       // same OS version: the local file is good enough
       local_file = platform_file;
       return Error();
     } else {
       // try to find the file in the cache
       std::string cache_path(GetLocalCacheDirectory());
       std::string module_path(platform_file.GetPath());
       cache_path.append(module_path);
-      FileSpec module_cache_spec(cache_path.c_str(), false);
+      FileSpec module_cache_spec(cache_path, false);
       if (module_cache_spec.Exists()) {
         local_file = module_cache_spec;
         return Error();
       }
       // bring in the remote module file
       FileSpec module_cache_folder =
           module_cache_spec.CopyByRemovingLastPathComponent();
       // try to make the local directory first

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

if (log) {
                   device_support_dir);
     }
     if (device_support_dir) {
       const bool find_directories = true;
       const bool find_files = false;
       const bool find_other = false;
 
       SDKDirectoryInfoCollection builtin_sdk_directory_infos;
-      FileSpec::EnumerateDirectory(m_device_support_directory.c_str(),
-                                   find_directories, find_files, find_other,
+      FileSpec::EnumerateDirectory(m_device_support_directory, find_directories,
+                                   find_files, find_other,
                                    GetContainedFilesIntoVectorOfStringsCallback,
                                    &builtin_sdk_directory_infos);
 
       // Only add SDK directories that have symbols in them, some SDKs only
       // contain
       // developer disk images and no symbols, so they aren't useful to us.
       FileSpec sdk_symbols_symlink_fspec;
       for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {
std::string sdkroot_path =
         m_sdk_directory_infos[sdk_idx].directory.GetPath();
     if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
       // We may need to interpose "/Symbols/" or "/Symbols.Internal/" between
       // the
       // SDK root directory and the file path.
 
       const char *paths_to_try[] = {"Symbols", "", "Symbols.Internal", nullptr};
       for (size_t i = 0; paths_to_try[i] != nullptr; i++) {
-        local_file.SetFile(sdkroot_path.c_str(), false);
+        local_file.SetFile(sdkroot_path, false);
         if (paths_to_try[i][0] != '\0')
           local_file.AppendPathComponent(paths_to_try[i]);
         local_file.AppendPathComponent(platform_file_path);
         local_file.ResolvePath();
         if (local_file.Exists()) {
           if (log)
             log->Printf("Found a copy of %s in the SDK dir %s/%s",
                         platform_file_path, sdkroot_path.c_str(),

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

if (log) {
                   device_support_dir);
     }
     if (device_support_dir) {
       const bool find_directories = true;
       const bool find_files = false;
       const bool find_other = false;
 
       SDKDirectoryInfoCollection builtin_sdk_directory_infos;
-      FileSpec::EnumerateDirectory(m_device_support_directory.c_str(),
-                                   find_directories, find_files, find_other,
+      FileSpec::EnumerateDirectory(m_device_support_directory, find_directories,
+                                   find_files, find_other,
                                    GetContainedFilesIntoVectorOfStringsCallback,
                                    &builtin_sdk_directory_infos);
 
       // Only add SDK directories that have symbols in them, some SDKs only
       // contain
       // developer disk images and no symbols, so they aren't useful to us.
       FileSpec sdk_symbols_symlink_fspec;
       for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {

 
 const char *PlatformRemoteAppleWatch::GetDeviceSupportDirectory() {
   if (m_device_support_directory.empty()) {
     const char *device_support_dir = GetDeveloperDirectory();
     if (device_support_dir) {
       m_device_support_directory.assign(device_support_dir);
       m_device_support_directory.append(
           "/Platforms/watchOS.platform/DeviceSupport");
-      FileSpec platform_device_support_dir(m_device_support_directory.c_str(),
-                                           true);
+      FileSpec platform_device_support_dir(m_device_support_directory, true);
       if (!platform_device_support_dir.Exists()) {
         std::string alt_platform_dirname = device_support_dir;
         alt_platform_dirname.append(
             "/Platforms/WatchOS.platform/DeviceSupport");
-        FileSpec alt_platform_device_support_dir(
-            m_device_support_directory.c_str(), true);
+        FileSpec alt_platform_device_support_dir(m_device_support_directory,
+                                                 true);
         if (alt_platform_device_support_dir.Exists()) {
           m_device_support_directory = alt_platform_dirname;
         }
       }
     } 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');
std::string sdkroot_path =
         m_sdk_directory_infos[sdk_idx].directory.GetPath();
     if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
       // We may need to interpose "/Symbols/" or "/Symbols.Internal/" between
       // the
       // SDK root directory and the file path.
 
       const char *paths_to_try[] = {"Symbols", "", "Symbols.Internal", nullptr};
       for (size_t i = 0; paths_to_try[i] != nullptr; i++) {
-        local_file.SetFile(sdkroot_path.c_str(), false);
+        local_file.SetFile(sdkroot_path, false);
         if (paths_to_try[i][0] != '\0')
           local_file.AppendPathComponent(paths_to_try[i]);
         local_file.AppendPathComponent(platform_file_path);
         local_file.ResolvePath();
         if (local_file.Exists()) {
           if (log)
             log->Printf("Found a copy of %s in the SDK dir %s/%s",
                         platform_file_path, sdkroot_path.c_str(),

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

if (log) {
                   device_support_dir);
     }
     if (device_support_dir) {
       const bool find_directories = true;
       const bool find_files = false;
       const bool find_other = false;
 
       SDKDirectoryInfoCollection builtin_sdk_directory_infos;
-      FileSpec::EnumerateDirectory(m_device_support_directory.c_str(),
-                                   find_directories, find_files, find_other,
+      FileSpec::EnumerateDirectory(m_device_support_directory, find_directories,
+                                   find_files, find_other,
                                    GetContainedFilesIntoVectorOfStringsCallback,
                                    &builtin_sdk_directory_infos);
 
       // Only add SDK directories that have symbols in them, some SDKs only
       // contain
       // developer disk images and no symbols, so they aren't useful to us.
       FileSpec sdk_symbols_symlink_fspec;
       for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {
if (sdk_idx < m_sdk_directory_infos.size()) {
 
     if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
       // We may need to interpose "/Symbols/" or "/Symbols.Internal/" between
       // the
       // SDK root directory and the file path.
 
       const char *paths_to_try[] = {"Symbols", "", "Symbols.Internal", nullptr};
       for (size_t i = 0; paths_to_try[i] != nullptr; i++) {
-        local_file.SetFile(sdkroot_path.c_str(), false);
+        local_file.SetFile(sdkroot_path, false);
         if (paths_to_try[i][0] != '\0')
           local_file.AppendPathComponent(paths_to_try[i]);
         local_file.AppendPathComponent(platform_file_path);
         local_file.ResolvePath();
         if (local_file.Exists()) {
           if (log)
             log->Printf("Found a copy of %s in the SDK dir %s/%s",
                         platform_file_path, sdkroot_path.c_str(),

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

Error NativeProcessLinux::GetLoadedModuleFileSpec(const char *module_path,
   file_spec.Clear();
   ProcFileReader::ProcessLineByLine(
       GetID(), "maps", [&](const std::string &line) {
         SmallVector<StringRef, 16> columns;
         StringRef(line).split(columns, " ", -1, false);
         if (columns.size() < 6)
           return true; // continue searching
 
-        FileSpec this_file_spec(columns[5].str().c_str(), false);
+        FileSpec this_file_spec(columns[5].str(), false);
         if (this_file_spec.GetFilename() != module_file_spec.GetFilename())
           return true; // continue searching
 
         file_spec = this_file_spec;
         found = true;
         return false; // we are done
       });
 

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

if (content_length == std::string::npos) {
                         (int)(total_length), m_bytes.c_str());
           else
             log->Printf("<%4" PRIu64 "> read packet: %.*s",
                         (uint64_t)total_length, (int)(total_length),
                         m_bytes.c_str());
         }
       }
 
-      m_history.AddPacket(m_bytes.c_str(), total_length,
-                          History::ePacketTypeRecv, total_length);
+      m_history.AddPacket(m_bytes, total_length, History::ePacketTypeRecv,
+                          total_length);
 
       // Clear packet_str in case there is some existing data in it.
       packet_str.clear();
       // Copy the packet from m_bytes to packet_str expanding the
       // run-length encoding in the process.
       // Reserve enough byte for the most common case (no RLE used)
       packet_str.reserve(m_bytes.length());
       for (std::string::const_iterator c = m_bytes.begin() + content_start;

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

m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
                                   // not, we assume no limit
 
   // build the qSupported packet
   std::vector<std::string> features = {"xmlRegisters=i386,arm,mips"};
   StreamString packet;
   packet.PutCString("qSupported");
   for (uint32_t i = 0; i < features.size(); ++i) {
     packet.PutCString(i == 0 ? ":" : ";");
-    packet.PutCString(features[i].c_str());
+    packet.PutCString(features[i]);
   }
 
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(packet.GetData(), response,
                                    /*send_async=*/false) ==
       PacketResult::Success) {
     const char *response_cstr = response.GetStringRef().c_str();
 
for (auto compression : supported_compressions) {
       }
     }
   }
 #endif
 
   if (avail_type != CompressionType::None) {
     StringExtractorGDBRemote response;
     std::string packet = "QEnableCompression:type:" + avail_name + ";";
-    if (SendPacketAndWaitForResponse(packet.c_str(), response, false) !=
+    if (SendPacketAndWaitForResponse(packet, response, false) !=
         PacketResult::Success)
       return;
 
     if (response.IsOKResponse()) {
       m_compression_type = avail_type;
     }
   }
 }
while (response.GetNameColonValue(name, value)) {
         extractor.GetHexByteString(triple);
         process_info.GetArchitecture().SetTriple(triple.c_str());
       } 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.c_str(), false);
+        process_info.GetExecutableFile().SetFile(name, false);
       } else if (name.equals("cputype")) {
         value.getAsInteger(0, cpu);
       } else if (name.equals("cpusubtype")) {
         value.getAsInteger(0, sub);
       } else if (name.equals("vendor")) {
         vendor = value;
       } else if (name.equals("ostype")) {
         os_type = value;
if (!match_info.MatchAllProcesses()) {
                       match_info.GetProcessInfo().GetEffectiveGroupID());
       if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
         packet.Printf("all_users:%u;", match_info.GetMatchAllUsers() ? 1 : 0);
       if (match_info.GetProcessInfo().GetArchitecture().IsValid()) {
         const ArchSpec &match_arch =
             match_info.GetProcessInfo().GetArchitecture();
         const llvm::Triple &triple = match_arch.GetTriple();
         packet.PutCString("triple:");
-        packet.PutCString(triple.getTriple().c_str());
+        packet.PutCString(triple.getTriple());
         packet.PutChar(';');
       }
     }
     StringExtractorGDBRemote response;
     // Increase timeout as the first qfProcessInfo packet takes a long time
     // on Android. The value of 1min was arrived at empirically.
     ScopedTimeout timeout(*this, std::chrono::seconds(60));
     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
while (response.GetNameColonValue(name, value)) {
     } else if (name == "file_size") {
       uint64_t ival = 0;
       if (!value.getAsInteger(16, ival))
         module_spec.SetObjectSize(ival);
     } else if (name == "file_path") {
       StringExtractor extractor(value);
       std::string path;
       extractor.GetHexByteString(path);
-      module_spec.GetFileSpec() = FileSpec(path.c_str(), false, arch_spec);
+      module_spec.GetFileSpec() = FileSpec(path, false, arch_spec);
     }
   }
 
   return true;
 }
 
 static llvm::Optional<ModuleSpec>
 ParseModuleSpec(StructuredData::Dictionary *dict) {
while (active) {
 
     // send query extended feature packet
     std::stringstream packet;
     packet << "qXfer:" << object.AsCString("")
            << ":read:" << annex.AsCString("") << ":" << std::hex << offset
            << "," << std::hex << size;
 
     GDBRemoteCommunication::PacketResult res =
-        SendPacketAndWaitForResponse(packet.str().c_str(), chunk, false);
+        SendPacketAndWaitForResponse(packet.str(), chunk, false);
 
     if (res != GDBRemoteCommunication::PacketResult::Success) {
       err.SetErrorString("Error sending $qXfer packet");
       return false;
     }
 
     const std::string &str = chunk.GetStringRef();
     if (str.length() == 0) {
if (config_sp) {
     stream.PutEscapedBytes(unescaped_stream.GetData(),
                            unescaped_stream.GetSize());
   }
   stream.Flush();
 
   // Send the packet.
   const bool send_async = false;
   StringExtractorGDBRemote response;
-  auto result = SendPacketAndWaitForResponse(stream.GetString().c_str(),
-                                             response, send_async);
+  auto result =
+      SendPacketAndWaitForResponse(stream.GetString(), response, send_async);
   if (result == PacketResult::Success) {
     // We failed if the config result comes back other than OK.
     if (strcmp(response.GetStringRef().c_str(), "OK") == 0) {
       // Okay!
       error.Clear();
     } else {
       error.SetErrorStringWithFormat("configuring StructuredData feature "
                                      "%s failed with error %s",

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

if (packet.GetChar() == ':') {
     llvm::StringRef key;
     llvm::StringRef value;
     while (packet.GetNameColonValue(key, value)) {
       bool success = true;
       if (key.equals("name")) {
         StringExtractor extractor(value);
         std::string file;
         extractor.GetHexByteString(file);
-        match_info.GetProcessInfo().GetExecutableFile().SetFile(file.c_str(),
-                                                                false);
+        match_info.GetProcessInfo().GetExecutableFile().SetFile(file, false);
       } else if (key.equals("name_match")) {
         NameMatchType name_match =
             llvm::StringSwitch<NameMatchType>(value)
                 .Case("equals", eNameMatchEquals)
                 .Case("starts_with", eNameMatchStartsWith)
                 .Case("ends_with", eNameMatchEndsWith)
                 .Case("contains", eNameMatchContains)
                 .Case("regex", eNameMatchRegularExpression)

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Size(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:size:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
-    lldb::user_id_t retcode =
-        FileSystem::GetFileSize(FileSpec(path.c_str(), false));
+    lldb::user_id_t retcode = FileSystem::GetFileSize(FileSpec(path, false));
     StreamString response;
     response.PutChar('F');
     response.PutHex64(retcode);
     if (retcode == UINT64_MAX) {
       response.PutChar(',');
       response.PutHex64(
           retcode); // TODO: replace with Host::GetSyswideErrorCode()
     }

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Exists(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:exists:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
-    bool retcode = FileSystem::GetFileExists(FileSpec(path.c_str(), false));
+    bool retcode = FileSystem::GetFileExists(FileSpec(path, false));
     StreamString response;
     response.PutChar('F');
     response.PutChar(',');
     if (retcode)
       response.PutChar('1');
     else
       response.PutChar('0');
     return SendPacketNoLock(response.GetString());

 GDBRemoteCommunicationServerCommon::Handle_vFile_MD5(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:MD5:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
     uint64_t a, b;
     StreamGDBRemote response;
-    if (!FileSystem::CalculateMD5(FileSpec(path.c_str(), false), a, b)) {
+    if (!FileSystem::CalculateMD5(FileSpec(path, false), a, b)) {
       response.PutCString("F,");
       response.PutCString("x");
     } else {
       response.PutCString("F,");
       response.PutHex64(a);
       response.PutHex64(b);
     }
     return SendPacketNoLock(response.GetString());
else {
               // If there are any bytes left
               if (packet.GetBytesLeft()) {
                 if (packet.GetChar() != ',')
                   success = false;
               }
 
               if (success) {
                 if (arg_idx == 0)
-                  m_process_launch_info.GetExecutableFile().SetFile(arg.c_str(),
-                                                                    false);
+                  m_process_launch_info.GetExecutableFile().SetFile(arg, false);
                 m_process_launch_info.GetArguments().AppendArgument(arg);
                 if (log)
                   log->Printf("LLGSPacketHandler::%s added arg %d: \"%s\"",
                               __FUNCTION__, actual_arg_index, arg.c_str());
                 ++actual_arg_index;
               }
             }
           }
#endif
   }
 }
 
 FileSpec GDBRemoteCommunicationServerCommon::FindModuleFile(
     const std::string &module_path, const ArchSpec &arch) {
 #ifdef __ANDROID__
   return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
 #else
-  return FileSpec(module_path.c_str(), true);
+  return FileSpec(module_path, true);
 #endif
 }
 
 ModuleSpec GDBRemoteCommunicationServerCommon::GetModuleInfo(
     const std::string &module_path, const std::string &triple) {
   ArchSpec arch(triple.c_str());
 
-  const FileSpec req_module_path_spec(module_path.c_str(), true);
+  const FileSpec req_module_path_spec(module_path, true);
   const FileSpec module_path_spec =
       FindModuleFile(req_module_path_spec.GetPath(), arch);
   const ModuleSpec module_spec(module_path_spec, arch);
 
   ModuleSpecList module_specs;
   if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
                                            module_specs))
     return ModuleSpec();
 
   ModuleSpec matched_module_spec;
   if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
     return ModuleSpec();
 
   return matched_module_spec;
 }

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

GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
 
   // Include the thread name if there is one.
   const std::string thread_name = thread_sp->GetName();
   if (!thread_name.empty()) {
     size_t thread_name_len = thread_name.length();
 
     if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) {
       response.PutCString("name:");
-      response.PutCString(thread_name.c_str());
+      response.PutCString(thread_name);
     } else {
       // The thread name contains special chars, send as hex bytes.
       response.PutCString("hexname:");
       response.PutCStringAsRawHex8(thread_name.c_str());
     }
     response.PutChar(';');
   }
 

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

debugserver_launch_info.SetMonitorProcessCallback(
       std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped,
                 this, std::placeholders::_1),
       false);
 
   std::string platform_scheme;
   std::string platform_ip;
   int platform_port;
   std::string platform_path;
-  bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme,
+  bool ok = UriParser::Parse(GetConnection()->GetURI(), platform_scheme,
                              platform_ip, platform_port, platform_path);
   UNUSED_IF_ASSERT_DISABLED(ok);
   assert(ok);
 
   std::ostringstream url;
 // debugserver does not accept the URL scheme prefix.
 #if !defined(__APPLE__)
   url << m_socket_scheme << "://";

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

while (stop_packet.GetNameColonValue(key, value)) {
         uint32_t wp_index = LLDB_INVALID_INDEX32;
 
         if (wp_sp)
           wp_index = wp_sp->GetHardwareIndex();
 
         reason = "watchpoint";
         StreamString ostr;
         ostr.Printf("%" PRIu64 " %" PRIu32, wp_addr, wp_index);
-        description = ostr.GetString().c_str();
+        description = ostr.GetString();
       } else if (key.compare("library") == 0) {
         LoadModules();
       } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
         uint32_t reg = UINT32_MAX;
         if (!key.getAsInteger(16, reg))
           expedited_register_map[reg] = std::move(value);
       }
     }
for (LoadedModuleInfoList::LoadedModuleInfo &modInfo : module_list.m_list) {
     valid &= modInfo.get_base(mod_base);
     valid &= modInfo.get_base_is_offset(mod_base_is_offset);
     if (!valid)
       continue;
 
     if (!modInfo.get_link_map(link_map))
       link_map = LLDB_INVALID_ADDRESS;
 
-    FileSpec file(mod_name.c_str(), true);
+    FileSpec file(mod_name, true);
     lldb::ModuleSP module_sp =
         LoadModuleAtAddress(file, link_map, mod_base, mod_base_is_offset);
 
     if (module_sp.get())
       new_modules.Append(module_sp);
   }
 
   if (new_modules.GetSize() > 0) {

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

Reset(PyRefType::Owned,
                         nullptr));
 #endif
 }
 
 uint32_t PythonFile::GetOptionsFromMode(llvm::StringRef mode) {
   if (mode.empty())
     return 0;
 
-  return llvm::StringSwitch<uint32_t>(mode.str().c_str())
+  return llvm::StringSwitch<uint32_t>(mode.str())
       .Case("r", File::eOpenOptionRead)
       .Case("w", File::eOpenOptionWrite)
       .Case("a", File::eOpenOptionWrite | File::eOpenOptionAppend |
                      File::eOpenOptionCanCreate)
       .Case("r+", File::eOpenOptionRead | File::eOpenOptionWrite)
       .Case("w+", File::eOpenOptionRead | File::eOpenOptionWrite |
                       File::eOpenOptionCanCreate | File::eOpenOptionTruncate)
       .Case("a+", File::eOpenOptionRead | File::eOpenOptionWrite |

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 
 // Switch over to the #if 0 branch once we figure out
 // how we want to present settings for the tri-state of
 // no-activity, activity (most derived only), or activity-chain.
 #if 1
       // Display the activity chain, from parent-most to child-most
       // activity, separated by a colon (:).
       stream.PutCString("activity-chain=");
-      stream.PutCString(activity_chain.c_str());
+      stream.PutCString(activity_chain);
 #else
       if (GetGlobalProperties()->GetDisplayActivityChain()) {
         // Display the activity chain, from parent-most to child-most
         // activity, separated by a colon (:).
         stream.PutCString("activity-chain=");
         stream.PutCString(activity_chain.c_str());
       } else {
         // We're only displaying the child-most activity.
#endif
 
   if (options_sp->GetDisplaySubsystem()) {
     std::string subsystem;
     if (event.GetValueForKeyAsString("subsystem", subsystem) &&
         !subsystem.empty()) {
       if (header_count > 0)
         stream.PutChar(',');
       stream.PutCString("subsystem=");
-      stream.PutCString(subsystem.c_str());
+      stream.PutCString(subsystem);
       ++header_count;
     }
   }
 
   if (options_sp->GetDisplayCategory()) {
     std::string category;
     if (event.GetValueForKeyAsString("category", category) &&
         !category.empty()) {
       if (header_count > 0)
         stream.PutChar(',');
       stream.PutCString("category=");
-      stream.PutCString(category.c_str());
+      stream.PutCString(category);
       ++header_count;
     }
   }
   stream.PutCString("] ");
 
   auto &result = stream.GetString();
-  output_stream.PutCString(result.c_str());
+  output_stream.PutCString(result);
 
   return result.size();
 }
 
 size_t StructuredDataDarwinLog::HandleDisplayOfEvent(
     const StructuredData::Dictionary &event, Stream &stream) {
   // Check the type of the event.
   ConstString event_type;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugPubnamesSet.cpp

 }
 
 void DWARFDebugPubnamesSet::Find(
     const RegularExpression &regex,
     std::vector<dw_offset_t> &die_offset_coll) const {
   DescriptorConstIter pos;
   DescriptorConstIter end = m_descriptors.end();
   for (pos = m_descriptors.begin(); pos != end; ++pos) {
-    if (regex.Execute(pos->name.c_str()))
+    if (regex.Execute(pos->name))
       die_offset_coll.push_back(m_header.die_offset + pos->offset);
   }
 }

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

void SymbolFilePDB::FindTypesByRegex(const std::string &regex,
   }
 }
 
 void SymbolFilePDB::FindTypesByName(const std::string &name,
                                     uint32_t max_matches,
                                     lldb_private::TypeMap &types) {
   auto global = m_session_up->getGlobalScope();
   std::unique_ptr<IPDBEnumSymbols> results;
-  results = global->findChildren(PDB_SymType::None, name.c_str(),
+  results = global->findChildren(PDB_SymType::None, name,
                                  PDB_NameSearchFlags::NS_Default);
 
   uint32_t matches = 0;
 
   while (auto result = results->getNext()) {
     if (max_matches > 0 && matches >= max_matches)
       break;
     switch (result->getSymTag()) {

lldb/trunk/source/Symbol/ClangASTContext.cpp

if (idx_is_valid && GetCompleteType(type)) {
       uint32_t field_idx = 0;
       clang::RecordDecl::field_iterator field, field_end;
       for (field = record_decl->field_begin(),
           field_end = record_decl->field_end();
            field != field_end; ++field, ++field_idx, ++child_idx) {
         if (idx == child_idx) {
           // Print the member type if requested
           // Print the member name and equal sign
-          child_name.assign(field->getNameAsString().c_str());
+          child_name.assign(field->getNameAsString());
 
           // Figure out the type byte size (field_type_info.first) and
           // alignment (field_type_info.second) from the AST context.
           CompilerType field_clang_type(getASTContext(), field->getType());
           assert(field_idx < record_layout.getFieldCount());
           child_byte_size = field_clang_type.GetByteSize(
               exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
           const uint32_t child_bit_size = child_byte_size * 8;
if (idx_is_valid && GetCompleteType(type)) {
               if (base_class_clang_type.GetNumChildren(
                       omit_empty_base_classes) > 0) {
                 if (idx == 0) {
                   clang::QualType ivar_qual_type(
                       getASTContext()->getObjCInterfaceType(
                           superclass_interface_decl));
 
                   child_name.assign(
-                      superclass_interface_decl->getNameAsString().c_str());
+                      superclass_interface_decl->getNameAsString());
 
                   clang::TypeInfo ivar_type_info =
                       getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr());
 
                   child_byte_size = ivar_type_info.Width / 8;
                   child_byte_offset = 0;
                   child_is_base_class = true;
 
if (idx_is_valid && GetCompleteType(type)) {
 
             for (ivar_pos = class_interface_decl->ivar_begin();
                  ivar_pos != ivar_end; ++ivar_pos) {
               if (child_idx == idx) {
                 clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
 
                 clang::QualType ivar_qual_type(ivar_decl->getType());
 
-                child_name.assign(ivar_decl->getNameAsString().c_str());
+                child_name.assign(ivar_decl->getNameAsString());
 
                 clang::TypeInfo ivar_type_info =
                     getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr());
 
                 child_byte_size = ivar_type_info.Width / 8;
 
                 // Figure out the field offset within the current
                 // struct/union/class type
if (class_interface_decl && property_clang_type_to_access.IsValid()) {
         class_interface_decl->addDecl(property_decl);
 
         clang::Selector setter_sel, getter_sel;
 
         if (property_setter_name != nullptr) {
           std::string property_setter_no_colon(
               property_setter_name, strlen(property_setter_name) - 1);
           clang::IdentifierInfo *setter_ident =
-              &clang_ast->Idents.get(property_setter_no_colon.c_str());
+              &clang_ast->Idents.get(property_setter_no_colon);
           setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident);
         } else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) {
           std::string setter_sel_string("set");
           setter_sel_string.push_back(::toupper(property_name[0]));
           setter_sel_string.append(&property_name[1]);
           clang::IdentifierInfo *setter_ident =
-              &clang_ast->Idents.get(setter_sel_string.c_str());
+              &clang_ast->Idents.get(setter_sel_string);
           setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident);
         }
         property_decl->setSetterName(setter_sel);
         property_decl->setPropertyAttributes(
             clang::ObjCPropertyDecl::OBJC_PR_setter);
 
         if (property_getter_name != nullptr) {
           clang::IdentifierInfo *getter_ident =
case clang::Type::Enum:
         lldb::offset_t offset = byte_offset;
         if (is_signed) {
           const int64_t enum_svalue = data.GetMaxS64Bitfield(
               &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
           for (enum_pos = enum_decl->enumerator_begin(),
               enum_end_pos = enum_decl->enumerator_end();
                enum_pos != enum_end_pos; ++enum_pos) {
             if (enum_pos->getInitVal().getSExtValue() == enum_svalue) {
-              s->PutCString(enum_pos->getNameAsString().c_str());
+              s->PutCString(enum_pos->getNameAsString());
               return true;
             }
           }
           // If we have gotten here we didn't get find the enumerator in the
           // enum decl, so just print the integer.
           s->Printf("%" PRIi64, enum_svalue);
         } else {
           const uint64_t enum_uvalue = data.GetMaxU64Bitfield(
               &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
           for (enum_pos = enum_decl->enumerator_begin(),
               enum_end_pos = enum_decl->enumerator_end();
                enum_pos != enum_end_pos; ++enum_pos) {
             if (enum_pos->getInitVal().getZExtValue() == enum_uvalue) {
-              s->PutCString(enum_pos->getNameAsString().c_str());
+              s->PutCString(enum_pos->getNameAsString());
               return true;
             }
           }
           // If we have gotten here we didn't get find the enumerator in the
           // enum decl, so just print the integer.
           s->Printf("%" PRIu64, enum_uvalue);
         }
         return true;
case clang::Type::Typedef: {
       const clang::TypedefType *typedef_type =
           qual_type->getAs<clang::TypedefType>();
       if (typedef_type) {
         const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
         std::string clang_typedef_name(
             typedef_decl->getQualifiedNameAsString());
         if (!clang_typedef_name.empty()) {
           s->PutCString("typedef ");
-          s->PutCString(clang_typedef_name.c_str());
+          s->PutCString(clang_typedef_name);
         }
       }
     } break;
 
     case clang::Type::Auto:
       CompilerType(getASTContext(),
                    llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
           .DumpTypeDescription(s);
default: {
           llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
       if (tag_type) {
         clang::TagDecl *tag_decl = tag_type->getDecl();
         if (tag_decl)
           tag_decl->print(llvm_ostrm, 0);
       } else {
         std::string clang_type_name(qual_type.getAsString());
         if (!clang_type_name.empty())
-          s->PutCString(clang_type_name.c_str());
+          s->PutCString(clang_type_name);
       }
     }
     }
 
     if (buf.size() > 0) {
       s->Write(buf.data(), buf.size());
     }
   }

lldb/trunk/source/Symbol/ObjectFile.cpp

bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
   RegularExpression g_object_regex(llvm::StringRef("(.*)\\(([^\\)]+)\\)$"));
   RegularExpression::Match regex_match(2);
   if (g_object_regex.Execute(llvm::StringRef::withNullAsEmpty(path_with_object),
                              &regex_match)) {
     std::string path;
     std::string obj;
     if (regex_match.GetMatchAtIndex(path_with_object, 1, path) &&
         regex_match.GetMatchAtIndex(path_with_object, 2, obj)) {
-      archive_file.SetFile(path.c_str(), false);
+      archive_file.SetFile(path, false);
       archive_object.SetCString(obj.c_str());
       if (must_exist && !archive_file.Exists())
         return false;
       return true;
     }
   }
   return false;
 }

lldb/trunk/source/Symbol/SymbolContext.cpp

if (m_target_sp.get() != sc.target_sp.get())
     return false;
 
   if (m_type & eModuleSpecified) {
     if (sc.module_sp) {
       if (m_module_sp.get() != nullptr) {
         if (m_module_sp.get() != sc.module_sp.get())
           return false;
       } else {
-        FileSpec module_file_spec(m_module_spec.c_str(), false);
+        FileSpec module_file_spec(m_module_spec, false);
         if (!FileSpec::Equal(module_file_spec, sc.module_sp->GetFileSpec(),
                              false))
           return false;
       }
     }
   }
   if (m_type & eFileSpecified) {
     if (m_file_spec_ap.get()) {

lldb/trunk/source/Target/Platform.cpp

case FileSpec::eFileTypeDirectory: {
     // now recurse
     std::string src_dir_path(src.GetPath());
 
     // Make a filespec that only fills in the directory of a FileSpec so
     // when we enumerate we can quickly fill in the filename for dst copies
     FileSpec recurse_dst;
     recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
     RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr, Error()};
-    FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true,
+    FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
                                  RecurseCopy_Callback, &rc_baton2);
     if (rc_baton2.error.Fail()) {
       rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
       return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
     return FileSpec::eEnumerateDirectoryResultNext;
   } break;
 
case FileSpec::eFileTypeDirectory: {
       error = MakeDirectory(fixed_dst, permissions);
       if (error.Success()) {
         // Make a filespec that only fills in the directory of a FileSpec so
         // when we enumerate we can quickly fill in the filename for dst copies
         FileSpec recurse_dst;
         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
         std::string src_dir_path(src.GetPath());
         RecurseCopyBaton baton = {recurse_dst, this, Error()};
-        FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true,
+        FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
                                      RecurseCopy_Callback, &baton);
         return baton.error;
       }
     } break;
 
     case FileSpec::eFileTypeRegular:
       if (GetFileExists(fixed_dst))
         Unlink(fixed_dst);

lldb/trunk/source/Target/ProcessLaunchInfo.cpp

if (m_shell) {
           }
           std::string curr_path;
           if (HostInfo::GetEnvironmentVar("PATH", curr_path)) {
             if (new_path.size() > empty_path_len)
               new_path += ':';
             new_path += curr_path;
           }
           new_path += "\" ";
-          shell_command.PutCString(new_path.c_str());
+          shell_command.PutCString(new_path);
         }
 
         if (triple.getOS() != llvm::Triple::Win32 ||
             triple.isWindowsCygwinEnvironment())
           shell_command.PutCString("exec");
 
         // Only Apple supports /usr/bin/arch being able to specify the
         // architecture

lldb/trunk/source/Target/TargetList.cpp

if (file.IsRelative() && user_exe_path) {
       if (!((user_exe_path[0] == '.' && user_exe_path[1] == '/') ||
             (user_exe_path[0] == '.' && user_exe_path[1] == '.' &&
              user_exe_path[2] == '/'))) {
         char cwd[PATH_MAX];
         if (getcwd(cwd, sizeof(cwd))) {
           std::string cwd_user_exe_path(cwd);
           cwd_user_exe_path += '/';
           cwd_user_exe_path += user_exe_path;
-          FileSpec cwd_file(cwd_user_exe_path.c_str(), false);
+          FileSpec cwd_file(cwd_user_exe_path, false);
           if (cwd_file.Exists())
             file = cwd_file;
         }
       }
     }
 
     ModuleSP exe_module_sp;
     if (platform_sp) {

lldb/trunk/source/Utility/ModuleCache.cpp

 }
 
 FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
   const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
   return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
 }
 
 FileSpec GetSymbolFileSpec(const FileSpec &module_file_spec) {
-  return FileSpec((module_file_spec.GetPath() + kSymFileExtension).c_str(),
-                  false);
+  return FileSpec(module_file_spec.GetPath() + kSymFileExtension, false);
 }
 
 void DeleteExistingModule(const FileSpec &root_dir_spec,
                           const FileSpec &sysroot_module_path_spec) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
   UUID module_uuid;
   {
     auto module_sp =
Error ModuleCache::Put(const FileSpec &root_dir_spec, const char *hostname,
                        const ModuleSpec &module_spec, const FileSpec &tmp_file,
                        const FileSpec &target_file) {
   const auto module_spec_dir =
       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
   const auto module_file_path =
       JoinPath(module_spec_dir, target_file.GetFilename().AsCString());
 
   const auto tmp_file_path = tmp_file.GetPath();
-  const auto err_code = llvm::sys::fs::rename(
-      tmp_file_path.c_str(), module_file_path.GetPath().c_str());
+  const auto err_code =
+      llvm::sys::fs::rename(tmp_file_path, module_file_path.GetPath());
   if (err_code)
     return Error("Failed to rename file %s to %s: %s", tmp_file_path.c_str(),
                  module_file_path.GetPath().c_str(),
                  err_code.message().c_str());
 
   const auto error = CreateHostSysRootModuleLink(
       root_dir_spec, hostname, target_file, module_file_path, true);
   if (error.Fail())
Error ModuleCache::GetAndPut(const FileSpec &root_dir_spec,
   // Check local cache for a module.
   error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
               cached_module_sp, did_create_ptr);
   if (error.Success())
     return error;
 
   const auto tmp_download_file_spec = JoinPath(module_spec_dir, kTempFileName);
   error = module_downloader(module_spec, tmp_download_file_spec);
-  llvm::FileRemover tmp_file_remover(tmp_download_file_spec.GetPath().c_str());
+  llvm::FileRemover tmp_file_remover(tmp_download_file_spec.GetPath());
   if (error.Fail())
     return Error("Failed to download module: %s", error.AsCString());
 
   // Put downloaded file into local module cache.
   error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
               tmp_download_file_spec, module_spec.GetFileSpec());
   if (error.Fail())
     return Error("Failed to put module into cache: %s", error.AsCString());
 
   tmp_file_remover.releaseFile();
   error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
               cached_module_sp, did_create_ptr);
   if (error.Fail())
     return error;
 
   // Fetching a symbol file for the module
   const auto tmp_download_sym_file_spec =
       JoinPath(module_spec_dir, kTempSymFileName);
   error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
-  llvm::FileRemover tmp_symfile_remover(
-      tmp_download_sym_file_spec.GetPath().c_str());
+  llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
   if (error.Fail())
     // Failed to download a symfile but fetching the module was successful. The
     // module might
     // contain the necessary symbols and the debugging is also possible without
     // a symfile.
     return Error();
 
   error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,

lldb/trunk/tools/lldb-server/Acceptor.cpp

for (auto s : socket_schemes) {
     if (s.m_protocol == protocol)
       return s.m_scheme;
   }
   return nullptr;
 }
 }
 
 Error Acceptor::Listen(int backlog) {
-  return m_listener_socket_up->Listen(StringRef(m_name.c_str()), backlog);
+  return m_listener_socket_up->Listen(StringRef(m_name), backlog);
 }
 
 Error Acceptor::Accept(const bool child_processes_inherit, Connection *&conn) {
   Socket *conn_socket = nullptr;
   auto error = m_listener_socket_up->Accept(
-      StringRef(m_name.c_str()), child_processes_inherit, conn_socket);
+      StringRef(m_name), child_processes_inherit, conn_socket);
   if (error.Success())
     conn = new ConnectionFileDescriptor(conn_socket);
 
   return error;
 }
 
 Socket::SocketProtocol Acceptor::GetSocketProtocol() const {
   return m_listener_socket_up->GetSocketProtocol();

lldb/trunk/tools/lldb-server/lldb-platform.cpp

static Error save_socket_id_to_file(const std::string &socket_id,
 
   {
     std::ofstream temp_file(temp_file_path.c_str(), std::ios::out);
     if (!temp_file.is_open())
       return Error("Failed to open temp file %s", temp_file_path.c_str());
     temp_file << socket_id;
   }
 
-  err_code = llvm::sys::fs::rename(temp_file_path.c_str(),
-                                   file_spec.GetPath().c_str());
+  err_code = llvm::sys::fs::rename(temp_file_path.c_str(), file_spec.GetPath());
   if (err_code)
     return Error("Failed to rename file %s to %s: %s", temp_file_path.c_str(),
                  file_spec.GetPath().c_str(), err_code.message().c_str());
 
   tmp_file_remover.releaseFile();
   return Error();
 }
 

lldb/trunk/unittests/Host/SocketTest.cpp

void CreateConnectedSockets(
     std::thread accept_thread(AcceptThread, listen_socket_up.get(),
                               listen_remote_address, child_processes_inherit,
                               &accept_socket, &accept_error);
 
     std::string connect_remote_address = get_connect_addr(*listen_socket_up);
     std::unique_ptr<SocketType> connect_socket_up(
         new SocketType(child_processes_inherit, error));
     EXPECT_FALSE(error.Fail());
-    error = connect_socket_up->Connect(connect_remote_address.c_str());
+    error = connect_socket_up->Connect(connect_remote_address);
     EXPECT_FALSE(error.Fail());
     EXPECT_TRUE(connect_socket_up->IsValid());
 
     a_up->swap(connect_socket_up);
     EXPECT_TRUE(error.Success());
     EXPECT_NE(nullptr, a_up->get());
     EXPECT_TRUE((*a_up)->IsValid());
 

lldb/trunk/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp

for (auto Enum : EnumsToCheck) {
     EXPECT_TRUE(ClangASTContext::IsEnumType(compiler_type.GetOpaqueQualType()));
     clang::EnumDecl *enum_decl = ClangASTContext::GetAsEnumDecl(compiler_type);
     EXPECT_NE(nullptr, enum_decl);
     EXPECT_EQ(2, std::distance(enum_decl->enumerator_begin(),
                                enum_decl->enumerator_end()));
 
     std::string sizeof_var = "sizeof_";
     sizeof_var.append(Enum);
-    EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var.c_str()),
+    EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var),
               enum_type->GetByteSize());
   }
 }
 
 TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestArrayTypes)) {
   // In order to get this test working, we need to support lookup by symbol
   // name.  Because array
   // types themselves do not have names, only the symbols have names (i.e. the
for (auto Typedef : TypedefsToCheck) {
     CompilerType compiler_type = typedef_type->GetFullCompilerType();
     ClangASTContext *clang_type_system =
         llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
     EXPECT_TRUE(
         clang_type_system->IsTypedefType(compiler_type.GetOpaqueQualType()));
 
     std::string sizeof_var = "sizeof_";
     sizeof_var.append(Typedef);
-    EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var.c_str()),
+    EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var),
               typedef_type->GetByteSize());
   }
 }
 
 TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestRegexNameMatch)) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);