[Debuginfo][llvm-dwarfdump][dsymutil] Add dsymutil compatibility dump.

[avl]

Summary

This patch adds a new kind of dump into the llvm-dwarfdump utility.
This new kind of dump can be used to compare semantically the same but
binary different DWARF files produced by dsymutil. f.e. these two should match:

dsymutil intput-file -o - | llvm-dwarfdump --dsymutil-compat-dump - -o - | md5
dsymutil --no-odr intput-file -o - | llvm-dwarfdump --dsymutil-compat-dump - -o - | md5

The idea of the dump is that it skips type dies. Instead, it prints type names.
Additionally, it skips dies offsets, strings offsets, etc...

"llvm-dwarfdump -a":

0x0000002a:   DW_TAG_class_type
                DW_AT_name      ("class1")

0x00000071:   DW_TAG_subprogram
                DW_AT_name      ("foo1")
                DW_AT_low_pc    (0x0000000000001000)
                DW_AT_high_pc   (0x0000000000001010)
                DW_AT_type      (0x0000002a "class1")

"llvm-dwarfdump --dsymutil-compat-dump":

== DW_TAG_subprogram [1]
   DW_AT_name "foo1"
   DW_AT_low_pc 0x0000000000001000
   DW_AT_high_pc 0x0000000000001010
   DW_AT_type "class1"

use cases for this dump:

1. to compare result produced by "dsymutil" and "dsymutil --no-odr".
2. to compare result produced by current upstream dsymutil and another one from https://reviews.llvm.org/D86539.
3. to compare result produced by current upstream dsymutil and another one from https://reviews.llvm.org/D96035.

[dblaikie]

I don't think this would be enough to make dumps very comparable, would it? We'd have to sort DIEs or something (based on their semantic content) to make things very comparable, beyond only omitting offsets?

(& also this mode probably wouldn't be dsym specific, I'd guess - but some comparable/generic/semantic dump?)

[avl]

In D124082#3462426, @dblaikie wrote:

I don't think this would be enough to make dumps very comparable, would it?

It works for dsymutil. Following commands produce equal md5 value for many llvm binaries(for others, they produce incompatible value which points to the real problem).

dsymutil intput-file -o - | llvm-dwarfdump --dsymutil-compat-dump - -o - | md5
dsymutil --no-odr intput-file -o - | llvm-dwarfdump --dsymutil-compat-dump - -o - | md5

We'd have to sort DIEs or something (based on their semantic content) to make things very comparable, beyond only omitting offsets?

This patch not only omit offsets but also skip dies. Currently it prints only dies which have
DW_AT_lowpc or DW_AT_ranges or parameters dies. For such dies the patch assumes(to have successful comparison) they are in the same order
as they are in the other input. Other dies are skipped. It allows not to depend on the order or amount of types dies.
The types are compared by names which are printed by this patch.

(& also this mode probably wouldn't be dsym specific, I'd guess - but some comparable/generic/semantic dump?)

Above assumption on the order of dies makes it dsymutil specific(and currently it would be most useful to compare dsymutil output). We can make it more general. But then, we would need to sort dies somehow as you suggested. I propose we can start from dsymutil specific solution and then make it more general.

[dblaikie]

Alrighty, I'll leave it to the dsymutil folks to hash this out - I'm not fundamentally opposed even in the current rather narrow form.

[jhenderson]

This is mostly outside my area of expertees, so I'm not going to review this more widely, but the new option needs adding to the Command Guide documentation for llvm-dwarfdump.

[clayborg]

Instead of doing a dumping thing, it might be a good idea to have a comparison mode build into llvm-dsymutil that can compare the contents of two files maybe? As David Blaikie suggested, this output format won't help diff things as we enable more complex garbage collection and type uniquing. If we do want a dump format that can be diffed, it should probably be output in a format that sorts things a bit better. Like sorting all functions by address and making a common output format for them. Types would be output sorted by type name, but it would be harder to diff especially since the other llvm-dsymutil did more simple type uniquing and the new modifications you are trying to get in really merge all of the types. There is already a "--diff" option to this tool that omits all addresses and offsets to help diff two files so chunks that were removed can easily be identified, does that mode not work for you?

[avl]

Instead of doing a dumping thing, it might be a good idea to have a comparison mode build into llvm-dsymutil that can compare the contents of two files maybe?

Agreed, creating some smarter tool(doing complex comparisons of DIEs trees) makes sense. Probably it should not be llvm-dsymutil. It might be llvm-dwarfdump or some separate tool.

Though, I think the dump suggested in this patch is still quite useful, especially for type de-duplication optimization. Please inspect the example of the usage of this dump in this message later.

As David Blaikie suggested, this output format won't help diff things as we enable more complex garbage collection and type uniquing. If we do want a dump format that can be diffed, it should probably be output in a format that sorts things a bit better. Like sorting all functions by address and making a common output format for them. Types would be output sorted by type name, but it would be harder to diff especially since the other llvm-dsymutil did more simple type uniquing and the new modifications you are trying to get in really merge all of the types.

If we think that adding any sorting will make this patch better - I am happy to add it.

Though, even without such sorting, this patch is quite powerful. The first thing is that it completely does not depend on the type(DW_TAG_*_type and other) dies. Type dies could be in any order or duplicated any number of times. Only names are printed for types(no need to sort type dies). The second thing is that dsymutil does not change the order of DW_TAG_subprogram dies. Thus, we can have an effective comparison without sorting DW_TAG_subprogram dies. We will need to sort them if there are some other tools that change order of DW_TAG_subprogram dies.

