[DWARFYAML] Add support for referencing different abbrev tables.

[Higuoxing]

Summary

This patch adds support for referencing different abbrev tables. We use
'ID' to distinguish abbrev tables and use 'AbbrevTableID' to explicitly
assign an abbrev table to compilation units.

The syntax is:

debug_abbrev:
  - ID: 0
    Table:
      ...
  - ID: 1
    Table:
      ...
debug_info:
  - ...
    AbbrevTableID: 1 ## Reference the second abbrev table.
  - ...
    AbbrevTableID: 0 ## Reference the first abbrev table.

[Higuoxing]

Newly added tests are marked by inline comments since too many tests are updated 😂.

llvm/test/ObjectYAML/MachO/DWARF-debug_info.yaml

679

Added test.

792

Added test.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

642

Added test.

[labath]

What would you say if, instead of AbbrevTableIndex, we had a field like AbbrevTableID. The main difference would be that this "ID" field can be explicitly specified on the Abbrev table, and it does not have to be a sequentially increasing number (though it could of course be that by default).

The thing I'm trying to achieve is to make the yaml more robust against modifications/simplifications. E.g., it would be nice if deleting an abbrev table does not make all compile units suddenly refer to different tables. If the ids were present explicitly, compile units would be unaffected by this, and one would get an explicit error message if there was a compile unit left which still referred to the deleted abbrev table.

(This is one of the aspects where an assembler is better than yaml, as symbolic labels in asm have these properties.)

[Higuoxing]

In D83116#2130019, @labath wrote:

What would you say if, instead of AbbrevTableIndex, we had a field like AbbrevTableID. The main difference would be that this "ID" field can be explicitly specified on the Abbrev table, and it does not have to be a sequentially increasing number (though it could of course be that by default).

I think it works. I'm fine with this approach, let's see what others thinking. Thanks a lot for sharing your ideas!

debug_abbrev:
  - ID: 1
    Table:
      - Code: 1
        Tag:  DW_TAG_something
        Children: DW_CHILDREN_yes
        Attributes:
          - Attribute: DW_AT_something
            Form:      DW_FORM_something
  - ID: 2
    Table:
      - Code: 1
        Tag:  DW_TAG_something
        Children: DW_CHILDREN_yes
        Attributes:
          - Attribute: DW_AT_something
            Form:      DW_FORM_something
  - ID: 3
    Table:
      - Code: 1
        Tag:  DW_TAG_something
        Children: DW_CHILDREN_yes
        Attributes:
          - Attribute: DW_AT_something
            Form:      DW_FORM_something

debug_info:
  - Length:        0x1234
    Version:       4
    AbbrevTableID: 3 ## references table 3
    ...
    Entries:
      - AbbrevCode: 1
        Values:
          - Value: 0x1234
  - Length:        0x1234
    Version:       4
    AbbrevTableID: 2 ## references table 2
    ...
    Entries:
      - AbbrevCode: 1
        Values:
          - Value: 0x1234
  - Length:        0x1234
    Version:       4
    AbbrevTableID: 1 ## references table 1
    ...
    Entries:
      - AbbrevCode: 1
        Values:
          - Value: 0x1234

[jhenderson]

In D83116#2130019, @labath wrote:

What would you say if, instead of AbbrevTableIndex, we had a field like AbbrevTableID. The main difference would be that this "ID" field can be explicitly specified on the Abbrev table, and it does not have to be a sequentially increasing number (though it could of course be that by default).

The thing I'm trying to achieve is to make the yaml more robust against modifications/simplifications. E.g., it would be nice if deleting an abbrev table does not make all compile units suddenly refer to different tables. If the ids were present explicitly, compile units would be unaffected by this, and one would get an explicit error message if there was a compile unit left which still referred to the deleted abbrev table.

(This is one of the aspects where an assembler is better than yaml, as symbolic labels in asm have these properties.)

+1 to this idea. By default it could of course be an incremental index, when emitting, but in yaml2obj, I see no reason for it to be tied in that way necessarily.

lldb/unittests/Symbol/Inputs/inlined-functions.yaml

348 ↗

