[DebugInfo] Basic .debug_names dumping support

[labath]

Summary

This commit renames DWARFAcceleratorTable to AppleAcceleratorTable to free up
the first name as an interface for the different accelerator tables.
Then I add a DWARFDebugNames class for the dwarf5 table.

Presently, the only common functionality of the two classes is the dump()
method, because this is the only method that was necessary to implement
dwarfdump -debug-names; and because the rest of the
AppleAcceleratorTable interface does not directly transfer to the dwarf5
tables (the main reason for that is that the present interface assumes
the tables are homogeneous, but the dwarf5 tables can have different
keys associated with each entry).

I expect to make the common interface richer as I add more functionality
to the new class (and invent a way to represent it in generic way).

In terms of sharing the implementation, I found the format of the two
tables sufficiently different to frustrate any attempts to have common
parsing or dumping code, so presently the implementations share just low
level code for formatting dwarf constants.

[labath]

I would really appreciate it if someone could compare the code with the dwarf
specification, to make sure we are reading it the same way.

The other open question for me here is the difference in dwarf-dump -apple-names
and -debug-names format. I chose to use a ScopedPrinter for dumping because the
dwarf tables have more structure to them than the apple ones, and ScopedPrinter
made dumping that much easier. However, that makes the format quite different.
If you are OK with this format, and there is no requirement to preserve the
apple-names dump, I could switch the apple format to use a ScopedPrinter as a
follow-up.

The test case input was generated by my very-experimental very-wip .debug_names
generator (with some additional massaging of the assembly).

[aprantl]

May I ask you to split out the renaming and the adding of the new functionality into separate patches? Having smaller incremental steps will make it easier for us to adapt our yet-to-be upstreamed code.

In terms of sharing the implementation, I found the format of the two
tables sufficiently different to frustrate any attempts to have common
parsing or dumping code, so presently the implementations share just low
level code for formatting dwarf constants.

Seems fair. @JDevlieghere, do you agree with Pavel's assessment?

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

26

We probably still want some comment here?

[probinson]

+1 for doing the renaming separately (first). There's not a lot of it compared to the rest of the patch, but it is a bit of a distraction.

[JDevlieghere]

In D42297#981752, @labath wrote:

I would really appreciate it if someone could compare the code with the dwarf
specification, to make sure we are reading it the same way.

I didn’t find time for this today, but I will do so on Monday.

The other open question for me here is the difference in dwarf-dump -apple-names
and -debug-names format. I chose to use a ScopedPrinter for dumping because the
dwarf tables have more structure to them than the apple ones, and ScopedPrinter
made dumping that much easier. However, that makes the format quite different.
If you are OK with this format, and there is no requirement to preserve the
apple-names dump, I could switch the apple format to use a ScopedPrinter as a
follow-up.

I’m very much in favor for keeping both consistent. We might have some internal tests that would need to be updated which I’ll gladly take care of.

The test case input was generated by my very-experimental very-wip .debug_names
generator (with some additional massaging of the assembly).

In D42297#981949, @aprantl wrote:

May I ask you to split out the renaming and the adding of the new functionality into separate patches? Having smaller incremental steps will make it easier for us to adapt our yet-to-be upstreamed code.

Another +1 from my part. I think you can directly commit the rename.

Seems fair. @JDevlieghere, do you agree with Pavel's assessment?

I totally agree. I was afraid this was going to be the outcome when I read the standard last time but I wanted to remain optimistic. We can always reevaluate this in the future.

So I had a quick look and generally this looks good. I’ll do a more in depth review on Monday as promised.

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

160

It would be useful to name things consistently with the standard where possible, particularly the fields in the header. I doubt anyone will object to changing the respective names in the Apple counterparts to keep things in sync. Here for example I'd go with BucketCount.

168

Move the ::dump() method into the struct and then just dump them all in a ranged for loop. This way if you ever and up with an instance of this struct you can dump it, for example in the verifier.

170

Let's call this NameIndex like in the standard?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

363

The next remark applies to the whole diff. While we currently only read in the data for dumping, we should split off the parsing. As DebugInfo is a library we want it to be reusable, for instance for things like the verifier (dwarfdump -verify) and looking up entries in the accelerator tables by name (dwarfdump -name).

For this particular instance, I'd parse everything into an Entry struct with a ::dump() method and have the Unit cache the result. This doesn't mean parsing everything in advance though, we should always try to be as lazy as possible and don't read data until we need it. At some point in the future we want to merge LLVM's and LLDB's implementation, so that's something to keep in mind.

503

Move this into a dump() method in the Header struct. Could even be it's own scope imho.

518

Building on my previous comment this would then become something like for (auto& Entry : GetEntries()) { Entry.dump(W); }

[labath]

Rebase after commiting the rename separately

