Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- DWARFVerifier.h ----------------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H

#define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H

#include "llvm/DebugInfo/DIContext.h"

#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"

#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"

#include "llvm/DebugInfo/DWARF/DWARFDie.h"

#include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"

#include <cstdint>

#include <map>

#include <set>

namespace llvm {

class raw_ostream;

struct DWARFAddressRange;

class DWARFUnit;

class DWARFUnitVector;

struct DWARFAttribute;

class DWARFContext;

class DWARFDataExtractor;

class DWARFDebugAbbrev;

class DataExtractor;

struct DWARFSection;

/// A class that verifies DWARF debug information given a DWARF Context.

class DWARFVerifier {

public:

  /// A class that keeps the address range information for a single DIE.

  struct DieRangeInfo {

    DWARFDie Die;

    /// Sorted DWARFAddressRanges.

    std::vector<DWARFAddressRange> Ranges;

    /// Sorted DWARFAddressRangeInfo.

    std::set<DieRangeInfo> Children;

    DieRangeInfo() = default;

    DieRangeInfo(DWARFDie Die) : Die(Die) {}

    /// Used for unit testing.

    DieRangeInfo(std::vector<DWARFAddressRange> Ranges)

        : Ranges(std::move(Ranges)) {}

    typedef std::set<DieRangeInfo>::const_iterator die_range_info_iterator;

    /// Inserts the address range. If the range overlaps with an existing

    /// range, the range that it overlaps with will be returned and the two

    /// address ranges will be unioned together in "Ranges".

    ///

    /// This is used for finding overlapping ranges in the DW_AT_ranges

    /// attribute of a DIE. It is also used as a set of address ranges that

    /// children address ranges must all be contained in.

    std::optional<DWARFAddressRange> insert(const DWARFAddressRange &R);

    /// Inserts the address range info. If any of its ranges overlaps with a

    /// range in an existing range info, the range info is *not* added and an

    /// iterator to the overlapping range info.

    ///

    /// This is used for finding overlapping children of the same DIE.

    die_range_info_iterator insert(const DieRangeInfo &RI);

    /// Return true if ranges in this object contains all ranges within RHS.

    bool contains(const DieRangeInfo &RHS) const;

    /// Return true if any range in this object intersects with any range in

    /// RHS.

    bool intersects(const DieRangeInfo &RHS) const;

  };

private:

  raw_ostream &OS;

  DWARFContext &DCtx;

  DIDumpOptions DumpOpts;

  uint32_t NumDebugLineErrors = 0;

  // Used to relax some checks that do not currently work portably

  bool IsObjectFile;

  bool IsMachOObject;

  using ReferenceMap = std::map<uint64_t, std::set<uint64_t>>;

  raw_ostream &error() const;

  raw_ostream &warn() const;

  raw_ostream &note() const;

  raw_ostream &dump(const DWARFDie &Die, unsigned indent = 0) const;

  /// Verifies the abbreviations section.

  ///

  /// This function currently checks that:

  /// --No abbreviation declaration has more than one attributes with the same

  /// name.

  ///

  /// \param Abbrev Pointer to the abbreviations section we are verifying

  /// Abbrev can be a pointer to either .debug_abbrev or debug_abbrev.dwo.

  ///

  /// \returns The number of errors that occurred during verification.

  unsigned verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev);

  /// Verifies the header of a unit in a .debug_info or .debug_types section.

  ///

  /// This function currently checks for:

  /// - Unit is in 32-bit DWARF format. The function can be modified to

  /// support 64-bit format.

  /// - The DWARF version is valid

  /// - The unit type is valid (if unit is in version >=5)

  /// - The unit doesn't extend beyond the containing section

  /// - The address size is valid

  /// - The offset in the .debug_abbrev section is valid

  ///

  /// \param DebugInfoData The section data

  /// \param Offset A reference to the offset start of the unit. The offset will

  /// be updated to point to the next unit in the section

  /// \param UnitIndex The index of the unit to be verified

  /// \param UnitType A reference to the type of the unit

  /// \param isUnitDWARF64 A reference to a flag that shows whether the unit is

  /// in 64-bit format.

  ///

  /// \returns true if the header is verified successfully, false otherwise.

  bool verifyUnitHeader(const DWARFDataExtractor DebugInfoData,

                        uint64_t *Offset, unsigned UnitIndex, uint8_t &UnitType,

                        bool &isUnitDWARF64);

  bool verifyName(const DWARFDie &Die);

