static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data, uint32_t Offset, int Length) { errs() << "DUMP: "; for (int i = 0; i < Length; ++i) { uint8_t c = Data.getU8(&Offset); errs().write_hex(c); errs() << " "; } errs() << "\n"; }
bool Type::ReadFromMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data) { if (address_type == eAddressTypeFile) { // Can't convert a file address to anything valid without more // context (which Module it came from) return false; } const uint64_t byte_size = GetByteSize(); if (data.GetByteSize() < byte_size) { lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); data.SetData(data_sp); } uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); if (dst != nullptr) { if (address_type == eAddressTypeHost) { // The address is an address in this process, so just copy it if (addr == 0) return false; memcpy (dst, (uint8_t*)nullptr + addr, byte_size); return true; } else { if (exe_ctx) { Process *process = exe_ctx->GetProcessPtr(); if (process) { Error error; return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size, error) == byte_size; } } } } return false; }
bool DWARFUnit::extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) { Length = debug_info.getU32(offset_ptr); Version = debug_info.getU16(offset_ptr); uint64_t AbbrOffset = debug_info.getU32(offset_ptr); AddrSize = debug_info.getU8(offset_ptr); bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1); bool VersionOK = DWARFContext::isSupportedVersion(Version); bool AddrSizeOK = AddrSize == 4 || AddrSize == 8; if (!LengthOK || !VersionOK || !AddrSizeOK) return false; Abbrevs = Abbrev->getAbbreviationDeclarationSet(AbbrOffset); if (Abbrevs == nullptr) return false; return true; }
static size_t ReadCStringFromMemory (ExecutionContextScope *exe_scope, const Address &address, Stream *strm) { if (exe_scope == NULL) return 0; const size_t k_buf_len = 256; char buf[k_buf_len+1]; buf[k_buf_len] = '\0'; // NULL terminate // Byte order and address size don't matter for C string dumping.. DataExtractor data (buf, sizeof(buf), lldb::endian::InlHostByteOrder(), 4); size_t total_len = 0; size_t bytes_read; Address curr_address(address); strm->PutChar ('"'); while ((bytes_read = ReadBytes (exe_scope, curr_address, buf, k_buf_len)) > 0) { size_t len = strlen(buf); if (len == 0) break; if (len > bytes_read) len = bytes_read; data.Dump (strm, 0, // Start offset in "data" eFormatChar, // Print as characters 1, // Size of item (1 byte for a char!) len, // How many bytes to print? UINT32_MAX, // num per line LLDB_INVALID_ADDRESS,// base address 0, // bitfield bit size 0); // bitfield bit offset total_len += bytes_read; if (len < k_buf_len) break; curr_address.SetOffset (curr_address.GetOffset() + bytes_read); } strm->PutChar ('"'); return total_len; }
bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U, uint32_t *OffsetPtr, const DataExtractor &DebugInfoData, uint32_t UEndOffset, uint32_t D) { Offset = *OffsetPtr; Depth = D; if (Offset >= UEndOffset || !DebugInfoData.isValidOffset(Offset)) return false; uint64_t AbbrCode = DebugInfoData.getULEB128(OffsetPtr); if (0 == AbbrCode) { // NULL debug tag entry. AbbrevDecl = nullptr; return true; } AbbrevDecl = U.getAbbreviations()->getAbbreviationDeclaration(AbbrCode); if (nullptr == AbbrevDecl) { // Restore the original offset. *OffsetPtr = Offset; return false; } // See if all attributes in this DIE have fixed byte sizes. If so, we can // just add this size to the offset to skip to the next DIE. if (Optional<size_t> FixedSize = AbbrevDecl->getFixedAttributesByteSize(U)) { *OffsetPtr += *FixedSize; return true; } // Skip all data in the .debug_info for the attributes for (const auto &AttrSpec : AbbrevDecl->attributes()) { // Check if this attribute has a fixed byte size. if (auto FixedSize = AttrSpec.getByteSize(U)) { // Attribute byte size if fixed, just add the size to the offset. *OffsetPtr += *FixedSize; } else if (!DWARFFormValue::skipValue(AttrSpec.Form, DebugInfoData, OffsetPtr, &U)) { // We failed to skip this attribute's value, restore the original offset // and return the failure status. *OffsetPtr = Offset; return false; } } return true; }
static bool GetAPInt(const DataExtractor &data, lldb::offset_t *offset_ptr, lldb::offset_t byte_size, llvm::APInt &result) { llvm::SmallVector<uint64_t, 2> uint64_array; lldb::offset_t bytes_left = byte_size; uint64_t u64; const lldb::ByteOrder byte_order = data.GetByteOrder(); if (byte_order == lldb::eByteOrderLittle) { while (bytes_left > 0) { if (bytes_left >= 8) { u64 = data.GetU64(offset_ptr); bytes_left -= 8; } else { u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left); bytes_left = 0; } uint64_array.push_back(u64); } result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); return true; } else if (byte_order == lldb::eByteOrderBig) { lldb::offset_t be_offset = *offset_ptr + byte_size; lldb::offset_t temp_offset; while (bytes_left > 0) { if (bytes_left >= 8) { be_offset -= 8; temp_offset = be_offset; u64 = data.GetU64(&temp_offset); bytes_left -= 8; } else { be_offset -= bytes_left; temp_offset = be_offset; u64 = data.GetMaxU64(&temp_offset, (uint32_t)bytes_left); bytes_left = 0; } uint64_array.push_back(u64); } *offset_ptr += byte_size; result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); return true; } return false; }
bool ObjectContainerBSDArchive::MagicBytesMatch (const DataExtractor &data) { uint32_t offset = 0; const char* armag = (const char* )data.PeekData (offset, sizeof(ar_hdr)); if (armag && ::strncmp(armag, ARMAG, SARMAG) == 0) { armag += offsetof(struct ar_hdr, ar_fmag) + SARMAG; if (strncmp(armag, ARFMAG, 2) == 0) return true; }
ObjectContainer *ObjectContainerUniversalMachO::CreateInstance( const lldb::ModuleSP &module_sp, DataBufferSP &data_sp, lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t file_offset, lldb::offset_t length) { // We get data when we aren't trying to look for cached container information, // so only try and look for an architecture slice if we get data if (data_sp) { DataExtractor data; data.SetData(data_sp, data_offset, length); if (ObjectContainerUniversalMachO::MagicBytesMatch(data)) { std::unique_ptr<ObjectContainerUniversalMachO> container_ap( new ObjectContainerUniversalMachO(module_sp, data_sp, data_offset, file, file_offset, length)); if (container_ap->ParseHeader()) { return container_ap.release(); } } } return NULL; }
RegisterContextCorePOSIX_x86_64::RegisterContextCorePOSIX_x86_64( Thread &thread, RegisterInfoInterface *register_info, const DataExtractor &gpregset, const DataExtractor &fpregset) : RegisterContextPOSIX_x86(thread, 0, register_info) { size_t size, len; size = GetGPRSize(); m_gpregset.reset(new uint8_t[size]); len = gpregset.ExtractBytes(0, size, lldb::eByteOrderLittle, m_gpregset.get()); if (len != size) m_gpregset.reset(); size = sizeof(FXSAVE); m_fpregset.reset(new uint8_t[size]); len = fpregset.ExtractBytes(0, size, lldb::eByteOrderLittle, m_fpregset.get()); if (len != size) m_fpregset.reset(); }
lldb::offset_t ObjectContainerBSDArchive::Object::Extract (const DataExtractor& data, lldb::offset_t offset) { size_t ar_name_len = 0; std::string str; char *err; str.assign ((const char *)data.GetData(&offset, 16), 16); if (str.find("#1/") == 0) { // If the name is longer than 16 bytes, or contains an embedded space // then it will use this format where the length of the name is // here and the name characters are after this header. ar_name_len = strtoul(str.c_str() + 3, &err, 10); } else { // Strip off any spaces (if the object file name contains spaces it // will use the extended format above). str.erase (str.find(' ')); ar_name.SetCString(str.c_str()); } str.assign ((const char *)data.GetData(&offset, 12), 12); ar_date = strtoul(str.c_str(), &err, 10); str.assign ((const char *)data.GetData(&offset, 6), 6); ar_uid = strtoul(str.c_str(), &err, 10); str.assign ((const char *)data.GetData(&offset, 6), 6); ar_gid = strtoul(str.c_str(), &err, 10); str.assign ((const char *)data.GetData(&offset, 8), 8); ar_mode = strtoul(str.c_str(), &err, 8); str.assign ((const char *)data.GetData(&offset, 10), 10); ar_size = strtoul(str.c_str(), &err, 10); str.assign ((const char *)data.GetData(&offset, 2), 2); if (str == ARFMAG) { if (ar_name_len > 0) { str.assign ((const char *)data.GetData(&offset, ar_name_len), ar_name_len); ar_name.SetCString (str.c_str()); } ar_file_offset = offset; ar_file_size = ar_size - ar_name_len; return offset; } return LLDB_INVALID_OFFSET; }
size_t Disassembler::ParseInstructions ( const ExecutionContext *exe_ctx, const AddressRange &range, DataExtractor& data ) { Target *target = exe_ctx->target; const addr_t byte_size = range.GetByteSize(); if (target == NULL || byte_size == 0 || !range.GetBaseAddress().IsValid()) return 0; DataBufferHeap *heap_buffer = new DataBufferHeap (byte_size, '\0'); DataBufferSP data_sp(heap_buffer); Error error; const size_t bytes_read = target->ReadMemory (range.GetBaseAddress(), heap_buffer->GetBytes(), heap_buffer->GetByteSize(), error); if (bytes_read > 0) { if (bytes_read != heap_buffer->GetByteSize()) heap_buffer->SetByteSize (bytes_read); data.SetData(data_sp); if (exe_ctx->process) { data.SetByteOrder(exe_ctx->process->GetByteOrder()); data.SetAddressByteSize(exe_ctx->process->GetAddressByteSize()); } else { data.SetByteOrder(target->GetArchitecture().GetDefaultEndian()); data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize()); } return DecodeInstructions (data, 0, UINT32_MAX); } return 0; }
size_t ObjectFilePECOFF::GetModuleSpecifications( const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, lldb_private::ModuleSpecList &specs) { const size_t initial_count = specs.GetSize(); if (ObjectFilePECOFF::MagicBytesMatch(data_sp)) { DataExtractor data; data.SetData(data_sp, data_offset, length); data.SetByteOrder(eByteOrderLittle); dos_header_t dos_header; coff_header_t coff_header; if (ParseDOSHeader(data, dos_header)) { lldb::offset_t offset = dos_header.e_lfanew; uint32_t pe_signature = data.GetU32(&offset); if (pe_signature != IMAGE_NT_SIGNATURE) return false; if (ParseCOFFHeader(data, &offset, coff_header)) { ArchSpec spec; if (coff_header.machine == MachineAmd64) { spec.SetTriple("x86_64-pc-windows"); specs.Append(ModuleSpec(file, spec)); } else if (coff_header.machine == MachineX86) { spec.SetTriple("i386-pc-windows"); specs.Append(ModuleSpec(file, spec)); spec.SetTriple("i686-pc-windows"); specs.Append(ModuleSpec(file, spec)); } else if (coff_header.machine == MachineArmNt) { spec.SetTriple("arm-pc-windows"); specs.Append(ModuleSpec(file, spec)); } } } } return specs.GetSize() - initial_count; }
//---------------------------------------------------------------------- // Get the section data from a complete contiguous copy of the // entire executable image. //---------------------------------------------------------------------- size_t Section::GetSectionDataFromImage (const DataExtractor& image_data, DataExtractor& section_data) const { size_t file_size = GetByteSize(); if (file_size > 0) { off_t file_offset = GetFileOffset(); if (section_data.SetData (image_data, file_offset, file_size) == file_size) return true; } return false; }
Scalar & Value::ResolveValue(ExecutionContext *exe_ctx, clang::ASTContext *ast_context) { void *opaque_clang_qual_type = GetClangType(); if (opaque_clang_qual_type) { switch (m_value_type) { case eValueTypeScalar: // raw scalar value break; default: case eValueTypeFileAddress: m_value.Clear(); break; case eValueTypeLoadAddress: // load address value case eValueTypeHostAddress: // host address value (for memory in the process that is using liblldb) { AddressType address_type = m_value_type == eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost; lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS); DataExtractor data; if (ClangASTType::ReadFromMemory (ast_context, opaque_clang_qual_type, exe_ctx, addr, address_type, data)) { Scalar scalar; if (ClangASTType::GetValueAsScalar (ast_context, opaque_clang_qual_type, data, 0, data.GetByteSize(), scalar)) { m_value = scalar; m_value_type = eValueTypeScalar; } else { if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) { m_value.Clear(); m_value_type = eValueTypeScalar; } } } else { if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) { m_value.Clear(); m_value_type = eValueTypeScalar; } } } break; } } return m_value; }
/// State transition when a NewBufferRecord is encountered. Error processFDRNewBufferRecord(FDRState &State, uint8_t RecordFirstByte, DataExtractor &RecordExtractor) { if (State.Expects != FDRState::Token::NEW_BUFFER_RECORD_OR_EOF) return make_error<StringError>( "Malformed log. Read New Buffer record kind out of sequence", std::make_error_code(std::errc::executable_format_error)); uint32_t OffsetPtr = 1; // 1 byte into record. State.ThreadId = RecordExtractor.getU16(&OffsetPtr); State.Expects = FDRState::Token::WALLCLOCK_RECORD; return Error::success(); }
void DWARFDebugAbbrev::extract(DataExtractor Data) { clear(); uint32_t Offset = 0; DWARFAbbreviationDeclarationSet AbbrDecls; while (Data.isValidOffset(Offset)) { uint32_t CUAbbrOffset = Offset; if (!AbbrDecls.extract(Data, &Offset)) break; AbbrDeclSets[CUAbbrOffset] = std::move(AbbrDecls); } }
bool DWARFCompileUnit::Extract(const DataExtractor &debug_info, uint32_t* offset_ptr) { Clear(); m_offset = *offset_ptr; if (debug_info.ValidOffset(*offset_ptr)) { dw_offset_t abbr_offset; const DWARFDebugAbbrev *abbr = m_dwarf2Data->DebugAbbrev(); m_length = debug_info.GetU32(offset_ptr); m_version = debug_info.GetU16(offset_ptr); abbr_offset = debug_info.GetU32(offset_ptr); m_addr_size = debug_info.GetU8 (offset_ptr); bool length_OK = debug_info.ValidOffset(GetNextCompileUnitOffset()-1); bool version_OK = SymbolFileDWARF::SupportedVersion(m_version); bool abbr_offset_OK = m_dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset); bool addr_size_OK = ((m_addr_size == 4) || (m_addr_size == 8)); if (length_OK && version_OK && addr_size_OK && abbr_offset_OK && abbr != NULL) { m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset); return true; } // reset the offset to where we tried to parse from if anything went wrong *offset_ptr = m_offset; } return false; }
bool DWARFDebugMacinfoEntry::Extract(const DataExtractor& mac_info_data, dw_offset_t* offset_ptr) { if (mac_info_data.ValidOffset(*offset_ptr)) { m_type_code = mac_info_data.GetU8(offset_ptr); switch (m_type_code) { case DW_MACINFO_define: case DW_MACINFO_undef: // 2 operands: // Arg 1: operand encodes the line number of the source line on which // the relevant defining or undefining pre-processor directives // appeared. m_line = mac_info_data.GetULEB128(offset_ptr); // Arg 2: define string m_op2.cstr = mac_info_data.GetCStr(offset_ptr); break; case DW_MACINFO_start_file: // 2 operands: // Op 1: line number of the source line on which the inclusion // pre-processor directive occurred. m_line = mac_info_data.GetULEB128(offset_ptr); // Op 2: a source file name index to a file number in the statement // information table for the relevant compilation unit. m_op2.file_idx = mac_info_data.GetULEB128(offset_ptr); break; case 0: // End of list case DW_MACINFO_end_file: // No operands m_line = DW_INVALID_OFFSET; m_op2.cstr = NULL; break; default: // Vendor specific entries always have a ULEB128 and a string m_line = mac_info_data.GetULEB128(offset_ptr); m_op2.cstr = mac_info_data.GetCStr(offset_ptr); break; } return true; } else m_type_code = 0; return false; }
void DWARFDebugLocDWO::parse(DataExtractor data) { uint32_t Offset = 0; while (data.isValidOffset(Offset)) { Locations.resize(Locations.size() + 1); LocationList &Loc = Locations.back(); Loc.Offset = Offset; dwarf::LocationListEntry Kind; while ((Kind = static_cast<dwarf::LocationListEntry>( data.getU8(&Offset))) != dwarf::DW_LLE_end_of_list) { if (Kind != dwarf::DW_LLE_startx_length) { llvm::errs() << "error: dumping support for LLE of kind " << (int)Kind << " not implemented\n"; return; } Entry E; E.Start = data.getULEB128(&Offset); E.Length = data.getU32(&Offset); unsigned Bytes = data.getU16(&Offset); // A single location description describing the location of the object... StringRef str = data.getData().substr(Offset, Bytes); Offset += Bytes; E.Loc.resize(str.size()); std::copy(str.begin(), str.end(), E.Loc.begin()); Loc.Entries.push_back(std::move(E)); } } }
bool DWARFCompileUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) { clear(); Offset = *offset_ptr; if (debug_info.isValidOffset(*offset_ptr)) { uint64_t abbrOffset; Length = debug_info.getU32(offset_ptr); Version = debug_info.getU16(offset_ptr); abbrOffset = debug_info.getU32(offset_ptr); AddrSize = debug_info.getU8(offset_ptr); bool lengthOK = debug_info.isValidOffset(getNextCompileUnitOffset()-1); bool versionOK = DWARFContext::isSupportedVersion(Version); bool abbrOffsetOK = AbbrevSection.size() > abbrOffset; bool addrSizeOK = AddrSize == 4 || AddrSize == 8; if (lengthOK && versionOK && addrSizeOK && abbrOffsetOK && Abbrev != NULL) { Abbrevs = Abbrev->getAbbreviationDeclarationSet(abbrOffset); return true; } // reset the offset to where we tried to parse from if anything went wrong *offset_ptr = Offset; } return false; }
RegisterContextCorePOSIX_powerpc::RegisterContextCorePOSIX_powerpc( Thread &thread, RegisterInfoInterface *register_info, const DataExtractor &gpregset, const DataExtractor &fpregset, const DataExtractor &vregset) : RegisterContextPOSIX_powerpc(thread, 0, register_info) { m_gpr_buffer.reset( new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize())); m_gpr.SetData(m_gpr_buffer); m_gpr.SetByteOrder(gpregset.GetByteOrder()); m_fpr_buffer.reset( new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize())); m_fpr.SetData(m_fpr_buffer); m_fpr.SetByteOrder(fpregset.GetByteOrder()); m_vec_buffer.reset( new DataBufferHeap(vregset.GetDataStart(), vregset.GetByteSize())); m_vec.SetData(m_vec_buffer); m_vec.SetByteOrder(vregset.GetByteOrder()); }
Scalar &Value::ResolveValue(ExecutionContext *exe_ctx) { const CompilerType &compiler_type = GetCompilerType(); if (compiler_type.IsValid()) { switch (m_value_type) { case eValueTypeScalar: // raw scalar value break; default: case eValueTypeFileAddress: case eValueTypeLoadAddress: // load address value case eValueTypeHostAddress: // host address value (for memory in the process // that is using liblldb) { DataExtractor data; lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS); Status error(GetValueAsData(exe_ctx, data, 0, NULL)); if (error.Success()) { Scalar scalar; if (compiler_type.GetValueAsScalar(data, 0, data.GetByteSize(), scalar)) { m_value = scalar; m_value_type = eValueTypeScalar; } else { if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) { m_value.Clear(); m_value_type = eValueTypeScalar; } } } else { if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) { m_value.Clear(); m_value_type = eValueTypeScalar; } } } break; } } return m_value; }
size_t Section::MemoryMapSectionDataFromObjectFile(const ObjectFile* objfile, DataExtractor& section_data) const { if (objfile == NULL) return 0; const FileSpec& file = objfile->GetFileSpec(); if (file) { size_t section_file_size = GetFileSize(); if (section_file_size > 0) { off_t section_file_offset = GetFileOffset() + objfile->GetOffset(); DataBufferSP section_data_sp(file.MemoryMapFileContents(section_file_offset, section_file_size)); section_data.SetByteOrder(objfile->GetByteOrder()); section_data.SetAddressByteSize(objfile->GetAddressByteSize()); return section_data.SetData (section_data_sp); } } return 0; }
bool DWARFUnitIndex::parseImpl(DataExtractor IndexData) { uint32_t Offset = 0; if (!Header.parse(IndexData, &Offset)) return false; if (!IndexData.isValidOffsetForDataOfSize( Offset, Header.NumBuckets * (8 + 4) + (2 * Header.NumUnits + 1) * 4 * Header.NumColumns)) return false; Rows = llvm::make_unique<Entry[]>(Header.NumBuckets); auto Contribs = llvm::make_unique<Entry::SectionContribution *[]>(Header.NumUnits); ColumnKinds = llvm::make_unique<DWARFSectionKind[]>(Header.NumColumns); // Read Hash Table of Signatures for (unsigned i = 0; i != Header.NumBuckets; ++i) Rows[i].Signature = IndexData.getU64(&Offset); // Read Parallel Table of Indexes for (unsigned i = 0; i != Header.NumBuckets; ++i) { auto Index = IndexData.getU32(&Offset); if (!Index) continue; Rows[i].Index = this; Rows[i].Contributions = llvm::make_unique<Entry::SectionContribution[]>(Header.NumColumns); Contribs[Index - 1] = Rows[i].Contributions.get(); } // Read the Column Headers for (unsigned i = 0; i != Header.NumColumns; ++i) { ColumnKinds[i] = static_cast<DWARFSectionKind>(IndexData.getU32(&Offset)); if (ColumnKinds[i] == InfoColumnKind) { if (InfoColumn != -1) return false; InfoColumn = i; } } if (InfoColumn == -1) return false; // Read Table of Section Offsets for (unsigned i = 0; i != Header.NumUnits; ++i) { auto *Contrib = Contribs[i]; for (unsigned i = 0; i != Header.NumColumns; ++i) Contrib[i].Offset = IndexData.getU32(&Offset); } // Read Table of Section Sizes for (unsigned i = 0; i != Header.NumUnits; ++i) { auto *Contrib = Contribs[i]; for (unsigned i = 0; i != Header.NumColumns; ++i) Contrib[i].Length = IndexData.getU32(&Offset); } return true; }
bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U, uint32_t *OffsetPtr) { Offset = *OffsetPtr; DataExtractor DebugInfoData = U->getDebugInfoExtractor(); uint32_t UEndOffset = U->getNextUnitOffset(); if (Offset >= UEndOffset || !DebugInfoData.isValidOffset(Offset)) return false; uint64_t AbbrCode = DebugInfoData.getULEB128(OffsetPtr); if (0 == AbbrCode) { // NULL debug tag entry. AbbrevDecl = nullptr; return true; } AbbrevDecl = U->getAbbreviations()->getAbbreviationDeclaration(AbbrCode); if (nullptr == AbbrevDecl) { // Restore the original offset. *OffsetPtr = Offset; return false; } ArrayRef<uint8_t> FixedFormSizes = DWARFFormValue::getFixedFormSizes( U->getAddressByteSize(), U->getVersion()); assert(FixedFormSizes.size() > 0); // Skip all data in the .debug_info for the attributes for (const auto &AttrSpec : AbbrevDecl->attributes()) { uint16_t Form = AttrSpec.Form; uint8_t FixedFormSize = (Form < FixedFormSizes.size()) ? FixedFormSizes[Form] : 0; if (FixedFormSize) *OffsetPtr += FixedFormSize; else if (!DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U)) { // Restore the original offset. *OffsetPtr = Offset; return false; } } return true; }
static bool FileAtPathContainsArchAndUUID ( const FileSpec &file_spec, const ArchSpec *arch, const lldb_private::UUID *uuid ) { DataExtractor data; off_t file_offset = 0; DataBufferSP data_buffer_sp (file_spec.ReadFileContents (file_offset, 0x1000)); if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0) { data.SetData(data_buffer_sp); uint32_t data_offset = 0; uint32_t magic = data.GetU32(&data_offset); switch (magic) { // 32 bit mach-o file case HeaderMagic32: case HeaderMagic32Swapped: case HeaderMagic64: case HeaderMagic64Swapped: return SkinnyMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset, data, data_offset, magic); // fat mach-o file case UniversalMagic: case UniversalMagicSwapped: return UniversalMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset, data, data_offset, magic); default: break; } } return false; }
bool Value::GetData(DataExtractor &data) { switch (m_value_type) { default: break; case eValueTypeScalar: if (m_value.GetData(data)) return true; break; case eValueTypeLoadAddress: case eValueTypeFileAddress: case eValueTypeHostAddress: if (m_data_buffer.GetByteSize()) { data.SetData(m_data_buffer.GetBytes(), m_data_buffer.GetByteSize(), data.GetByteOrder()); return true; } break; } return false; }
DataExtractor ObjectFilePECOFF::ReadImageData(uint32_t offset, size_t size) { if (m_file) { // A bit of a hack, but we intend to write to this buffer, so we can't // mmap it. auto buffer_sp = DataBufferLLVM::CreateSliceFromPath(m_file.GetPath(), size, offset, true); return DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()); } ProcessSP process_sp(m_process_wp.lock()); DataExtractor data; if (process_sp) { auto data_ap = llvm::make_unique<DataBufferHeap>(size, 0); Status readmem_error; size_t bytes_read = process_sp->ReadMemory(m_image_base + offset, data_ap->GetBytes(), data_ap->GetByteSize(), readmem_error); if (bytes_read == size) { DataBufferSP buffer_sp(data_ap.release()); data.SetData(buffer_sp, 0, buffer_sp->GetByteSize()); } } return data; }
RegisterContextCorePOSIX_mips64::RegisterContextCorePOSIX_mips64(Thread &thread, RegisterInfoInterface *register_info, const DataExtractor &gpregset, const DataExtractor &fpregset) : RegisterContextPOSIX_mips64(thread, 0, register_info) { size_t i; lldb::offset_t offset = 0; for (i = 0; i < k_num_gpr_registers_mips64; i++) { m_reg[i] = gpregset.GetU64(&offset); } }
void ThreadKDP::SetStopInfoFrom_KDP_EXCEPTION (const DataExtractor &exc_reply_packet) { lldb::offset_t offset = 0; uint8_t reply_command = exc_reply_packet.GetU8(&offset); if (reply_command == CommunicationKDP::KDP_EXCEPTION) { offset = 8; const uint32_t count = exc_reply_packet.GetU32 (&offset); if (count >= 1) { //const uint32_t cpu = exc_reply_packet.GetU32 (&offset); offset += 4; // Skip the useless CPU field const uint32_t exc_type = exc_reply_packet.GetU32 (&offset); const uint32_t exc_code = exc_reply_packet.GetU32 (&offset); const uint32_t exc_subcode = exc_reply_packet.GetU32 (&offset); // We have to make a copy of the stop info because the thread list // will iterate through the threads and clear all stop infos.. // Let the StopInfoMachException::CreateStopReasonWithMachException() // function update the PC if needed as we might hit a software breakpoint // and need to decrement the PC (i386 and x86_64 need this) and KDP // doesn't do this for us. const bool pc_already_adjusted = false; const bool adjust_pc_if_needed = true; m_cached_stop_info_sp = StopInfoMachException::CreateStopReasonWithMachException (*this, exc_type, 2, exc_code, exc_subcode, 0, pc_already_adjusted, adjust_pc_if_needed); } } }