This also makes the dwarfdump output more concise by moving the "unique id" into
the block header instead of a separate entry. (E.g., Bucket {\n Index: 0\n...
becomes Bucket 0 {\n...). This also brings the output format a bit closer to
the present apple tables dump.

This does not yet incorporate the latest round of feedback from Jonas. I'll
respond to that separately.

[labath]

Incorporate feedback from Jonas.

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

363

I've split off parsing from dumping as much as possible (most of the "parsing" functions are extremely simple). I started implementing Entry caching, but then I've decided against it because the memory/speed tradeoff doesn't seem right. Parsing an Entry should be a very fast process particularly if the values are fixed size, and I'm not sure if the extra memory needed to cache the entries would outweigh that. Also, neither the current llvm AppleAcceleratorTable nor the LLDB's MappedHash classes do any caching at present. I'm not outright opposed to the idea of caching, but I think this should be driven by the needs of a specific consumer.

518

Kinda done, but I don't have a range-based for iteration. I don't think it's a good match for the dwarfdump use case, as it makes hard to convey parsing error messages to the caller, but I will consider adding it in the future for callers that don't need to distinguish between properly terminated list, and one that got cut short by a parsing error.

[JDevlieghere]

Thanks Pavel, this seems to be going in the right direction!

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

231

I'm guessing this returns the index into the hashes array, but it's hard to tell without any information other than the return type being a uint32.

234

What does this return exactly? Is it the hash at the given index? Is it the index for that entry in the name table?

239

Same here. If you're not relying on it being a pair maybe we can wrap it in a struct too with a sensible name like NameTableOffset with StringOffset and EntryOffset members? I think we might be able to reuse this for what a hash points at (based on Figure 6.1 in the standard)

262

NameIndices?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

363

Agree, it's probably not worth it here. I mentioned it because it's part of the general approach we take in the DebugInfo lib, but like you said it should be driven by the need of a consumer. Thanks for looking into it!

395

I was a little confused why you were copying the forms here, especially with the two lists called Indices. I see it's to create DWARFFormValues which are then set in the parser. Makes sense but maybe add a little comment here or in the struct.

513

Can we split this too, like getCUOffsets() and getTUOffsets(), getForeignTUOffsets(), etc?

[aprantl]

Thanks! I have a couple of stylistic suggestions inline.

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

26

Could you add a Doxygen comment explaining the purpose of this class please?

172

Would a struct with named members make the code more readable than a std::pair?

179

Could you please add some one-liner Doxygen comments explaining what these inner structs and classes are for?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

25

Would it make more sense for these functions to take a raw_ostream as first argument instead of creating a temporary std::string?

440

A pair of two uint32_t looks dangerous to my eyes. Perhaps define a struct with two named members to avoid accidental confusion?

[labath]

Apply suggestions from Jonas.

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

231

It's an index into all three arrays (hashes, string offsets, entry offsets). I have put more information in the comment, and I have made the function names more descriptive (getBucketArrayEntry). I'm not sure if that makes things better...

239

I've called the new struct NameTableEntry (so this function becomes: getNameTableEntry(Index))

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

363

The biggest difference I see between this and random other debug info section is that this one is specifically designed to enable easy random access, whereas for e.g. .debug_frame you have to evaluate a state machine to get a reasonable representation of the data.

395

I've added some comments, and I've renamed the two arrays (one is now Attributes and the other Values).

[JDevlieghere]

Looking at how we currently query the accelerator tables for names, I wonder if we'd be able to share the ValueIterator so that we can move the equal_range method into the base class. At first sight it looks feasible as most of the work is done in the equal_range function itself, which can potentially be different between the two tables. Pavel, what do you think?

[labath]

In D42297#985510, @JDevlieghere wrote:

Looking at how we currently query the accelerator tables for names, I wonder if we'd be able to share the ValueIterator so that we can move the equal_range method into the base class. At first sight it looks feasible as most of the work is done in the equal_range function itself, which can potentially be different between the two tables. Pavel, what do you think?

I was hoping to leave that for a separate patch. The main reason the ValueIterator class cannot be used out-of-the-box is because it assumes the accelerator table is homogeneous, but in the dwarf5 case, each abbreviation can describe a different set of index attributes. So we will need to come up with a more generic iterator for the dwarf tables (and that one can then be used for the apple tables as well). (And even the tiny bit of parsing that happens in the iterator (Next() function) is incorrect for dwarf5).

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

25

I did it to streamline the usage (just << everything into OS). But I guess the same thing can be achieved by having formatXXX return a struct and defining an operator<< for that struct.

[labath]

Respond to comments from Adrian (which were made concurrently with my last patch).

[JDevlieghere]

In D42297#986174, @labath wrote:

I was hoping to leave that for a separate patch.

Doing this in a separate patch sounds like the right thing to do.

The main reason the ValueIterator class cannot be used out-of-the-box is because it assumes the accelerator table is homogeneous, but in the dwarf5 case, each abbreviation can describe a different set of index attributes. So we will need to come up with a more generic iterator for the dwarf tables (and that one can then be used for the apple tables as well). (And even the tiny bit of parsing that happens in the iterator (Next() function) is incorrect for dwarf5).

Alright, I have some questions but maybe it's better so save this discussion for the other patch :-)

[JDevlieghere]

A few more comments, nothing major I think.

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

182

Nit: I saw a few patches were these style of comments were being replaced with comments before the variable. Not sure if this is a global change in coding style but personally I prefer that aesthetically, especially if the comments grows in the future. Feel free to ignore if you disagree!

258

Without a way to access the number of CUs in the header this function doesn't provide a very useful public interface. What do you think about returning a list (this way you can still index) and we don't need to expose the internals of the header and whatnot?

266

Reads an entry in the Bucket Array for the given Bucket?

271

Reads an entry in the Hash Array for the given Index?

278

Should this be an expected too?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

339

If this is only used for parsing AttributeEncodings, could we maybe make it a static member function that returns an Expected<AttributeEncoding>? That would allow us to move up the additional checks you do below in the while loop.

511

This has been bothering me since the first revision. I understand your motivation about doing a best effort in case something is off. I wonder if it's worth the trade off if we implement a check for this in the verifier.

[labath]

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

182

I like the short one more when it fits on a line, but I would definitely change it if the comment does not fit on a line anymore.

258

Right now this *isn't* a public interface (it's private within NameIndex and DwarfDebugNames doesn't even allow you to obtain the NameIndex objects it holds).

I am not sure how I could return a list here. The values themselves need to be accessed through DWARFDataExtractor::getRelocatedValue so none of the existing containers would work without materializing the elements somewhere. For a public interface (when we add one) I would consider writing a tiny pseudo-iterator that delegates to this method, but that's something I think we need for a private interface.

Of course always delegating to getRelocatedValue may turn out to be very slow actually (I have not looked at the complexity of that function), but I am trying to make this class copy-free because of the lldb use-case. In lldb we will be generally processing a fully linked shared object, the getRelocatedValue will be a no-op and we *should* be able to index these arrays directly without any intermediate copies (that's how lldb's MappedHash works for apple tables). Of course, this assumes I will manage to plug in this class into lldb.

278

The extract() function verifies that the section contains enough data for all of the fixed-size tables (which reminds me to add asserts to this function to verify they only access in-range values). It is up to the caller to verify that e.g. the returned String Offset points to a valid string in the string table.

So, no Expected is necessary, as this cannot fail.

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

339

I stared at this for about an hour, and I couldn't figure out a way to make it look nice (the issue being that the function would need to give three different kinds of result -- valid attribute encoding, parse error, sentinel. SentinelError would do the trick but it made the caller extremely ugly). I eventually settled for something else: extractAttributeEncoding*s*, which returns a parsed vector of encodings or an error.

511

I don't think there any tradeoff here. The result of the dumpEntry function is basically "are there more entries after this one", and we keep dumping until we reach the last entry or encounter a parse error.

(Unlike the apple tables, the dwarf table does not give us the count of entries up-front but instead relies on a terminator entry to denote end of list.)

[labath]

One more batch of small tweaks.

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

258

Sounds fair, thanks for the explanation!

278

Alright. Adding asserts is fine as long as they only detect misuse of the API. If they can trigger for invalid input we should have a different mechanism for notifying the caller.

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

339

One approach could be to create a static (constexpr) AttributeEncoding for the sentinel, then comparing against it to see if we've reached the end. I don't know if that helps with your original problem? I think it might still be useful here as it clearly conveys what you're doing, i.e. comparing against the sentinel.

511

The alternative which I was thinking of (but clearly forgot to write down in the comment, sorry!) was to read all the entries into a list and then have the dump method print them one by one. The trade-off being that you read all entries in advance, rather than one at a time. If you do this with an Expcected<vector> you lose the ability to display the valid entries up to the error, and if you do a vector<Expected> you increase the memory footprint while you know all elements will be fine expect for the last one.

[labath]

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

278

I'ts an internal API, and it's up to the caller to make sure it only accesses compilations units up to CompUnitCount.

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

339

I liked that idea, and I wanted to use it for the Abbrev sentinel as well, but creating an constexpr Abbrev is impossible. So, I modified this idea to use a factory function for the sentinels (and the AttributeEncoding factory is constexpr).

511

Ok, I see what you meant now.

I don't think it's worth doing anything about this now. Maybe later when we have a better iterating mechanism for external users (they would probably also want to know that the list was cut short due to a parse error), we can change this to use that.

[labath]

use sentinel values to report list ends

[JDevlieghere]

I'm happy with the current state of this patch. Unless anyone objects I think it is ready to go in, so LGTM. Thanks Pavel!

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

278

Fair enough

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

339

Right, I got a deja-vu feeling while writing that comment, because I wanted to suggest it too for the Abbrevs but indeed, the vector makes that impossible. I'm happy with the factory.

511

Sound reasonable

[labath]

llvm/trunk/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

311 ↗

(On Diff #131758)

I fixed an error here in a follow-up (r323648), which I noticed when some buildbots started failing:
Originally Header, contained only the fixed-size part, but during review it grew into something more. So, I split the fixed-size part into a separate struct to enable the sizeof() expression here to work.

Let me know if you want me to handle this differently.

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

 //===- DWARFAcceleratorTable.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFACCELERATORTABLE_H
 #define LLVM_DEBUGINFO_DWARFACCELERATORTABLE_H
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
 class raw_ostream;
+class ScopedPrinter;
 
-/// This implements the Apple accelerator table format, a precursor of the
-/// DWARF 5 accelerator table format.
-/// TODO: Factor out a common base class for both formats.
 class DWARFAcceleratorTable {
+protected:
+  DWARFDataExtractor AccelSection;
+  DataExtractor StringSection;
+
+public:
+  DWARFAcceleratorTable(const DWARFDataExtractor &AccelSection,
+                        DataExtractor StringSection)
+      : AccelSection(AccelSection), StringSection(StringSection) {}
+  virtual ~DWARFAcceleratorTable();
+
+  virtual llvm::Error extract() = 0;
+  virtual void dump(raw_ostream &OS) const = 0;
+
+  DWARFAcceleratorTable(const DWARFAcceleratorTable &) = delete;
+  void operator=(const DWARFAcceleratorTable &) = delete;
+};
+
+class AppleAcceleratorTable : public DWARFAcceleratorTable {
   struct Header {
     uint32_t Magic;
     uint16_t Version;
     uint16_t HashFunction;
     uint32_t NumBuckets;
     uint32_t NumHashes;
     uint32_t HeaderDataLength;
   };
 
   struct HeaderData {
     using AtomType = uint16_t;
     using Form = dwarf::Form;
 
     uint32_t DIEOffsetBase;
     SmallVector<std::pair<AtomType, Form>, 3> Atoms;
   };
 
   struct Header Hdr;
   struct HeaderData HdrData;
-  DWARFDataExtractor AccelSection;
-  DataExtractor StringSection;
   bool IsValid = false;
 
 public:
   /// An iterator for the entries associated with one key. Each entry can have
   /// multiple DWARFFormValues.
   class ValueIterator : public std::iterator<std::input_iterator_tag,
                                             ArrayRef<DWARFFormValue>> {
-    const DWARFAcceleratorTable *AccelTable = nullptr;
+    const AppleAcceleratorTable *AccelTable = nullptr;
     SmallVector<DWARFFormValue, 3> AtomForms; ///< The decoded data entry.
 
     unsigned DataOffset = 0; ///< Offset into the section.
     unsigned Data = 0; ///< Current data entry.
     unsigned NumData = 0; ///< Number of data entries.
 
     /// Advance the iterator.
     void Next();
   public:
     /// Construct a new iterator for the entries at \p DataOffset.
-    ValueIterator(const DWARFAcceleratorTable &AccelTable, unsigned DataOffset);
+    ValueIterator(const AppleAcceleratorTable &AccelTable, unsigned DataOffset);
     /// End marker.
     ValueIterator() = default;
 
     const ArrayRef<DWARFFormValue> operator*() const {
       return AtomForms;
     }
     ValueIterator &operator++() { Next(); return *this; }
     ValueIterator operator++(int) {
       ValueIterator I = *this;
       Next();
       return I;
     }
     friend bool operator==(const ValueIterator &A, const ValueIterator &B) {
       return A.NumData == B.NumData && A.DataOffset == B.DataOffset;
     }
     friend bool operator!=(const ValueIterator &A, const ValueIterator &B) {
       return !(A == B);
     }
   };
 
-
-  DWARFAcceleratorTable(const DWARFDataExtractor &AccelSection,
+  AppleAcceleratorTable(const DWARFDataExtractor &AccelSection,
                         DataExtractor StringSection)
-      : AccelSection(AccelSection), StringSection(StringSection) {}
+      : DWARFAcceleratorTable(AccelSection, StringSection) {}
 
-  llvm::Error extract();
+  llvm::Error extract() override;
   uint32_t getNumBuckets();
   uint32_t getNumHashes();
   uint32_t getSizeHdr();
   uint32_t getHeaderDataLength();
   ArrayRef<std::pair<HeaderData::AtomType, HeaderData::Form>> getAtomsDesc();
   bool validateForms();
 
   /// Return information related to the DWARF DIE we're looking for when
   /// performing a lookup by name.
   ///
   /// \param HashDataOffset an offset into the hash data table
   /// \returns <DieOffset, DieTag>
   /// DieOffset is the offset into the .debug_info section for the DIE
   /// related to the input hash data offset.
   /// DieTag is the tag of the DIE
   std::pair<uint32_t, dwarf::Tag> readAtoms(uint32_t &HashDataOffset);
-  void dump(raw_ostream &OS) const;
+  void dump(raw_ostream &OS) const override;
 
   /// Look up all entries in the accelerator table matching \c Key.
   iterator_range<ValueIterator> equal_range(StringRef Key) const;
 };
 
+/// .debug_names section consists of one or more units. Each unit starts with a
+/// header, which is followed by a list of compilation units, local and foreign
+/// type units.
+///
+/// These may be followed by an (optional) hash lookup table, which consists of
+/// an array of buckets and hashes similar to the apple tables above. The only
+/// difference is that the hashes array is 1-based, and consequently an empty
+/// bucket is denoted by 0 and not UINT32_MAX.
+///
+/// Next is the name table, which consists of an array of names and array of
+/// entry offsets. This is different from the apple tables, which store names
+/// next to the actual entries.
+///
+/// The structure of the entries is described by an abbreviations table, which
+/// comes after the name table. Unlike the apple tables, which have a uniform
+/// entry structure described in the header, each .debug_names entry may have
+/// different index attributes (DW_IDX_???) attached to it.
+///
+/// The last segment consists of a list of entries, which is a 0-terminated list
+/// referenced by the name table and interpreted with the help of the
+/// abbreviation table.
+class DWARFDebugNames : public DWARFAcceleratorTable {
+public:
+  struct Header {
+    uint32_t UnitLength;
+    uint16_t Version;
+    uint16_t Padding;
+    uint32_t NumCUs;
+    uint32_t NumLocalTUs;
+    uint32_t NumForeignTUs;
+    uint32_t NumBuckets;
+    uint32_t NumNames;
+    uint32_t AbbrevLength;
+    uint32_t AugmentationLen;
+    // Augmentation bytes follow
+  };
+  struct Abbrev {
+    dwarf::Tag Tag;
+    std::vector<std::pair<dwarf::Index, dwarf::Form>> Indices;
+  };
+
+  class Unit {
+    DenseMap<uint32_t, Abbrev> Abbrevs;
+    struct Header Hdr;
+    llvm::SmallString<8> HeaderAugmentation;
+    const DWARFDebugNames &Section;
+
+    // Base of the whole unit and of various important tables, as offsets from
+    // the start of the section.
+    uint32_t Base;
+    uint32_t CUsBase;
+    uint32_t BucketsBase;
+    uint32_t HashesBase;
+    uint32_t StringOffsetsBase;
+    uint32_t EntryOffsetsBase;
+    uint32_t EntriesBase;
+
+    void dumpCUs(ScopedPrinter &W) const;
+    void dumpLocalTUs(ScopedPrinter &W) const;
+    void dumpForeignTUs(ScopedPrinter &W) const;
+    void dumpAbbreviations(ScopedPrinter &W) const;
+    bool dumpEntry(ScopedPrinter &W, uint32_t *Offset) const;
+    void dumpName(ScopedPrinter &W, uint32_t Index,
+                  Optional<uint32_t> Hash) const;
+    void dumpBucket(ScopedPrinter &W, uint32_t Bucket) const;
+
+  public:
+    Unit(const DWARFDebugNames &Section, uint32_t Base)
+        : Section(Section), Base(Base) {}
+
+    llvm::Error extract();
+    uint32_t getNextUnitOffset() const { return Base + 4 + Hdr.UnitLength; }
+    void dump(ScopedPrinter &W) const;
+  };
+
+private:
+  std::vector<Unit> Units;
+
+public:
+  DWARFDebugNames(const DWARFDataExtractor &AccelSection,
+                  DataExtractor StringSection)
+      : DWARFAcceleratorTable(AccelSection, StringSection) {}
+
+  llvm::Error extract() override;
+  void dump(raw_ostream &OS) const override;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFACCELERATORTABLE_H

include/llvm/DebugInfo/DWARF/DWARFContext.h

class DWARFContext : public DIContext {
   std::unique_ptr<DWARFUnitIndex> TUIndex;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
   std::unique_ptr<DWARFDebugFrame> EHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
-  std::unique_ptr<DWARFAcceleratorTable> AppleNames;
-  std::unique_ptr<DWARFAcceleratorTable> AppleTypes;
-  std::unique_ptr<DWARFAcceleratorTable> AppleNamespaces;
-  std::unique_ptr<DWARFAcceleratorTable> AppleObjC;
+  std::unique_ptr<DWARFDebugNames> Names;
+  std::unique_ptr<AppleAcceleratorTable> AppleNames;
+  std::unique_ptr<AppleAcceleratorTable> AppleTypes;
+  std::unique_ptr<AppleAcceleratorTable> AppleNamespaces;
+  std::unique_ptr<AppleAcceleratorTable> AppleObjC;
 
   DWARFUnitSection<DWARFCompileUnit> DWOCUs;
   std::deque<DWARFUnitSection<DWARFTypeUnit>> DWOTUs;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
   std::unique_ptr<DWARFDebugLocDWO> LocDWO;
 
   /// The maximum DWARF version of all units.
   unsigned MaxVersion = 0;
public:
 
   /// Get a pointer to the parsed eh frame information object.
   const DWARFDebugFrame *getEHFrame();
 
   /// Get a pointer to the parsed DebugMacro object.
   const DWARFDebugMacro *getDebugMacro();
 
   /// Get a reference to the parsed accelerator table object.
-  const DWARFAcceleratorTable &getAppleNames();
+  const AppleAcceleratorTable &getAppleNames();
 
   /// Get a reference to the parsed accelerator table object.
-  const DWARFAcceleratorTable &getAppleTypes();
+  const AppleAcceleratorTable &getAppleTypes();
 
   /// Get a reference to the parsed accelerator table object.
-  const DWARFAcceleratorTable &getAppleNamespaces();
+  const AppleAcceleratorTable &getAppleNamespaces();
 
   /// Get a reference to the parsed accelerator table object.
-  const DWARFAcceleratorTable &getAppleObjC();
+  const AppleAcceleratorTable &getAppleObjC();
+
+  /// Get a reference to the parsed accelerator table object.
+  const DWARFDebugNames &getDebugNames();
 
   /// Get a pointer to a parsed line table corresponding to a compile unit.
   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *cu);
 
   /// Wraps the returned DIEs for a given address.
   struct DIEsForAddress {
     DWARFCompileUnit *CompileUnit = nullptr;
     DWARFDie FunctionDIE;

include/llvm/DebugInfo/DWARF/DWARFObject.h

public:
   }
   virtual const DWARFSection &getRangeDWOSection() const { return Dummy; }
   virtual const DWARFSection &getAddrSection() const { return Dummy; }
   virtual const DWARFSection &getAppleNamesSection() const { return Dummy; }
   virtual const DWARFSection &getAppleTypesSection() const { return Dummy; }
   virtual const DWARFSection &getAppleNamespacesSection() const {
     return Dummy;
   }
+  virtual const DWARFSection &getDebugNamesSection() const { return Dummy; }
   virtual const DWARFSection &getAppleObjCSection() const { return Dummy; }
   virtual StringRef getCUIndexSection() const { return ""; }
   virtual StringRef getGdbIndexSection() const { return ""; }
   virtual StringRef getTUIndexSection() const { return ""; }
   virtual Optional<RelocAddrEntry> find(const DWARFSection &Sec,
                                         uint64_t Pos) const = 0;
 };
 
 } // namespace llvm
 #endif

include/llvm/DebugInfo/DWARF/DWARFVerifier.h

private:
   /// - 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 occured during verification
-  unsigned verifyAccelTable(const DWARFSection *AccelSection,
-                            DataExtractor *StrData, const char *SectionName);
+  unsigned verifyAppleAccelTable(const DWARFSection *AccelSection,
+                                 DataExtractor *StrData,
+                                 const char *SectionName);
 
 public:
   DWARFVerifier(raw_ostream &S, DWARFContext &D,
                 DIDumpOptions DumpOpts = DIDumpOptions::getForSingleDIE())
       : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)) {}
   /// Verify the information in any of the following sections, if available:
   /// .debug_abbrev, debug_abbrev.dwo
   ///

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

 //===- DWARFAcceleratorTable.cpp ------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstddef>
 #include <cstdint>
 #include <utility>
 
 using namespace llvm;
 
-llvm::Error DWARFAcceleratorTable::extract() {
+static std::string formatEnum(StringRef (*StringFn)(unsigned), StringRef Type, unsigned Value) {
+  std::string Str = StringFn(Value);
+  if (!Str.empty())
+    return Str;
+  raw_string_ostream SS(Str);
+  SS << "DW_" << Type << "_Unknown_0x" << format("%x", Value);
+  return SS.str();
+}
+
+static std::string formatTag(unsigned Tag) {
+  return formatEnum(dwarf::TagString, "TAG", Tag);
+}
+
+static std::string formatForm(unsigned Form) {
+  return formatEnum(dwarf::FormEncodingString, "FORM", Form);
+}
+
+static std::string formatIndex(unsigned Idx) {
+  return formatEnum(dwarf::IndexString, "IDX", Idx);
+}
+
+static std::string formatAtom(unsigned Atom) {
+  return formatEnum(dwarf::AtomTypeString, "IDX", Atom);
+}
+
+DWARFAcceleratorTable::~DWARFAcceleratorTable() = default;
+
+llvm::Error AppleAcceleratorTable::extract() {
   uint32_t Offset = 0;
 
   // Check that we can at least read the header.
   if (!AccelSection.isValidOffset(offsetof(Header, HeaderDataLength)+4))
     return make_error<StringError>("Section too small: cannot read header.",
                                    inconvertibleErrorCode());
 
   Hdr.Magic = AccelSection.getU32(&Offset);
for (unsigned i = 0; i < NumAtoms; ++i) {
     auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset));
     HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
   }
 
   IsValid = true;
   return Error::success();
 }
 