This patch also works good when types de-duplication is done in completely different way.
With some small modifications for declarations it helps to compare output of current dsymutil and output of dsymutil from the patch D96035(even if it works in non-deterministic mode).

There is already a "--diff" option to this tool that omits all addresses and offsets to help diff two files so chunks that were removed can easily be identified, does that mode not work for you?

No, it does not. f.e. if type deduplication is done then the final DWARF files(with ODR and without ODR) will contain different number of type dies, even if they are semantically the same. Thus dumps created with "--diff" option will not match. Someone need to inspect differences(which might be quite complex) to understand whether they are semantically equal. At the same time dumps created with "--dsymutil-compat-dump" option will be 100% equal. Let`s see the example:

dsymutil llvm-strings

llvm-dwarfdump --debug-info --diff llvm-strings.dSYM/Contents/Resources/DWARF/llvm-strings > llvm-strings-diff-dump
llvm-dwarfdump --dsymutil-compat-dump llvm-strings.dSYM/Contents/Resources/DWARF/llvm-strings > llvm-strings-compat-dump

dsymutil --no-odr llvm-strings

llvm-dwarfdump --debug-info --diff llvm-strings.dSYM/Contents/Resources/DWARF/llvm-strings > llvm-strings-noodr-diff-dump
llvm-dwarfdump --dsymutil-compat-dump llvm-strings.dSYM/Contents/Resources/DWARF/llvm-strings > llvm-strings-noodr-compat-dump


diff llvm-strings-diff-dump llvm-strings-noodr-diff-dump | wc -c | awk '{print $1/1000"K"}'
68563,8K

diff llvm-strings-compat-dump llvm-strings-noodr-compat-dump | wc -c | awk '{print $1/1000"K"}'
0K

One of the secret why dsymutil-compat-dump does not have a lot of differencies is that it skips much.
Probably we can make it more detailed. But even in this form it is able to catch errors. f.e. it shows
that dsymutil applied for "opt" binary has a bug inside odr deduplication optimization:

diff opt-compat-dump opt-noodr-compat-dump 
12158120c12158120
<      DW_AT_specification "operator()": "llvm::VPBasicBlock *"
---
>      DW_AT_specification "operator()": "const llvm::VPBasicBlock *"

The "const" qualifier is lost.

Thus, In short, a powerful tool comparing type die trees would be useful. But it would also be much more complex. While this dump is quite simple and can help to find some classes of errors.

[avl]

renamed option to less specific variant (dsymutil-compat-dump -> type-compat-dump)
added doc description.

[clayborg]

I am all for this patch if it helps you test and verify new features in dsymutil and llvm-dwarfutil progress. So I am ok with this, but I am not a code owner of the LLVM DWARF tools so I will let someone else give the final ok

[probinson]

Comparing different DWARF output in a more abstract way is exactly what the llvm-dva tool is designed to do; unfortunately it isn't upstream yet, although @CarlosAlbertoEnciso is working on generating the patches now.
I'd prefer not to have a works-in-a-few-cases-for-one-tool feature come in when a better solution is around the corner.

[JDevlieghere]

When you used this to compare the output of dsymutil changes, what was the input binary? Does this generate meaningful output for bigger programs like dsymutil itself?

In my experience, when you change the dsymutil algorithm that marks dies as kept, they end up in different subtrees. Is that something this tool can deal with? My original assumption was that it can't, but then I don't understand how this was useful for the other two patches.

In D124082#3474691, @probinson wrote:

Comparing different DWARF output in a more abstract way is exactly what the llvm-dva tool is designed to do; unfortunately it isn't upstream yet, although @CarlosAlbertoEnciso is working on generating the patches now.
I'd prefer not to have a works-in-a-few-cases-for-one-tool feature come in when a better solution is around the corner.

+1 if that tool is actually coming. @CarlosAlbertoEnciso or @probinson do you have a rough timeline in mind?

[probinson]

In D124082#3495415, @JDevlieghere wrote:

In D124082#3474691, @probinson wrote:

Comparing different DWARF output in a more abstract way is exactly what the llvm-dva tool is designed to do; unfortunately it isn't upstream yet, although @CarlosAlbertoEnciso is working on generating the patches now.
I'd prefer not to have a works-in-a-few-cases-for-one-tool feature come in when a better solution is around the corner.

+1 if that tool is actually coming. @CarlosAlbertoEnciso or @probinson do you have a rough timeline in mind?

I'm even now doing the last round of internal reviews before Carlos posts the patch set.

[avl]

When you used this to compare the output of dsymutil changes, what was the input binary? Does this generate meaningful output for bigger programs like dsymutil itself?

yes it does. I used it for all llvm&clang binaries.

In my experience, when you change the dsymutil algorithm that marks dies as kept, they end up in different subtrees. Is that something this tool can deal with? My original assumption was that it can't, but then I don't understand how this was useful for the other two patches.

Yes, this tool can deal with different subtrees(type subtrees). The idea is that it skips type subtrees. The types are compared by string representation. Following is the example:

a)

0x0000001b:   DW_TAG_const_type
                DW_AT_type      (0x0000002a "class1")

0x0000002a:   DW_TAG_class_type
                DW_AT_name      ("class1")

0x00000071:   DW_TAG_subprogram
                DW_AT_name      ("foo1")
                DW_AT_low_pc    (0x0000000000001000)
                DW_AT_high_pc   (0x0000000000001010)
                DW_AT_type      (0x0000001b "const class1")


b)

0x0000001b:   DW_TAG_class_type
                DW_AT_name      ("class1")

0x0000002a:   DW_TAG_const_type
                DW_AT_type      (0x0000001b "class1")

0x00000071:   DW_TAG_subprogram
                DW_AT_name      ("foo1")
                DW_AT_low_pc    (0x0000000000001000)
                DW_AT_high_pc   (0x0000000000001010)
                DW_AT_type      (0x0000002a "const class1")

For both above examples --type-compat-dump will skip types descriptions and print only type names:

== DW_TAG_subprogram [1]
   DW_AT_name "foo1"
   DW_AT_low_pc 0x0000000000001000
   DW_AT_high_pc 0x0000000000001010
   DW_AT_type "const class1"

That allows to catch errors if type trees were incorrect. F.e. if "DW_AT_type "const class1"" look like this

DW_AT_type "class1"
DW_AT_type "const class2"
DW_AT_type "class1*".

That solution works not for all possible dies trees modifications, but for only type trees.

llvm/docs/CommandGuide/llvm-dwarfdump.rst

.. option:: --statistics
             Collect debug info quality metrics and print the results
             as machine-readable single-line JSON output. The output
             format is described in the section below (:ref:`stats-format`).
 
 .. option:: --summarize-types
 
             Abbreviate the description of type unit entries.
 
+.. option:: --type-compat-dump
+
+            Dump the output in a format that is more friendly for comparing
+            types inside DWARF output from two different files.
+
 .. option:: -x, --regex
 
             Treat any <name> strings as regular expressions when searching
             with :option:`--name`. If :option:`--ignore-case` is also specified,
             the regular expression becomes case-insensitive.
 
 .. option:: -u, --uuid
 

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

public:
 
   /// Dump the location list at the given \p Offset. The function returns true
   /// iff it has successfully reched the end of the list. This means that one
   /// can attempt to parse another list after the current one (\p Offset will be
   /// updated to point past the end of the current list).
   bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
                         Optional<object::SectionedAddress> BaseAddr,
                         const MCRegisterInfo *MRI, const DWARFObject &Obj,
-                        DWARFUnit *U, DIDumpOptions DumpOpts,
-                        unsigned Indent) const;
+                        DWARFUnit *U, DIDumpOptions DumpOpts, unsigned Indent,
+                        bool DumpListOffset = true) const;
 
   Error visitAbsoluteLocationList(
       uint64_t Offset, Optional<object::SectionedAddress> BaseAddr,
       std::function<Optional<object::SectionedAddress>(uint32_t)> LookupAddr,
       function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const;
 
   const DWARFDataExtractor &getData() { return Data; }
 

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

static void dumpExpression(raw_ostream &OS, DIDumpOptions DumpOpts,
   DWARFDataExtractor Extractor(Data, IsLittleEndian, AddressSize);
   // Note. We do not pass any format to DWARFExpression, even if the
   // corresponding unit is known. For now, there is only one operation,
   // DW_OP_call_ref, which depends on the format; it is rarely used, and
   // is unexpected in location tables.
   DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, MRI, U);
 }
 
-bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS,
-                                          Optional<SectionedAddress> BaseAddr,
-                                          const MCRegisterInfo *MRI,
-                                          const DWARFObject &Obj, DWARFUnit *U,
-                                          DIDumpOptions DumpOpts,
-                                          unsigned Indent) const {
+bool DWARFLocationTable::dumpLocationList(
+    uint64_t *Offset, raw_ostream &OS, Optional<SectionedAddress> BaseAddr,
+    const MCRegisterInfo *MRI, const DWARFObject &Obj, DWARFUnit *U,
+    DIDumpOptions DumpOpts, unsigned Indent, bool DumpListOffset) const {
   DWARFLocationInterpreter Interp(
       BaseAddr, [U](uint32_t Index) -> Optional<SectionedAddress> {
         if (U)
           return U->getAddrOffsetSectionItem(Index);
         return None;
       });
+  if (DumpListOffset)
     OS << format("0x%8.8" PRIx64 ": ", *Offset);
   Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
     Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
     if (!Loc || DumpOpts.DisplayRawContents)
       dumpRawEntry(E, OS, Indent, DumpOpts, Obj);
     if (Loc && *Loc) {
       OS << "\n";
       OS.indent(Indent);
       if (DumpOpts.DisplayRawContents)

llvm/test/tools/llvm-dwarfdump/type-compat/basic.yaml

+## This test checks basic output for --type-compat-dump option.
+## All type dies should be removed. Instead, the type name should be
+## printed for DW_AT_type attribute.
+
+# RUN: yaml2obj %s -o - | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_producer "by_hand"
+# CHECK:    DW_AT_language DW_LANG_C_plus_plus
+# CHECK:    DW_AT_name "CU1"
+# CHECK:    DW_AT_low_pc 0x0000000000001000
+# CHECK:    DW_AT_high_pc 0x000000000000101b
+
+# CHECK-NOT: DW_TAG_class_type
+# CHECK-NOT: DW_TAG_member
+# CHECK-NOT: DW_TAG_base_type
+
+# CHECK: DW_TAG_subprogram [1]
+# CHECK:      DW_AT_name "foo1"
+# CHECK:      DW_AT_low_pc 0x0000000000001000
+# CHECK:      DW_AT_high_pc 0x0000000000001010
+# CHECK:      DW_AT_type "class1"
+
+# CHECK: DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_producer "by_hand"
+# CHECK:    DW_AT_language DW_LANG_C_plus_plus
+# CHECK:    DW_AT_name "CU1"
+# CHECK:    DW_AT_low_pc 0x0000000000002000
+# CHECK:    DW_AT_high_pc 0x000000000000201b
+
+# CHECK-NOT: DW_TAG_class_type
+# CHECK-NOT: DW_TAG_member
+# CHECK-NOT: DW_TAG_base_type
+
+# CHECK: DW_TAG_subprogram [1]
+# CHECK:      DW_AT_name "foo2"
+# CHECK:      DW_AT_low_pc 0x0000000000002000
+# CHECK:      DW_AT_high_pc 0x0000000000002010
+# CHECK:      DW_AT_type "class2"
+
+
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_producer
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_language
+            Form:      DW_FORM_data2
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data8
+      - Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data8
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_member
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_declaration
+            Form:      DW_FORM_flag_present
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_declaration
+            Form:      DW_FORM_flag_present
+      - Tag:      DW_TAG_template_type_parameter
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+      - Tag:      DW_TAG_base_type
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+    - Table:
+      - Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_producer
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_language
+            Form:      DW_FORM_data2
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data8
+      - Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data8
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_member
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_declaration
+            Form:      DW_FORM_flag_present
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_declaration
+            Form:      DW_FORM_flag_present
+      - Tag:      DW_TAG_template_type_parameter
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+      - Tag:      DW_TAG_base_type
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+  debug_info:
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - CStr: by_hand
+            - Value:  0x04
+            - CStr: CU1
+            - Value:  0x1000
+            - Value:  0x1b
+        - AbbrCode: 3
+          Values:
+            - CStr: class1
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 3
+          Values:
+            - CStr: class2
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 3
+          Values:
+            - CStr: class3
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 8
+          Values:
+            - CStr: int
+        - AbbrCode: 2
+          Values:
+            - CStr: foo1
+            - Value:  0x1000
+            - Value:  0x10
+            - Value:  0x0000002a
+        - AbbrCode: 0
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - CStr: by_hand
+            - Value:  0x04
+            - CStr: CU1
+            - Value:  0x2000
+            - Value:  0x1b
+        - AbbrCode: 3
+          Values:
+            - CStr: class1
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 3
+          Values:
+            - CStr: class2
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 3
+          Values:
+            - CStr: class3
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 8
+          Values:
+            - CStr: int
+        - AbbrCode: 2
+          Values:
+            - CStr: foo2
+            - Value:  0x2000
+            - Value:  0x10
+            - Value:  0x00000040
+        - AbbrCode: 0
+...

llvm/test/tools/llvm-dwarfdump/type-compat/loc.yaml

+## This test checks how DWARF v4 location lists are printed
+## by --type-compat-dump option.
+
+# RUN: yaml2obj %s | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: == DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_low_pc 0x0000000000000000
+# CHECK:    DW_AT_high_pc 0x000000000000000b
+
+# CHECK:   == DW_TAG_subprogram [1]
+# CHECK:      DW_AT_low_pc 0x0000000000000000
+# CHECK:      DW_AT_high_pc 0x000000000000000b
+
+# CHECK:     == DW_TAG_variable [2]
+# CHECK:        DW_AT_location
+# CHECK:                    [0x0000000000000000, 0x0000000000000006): DW_OP_reg5
+
+# CHECK:     == DW_TAG_variable [2]
+# CHECK:        DW_AT_location
+# CHECK:                    [0x0000000000000003, 0x0000000000000005): DW_OP_reg2
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_loc
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x01
+    Content:      '00000000000000000600000000000000010055000000000000000000000000000000000300000000000000050000000000000001005200000000000000000000000000000000'
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     2
+        Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     3
+        Tag:      DW_TAG_variable
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_location
+            Form:      DW_FORM_sec_offset
+  debug_info:
+    - Version:    4
+      AbbrOffset: 0x00
+      Entries:
+        - AbbrCode: 1 ## DW_TAG_compile_unit
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 2 ## DW_TAG_subprogram
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 3 ## DW_TAG_variable
+          Values:
+            - Value: 0x00 ## DW_AT_sec_offset
+        - AbbrCode: 3 ## DW_TAG_variable
+          Values:
+            - Value: 0x23 ## DW_AT_sec_offset
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL

llvm/test/tools/llvm-dwarfdump/type-compat/loclists.yaml

+## This test checks how DWARF v5 location lists are printed
+## by --type-compat-dump option.
+
+# RUN: yaml2obj %s | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: == DW_TAG_compile_unit [0]
+# CHECK-NOT:    DW_AT_addr_base
+# CHECK-NOT:    DW_AT_loclists_base
+# CHECK:    DW_AT_low_pc 0x0000000000000000
+# CHECK:    DW_AT_high_pc 0x0000000000000008
+
+# CHECK:   == DW_TAG_subprogram [1]
+# CHECK:      DW_AT_low_pc 0x0000000000000000
+# CHECK:      DW_AT_high_pc 0x000000000000000b
+
+# CHECK:     == DW_TAG_formal_parameter [2]
+# CHECK:        DW_AT_location
+# CHECK:           DW_LLE_startx_endx     (0x0000000000000000, 0x0000000000000011): DW_OP_breg16
+# CHECK:           DW_LLE_startx_length   (0x0000000000000011, 0x0000000000000012): DW_OP_breg17
+# CHECK:           [0x0000000000000012, 0x0000000000000013): DW_OP_breg18
+# CHECK:           <default>: DW_OP_breg19
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_loclists
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x01
+    Content:      '1b000000050008000000000002001101800311120181041213018205018300'
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_addr_base
+            Form:      DW_FORM_sec_offset
+          - Attribute: DW_AT_loclists_base
+            Form:      DW_FORM_sec_offset
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     2
+        Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     3
+        Tag:      DW_TAG_formal_parameter
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_location
+            Form:      DW_FORM_sec_offset
+  debug_info:
+    - Version:    5
+      UnitType:   DW_UT_compile
+      AddrSize:   8
+      Entries:
+        - AbbrCode: 1 ## DW_TAG_compile_unit
+          Values:
+            - Value: 0x08 ## DW_AT_addr_base
+            - Value: 0x0c ## DW_AT_loclists_base
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x08 ## DW_AT_high_pc
+        - AbbrCode: 2 ## DW_TAG_subprogram
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 3 ## DW_TAG_formal_parameter
+          Values:
+            - Value: 0x0c ## DW_AT_sec_offset
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL

llvm/test/tools/llvm-dwarfdump/type-compat/ranges-error.yaml

+## This test checks error message displayed for corrupted .debug_ranges section.
+
+# RUN: yaml2obj %s | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: == DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_low_pc 0x0000000000000000
+# CHECK:    DW_AT_high_pc 0x000000000000000b
+
+# CHECK:   == DW_TAG_subprogram [1]
+# CHECK:      DW_AT_low_pc 0x0000000000000000
+# CHECK:      DW_AT_high_pc 0x000000000000000b
+
+# CHECK:     == DW_TAG_lexical_block [2]
+# CHECK:        DW_AT_ranges
+# CHECK:          decoding address ranges: invalid range list entry at offset 0x0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_ranges
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x01
+    Content:      '000000000000000003000000'
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     2
+        Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     3
+        Tag:      DW_TAG_lexical_block
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_ranges
+            Form:      DW_FORM_sec_offset
+      - Code:     4
+        Tag:      DW_TAG_variable
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_location
+            Form:      DW_FORM_sec_offset
+  debug_info:
+    - Version:    4
+      AbbrOffset: 0x00
+      Entries:
+        - AbbrCode: 1 ## DW_TAG_compile_unit
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 2 ## DW_TAG_subprogram
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 3 ## DW_TAG_lexical_block
+          Values:
+            - Value: 0x00 ## DW_AT_ranges
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL

llvm/test/tools/llvm-dwarfdump/type-compat/ranges.yaml

+## This test checks how DWARF v4 range list is printed
+## by --type-compat-dump option.
+
+# RUN: yaml2obj %s | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: == DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_low_pc 0x0000000000000000
+# CHECK:    DW_AT_high_pc 0x000000000000000b
+
+# CHECK:   == DW_TAG_subprogram [1]
+# CHECK:      DW_AT_low_pc 0x0000000000000000
+# CHECK:      DW_AT_high_pc 0x000000000000000b
+
+# CHECK:     == DW_TAG_lexical_block [2]
+# CHECK:        DW_AT_ranges
+# CHECK:          [0x0000000000000000, 0x0000000000000003)
+# CHECK:          [0x0000000000000005, 0x0000000000000008)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_ranges
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x01
+    Content:      '000000000000000003000000000000000500000000000000080000000000000000000000000000000000000000000000'
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     2
+        Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data4
+      - Code:     3
+        Tag:      DW_TAG_lexical_block
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_ranges
+            Form:      DW_FORM_sec_offset
+      - Code:     4
+        Tag:      DW_TAG_variable
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_location
+            Form:      DW_FORM_sec_offset
+  debug_info:
+    - Version:    4
+      AbbrOffset: 0x00
+      Entries:
+        - AbbrCode: 1 ## DW_TAG_compile_unit
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 2 ## DW_TAG_subprogram
+          Values:
+            - Value: 0x00 ## DW_AT_low_pc
+            - Value: 0x0b ## DW_AT_high_pc
+        - AbbrCode: 3 ## DW_TAG_lexical_block
+          Values:
+            - Value: 0x00 ## DW_AT_ranges
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL
+        - AbbrCode: 0 ## NULL

llvm/test/tools/llvm-dwarfdump/type-compat/rnglists.yaml

+## This test checks how DWARF v5 range list is printed
+## by --type-compat-dump option.
+
+# RUN: yaml2obj %s -o - | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: == DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_name "by_hand"
+# CHECK:    DW_AT_ranges
+# CHECK:      [0x0000000000000010, 0x0000000000000020)
+# CHECK:      [0x0000000000000025, 0x00000000000000a5)
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_rnglists
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x01
+    Content:      '2500000005000800000000000610000000000000002000000000000000072500000000000000800100'
+DWARF:
+  debug_str:
+    - ''
+    - /tmp/main.c
+  debug_abbrev:
+    - Table:
+        - Code:            0x00000001
+          Tag:             DW_TAG_compile_unit
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_name
+              Form:            DW_FORM_string
+            - Attribute:       DW_AT_ranges
+              Form:            DW_FORM_sec_offset
+  debug_info:
+    - Version:         5
+      UnitType:        DW_UT_compile
+      AddrSize:        8
+      Entries:
+        - AbbrCode:    0x00000001
+          Values:
+            - CStr:    by_hand
+            - Value:   0x0c

llvm/test/tools/llvm-dwarfdump/type-compat/specification.yaml

+## This test checks how DW_AT_specification attribute
+## is printed by --type-compat-dump option.
+
+# RUN: yaml2obj %s -o - | llvm-dwarfdump --type-compat-dump - | FileCheck %s
+
+# CHECK: DW_TAG_compile_unit [0]
+# CHECK:    DW_AT_producer "by_hand"
+# CHECK:    DW_AT_language DW_LANG_C_plus_plus
+# CHECK:    DW_AT_name "CU1"
+# CHECK:    DW_AT_low_pc 0x0000000000001000
+# CHECK:    DW_AT_high_pc 0x000000000000101b
+
+# CHECK-NOT: DW_TAG_class_type
+# CHECK-NOT: DW_TAG_member
+# CHECK-NOT: DW_TAG_base_type
+
+# CHECK: DW_TAG_subprogram [1]
+# CHECK:    DW_AT_name "foo1"
+# CHECK:    DW_AT_low_pc 0x0000000000001000
+# CHECK:    DW_AT_high_pc 0x0000000000001010
+# CHECK:    DW_AT_type "class1"
+# CHECK:    DW_AT_specification "foo1": "class1"
+
+# CHECK-NOT: DW_TAG_subprogram
+
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_producer
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_language
+            Form:      DW_FORM_data2
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data8
+      - Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_low_pc
+            Form:      DW_FORM_addr
+          - Attribute: DW_AT_high_pc
+            Form:      DW_FORM_data8
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+          - Attribute: DW_AT_specification
+            Form:      DW_FORM_ref4
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_member
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_declaration
+            Form:      DW_FORM_flag_present
+      - Tag:      DW_TAG_class_type
+        Children: DW_CHILDREN_yes
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_declaration
+            Form:      DW_FORM_flag_present
+      - Tag:      DW_TAG_template_type_parameter
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+      - Tag:      DW_TAG_base_type
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+      - Tag:      DW_TAG_subprogram
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+  debug_info:
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+            - CStr: by_hand
+            - Value:  0x04
+            - CStr: CU1
+            - Value:  0x1000
+            - Value:  0x1b
+        - AbbrCode: 3
+          Values:
+            - CStr: class1
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 3
+          Values:
+            - CStr: class2
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 3
+          Values:
+            - CStr: class3
+        - AbbrCode: 4
+          Values:
+            - Value:  0x0000006c
+            - CStr: member1
+        - AbbrCode: 0
+        - AbbrCode: 8
+          Values:
+            - CStr: int
+        - AbbrCode: 2
+          Values:
+            - CStr: foo1
+            - Value:  0x1000
+            - Value:  0x10
+            - Value:  0x0000002a
+            - Value:  0x0000008f
+        - AbbrCode: 9
+          Values:
+            - CStr: foo1
+            - Value:  0x0000002a
+        - AbbrCode: 0
+...

llvm/tools/llvm-dwarfdump/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   AllTargetsDescs
   AllTargetsInfos
+  BinaryFormat
   MC
   Object
   Support
   )
 
 add_llvm_tool(llvm-dwarfdump
   SectionSizes.cpp
   Statistics.cpp
   llvm-dwarfdump.cpp
   )
 
 add_subdirectory(fuzzer)

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

 #include "llvm-dwarfdump.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
ArchFilters("arch",
                      "architecture only. Architectures may be specified by "
                      "name or by number. This option can be specified "
                      "multiple times, once for each desired architecture."),
                 cat(DwarfDumpCategory));
 static opt<bool>
     Diff("diff",
          desc("Emit diff-friendly output by omitting offsets and addresses."),
          cat(DwarfDumpCategory));
+
+static cl::opt<bool>
+    TypeCompatDump("type-compat-dump",
+                   cl::desc("Dump the output in a format that is more friendly"
+                            " for comparing types inside DWARF output from two"
+                            " different files."),
+                   cat(DwarfDumpCategory));
+
 static list<std::string>
     Find("find",
          desc("Search for the exact match for <name> in the accelerator tables "
               "and print the matching debug information entries. When no "
               "accelerator tables are available, the slower but more complete "
               "-name option can be used instead."),
          value_desc("name"), cat(DwarfDumpCategory));
 static alias FindAlias("f", desc("Alias for --find."), aliasopt(Find),
static bool verifyObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
   bool Result = DICtx.verify(stream, getDumpOpts(DICtx));
   if (Result)
     stream << "No errors.\n";
   else
     stream << "Errors detected.\n";
   return Result;
 }
 
+// \returns true if specified \p Die should be printed by type compatibility
+// dump.
+static bool shouldBePrintedByTypeCompatDump(const DWARFDie &Die) {
+  switch (Die.getTag()) {
+  case dwarf::DW_TAG_formal_parameter:
+  case dwarf::DW_TAG_template_type_parameter:
+  case dwarf::DW_TAG_unspecified_parameters:
+  case dwarf::DW_TAG_call_site_parameter:
+  case dwarf::DW_TAG_template_value_parameter:
+  case dwarf::DW_TAG_GNU_template_parameter_pack:
+  case dwarf::DW_TAG_GNU_formal_parameter_pack:
+    return true;
+
+  default:
+    return Die
+        .find({dwarf::DW_AT_low_pc, dwarf::DW_AT_ranges, dwarf::DW_AT_location})
+        .hasValue();
+  }
+
+  llvm_unreachable("unknown Die tag");
+}
+
+// \returns value of indention depending on \p Depth.
+static uint32_t getTypeCompatDumpIndent(unsigned Depth) {
+  return Depth * 2 + 3;
+}
+
+// Dump location list.
+static void dumpTypeCompatLocationList(raw_ostream &OS,
+                                       const DWARFFormValue &FormValue,
+                                       DWARFUnit *Unit, unsigned Depth) {
+  assert(FormValue.isFormClass(DWARFFormValue::FC_SectionOffset) &&
+         "bad FORM for location list");
+  DWARFContext &Ctx = Unit->getContext();
+  const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
+  uint64_t Offset = *FormValue.getAsSectionOffset();
+
+  if (FormValue.getForm() == dwarf::DW_FORM_loclistx) {
+    if (auto LoclistOffset = Unit->getLoclistOffset(Offset))
+      Offset = *LoclistOffset;
+    else
+      return;
+  }
+
+  Unit->getLocationTable().dumpLocationList(
+      &Offset, OS, Unit->getBaseAddress(), MRI, Ctx.getDWARFObj(), Unit,
+      DIDumpOptions(), getTypeCompatDumpIndent(Depth), false);
+}
+
+// Dump address ranges.
+static void dumpTypeCompatRanges(raw_ostream &OS, const DWARFDie &Die,
+                                 DWARFUnit *Unit, unsigned Depth) {
+  Expected<DWARFAddressRangesVector> RangesOrError = Die.getAddressRanges();
+  if (!RangesOrError) {
+    OS << '\n';
+    OS.indent(getTypeCompatDumpIndent(Depth) + 2);
+    OS << "decoding address ranges: " << toString(RangesOrError.takeError());
+    return;
+  }
+
+  // TODO: combine overlapped address ranges.
+  for (const DWARFAddressRange &R : *RangesOrError) {
+    OS << '\n';
+    OS.indent(getTypeCompatDumpIndent(Depth) + 2);
+
+    R.dump(OS, Unit->getAddressByteSize(), DIDumpOptions(), nullptr);
+  }
+}
+
+// Dump location expression.
+static void dumpTypeCompatLocationExpr(raw_ostream &OS,
+                                       const DWARFFormValue &FormValue,
+                                       DWARFUnit *Unit) {
+  assert((FormValue.isFormClass(DWARFFormValue::FC_Block) ||
+          FormValue.isFormClass(DWARFFormValue::FC_Exprloc)) &&
+         "bad FORM for location expression");
+  DWARFContext &Ctx = Unit->getContext();
+  const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
+  ArrayRef<uint8_t> Expr = *FormValue.getAsBlock();
+  DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
+                     Ctx.isLittleEndian(), 0);
+  DWARFExpression(Data, Unit->getAddressByteSize(),
+                  Unit->getFormParams().Format)
+      .print(OS, DIDumpOptions(), MRI, Unit);
+}
+
+// Dump Die attribute.
+static void dumpTypeCompatAttribute(raw_ostream &OS, const DWARFDie &Die,
+                                    const DWARFAttribute &AttrValue,
+                                    unsigned Depth) {
+  dwarf::Attribute Attr = AttrValue.Attr;
+  const DWARFFormValue &FormValue = AttrValue.Value;
+  DWARFUnit *Unit = Die.getDwarfUnit();
+  if (Unit == nullptr)
+    return;
+
+  if (Attr == dwarf::DW_AT_sibling || Attr == dwarf::DW_AT_loclists_base ||
+      Attr == dwarf::DW_AT_rnglists_base ||
+      Attr == dwarf::DW_AT_str_offsets_base || Attr == dwarf::DW_AT_addr_base)
+    // Skip attribute.
+    return;
+
+  OS << "\n";
+  OS.indent(getTypeCompatDumpIndent(Depth));
+  WithColor(OS, HighlightColor::Attribute) << formatv("{0} ", Attr);
+
+  switch (Attr) {
+  case dwarf::DW_AT_object_pointer:
+  case dwarf::DW_AT_specification:
+  case dwarf::DW_AT_abstract_origin:
+  case dwarf::DW_AT_import:
+    if (DWARFDie ReferencedDie =
+            Die.getAttributeValueAsReferencedDie(FormValue)) {
+      if (const char *Name = ReferencedDie.getLinkageName())
+        OS << "\"" << Name << "\"";
+      else {
+        if (const char *Name = ReferencedDie.getShortName())
+          OS << "\"" << Name << "\"";
+        else
+          OS << "None";
+
+        if (llvm::Optional<DWARFFormValue> TypeRef =
+                ReferencedDie.find(dwarf::DW_AT_type)) {
+          OS << ": ";
+          if (DWARFDie TypeDie =
+                  Die.getAttributeValueAsReferencedDie(*TypeRef)) {
+            OS << '"';
+            dumpTypeQualifiedName(TypeDie, OS);
+            OS << '"';
+          }
+        }
+      }
+    }
+    break;
+
+  case dwarf::DW_AT_type:
+  case dwarf::DW_AT_containing_type:
+    if (DWARFDie TypeDie = Die.getAttributeValueAsReferencedDie(FormValue)) {
+      OS << '"';
+      dumpTypeQualifiedName(TypeDie, OS);
+      OS << '"';
+    }
+    break;
+
+  case dwarf::DW_AT_ranges:
+    dumpTypeCompatRanges(OS, Die, Unit, Depth);
+    break;
+
+  case dwarf::DW_AT_high_pc:
+    uint64_t LowPC, HighPC, Index;
+    if (Die.getLowAndHighPC(LowPC, HighPC, Index))
+      DWARFFormValue::dumpAddress(OS, Unit->getAddressByteSize(), HighPC);
+    else
+      FormValue.dump(OS);
+    break;
+
+  case dwarf::DW_AT_accessibility:
+  case dwarf::DW_AT_virtuality:
+  case dwarf::DW_AT_language:
+  case dwarf::DW_AT_encoding:
+  case dwarf::DW_AT_decimal_sign:
+  case dwarf::DW_AT_endianity:
+  case dwarf::DW_AT_visibility:
+  case dwarf::DW_AT_identifier_case:
+  case dwarf::DW_AT_calling_convention:
+  case dwarf::DW_AT_inline:
+  case dwarf::DW_AT_ordering:
+  case dwarf::DW_AT_APPLE_runtime_class:
+  case dwarf::DW_AT_defaulted:
+    if (llvm::Optional<uint64_t> Value =
+            AttrValue.Value.getAsUnsignedConstant())
+      OS << dwarf::AttributeValueString(Attr, *Value);
+    else
+      OS << "None";
+    break;
+
+  case dwarf::DW_AT_decl_file:
+  case dwarf::DW_AT_call_file: {
+    std::string File;
+    if (const auto *LT = Unit->getContext().getLineTableForUnit(Unit))
+      if (LT->getFileNameByIndex(
+              FormValue.getAsUnsignedConstant().getValue(),
+              Unit->getCompilationDir(),
+              DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) {
+        OS << '"' << File << '"';
+      }
+  } break;
+
+  default:
+    if (DWARFAttribute::mayHaveLocationList(Attr) &&
+        FormValue.isFormClass(DWARFFormValue::FC_SectionOffset))
+      dumpTypeCompatLocationList(OS, FormValue, Unit, Depth * 2 + 4);
+    else if (FormValue.isFormClass(DWARFFormValue::FC_Exprloc) ||
+             (DWARFAttribute::mayHaveLocationExpr(Attr) &&
+              FormValue.isFormClass(DWARFFormValue::FC_Block)))
+      dumpTypeCompatLocationExpr(OS, FormValue, Unit);
+    else
+      FormValue.dump(OS);
+
+    break;
+  };
+}
+
+// Dump \p Die recursively.
+static void dumpTypeCompatDie(raw_ostream &OS, const DWARFDie &Die,
+                              unsigned Depth) {
+  if (!Die.isValid())
+    return;
+
+  if (!shouldBePrintedByTypeCompatDump(Die))
+    return;
+
+  OS << '\n';
+  WithColor(OS, HighlightColor::Tag).get().indent(Depth * 2)
+      << formatv("== {0} [{1}]", Die.getTag(), Depth);
+
+  // Dump DIEs attributes.
+  for (const DWARFAttribute &AttrValue : Die.attributes())
+    dumpTypeCompatAttribute(OS, Die, AttrValue, Depth);
+
+  OS << '\n';
+  for (DWARFDie Child = Die.getFirstChild(); Child; Child = Child.getSibling())
+    dumpTypeCompatDie(OS, Child, Depth + 1);
+}
+
+// The typeCompatDump prints incoming DWARF in such a way that it
+// tolerant to type dies order and amount, dies offsets, strings order.
+// It allows to compare dumps if they are semantically correct but differ
+// in binary contents. f.e. it is possible to compare DWARF file built
+// with odr deduplication and without(typeCompatDump should generate
+// equal result for both cases).
+static bool typeCompatDump(ObjectFile &Obj, DWARFContext &DICtx,
+                           const Twine &Filename, raw_ostream &Stream) {
+  raw_ostream &OS = Quiet ? nulls() : Stream;
+  OS << "type compatibility dump.\n\n"
+     << "'" << Filename.str() << "'"
+     << ", file format " << Obj.getFileFormatName() << ":\n\n";
+
+  for (std::unique_ptr<DWARFUnit> &CU : DICtx.normal_units())
+    dumpTypeCompatDie(OS, CU->getUnitDIE(false), 0);
+
+  return true;
+}
+
 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
                          HandlerFn HandleObj, raw_ostream &OS);
 
 static bool handleArchive(StringRef Filename, Archive &Arch,
                           HandlerFn HandleObj, raw_ostream &OS) {
   bool Result = true;
   Error Err = Error::success();
   for (auto Child : Arch.children(Err)) {
if (Verify) {
     for (auto Object : Objects)
       Success &= handleFile(Object, verifyObjectFile, OutputFile.os());
   } else if (Statistics) {
     for (auto Object : Objects)
       Success &= handleFile(Object, collectStatsForObjectFile, OutputFile.os());
   } else if (ShowSectionSizes) {
     for (auto Object : Objects)
       Success &= handleFile(Object, collectObjectSectionSizes, OutputFile.os());
+  } else if (TypeCompatDump) {
+    for (auto Object : Objects)
+      Success &= handleFile(Object, typeCompatDump, OutputFile.os());
   } else {
     for (auto Object : Objects)
       Success &= handleFile(Object, dumpObjectFile, OutputFile.os());
   }
 
   return Success ? EXIT_SUCCESS : EXIT_FAILURE;
 }