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;
llvm::StringRef name;
llvm::StringRef queue_name;
std::unique_ptr<ThreadSpec> thread_spec_up(new ThreadSpec());
bool success = spec_dict.GetValueForKeyAsInteger(
GetKey(OptionNames::ThreadIndex), index);
if (success)
thread_spec_up->SetIndex(index);
success =
spec_dict.GetValueForKeyAsInteger(GetKey(OptionNames::ThreadID), tid);
if (success)
thread_spec_up->SetTID(tid);
success =
spec_dict.GetValueForKeyAsString(GetKey(OptionNames::ThreadName), name);
if (success)
thread_spec_up->SetName(name);
success = spec_dict.GetValueForKeyAsString(GetKey(OptionNames::ThreadName),
queue_name);
if (success)
thread_spec_up->SetQueueName(queue_name);
return thread_spec_up;
}
ThreadSP OperatingSystemPython::CreateThreadFromThreadInfo(
StructuredData::Dictionary &thread_dict, ThreadList &core_thread_list,
ThreadList &old_thread_list, std::vector<bool> &core_used_map,
bool *did_create_ptr) {
ThreadSP thread_sp;
tid_t tid = LLDB_INVALID_THREAD_ID;
if (!thread_dict.GetValueForKeyAsInteger("tid", tid))
return ThreadSP();
uint32_t core_number;
addr_t reg_data_addr;
llvm::StringRef name;
llvm::StringRef queue;
thread_dict.GetValueForKeyAsInteger("core", core_number, UINT32_MAX);
thread_dict.GetValueForKeyAsInteger("register_data_addr", reg_data_addr,
LLDB_INVALID_ADDRESS);
thread_dict.GetValueForKeyAsString("name", name);
thread_dict.GetValueForKeyAsString("queue", queue);
// See if a thread already exists for "tid"
thread_sp = old_thread_list.FindThreadByID(tid, false);
if (thread_sp) {
// A thread already does exist for "tid", make sure it was an operating
// system
// plug-in generated thread.
if (!IsOperatingSystemPluginThread(thread_sp)) {
// We have thread ID overlap between the protocol threads and the
// operating system threads, clear the thread so we create an operating
// system thread for this.
thread_sp.reset();
}
}
if (!thread_sp) {
if (did_create_ptr)
*did_create_ptr = true;
thread_sp = std::make_shared<ThreadMemory>(*m_process, tid, name, queue,
reg_data_addr);
}
if (core_number < core_thread_list.GetSize(false)) {
ThreadSP core_thread_sp(
core_thread_list.GetThreadAtIndex(core_number, false));
if (core_thread_sp) {
// Keep track of which cores were set as the backing thread for memory
// threads...
if (core_number < core_used_map.size())
core_used_map[core_number] = true;
ThreadSP backing_core_thread_sp(core_thread_sp->GetBackingThread());
if (backing_core_thread_sp) {
thread_sp->SetBackingThread(backing_core_thread_sp);
} else {
thread_sp->SetBackingThread(core_thread_sp);
}
}
}
return thread_sp;
}
SearchFilterSP SearchFilter::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &filter_dict,
Status &error) {
SearchFilterSP result_sp;
if (!filter_dict.IsValid()) {
error.SetErrorString("Can't deserialize from an invalid data object.");
return result_sp;
}
llvm::StringRef subclass_name;
bool success = filter_dict.GetValueForKeyAsString(
GetSerializationSubclassKey(), subclass_name);
if (!success) {
error.SetErrorStringWithFormat("Filter data missing subclass key");
return result_sp;
}
FilterTy filter_type = NameToFilterTy(subclass_name);
if (filter_type == UnknownFilter) {
error.SetErrorStringWithFormatv("Unknown filter type: {0}.", subclass_name);
return result_sp;
}
StructuredData::Dictionary *subclass_options = nullptr;
success = filter_dict.GetValueForKeyAsDictionary(
GetSerializationSubclassOptionsKey(), subclass_options);
if (!success || !subclass_options || !subclass_options->IsValid()) {
error.SetErrorString("Filter data missing subclass options key.");
return result_sp;
}
switch (filter_type) {
case Unconstrained:
result_sp = SearchFilterForUnconstrainedSearches::CreateFromStructuredData(
target, *subclass_options, error);
break;
case ByModule:
result_sp = SearchFilterByModule::CreateFromStructuredData(
target, *subclass_options, error);
break;
case ByModules:
result_sp = SearchFilterByModuleList::CreateFromStructuredData(
target, *subclass_options, error);
break;
case ByModulesAndCU:
result_sp = SearchFilterByModuleListAndCU::CreateFromStructuredData(
target, *subclass_options, error);
break;
case Exception:
error.SetErrorString("Can't serialize exception breakpoints yet.");
break;
default:
llvm_unreachable("Should never get an uresolvable filter type.");
}
return result_sp;
}
GDBRemoteCommunication::PacketResult
GDBRemoteCommunicationServerCommon::Handle_jModulesInfo(
StringExtractorGDBRemote &packet) {
packet.SetFilePos(::strlen("jModulesInfo:"));
StructuredData::ObjectSP object_sp = StructuredData::ParseJSON(packet.Peek());
if (!object_sp)
return SendErrorResponse(1);
StructuredData::Array *packet_array = object_sp->GetAsArray();
if (!packet_array)
return SendErrorResponse(2);
JSONArray::SP response_array_sp = std::make_shared<JSONArray>();
for (size_t i = 0; i < packet_array->GetSize(); ++i) {
StructuredData::Dictionary *query =
packet_array->GetItemAtIndex(i)->GetAsDictionary();
if (!query)
continue;
std::string file, triple;
if (!query->GetValueForKeyAsString("file", file) ||
!query->GetValueForKeyAsString("triple", triple))
continue;
ModuleSpec matched_module_spec = GetModuleInfo(file, triple);
if (!matched_module_spec.GetFileSpec())
continue;
const auto file_offset = matched_module_spec.GetObjectOffset();
const auto file_size = matched_module_spec.GetObjectSize();
const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
if (uuid_str.empty())
continue;
JSONObject::SP response = std::make_shared<JSONObject>();
response_array_sp->AppendObject(response);
response->SetObject("uuid", std::make_shared<JSONString>(uuid_str));
response->SetObject(
"triple",
std::make_shared<JSONString>(
matched_module_spec.GetArchitecture().GetTriple().getTriple()));
response->SetObject("file_path",
std::make_shared<JSONString>(
matched_module_spec.GetFileSpec().GetPath()));
response->SetObject("file_offset",
std::make_shared<JSONNumber>(file_offset));
response->SetObject("file_size", std::make_shared<JSONNumber>(file_size));
}
StreamString response;
response_array_sp->Write(response);
StreamGDBRemote escaped_response;
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
return SendPacketNoLock(escaped_response.GetString());
}
SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &data_dict,
Status &error) {
StructuredData::Array *modules_array;
bool success = data_dict.GetValueForKeyAsArray(GetKey(OptionNames::ModList),
modules_array);
if (!success) {
error.SetErrorString("SFBM::CFSD: Could not find the module list key.");
return nullptr;
}
size_t num_modules = modules_array->GetSize();
if (num_modules > 1) {
error.SetErrorString(
"SFBM::CFSD: Only one modules allowed for SearchFilterByModule.");
return nullptr;
}
llvm::StringRef 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);
return std::make_shared<SearchFilterByModule>(target.shared_from_this(),
module_spec);
}
lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &data_dict,
Status &error) {
StructuredData::Array *modules_array = nullptr;
SearchFilterSP result_sp;
bool success = data_dict.GetValueForKeyAsArray(GetKey(OptionNames::ModList),
modules_array);
FileSpecList modules;
if (success) {
size_t num_modules = modules_array->GetSize();
for (size_t i = 0; i < num_modules; i++) {
llvm::StringRef 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));
}
}
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++) {
llvm::StringRef 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));
}
return std::make_shared<SearchFilterByModuleListAndCU>(
target.shared_from_this(), modules, cus);
}
SearchFilterSP SearchFilterByModuleList::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &data_dict,
Status &error) {
StructuredData::Array *modules_array;
bool success = data_dict.GetValueForKeyAsArray(GetKey(OptionNames::ModList),
modules_array);
FileSpecList modules;
if (success) {
size_t num_modules = modules_array->GetSize();
for (size_t i = 0; i < num_modules; i++) {
llvm::StringRef 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));
}
}
return std::make_shared<SearchFilterByModuleList>(target.shared_from_this(),
modules);
}
void
SystemRuntimeMacOSX::AddThreadExtendedInfoPacketHints (lldb_private::StructuredData::ObjectSP dict_sp)
{
StructuredData::Dictionary *dict = dict_sp->GetAsDictionary();
if (dict)
{
ReadLibpthreadOffsets();
if (m_libpthread_offsets.IsValid())
{
dict->AddIntegerItem ("plo_pthread_tsd_base_offset", m_libpthread_offsets.plo_pthread_tsd_base_offset);
dict->AddIntegerItem ("plo_pthread_tsd_base_address_offset", m_libpthread_offsets.plo_pthread_tsd_base_address_offset);
dict->AddIntegerItem ("plo_pthread_tsd_entry_size", m_libpthread_offsets.plo_pthread_tsd_entry_size);
}
ReadLibdispatchTSDIndexes ();
if (m_libdispatch_tsd_indexes.IsValid())
{
dict->AddIntegerItem ("dti_queue_index", m_libdispatch_tsd_indexes.dti_queue_index);
dict->AddIntegerItem ("dti_voucher_index", m_libdispatch_tsd_indexes.dti_voucher_index);
dict->AddIntegerItem ("dti_qos_class_index", m_libdispatch_tsd_indexes.dti_qos_class_index);
}
}
}
BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
const StructuredData::Dictionary &resolver_dict, Status &error) {
BreakpointResolverSP result_sp;
if (!resolver_dict.IsValid()) {
error.SetErrorString("Can't deserialize from an invalid data object.");
return result_sp;
}
llvm::StringRef subclass_name;
bool success = resolver_dict.GetValueForKeyAsString(
GetSerializationSubclassKey(), subclass_name);
if (!success) {
error.SetErrorStringWithFormat(
"Resolver data missing subclass resolver key");
return result_sp;
}
ResolverTy resolver_type = NameToResolverTy(subclass_name);
if (resolver_type == UnknownResolver) {
error.SetErrorStringWithFormatv("Unknown resolver type: {0}.",
subclass_name);
return result_sp;
}
StructuredData::Dictionary *subclass_options = nullptr;
success = resolver_dict.GetValueForKeyAsDictionary(
GetSerializationSubclassOptionsKey(), subclass_options);
if (!success || !subclass_options || !subclass_options->IsValid()) {
error.SetErrorString("Resolver data missing subclass options key.");
return result_sp;
}
lldb::addr_t offset;
success = subclass_options->GetValueForKeyAsInteger(
GetKey(OptionNames::Offset), offset);
if (!success) {
error.SetErrorString("Resolver data missing offset options key.");
return result_sp;
}
BreakpointResolver *resolver;
switch (resolver_type) {
case FileLineResolver:
resolver = BreakpointResolverFileLine::CreateFromStructuredData(
nullptr, *subclass_options, error);
break;
case AddressResolver:
resolver = BreakpointResolverAddress::CreateFromStructuredData(
nullptr, *subclass_options, error);
break;
case NameResolver:
resolver = BreakpointResolverName::CreateFromStructuredData(
nullptr, *subclass_options, error);
break;
case FileRegexResolver:
resolver = BreakpointResolverFileRegex::CreateFromStructuredData(
nullptr, *subclass_options, error);
break;
case PythonResolver:
resolver = BreakpointResolverScripted::CreateFromStructuredData(
nullptr, *subclass_options, error);
break;
case ExceptionResolver:
error.SetErrorString("Exception resolvers are hard.");
break;
default:
llvm_unreachable("Should never get an unresolvable resolver type.");
}
if (!error.Success()) {
return result_sp;
} else {
// Add on the global offset option:
resolver->SetOffset(offset);
return BreakpointResolverSP(resolver);
}
}
size_t
DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict, ByteOrder byte_order)
{
assert(!m_finalized);
StructuredData::Array *sets = nullptr;
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;
ConstString set_name;
if (sets->GetItemAtIndexAsString(i, set_name_str))
set_name.SetCString(set_name_str.c_str());
if (set_name)
{
RegisterSet new_set = { set_name.AsCString(), NULL, 0, NULL };
m_sets.push_back (new_set);
}
else
{
Clear();
printf("error: register sets must have valid names\n");
return 0;
}
}
m_set_reg_nums.resize(m_sets.size());
}
StructuredData::Array *regs = nullptr;
if (!dict.GetValueForKeyAsArray("registers", regs))
return 0;
const uint32_t num_regs = regs->GetSize();
// typedef std::map<std::string, std::vector<std::string> > InvalidateNameMap;
// InvalidateNameMap invalidate_map;
for (uint32_t i = 0; i < num_regs; ++i)
{
StructuredData::Dictionary *reg_info_dict = nullptr;
if (!regs->GetItemAtIndexAsDictionary(i, reg_info_dict))
{
Clear();
printf("error: items in the 'registers' array must be dictionaries\n");
regs->DumpToStdout();
return 0;
}
// { 'name':'rcx' , 'bitsize' : 64, 'offset' : 16, 'encoding':'uint' , 'format':'hex' , 'set': 0, 'gcc' : 2,
// 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
RegisterInfo reg_info;
std::vector<uint32_t> value_regs;
std::vector<uint32_t> invalidate_regs;
memset(®_info, 0, sizeof(reg_info));
ConstString name_val;
ConstString alt_name_val;
if (!reg_info_dict->GetValueForKeyAsString("name", name_val, nullptr))
{
Clear();
printf("error: registers must have valid names and offsets\n");
reg_info_dict->DumpToStdout();
return 0;
}
reg_info.name = name_val.GetCString();
reg_info_dict->GetValueForKeyAsString("alt-name", alt_name_val, nullptr);
reg_info.alt_name = alt_name_val.GetCString();
reg_info_dict->GetValueForKeyAsInteger("offset", reg_info.byte_offset, UINT32_MAX);
if (reg_info.byte_offset == UINT32_MAX)
{
// No offset for this register, see if the register has a value expression
// which indicates this register is part of another register. Value expressions
// are things like "rax[31:0]" which state that the current register's value
// is in a concrete register "rax" in bits 31:0. If there is a value expression
// we can calculate the offset
bool success = false;
std::string slice_str;
if (reg_info_dict->GetValueForKeyAsString("slice", slice_str, nullptr))
{
// Slices use the following format:
// REGNAME[MSBIT:LSBIT]
// REGNAME - name of the register to grab a slice of
// MSBIT - the most significant bit at which the current register value starts at
// LSBIT - the least significant bit at which the current register value ends at
static RegularExpression g_bitfield_regex("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]");
RegularExpression::Match regex_match(3);
if (g_bitfield_regex.Execute(slice_str.c_str(), ®ex_match))
{
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))
{
const uint32_t msbit = StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
const uint32_t lsbit = StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
if (msbit != UINT32_MAX && lsbit != UINT32_MAX)
{
if (msbit > lsbit)
{
const uint32_t msbyte = msbit / 8;
const uint32_t lsbyte = lsbit / 8;
ConstString containing_reg_name(reg_name_str);
RegisterInfo *containing_reg_info = GetRegisterInfo(containing_reg_name);
if (containing_reg_info)
{
const uint32_t max_bit = containing_reg_info->byte_size * 8;
if (msbit < max_bit && lsbit < max_bit)
{
m_invalidate_regs_map[containing_reg_info->kinds[eRegisterKindLLDB]].push_back(i);
m_value_regs_map[i].push_back(containing_reg_info->kinds[eRegisterKindLLDB]);
m_invalidate_regs_map[i].push_back(containing_reg_info->kinds[eRegisterKindLLDB]);
if (byte_order == eByteOrderLittle)
{
success = true;
reg_info.byte_offset = containing_reg_info->byte_offset + lsbyte;
}
else if (byte_order == eByteOrderBig)
{
success = true;
reg_info.byte_offset = containing_reg_info->byte_offset + msbyte;
}
else
{
assert(!"Invalid byte order");
}
}
else
{
if (msbit > max_bit)
printf("error: msbit (%u) must be less than the bitsize of the register (%u)\n", msbit,
max_bit);
else
printf("error: lsbit (%u) must be less than the bitsize of the register (%u)\n", lsbit,
max_bit);
}
}
else
{
printf("error: invalid concrete register \"%s\"\n", containing_reg_name.GetCString());
}
}
else
{
printf("error: msbit (%u) must be greater than lsbit (%u)\n", msbit, lsbit);
}
}
else
{
printf("error: msbit (%u) and lsbit (%u) must be valid\n", msbit, lsbit);
}
}
else
{
// TODO: print error invalid slice string that doesn't follow the format
printf("error: failed to extract regex matches for parsing the register bitfield regex\n");
}
}
else
{
// TODO: print error invalid slice string that doesn't follow the format
printf("error: failed to match against register bitfield regex\n");
}
}
else
{
StructuredData::Array *composite_reg_list = nullptr;
if (reg_info_dict->GetValueForKeyAsArray("composite", composite_reg_list))
{
const size_t num_composite_regs = composite_reg_list->GetSize();
if (num_composite_regs > 0)
{
uint32_t composite_offset = UINT32_MAX;
for (uint32_t composite_idx = 0; composite_idx < num_composite_regs; ++composite_idx)
{
ConstString composite_reg_name;
if (composite_reg_list->GetItemAtIndexAsString(composite_idx, composite_reg_name, nullptr))
{
RegisterInfo *composite_reg_info = GetRegisterInfo(composite_reg_name);
if (composite_reg_info)
{
composite_offset = std::min(composite_offset, composite_reg_info->byte_offset);
m_value_regs_map[i].push_back(composite_reg_info->kinds[eRegisterKindLLDB]);
m_invalidate_regs_map[composite_reg_info->kinds[eRegisterKindLLDB]].push_back(i);
m_invalidate_regs_map[i].push_back(composite_reg_info->kinds[eRegisterKindLLDB]);
}
else
{
// TODO: print error invalid slice string that doesn't follow the format
printf("error: failed to find composite register by name: \"%s\"\n", composite_reg_name.GetCString());
}
}
else
{
printf("error: 'composite' list value wasn't a python string\n");
}
}
if (composite_offset != UINT32_MAX)
{
reg_info.byte_offset = composite_offset;
success = m_value_regs_map.find(i) != m_value_regs_map.end();
}
else
{
printf("error: 'composite' registers must specify at least one real register\n");
}
}
else
{
printf("error: 'composite' list was empty\n");
}
}
}
if (!success)
{
Clear();
reg_info_dict->DumpToStdout();
return 0;
}
}
int64_t bitsize = 0;
if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize))
{
Clear();
printf("error: invalid or missing 'bitsize' key/value pair in register dictionary\n");
reg_info_dict->DumpToStdout();
return 0;
}
reg_info.byte_size = bitsize / 8;
std::string format_str;
if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr))
{
if (Args::StringToFormat(format_str.c_str(), reg_info.format, NULL).Fail())
{
Clear();
printf("error: invalid 'format' value in register dictionary\n");
reg_info_dict->DumpToStdout();
return 0;
}
}
else
{
reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format, eFormatHex);
}
std::string encoding_str;
if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
reg_info.encoding = Args::StringToEncoding(encoding_str.c_str(), eEncodingUint);
else
reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding, eEncodingUint);
size_t set = 0;
if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) || set >= m_sets.size())
{
Clear();
printf("error: invalid 'set' value in register dictionary, valid values are 0 - %i\n", (int)set);
reg_info_dict->DumpToStdout();
return 0;
}
// Fill in the register numbers
reg_info.kinds[lldb::eRegisterKindLLDB] = i;
reg_info.kinds[lldb::eRegisterKindGDB] = i;
reg_info_dict->GetValueForKeyAsInteger("gcc", reg_info.kinds[lldb::eRegisterKindGCC], LLDB_INVALID_REGNUM);
reg_info_dict->GetValueForKeyAsInteger("dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM);
std::string generic_str;
if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
reg_info.kinds[lldb::eRegisterKindGeneric] = Args::StringToGenericRegister(generic_str.c_str());
else
reg_info_dict->GetValueForKeyAsInteger("generic", reg_info.kinds[lldb::eRegisterKindGeneric], LLDB_INVALID_REGNUM);
// Check if this register invalidates any other register values when it is modified
StructuredData::Array *invalidate_reg_list = nullptr;
if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs", invalidate_reg_list))
{
const size_t num_regs = invalidate_reg_list->GetSize();
if (num_regs > 0)
{
for (uint32_t idx = 0; idx < num_regs; ++idx)
{
ConstString invalidate_reg_name;
uint64_t invalidate_reg_num;
if (invalidate_reg_list->GetItemAtIndexAsString(idx, invalidate_reg_name))
{
RegisterInfo *invalidate_reg_info = GetRegisterInfo(invalidate_reg_name);
if (invalidate_reg_info)
{
m_invalidate_regs_map[i].push_back(invalidate_reg_info->kinds[eRegisterKindLLDB]);
}
else
{
// TODO: print error invalid slice string that doesn't follow the format
printf("error: failed to find a 'invalidate-regs' register for \"%s\" while parsing register \"%s\"\n",
invalidate_reg_name.GetCString(), reg_info.name);
}
}
else if (invalidate_reg_list->GetItemAtIndexAsInteger(idx, invalidate_reg_num))
{
if (invalidate_reg_num != UINT64_MAX)
m_invalidate_regs_map[i].push_back(invalidate_reg_num);
else
printf("error: 'invalidate-regs' list value wasn't a valid integer\n");
}
else
{
printf("error: 'invalidate-regs' list value wasn't a python string or integer\n");
}
}
}
else
{
printf("error: 'invalidate-regs' contained an empty list\n");
}
}
// Calculate the register offset
const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
if (m_reg_data_byte_size < end_reg_offset)
m_reg_data_byte_size = end_reg_offset;
m_regs.push_back(reg_info);
m_set_reg_nums[set].push_back(i);
}
Finalize();
return m_regs.size();
}