-uint32_t DWARFAcceleratorTable::getNumBuckets() { return Hdr.NumBuckets; }
-uint32_t DWARFAcceleratorTable::getNumHashes() { return Hdr.NumHashes; }
-uint32_t DWARFAcceleratorTable::getSizeHdr() { return sizeof(Hdr); }
-uint32_t DWARFAcceleratorTable::getHeaderDataLength() {
+uint32_t AppleAcceleratorTable::getNumBuckets() { return Hdr.NumBuckets; }
+uint32_t AppleAcceleratorTable::getNumHashes() { return Hdr.NumHashes; }
+uint32_t AppleAcceleratorTable::getSizeHdr() { return sizeof(Hdr); }
+uint32_t AppleAcceleratorTable::getHeaderDataLength() {
   return Hdr.HeaderDataLength;
 }
 
-ArrayRef<std::pair<DWARFAcceleratorTable::HeaderData::AtomType,
-                   DWARFAcceleratorTable::HeaderData::Form>>
-DWARFAcceleratorTable::getAtomsDesc() {
+ArrayRef<std::pair<AppleAcceleratorTable::HeaderData::AtomType,
+                   AppleAcceleratorTable::HeaderData::Form>>
+AppleAcceleratorTable::getAtomsDesc() {
   return HdrData.Atoms;
 }
 
-bool DWARFAcceleratorTable::validateForms() {
+bool AppleAcceleratorTable::validateForms() {
   for (auto Atom : getAtomsDesc()) {
     DWARFFormValue FormValue(Atom.second);
     switch (Atom.first) {
     case dwarf::DW_ATOM_die_offset:
     case dwarf::DW_ATOM_die_tag:
     case dwarf::DW_ATOM_type_flags:
       if ((!FormValue.isFormClass(DWARFFormValue::FC_Constant) &&
            !FormValue.isFormClass(DWARFFormValue::FC_Flag)) ||
           FormValue.getForm() == dwarf::DW_FORM_sdata)
         return false;
       break;
     default:
       break;
     }
   }
   return true;
 }
 
 std::pair<uint32_t, dwarf::Tag>
-DWARFAcceleratorTable::readAtoms(uint32_t &HashDataOffset) {
+AppleAcceleratorTable::readAtoms(uint32_t &HashDataOffset) {
   uint32_t DieOffset = dwarf::DW_INVALID_OFFSET;
   dwarf::Tag DieTag = dwarf::DW_TAG_null;
   DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
 
   for (auto Atom : getAtomsDesc()) {
     DWARFFormValue FormValue(Atom.second);
     FormValue.extractValue(AccelSection, &HashDataOffset, FormParams);
     switch (Atom.first) {
     case dwarf::DW_ATOM_die_offset:
       DieOffset = *FormValue.getAsUnsignedConstant();
       break;
     case dwarf::DW_ATOM_die_tag:
       DieTag = (dwarf::Tag)*FormValue.getAsUnsignedConstant();
       break;
     default:
       break;
     }
   }
   return {DieOffset, DieTag};
 }
 
-LLVM_DUMP_METHOD void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
+LLVM_DUMP_METHOD void AppleAcceleratorTable::dump(raw_ostream &OS) const {
   if (!IsValid)
     return;
 
   // Dump the header.
   OS << "Magic = " << format("0x%08x", Hdr.Magic) << '\n'
      << "Version = " << format("0x%04x", Hdr.Version) << '\n'
      << "Hash function = " << format("0x%08x", Hdr.HashFunction) << '\n'
      << "Bucket count = " << Hdr.NumBuckets << '\n'
      << "Hashes count = " << Hdr.NumHashes << '\n'
      << "HeaderData length = " << Hdr.HeaderDataLength << '\n'
      << "DIE offset base = " << HdrData.DIEOffsetBase << '\n'
      << "Number of atoms = " << HdrData.Atoms.size() << '\n';
 
   unsigned i = 0;
   SmallVector<DWARFFormValue, 3> AtomForms;
   for (const auto &Atom: HdrData.Atoms) {
-    OS << format("Atom[%d] Type: ", i++);
-    auto TypeString = dwarf::AtomTypeString(Atom.first);
-    if (!TypeString.empty())
-      OS << TypeString;
-    else
-      OS << format("DW_ATOM_Unknown_0x%x", Atom.first);
-    OS << " Form: ";
-    auto FormString = dwarf::FormEncodingString(Atom.second);
-    if (!FormString.empty())
-      OS << FormString;
-    else
-      OS << format("DW_FORM_Unknown_0x%x", Atom.second);
-    OS << '\n';
+    OS << format("Atom[%d] Type: ", i++) << formatAtom(Atom.first)
+       << " Form: " << formatForm(Atom.second) << '\n';
     AtomForms.push_back(DWARFFormValue(Atom.second));
   }
 
   // Now go through the actual tables and dump them.
   uint32_t Offset = sizeof(Hdr) + Hdr.HeaderDataLength;
   unsigned HashesBase = Offset + Hdr.NumBuckets * 4;
   unsigned OffsetsBase = HashesBase + Hdr.NumHashes * 4;
   DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
           }
           OS << '\n';
         }
       }
     }
   }
 }
 
