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(); }