  /// Verifies the header of a unit in a .debug_info or .debug_types section.

  ///

  /// This function currently verifies:

  ///  - The debug info attributes.

  ///  - The debug info form=s.

  ///  - The presence of a root DIE.

  ///  - That the root DIE is a unit DIE.

  ///  - If a unit type is provided, that the unit DIE matches the unit type.

  ///  - The DIE ranges.

  ///  - That call site entries are only nested within subprograms with a

  ///    DW_AT_call attribute.

  ///

  /// \param Unit      The DWARF Unit to verify.

  ///

  /// \returns The number of errors that occurred during verification.

  unsigned verifyUnitContents(DWARFUnit &Unit,

                              ReferenceMap &UnitLocalReferences,

                              ReferenceMap &CrossUnitReferences);

  /// Verifies the unit headers and contents in a .debug_info or .debug_types

  /// section.

  ///

  /// \param S           The DWARF Section to verify.

  ///

  /// \returns The number of errors that occurred during verification.

  unsigned verifyUnitSection(const DWARFSection &S);

  unsigned verifyUnits(const DWARFUnitVector &Units);

  unsigned verifyIndexes(const DWARFObject &DObj);

  unsigned verifyIndex(StringRef Name, DWARFSectionKind SectionKind,

                       StringRef Index);

  /// Verifies that a call site entry is nested within a subprogram with a

  /// DW_AT_call attribute.

  ///

  /// \returns Number of errors that occurred during verification.

  unsigned verifyDebugInfoCallSite(const DWARFDie &Die);

  /// Verify that all Die ranges are valid.

  ///

  /// This function currently checks for:

  /// - cases in which lowPC >= highPC

  ///

  /// \returns Number of errors that occurred during verification.

  unsigned verifyDieRanges(const DWARFDie &Die, DieRangeInfo &ParentRI);

  /// Verifies the attribute's DWARF attribute and its value.

  ///

  /// This function currently checks for:

  /// - DW_AT_ranges values is a valid .debug_ranges offset

  /// - DW_AT_stmt_list is a valid .debug_line offset

  ///

  /// \param Die          The DWARF DIE that owns the attribute value

  /// \param AttrValue    The DWARF attribute value to check

  ///

  /// \returns NumErrors The number of errors occurred during verification of

  /// attributes' values in a unit

  unsigned verifyDebugInfoAttribute(const DWARFDie &Die,

                                    DWARFAttribute &AttrValue);

  /// Verifies the attribute's DWARF form.

  ///

  /// This function currently checks for:

  /// - All DW_FORM_ref values that are CU relative have valid CU offsets

  /// - All DW_FORM_ref_addr values have valid section offsets

  /// - All DW_FORM_strp values have valid .debug_str offsets

  ///

  /// \param Die          The DWARF DIE that owns the attribute value

  /// \param AttrValue    The DWARF attribute value to check

  ///

  /// \returns NumErrors The number of errors occurred during verification of

  /// attributes' forms in a unit

  unsigned verifyDebugInfoForm(const DWARFDie &Die, DWARFAttribute &AttrValue,

                               ReferenceMap &UnitLocalReferences,

                               ReferenceMap &CrossUnitReferences);

  /// Verifies the all valid references that were found when iterating through

  /// all of the DIE attributes.

  ///

  /// This function will verify that all references point to DIEs whose DIE

  /// offset matches. This helps to ensure if a DWARF link phase moved things

  /// around, that it doesn't create invalid references by failing to relocate

  /// CU relative and absolute references.

  ///

  /// \returns NumErrors The number of errors occurred during verification of

  /// references for the .debug_info and .debug_types sections

  unsigned verifyDebugInfoReferences(

      const ReferenceMap &,

      llvm::function_ref<DWARFUnit *(uint64_t)> GetUnitForDieOffset);

  /// Verify the DW_AT_stmt_list encoding and value and ensure that no

  /// compile units that have the same DW_AT_stmt_list value.

  void verifyDebugLineStmtOffsets();

  /// Verify that all of the rows in the line table are valid.

  ///

  /// This function currently checks for:

  /// - addresses within a sequence that decrease in value

  /// - invalid file indexes

  void verifyDebugLineRows();

  /// Verify that an Apple-style accelerator table is valid.

  ///

  /// This function currently checks that:

  /// - The fixed part of the header fits in the section

  /// - The size of the section is as large as what the header describes

  /// - There is at least one atom