-DWARFAcceleratorTable::ValueIterator::ValueIterator(
-    const DWARFAcceleratorTable &AccelTable, unsigned Offset)
+AppleAcceleratorTable::ValueIterator::ValueIterator(
+    const AppleAcceleratorTable &AccelTable, unsigned Offset)
     : AccelTable(&AccelTable), DataOffset(Offset) {
   if (!AccelTable.AccelSection.isValidOffsetForDataOfSize(DataOffset, 4))
     return;
 
   for (const auto &Atom : AccelTable.HdrData.Atoms)
     AtomForms.push_back(DWARFFormValue(Atom.second));
 
   // Read the first entry.
   NumData = AccelTable.AccelSection.getU32(&DataOffset);
   Next();
 }
 
-void DWARFAcceleratorTable::ValueIterator::Next() {
+void AppleAcceleratorTable::ValueIterator::Next() {
   assert(NumData > 0 && "attempted to increment iterator past the end");
   auto &AccelSection = AccelTable->AccelSection;
   if (Data >= NumData ||
       !AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) {
     NumData = 0;
     return;
   }
   DWARFFormParams FormParams = {AccelTable->Hdr.Version, 0,
                                 dwarf::DwarfFormat::DWARF32};
   for (auto &Atom : AtomForms)
     Atom.extractValue(AccelSection, &DataOffset, FormParams);
   ++Data;
 }
 
-iterator_range<DWARFAcceleratorTable::ValueIterator>
-DWARFAcceleratorTable::equal_range(StringRef Key) const {
+iterator_range<AppleAcceleratorTable::ValueIterator>
+AppleAcceleratorTable::equal_range(StringRef Key) const {
   if (!IsValid)
     return make_range(ValueIterator(), ValueIterator());
 
   // Find the bucket.
   unsigned HashValue = dwarf::djbHash(Key);
   unsigned Bucket = HashValue % Hdr.NumBuckets;
   unsigned BucketBase = sizeof(Hdr) + Hdr.HeaderDataLength;
   unsigned HashesBase = BucketBase + Hdr.NumBuckets * 4;
if (!StringOffset)
       break;
 
     // Finally, compare the key.
     if (Key == StringSection.getCStr(&StringOffset))
       return make_range({*this, DataOffset}, ValueIterator());
   }
   return make_range(ValueIterator(), ValueIterator());
 }
+
+static std::pair<uint32_t, uint32_t> getULEB128Pair(const DWARFDataExtractor &E,
+                                                    uint32_t *Offset) {
+  uint32_t One = E.getULEB128(Offset);
+  uint32_t Two = E.getULEB128(Offset);
+  return {One, Two};
+}
+
+llvm::Error DWARFDebugNames::Unit::extract() {
+  uint32_t Offset = Base;
+  const DWARFDataExtractor &AS = Section.AccelSection;
+
+  // Check that we can at least read the header.
+  if (!AS.isValidOffset(Offset + sizeof(Header) - 1))
+    return make_error<StringError>("Section too small: cannot read header.",
+                                   inconvertibleErrorCode());
+
+  Hdr.UnitLength = AS.getU32(&Offset);
+  Hdr.Version = AS.getU16(&Offset);
+  Hdr.Padding = AS.getU16(&Offset);
+  Hdr.NumCUs = AS.getU32(&Offset);
+  Hdr.NumLocalTUs = AS.getU32(&Offset);
+  Hdr.NumForeignTUs = AS.getU32(&Offset);
+  Hdr.NumBuckets = AS.getU32(&Offset);
+  Hdr.NumNames = AS.getU32(&Offset);
+  Hdr.AbbrevLength = AS.getU32(&Offset);
+  Hdr.AugmentationLen = AS.getU32(&Offset);
+
+  if (!AS.isValidOffsetForDataOfSize(Offset, Hdr.AugmentationLen))
+    return make_error<StringError>(
+        "Section too small: cannot read header augmentation.",
+        inconvertibleErrorCode());
+  HeaderAugmentation.resize(Hdr.AugmentationLen);
+  AS.getU8(&Offset, reinterpret_cast<uint8_t *>(HeaderAugmentation.data()),
+           Hdr.AugmentationLen);
+  Offset = alignTo(Offset, 4);
+
+  CUsBase = Offset;
+  Offset += Hdr.NumCUs * 4;
+  Offset += Hdr.NumLocalTUs * 4;
+  Offset += Hdr.NumForeignTUs * 8;
+  BucketsBase = Offset;
+  Offset += Hdr.NumBuckets * 4;
+  HashesBase = Offset;
+  if (Hdr.NumBuckets > 0)
+    Offset += Hdr.NumNames * 4;
+  StringOffsetsBase = Offset;
+  Offset += Hdr.NumNames * 4;
+  EntryOffsetsBase = Offset;
+  Offset += Hdr.NumNames * 4;
+
+  if (!AS.isValidOffsetForDataOfSize(Offset, Hdr.AbbrevLength))
+    return make_error<StringError>(
+        "Section too small: cannot read abbreviations.",
+        inconvertibleErrorCode());
+
+  EntriesBase = Offset + Hdr.AbbrevLength;
+
+  uint32_t Code;
+  while ((Code = AS.getULEB128(&Offset)) != 0) {
+    Abbrev &A = Abbrevs[Code];
+    A.Tag = dwarf::Tag(AS.getULEB128(&Offset));
+    std::pair<uint32_t, uint32_t> IndexForm;
+    while (IndexForm = getULEB128Pair(AS, &Offset),
+           IndexForm.first || IndexForm.second) {
+      A.Indices.emplace_back(dwarf::Index(IndexForm.first),
+                             dwarf::Form(IndexForm.second));
+    }
+  }
+
+  return Error::success();
+}
+
+// Returns true if we should continue scanning for entries, false if this is the
+// last (sentinel) entry). In case of a parsing error we also return false, as
+// it's not possible to recover this entry list (but the other lists may still
+// parse OK).
+bool DWARFDebugNames::Unit::dumpEntry(ScopedPrinter &W,
+                                      uint32_t *Offset) const {
+  DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  uint32_t EntryID = *Offset;
+  uint32_t AbbrevID = AS.getULEB128(Offset);
+  if (AbbrevID == 0)
+    return false;
+
+  DictScope EntryScope(W, "Entry");
+  W.printHex("Offset", EntryID);
+  W.printHex("Abbrev", AbbrevID);
+
+  const auto AbbrevIt = Abbrevs.find(AbbrevID);
+  if (AbbrevIt == Abbrevs.end()) {
+    W.startLine() << "Invalid abbreviation\n";
+    return false;
+  }
+  const Abbrev &Abbr = AbbrevIt->second;
+  W.startLine() << "Tag: " << formatTag(Abbr.Tag) << "\n";
+
+  for (const auto &Ind : Abbr.Indices) {
+    W.startLine() << formatIndex(Ind.first) << ": ";
+    DWARFFormValue Form(Ind.second);
+    if (!Form.extractValue(AS, Offset, FormParams)) {
+      W.getOStream() << "Error extracting the value\n";
+      return false;
+    }
+    Form.dump(W.getOStream());
+    W.getOStream() << '\n';
+  }
+  return true;
+}
+
+void DWARFDebugNames::Unit::dumpName(ScopedPrinter &W, uint32_t Index,
+                                     Optional<uint32_t> Hash) const {
+  uint32_t StringOffsetOffset = StringOffsetsBase + 4 * (Index - 1);
+  uint32_t EntryOffsetOffset = EntryOffsetsBase + 4 * (Index - 1);
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  const DataExtractor &SS = Section.StringSection;
+
+  DictScope NameScope(W, "Name");
+  W.printNumber("Index", Index);
+  if (Hash)
+    W.printHex("Hash", *Hash);
+
+  uint32_t StringOffset = AS.getRelocatedValue(4, &StringOffsetOffset);
+  W.startLine() << format("String: 0x%08X", StringOffset);
+  W.getOStream() << " \"" << SS.getCStr(&StringOffset) << "\"\n";
+
+  uint32_t EntryOffset = AS.getU32(&EntryOffsetOffset);
+  EntryOffset += EntriesBase;
+
+  do {
+    if (!AS.isValidOffset(EntryOffset)) {
+      W.startLine() << "Incorrectly terminated entry list\n";
+      break;
+    }
+  } while (dumpEntry(W, &EntryOffset));
+}
+
+void DWARFDebugNames::Unit::dumpCUs(ScopedPrinter &W) const {
+  uint32_t Offset = CUsBase;
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  ListScope CUScope(W, "Compilation Unit offsets");
+  for (uint32_t CU = 0; CU < Hdr.NumCUs; ++CU) {
+    uint32_t CUOffset = AS.getRelocatedValue(4, &Offset);
+    W.startLine() << format("CU[%u]: 0x%08X\n", CU, CUOffset);
+  }
+}
+
+void DWARFDebugNames::Unit::dumpLocalTUs(ScopedPrinter &W) const {
+  if (Hdr.NumLocalTUs == 0)
+    return;
+
+  uint32_t Offset = CUsBase + Hdr.NumCUs * 4;
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  ListScope TUScope(W, "Local Type Unit offsets");
+  for (uint32_t TU = 0; TU < Hdr.NumLocalTUs; ++TU) {
+    uint32_t TUOffset = AS.getRelocatedValue(4, &Offset);
+    W.startLine() << format("LocalTU[%u]: 0x%08X\n", TU, TUOffset);
+  }
+}
+
+void DWARFDebugNames::Unit::dumpForeignTUs(ScopedPrinter &W) const {
+  if (Hdr.NumForeignTUs == 0)
+    return;
+
+  uint32_t Offset = CUsBase + (Hdr.NumCUs + Hdr.NumLocalTUs) * 4;
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  ListScope TUScope(W, "Foreign Type Unit signatures");
+  for (uint32_t TU = 0; TU < Hdr.NumForeignTUs; ++TU) {
+    uint64_t TUOffset = AS.getU64(&Offset);
+    W.startLine() << format("ForeignTU[%u]: 0x%016" PRIx64 "\n", TU, TUOffset);
+  }
+}
+
+void DWARFDebugNames::Unit::dumpAbbreviations(ScopedPrinter &W) const {
+  ListScope AbbrevsScope(W, "Abbreviations");
+  for (const auto &KV : Abbrevs) {
+    DictScope AbbrevScope(W, "Abbreviation");
+    W.printHex("Code", KV.getFirst());
+    W.startLine() << "Tag: " << formatTag(KV.getSecond().Tag) << '\n';
+
+    for (const auto &IndexForm : KV.getSecond().Indices) {
+      W.startLine() << formatIndex(IndexForm.first) << ": "
+                    << formatForm(IndexForm.second) << '\n';
+    }
+  }
+}
+
+void DWARFDebugNames::Unit::dumpBucket(ScopedPrinter &W,
+                                       uint32_t Bucket) const {
+  uint32_t Offset = BucketsBase + 4 * Bucket;
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  DictScope BucketScope(W, "Bucket");
+  W.printNumber("Index", Bucket);
+  uint32_t Index = AS.getU32(&Offset);
+  if (Index == 0) {
+    W.printString("EMPTY");
+    return;
+  }
+  if (Index > Hdr.NumNames) {
+    W.printString("Name index is invalid\n");
+    return;
+  }
+
+  for (; Index <= Hdr.NumNames; ++Index) {
+    uint32_t HashOffset = HashesBase + 4 * (Index - 1);
+
+    uint32_t Hash = AS.getU32(&HashOffset);
+    if (Hash % Hdr.NumBuckets != Bucket)
+      break;
+
+    dumpName(W, Index, Hash);
+  }
+}
+
+LLVM_DUMP_METHOD void DWARFDebugNames::Unit::dump(ScopedPrinter &W) const {
+  DictScope UnitScope(W, "Unit");
+  W.printHex("Offset", Base);
+  W.printHex("Length", Hdr.UnitLength);
+  W.printNumber("Version", Hdr.Version);
+  W.printHex("Padding", Hdr.Padding);
+  W.printNumber("CU count", Hdr.NumCUs);
+  W.printNumber("Local TU count", Hdr.NumLocalTUs);
+  W.printNumber("Foreign TU count", Hdr.NumForeignTUs);
+  W.printNumber("Bucket count", Hdr.NumBuckets);
+  W.printNumber("Name count", Hdr.NumNames);
+  W.printHex("Abbreviations length", Hdr.AbbrevLength);
+  W.startLine() << "Augmentation: '" << HeaderAugmentation << "'\n";
+
+  dumpCUs(W);
+  dumpLocalTUs(W);
+  dumpForeignTUs(W);
+  dumpAbbreviations(W);
+
+  if (Hdr.NumBuckets > 0) {
+    for (uint32_t Bucket = 0; Bucket < Hdr.NumBuckets; ++Bucket)
+      dumpBucket(W, Bucket);
+    return;
+  }
+
+  W.startLine() << "Hash table not present\n";
+  for (uint32_t Index = 1; Index <= Hdr.NumNames; ++Index)
+    dumpName(W, Index, None);
+}
+
+llvm::Error DWARFDebugNames::extract() {
+  uint32_t Offset = 0;
+  while (AccelSection.isValidOffset(Offset)) {
+    Unit Next(*this, Offset);
+    if (llvm::Error E = Next.extract())
+      return E;
+    Offset = Next.getNextUnitOffset();
+    Units.push_back(std::move(Next));
+  }
+  return Error::success();
+}
+
+LLVM_DUMP_METHOD void DWARFDebugNames::dump(raw_ostream &OS) const {
+  ScopedPrinter W(OS);
+  for (const Unit &U : Units)
+    U.dump(W);
+}

lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(
 
   if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces,
                  DObj->getAppleNamespacesSection().Data))
     getAppleNamespaces().dump(OS);
 
   if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC,
                  DObj->getAppleObjCSection().Data))
     getAppleObjC().dump(OS);