(On Diff #275304)

AbbrevTableIndex should be an optional value. I think by default it should pick the first table (or possibly should pick the Nth table, where N is the .debug_info table index). Thus in this and pretty much every other case, you should be able to omit the new value.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

649

Perhaps worth including the index and table count values in this error message to make it easier for people to identify the problem.

llvm/tools/obj2yaml/dwarf2yaml.cpp

20

I'm slightly surprised you needed to add this. Did this not compile without it?

[Higuoxing]

llvm/tools/obj2yaml/dwarf2yaml.cpp

20

I guess it was automatically added by the code completion tool.

[Higuoxing]

In this revision, I added a helper struct called DWARFState. When emitting DWARF sections, we should initialize DWARFState first, it will help us make DWARF sections interlinked.

Now, we are able to use AbbrevTableID to reference abbrev tables and use ID to assign a number as abbrev table's ID.

[Higuoxing]

Suppress clang-format warnings.

[jhenderson]

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

34 ↗

(On Diff #286191)

Would it make any sense to merge the DWARFYAML::Data class and DWARFYAML::DWARFState class at all?

35 ↗

(On Diff #286191)

Can you use std::unordered_map here? Do we need deterministic ordering? Might also be worth naming it something like AbbrevTableID2Index to avoid confusing with the AbbrevCode values.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

92

Maybe to avoid weird errors, it might make sense to disallow mixing the two methods, i.e. if one table has an explicit ID, the others all must do too. What do you think? It may not be worth it if the code is more complex, I don't know.

105

Could you use the return value of insert to identify whether the key already exists in the map? That way, you don't need the explicit count call.

260–267

It might make more sense to do this work in the caller of this function, and to maintain this function's interface.

llvm/lib/ObjectYAML/MachOEmitter.cpp

271 ↗

(On Diff #286191)

llvm/test/ObjectYAML/MachO/DWARF-debug_info.yaml

679–681

Is there any particular reason you don't have something equivalent to this in the ELF testing, to show you can have tables out-of-order etc.

711

Something's not right here - the YAML below has four debug_info tables, but only three have check lines. What happened to the one that should be referencing abbrev table 2?

873–884

Can you omit the abbrev section entirely?

906–911

This feels like it belongs in a debug_abbrev dedicated test?

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

925–926

Same as Mach-O, this really is a debug_abbrev test, not a debug_info test.

[labath]

This seems fairly straight-forward to me, though I didn't dive into all the details.

Given the amount of changed tests, it may be nice to separate the format change from the linking patch (so in the interim state, one could generate multiple abbrev tables, but there would be no (reasonable) way to reference any table except the first one).

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

34 ↗

(On Diff #286191)

That would definitely be nice.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

89

If you'd do all this work in the factory function and then just pass in a finished map to the constructor, there'd be no need for the ErrorAsOutParameter thingy.

91

consider: for (auto &Abbr : enumerate(DI.DebugAbbrev))

93–95

ID = DI.DebugAbbrev[I].ID.getValueOr(I)

[Higuoxing]

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

34 ↗

(On Diff #286191)

@jhenderson :

Would it make any sense to merge the DWARFYAML::Data class and DWARFYAML::DWARFState class at all?

@labath :

That would definitely be nice.

I think they can be merged. But is there any particular reason to merge them? Personally, I would like to keep the DWARFYAML::DWARFState class. Here are a few concerns I would like to address:

• If we merge the DWARFYAML::DWARFState and DWARFYAML::Data at all, we will need to add some helper variables, e.g. AbbrevTableID2Index and a method like Error DWARFYAML::link() to DWARFYAML::Data class to link DWARF sections. We will have to call this special method before DWARF sections being emitted. If we port DWARF support to other binary format in the future, e.g., wasm, we might forget to call this method. If we make DWARF emitters accept DWARFYAML::DWARFState, it's easy to figure out that we need a DWARFState before emitting DWARF sections.

• Besides, I think DWARFYAML::Data and DWARFYAML::DWARFState have different functions. DWARFYAML::Data is used to contain original DWARF section descriptions and DWARFYAML::DWARFState contains helper structs and methods which helps link DWARF sections. It might be good not to merge them so that we can easily figure out when and where are those sections get linked?

I can be persuaded :-)

[jhenderson]

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

34 ↗

(On Diff #286191)

I think they can be merged. But is there any particular reason to merge them?

As things stand, it mostly seems like DWARFState merely gets in the way of accessing the Data class. It seems to me like it would be easier to use if the two were one class, as you wouldn't have to keep going through an extra function call/member access.

• If we merge the DWARFYAML::DWARFState and DWARFYAML::Data at all, we will need to add some helper variables, e.g. AbbrevTableID2Index and a method like Error DWARFYAML::link() to DWARFYAML::Data class to link DWARF sections. We will have to call this special method before DWARF sections being emitted. If we port DWARF support to other binary format in the future, e.g., wasm, we might forget to call this method. If we make DWARF emitters accept DWARFYAML::DWARFState, it's easy to figure out that we need a DWARFState before emitting DWARF sections.

If, rather than do all the calculations up front (e.g. mapping tables to IDs), you put the Data members behind getters, you could then add the "linking" code there. For example, with the AbbrevTable ID mapping, you could have the getAbbrevTableIndexByID method, which is the only way of getting an abbrev table from outside the class. The first time this is called (or optionally every time), it works out the mapping between ID(s) and table(s). This avoids the need for an explicit link or finalize method.

• Besides, I think DWARFYAML::Data and DWARFYAML::DWARFState have different functions. DWARFYAML::Data is used to contain original DWARF section descriptions and DWARFYAML::DWARFState contains helper structs and methods which helps link DWARF sections. It might be good not to merge them so that we can easily figure out when and where are those sections get linked?

I'm not sure I agree they have different functions. The AbbrevID2Index map is just a helper variable that is directly derived from the Data struct's members. We could get rid of it entirely, and just move the getAbbrevTableIndexByID method into Data, rewriting it to just run through the list of tables each time to find the right ID. This is obviously less efficient than instantiating a mapping up front, if done repeatedly, but I think it indicates that this extra layer is not actually doing anything distinct. Similar principles apply probably for other things, although without further concrete examples, it's hard to discuss them!

[Higuoxing]

Merge DWARFYAML::Data and DWARFYAML::DWARFState.

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

34 ↗

(On Diff #286191)

Thanks for the explanation!

llvm/lib/ObjectYAML/DWARFEmitter.cpp

89

DWARFYAML::DWARFState is merged into DWARFYAML::Data, so we don't need ErrorAsOutParameter any more.

92

I think it's a little bit difficult to distinguish these 2 situations. Besides, sometimes we might want to add one compilation unit to a test case and let it reference an existing abbrev table. We don't need to mutate the whole test case to add IDs. What do think of it?

[Higuoxing]

llvm/test/ObjectYAML/MachO/DWARF-debug_abbrev.yaml

426

I will remove this blank line later.

[jhenderson]

I'm not sure if my test comments have been looked at. Could you mark them as Done if you think you have addressed them, please?

llvm/include/llvm/ObjectYAML/DWARFYAML.h

234–237

Something to consider here: the user-visible behaviour of this class is that this is a const operation, but because this method causes AbbrevTableID2Index to be populated on the first call, it technically isn't. I would say this is a reasonable use case for mutable - the cache (in this case AbbrevTableID2Index) is marked as mutable, and then you can continue to pass this class around as const.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

92

Leave it as is. I wasn't convinced by my own statement, so I think what you've got is fine.

[Higuoxing]

Address comments.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

260–267

This is discussed in D86194

llvm/test/ObjectYAML/MachO/DWARF-debug_info.yaml

679–681

Added in test/tools/yaml2obj/ELF/DWARF/debug-info.yaml (o)

711

Sorry, the length and offsets are calculated by myself, and the __debug_info section's length is miscalculated to be 60, which should be 67. I've corrected it.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

649

I've included the abbrev table ID and compilation unit count values in test case (n). Can we prettify the error message in test case (i) in a follow-up patch?

[jhenderson]

LGTM. Thanks!

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

649

That's fine.

[Higuoxing]

Rebase.

[Higuoxing]

This change is causing build failure, I'm going to revise this change.

[Higuoxing]

Fix incorrect format string.

[Higuoxing]

Add missing test.

[Higuoxing]

Hi @jhenderson

This change is causing build failure on armv7 platform and I've fixed it.

See: http://lab.llvm.org:8011/builders/clang-cmake-armv7-global-isel/builds/10400 and http://lab.llvm.org:8011/builders/clang-cmake-armv7-quick/builds/20261

Could you please review this change again? Thanks a lot!

llvm/lib/ObjectYAML/DWARFYAML.cpp

69

The build failure is caused by the incorrect format string. AbbrevTable.index() returns size_t and it was formatted as %u. We should use %zu here.

[jhenderson]

Looks good!

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 #define LLVM_OBJECTYAML_DWARFYAML_H
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
+#include <unordered_map>
 #include <vector>
 
 namespace llvm {
 namespace DWARFYAML {
 
 struct AttributeAbbrev {
   llvm::dwarf::Attribute Attribute;
   llvm::dwarf::Form Form;
   llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values
 };
 
 struct Abbrev {
   Optional<yaml::Hex64> Code;
   llvm::dwarf::Tag Tag;
   llvm::dwarf::Constants Children;
   std::vector<AttributeAbbrev> Attributes;
 };
 
 struct AbbrevTable {
+  Optional<uint64_t> ID;
   std::vector<Abbrev> Table;
 };
 
 struct ARangeDescriptor {
   llvm::yaml::Hex64 Address;
   yaml::Hex64 Length;
 };
 

 };
 
 struct Unit {
   dwarf::DwarfFormat Format;
   Optional<yaml::Hex64> Length;
   uint16_t Version;
   Optional<uint8_t> AddrSize;
   llvm::dwarf::UnitType Type; // Added in DWARF 5
+  Optional<uint64_t> AbbrevTableID;
   yaml::Hex64 AbbrOffset;
   std::vector<Entry> Entries;
 };
 
 struct File {
   StringRef Name;
   uint64_t DirIdx;
   uint64_t ModTime;
struct Data {
 
   std::vector<LineTable> DebugLines;
   Optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists;
   Optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists;
 
   bool isEmpty() const;
 
   SetVector<StringRef> getNonEmptySectionNames() const;
+  Expected<uint64_t> getAbbrevTableIndexByID(uint64_t ID) const;
+
+private:
+  mutable std::unordered_map<uint64_t, uint64_t> AbbrevTableID2Index;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AbbrevTable)

llvm/lib/ObjectYAML/DWARFEmitter.cpp

 
 static void writeDWARFOffset(uint64_t Offset, dwarf::DwarfFormat Format,
                              raw_ostream &OS, bool IsLittleEndian) {
   cantFail(writeVariableSizedInteger(Offset, Format == dwarf::DWARF64 ? 8 : 4,
                                      OS, IsLittleEndian));
 }
 
 Error DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto Str : DI.DebugStrings) {
     OS.write(Str.data(), Str.size());
     OS.write('\0');
   }
 
   return Error::success();
 }
 
 Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
   uint64_t AbbrevCode = 0;
   for (const DWARFYAML::AbbrevTable &AbbrevTable : DI.DebugAbbrev) {
     for (const DWARFYAML::Abbrev &AbbrevDecl : AbbrevTable.Table) {
       AbbrevCode =
           AbbrevDecl.Code ? (uint64_t)*AbbrevDecl.Code : AbbrevCode + 1;
       encodeULEB128(AbbrevCode, OS);
       encodeULEB128(AbbrevDecl.Tag, OS);
       OS.write(AbbrevDecl.Children);
       for (auto Attr : AbbrevDecl.Attributes) {
         encodeULEB128(Attr.Attribute, OS);
         encodeULEB128(Attr.Form, OS);
         if (Attr.Form == dwarf::DW_FORM_implicit_const)
           encodeSLEB128(Attr.Value, OS);
       }
       encodeULEB128(0, OS);
       encodeULEB128(0, OS);

 }
 
 Error DWARFYAML::emitDebugGNUPubtypes(raw_ostream &OS, const Data &DI) {
   assert(DI.GNUPubTypes && "unexpected emitDebugGNUPubtypes() call");
   return emitPubSection(OS, *DI.GNUPubTypes, DI.IsLittleEndian,
                         /*IsGNUStyle=*/true);
 }
 
-static Expected<uint64_t> writeDIE(ArrayRef<DWARFYAML::AbbrevTable> AbbrevTable,
+static Expected<uint64_t> writeDIE(const DWARFYAML::Data &DI, uint64_t CUIndex,
+                                   uint64_t AbbrevTableID,
                                    const dwarf::FormParams &Params,
                                    const DWARFYAML::Entry &Entry,
                                    raw_ostream &OS, bool IsLittleEndian) {
   uint64_t EntryBegin = OS.tell();
   encodeULEB128(Entry.AbbrCode, OS);
   uint32_t AbbrCode = Entry.AbbrCode;
   if (AbbrCode == 0 || Entry.Values.empty())
     return OS.tell() - EntryBegin;
 
-  if (AbbrevTable.empty())
-    return createStringError(
-        errc::invalid_argument,
-        "non-empty compilation unit should have an associated abbrev table");
+  Expected<uint64_t> AbbrevTableIndexOrErr =
+      DI.getAbbrevTableIndexByID(AbbrevTableID);
+  if (!AbbrevTableIndexOrErr)
+    return createStringError(errc::invalid_argument,
+                             toString(AbbrevTableIndexOrErr.takeError()) +
+                                 " for compilation unit with index " +
+                                 utostr(CUIndex));
 
-  ArrayRef<DWARFYAML::Abbrev> AbbrevDecls(AbbrevTable[0].Table);
+  ArrayRef<DWARFYAML::Abbrev> AbbrevDecls(
+      DI.DebugAbbrev[*AbbrevTableIndexOrErr].Table);
 
   if (AbbrCode > AbbrevDecls.size())
     return createStringError(
         errc::invalid_argument,
         "abbrev code must be less than or equal to the number of "
         "entries in abbreviation table");
   const DWARFYAML::Abbrev &Abbrev = AbbrevDecls[AbbrCode - 1];
   auto FormVal = Entry.Values.begin();
do {
       }
     } while (Indirect);
   }
 
   return OS.tell() - EntryBegin;
 }
 
 Error DWARFYAML::emitDebugInfo(raw_ostream &OS, const DWARFYAML::Data &DI) {
-  for (const DWARFYAML::Unit &Unit : DI.CompileUnits) {
+  for (uint64_t I = 0; I < DI.CompileUnits.size(); ++I) {
+    const DWARFYAML::Unit &Unit = DI.CompileUnits[I];
     uint8_t AddrSize;
     if (Unit.AddrSize)
       AddrSize = *Unit.AddrSize;
     else
       AddrSize = DI.Is64BitAddrSize ? 8 : 4;
     dwarf::FormParams Params = {Unit.Version, AddrSize, Unit.Format};
     uint64_t Length = 3; // sizeof(version) + sizeof(address_size)
     Length += Unit.Version >= 5 ? 1 : 0;       // sizeof(unit_type)
     Length += Params.getDwarfOffsetByteSize(); // sizeof(debug_abbrev_offset)
 
     // Since the length of the current compilation unit is undetermined yet, we
     // firstly write the content of the compilation unit to a buffer to
     // calculate it and then serialize the buffer content to the actual output
     // stream.
     std::string EntryBuffer;
     raw_string_ostream EntryBufferOS(EntryBuffer);
 
+    uint64_t AbbrevTableID = Unit.AbbrevTableID.getValueOr(I);
     for (const DWARFYAML::Entry &Entry : Unit.Entries) {
-      if (Expected<uint64_t> EntryLength = writeDIE(
-              DI.DebugAbbrev, Params, Entry, EntryBufferOS, DI.IsLittleEndian))
+      if (Expected<uint64_t> EntryLength =
+              writeDIE(DI, I, AbbrevTableID, Params, Entry, EntryBufferOS,
+                       DI.IsLittleEndian))
         Length += *EntryLength;
       else
         return EntryLength.takeError();
     }
 
     // If the length is specified in the YAML description, we use it instead of
     // the actual length.
     if (Unit.Length)

llvm/lib/ObjectYAML/DWARFYAML.cpp

 //===- DWARFYAML.cpp - DWARF YAMLIO implementation ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines classes for handling the YAML representation of DWARF Debug
 // Info.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
 
 namespace llvm {
 
 bool DWARFYAML::Data::isEmpty() const {
   return getNonEmptySectionNames().empty();
 }
 
 SetVector<StringRef> DWARFYAML::Data::getNonEmptySectionNames() const {
if (DebugStrOffsets)
     SecNames.insert("debug_str_offsets");
   if (DebugRnglists)
     SecNames.insert("debug_rnglists");
   if (DebugLoclists)
     SecNames.insert("debug_loclists");
   return SecNames;
 }
 
+Expected<uint64_t> DWARFYAML::Data::getAbbrevTableIndexByID(uint64_t ID) const {
+  if (AbbrevTableID2Index.empty()) {
+    for (auto &AbbrevTable : enumerate(DebugAbbrev)) {
+      // If the abbrev table's ID isn't specified, we use the index as its ID.
+      uint64_t AbbrevTableID =
+          AbbrevTable.value().ID.getValueOr(AbbrevTable.index());
+      auto It =
+          AbbrevTableID2Index.insert({AbbrevTableID, AbbrevTable.index()});
+      if (!It.second)
+        return createStringError(
+            errc::invalid_argument,
+            "the ID (%" PRIu64 ") of abbrev table with index %zu has been used "
+            "by abbrev table with index %" PRIu64,
+            AbbrevTableID, AbbrevTable.index(), It.first->second);
+    }
+  }
+
+  auto It = AbbrevTableID2Index.find(ID);
+  if (It == AbbrevTableID2Index.end())
+    return createStringError(errc::invalid_argument,
+                             "cannot find abbrev table whose ID is %" PRIu64,
+                             ID);
+  return It->second;
+}
+
 namespace yaml {
 
 void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   void *OldContext = IO.getContext();
   DWARFYAML::DWARFContext DWARFCtx;
   IO.setContext(&DWARFCtx);
   IO.mapOptional("debug_str", DWARF.DebugStrings);
   IO.mapOptional("debug_abbrev", DWARF.DebugAbbrev);
void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   IO.mapOptional("debug_str_offsets", DWARF.DebugStrOffsets);
   IO.mapOptional("debug_rnglists", DWARF.DebugRnglists);
   IO.mapOptional("debug_loclists", DWARF.DebugLoclists);
   IO.setContext(OldContext);
 }
 
 void MappingTraits<DWARFYAML::AbbrevTable>::mapping(
     IO &IO, DWARFYAML::AbbrevTable &AbbrevTable) {
+  IO.mapOptional("ID", AbbrevTable.ID);
   IO.mapOptional("Table", AbbrevTable.Table);
 }
 
 void MappingTraits<DWARFYAML::Abbrev>::mapping(IO &IO,
                                                DWARFYAML::Abbrev &Abbrev) {
   IO.mapOptional("Code", Abbrev.Code);
   IO.mapRequired("Tag", Abbrev.Tag);
   IO.mapRequired("Children", Abbrev.Children);

 }
 
 void MappingTraits<DWARFYAML::Unit>::mapping(IO &IO, DWARFYAML::Unit &Unit) {
   IO.mapOptional("Format", Unit.Format, dwarf::DWARF32);
   IO.mapOptional("Length", Unit.Length);
   IO.mapRequired("Version", Unit.Version);
   if (Unit.Version >= 5)
     IO.mapRequired("UnitType", Unit.Type);
+  IO.mapOptional("AbbrevTableID", Unit.AbbrevTableID);
   IO.mapRequired("AbbrOffset", Unit.AbbrOffset);
   IO.mapOptional("AddrSize", Unit.AddrSize);
   IO.mapOptional("Entries", Unit.Entries);
 }
 
 void MappingTraits<DWARFYAML::Entry>::mapping(IO &IO, DWARFYAML::Entry &Entry) {
   IO.mapRequired("AbbrCode", Entry.AbbrCode);
   IO.mapOptional("Values", Entry.Values);

llvm/test/ObjectYAML/MachO/DWARF-debug_abbrev.yaml

-# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+## a) Test that yaml2obj is able to emit the __debug_abbrev section and obj2yaml is
+## able to convert it back.
+
+# RUN: yaml2obj --docnum=1 %s | obj2yaml | FileCheck %s
 
 --- !mach-o
 FileHeader:      
   magic:           0xFEEDFACF
   cputype:         0x01000007
   cpusubtype:      0x00000003
   filetype:        0x0000000A
   ncmds:           5

 #CHECK:         - Attribute:       DW_AT_byte_size
 #CHECK:           Form:            DW_FORM_data1
 #CHECK:     - Code:            0x0000000000000005
 #CHECK:       Tag:             DW_TAG_pointer_type
 #CHECK:       Children:        DW_CHILDREN_no
 #CHECK:       Attributes:      
 #CHECK:         - Attribute:       DW_AT_type
 #CHECK:           Form:            DW_FORM_ref4
+
+## b) Test that yaml2obj emits an error message when there are non-empty compilation
+## units and multiple abbrev tables are assigned the same ID.
+
+# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ID-COLLISION
+
+# ID-COLLISION: yaml2obj: error: the ID (1) of abbrev table with index 1 has been used by abbrev table with index 0
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  232
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   2
+    flags:    0
+    Sections:
+      - sectname:  __debug_abbrev
+        segname:   __DWARF
+        addr:      0x00
+        size:      24
+        offset:    528
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+      - sectname:  __debug_info
+        segname:   __DWARF
+        addr:      0x00
+        size:      64
+        offset:    1070
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+DWARF:
+  debug_abbrev:
+    - ID: 1
+    - ID: 1
+  debug_info:
+    - Version:    4
+      AbbrOffset: 0x00
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x1234

llvm/test/ObjectYAML/MachO/DWARF-debug_info.yaml

- Length:          65
           Data:            11
 ...
 ...
 
 #      DWARF32: DWARF:
 #      DWARF32:   debug_info:
 # DWARF32-NEXT:     - Length:        0x0000000000000075
 # DWARF32-NEXT:       Version:       4
+# DWARF32-NEXT:       AbbrevTableID: 0
 # DWARF32-NEXT:       AbbrOffset:    0
 # DWARF32-NEXT:       AddrSize:      8
 # DWARF32-NEXT:       Entries:
 # DWARF32-NEXT:         - AbbrCode: 0x00000001
 # DWARF32-NEXT:           Values:
 # DWARF32-NEXT:             - Value: 0x0000000000000001
 # DWARF32-NEXT:             - Value: 0x000000000000000C
 # DWARF32-NEXT:             - Value: 0x0000000000000038

 ## Test DWARF32 unit header.
 
 # RUN: yaml2obj --docnum=2 -DFORMAT=DWARF32 %s | \
 # RUN:   obj2yaml | FileCheck %s --check-prefix=DWARF32-YAML
 
 #      DWARF32-YAML: debug_info:
 # DWARF32-YAML-NEXT:   - Length:        0x000000000000000C
 # DWARF32-YAML-NEXT:     Version:       4
+# DWARF32-YAML-NEXT:     AbbrevTableID: 0
 # DWARF32-YAML-NEXT:     AbbrOffset:    0
 # DWARF32-YAML-NEXT:     AddrSize:      8
 # DWARF32-YAML-NEXT:     Entries:
 # DWARF32-YAML-NEXT:       - AbbrCode: 0x00000001
 # DWARF32-YAML-NEXT:         Values:
 # DWARF32-YAML-NEXT:           - Value: 0x0000000000001234
 
 --- !mach-o

 
 # RUN: yaml2obj --docnum=2 -DFORMAT=DWARF64 %s | \
 # RUN:   obj2yaml | FileCheck %s --check-prefix=DWARF64-YAML
 
 #      DWARF64-YAML: debug_info:
 # DWARF64-YAML-NEXT:   - Format:        DWARF64
 # DWARF64-YAML-NEXT:     Length:        0x000000000000000C
 # DWARF64-YAML-NEXT:     Version:       4
+# DWARF64-YAML-NEXT:     AbbrevTableID: 0
 # DWARF64-YAML-NEXT:     AbbrOffset:    0
 # DWARF64-YAML-NEXT:     AddrSize:      8
 # DWARF64-YAML-NEXT:     Entries:
 # DWARF64-YAML-NEXT:       - AbbrCode: 0x00000001
 # DWARF64-YAML-NEXT:         Values:
 # DWARF64-YAML-NEXT:           - Value: 0x0000000000001234
+
+## c) Test that yaml2obj is able to generate compilation units according to the
+## associated abbrev table that is referenced by the 'AbbrevTableID' and obj2yaml
+## is able to convert it back.
+
+# RUN: yaml2obj --docnum=3 %s | obj2yaml | FileCheck %s --check-prefix=MULTI-TABLES
+
+#      MULTI-TABLES: DWARF:
+# MULTI-TABLES-NEXT:   debug_abbrev:
+# MULTI-TABLES-NEXT:     - ID: 0
+# MULTI-TABLES-NEXT:       Table:
+# MULTI-TABLES-NEXT:         - Code:     0x0000000000000001
+# MULTI-TABLES-NEXT:           Tag:      DW_TAG_compile_unit
+# MULTI-TABLES-NEXT:           Children: DW_CHILDREN_no
+# MULTI-TABLES-NEXT:           Attributes:
+# MULTI-TABLES-NEXT:             - Attribute: DW_AT_low_pc
+# MULTI-TABLES-NEXT:               Form:      DW_FORM_addr
+# MULTI-TABLES-NEXT:     - ID: 1
+# MULTI-TABLES-NEXT:       Table:
+# MULTI-TABLES-NEXT:         - Code:     0x0000000000000001
+# MULTI-TABLES-NEXT:           Tag:      DW_TAG_compile_unit
+# MULTI-TABLES-NEXT:           Children: DW_CHILDREN_no
+# MULTI-TABLES-NEXT:           Attributes:
+# MULTI-TABLES-NEXT:             - Attribute: DW_AT_low_pc
+# MULTI-TABLES-NEXT:               Form:      DW_FORM_data4
+# MULTI-TABLES-NEXT:     - ID: 2
+# MULTI-TABLES-NEXT:       Table:
+# MULTI-TABLES-NEXT:         - Code:     0x0000000000000001
+# MULTI-TABLES-NEXT:           Tag:      DW_TAG_compile_unit
+# MULTI-TABLES-NEXT:           Children: DW_CHILDREN_no
+# MULTI-TABLES-NEXT:           Attributes:
+# MULTI-TABLES-NEXT:             - Attribute: DW_AT_low_pc
+# MULTI-TABLES-NEXT:               Form:      DW_FORM_udata
+# MULTI-TABLES-NEXT:   debug_info:
+# MULTI-TABLES-NEXT:     - Length:        0x000000000000000C
+# MULTI-TABLES-NEXT:       Version:       4
+# MULTI-TABLES-NEXT:       AbbrevTableID: 1
+# MULTI-TABLES-NEXT:       AbbrOffset:    0x0000000000000008
+# MULTI-TABLES-NEXT:       AddrSize:      8
+# MULTI-TABLES-NEXT:       Entries:
+# MULTI-TABLES-NEXT:         - AbbrCode: 0x00000001
+# MULTI-TABLES-NEXT:           Values:
+# MULTI-TABLES-NEXT:             - Value: 0x0000000000001234
+# MULTI-TABLES-NEXT:     - Length:        0x000000000000000C
+# MULTI-TABLES-NEXT:       Version:       4
+# MULTI-TABLES-NEXT:       AbbrevTableID: 1
+# MULTI-TABLES-NEXT:       AbbrOffset:    0x0000000000000008
+# MULTI-TABLES-NEXT:       AddrSize:      8
+# MULTI-TABLES-NEXT:       Entries:
+# MULTI-TABLES-NEXT:         - AbbrCode: 0x00000001
+# MULTI-TABLES-NEXT:           Values:
+# MULTI-TABLES-NEXT:             - Value: 0x0000000000004321
+# MULTI-TABLES-NEXT:     - Length:        0x0000000000000010
+# MULTI-TABLES-NEXT:       Version:       4
+# MULTI-TABLES-NEXT:       AbbrevTableID: 0
+# MULTI-TABLES-NEXT:       AbbrOffset:    0x0000000000000000
+# MULTI-TABLES-NEXT:       AddrSize:      8
+# MULTI-TABLES-NEXT:       Entries:
+# MULTI-TABLES-NEXT:         - AbbrCode: 0x00000001
+# MULTI-TABLES-NEXT:           Values:
+# MULTI-TABLES-NEXT:             - Value: 0x0000000000005678
+# MULTI-TABLES-NEXT:     - Length:        0x000000000000000B
+# MULTI-TABLES-NEXT:       Version:       4
+# MULTI-TABLES-NEXT:       AbbrevTableID: 2
+# MULTI-TABLES-NEXT:       AbbrOffset:    0x0000000000000010
+# MULTI-TABLES-NEXT:       AddrSize:      8
+# MULTI-TABLES-NEXT:       Entries:
+# MULTI-TABLES-NEXT:         - AbbrCode: 0x00000001
+# MULTI-TABLES-NEXT:           Values:
+# MULTI-TABLES-NEXT:             - Value: 0x0000000000008765
+# MULTI-TABLES-NEXT: ...
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  232
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   2
+    flags:    0
+    Sections:
+      - sectname:  __debug_abbrev
+        segname:   __DWARF
+        addr:      0x00
+        size:      24
+        offset:    528
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+      - sectname:  __debug_info
+        segname:   __DWARF
+        addr:      0x00
+        size:      67
+        offset:    1070
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+DWARF:
+  debug_abbrev:
+    - Table:
+        - Code:     1
+          Tag:      DW_TAG_compile_unit
+          Children: DW_CHILDREN_no
+          Attributes:
+            - Attribute: DW_AT_low_pc
+              Form:      DW_FORM_addr
+    - ID: 2
+      Table:
+        - Code:     1
+          Tag:      DW_TAG_compile_unit
+          Children: DW_CHILDREN_no
+          Attributes:
+            - Attribute: DW_AT_low_pc
+              Form:      DW_FORM_data4
+    - ID: 1
+      Table:
+        - Code:     1
+          Tag:      DW_TAG_compile_unit
+          Children: DW_CHILDREN_no
+          Attributes:
+            - Attribute: DW_AT_low_pc
+              Form:      DW_FORM_udata
+  debug_info:
+    - Version:       4
+      AbbrevTableID: 2
+      AbbrOffset:    8
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x1234
+    - Version:       4
+      AbbrevTableID: 2
+      AbbrOffset:    8
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x4321
+    - Version:       4
+      AbbrevTableID: 0
+      AbbrOffset:    0
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x5678
+    - Version:       4
+      AbbrevTableID: 1
+      AbbrOffset:    16
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x8765
+
+## d) Test that yaml2obj emits an error message when a compilation unit doesn't have
+## an associated abbrev table.
+
+# RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=MISSING-ABBREV
+
+# MISSING-ABBREV: yaml2obj: error: cannot find abbrev table whose ID is 0 for compilation unit with index 0
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  152
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   2
+    flags:    0
+    Sections:
+      - sectname:  __debug_info
+        segname:   __DWARF
+        addr:      0x00
+        size:      64
+        offset:    1070
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+DWARF:
+  debug_info:
+    - Version:    4
+      AbbrOffset: 0x00
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x1234

llvm/test/ObjectYAML/MachO/DWARF5-debug_info.yaml

- Length:          65
           Data:            11
 ...
 
 #      DWARF32: DWARF:
 #      DWARF32:   debug_info:
 # DWARF32-NEXT:     - Length:        0x0000000000000076
 # DWARF32-NEXT:       Version:       5
 # DWARF32-NEXT:       UnitType:      DW_UT_compile
+# DWARF32-NEXT:       AbbrevTableID: 0
 # DWARF32-NEXT:       AbbrOffset:    0
 # DWARF32-NEXT:       AddrSize:      8
 # DWARF32-NEXT:       Entries:
 # DWARF32-NEXT:         - AbbrCode: 0x00000001
 # DWARF32-NEXT:           Values:
 # DWARF32-NEXT:             - Value: 0x0000000000000001
 # DWARF32-NEXT:             - Value: 0x000000000000000C
 # DWARF32-NEXT:             - Value: 0x0000000000000038

 
 # RUN: yaml2obj --docnum=2 -DFORMAT=DWARF32 -DLENGTH=12 %s | \
 # RUN:   obj2yaml | FileCheck %s --check-prefix=DWARF32-YAML
 
 #      DWARF32-YAML: debug_info:
 # DWARF32-YAML-NEXT:   - Length:        0x000000000000000C
 # DWARF32-YAML-NEXT:     Version:       5
 # DWARF32-YAML-NEXT:     UnitType:      DW_UT_compile
+# DWARF32-YAML-NEXT:     AbbrevTableID: 0
 # DWARF32-YAML-NEXT:     AbbrOffset:    0x0000000000000000
 # DWARF32-YAML-NEXT:     AddrSize:      8
 # DWARF32-YAML-NEXT:     Entries:
 # DWARF32-YAML-NEXT:       - AbbrCode: 0x00000001
 # DWARF32-YAML-NEXT:         Values:
 # DWARF32-YAML-NEXT:           - Value: 0x0000000000001234
 
 --- !mach-o

 # RUN: yaml2obj --docnum=2 -DFORMAT=DWARF64 -DLENGTH=20 %s | \
 # RUN:   obj2yaml | FileCheck %s --check-prefix=DWARF64-YAML
 
 #      DWARF64-YAML: debug_info:
 # DWARF64-YAML-NEXT:   - Format:        DWARF64
 # DWARF64-YAML-NEXT:     Length:        0x0000000000000014
 # DWARF64-YAML-NEXT:     Version:       5
 # DWARF64-YAML-NEXT:     UnitType:      DW_UT_compile
+# DWARF64-YAML-NEXT:     AbbrevTableID: 0
 # DWARF64-YAML-NEXT:     AbbrOffset:    0x0000000000000000
 # DWARF64-YAML-NEXT:     AddrSize:      8
 # DWARF64-YAML-NEXT:     Entries:
 # DWARF64-YAML-NEXT:       - AbbrCode: 0x00000001
 # DWARF64-YAML-NEXT:         Values:
 # DWARF64-YAML-NEXT:           - Value: 0x0000000000001234

llvm/test/tools/yaml2obj/ELF/DWARF/debug-abbrev.yaml

- Table:
           Children:   DW_CHILDREN_no
           Attributes: []
         - Tag:        DW_TAG_subprogram
           Children:   DW_CHILDREN_no
           Attributes: []
         - Tag:        DW_TAG_subprogram
           Children:   DW_CHILDREN_no
           Attributes: []
+
+## i) Test that yaml2obj emits an error message when there are non-empty compilation units
+## and multiple abbrev tables are assigned the same ID.
+
+## RUN: not yaml2obj --docnum=9 %s 2>&1 | FileCheck %s --check-prefix=ID-COLLISION
+
+# ID-COLLISION: yaml2obj: error: the ID (1) of abbrev table with index 1 has been used by abbrev table with index 0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_abbrev:
+    - ID: 1
+    - ID: 1
+  debug_info:
+    - Version:    4
+      AbbrOffset: 0x00
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x1234

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

- Length:        0x1234
       AbbrOffset:    0x1234
       AddrSize:      4
       Entries:
         - AbbrCode: 0
           Values:   []
     - Length:        0x5678
       ## Test DWARFv4
       Version:       4
+      AbbrevTableID: 0
       AbbrOffset:    0x5678
       AddrSize:      4
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x12345678 ## DW_FORM_addr
             - BlockData:        ## DW_FORM_block2
                 - 0x12
- Length:     0x1234
           Values:
             - Value: 0x87654321
             - Value: 0x1234
         ## Test that yaml2obj ignores the contents of entries with abbrev code 0.
         - AbbrCode: 0
           Values:
             - Value: 0x1234
 
 ## i) Test that yaml2obj reports an error when 'debug_info' has values in its
 ## entries but 'debug_abbrev' doesn't have enough attributes for them.
 
 # RUN: not yaml2obj --docnum=10 %s -o %t10.o 2>&1 | \
 # RUN:   FileCheck %s --check-prefixes=ERROR
 
 # ERROR: yaml2obj: error: abbrev code must be less than or equal to the number of entries in abbreviation table
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 DWARF:
   debug_abbrev:
     - Table: []
DWARF:
   debug_info:
     - Version:    4
       AbbrOffset: 0x00
 
 ## n) Test that yaml2obj emits an error message when a compilation unit has values but there is no associated abbrev table.
 
 ## RUN: not yaml2obj --docnum=16 %s 2>&1 | FileCheck %s --check-prefix=NO-ABBREV
 
-# NO-ABBREV: yaml2obj: error: non-empty compilation unit should have an associated abbrev table
+# NO-ABBREV: yaml2obj: error: cannot find abbrev table whose ID is 0 for compilation unit with index 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 DWARF:
   debug_info:
     - Version:    4
       AbbrOffset: 0x00
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x1234
+
+## o) Test that yaml2obj is able to generate compilation units according to the
+## associated abbrev table that is referenced by the 'AbbrevTableID'.
+
+# RUN: yaml2obj --docnum=17 %s -o %t17.o
+# RUN: llvm-readelf --hex-dump=.debug_info %t17.o | FileCheck %s --check-prefix=MULTI-TABLES
+
+#      MULTI-TABLES: Hex dump of section '.debug_info':
+# MULTI-TABLES-NEXT: 0x00000000 0c000000 04000800 00000801 34120000 ............4...
+##                              ^-------                            unit_length (4-byte)
+##                                       ^---                       version (2-byte)
+##                                           ^--------              debug_abbrev_offset (4-byte)
+##                                                    ^-            address_size (1-byte)
+##                                                      ^-          abbrev_code (ULEB128) 0x01
+##                                                         ^------- Form: DW_FORM_data4 (4-byte) 0x1234
+# MULTI-TABLES-NEXT: 0x00000010 0c000000 04000800 00000801 21430000 ............!C..
+##                              ^-------                            unit_length (4-byte)
+##                                       ^---                       version (2-byte)
+##                                           ^--------              debug_abbrev_offset (4-byte)
+##                                                    ^-            address_size (1-byte)
+##                                                      ^-          abbrev_code (ULEB128) 0x01
+##                                                         ^------- Form: DW_FORM_data4 (4-byte) 0x4321
+# MULTI-TABLES-NEXT: 0x00000020 10000000 04000000 00000801 78560000 ............xV..
+##                              ^-------                            unit_length (4-byte)
+##                                       ^---                       version (2-byte)
+##                                           ^--------              debug_abbrev_offset (4-byte)
+##                                                    ^-            address_size (1-byte)
+##                                                      ^-          abbrev_code (ULEB128) 0x01
+##                                                         ^------- Form: DW_FORM_addr (8-byte) 0x5678
+# MULTI-TABLES-NEXT: 0x00000030 00000000 0b000000 04001000 00000801 ................
+##                              --------
+##                                       ^-------                   unit_length (4-byte)
+##                                                ^---              version (2-byte)
+##                                                    ^--------     debug_abbrev_offset (4-byte)
+##                                                             ^-   address_size (1-byte)
+##                                                               ^- abbrev_code (ULEB128) 0x01
+# MULTI-TABLES-NEXT: 0x00000040 e58e02                              ...
+##                              ^-----                              Form: DW_FORM_udata (ULEB128) 0x8765
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+DWARF:
+  debug_abbrev:
+    - Table:
+        - Code:     1
+          Tag:      DW_TAG_compile_unit
+          Children: DW_CHILDREN_no
+          Attributes:
+            - Attribute: DW_AT_low_pc
+              Form:      DW_FORM_addr
+    - ID: 2
+      Table:
+        - Code:     1
+          Tag:      DW_TAG_compile_unit
+          Children: DW_CHILDREN_no
+          Attributes:
+            - Attribute: DW_AT_low_pc
+              Form:      DW_FORM_data4
+    - ID: 1
+      Table:
+        - Code:     1
+          Tag:      DW_TAG_compile_unit
+          Children: DW_CHILDREN_no
+          Attributes:
+            - Attribute: DW_AT_low_pc
+              Form:      DW_FORM_udata
+  debug_info:
+    - Version:       4
+      AbbrevTableID: 2
+      AbbrOffset:    8
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x1234
+    - Version:       4
+      AbbrevTableID: 2
+      AbbrOffset:    8
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x4321
+    - Version:       4
+      AbbrevTableID: 0
+      AbbrOffset:    0
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x5678
+    - Version:       4
+      AbbrevTableID: 1
+      AbbrOffset:    16
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - Value: 0x8765

llvm/tools/obj2yaml/dwarf2yaml.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 
 #include <algorithm>
 
 using namespace llvm;
 
 void dumpDebugAbbrev(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   auto AbbrevSetPtr = DCtx.getDebugAbbrev();
   if (AbbrevSetPtr) {
+    uint64_t AbbrevTableID = 0;
     for (auto AbbrvDeclSet : *AbbrevSetPtr) {
       Y.DebugAbbrev.emplace_back();
       for (auto AbbrvDecl : AbbrvDeclSet.second) {
         DWARFYAML::Abbrev Abbrv;
         Abbrv.Code = AbbrvDecl.getCode();
         Abbrv.Tag = AbbrvDecl.getTag();
         Abbrv.Children = AbbrvDecl.hasChildren() ? dwarf::DW_CHILDREN_yes
                                                  : dwarf::DW_CHILDREN_no;
         for (auto Attribute : AbbrvDecl.attributes()) {
           DWARFYAML::AttributeAbbrev AttAbrv;
           AttAbrv.Attribute = Attribute.Attr;
           AttAbrv.Form = Attribute.Form;
           if (AttAbrv.Form == dwarf::DW_FORM_implicit_const)
             AttAbrv.Value = Attribute.getImplicitConstValue();
           Abbrv.Attributes.push_back(AttAbrv);
         }
+        Y.DebugAbbrev.back().ID = AbbrevTableID++;
         Y.DebugAbbrev.back().Table.push_back(Abbrv);
       }
     }
   }
 }
 
 void dumpDebugStrings(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   StringRef RemainingTable = DCtx.getDWARFObj().getStrSection();

 void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   for (const auto &CU : DCtx.compile_units()) {
     DWARFYAML::Unit NewUnit;
     NewUnit.Format = CU->getFormat();
     NewUnit.Length = CU->getLength();
     NewUnit.Version = CU->getVersion();
     if (NewUnit.Version >= 5)
       NewUnit.Type = (dwarf::UnitType)CU->getUnitType();
+    const DWARFDebugAbbrev *DebugAbbrev = DCtx.getDebugAbbrev();
+    NewUnit.AbbrevTableID = std::distance(
+        DebugAbbrev->begin(),
+        std::find_if(
+            DebugAbbrev->begin(), DebugAbbrev->end(),
+            [&](const std::pair<uint64_t, DWARFAbbreviationDeclarationSet> &P) {
+              return P.first == CU->getAbbreviations()->getOffset();
+            }));
     NewUnit.AbbrOffset = CU->getAbbreviations()->getOffset();
     NewUnit.AddrSize = CU->getAddressByteSize();
     for (auto DIE : CU->dies()) {
       DWARFYAML::Entry NewEntry;
       DataExtractor EntryData = CU->getDebugInfoExtractor();
       uint64_t offset = DIE.getOffset();
 
       assert(EntryData.isValidOffset(offset) && "Invalid DIE Offset");

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

debug_info:
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
       - Length:          16
         Version:         4
+        AbbrevTableID:   0
         AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x000000000000000D
               - Value:           0x0000000000000000
     debug_line: