maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Update StructuredData::String to return StringRefs. 

It was returning const std::string& which was leading to
unnecessary copies all over the place, and preventing people
from doing things like Dict->GetValueForKeyAsString("foo", ref);

llvm-svn: 302875
This commit is contained in:
Zachary Turner 2017-05-12 05:49:54 +00:00
parent 41c9936460
commit 2833321f09
32 changed files with 122 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lldb/include/lldb/Breakpoint/Breakpoint.h
View File

@ -613,7 +613,7 @@ public:
lldb::SearchFilterSP GetSearchFilter() { return m_filter_sp; }
bool AddName(const char *new_name, Status &error);
bool AddName(llvm::StringRef new_name, Status &error);
void RemoveName(const char *name_to_remove) {
if (name_to_remove)

2
lldb/include/lldb/Breakpoint/BreakpointResolver.h
View File

@ -192,7 +192,7 @@ public:
static const char *ResolverTyToName(enum ResolverTy);
static ResolverTy NameToResolverTy(const char *name);
static ResolverTy NameToResolverTy(llvm::StringRef name);
virtual lldb::BreakpointResolverSP
CopyForBreakpoint(Breakpoint &breakpoint) = 0;

2
lldb/include/lldb/Core/SearchFilter.h
View File

@ -285,7 +285,7 @@ public:
static const char *FilterTyToName(enum FilterTy);
static FilterTy NameToFilterTy(const char *name);
static FilterTy NameToFilterTy(llvm::StringRef name);
protected:
// Serialization of SearchFilter options:

36
lldb/include/lldb/Core/StructuredData.h
View File

@ -143,15 +143,12 @@ public:
: nullptr);
}
std::string GetStringValue(const char *fail_value = nullptr) {
llvm::StringRef GetStringValue(const char *fail_value = nullptr) {
String *s = GetAsString();
if (s)
return s->GetValue();
if (fail_value && fail_value[0])
return std::string(fail_value);
return std::string();
return fail_value;
}
Generic *GetAsGeneric() {
@ -220,7 +217,7 @@ public:
return success;
}
bool GetItemAtIndexAsString(size_t idx, std::string &result) const {
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) const {
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
@ -231,8 +228,8 @@ public:
return false;
}
bool GetItemAtIndexAsString(size_t idx, std::string &result,
const std::string &default_val) const {
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result,
llvm::StringRef default_val) const {
bool success = GetItemAtIndexAsString(idx, result);
if (!success)
result = default_val;
@ -339,18 +336,13 @@ public:
class String : public Object {
public:
String(const char *cstr = nullptr) : Object(Type::eTypeString), m_value() {
if (cstr)
m_value = cstr;
}
String() : Object(Type::eTypeString) {}
explicit String(llvm::StringRef S)
: Object(Type::eTypeString), m_value(S) {}
String(const std::string &s) : Object(Type::eTypeString), m_value(s) {}
void SetValue(llvm::StringRef S) { m_value = S; }
String(const std::string &&s) : Object(Type::eTypeString), m_value(s) {}
void SetValue(const std::string &string) { m_value = string; }
const std::string &GetValue() { return m_value; }
llvm::StringRef GetValue() { return m_value; }
void Dump(Stream &s, bool pretty_print = true) const override;
@ -430,7 +422,7 @@ public:
}
bool GetValueForKeyAsString(llvm::StringRef key,
std::string &result) const {
llvm::StringRef &result) const {
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
@ -441,14 +433,14 @@ public:
return false;
}
bool GetValueForKeyAsString(llvm::StringRef key, std::string &result,
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result,
const char *default_val) const {
bool success = GetValueForKeyAsString(key, result);
if (!success) {
if (default_val)
result = default_val;
else
result.clear();
result = llvm::StringRef();
}
return success;
}
@ -513,7 +505,7 @@ public:
AddItem(key, std::make_shared<Float>(value));
}
void AddStringItem(llvm::StringRef key, std::string value) {
void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
AddItem(key, std::make_shared<String>(std::move(value)));
}

4
lldb/include/lldb/Target/ThreadSpec.h
View File

@ -55,9 +55,9 @@ public:
void SetTID(lldb::tid_t tid) { m_tid = tid; }
void SetName(const char *name) { m_name = name; }
void SetName(llvm::StringRef name) { m_name = name; }
void SetQueueName(const char *queue_name) { m_queue_name = queue_name; }
void SetQueueName(llvm::StringRef queue_name) { m_queue_name = queue_name; }
uint32_t GetIndex() const { return m_index; }

1
lldb/include/lldb/Utility/UUID.h
View File

@ -54,6 +54,7 @@ public:
std::string GetAsString(const char *separator = nullptr) const;
size_t SetFromStringRef(llvm::StringRef str, uint32_t num_uuid_bytes = 16);
size_t SetFromCString(const char *c_str, uint32_t num_uuid_bytes = 16);
// Decode as many UUID bytes (up to 16) as possible from the C string "cstr"

2
lldb/source/API/SBThread.cpp
View File

@ -562,7 +562,7 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
info_root_sp->GetObjectForDotSeparatedPath(path);
if (node) {
if (node->GetType() == StructuredData::Type::eTypeString) {
strm.Printf("%s", node->GetAsString()->GetValue().c_str());
strm.Printf("%s", node->GetAsString()->GetValue().str().c_str());
success = true;
}
if (node->GetType() == StructuredData::Type::eTypeInteger) {

12
lldb/source/Breakpoint/Breakpoint.cpp
View File

@ -207,10 +207,10 @@ lldb::BreakpointSP Breakpoint::CreateFromStructuredData(
if (success && names_array) {
size_t num_names = names_array->GetSize();
for (size_t i = 0; i < num_names; i++) {
std::string name;
llvm::StringRef name;
Status error;
success = names_array->GetItemAtIndexAsString(i, name);
result_sp->AddName(name.c_str(), error);
result_sp->AddName(name, error);
}
}
@ -242,7 +242,7 @@ bool Breakpoint::SerializedBreakpointMatchesNames(
std::vector<std::string>::iterator end = names.end();
for (size_t i = 0; i < num_names; i++) {
std::string name;
llvm::StringRef name;
if (names_array->GetItemAtIndexAsString(i, name)) {
if (std::find(begin, end, name) != end) {
return true;
@ -833,10 +833,10 @@ size_t Breakpoint::GetNumResolvedLocations() const {
size_t Breakpoint::GetNumLocations() const { return m_locations.GetSize(); }
bool Breakpoint::AddName(const char *new_name, Status &error) {
if (!new_name)
bool Breakpoint::AddName(llvm::StringRef new_name, Status &error) {
if (new_name.empty())
return false;
if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(new_name), error)) {
if (!BreakpointID::StringIsBreakpointName(new_name, error)) {
error.SetErrorStringWithFormat("input name \"%s\" not a breakpoint name.",
new_name);
return false;

4
lldb/source/Breakpoint/BreakpointOptions.cpp
View File

@ -73,7 +73,7 @@ BreakpointOptions::CommandData::CreateFromStructuredData(
if (success)
found_something = true;
std::string interpreter_str;
llvm::StringRef interpreter_str;
ScriptLanguage interp_language;
success = options_dict.GetValueForKeyAsString(
GetKey(OptionNames::Interpreter), interpreter_str);
@ -99,7 +99,7 @@ BreakpointOptions::CommandData::CreateFromStructuredData(
found_something = true;
size_t num_elems = user_source->GetSize();
for (size_t i = 0; i < num_elems; i++) {
std::string elem_string;
llvm::StringRef elem_string;
success = user_source->GetItemAtIndexAsString(i, elem_string);
if (success)
data_up->user_source.AppendString(elem_string);

12
lldb/source/Breakpoint/BreakpointResolver.cpp
View File

@ -56,9 +56,9 @@ const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
}
BreakpointResolver::ResolverTy
BreakpointResolver::NameToResolverTy(const char *name) {
BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
for (size_t i = 0; i < LastKnownResolverType; i++) {
if (strcmp(name, g_ty_to_name[i]) == 0)
if (name == g_ty_to_name[i])
return (ResolverTy)i;
}
return UnknownResolver;
@ -79,7 +79,7 @@ BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
return result_sp;
}
std::string subclass_name;
llvm::StringRef subclass_name;
bool success = resolver_dict.GetValueForKeyAsString(
GetSerializationSubclassKey(), subclass_name);
@ -90,10 +90,10 @@ BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
return result_sp;
}
ResolverTy resolver_type = NameToResolverTy(subclass_name.c_str());
ResolverTy resolver_type = NameToResolverTy(subclass_name);
if (resolver_type == UnknownResolver) {
error.SetErrorStringWithFormat("Unknown resolver type: %s.",
subclass_name.c_str());
error.SetErrorStringWithFormatv("Unknown resolver type: {0}.",
subclass_name);
return result_sp;
}

2
lldb/source/Breakpoint/BreakpointResolverAddress.cpp
View File

@ -45,7 +45,7 @@ BreakpointResolverAddress::~BreakpointResolverAddress() {}
BreakpointResolver *BreakpointResolverAddress::CreateFromStructuredData(
Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
Status &error) {
std::string module_name;
llvm::StringRef module_name;
lldb::addr_t addr_offset;
FileSpec module_filespec;
bool success;

2
lldb/source/Breakpoint/BreakpointResolverFileLine.cpp
View File

@ -39,7 +39,7 @@ BreakpointResolverFileLine::~BreakpointResolverFileLine() {}
BreakpointResolver *BreakpointResolverFileLine::CreateFromStructuredData(
Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
Status &error) {
std::string filename;
llvm::StringRef filename;
uint32_t line_no;
bool check_inlines;
bool skip_prologue;

4
lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp
View File

@ -40,7 +40,7 @@ BreakpointResolver *BreakpointResolverFileRegex::CreateFromStructuredData(
Status &error) {
bool success;
std::string regex_string;
llvm::StringRef regex_string;
success = options_dict.GetValueForKeyAsString(
GetKey(OptionNames::RegexString), regex_string);
if (!success) {
@ -65,7 +65,7 @@ BreakpointResolver *BreakpointResolverFileRegex::CreateFromStructuredData(
if (success && names_array) {
size_t num_names = names_array->GetSize();
for (size_t i = 0; i < num_names; i++) {
std::string name;
llvm::StringRef name;
success = names_array->GetItemAtIndexAsString(i, name);
if (!success) {
error.SetErrorStringWithFormat(

10
lldb/source/Breakpoint/BreakpointResolverName.cpp
View File

@ -94,14 +94,14 @@ BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
Status &error) {
LanguageType language = eLanguageTypeUnknown;
std::string language_name;
llvm::StringRef language_name;
bool success = options_dict.GetValueForKeyAsString(
GetKey(OptionNames::LanguageName), language_name);
if (success) {
language = Language::GetLanguageTypeFromString(language_name);
if (language == eLanguageTypeUnknown) {
error.SetErrorStringWithFormat("BRN::CFSD: Unknown language: %s.",
language_name.c_str());
error.SetErrorStringWithFormatv("BRN::CFSD: Unknown language: {0}.",
language_name);
return nullptr;
}
}
@ -122,7 +122,7 @@ BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
return nullptr;
}
std::string regex_text;
llvm::StringRef regex_text;
success = options_dict.GetValueForKeyAsString(
GetKey(OptionNames::RegexString), regex_text);
if (success) {
@ -162,7 +162,7 @@ BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
std::vector<uint32_t> name_masks;
for (size_t i = 0; i < num_elem; i++) {
uint32_t name_mask;
std::string name;
llvm::StringRef name;
success = names_array->GetItemAtIndexAsString(i, name);
if (!success) {

2
lldb/source/Core/FormatEntity.cpp
View File

@ -1050,7 +1050,7 @@ static bool FormatThreadExtendedInfoRecurse(
s.Printf("%f", value->GetAsFloat()->GetValue());
return true;
} else if (value->GetType() == StructuredData::Type::eTypeString) {
s.Printf("%s", value->GetAsString()->GetValue().c_str());
s.Format("{0}", value->GetAsString()->GetValue());
return true;
} else if (value->GetType() == StructuredData::Type::eTypeArray) {
if (value->GetAsArray()->GetSize() > 0) {

19
lldb/source/Core/SearchFilter.cpp
View File

@ -55,9 +55,9 @@ const char *SearchFilter::FilterTyToName(enum FilterTy type) {
return g_ty_to_name[type];
}
SearchFilter::FilterTy SearchFilter::NameToFilterTy(const char *name) {
SearchFilter::FilterTy SearchFilter::NameToFilterTy(llvm::StringRef name) {
for (size_t i = 0; i <= LastKnownFilterType; i++) {
if (strcmp(name, g_ty_to_name[i]) == 0)
if (name == g_ty_to_name[i])
return (FilterTy)i;
}
return UnknownFilter;
@ -87,7 +87,7 @@ SearchFilterSP SearchFilter::CreateFromStructuredData(
return result_sp;
}
std::string subclass_name;
llvm::StringRef subclass_name;
bool success = filter_dict.GetValueForKeyAsString(
GetSerializationSubclassKey(), subclass_name);
@ -96,10 +96,9 @@ SearchFilterSP SearchFilter::CreateFromStructuredData(
return result_sp;
}
FilterTy filter_type = NameToFilterTy(subclass_name.c_str());
FilterTy filter_type = NameToFilterTy(subclass_name);
if (filter_type == UnknownFilter) {
error.SetErrorStringWithFormat("Unknown filter type: %s.",
subclass_name.c_str());
error.SetErrorStringWithFormatv("Unknown filter type: {0}.", subclass_name);
return result_sp;
}
@ -484,7 +483,7 @@ SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
return nullptr;
}
std::string module;
llvm::StringRef module;
success = modules_array->GetItemAtIndexAsString(0, module);
if (!success) {
error.SetErrorString("SFBM::CFSD: filter module item not a string.");
@ -639,7 +638,7 @@ SearchFilterSP SearchFilterByModuleList::CreateFromStructuredData(
if (success) {
size_t num_modules = modules_array->GetSize();
for (size_t i = 0; i < num_modules; i++) {
std::string module;
llvm::StringRef module;
success = modules_array->GetItemAtIndexAsString(i, module);
if (!success) {
error.SetErrorStringWithFormat(
@ -704,7 +703,7 @@ lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
if (success) {
size_t num_modules = modules_array->GetSize();
for (size_t i = 0; i < num_modules; i++) {
std::string module;
llvm::StringRef module;
success = modules_array->GetItemAtIndexAsString(i, module);
if (!success) {
error.SetErrorStringWithFormat(
@ -726,7 +725,7 @@ lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
size_t num_cus = cus_array->GetSize();
FileSpecList cus;
for (size_t i = 0; i < num_cus; i++) {
std::string cu;
llvm::StringRef cu;
success = cus_array->GetItemAtIndexAsString(i, cu);
if (!success) {
error.SetErrorStringWithFormat(

8
lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
View File

@ -440,8 +440,8 @@ bool DynamicLoaderDarwin::JSONImageInformationIntoImageInfo(
Segment segment;
StructuredData::Dictionary *seg =
segments->GetItemAtIndex(j)->GetAsDictionary();
segment.name = ConstString(
seg->GetValueForKey("name")->GetAsString()->GetValue().c_str());
segment.name =
ConstString(seg->GetValueForKey("name")->GetAsString()->GetValue());
segment.vmaddr =
seg->GetValueForKey("vmaddr")->GetAsInteger()->GetValue();
segment.vmsize =
@ -478,8 +478,8 @@ bool DynamicLoaderDarwin::JSONImageInformationIntoImageInfo(
image_infos[i].segments.push_back(segment);
}
image_infos[i].uuid.SetFromCString(
image->GetValueForKey("uuid")->GetAsString()->GetValue().c_str());
image_infos[i].uuid.SetFromStringRef(
image->GetValueForKey("uuid")->GetAsString()->GetValue());
// All sections listed in the dyld image info structure will all
// either be fixed up already, or they will all be off by a single

4
lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp
View File

@ -340,8 +340,8 @@ bool OperatingSystemGo::UpdateThreadList(ThreadList &old_thread_list,
memory_thread->IsValid()) {
memory_thread->ClearBackingThread();
} else {
memory_thread.reset(new ThreadMemory(
*m_process, goroutine.m_goid, nullptr, nullptr, goroutine.m_gobuf));
memory_thread.reset(new ThreadMemory(*m_process, goroutine.m_goid, "", "",
goroutine.m_gobuf));
}
// Search for the backing thread if the goroutine is running.
if (2 == (goroutine.m_status & 0xfff)) {

8
lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
View File

@ -240,8 +240,8 @@ ThreadSP OperatingSystemPython::CreateThreadFromThreadInfo(
uint32_t core_number;
addr_t reg_data_addr;
std::string name;
std::string queue;
llvm::StringRef name;
llvm::StringRef queue;
thread_dict.GetValueForKeyAsInteger("core", core_number, UINT32_MAX);
thread_dict.GetValueForKeyAsInteger("register_data_addr", reg_data_addr,
@ -266,8 +266,8 @@ ThreadSP OperatingSystemPython::CreateThreadFromThreadInfo(
if (!thread_sp) {
if (did_create_ptr)
*did_create_ptr = true;
thread_sp.reset(new ThreadMemory(*m_process, tid, name.c_str(),
queue.c_str(), reg_data_addr));
thread_sp.reset(
new ThreadMemory(*m_process, tid, name, queue, reg_data_addr));
}
if (core_number < core_thread_list.GetSize(false)) {

4
lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
View File

@ -784,7 +784,7 @@ const UnixSignalsSP &PlatformRemoteGDBServer::GetRemoteUnixSignals() {
if (!dict->GetValueForKeyAsInteger("signo", signo))
return false;
std::string name;
llvm::StringRef name;
if (!dict->GetValueForKeyAsString("name", name))
return false;
@ -809,7 +809,7 @@ const UnixSignalsSP &PlatformRemoteGDBServer::GetRemoteUnixSignals() {
if (object_sp && object_sp->IsValid())
description = object_sp->GetStringValue();
remote_signals_sp->AddSignal(signo, name.c_str(), suppress, stop,
remote_signals_sp->AddSignal(signo, name.str().c_str(), suppress, stop,
notify, description.c_str());
return true;
});

28
lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
View File

@ -48,10 +48,10 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
if (dict.GetValueForKeyAsArray("sets", sets)) {
const uint32_t num_sets = sets->GetSize();
for (uint32_t i = 0; i < num_sets; ++i) {
std::string set_name_str;
llvm::StringRef set_name_str;
ConstString set_name;
if (sets->GetItemAtIndexAsString(i, set_name_str))
set_name.SetCString(set_name_str.c_str());
set_name.SetString(set_name_str);
if (set_name) {
RegisterSet new_set = {set_name.AsCString(), NULL, 0, NULL};
m_sets.push_back(new_set);
@ -115,7 +115,7 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
// expression
// we can calculate the offset
bool success = false;
std::string slice_str;
llvm::StringRef slice_str;
if (reg_info_dict->GetValueForKeyAsString("slice", slice_str, nullptr)) {
// Slices use the following format:
// REGNAME[MSBIT:LSBIT]
@ -131,9 +131,9 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
llvm::StringRef reg_name_str;
std::string msbit_str;
std::string lsbit_str;
if (regex_match.GetMatchAtIndex(slice_str.c_str(), 1, reg_name_str) &&
regex_match.GetMatchAtIndex(slice_str.c_str(), 2, msbit_str) &&
regex_match.GetMatchAtIndex(slice_str.c_str(), 3, lsbit_str)) {
if (regex_match.GetMatchAtIndex(slice_str, 1, reg_name_str) &&
regex_match.GetMatchAtIndex(slice_str, 2, msbit_str) &&
regex_match.GetMatchAtIndex(slice_str, 3, lsbit_str)) {
const uint32_t msbit =
StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
const uint32_t lsbit =
@ -269,17 +269,15 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
reg_info.byte_size = bitsize / 8;
std::string dwarf_opcode_string;
llvm::StringRef dwarf_opcode_string;
if (reg_info_dict->GetValueForKeyAsString("dynamic_size_dwarf_expr_bytes",
dwarf_opcode_string)) {
reg_info.dynamic_size_dwarf_len = dwarf_opcode_string.length() / 2;
reg_info.dynamic_size_dwarf_len = dwarf_opcode_string.size() / 2;
assert(reg_info.dynamic_size_dwarf_len > 0);
std::vector<uint8_t> dwarf_opcode_bytes(reg_info.dynamic_size_dwarf_len);
uint32_t j;
StringExtractor opcode_extractor;
// Swap "dwarf_opcode_string" over into "opcode_extractor"
opcode_extractor.GetStringRef().swap(dwarf_opcode_string);
StringExtractor opcode_extractor(dwarf_opcode_string);
uint32_t ret_val = opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
UNUSED_IF_ASSERT_DISABLED(ret_val);
assert(ret_val == reg_info.dynamic_size_dwarf_len);
@ -290,9 +288,9 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data();
}
std::string format_str;
llvm::StringRef format_str;
if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) {
if (Args::StringToFormat(format_str.c_str(), reg_info.format, NULL)
if (Args::StringToFormat(format_str.str().c_str(), reg_info.format, NULL)
.Fail()) {
Clear();
printf("error: invalid 'format' value in register dictionary\n");
@ -304,7 +302,7 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
eFormatHex);
}
std::string encoding_str;
llvm::StringRef encoding_str;
if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint);
else
@ -334,7 +332,7 @@ DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno;
reg_info_dict->GetValueForKeyAsInteger(
"dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM);
std::string generic_str;
llvm::StringRef generic_str;
if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
reg_info.kinds[lldb::eRegisterKindGeneric] =
Args::StringToGenericRegister(generic_str);

12
lldb/source/Plugins/Process/Utility/ThreadMemory.cpp
View File

@ -24,15 +24,11 @@ ThreadMemory::ThreadMemory(Process &process, tid_t tid,
: Thread(process, tid), m_backing_thread_sp(),
m_thread_info_valobj_sp(thread_info_valobj_sp), m_name(), m_queue() {}
ThreadMemory::ThreadMemory(Process &process, lldb::tid_t tid, const char *name,
const char *queue, lldb::addr_t register_data_addr)
ThreadMemory::ThreadMemory(Process &process, lldb::tid_t tid,
llvm::StringRef name, llvm::StringRef queue,
lldb::addr_t register_data_addr)
: Thread(process, tid), m_backing_thread_sp(), m_thread_info_valobj_sp(),
m_name(), m_queue(), m_register_data_addr(register_data_addr) {
if (name)
m_name = name;
if (queue)
m_queue = queue;
}
m_name(name), m_queue(queue), m_register_data_addr(register_data_addr) {}
ThreadMemory::~ThreadMemory() { DestroyThread(); }

2
lldb/source/Plugins/Process/Utility/ThreadMemory.h
View File

@ -24,7 +24,7 @@ public:
const lldb::ValueObjectSP &thread_info_valobj_sp);
ThreadMemory(lldb_private::Process &process, lldb::tid_t tid,
const char *name, const char *queue,
llvm::StringRef name, llvm::StringRef queue,
lldb::addr_t register_data_addr);
~ThreadMemory() override;

6
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
View File

@ -3224,12 +3224,12 @@ ParseModuleSpec(StructuredData::Dictionary *dict) {
if (!dict)
return llvm::None;
std::string string;
llvm::StringRef string;
uint64_t integer;
if (!dict->GetValueForKeyAsString("uuid", string))
return llvm::None;
result.GetUUID().SetFromCString(string.c_str(), string.size());
result.GetUUID().SetFromStringRef(string, string.size());
if (!dict->GetValueForKeyAsInteger("file_offset", integer))
return llvm::None;
@ -3241,7 +3241,7 @@ ParseModuleSpec(StructuredData::Dictionary *dict) {
if (!dict->GetValueForKeyAsString("triple", string))
return llvm::None;
result.GetArchitecture().SetTriple(string.c_str());
result.GetArchitecture().SetTriple(string);
if (!dict->GetValueForKeyAsString("file_path", string))
return llvm::None;

9
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
View File

@ -1140,7 +1140,7 @@ GDBRemoteCommunicationServerCommon::Handle_jModulesInfo(
packet_array->GetItemAtIndex(i)->GetAsDictionary();
if (!query)
continue;
std::string file, triple;
llvm::StringRef file, triple;
if (!query->GetValueForKeyAsString("file", file) ||
!query->GetValueForKeyAsString("triple", triple))
continue;
@ -1278,9 +1278,10 @@ FileSpec GDBRemoteCommunicationServerCommon::FindModuleFile(
#endif
}
ModuleSpec GDBRemoteCommunicationServerCommon::GetModuleInfo(
const std::string &module_path, const std::string &triple) {
ArchSpec arch(triple.c_str());
ModuleSpec
GDBRemoteCommunicationServerCommon::GetModuleInfo(llvm::StringRef module_path,
llvm::StringRef triple) {
ArchSpec arch(triple);
const FileSpec req_module_path_spec(module_path, true);
const FileSpec module_path_spec =

3
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h
View File

@ -153,8 +153,7 @@ protected:
const ArchSpec &arch);
private:
ModuleSpec GetModuleInfo(const std::string &module_path,
const std::string &triple);
ModuleSpec GetModuleInfo(llvm::StringRef module_path, llvm::StringRef triple);
};
} // namespace process_gdb_remote

6
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
View File

@ -2113,9 +2113,9 @@ ProcessGDBRemote::SetThreadStopInfo(StructuredData::Dictionary *thread_dict) {
if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>(
"address", mem_cache_addr)) {
if (mem_cache_addr != LLDB_INVALID_ADDRESS) {
StringExtractor bytes;
if (mem_cache_dict->GetValueForKeyAsString(
"bytes", bytes.GetStringRef())) {
llvm::StringRef str;
if (mem_cache_dict->GetValueForKeyAsString("bytes", str)) {
StringExtractor bytes(str);
bytes.SetFilePos(0);
const size_t byte_size = bytes.GetStringRef().size() / 2;

12
lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp
View File

@ -1817,7 +1817,7 @@ StructuredDataDarwinLog::DumpHeader(Stream &output_stream,
}
if (options_sp->GetDisplayActivityChain()) {
std::string activity_chain;
llvm::StringRef activity_chain;
if (event.GetValueForKeyAsString("activity-chain", activity_chain) &&
!activity_chain.empty()) {
if (header_count > 0)
@ -1856,7 +1856,7 @@ StructuredDataDarwinLog::DumpHeader(Stream &output_stream,
}
if (options_sp->GetDisplaySubsystem()) {
std::string subsystem;
llvm::StringRef subsystem;
if (event.GetValueForKeyAsString("subsystem", subsystem) &&
!subsystem.empty()) {
if (header_count > 0)
@ -1868,7 +1868,7 @@ StructuredDataDarwinLog::DumpHeader(Stream &output_stream,
}
if (options_sp->GetDisplayCategory()) {
std::string category;
llvm::StringRef category;
if (event.GetValueForKeyAsString("category", category) &&
!category.empty()) {
if (header_count > 0)
@ -1901,16 +1901,16 @@ size_t StructuredDataDarwinLog::HandleDisplayOfEvent(
size_t total_bytes = 0;
// Grab the message content.
std::string message;
llvm::StringRef message;
if (!event.GetValueForKeyAsString("message", message))
return true;
// Display the log entry.
const auto len = message.length();
const auto len = message.size();
total_bytes += DumpHeader(stream, event);
stream.Write(message.c_str(), len);
stream.Write(message.data(), len);
total_bytes += len;
// Add an end of line.

3
lldb/source/Target/Process.cpp
View File

@ -6162,8 +6162,7 @@ void Process::MapSupportedStructuredDataPlugins(
}
const_type_names.insert(ConstString(type_name->GetValue()));
if (log)
log->Printf("- %s", type_name->GetValue().c_str());
LLDB_LOG(log, "- {0}", type_name->GetValue());
return true;
});

11
lldb/source/Target/Thread.cpp
View File

@ -2001,8 +2001,8 @@ bool Thread::GetDescription(Stream &strm, lldb::DescriptionLevel level,
StructuredData::ObjectSP name = activity_dict->GetValueForKey("name");
if (name && name->GetType() == StructuredData::Type::eTypeString && id &&
id->GetType() == StructuredData::Type::eTypeInteger) {
strm.Printf(" Activity '%s', 0x%" PRIx64 "\n",
name->GetAsString()->GetValue().c_str(),
strm.Format(" Activity '{0}', {1:x}\n",
name->GetAsString()->GetValue(),
id->GetAsInteger()->GetValue());
}
printed_activity = true;
@ -2018,8 +2018,8 @@ bool Thread::GetDescription(Stream &strm, lldb::DescriptionLevel level,
breadcrumb_dict->GetValueForKey("name");
if (breadcrumb_text &&
breadcrumb_text->GetType() == StructuredData::Type::eTypeString) {
strm.Printf(" Current Breadcrumb: %s\n",
breadcrumb_text->GetAsString()->GetValue().c_str());
strm.Format(" Current Breadcrumb: {0}\n",
breadcrumb_text->GetAsString()->GetValue());
}
printed_breadcrumb = true;
}
@ -2040,8 +2040,7 @@ bool Thread::GetDescription(Stream &strm, lldb::DescriptionLevel level,
message_dict->GetValueForKey("message");
if (message_text &&
message_text->GetType() == StructuredData::Type::eTypeString) {
strm.Printf(" %s\n",
message_text->GetAsString()->GetValue().c_str());
strm.Format(" {0}\n", message_text->GetAsString()->GetValue());
}
}
}

8
lldb/source/Target/ThreadSpec.cpp
View File

@ -42,8 +42,8 @@ std::unique_ptr<ThreadSpec> ThreadSpec::CreateFromStructuredData(
const StructuredData::Dictionary &spec_dict, Status &error) {
uint32_t index = UINT32_MAX;
lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
std::string name;
std::string queue_name;
llvm::StringRef name;
llvm::StringRef queue_name;
std::unique_ptr<ThreadSpec> thread_spec_up(new ThreadSpec());
bool success = spec_dict.GetValueForKeyAsInteger(
@ -59,12 +59,12 @@ std::unique_ptr<ThreadSpec> ThreadSpec::CreateFromStructuredData(
success =
spec_dict.GetValueForKeyAsString(GetKey(OptionNames::ThreadName), name);
if (success)
thread_spec_up->SetName(name.c_str());
thread_spec_up->SetName(name);
success = spec_dict.GetValueForKeyAsString(GetKey(OptionNames::ThreadName),
queue_name);
if (success)
thread_spec_up->SetQueueName(queue_name.c_str());
thread_spec_up->SetQueueName(queue_name);
return thread_spec_up;
}

16
lldb/source/Utility/UUID.cpp
View File

@ -160,12 +160,9 @@ llvm::StringRef UUID::DecodeUUIDBytesFromString(llvm::StringRef p,
bytes_decoded = uuid_byte_idx;
return p;
}
size_t UUID::SetFromCString(const char *cstr, uint32_t num_uuid_bytes) {
if (cstr == NULL)
return 0;
llvm::StringRef orig(cstr);
llvm::StringRef p = orig;
size_t UUID::SetFromStringRef(llvm::StringRef str, uint32_t num_uuid_bytes) {
llvm::StringRef p = str;
// Skip leading whitespace characters
p = p.ltrim();
@ -178,12 +175,19 @@ size_t UUID::SetFromCString(const char *cstr, uint32_t num_uuid_bytes) {
// were consumed
if (bytes_decoded == num_uuid_bytes) {
m_num_uuid_bytes = num_uuid_bytes;
return orig.size() - rest.size();
return str.size() - rest.size();
}
// Else return zero to indicate we were not able to parse a UUID value
return 0;
}
size_t UUID::SetFromCString(const char *cstr, uint32_t num_uuid_bytes) {
if (cstr == NULL)
return 0;
return SetFromStringRef(cstr, num_uuid_bytes);
}
}
bool lldb_private::operator==(const lldb_private::UUID &lhs,