void DWARFDebugLoc::parse(const DWARFDataExtractor &data) { IsLittleEndian = data.isLittleEndian(); AddressSize = data.getAddressSize(); uint32_t Offset = 0; while (data.isValidOffset(Offset + data.getAddressSize() - 1)) { if (auto LL = parseOneLocationList(data, &Offset)) Locations.push_back(std::move(*LL)); else break; } if (data.isValidOffset(Offset)) errs() << "error: failed to consume entire .debug_loc section\n"; }
llvm::Error DWARFDebugNames::Header::extract(const DWARFDataExtractor &AS, uint32_t *Offset) { // Check that we can read the fixed-size part. if (!AS.isValidOffset(*Offset + sizeof(HeaderPOD) - 1)) return make_error<StringError>("Section too small: cannot read header.", inconvertibleErrorCode()); UnitLength = AS.getU32(Offset); Version = AS.getU16(Offset); Padding = AS.getU16(Offset); CompUnitCount = AS.getU32(Offset); LocalTypeUnitCount = AS.getU32(Offset); ForeignTypeUnitCount = AS.getU32(Offset); BucketCount = AS.getU32(Offset); NameCount = AS.getU32(Offset); AbbrevTableSize = AS.getU32(Offset); AugmentationStringSize = AS.getU32(Offset); if (!AS.isValidOffsetForDataOfSize(*Offset, AugmentationStringSize)) return make_error<StringError>( "Section too small: cannot read header augmentation.", inconvertibleErrorCode()); AugmentationString.resize(AugmentationStringSize); AS.getU8(Offset, reinterpret_cast<uint8_t *>(AugmentationString.data()), AugmentationStringSize); *Offset = alignTo(*Offset, 4); return Error::success(); }
bool DWARFDebugRangeList::extract(const DWARFDataExtractor &data, uint32_t *offset_ptr) { clear(); if (!data.isValidOffset(*offset_ptr)) return false; AddressSize = data.getAddressSize(); if (AddressSize != 4 && AddressSize != 8) return false; Offset = *offset_ptr; while (true) { RangeListEntry entry; uint32_t prev_offset = *offset_ptr; entry.StartAddress = data.getRelocatedAddress(offset_ptr, &entry.SectionIndex); entry.EndAddress = data.getRelocatedAddress(offset_ptr); // Check that both values were extracted correctly. if (*offset_ptr != prev_offset + 2 * AddressSize) { clear(); return false; } if (entry.isEndOfListEntry()) break; Entries.push_back(entry); } return true; }
Error DWARFDebugRangeList::extract(const DWARFDataExtractor &data, uint32_t *offset_ptr) { clear(); if (!data.isValidOffset(*offset_ptr)) return createStringError(errc::invalid_argument, "invalid range list offset 0x%" PRIx32, *offset_ptr); AddressSize = data.getAddressSize(); if (AddressSize != 4 && AddressSize != 8) return createStringError(errc::invalid_argument, "invalid address size: %" PRIu8, AddressSize); Offset = *offset_ptr; while (true) { RangeListEntry Entry; Entry.SectionIndex = -1ULL; uint32_t prev_offset = *offset_ptr; Entry.StartAddress = data.getRelocatedAddress(offset_ptr); Entry.EndAddress = data.getRelocatedAddress(offset_ptr, &Entry.SectionIndex); // Check that both values were extracted correctly. if (*offset_ptr != prev_offset + 2 * AddressSize) { clear(); return createStringError(errc::invalid_argument, "invalid range list entry at offset 0x%" PRIx32, prev_offset); } if (Entry.isEndOfListEntry()) break; Entries.push_back(Entry); } return Error::success(); }
Expected<const DWARFDebugLine::LineTable *> DWARFDebugLine::getOrParseLineTable( DWARFDataExtractor &DebugLineData, uint32_t Offset, const DWARFContext &Ctx, const DWARFUnit *U, std::function<void(Error)> RecoverableErrorCallback) { if (!DebugLineData.isValidOffset(Offset)) return createStringError(errc::invalid_argument, "offset 0x%8.8" PRIx32 " is not a valid debug line section offset", Offset); std::pair<LineTableIter, bool> Pos = LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable())); LineTable *LT = &Pos.first->second; if (Pos.second) { if (Error Err = LT->parse(DebugLineData, &Offset, Ctx, U, RecoverableErrorCallback)) return std::move(Err); return LT; } return LT; }
bool DWARFVerifier::verifyUnitHeader(const DWARFDataExtractor DebugInfoData, uint32_t *Offset, unsigned UnitIndex, uint8_t &UnitType, bool &isUnitDWARF64) { uint32_t AbbrOffset, Length; uint8_t AddrSize = 0; uint16_t Version; bool Success = true; bool ValidLength = false; bool ValidVersion = false; bool ValidAddrSize = false; bool ValidType = true; bool ValidAbbrevOffset = true; uint32_t OffsetStart = *Offset; Length = DebugInfoData.getU32(Offset); if (Length == UINT32_MAX) { isUnitDWARF64 = true; OS << format( "Unit[%d] is in 64-bit DWARF format; cannot verify from this point.\n", UnitIndex); return false; } Version = DebugInfoData.getU16(Offset); if (Version >= 5) { UnitType = DebugInfoData.getU8(Offset); AddrSize = DebugInfoData.getU8(Offset); AbbrOffset = DebugInfoData.getU32(Offset); ValidType = dwarf::isUnitType(UnitType); } else { UnitType = 0; AbbrOffset = DebugInfoData.getU32(Offset); AddrSize = DebugInfoData.getU8(Offset); } if (!DCtx.getDebugAbbrev()->getAbbreviationDeclarationSet(AbbrOffset)) ValidAbbrevOffset = false; ValidLength = DebugInfoData.isValidOffset(OffsetStart + Length + 3); ValidVersion = DWARFContext::isSupportedVersion(Version); ValidAddrSize = AddrSize == 4 || AddrSize == 8; if (!ValidLength || !ValidVersion || !ValidAddrSize || !ValidAbbrevOffset || !ValidType) { Success = false; error() << format("Units[%d] - start offset: 0x%08x \n", UnitIndex, OffsetStart); if (!ValidLength) note() << "The length for this unit is too " "large for the .debug_info provided.\n"; if (!ValidVersion) note() << "The 16 bit unit header version is not valid.\n"; if (!ValidType) note() << "The unit type encoding is not valid.\n"; if (!ValidAbbrevOffset) note() << "The offset into the .debug_abbrev section is " "not valid.\n"; if (!ValidAddrSize) note() << "The address size is unsupported.\n"; } *Offset = OffsetStart + Length + 4; return Success; }
bool DWARFUnitHeader::extract(DWARFContext &Context, const DWARFDataExtractor &debug_info, uint32_t *offset_ptr, DWARFSectionKind SectionKind, const DWARFUnitIndex *Index) { Offset = *offset_ptr; IndexEntry = Index ? Index->getFromOffset(*offset_ptr) : nullptr; Length = debug_info.getU32(offset_ptr); // FIXME: Support DWARF64. unsigned SizeOfLength = 4; FormParams.Format = DWARF32; FormParams.Version = debug_info.getU16(offset_ptr); if (FormParams.Version >= 5) { UnitType = debug_info.getU8(offset_ptr); FormParams.AddrSize = debug_info.getU8(offset_ptr); AbbrOffset = debug_info.getU32(offset_ptr); } else { AbbrOffset = debug_info.getRelocatedValue(4, offset_ptr); FormParams.AddrSize = debug_info.getU8(offset_ptr); // Fake a unit type based on the section type. This isn't perfect, // but distinguishing compile and type units is generally enough. if (SectionKind == DW_SECT_TYPES) UnitType = DW_UT_type; else UnitType = DW_UT_compile; } if (IndexEntry) { if (AbbrOffset) return false; auto *UnitContrib = IndexEntry->getOffset(); if (!UnitContrib || UnitContrib->Length != (Length + 4)) return false; auto *AbbrEntry = IndexEntry->getOffset(DW_SECT_ABBREV); if (!AbbrEntry) return false; AbbrOffset = AbbrEntry->Offset; } if (isTypeUnit()) { TypeHash = debug_info.getU64(offset_ptr); TypeOffset = debug_info.getU32(offset_ptr); } else if (UnitType == DW_UT_split_compile || UnitType == DW_UT_skeleton) DWOId = debug_info.getU64(offset_ptr); // Header fields all parsed, capture the size of this unit header. assert(*offset_ptr - Offset <= 255 && "unexpected header size"); Size = uint8_t(*offset_ptr - Offset); // Type offset is unit-relative; should be after the header and before // the end of the current unit. bool TypeOffsetOK = !isTypeUnit() ? true : TypeOffset >= Size && TypeOffset < getLength() + SizeOfLength; bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1); bool VersionOK = DWARFContext::isSupportedVersion(getVersion()); bool AddrSizeOK = getAddressByteSize() == 4 || getAddressByteSize() == 8; if (!LengthOK || !VersionOK || !AddrSizeOK || !TypeOffsetOK) return false; // Keep track of the highest DWARF version we encounter across all units. Context.setMaxVersionIfGreater(getVersion()); return true; }