+  if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames,
+                 DObj->getDebugNamesSection().Data))
+    getDebugNames().dump(OS);
 }
 
 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
   DWOCUs.parseDWO(*this, DObj->getInfoDWOSection(), true);
 
   if (const auto &CUI = getCUIndex()) {
     if (const auto *R = CUI.getFromHash(Hash))
       return DWOCUs.getUnitForIndexEntry(*R);
if (Macro)
     return Macro.get();
 
   DataExtractor MacinfoData(DObj->getMacinfoSection(), isLittleEndian(), 0);
   Macro.reset(new DWARFDebugMacro());
   Macro->parse(MacinfoData);
   return Macro.get();
 }
 
-static DWARFAcceleratorTable &
-getAccelTable(std::unique_ptr<DWARFAcceleratorTable> &Cache,
-              const DWARFObject &Obj, const DWARFSection &Section,
-              StringRef StringSection, bool IsLittleEndian) {
+template <typename T>
+static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj,
+                        const DWARFSection &Section, StringRef StringSection,
+                        bool IsLittleEndian) {
   if (Cache)
     return *Cache;
   DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
   DataExtractor StrData(StringSection, IsLittleEndian, 0);
-  Cache.reset(new DWARFAcceleratorTable(AccelSection, StrData));
+  Cache.reset(new T(AccelSection, StrData));
   if (Error E = Cache->extract())
     llvm::consumeError(std::move(E));
   return *Cache;
 }
 
