[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 ↗

(On Diff #130602)

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 ↗

(On Diff #130602)

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 ↗

(On Diff #130602)

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 ↗

(On Diff #130602)

Let's call this NameIndex like in the standard?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

363 ↗

(On Diff #130602)

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 ↗

(On Diff #130602)

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

518 ↗

(On Diff #130602)

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 ↗

(On Diff #130602)

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 ↗

(On Diff #130602)

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

235 ↗

(On Diff #131031)

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.

238 ↗

(On Diff #131031)

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

243 ↗

(On Diff #131031)

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)

266 ↗

(On Diff #131031)

NameIndices?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

395 ↗

(On Diff #131031)

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 ↗

(On Diff #131031)

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

363 ↗

(On Diff #130602)

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!

[aprantl]

Thanks! I have a couple of stylistic suggestions inline.

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

27 ↗

(On Diff #131031)

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

176 ↗

(On Diff #131031)

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

183 ↗

(On Diff #131031)

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

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

25 ↗

(On Diff #131031)

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

440 ↗

(On Diff #131031)

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

235 ↗

(On Diff #131031)

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...

243 ↗

(On Diff #131031)

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

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

395 ↗

(On Diff #131031)

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

363 ↗

(On Diff #130602)

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.

[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 ↗

(On Diff #131031)

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

190 ↗

(On Diff #131214)

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!

266 ↗

(On Diff #131214)

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?

274 ↗

(On Diff #131214)

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

279 ↗

(On Diff #131214)

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

286 ↗

(On Diff #131214)

Should this be an expected too?

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

345 ↗

(On Diff #131214)

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.

517 ↗

(On Diff #131214)

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

190 ↗

(On Diff #131214)

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.

266 ↗

(On Diff #131214)

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.

286 ↗

(On Diff #131214)

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

345 ↗

(On Diff #131214)

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.

517 ↗

(On Diff #131214)

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

266 ↗

(On Diff #131214)

Sounds fair, thanks for the explanation!

286 ↗

(On Diff #131214)

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

345 ↗

(On Diff #131214)

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.

517 ↗

(On Diff #131214)

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

286 ↗

(On Diff #131214)

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

345 ↗

(On Diff #131214)

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).

517 ↗

(On Diff #131214)

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

286 ↗

(On Diff #131214)

Fair enough

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

345 ↗

(On Diff #131214)

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.

517 ↗

(On Diff #131214)

Sound reasonable

[labath]

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

311

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.

llvm/trunk/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/DenseSet.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;
+
+/// The accelerator tables are designed to allow efficient random access
+/// (using a symbol name as a key) into debug info by providing an index of the
+/// debug info DIEs. This class implements the common functionality of Apple and
+/// DWARF 5 accelerator tables.
+/// TODO: Generalize the rest of the AppleAcceleratorTable interface and move it
+/// to this class.
+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;
+};
 
 /// 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 AppleAcceleratorTable {
+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 AppleAcceleratorTable *AccelTable = nullptr;
public:
     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);
     }
   };
 
-
   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:
+  /// Dwarf 5 Name Index header.
+  struct Header {
+    uint32_t UnitLength;
+    uint16_t Version;
+    uint16_t Padding;
+    uint32_t CompUnitCount;
+    uint32_t LocalTypeUnitCount;
+    uint32_t ForeignTypeUnitCount;
+    uint32_t BucketCount;
+    uint32_t NameCount;
+    uint32_t AbbrevTableSize;
+    uint32_t AugmentationStringSize;
+    SmallString<8> AugmentationString;
+
+    Error extract(const DWARFDataExtractor &AS, uint32_t *Offset);
+    void dump(ScopedPrinter &W) const;
+  };
+
+  /// Index attribute and its encoding.
+  struct AttributeEncoding {
+    dwarf::Index Index;
+    dwarf::Form Form;
+
+    constexpr AttributeEncoding(dwarf::Index Index, dwarf::Form Form)
+        : Index(Index), Form(Form) {}
+
+    friend bool operator==(const AttributeEncoding &LHS,
+                           const AttributeEncoding &RHS) {
+      return LHS.Index == RHS.Index && LHS.Form == RHS.Form;
+    }
+  };
+
+  /// Abbreviation describing the encoding of Name Index entries.
+  struct Abbrev {
+    uint32_t Code;  ///< Abbreviation code
+    dwarf::Tag Tag; ///< Dwarf Tag of the described entity.
+    std::vector<AttributeEncoding> Attributes; ///< List of index attributes.
+
+    Abbrev(uint32_t Code, dwarf::Tag Tag,
+           std::vector<AttributeEncoding> Attributes)
+        : Code(Code), Tag(Tag), Attributes(std::move(Attributes)) {}
+
+    void dump(ScopedPrinter &W) const;
+  };
+
+  /// A single entry in the Name Index.
+  struct Entry {
+    const Abbrev &Abbr;
+
+    /// Values of the index attributes described by Abbr.
+    std::vector<DWARFFormValue> Values;
+
+    Entry(const Abbrev &Abbr);
+
+    void dump(ScopedPrinter &W) const;
+  };
+
+private:
+  /// Error returned by NameIndex::getEntry to report it has reached the end of
+  /// the entry list.
+  class SentinelError : public ErrorInfo<SentinelError> {
+  public:
+    static char ID;
+
+    void log(raw_ostream &OS) const override { OS << "Sentinel"; }
+    std::error_code convertToErrorCode() const override;
+  };
+
+  /// DenseMapInfo for struct Abbrev.
+  struct AbbrevMapInfo {
+    static Abbrev getEmptyKey();
+    static Abbrev getTombstoneKey();
+    static unsigned getHashValue(uint32_t Code) {
+      return DenseMapInfo<uint32_t>::getHashValue(Code);
+    }
+    static unsigned getHashValue(const Abbrev &Abbr) {
+      return getHashValue(Abbr.Code);
+    }
+    static bool isEqual(uint32_t LHS, const Abbrev &RHS) {
+      return LHS == RHS.Code;
+    }
+    static bool isEqual(const Abbrev &LHS, const Abbrev &RHS) {
+      return LHS.Code == RHS.Code;
+    }
+  };
+
+  /// A single entry in the Name Table (Dwarf 5 sect. 6.1.1.4.6) of the Name
+  /// Index.
+  struct NameTableEntry {
+    uint32_t StringOffset; ///< Offset of the name of the described entities.
+    uint32_t EntryOffset;  ///< Offset of the first Entry in the list.
+  };
+
+public:
+  /// Represents a single accelerator table within the Dwarf 5 .debug_names
+  /// section.
+  class NameIndex {
+    DenseSet<Abbrev, AbbrevMapInfo> Abbrevs;
+    struct Header Hdr;
+    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;
+
+    /// Reads offset of compilation unit CU. CU is 0-based.
+    uint32_t getCUOffset(uint32_t CU) const;
+
+    /// Reads offset of local type unit TU, TU is 0-based.
+    uint32_t getLocalTUOffset(uint32_t TU) const;
+
+    /// Reads signature of foreign type unit TU. TU is 0-based.
+    uint64_t getForeignTUOffset(uint32_t TU) const;
+
+    /// Reads an entry in the Bucket Array for the given Bucket. The returned
+    /// value is a (1-based) index into the Names, StringOffsets and
+    /// EntryOffsets arrays. The input Bucket index is 0-based.
+    uint32_t getBucketArrayEntry(uint32_t Bucket) const;
+
+    /// Reads an entry in the Hash Array for the given Index. The input Index
+    /// is 1-based.
+    uint32_t getHashArrayEntry(uint32_t Index) const;
+
+    /// Reads an entry in the Name Table for the given Index. The Name Table
+    /// consists of two arrays -- String Offsets and Entry Offsets. The returned
+    /// offsets are relative to the starts of respective sections. Input Index
+    /// is 1-based.
+    NameTableEntry getNameTableEntry(uint32_t Index) const;
+
+    Expected<Entry> getEntry(uint32_t *Offset) const;
+
+    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;
+
+    Expected<AttributeEncoding> extractAttributeEncoding(uint32_t *Offset);
+
+    Expected<std::vector<AttributeEncoding>>
+    extractAttributeEncodings(uint32_t *Offset);
+
+    Expected<Abbrev> extractAbbrev(uint32_t *Offset);
+
+  public:
+    NameIndex(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<NameIndex> NameIndices;
+
+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

llvm/trunk/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<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;
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 DWARFDebugNames &getDebugNames();
+
+  /// Get a reference to the parsed accelerator table object.
   const AppleAcceleratorTable &getAppleNames();
 
   /// Get a reference to the parsed accelerator table object.
   const AppleAcceleratorTable &getAppleTypes();
 
   /// Get a reference to the parsed accelerator table object.
   const AppleAcceleratorTable &getAppleNamespaces();
 

llvm/trunk/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

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

 #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/DJB.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;
 
+namespace {
+struct DwarfConstant {
+  StringRef (*StringFn)(unsigned);
+  StringRef Type;
+  unsigned Value;
+};
+
+static raw_ostream &operator<<(raw_ostream &OS, const DwarfConstant &C) {
+  StringRef Str = C.StringFn(C.Value);
+  if (!Str.empty())
+    return OS << Str;
+  return OS << "DW_" << C.Type << "_Unknown_0x" << format("%x", C.Value);
+}
+} // namespace
+
+static DwarfConstant formatTag(unsigned Tag) {
+  return {dwarf::TagString, "TAG", Tag};
+}
+
+static DwarfConstant formatForm(unsigned Form) {
+  return {dwarf::FormEncodingString, "FORM", Form};
+}
+
+static DwarfConstant formatIndex(unsigned Idx) {
+  return {dwarf::IndexString, "IDX", Idx};
+}
+
+static DwarfConstant formatAtom(unsigned Atom) {
+  return {dwarf::AtomTypeString, "ATOM", 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());
 
OS << "Magic = " << format("0x%08x", Hdr.Magic) << '\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};
if (!StringOffset)
       break;
 
     // Finally, compare the key.
     if (Key == StringSection.getCStr(&StringOffset))
       return make_range({*this, DataOffset}, ValueIterator());
   }
   return make_range(ValueIterator(), ValueIterator());
 }
+
+void DWARFDebugNames::Header::dump(ScopedPrinter &W) const {
+  DictScope HeaderScope(W, "Header");
+  W.printHex("Length", UnitLength);
+  W.printNumber("Version", Version);
+  W.printHex("Padding", Padding);
+  W.printNumber("CU count", CompUnitCount);
+  W.printNumber("Local TU count", LocalTypeUnitCount);
+  W.printNumber("Foreign TU count", ForeignTypeUnitCount);
+  W.printNumber("Bucket count", BucketCount);
+  W.printNumber("Name count", NameCount);
+  W.printHex("Abbreviations table size", AbbrevTableSize);
+  W.startLine() << "Augmentation: '" << AugmentationString << "'\n";
+}
+
+llvm::Error DWARFDebugNames::Header::extract(const DWARFDataExtractor &AS,
+                                             uint32_t *Offset) {
+  // Check that we can read the fixed-size part.
+  if (!AS.isValidOffset(*Offset + sizeof(Header) - 1))
+    return make_error<StringError>("Section too small: cannot read header.",
+                                   inconvertibleErrorCode());
+
+  UnitLength = AS.getU32(Offset);
+  Version = AS.getU16(Offset);
+  Padding = AS.getU16(Offset);
+  CompUnitCount = AS.getU32(Offset);
+  LocalTypeUnitCount = AS.getU32(Offset);
+  ForeignTypeUnitCount = AS.getU32(Offset);
+  BucketCount = AS.getU32(Offset);
+  NameCount = AS.getU32(Offset);
+  AbbrevTableSize = AS.getU32(Offset);
+  AugmentationStringSize = AS.getU32(Offset);
+
+  if (!AS.isValidOffsetForDataOfSize(*Offset, AugmentationStringSize))
+    return make_error<StringError>(
+        "Section too small: cannot read header augmentation.",
+        inconvertibleErrorCode());
+  AugmentationString.resize(AugmentationStringSize);
+  AS.getU8(Offset, reinterpret_cast<uint8_t *>(AugmentationString.data()),
+           AugmentationStringSize);
+  *Offset = alignTo(*Offset, 4);
+  return Error::success();
+}
+
+void DWARFDebugNames::Abbrev::dump(ScopedPrinter &W) const {
+  DictScope AbbrevScope(W, ("Abbreviation 0x" + Twine::utohexstr(Code)).str());
+  W.startLine() << "Tag: " << formatTag(Tag) << '\n';
+
+  for (const auto &Attr : Attributes) {
+    W.startLine() << formatIndex(Attr.Index) << ": " << formatForm(Attr.Form)
+                  << '\n';
+  }
+}
+
+static constexpr DWARFDebugNames::AttributeEncoding sentinelAttrEnc() {
+  return {dwarf::Index(0), dwarf::Form(0)};
+}
+
+static bool isSentinel(const DWARFDebugNames::AttributeEncoding &AE) {
+  return AE == sentinelAttrEnc();
+}
+
+static DWARFDebugNames::Abbrev sentinelAbbrev() {
+  return DWARFDebugNames::Abbrev(0, dwarf::Tag(0), {});
+}
+
+static bool isSentinel(const DWARFDebugNames::Abbrev &Abbr) {
+  return Abbr.Code == 0;
+}
+
+DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getEmptyKey() {
+  return sentinelAbbrev();
+}
+
+DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getTombstoneKey() {
+  return DWARFDebugNames::Abbrev(~0, dwarf::Tag(0), {});
+}
+
+Expected<DWARFDebugNames::AttributeEncoding>
+DWARFDebugNames::NameIndex::extractAttributeEncoding(uint32_t *Offset) {
+  if (*Offset >= EntriesBase) {
+    return make_error<StringError>("Incorrectly terminated abbreviation table.",
+                                   inconvertibleErrorCode());
+  }
+
+  uint32_t Index = Section.AccelSection.getULEB128(Offset);
+  uint32_t Form = Section.AccelSection.getULEB128(Offset);
+  return AttributeEncoding(dwarf::Index(Index), dwarf::Form(Form));
+}
+
+Expected<std::vector<DWARFDebugNames::AttributeEncoding>>
+DWARFDebugNames::NameIndex::extractAttributeEncodings(uint32_t *Offset) {
+  std::vector<AttributeEncoding> Result;
+  for (;;) {
+    auto AttrEncOr = extractAttributeEncoding(Offset);
+    if (!AttrEncOr)
+      return AttrEncOr.takeError();
+    if (isSentinel(*AttrEncOr))
+      return std::move(Result);
+
+    Result.emplace_back(*AttrEncOr);
+  }
+}
+
+Expected<DWARFDebugNames::Abbrev>
+DWARFDebugNames::NameIndex::extractAbbrev(uint32_t *Offset) {
+  if (*Offset >= EntriesBase) {
+    return make_error<StringError>("Incorrectly terminated abbreviation table.",
+                                   inconvertibleErrorCode());
+  }
+
+  uint32_t Code = Section.AccelSection.getULEB128(Offset);
+  if (Code == 0)
+    return sentinelAbbrev();
+
+  uint32_t Tag = Section.AccelSection.getULEB128(Offset);
+  auto AttrEncOr = extractAttributeEncodings(Offset);
+  if (!AttrEncOr)
+    return AttrEncOr.takeError();
+  return Abbrev(Code, dwarf::Tag(Tag), std::move(*AttrEncOr));
+}
+
+Error DWARFDebugNames::NameIndex::extract() {
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  uint32_t Offset = Base;
+  if (Error E = Hdr.extract(AS, &Offset))
+    return E;
+
+  CUsBase = Offset;
+  Offset += Hdr.CompUnitCount * 4;
+  Offset += Hdr.LocalTypeUnitCount * 4;
+  Offset += Hdr.ForeignTypeUnitCount * 8;
+  BucketsBase = Offset;
+  Offset += Hdr.BucketCount * 4;
+  HashesBase = Offset;
+  if (Hdr.BucketCount > 0)
+    Offset += Hdr.NameCount * 4;
+  StringOffsetsBase = Offset;
+  Offset += Hdr.NameCount * 4;
+  EntryOffsetsBase = Offset;
+  Offset += Hdr.NameCount * 4;
+
+  if (!AS.isValidOffsetForDataOfSize(Offset, Hdr.AbbrevTableSize))
+    return make_error<StringError>(
+        "Section too small: cannot read abbreviations.",
+        inconvertibleErrorCode());
+
+  EntriesBase = Offset + Hdr.AbbrevTableSize;
+
+  for (;;) {
+    auto AbbrevOr = extractAbbrev(&Offset);
+    if (!AbbrevOr)
+      return AbbrevOr.takeError();
+    if (isSentinel(*AbbrevOr))
+      return Error::success();
+
+    if (!Abbrevs.insert(std::move(*AbbrevOr)).second) {
+      return make_error<StringError>("Duplicate abbreviation code.",
+                                     inconvertibleErrorCode());
+    }
+  }
+}
+
+DWARFDebugNames::Entry::Entry(const Abbrev &Abbr) : Abbr(Abbr) {
+  // This merely creates form values. It is up to the caller
+  // (NameIndex::getEntry) to populate them.
+  Values.reserve(Abbr.Attributes.size());
+  for (const auto &Attr : Abbr.Attributes)
+    Values.emplace_back(Attr.Form);
+}
+
+void DWARFDebugNames::Entry::dump(ScopedPrinter &W) const {
+  W.printHex("Abbrev", Abbr.Code);
+  W.startLine() << "Tag: " << formatTag(Abbr.Tag) << "\n";
+
+  assert(Abbr.Attributes.size() == Values.size());
+  for (uint32_t I = 0, E = Values.size(); I < E; ++I) {
+    W.startLine() << formatIndex(Abbr.Attributes[I].Index) << ": ";
+    Values[I].dump(W.getOStream());
+    W.getOStream() << '\n';
+  }
+}
+
+char DWARFDebugNames::SentinelError::ID;
+std::error_code DWARFDebugNames::SentinelError::convertToErrorCode() const {
+  return inconvertibleErrorCode();
+}
+
+uint32_t DWARFDebugNames::NameIndex::getCUOffset(uint32_t CU) const {
+  assert(CU < Hdr.CompUnitCount);
+  uint32_t Offset = CUsBase + 4 * CU;
+  return Section.AccelSection.getRelocatedValue(4, &Offset);
+}
+
+uint32_t DWARFDebugNames::NameIndex::getLocalTUOffset(uint32_t TU) const {
+  assert(TU < Hdr.LocalTypeUnitCount);
+  uint32_t Offset = CUsBase + Hdr.CompUnitCount * 4;
+  return Section.AccelSection.getRelocatedValue(4, &Offset);
+}
+
+uint64_t DWARFDebugNames::NameIndex::getForeignTUOffset(uint32_t TU) const {
+  assert(TU < Hdr.ForeignTypeUnitCount);
+  uint32_t Offset = CUsBase + (Hdr.CompUnitCount + Hdr.LocalTypeUnitCount) * 4;
+  return Section.AccelSection.getU64(&Offset);
+}
+
+Expected<DWARFDebugNames::Entry>
+DWARFDebugNames::NameIndex::getEntry(uint32_t *Offset) const {
+  const DWARFDataExtractor &AS = Section.AccelSection;
+  if (!AS.isValidOffset(*Offset))
+    return make_error<StringError>("Incorrectly terminated entry list",
+                                   inconvertibleErrorCode());
+
+  uint32_t AbbrevCode = AS.getULEB128(Offset);
+  if (AbbrevCode == 0)
+    return make_error<SentinelError>();
+
+  const auto AbbrevIt = Abbrevs.find_as(AbbrevCode);
+  if (AbbrevIt == Abbrevs.end())
+    return make_error<StringError>("Invalid abbreviation",
+                                   inconvertibleErrorCode());
+
+  Entry E(*AbbrevIt);
+
+  DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
+  for (auto &Value : E.Values) {
+    if (!Value.extractValue(AS, Offset, FormParams))
+      return make_error<StringError>("Error extracting index attribute values",
+                                     inconvertibleErrorCode());
+  }
+  return std::move(E);
+}
+
+DWARFDebugNames::NameTableEntry
+DWARFDebugNames::NameIndex::getNameTableEntry(uint32_t Index) const {
+  assert(0 < Index && Index <= Hdr.NameCount);
+  uint32_t StringOffsetOffset = StringOffsetsBase + 4 * (Index - 1);
+  uint32_t EntryOffsetOffset = EntryOffsetsBase + 4 * (Index - 1);
+  const DWARFDataExtractor &AS = Section.AccelSection;
+
+  uint32_t StringOffset = AS.getRelocatedValue(4, &StringOffsetOffset);
+  uint32_t EntryOffset = AS.getU32(&EntryOffsetOffset);
+  EntryOffset += EntriesBase;
+  return {StringOffset, EntryOffset};
+}
+
+uint32_t
+DWARFDebugNames::NameIndex::getBucketArrayEntry(uint32_t Bucket) const {
+  assert(Bucket < Hdr.BucketCount);
+  uint32_t BucketOffset = BucketsBase + 4 * Bucket;
+  return Section.AccelSection.getU32(&BucketOffset);
+}
+
+uint32_t DWARFDebugNames::NameIndex::getHashArrayEntry(uint32_t Index) const {
+  assert(0 < Index && Index <= Hdr.NameCount);
+  uint32_t HashOffset = HashesBase + 4 * (Index - 1);
+  return Section.AccelSection.getU32(&HashOffset);
+}
+
+// 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::NameIndex::dumpEntry(ScopedPrinter &W,
+                                           uint32_t *Offset) const {
+  uint32_t EntryId = *Offset;
+  auto EntryOr = getEntry(Offset);
+  if (!EntryOr) {
+    handleAllErrors(EntryOr.takeError(), [](const SentinelError &) {},
+                    [&W](const ErrorInfoBase &EI) { EI.log(W.startLine()); });
+    return false;
+  }
+
+  DictScope EntryScope(W, ("Entry @ 0x" + Twine::utohexstr(EntryId)).str());
+  EntryOr->dump(W);
+  return true;
+}
+
+void DWARFDebugNames::NameIndex::dumpName(ScopedPrinter &W, uint32_t Index,
+                                          Optional<uint32_t> Hash) const {
+  const DataExtractor &SS = Section.StringSection;
+  NameTableEntry NTE = getNameTableEntry(Index);
+
+  DictScope NameScope(W, ("Name " + Twine(Index)).str());
+  if (Hash)
+    W.printHex("Hash", *Hash);
+
+  W.startLine() << format("String: 0x%08x", NTE.StringOffset);
+  W.getOStream() << " \"" << SS.getCStr(&NTE.StringOffset) << "\"\n";
+
+  while (dumpEntry(W, &NTE.EntryOffset))
+    /*empty*/;
+}
+
+void DWARFDebugNames::NameIndex::dumpCUs(ScopedPrinter &W) const {
+  ListScope CUScope(W, "Compilation Unit offsets");
+  for (uint32_t CU = 0; CU < Hdr.CompUnitCount; ++CU)
+    W.startLine() << format("CU[%u]: 0x%08x\n", CU, getCUOffset(CU));
+}
+
+void DWARFDebugNames::NameIndex::dumpLocalTUs(ScopedPrinter &W) const {
+  if (Hdr.LocalTypeUnitCount == 0)
+    return;
+
+  ListScope TUScope(W, "Local Type Unit offsets");
+  for (uint32_t TU = 0; TU < Hdr.LocalTypeUnitCount; ++TU)
+    W.startLine() << format("LocalTU[%u]: 0x%08x\n", TU, getLocalTUOffset(TU));
+}
+
+void DWARFDebugNames::NameIndex::dumpForeignTUs(ScopedPrinter &W) const {
+  if (Hdr.ForeignTypeUnitCount == 0)
+    return;
+
+  ListScope TUScope(W, "Foreign Type Unit signatures");
+  for (uint32_t TU = 0; TU < Hdr.ForeignTypeUnitCount; ++TU) {
+    W.startLine() << format("ForeignTU[%u]: 0x%016" PRIx64 "\n", TU,
+                            getForeignTUOffset(TU));
+  }
+}
+
+void DWARFDebugNames::NameIndex::dumpAbbreviations(ScopedPrinter &W) const {
+  ListScope AbbrevsScope(W, "Abbreviations");
+  for (const auto &Abbr : Abbrevs)
+    Abbr.dump(W);
+}
+
+void DWARFDebugNames::NameIndex::dumpBucket(ScopedPrinter &W,
+                                            uint32_t Bucket) const {
+  ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str());
+  uint32_t Index = getBucketArrayEntry(Bucket);
+  if (Index == 0) {
+    W.printString("EMPTY");
+    return;
+  }
+  if (Index > Hdr.NameCount) {
+    W.printString("Name index is invalid");
+    return;
+  }
+
+  for (; Index <= Hdr.NameCount; ++Index) {
+    uint32_t Hash = getHashArrayEntry(Index);
+    if (Hash % Hdr.BucketCount != Bucket)
+      break;
+
+    dumpName(W, Index, Hash);
+  }
+}
+
+LLVM_DUMP_METHOD void DWARFDebugNames::NameIndex::dump(ScopedPrinter &W) const {
+  DictScope UnitScope(W, ("Name Index @ 0x" + Twine::utohexstr(Base)).str());
+  Hdr.dump(W);
+  dumpCUs(W);
+  dumpLocalTUs(W);
+  dumpForeignTUs(W);
+  dumpAbbreviations(W);
+
+  if (Hdr.BucketCount > 0) {
+    for (uint32_t Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket)
+      dumpBucket(W, Bucket);
+    return;
+  }
+
+  W.startLine() << "Hash table not present\n";
+  for (uint32_t Index = 1; Index <= Hdr.NameCount; ++Index)
+    dumpName(W, Index, None);
+}
+
+llvm::Error DWARFDebugNames::extract() {
+  uint32_t Offset = 0;
+  while (AccelSection.isValidOffset(Offset)) {
+    NameIndex Next(*this, Offset);
+    if (llvm::Error E = Next.extract())
+      return E;
+    Offset = Next.getNextUnitOffset();
+    NameIndices.push_back(std::move(Next));
+  }
+  return Error::success();
+}
+
+LLVM_DUMP_METHOD void DWARFDebugNames::dump(raw_ostream &OS) const {
+  ScopedPrinter W(OS);
+  for (const NameIndex &NI : NameIndices)
+    NI.dump(W);
+}

llvm/trunk/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 AppleAcceleratorTable &
-getAccelTable(std::unique_ptr<AppleAcceleratorTable> &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 AppleAcceleratorTable(AccelSection, StrData));
+  Cache.reset(new T(AccelSection, StrData));
   if (Error E = Cache->extract())
     llvm::consumeError(std::move(E));
   return *Cache;
 }
 
+const DWARFDebugNames &DWARFContext::getDebugNames() {
+  return getAccelTable(Names, *DObj, DObj->getDebugNamesSection(),
+                       DObj->getStringSection(), isLittleEndian());
+}
+
 const AppleAcceleratorTable &DWARFContext::getAppleNames() {
   return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
                        DObj->getStringSection(), isLittleEndian());
 }
 
 const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
   return getAccelTable(AppleTypes, *DObj, DObj->getAppleTypesSection(),
                        DObj->getStringSection(), isLittleEndian());
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);

llvm/trunk/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: Name Index @ 0x0 {
+# CHECK-NEXT:   Header {
+# 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 table size: 0x7
+# CHECK-NEXT:     Augmentation: ''
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Compilation Unit offsets [
+# CHECK-NEXT:     CU[0]: 0x00000000
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Abbreviations [
+# CHECK-NEXT:     Abbreviation 0x2e {
+# CHECK-NEXT:       Tag: DW_TAG_subprogram
+# CHECK-NEXT:       DW_IDX_die_offset: DW_FORM_data4
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Bucket 0 [
+# CHECK-NEXT:     EMPTY
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Bucket 1 [
+# CHECK-NEXT:     Name 1 {
+# CHECK-NEXT:       Hash: 0xB887389
+# CHECK-NEXT:       String: 0x00000000 "foo"
+# CHECK-NEXT:       Entry @ 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 2 {
+# CHECK-NEXT:       Hash: 0xB5063D0B
+# CHECK-NEXT:       String: 0x00000004 "_Z3foov"
+# CHECK-NEXT:       Entry @ 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: Name Index @ 0x64 {
+# CHECK-NEXT:   Header {
+# 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 table size: 0x7
+# CHECK-NEXT:     Augmentation: ''
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Compilation Unit offsets [
+# CHECK-NEXT:     CU[0]: 0x00000002
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Abbreviations [
+# CHECK-NEXT:     Abbreviation 0x34 {
+# CHECK-NEXT:       Tag: DW_TAG_variable
+# CHECK-NEXT:       DW_IDX_die_offset: DW_FORM_data4
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Bucket 0 [
+# CHECK-NEXT:     Name 1 {
+# CHECK-NEXT:       Hash: 0xB8860BA
+# CHECK-NEXT:       String: 0x0000000c "bar"
+# CHECK-NEXT:       Entry @ 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: }

llvm/trunk/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

DumpOffsets[DIDT_ID_DebugInfo] = [&]() -> llvm::Optional<uint64_t> {
           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;
   }