[lldb][tsan] Avoid some string copies (NFC)

[compnerd]

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

289 ↗

(On Diff #66202)

Why not make count_name a const std::string & as well?

[vsk]

• Catch a few more copies pointed out by @compnerd.

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

for (int i = 0; i < t.unique_tid_count; i++) {
     t.unique_tids[i].idx = i;
     __tsan_get_report_unique_tid(t.report, i, &t.unique_tids[i].tid);
 }
 
 t;
 )";
 
 static StructuredData::Array *
-CreateStackTrace(ValueObjectSP o, std::string trace_item_name = ".trace") {
+CreateStackTrace(ValueObjectSP o, const std::string &trace_item_name = ".trace") {
     StructuredData::Array *trace = new StructuredData::Array();
     ValueObjectSP trace_value_object = o->GetValueForExpressionPath(trace_item_name.c_str());
     for (int j = 0; j < 8; j++) {
         addr_t trace_addr = trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
         if (trace_addr == 0)
             break;
         trace->AddItem(StructuredData::ObjectSP(new StructuredData::Integer(trace_addr)));
     }
     return trace;
 }
 
 static StructuredData::Array *
-ConvertToStructuredArray(ValueObjectSP return_value_sp, std::string items_name, std::string count_name, std::function <void(ValueObjectSP o, StructuredData::Dictionary *dict)> const &callback)
+ConvertToStructuredArray(ValueObjectSP return_value_sp, const std::string &items_name, const std::string &count_name, std::function <void(ValueObjectSP o, StructuredData::Dictionary *dict)> const &callback)
 {
     StructuredData::Array *array = new StructuredData::Array();
     unsigned int count = return_value_sp->GetValueForExpressionPath(count_name.c_str())->GetValueAsUnsigned(0);
     ValueObjectSP objects = return_value_sp->GetValueForExpressionPath(items_name.c_str());
     for (unsigned int i = 0; i < count; i++) {
         ValueObjectSP o = objects->GetChildAtIndex(i, true);
         StructuredData::Dictionary *dict = new StructuredData::Dictionary();
         
         callback(o, dict);
         
         array->AddItem(StructuredData::ObjectSP(dict));
     }
     return array;
 }
 
 static std::string
-RetrieveString(ValueObjectSP return_value_sp, ProcessSP process_sp, std::string expression_path)
+RetrieveString(ValueObjectSP return_value_sp, ProcessSP process_sp, const std::string &expression_path)
 {
     addr_t ptr = return_value_sp->GetValueForExpressionPath(expression_path.c_str())->GetValueAsUnsigned(0);
     std::string str;
     Error error;
     process_sp->ReadCStringFromMemory(ptr, str, error);
     return str;
 }
 
if (m_breakpoint_id != LLDB_INVALID_BREAK_ID)
             process_sp->GetTarget().RemoveBreakpointByID(m_breakpoint_id);
             m_breakpoint_id = LLDB_INVALID_BREAK_ID;
         }
     }
     m_is_active = false;
 }
 
 static std::string
-GenerateThreadName(std::string path, StructuredData::Object *o, StructuredData::ObjectSP main_info) {
+GenerateThreadName(const std::string &path, StructuredData::Object *o, StructuredData::ObjectSP main_info) {
     std::string result = "additional information";
     
     if (path == "mops") {
         int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();
         int thread_id = o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
         bool is_write = o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();
         bool is_atomic = o->GetObjectForDotSeparatedPath("is_atomic")->GetBooleanValue();
         addr_t addr = o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
GenerateThreadName(const std::string &path, StructuredData::Object *o, StructuredData::ObjectSP main_info) {
     }
     
     result[0] = toupper(result[0]);
     
     return result;
 }
 
 static void
-AddThreadsForPath(std::string path, ThreadCollectionSP threads, ProcessSP process_sp, StructuredData::ObjectSP info)
+AddThreadsForPath(const std::string &path, ThreadCollectionSP threads, ProcessSP process_sp, StructuredData::ObjectSP info)
 {
     info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach([process_sp, threads, path, info] (StructuredData::Object *o) -> bool {
         std::vector<lldb::addr_t> pcs;
         o->GetObjectForDotSeparatedPath("trace")->GetAsArray()->ForEach([&pcs] (StructuredData::Object *pc) -> bool {
             pcs.push_back(pc->GetAsInteger()->GetValue());
             return true;
         });