include/llvm/DebugInfo/DWARF/DWARFVerifier.h

   1 //===- DWARFVerifier.h ----------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
  11 #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
  12
  13 #include "llvm/DebugInfo/DIContext.h"
  14 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
  15 #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
  16 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
  17
  18 #include <cstdint>
  19 #include <map>
  20 #include <set>
  21
  22 namespace llvm {
  23 class raw_ostream;
  24 struct DWARFAttribute;
  25 class DWARFContext;
  26 class DWARFDie;
  27 class DWARFUnit;
  28 class DWARFCompileUnit;
  29 class DWARFDataExtractor;
  30 class DWARFDebugAbbrev;
  31 class DataExtractor;
  32 struct DWARFSection;
  33
  34 /// A class that verifies DWARF debug information given a DWARF Context.
  35 class DWARFVerifier {
  36 public:
  37   /// A class that keeps the address range information for a single DIE.
  38   struct DieRangeInfo {
  39     DWARFDie Die;
  40
  41     /// Sorted DWARFAddressRanges.
  42     std::vector<DWARFAddressRange> Ranges;
  43
  44     /// Sorted DWARFAddressRangeInfo.
  45     std::set<DieRangeInfo> Children;
  46
  47     DieRangeInfo() = default;
  48     DieRangeInfo(DWARFDie Die) : Die(Die) {}
  49
  50     /// Used for unit testing.
  51     DieRangeInfo(std::vector<DWARFAddressRange> Ranges)
  52         : Ranges(std::move(Ranges)) {}
  53
  54     typedef std::vector<DWARFAddressRange>::const_iterator
  55         address_range_iterator;
  56     typedef std::set<DieRangeInfo>::const_iterator die_range_info_iterator;
  57
  58     /// Inserts the address range. If the range overlaps with an existing
  59     /// range, the range is *not* added and an iterator to the overlapping
  60     /// range is returned.
  61     ///
  62     /// This is used for finding overlapping ranges within the same DIE.
  63     address_range_iterator insert(const DWARFAddressRange &R);
  64
  65     /// Finds an address range in the sorted vector of ranges.
  66     address_range_iterator findRange(const DWARFAddressRange &R) const {
  67       auto Begin = Ranges.begin();
  68       auto End = Ranges.end();
  69       auto Iter = std::upper_bound(Begin, End, R);
  70       if (Iter != Begin)
  71         --Iter;
  72       return Iter;
  73     }
  74
  75     /// Inserts the address range info. If any of its ranges overlaps with a
  76     /// range in an existing range info, the range info is *not* added and an
  77     /// iterator to the overlapping range info.
  78     ///
  79     /// This is used for finding overlapping children of the same DIE.
  80     die_range_info_iterator insert(const DieRangeInfo &RI);
  81
  82     /// Return true if ranges in this object contains all ranges within RHS.
  83     bool contains(const DieRangeInfo &RHS) const;
  84
  85     /// Return true if any range in this object intersects with any range in
  86     /// RHS.
  87     bool intersects(const DieRangeInfo &RHS) const;
  88   };
  89
  90 private:
  91   raw_ostream &OS;
  92   DWARFContext &DCtx;
  93   DIDumpOptions DumpOpts;
  94   /// A map that tracks all references (converted absolute references) so we
  95   /// can verify each reference points to a valid DIE and not an offset that
  96   /// lies between to valid DIEs.
  97   std::map<uint64_t, std::set<uint32_t>> ReferenceToDIEOffsets;
  98   uint32_t NumDebugLineErrors = 0;
  99
 100   raw_ostream &error() const;
 101   raw_ostream &warn() const;
 102   raw_ostream &note() const;
 103
 104   /// Verifies the abbreviations section.
 105   ///
 106   /// This function currently checks that:
 107   /// --No abbreviation declaration has more than one attributes with the same
 108   /// name.
 109   ///
 110   /// \param Abbrev Pointer to the abbreviations section we are verifying
 111   /// Abbrev can be a pointer to either .debug_abbrev or debug_abbrev.dwo.
 112   ///
 113   /// \returns The number of errors that occurred during verification.
 114   unsigned verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev);
 115
 116   /// Verifies the header of a unit in the .debug_info section.
 117   ///
 118   /// This function currently checks for:
 119   /// - Unit is in 32-bit DWARF format. The function can be modified to
 120   /// support 64-bit format.
 121   /// - The DWARF version is valid
 122   /// - The unit type is valid (if unit is in version >=5)
 123   /// - The unit doesn't extend beyond .debug_info section
 124   /// - The address size is valid
 125   /// - The offset in the .debug_abbrev section is valid
 126   ///
 127   /// \param DebugInfoData The .debug_info section data
 128   /// \param Offset A reference to the offset start of the unit. The offset will
 129   /// be updated to point to the next unit in .debug_info
 130   /// \param UnitIndex The index of the unit to be verified
 131   /// \param UnitType A reference to the type of the unit
 132   /// \param isUnitDWARF64 A reference to a flag that shows whether the unit is
 133   /// in 64-bit format.
 134   ///
 135   /// \returns true if the header is verified successfully, false otherwise.
 136   bool verifyUnitHeader(const DWARFDataExtractor DebugInfoData,
 137                         uint32_t *Offset, unsigned UnitIndex, uint8_t &UnitType,
 138                         bool &isUnitDWARF64);
 139
 140   /// Verifies the header of a unit in the .debug_info section.
 141   ///
 142   /// This function currently verifies:
 143   ///  - The debug info attributes.
 144   ///  - The debug info form=s.
 145   ///  - The presence of a root DIE.
 146   ///  - That the root DIE is a unit DIE.
 147   ///  - If a unit type is provided, that the unit DIE matches the unit type.
 148   ///  - The DIE ranges.
 149   ///
 150   /// \param Unit      The DWARF Unit to verifiy.
 151   /// \param UnitType  An optional unit type which will be used to verify the
 152   ///                  type of the unit DIE.
 153   ///
 154   /// \returns true if the content is verified successfully, false otherwise.
 155   bool verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType = 0);
 156
 157   /// Verify that all Die ranges are valid.
 158   ///
 159   /// This function currently checks for:
 160   /// - cases in which lowPC >= highPC
 161   ///
 162   /// \returns Number of errors that occurred during verification.
 163   unsigned verifyDieRanges(const DWARFDie &Die, DieRangeInfo &ParentRI);
 164
 165   /// Verifies the attribute's DWARF attribute and its value.
 166   ///
 167   /// This function currently checks for:
 168   /// - DW_AT_ranges values is a valid .debug_ranges offset
 169   /// - DW_AT_stmt_list is a valid .debug_line offset
 170   ///
 171   /// \param Die          The DWARF DIE that owns the attribute value
 172   /// \param AttrValue    The DWARF attribute value to check
 173   ///
 174   /// \returns NumErrors The number of errors occurred during verification of
 175   /// attributes' values in a .debug_info section unit
 176   unsigned verifyDebugInfoAttribute(const DWARFDie &Die,
 177                                     DWARFAttribute &AttrValue);
 178
 179   /// Verifies the attribute's DWARF form.
 180   ///
 181   /// This function currently checks for:
 182   /// - All DW_FORM_ref values that are CU relative have valid CU offsets
 183   /// - All DW_FORM_ref_addr values have valid .debug_info offsets
 184   /// - All DW_FORM_strp values have valid .debug_str offsets
 185   ///
 186   /// \param Die          The DWARF DIE that owns the attribute value
 187   /// \param AttrValue    The DWARF attribute value to check
 188   ///
 189   /// \returns NumErrors The number of errors occurred during verification of
 190   /// attributes' forms in a .debug_info section unit
 191   unsigned verifyDebugInfoForm(const DWARFDie &Die, DWARFAttribute &AttrValue);
 192
 193   /// Verifies the all valid references that were found when iterating through
 194   /// all of the DIE attributes.
 195   ///
 196   /// This function will verify that all references point to DIEs whose DIE
 197   /// offset matches. This helps to ensure if a DWARF link phase moved things
 198   /// around, that it doesn't create invalid references by failing to relocate
 199   /// CU relative and absolute references.
 200   ///
 201   /// \returns NumErrors The number of errors occurred during verification of
 202   /// references for the .debug_info section
 203   unsigned verifyDebugInfoReferences();
 204
 205   /// Verify the DW_AT_stmt_list encoding and value and ensure that no
 206   /// compile units that have the same DW_AT_stmt_list value.
 207   void verifyDebugLineStmtOffsets();
 208
 209   /// Verify that all of the rows in the line table are valid.
 210   ///
 211   /// This function currently checks for:
 212   /// - addresses within a sequence that decrease in value
 213   /// - invalid file indexes
 214   void verifyDebugLineRows();
 215
 216   /// Verify that an Apple-style accelerator table is valid.
 217   ///
 218   /// This function currently checks that:
 219   /// - The fixed part of the header fits in the section
 220   /// - The size of the section is as large as what the header describes
 221   /// - There is at least one atom
 222   /// - The form for each atom is valid
 223   /// - The tag for each DIE in the table is valid
 224   /// - The buckets have a valid index, or they are empty
 225   /// - Each hashdata offset is valid
 226   /// - Each DIE is valid
 227   ///
 228   /// \param AccelSection pointer to the section containing the acceleration table
 229   /// \param StrData pointer to the string section
 230   /// \param SectionName the name of the table we're verifying
 231   ///
 232   /// \returns The number of errors occurred during verification
 233   unsigned verifyAppleAccelTable(const DWARFSection *AccelSection,
 234                                  DataExtractor *StrData,
 235                                  const char *SectionName);
 236
 237   unsigned verifyDebugNamesCULists(const DWARFDebugNames &AccelTable);
 238   unsigned verifyNameIndexBuckets(const DWARFDebugNames::NameIndex &NI,
 239                                   const DataExtractor &StrData);
 240   unsigned verifyNameIndexAbbrevs(const DWARFDebugNames::NameIndex &NI);
 241   unsigned verifyNameIndexAttribute(const DWARFDebugNames::NameIndex &NI,
 242                                     const DWARFDebugNames::Abbrev &Abbr,
 243                                     DWARFDebugNames::AttributeEncoding AttrEnc);
 244   unsigned verifyNameIndexEntries(const DWARFDebugNames::NameIndex &NI,
 245                                   const DWARFDebugNames::NameTableEntry &NTE);
 246   unsigned verifyNameIndexCompleteness(const DWARFDie &Die,
 247                                        const DWARFDebugNames::NameIndex &NI);
 248
 249   /// Verify that the DWARF v5 accelerator table is valid.
 250   ///
 251   /// This function currently checks that:
 252   /// - Headers individual Name Indices fit into the section and can be parsed.
 253   /// - Abbreviation tables can be parsed and contain valid index attributes
 254   ///   with correct form encodings.
 255   /// - The CU lists reference existing compile units.
 256   /// - The buckets have a valid index, or they are empty.
 257   /// - All names are reachable via the hash table (they have the correct hash,
 258   ///   and the hash is in the correct bucket).
 259   /// - Information in the index entries is complete (all required entries are
 260   ///   present) and consistent with the debug_info section DIEs.
 261   ///
 262   /// \param AccelSection section containing the acceleration table
 263   /// \param StrData string section
 264   ///
 265   /// \returns The number of errors occurred during verification
 266   unsigned verifyDebugNames(const DWARFSection &AccelSection,
 267                             const DataExtractor &StrData);
 268
 269 public:
 270   DWARFVerifier(raw_ostream &S, DWARFContext &D,
 271                 DIDumpOptions DumpOpts = DIDumpOptions::getForSingleDIE())
 272       : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)) {}
 273   /// Verify the information in any of the following sections, if available:
 274   /// .debug_abbrev, debug_abbrev.dwo
 275   ///
 276   /// Any errors are reported to the stream that was this object was
 277   /// constructed with.
 278   ///
 279   /// \returns true if .debug_abbrev and .debug_abbrev.dwo verify successfully,
 280   /// false otherwise.
 281   bool handleDebugAbbrev();
 282
 283   /// Verify the information in the .debug_info section.
 284   ///
 285   /// Any errors are reported to the stream that was this object was
 286   /// constructed with.
 287   ///
 288   /// \returns true if the .debug_info verifies successfully, false otherwise.
 289   bool handleDebugInfo();
 290
 291   /// Verify the information in the .debug_line section.
 292   ///
 293   /// Any errors are reported to the stream that was this object was
 294   /// constructed with.
 295   ///
 296   /// \returns true if the .debug_line verifies successfully, false otherwise.
 297   bool handleDebugLine();
 298
 299   /// Verify the information in accelerator tables, if they exist.
 300   ///
 301   /// Any errors are reported to the stream that was this object was
 302   /// constructed with.
 303   ///
 304   /// \returns true if the existing Apple-style accelerator tables verify
 305   /// successfully, false otherwise.
 306   bool handleAccelTables();
 307 };
 308
 309 static inline bool operator<(const DWARFVerifier::DieRangeInfo &LHS,
 310                              const DWARFVerifier::DieRangeInfo &RHS) {
 311   return std::tie(LHS.Ranges, LHS.Die) < std::tie(RHS.Ranges, RHS.Die);
 312 }
 313
 314 } // end namespace llvm
 315
 316 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H