  /// - The form for each atom is valid

  /// - The tag for each DIE in the table is valid

  /// - The buckets have a valid index, or they are empty

  /// - Each hashdata offset is valid

  /// - Each DIE is valid

  ///

  /// \param AccelSection pointer to the section containing the acceleration table

  /// \param StrData pointer to the string section

  /// \param SectionName the name of the table we're verifying

  ///

  /// \returns The number of errors occurred during verification

  unsigned verifyAppleAccelTable(const DWARFSection *AccelSection,

                                 DataExtractor *StrData,

                                 const char *SectionName);

  unsigned verifyDebugNamesCULists(const DWARFDebugNames &AccelTable);

  unsigned verifyNameIndexBuckets(const DWARFDebugNames::NameIndex &NI,

                                  const DataExtractor &StrData);

  unsigned verifyNameIndexAbbrevs(const DWARFDebugNames::NameIndex &NI);

  unsigned verifyNameIndexAttribute(const DWARFDebugNames::NameIndex &NI,

                                    const DWARFDebugNames::Abbrev &Abbr,

                                    DWARFDebugNames::AttributeEncoding AttrEnc);

  unsigned verifyNameIndexEntries(const DWARFDebugNames::NameIndex &NI,

                                  const DWARFDebugNames::NameTableEntry &NTE);

  unsigned verifyNameIndexCompleteness(const DWARFDie &Die,

                                       const DWARFDebugNames::NameIndex &NI);

  /// Verify that the DWARF v5 accelerator table is valid.

  ///

  /// This function currently checks that:

  /// - Headers individual Name Indices fit into the section and can be parsed.

  /// - Abbreviation tables can be parsed and contain valid index attributes

  ///   with correct form encodings.

  /// - The CU lists reference existing compile units.

  /// - The buckets have a valid index, or they are empty.

  /// - All names are reachable via the hash table (they have the correct hash,

  ///   and the hash is in the correct bucket).

  /// - Information in the index entries is complete (all required entries are

  ///   present) and consistent with the debug_info section DIEs.

  ///

  /// \param AccelSection section containing the acceleration table

  /// \param StrData string section

  ///

  /// \returns The number of errors occurred during verification

  unsigned verifyDebugNames(const DWARFSection &AccelSection,

                            const DataExtractor &StrData);

public:

  DWARFVerifier(raw_ostream &S, DWARFContext &D,

                DIDumpOptions DumpOpts = DIDumpOptions::getForSingleDIE());

  /// Verify the information in any of the following sections, if available:

  /// .debug_abbrev, debug_abbrev.dwo

  ///

  /// Any errors are reported to the stream that was this object was

  /// constructed with.

  ///

  /// \returns true if .debug_abbrev and .debug_abbrev.dwo verify successfully,

  /// false otherwise.

  bool handleDebugAbbrev();

  /// Verify the information in the .debug_info and .debug_types sections.

  ///

  /// Any errors are reported to the stream that this object was

  /// constructed with.

  ///

  /// \returns true if all sections verify successfully, false otherwise.

  bool handleDebugInfo();

  /// Verify the information in the .debug_cu_index section.

  ///

  /// Any errors are reported to the stream that was this object was

  /// constructed with.

  ///

  /// \returns true if the .debug_cu_index verifies successfully, false

  /// otherwise.

  bool handleDebugCUIndex();

  /// Verify the information in the .debug_tu_index section.

  ///

  /// Any errors are reported to the stream that was this object was

  /// constructed with.

  ///

  /// \returns true if the .debug_tu_index verifies successfully, false

  /// otherwise.

  bool handleDebugTUIndex();

  /// Verify the information in the .debug_line section.

  ///

  /// Any errors are reported to the stream that was this object was

  /// constructed with.

  ///

  /// \returns true if the .debug_line verifies successfully, false otherwise.

  bool handleDebugLine();

  /// Verify the information in accelerator tables, if they exist.

  ///

  /// Any errors are reported to the stream that was this object was

  /// constructed with.

  ///

  /// \returns true if the existing Apple-style accelerator tables verify

  /// successfully, false otherwise.

  bool handleAccelTables();

};

static inline bool operator<(const DWARFVerifier::DieRangeInfo &LHS,

                             const DWARFVerifier::DieRangeInfo &RHS) {

  return std::tie(LHS.Ranges, LHS.Die) < std::tie(RHS.Ranges, RHS.Die);

}

} // end namespace llvm

#endif // LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H