-const DWARFAcceleratorTable &DWARFContext::getAppleNames() {
+const AppleAcceleratorTable &DWARFContext::getAppleNames() {
   return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
                        DObj->getStringSection(), isLittleEndian());
 }
 
-const DWARFAcceleratorTable &DWARFContext::getAppleTypes() {
+const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
   return getAccelTable(AppleTypes, *DObj, DObj->getAppleTypesSection(),
                        DObj->getStringSection(), isLittleEndian());
 }
 
-const DWARFAcceleratorTable &DWARFContext::getAppleNamespaces() {
+const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() {
   return getAccelTable(AppleNamespaces, *DObj,
                        DObj->getAppleNamespacesSection(),
                        DObj->getStringSection(), isLittleEndian());
 }
 
-const DWARFAcceleratorTable &DWARFContext::getAppleObjC() {
+const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
   return getAccelTable(AppleObjC, *DObj, DObj->getAppleObjCSection(),
                        DObj->getStringSection(), isLittleEndian());
 }
 
+const DWARFDebugNames &DWARFContext::getDebugNames() {
+  return getAccelTable(Names, *DObj, DObj->getDebugNamesSection(),
+                       DObj->getStringSection(), isLittleEndian());
+}
+
 const DWARFLineTable *
 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   if (!Line)
     Line.reset(new DWARFDebugLine);
 
   auto UnitDIE = U->getUnitDIE();
   if (!UnitDIE)
     return nullptr;
class DWARFObjInMemory final : public DWARFObject {
   DWARFSectionMap LocDWOSection;
   DWARFSectionMap StringOffsetDWOSection;
   DWARFSectionMap RangeDWOSection;
   DWARFSectionMap AddrSection;
   DWARFSectionMap AppleNamesSection;
   DWARFSectionMap AppleTypesSection;
   DWARFSectionMap AppleNamespacesSection;
   DWARFSectionMap AppleObjCSection;
+  DWARFSectionMap DebugNamesSection;
 
   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
     return StringSwitch<DWARFSectionMap *>(Name)
         .Case("debug_info", &InfoSection)
         .Case("debug_loc", &LocSection)
         .Case("debug_line", &LineSection)
         .Case("debug_str_offsets", &StringOffsetSection)
         .Case("debug_ranges", &RangeSection)
         .Case("debug_info.dwo", &InfoDWOSection)
         .Case("debug_loc.dwo", &LocDWOSection)
         .Case("debug_line.dwo", &LineDWOSection)
+        .Case("debug_names", &DebugNamesSection)
         .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
         .Case("debug_addr", &AddrSection)
         .Case("apple_names", &AppleNamesSection)
         .Case("apple_types", &AppleTypesSection)
         .Case("apple_namespaces", &AppleNamespacesSection)
         .Case("apple_namespac", &AppleNamespacesSection)
         .Case("apple_objc", &AppleObjCSection)
         .Default(nullptr);
const DWARFSection &getAppleTypesSection() const override {
     return AppleTypesSection;
   }
   const DWARFSection &getAppleNamespacesSection() const override {
     return AppleNamespacesSection;
   }
   const DWARFSection &getAppleObjCSection() const override {
     return AppleObjCSection;
   }
+  const DWARFSection &getDebugNamesSection() const override {
+    return DebugNamesSection;
+  }
 
   StringRef getFileName() const override { return FileName; }
   uint8_t getAddressSize() const override { return AddressSize; }
   const DWARFSection &getInfoSection() const override { return InfoSection; }
   void forEachTypesSections(
       function_ref<void(const DWARFSection &)> F) const override {
     for (auto &P : TypesSections)
       F(P.second);

lib/DebugInfo/DWARF/DWARFVerifier.cpp

 bool DWARFVerifier::handleDebugLine() {
   NumDebugLineErrors = 0;
   OS << "Verifying .debug_line...\n";
   verifyDebugLineStmtOffsets();
   verifyDebugLineRows();
   return NumDebugLineErrors == 0;
 }
 
-unsigned DWARFVerifier::verifyAccelTable(const DWARFSection *AccelSection,
+unsigned DWARFVerifier::verifyAppleAccelTable(const DWARFSection *AccelSection,
                                               DataExtractor *StrData,
                                               const char *SectionName) {
   unsigned NumErrors = 0;
   DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), *AccelSection,
                                       DCtx.isLittleEndian(), 0);
-  DWARFAcceleratorTable AccelTable(AccelSectionData, *StrData);
+  AppleAcceleratorTable AccelTable(AccelSectionData, *StrData);
 
   OS << "Verifying " << SectionName << "...\n";
 
   // Verify that the fixed part of the header is not too short.
   if (!AccelSectionData.isValidOffset(AccelTable.getSizeHdr())) {
     error() << "Section is too small to fit a section header.\n";
     return 1;
   }

 }
 
 bool DWARFVerifier::handleAccelTables() {
   const DWARFObject &D = DCtx.getDWARFObj();
   DataExtractor StrData(D.getStringSection(), DCtx.isLittleEndian(), 0);
   unsigned NumErrors = 0;
   if (!D.getAppleNamesSection().Data.empty())
     NumErrors +=
-        verifyAccelTable(&D.getAppleNamesSection(), &StrData, ".apple_names");
+        verifyAppleAccelTable(&D.getAppleNamesSection(), &StrData, ".apple_names");
   if (!D.getAppleTypesSection().Data.empty())
     NumErrors +=
-        verifyAccelTable(&D.getAppleTypesSection(), &StrData, ".apple_types");
+        verifyAppleAccelTable(&D.getAppleTypesSection(), &StrData, ".apple_types");
   if (!D.getAppleNamespacesSection().Data.empty())
-    NumErrors += verifyAccelTable(&D.getAppleNamespacesSection(), &StrData,
+    NumErrors += verifyAppleAccelTable(&D.getAppleNamespacesSection(), &StrData,
                                   ".apple_namespaces");
   if (!D.getAppleObjCSection().Data.empty())
     NumErrors +=
-        verifyAccelTable(&D.getAppleObjCSection(), &StrData, ".apple_objc");
+        verifyAppleAccelTable(&D.getAppleObjCSection(), &StrData, ".apple_objc");
   return NumErrors == 0;
 }
 
 raw_ostream &DWARFVerifier::error() const {
   return WithColor(OS, syntax::Error).get() << "error: ";
 }
 
 raw_ostream &DWARFVerifier::warn() const {
   return WithColor(OS, syntax::Warning).get() << "warning: ";
 }
 
 raw_ostream &DWARFVerifier::note() const {
   return WithColor(OS, syntax::Note).get() << "note: ";
 }

test/DebugInfo/X86/dwarfdump-debug-names.s

+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj -o - | llvm-dwarfdump -debug-names - | FileCheck %s
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "foo"
+.Linfo_string1:
+  .asciz  "_Z3foov"
+.Linfo_string2:
+  .asciz  "bar"
+
+# Fake .debug_info. We just need it for the offsets to two "compile units" and
+# two "DIEs"
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .byte 0
+.Ldie0:
+  .byte 0
+.Lcu_begin1:
+  .byte 0
+.Ldie1:
+  .byte 0
+
+  .section  .debug_names,"",@progbits
+  .long .Lnames_end0-.Lnames_start0 # Header: contribution length
+.Lnames_start0:
+  .short  5                       # Header: version
+  .short  0                       # Header: padding
+  .long 1                       # Header: compilation unit count
+  .long 0                       # Header: local type unit count
+  .long 0                       # Header: foreign type unit count
+  .long 2                       # Header: bucket count
+  .long 2                       # Header: name count
+  .long .Lnames_abbrev_end0-.Lnames_abbrev_start0 # Header: abbreviation table size
+  .long 0                       # Header: augmentation length
+  .long .Lcu_begin0             # Compilation unit 0
+  .long 0                       # Bucket 0
+  .long 1                       # Bucket 1
+  .long 193491849               # Hash in Bucket 1
+  .long -1257882357             # Hash in Bucket 1
+  .long .Linfo_string0          # String in Bucket 1: foo
+  .long .Linfo_string1          # String in Bucket 1: _Z3foov
+  .long .Lnames0-.Lnames_entries0 # Offset in Bucket 1
+  .long .Lnames1-.Lnames_entries0 # Offset in Bucket 1
+.Lnames_abbrev_start0:
+  .byte 46                      # Abbrev code
+  .byte 46                      # DW_TAG_subprogram
+  .byte 3                       # DW_IDX_die_offset
+  .byte 6                       # DW_FORM_data4
+  .byte 0                       # End of abbrev
+  .byte 0                       # End of abbrev
+  .byte 0                       # End of abbrev list
+.Lnames_abbrev_end0:
+.Lnames_entries0:
+.Lnames0:
+  .byte 46                      # Abbrev code
+  .long .Ldie0                  # DW_IDX_die_offset
+  .long 0                       # End of list: foo
+.Lnames1:
+  .byte 46                      # Abbrev code
+  .long .Ldie0                  # DW_IDX_die_offset
+  .long 0                       # End of list: _Z3foov
+  .p2align  2
+.Lnames_end0:
+
+  .long .Lnames_end1-.Lnames_start1 # Header: contribution length
+.Lnames_start1:
+  .short  5                       # Header: version
+  .short  0                       # Header: padding
+  .long 1                       # Header: compilation unit count
+  .long 0                       # Header: local type unit count
+  .long 0                       # Header: foreign type unit count
+  .long 1                       # Header: bucket count
+  .long 1                       # Header: name count
+  .long .Lnames_abbrev_end1-.Lnames_abbrev_start1 # Header: abbreviation table size
+  .long 0                       # Header: augmentation length
+  .long .Lcu_begin1             # Compilation unit 0
+  .long 1                       # Bucket 0
+  .long 193487034               # Hash in Bucket 0
+  .long .Linfo_string2          # String in Bucket 0: bar
+  .long .Lnames2-.Lnames_entries1 # Offset in Bucket 0
+.Lnames_abbrev_start1:
+  .byte 52                      # Abbrev code
+  .byte 52                      # DW_TAG_variable
+  .byte 3                       # DW_IDX_die_offset
+  .byte 6                       # DW_FORM_data4
+  .byte 0                       # End of abbrev
+  .byte 0                       # End of abbrev
+  .byte 0                       # End of abbrev list
+.Lnames_abbrev_end1:
+.Lnames_entries1:
+.Lnames2:
+  .byte 52                      # Abbrev code
+  .long .Ldie1                  # DW_IDX_die_offset
+  .long 0                       # End of list: bar
+  .p2align  2
+.Lnames_end1:
+# CHECK: .debug_names contents:
+# CHECK-NEXT: Unit {
+# CHECK-NEXT:   Offset: 0x0
+# CHECK-NEXT:   Length: 0x60
+# CHECK-NEXT:   Version: 5
+# CHECK-NEXT:   Padding: 0x0
+# CHECK-NEXT:   CU count: 1
+# CHECK-NEXT:   Local TU count: 0
+# CHECK-NEXT:   Foreign TU count: 0
+# CHECK-NEXT:   Bucket count: 2
+# CHECK-NEXT:   Name count: 2
+# CHECK-NEXT:   Abbreviations length: 0x7
+# CHECK-NEXT:   Augmentation: ''
+# CHECK-NEXT:   Compilation Unit offsets [
+# CHECK-NEXT:     CU[0]: 0x00000000
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Abbreviations [
+# CHECK-NEXT:     Abbreviation {
+# CHECK-NEXT:       Code: 0x2E
+# CHECK-NEXT:       Tag: DW_TAG_subprogram
+# CHECK-NEXT:       DW_IDX_die_offset: DW_FORM_data4
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Bucket {
+# CHECK-NEXT:     Index: 0
+# CHECK-NEXT:     EMPTY
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Bucket {
+# CHECK-NEXT:     Index: 1
+# CHECK-NEXT:     Name {
+# CHECK-NEXT:       Index: 1
+# CHECK-NEXT:       Hash: 0xB887389
+# CHECK-NEXT:       String: 0x00000000 "foo"
+# CHECK-NEXT:       Entry {
+# CHECK-NEXT:         Offset: 0x4F
+# CHECK-NEXT:         Abbrev: 0x2E
+# CHECK-NEXT:         Tag: DW_TAG_subprogram
+# CHECK-NEXT:         DW_IDX_die_offset: 0x00000001
+# CHECK-NEXT:       }
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Name {
+# CHECK-NEXT:       Index: 2
+# CHECK-NEXT:       Hash: 0xB5063D0B
+# CHECK-NEXT:       String: 0x00000004 "_Z3foov"
+# CHECK-NEXT:       Entry {
+# CHECK-NEXT:         Offset: 0x58
+# CHECK-NEXT:         Abbrev: 0x2E
+# CHECK-NEXT:         Tag: DW_TAG_subprogram
+# CHECK-NEXT:         DW_IDX_die_offset: 0x00000001
+# CHECK-NEXT:       }
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT: }
+# CHECK-NEXT: Unit {
+# CHECK-NEXT:   Offset: 0x64
+# CHECK-NEXT:   Length: 0x44
+# CHECK-NEXT:   Version: 5
+# CHECK-NEXT:   Padding: 0x0
+# CHECK-NEXT:   CU count: 1
+# CHECK-NEXT:   Local TU count: 0
+# CHECK-NEXT:   Foreign TU count: 0
+# CHECK-NEXT:   Bucket count: 1
+# CHECK-NEXT:   Name count: 1
+# CHECK-NEXT:   Abbreviations length: 0x7
+# CHECK-NEXT:   Augmentation: ''
+# CHECK-NEXT:   Compilation Unit offsets [
+# CHECK-NEXT:     CU[0]: 0x00000002
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Abbreviations [
+# CHECK-NEXT:     Abbreviation {
+# CHECK-NEXT:       Code: 0x34
+# CHECK-NEXT:       Tag: DW_TAG_variable
+# CHECK-NEXT:       DW_IDX_die_offset: DW_FORM_data4
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Bucket {
+# CHECK-NEXT:     Index: 0
+# CHECK-NEXT:     Name {
+# CHECK-NEXT:       Index: 1
+# CHECK-NEXT:       Hash: 0xB8860BA
+# CHECK-NEXT:       String: 0x0000000C "bar"
+# CHECK-NEXT:       Entry {
+# CHECK-NEXT:         Offset: 0xA3
+# CHECK-NEXT:         Abbrev: 0x34
+# CHECK-NEXT:         Tag: DW_TAG_variable
+# CHECK-NEXT:         DW_IDX_die_offset: 0x00000003
+# CHECK-NEXT:       }
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT: }

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

if (!Name.empty()) {
     filterByName(Names, DICtx.dwo_compile_units(), OS);
     return true;
   }
 
   // Handle the --find option and lower it to --debug-info=<offset>.
   if (!Find.empty()) {
     DumpOffsets[DIDT_ID_DebugInfo] = [&]() -> llvm::Optional<uint64_t> {
       for (auto Name : Find) {
-        auto find = [&](const DWARFAcceleratorTable &Accel)
+        auto find = [&](const AppleAcceleratorTable &Accel)
             -> llvm::Optional<uint64_t> {
           for (auto Entry : Accel.equal_range(Name))
             for (auto Atom : Entry)
               if (auto Offset = Atom.getAsSectionOffset())
                 return Offset;
           return None;
         };
         if (auto Offset = find(DICtx.getAppleNames()))
           return DumpOffsets[DIDT_ID_DebugInfo] = *Offset;
         if (auto Offset = find(DICtx.getAppleTypes()))
           return DumpOffsets[DIDT_ID_DebugInfo] = *Offset;
         if (auto Offset = find(DICtx.getAppleNamespaces()))
           return DumpOffsets[DIDT_ID_DebugInfo] = *Offset;
+        // TODO: Add .debug_names support
       }
       return None;
     }();
     // Early exit if --find was specified but the current file doesn't have it.
     if (!DumpOffsets[DIDT_ID_DebugInfo])
       return true;
   }