[DWARFv5] Support FORM_strp in the line table header

[probinson]

Summary

This mainly required teaching DWARFFormValue to use relocations for a
section other than .debug_info (i.e., .debug_line). Also the version
and 32/64-bit format might be different for the .debug_line section.

[probinson]

It turns out that the dumper doesn't visibly distinguish between in-line strings and referenced strings when it dumps the V5 line-table header. I think I can get that, but it should be a separate follow-up.

I am also thinking that in another follow-up, in DWARFDebugLine.cpp the static helpers to parse the different headers should become private methods. Then they can lose about half their parameters because they are class data members.

Let me know if you think these are bad ideas.

[aprantl]

lib/DebugInfo/DWARF/DWARFFormValue.cpp

67

I found the FV a bit hard to parse... DWARFUnitProxy, maybe?

71

Are these methods used anywhere? (Or will that come later?)

[probinson]

lib/DebugInfo/DWARF/DWARFFormValue.cpp

67

It's specific to DWARFFormValue, which is why I stuck with the FV.
But maybe that's not important, and DWARFUnitProxy would be okay.

71

They are used now (e.g. in getAsCString). The old helper class didn't need them because the old helper class was used only in getFixedByteSize() and skipFormValue(). But the new helper is used in places where it used to call the Unit methods directly, so it needs all these.

[probinson]

Rename DWARFFVUnit -> DWARFUnitProxy.
DRY when figuring out the format to use.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

86

My best guess is that sizeof(DWARFFormValue) isn't so important this needs to be indirected. It looks like most/all DWARFFormValues are transient, when some code is visiting the current attribute or form - I don't see code manifesting in a container "all forms/attributes for a DIE" for example (nor all attributes/forms in an entire file, etc).

So maybe having this as a value member, rather than a shared_ptr would reduce complexity?

Also - while I understand it's convenient to wrap DWARFUnit in the proxy so existing code doesn't need to be touched, I'm not sure it's that much of an improvement in readability - but I could be wrong - compared to having a few members and using those directly? (indeed most code still wouldn't change because it could use the DWARFUnit *U that was there before/would remain - and a few places would use the few extra new state/variables)

106–114

Feel free to commit changes like this separately, without pre-commit review. Keeps patches small/targeted/easier to review/revert, etc.

111

Does the LLVM style guide say to document all parameters? (I guess the clang doxy warnings flag things like this if they're not document?)

It'd be nice if there were a tidier way to just say "there's nothing to add here" - because I don't think "The DataExtractor to use" really adds anything compared to what the generated documentation or function signature already has.

lib/DebugInfo/DWARF/DWARFContext.cpp

193–197

Guessing this probably isn't right for DWP files? Or potentially for a DWO containing multiple CUs that might have different CU properties that are relevant to the line table?

Though that's perhaps an interesting question - since a DWO line table is just for type units, the CU won't have a reference to any line.dwo section, and multiple DWO TUs might refer to the same line table, I think? (I think LLVM produces only one, but I forget - it's been awhile since I implemented taht) so you'd want to pick one of the DWO TUs that references this line table to use here?

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

143–144

I know DWARF64 support is starting to be considered in a few places - but is this tested?

lib/DebugInfo/DWARF/DWARFFormValue.cpp

84

avoid branch-to-unreachable, instead "assert(U)" at the start of the function (similarly for other cases above/in this patch)

[probinson]

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

86

You have touched on a couple of different things here.

Using a value member instead of shared_ptr seems fine, it would make the diff a whole lot longer but most of the extra changes would be replacing U->foo with U.foo.

Yes we could build a helper class that has value members with all the right info. But then we are paying some nonzero cost to extract/compute those values (e.g., size of a ref-addr) when constructing the class, but most of the time we won't actually need all that. And remember that with all the new indirection in v5, we are talking about handles on quite a few different sections that we'd need to copy over into the new helper, on the off chance that we'd need them. Or make the constructor a lot more complicated, smart enough to work out which pieces it needs based on the Form...

If we really wanted to get radical, DWARFFormValue should be handed the DWARFContext rather than the DWARFUnit, along with the few bits of unit-specific info (32/64 format, version, address size). Then we query the context as needed, instead of the unit. That minimizes copying while retaining the unit/line-table flexibility.

I'm open to suggestions.

111

Seems to me I did get warnings or something when not all parameters were documents.
If you want to propose a "nothing to see here" case in the coding standard, knock yourself out.

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

143–144

Huh. No, I missed that, I will add a test.
IMHO it would not be the end of the world for the dumpers to be able to handle DWARF64. The day will likely come when somebody really can't work around the lack.

lib/DebugInfo/DWARF/DWARFFormValue.cpp

84

Hmm so a release build would get a seg fault instead of a more intelligent error? I can do what you said but an actual diagnostic instead of a seg fault seems pretty cheap.

[probinson]

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

106–114

r303214.

[probinson]

lib/DebugInfo/DWARF/DWARFContext.cpp

193–197

There are no CU properties relevant to a DWO v5 line table. The only reason we need a CU is because it is a convenient way to relay handles on the other sections that a v5 line table header might need (.debug_str etc). So it doesn't matter whether the CU is related to the line table.

It's quite easy to argue that, therefore, we shouldn't pass a CU down at all, but something else that provides the same information. I thought about that for a while, and decided that if we do go that route then probably it should be done as a separate commit, because all the existing APIs are expecting a CU.
What do you think?

[dblaikie]

lib/DebugInfo/DWARF/DWARFContext.cpp

193–197

Ah, right - well, given the point was to make debug_line standalone, easier to preserve while stripping other things (if I recall/understand correctly) that seems like a good goal. It should be possible to dump a file that doesn't contain a debug_info section/any CUs and only line tables/debug_str/etc.

As for ordering - I'm not too fussed either way. I'd probably/ideally have staged the work to separate the needed properties out of the CU abstractions first, but since we're here I can't see any reason to make that a necessity for this work.

[probinson]

Make the helper class be copyable values rather than a shared_ptr.
Add a test for DWARF-64 line-table header.
Use assert() instead of unreachable in some cases.

[probinson]

I'd probably/ideally have staged the work to separate the needed properties out of the CU abstractions first,

Yeah, well, I didn't come to terms with that direction until I was really pretty invested in this piece. But hey, if I knew what the endpoint was up front, it wouldn't be iterative development.
Sadly, what has struck me just this minute (after posting the diff of course) is that what's currently the nested FormValueInfo class is probably going to have to be factored out on its own so callers can DTRT and then hand over a constructed helper to DWARFFormValue. Oh well.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

42

= default

58–66

I'd consider keeping the ctors, dropping these Init functions, and where you have:

x.Init(...);

use:

x = FormValueInfo(...);

perhaps? since it's simple to copy/move, etc. Seems like less API surface, surprises (no/less chance that Init leaves some stale state, etc), etc :)

86

The other point I was making here was that maybe the members of FormValueInfo could be members of DWARFFormValue directly.

I see there are a few cases where FormValueInfo objects are constructed separately from a DWARFFormValue - but they're all /inside/ a DWARFFormValue member function if I'm not mistaken. Why are those cases not using the FormValueInfo in the DWARFFormValue they're a member of?

[probinson]

FYI I'm away at a conference next week and I might not get back to this until the week after.

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

86

Those cases are static member functions.

it sounds like you would prefer each method to have several overloads for the different use-cases. I was thinking that FormValueInfo could be factored out into an independent class, constructed by the caller and then passed in, reducing the DWARFFormValue API surface (as there could be simply one copy of skipValue and getFixedByteSize instead of several of each).

[dblaikie]

In D33155#759961, @probinson wrote:

FYI I'm away at a conference next week and I might not get back to this until the week after.

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

58–66

Still curious about this.

Also this class doesn't seem to provide any encapsulation, so it's weird that it has init/ctor like behavior - since there's no invariants that can be held, etc. Should it have a narrower surface area? Or maybe wider - perhaps a couple of functions that return this struct? With names that make clear their use case (the two different ways of using this function that represent different situations, etc)? Will those use cases be unified in some way?

Sorry, I'm still a bit fuzzy on the details/goals/end state.

86

I'm not sure what I'd prefer - mostly trying to understand the current motivations/use cases/etc. Thanks for pointing out/explaining the details.

With regard to one function that takes a struct and behaves differently depending on the struct, versus two functions that behave differently/have different parameters:

I'd tend to prefer not to make a decision dynamic when it's static (ie: if all the callers know, statically, which behavior they want - no need to make the caller do dynamic work (yeah, the inliner can fix this, but from a legibility standpoint too, it seems simpler)). But this doesn't always apply - if the callee does mostly common work and somewhere deep inside does one of two different things based on those callers, then yeah, it may make sense to have a single function with some kind of dynamic parameter.

[probinson]

Sorry, I'm still a bit fuzzy on the details/goals/end state.

Yes, well. DWARFFormValue is a bit slippery, partly because forms are a bit slippery, and partly because it seems DWARFFormValue was a convenient place to stuff miscellaneous and not entirely related queries about forms.

Users of DWARFFormValue tend to want one of three things: (a) the data value described by the form, as extracted from a DataExtractor, and possibly from another section; (b) the *size* of the data value described by the form, because they want to skip over it; or (c) whether the size of a data value that *could* be described by the form is fixed-size, and if so, what size is that. The latter case comes up when parsing an abbrev table on its own, some consumers like to know ahead of time which abbrevs describe DIEs that are fixed-size and how big those are.

This gets trickier because sometimes the data value depends on external information (e.g. relocations) and sometimes the data value has a fixed size but that size depends on external information (e.g. the DWARF version or 32/64 format). Up through DWARF v4, all of that external information was available through the relevant DWARFUnit, because forms always described data from a Unit, and so passing a DWARFUnit pointer in to various methods was enough to hide all the details about bits and pieces from the callers.

Now in DWARF v5, forms become even more exciting, because sometimes the data value depends on even more external information (e.g. yet another object-file section such as the string-offset section or the address table). And when we are looking at forms describing information in the .debug_line section, the DWARF version and 32/64 format come from the line-table header not the Unit, and the relevant relocations are .debug_line relocations not .debug_info relocations. When we're dumping a .debug_line section in dwarfdump, really we shouldn't be relying on a Unit at all.

So, I am trying to package up the information that DWARFFormValue needs in order to answer the various queries that it gets, without DWARFFormValue itself needing to understand whether it is looking at .debug_info or .debug_line (it should be given the relevant info by its callers), and without making DWARFFormValue's API look too ridiculous.

[probinson]

Provide DWARFDebugLine parsers with the DWARFContext, not just a relocation map.
Add a second overload of DWARFFormValue::extractValue() for use by the line-table parser; both overloads call a common private implementation.
This allows the v5 line-table header to use DW_FORM_strp.

[probinson]

Ping.

[dblaikie]

In D33155#775734, @probinson wrote:

Sorry, I'm still a bit fuzzy on the details/goals/end state.

Yes, well. DWARFFormValue is a bit slippery, partly because forms are a bit slippery, and partly because it seems DWARFFormValue was a convenient place to stuff miscellaneous and not entirely related queries about forms.

Users of DWARFFormValue tend to want one of three things: (a) the data value described by the form, as extracted from a DataExtractor, and possibly from another section; (b) the *size* of the data value described by the form, because they want to skip over it; or (c) whether the size of a data value that *could* be described by the form is fixed-size, and if so, what size is that. The latter case comes up when parsing an abbrev table on its own, some consumers like to know ahead of time which abbrevs describe DIEs that are fixed-size and how big those are.

This gets trickier because sometimes the data value depends on external information (e.g. relocations) and sometimes the data value has a fixed size but that size depends on external information (e.g. the DWARF version or 32/64 format). Up through DWARF v4, all of that external information was available through the relevant DWARFUnit, because forms always described data from a Unit, and so passing a DWARFUnit pointer in to various methods was enough to hide all the details about bits and pieces from the callers.

Now in DWARF v5, forms become even more exciting, because sometimes the data value depends on even more external information (e.g. yet another object-file section such as the string-offset section or the address table). And when we are looking at forms describing information in the .debug_line section, the DWARF version and 32/64 format come from the line-table header not the Unit, and the relevant relocations are .debug_line relocations not .debug_info relocations. When we're dumping a .debug_line section in dwarfdump, really we shouldn't be relying on a Unit at all.

So, I am trying to package up the information that DWARFFormValue needs in order to answer the various queries that it gets, without DWARFFormValue itself needing to understand whether it is looking at .debug_info or .debug_line (it should be given the relevant info by its callers), and without making DWARFFormValue's API look too ridiculous.

Ah, right, thanks for explaining/refreshing all that.

seems like anywhere that still has a DWARFCompileUnit in the DWARFFormValue is a possible bug waiting to happen for non-Unit uses of forms? I think it'd be good to port it all over so it's not in this hybrid/partially supported state. Perhaps the best thing would be if FormSizeHelper (hmm, wonder if there's a better name for that) had an implicit ctor from DWARFCompileUnit so DWARFFormValue could have one API in terms of FormSizeHelper only & callers can either construct the pieces they need, or have it constructed from a DWARFCompileUnit.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

333 ↗

(On Diff #102212)

Maybe reverse this to reduce indentation/early exit:

if (!CU)
  return extractValueImpl(Data, OffsetPtr, nullptr);
U = CU;
...

334 ↗

(On Diff #102212)

The existence of this 'U' member makes it look like the dumping and other code may not work? Since the FormSizeHelper infrastructure won't be used in those cases. That seems problematic/inconsistent.

655–658 ↗

(On Diff #102212)

This sort of fallback seems error prone or confusing. Are there cases where the first part is necessary? If so, it seems like there would be places where the second/new part is incorrect?

[probinson]

I'm not super excited about the hybrid form, but always unpacking a Unit inside the DWARFFormValue methods felt kind of expensive.

I have, over the weeks, contemplated inventing a fake kind of Unit for the line table, which would have all the Right Stuff in it to let DWARFFormValue do its thing. This of course is getting away from the hybrid in the opposite way--make callers provide a Unit-like object, instead of making most callers unpack a Unit into some other kind of info/helper class. Building a fake Unit feels a little icky, and I think might not be especially cheap, but as it's only once per line-table it might be okay... I've been resisting it because a line table is-not-a Unit, what is your opinion? (Am I making sense?)

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

655–658 ↗

(On Diff #102212)

I had discovered that the first part is necessary for .dwo cases (~10 tests), because of things like .debug_types.dwo wanting to get its strings from .debug_str.dwo not .debug_str, and so forth. The dumper constructs a Unit that has either the .dwo or non-.dwo section handles in it, so that getStringExtractor will point to the correct section. I can't get that directly out of the Context unless DWARFFormValue knows a whole lot more about its environment than I would really like.

[probinson]

See D34570, which packages the version/address-size/format and puts the query methods in one place. DWARFUnit and DWARFDebugLine use the new class as a data member, as suggested by @dblaikie. I'll update this patch again after that one's resolved.

[probinson]

By passing a DWARFUnit into the line-table parser (if we have one), we allow it to handle indirect string forms, which require finding other sections. Previously the line-table parser couldn't do that (and didn't need to, prior to v5).
By passing DWARFFormParams to DWARFFormValue::extractValue() separately from the DWARFUnit, we allow interpreting forms according to the line-table's version/format, which could be different from the Unit's version/format.

This doesn't do the .dwo part yet, I'd like to leave that for a follow-up.

[ruiu]

lld/ELF/InputFiles.cpp

80–83 ↗

(On Diff #120642)

I don't fully understand this change, but it seems like if it was working before, Dwarf.getNumCompileUnits() >0 is guaranteed, no?

[aprantl]

llvm/test/DebugInfo/Inputs/dwarfdump-header-64.s

7 ↗

(On Diff #120642)

Why do we need/want to check in the binary? Could it just be generated on the fly?

It looks like this assembler file may be general enough to also assemble for am x86_64-apple-darwin triple so we could test Mach-O support, too?

[probinson]

lld/ELF/InputFiles.cpp

80–83 ↗

(On Diff #120642)

No. If you have no debug info, getNumCompileUnits() == 0, but we still go through this path. When we discover there's no debug info, lld falls back to using FILE symbols instead.
That said, I don't have an lld test for retrieving filespecs from a DWARF v5 line table, so we could hardcode it to nullptr for now and leave a FIXME.

llvm/test/DebugInfo/Inputs/dwarfdump-header-64.s

7 ↗

(On Diff #120642)

I thought checked-in binaries were usual; for example the DWARF32 version of the test is a checked-in binary. Generating the binary on the fly has a small test-time performance cost.
I don't actually know if Mach-O would be okay with this, because section names? I'm happy to do it that way if there's a coverage benefit. I'll play with it and see what happens.

[aprantl]

llvm/test/DebugInfo/Inputs/dwarfdump-header-64.s

7 ↗

(On Diff #120642)

We don't have a clear policy for binary files. My opinion is that we should avoid binaries where a sufficiently reliable alternative exists, to make it easier to modify and maintain testcases in the future. So unless we need to become independent from variability introduced by llvm-mc, I think just checking in the assembler sources is the way to go. A counterexample for when binaries are necessary are the LLVM bitcode compatibility tests.

For completeness: another alternative is yam2obj, but it is even more low-level than assembler and in my experience too verbose for DWARF tests.

because section names?

Good point, I forgot about those. Half-serious: we could run the C preprocessor over the assembler file to support alternate section names guarded by #ifdefs.

[probinson]

llvm/test/DebugInfo/Inputs/dwarfdump-header-64.s

7 ↗

(On Diff #120642)

I am pretty sure that with a checked-in binary, you don't need to build the right target architecture to be able to dump it. For sure assembling the file at test time will depend on having llvm-mc built with the correct target. But overall I think being able to show the cross-section stuff works for both Mach-O and ELF is probably more important than being able to run an ELF-only test on bots that don't build X86. So I will proceed with trying to find a reasonable way to make the assembly source work for both ELF and Mach-O.

[aprantl]

Thanks, that sounds great! As far as I know there are only very few bots that don't build the X86 backend at the moment so I wouldn't be too concerned about that.

[probinson]

Make the new test work for both ELF and Mach-O.
Simplify LLD change to never pass a Unit, as there's no test for it yet.

[probinson]

Ping.

I left the existing test (dwarfdump-header.s) as a checked-in binary, because it tests both normal and split headers, and I don't know what MachO section names to use for the .dwo sections. My intuition is that MachO will never bother supporting split DWARF so maybe it's fine to leave it as is. If somebody does want me to convert the test, I'll need a list of section names to use, and I would do it as a follow-up. Just thought I'd put that out there.

[aprantl]

Thanks for converting the other testcase.

I left the existing test (dwarfdump-header.s) as a checked-in binary, because it tests both normal and split headers, and I don't know what MachO section names to use for the .dwo sections.

There is no need to test split DWARF + MachO since that combination is neither tested nor specified anywhere.

Why can't the other test be ELF-only assembler though? Otherwise this LGTM now.

llvm/test/DebugInfo/X86/dwarfdump-header-64.s

18 ↗

(On Diff #121087)

Nice, thank you!

[probinson]

In D33155#918127, @aprantl wrote:

Why can't the other test be ELF-only assembler though?

It can, I will convert it as a follow-up. Thanks!

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

 #include "llvm/Support/DataExtractor.h"
 #include <cstdint>
 #include <map>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
+class DWARFUnit;
 class raw_ostream;
 
 class DWARFDebugLine {
 public:
   DWARFDebugLine(const RelocAddrMap *LineInfoRelocMap)
       : RelocMap(LineInfoRelocMap) {}
 
   struct FileNameEntry {
struct Prologue {
     }
 
     int32_t getMaxLineIncrementForSpecialOpcode() const {
       return LineBase + (int8_t)LineRange - 1;
     }
 
     void clear();
     void dump(raw_ostream &OS) const;
-    bool parse(DataExtractor DebugLineData, uint32_t *OffsetPtr);
+    bool parse(DataExtractor DebugLineData, uint32_t *OffsetPtr,
+               const DWARFUnit *U, const RelocAddrMap *RMap = nullptr);
   };
 
   /// Standard .debug_line state machine structure.
   struct Row {
     explicit Row(bool DefaultIsStmt = false);
 
     /// Called after a row is appended to the matrix.
     void postAppend();
bool getFileLineInfoForAddress(uint64_t Address, const char *CompDir,
                                    DILineInfoSpecifier::FileLineInfoKind Kind,
                                    DILineInfo &Result) const;
 
     void dump(raw_ostream &OS) const;
     void clear();
 
     /// Parse prologue and all rows.
     bool parse(DataExtractor DebugLineData, const RelocAddrMap *RMap,
-               uint32_t *OffsetPtr);
+               uint32_t *OffsetPtr, const DWARFUnit *U);
 
     struct Prologue Prologue;
     typedef std::vector<Row> RowVector;
     typedef RowVector::const_iterator RowIter;
     typedef std::vector<Sequence> SequenceVector;
     typedef SequenceVector::const_iterator SequenceIter;
     RowVector Rows;
     SequenceVector Sequences;
 
   private:
     uint32_t findRowInSeq(const DWARFDebugLine::Sequence &Seq,
                           uint64_t Address) const;
   };
 
   const LineTable *getLineTable(uint32_t Offset) const;
   const LineTable *getOrParseLineTable(DataExtractor DebugLineData,
-                                       uint32_t Offset);
+                                       uint32_t Offset, const DWARFUnit *U);
 
 private:
   struct ParsingState {
     ParsingState(struct LineTable *LT);
 
     void resetRowAndSequence();
     void appendRowToMatrix(uint32_t Offset);
 

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

 //===- DWARFFormValue.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFFORMVALUE_H
 #define LLVM_DEBUGINFO_DWARFFORMVALUE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Dwarf.h"
 #include <cstdint>
 
 namespace llvm {
 
 class DWARFUnit;
 class raw_ostream;
 
 class DWARFFormValue {
 public:
   enum FormClass {
     FC_Unknown,
     FC_Address,
     FC_Block,
     FC_Constant,
     FC_String,
     FC_Flag,
     FC_Reference,
     FC_Indirect,
     FC_SectionOffset,
     FC_Exprloc
   };
 
+  struct FormValueInfo {
+    FormValueInfo() {}
+    FormValueInfo(const DWARFUnit *U) { Init(U); }
+    FormValueInfo(uint16_t Ver, uint8_t AddrByteSize, bool IsDwarf64) {
+      Init(nullptr, nullptr, Ver, AddrByteSize, IsDwarf64);
+    }
+    FormValueInfo(const DWARFUnit *U, const RelocAddrMap *RMap, uint16_t Ver,
+                  uint8_t AddrByteSize, bool IsDwarf64) {
+      Init(U, RMap, Ver, AddrByteSize, IsDwarf64);
+    }
+
+    const DWARFUnit *Unit = nullptr;
+    const RelocAddrMap *RelocMap = nullptr;
+    uint16_t Version = 0;
+    uint8_t AddrSize = 0;
+    uint8_t OffsetSize = 0;
+
+    void Init(const DWARFUnit *U);
+    void Init(const DWARFUnit *U, const RelocAddrMap *RMap, uint16_t Ver,
+              uint8_t AddrByteSize, bool IsDwarf64) {
+      Unit = U;
+      RelocMap = RMap;
+      Version = Ver;
+      AddrSize = AddrByteSize;
+      OffsetSize = IsDwarf64 ? 8 : 4;
+    }
+    uint8_t getRefAddrByteSize() const {
+      return Version == 2 ? AddrSize : OffsetSize;
+    }
+  };
+
 private:
   struct ValueType {
     ValueType() { uval = 0; }
 
     union {
       uint64_t uval;
       int64_t sval;
       const char *cstr;
     };
     const uint8_t *data = nullptr;
   };
 
   dwarf::Form Form;             // Form for this value.
   ValueType Value;              // Contains all data for the form.
-  const DWARFUnit *U = nullptr; // Remember the DWARFUnit at extract time.
+  FormValueInfo Info;           // Info useful during extraction.
 
 public:
   DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F) {}
 
   dwarf::Form getForm() const { return Form; }
   uint64_t getRawUValue() const { return Value.uval; }
   void setForm(dwarf::Form F) { Form = F; }
   void setUValue(uint64_t V) { Value.uval = V; }
   void setSValue(int64_t V) { Value.sval = V; }
   void setPValue(const char *V) { Value.cstr = V; }
 
   void setBlockValue(const ArrayRef<uint8_t> &Data) {
     Value.data = Data.data();
     setUValue(Data.size());
   }
 
   bool isFormClass(FormClass FC) const;
-  const DWARFUnit *getUnit() const { return U; }
   void dump(raw_ostream &OS) const;
 
   /// Extracts a value in \p Data at offset \p *OffsetPtr.
   ///
   /// The passed DWARFUnit is allowed to be nullptr, in which
   /// case no relocation processing will be performed and some
   /// kind of forms that depend on Unit information are disallowed.
   /// \param Data The DataExtractor to use.
   /// \param OffsetPtr The offset within DataExtractor where the data starts.
   /// \param U The optional DWARFUnit supplying information for some forms.
   /// \returns whether the extraction succeeded.
   bool extractValue(const DataExtractor &Data, uint32_t *OffsetPtr,
                     const DWARFUnit *U);
 
+  /// Extracts a value in \p Data at offset \p *OffsetPtr, from a section
+  /// other than .debug_info (e.g., .debug_line).
+  ///
+  /// The passed DWARFUnit mainly provides information about other sections
+  /// that might be needed for reference or indirect forms.  Additional
+  /// parameters specify the relocations, DWARF format, and DWARF version to
+  /// use for interpreting certain forms.
+  /// \param Data The DataExtractor to use.
+  /// \param OffsetPtr The offset within DataExtractor where the data starts.
+  /// \param U The DWARFUnit supplying information about other sections.
+  /// \param RM The relocations for the section referenced by \p Data.
+  /// \param Format DWARF format (32-bit or 64-bit).
+  /// \param Version DWARF version number.
+  /// \returns whether the extraction succeeded.
+  bool extractValue(const DataExtractor &Data, uint32_t *OffsetPtr,
+                    const DWARFUnit *U, const RelocAddrMap *RM,
+                    uint16_t Version, uint8_t AddrSize, bool IsDwarf64);
+
   bool isInlinedCStr() const {
     return Value.data != nullptr && Value.data == (const uint8_t *)Value.cstr;
   }
 
   /// getAsFoo functions below return the extracted value as Foo if only
   /// DWARFFormValue has form class is suitable for representing Foo.
   Optional<uint64_t> getAsReference() const;
   Optional<uint64_t> getAsUnsignedConstant() const;
public:
   ///
   /// Skips the bytes for this form in the debug info and updates the offset.
   ///
   /// \param Form the DW_FORM enumeration that indicates the form to skip.
   /// \param DebugInfoData the .debug_info data to use to skip the value.
   /// \param OffsetPtr a reference to the offset that will be updated.
   /// \param Version DWARF version number.
   /// \param AddrSize size of an address in bytes.
-  /// \param Format enum value from llvm::dwarf::DwarfFormat.
+  /// \param IsDwarf64 which DWARF format.
   /// \returns true on success, false if the form was not skipped.
   static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
                         uint32_t *OffsetPtr, uint16_t Version, uint8_t AddrSize,
-                        llvm::dwarf::DwarfFormat Format);
+                        bool IsDwarf64);
+
+  /// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
+  ///
+  /// Skips the bytes for this form in a section other than .debug_info,
+  /// and updates the offset.
+  ///
+  /// \param Form the DW_FORM enumeration that indicates the form to skip.
+  /// \param DebugInfoData the .debug_info data to use to skip the value.
+  /// \param OffsetPtr a reference to the offset that will be updated.
+  /// \param DU a DWARFUnit describing other sections that might be needed.
+  /// \param RM relocations for the section used by \p DebugInfoData.
+  /// \param Version DWARF version number.
+  /// \param AddrSize size of an address in bytes.
+  /// \param IsDwarf64 which DWARF format.
+  /// \returns true on success, false if the form was not skipped.
+  bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
+                 const DWARFUnit *DU, const RelocAddrMap *RM, uint16_t Version,
+                 uint8_t AddrSize, bool IsDwarf64);
 
 private:
   void dumpString(raw_ostream &OS) const;
+  bool extractValueImpl(const DataExtractor &DebugInfoData,
+                        uint32_t *OffsetPtr);
 };
 
 namespace dwarf {
 
 /// Take an optional DWARFFormValue and try to extract a string value from it.
 ///
 /// \param V and optional DWARFFormValue to attempt to extract the value from.
 /// \returns an optional value that contains a value if the form value

lib/DebugInfo/DWARF/DWARFContext.cpp

for (const auto &CU : compile_units()) {
       auto CUDIE = CU->getUnitDIE();
       if (!CUDIE)
         continue;
       if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list))) {
         DataExtractor lineData(getLineSection().Data, isLittleEndian(),
                                savedAddressByteSize);
         DWARFDebugLine::LineTable LineTable;
         uint32_t Offset = *StmtOffset;
-        LineTable.parse(lineData, &getLineSection().Relocs, &Offset);
+        LineTable.parse(lineData, &getLineSection().Relocs, &Offset, &*CU);
         LineTable.dump(OS);
       }
     }
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_CUIndex) {
     OS << "\n.debug_cu_index contents:\n";
     getCUIndex().dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_TUIndex) {
     OS << "\n.debug_tu_index contents:\n";
     getTUIndex().dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_LineDwo) {
     OS << "\n.debug_line.dwo contents:\n";
     unsigned stmtOffset = 0;
     DataExtractor lineData(getLineDWOSection().Data, isLittleEndian(),
                            savedAddressByteSize);
     DWARFDebugLine::LineTable LineTable;
-    while (LineTable.Prologue.parse(lineData, &stmtOffset)) {
+    DWARFUnit *U = nullptr;
+    if (!CUs.empty())
+      U = &**CUs.begin();
+    while (LineTable.Prologue.parse(lineData, &stmtOffset, U)) {
       LineTable.dump(OS);
       LineTable.clear();
     }
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Str) {
     OS << "\n.debug_str contents:\n";
     DataExtractor strData(getStringSection(), isLittleEndian(), 0);
     offset = 0;
DWARFContext::getLineTableForUnit(DWARFUnit *U) {
 
   // Make sure the offset is good before we try to parse.
   if (stmtOffset >= U->getLineSection().size())
     return nullptr;  
 
   // We have to parse it first.
   DataExtractor lineData(U->getLineSection(), isLittleEndian(),
                          U->getAddressByteSize());
-  return Line->getOrParseLineTable(lineData, stmtOffset);
+  return Line->getOrParseLineTable(lineData, stmtOffset, U);
 }
 
 void DWARFContext::parseCompileUnits() {
   CUs.parse(*this, getInfoSection());
 }
 
 void DWARFContext::parseTypeUnits() {
   if (!TUs.empty())

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

if (Descriptor.Type == dwarf::DW_LNCT_path)
       HasPath = true;
     Descriptors.push_back(Descriptor);
   }
   return HasPath ? Descriptors : ContentDescriptors();
 }
 
 static bool
 parseV5DirFileTables(DataExtractor DebugLineData, uint32_t *OffsetPtr,
-                     uint64_t EndPrologueOffset,
-                     std::vector<StringRef> &IncludeDirectories,
+                     uint64_t EndPrologueOffset, const DWARFUnit *U,
+                     const RelocAddrMap *RM, uint16_t Version, uint8_t AddrSize,
+                     bool IsDwarf64, std::vector<StringRef> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   // Get the directory entry description.
   ContentDescriptors DirDescriptors =
     parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset);
   if (DirDescriptors.empty())
     return false;
 
   // Get the directory entries, according to the format described above.
   int DirEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != DirEntryCount; ++I) {
     if (*OffsetPtr >= EndPrologueOffset)
       return false;
     for (auto Descriptor : DirDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       switch (Descriptor.Type) {
       case DW_LNCT_path:
-        if (!Value.extractValue(DebugLineData, OffsetPtr, nullptr))
+        if (!Value.extractValue(DebugLineData, OffsetPtr, U, RM, Version,
+                                AddrSize, IsDwarf64))
           return false;
         IncludeDirectories.push_back(Value.getAsCString().getValue());
         break;
       default:
-        if (!Value.skipValue(DebugLineData, OffsetPtr, nullptr))
+        if (!Value.skipValue(DebugLineData, OffsetPtr, U, RM, Version, AddrSize,
+                             IsDwarf64))
           return false;
       }
     }
   }
 
   // Get the file entry description.
   ContentDescriptors FileDescriptors =
     parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset);
   if (FileDescriptors.empty())
     return false;
 
   // Get the file entries, according to the format described above.
   int FileEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != FileEntryCount; ++I) {
     if (*OffsetPtr >= EndPrologueOffset)
       return false;
     DWARFDebugLine::FileNameEntry FileEntry;
     for (auto Descriptor : FileDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
-      if (!Value.extractValue(DebugLineData, OffsetPtr, nullptr))
+      if (!Value.extractValue(DebugLineData, OffsetPtr, U, RM, Version,
+                              AddrSize, IsDwarf64))
         return false;
       switch (Descriptor.Type) {
       case DW_LNCT_path:
         FileEntry.Name = Value.getAsCString().getValue();
         break;
       case DW_LNCT_directory_index:
         FileEntry.DirIdx = Value.getAsUnsignedConstant().getValue();
         break;
for (auto Descriptor : FileDescriptors) {
       }
     }
     FileNames.push_back(FileEntry);
   }
   return true;
 }
 
 bool DWARFDebugLine::Prologue::parse(DataExtractor DebugLineData,
-                                     uint32_t *OffsetPtr) {
+                                     uint32_t *OffsetPtr, const DWARFUnit *U,
+                                     const RelocAddrMap *RM) {
   const uint64_t PrologueOffset = *OffsetPtr;
 
   clear();
   TotalLength = DebugLineData.getU32(OffsetPtr);
   if (TotalLength == UINT32_MAX) {
     IsDWARF64 = true;
     TotalLength = DebugLineData.getU64(OffsetPtr);
   } else if (TotalLength > 0xffffff00) {
bool DWARFDebugLine::Prologue::parse(DataExtractor DebugLineData,
 
   StandardOpcodeLengths.reserve(OpcodeBase - 1);
   for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
   if (Version >= 5) {
-    if (!parseV5DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
+    if (!parseV5DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset, U,
+                              RM, Version, AddressSize, IsDWARF64,
                               IncludeDirectories, FileNames)) {
       fprintf(stderr,
               "warning: parsing line table prologue at 0x%8.8" PRIx64
               " found an invalid directory or file table description at"
               " 0x%8.8" PRIx64 "\n", PrologueOffset, (uint64_t)*OffsetPtr);
       return false;
     }
   } else
DWARFDebugLine::getLineTable(uint32_t Offset) const {
   LineTableConstIter Pos = LineTableMap.find(Offset);
   if (Pos != LineTableMap.end())
     return &Pos->second;
   return nullptr;
 }
 
 const DWARFDebugLine::LineTable *
 DWARFDebugLine::getOrParseLineTable(DataExtractor DebugLineData,
-                                    uint32_t Offset) {
+                                    uint32_t Offset, const DWARFUnit *U) {
   std::pair<LineTableIter, bool> Pos =
       LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable()));
   LineTable *LT = &Pos.first->second;
   if (Pos.second) {
-    if (!LT->parse(DebugLineData, RelocMap, &Offset))
+    if (!LT->parse(DebugLineData, RelocMap, &Offset, U))
       return nullptr;
   }
   return LT;
 }
 
 bool DWARFDebugLine::LineTable::parse(DataExtractor DebugLineData,
                                       const RelocAddrMap *RMap,
-                                      uint32_t *OffsetPtr) {
+                                      uint32_t *OffsetPtr, const DWARFUnit *U) {
   const uint32_t DebugLineOffset = *OffsetPtr;
 
   clear();
 
-  if (!Prologue.parse(DebugLineData, OffsetPtr)) {
+  if (!Prologue.parse(DebugLineData, OffsetPtr, U, RMap)) {
     // Restore our offset and return false to indicate failure!
     *OffsetPtr = DebugLineOffset;
     return false;
   }
 
   const uint32_t EndOffset =
       DebugLineOffset + Prologue.TotalLength + Prologue.sizeofTotalLength();
 

lib/DebugInfo/DWARF/DWARFFormValue.cpp

static const DWARFFormValue::FormClass DWARF4FormClasses[] = {
     DWARFFormValue::FC_Reference,     // 0x14 DW_FORM_ref8
     DWARFFormValue::FC_Reference,     // 0x15 DW_FORM_ref_udata
     DWARFFormValue::FC_Indirect,      // 0x16 DW_FORM_indirect
     DWARFFormValue::FC_SectionOffset, // 0x17 DW_FORM_sec_offset
     DWARFFormValue::FC_Exprloc,       // 0x18 DW_FORM_exprloc
     DWARFFormValue::FC_Flag,          // 0x19 DW_FORM_flag_present
 };
 
-namespace {
+typedef DWARFFormValue::FormValueInfo FormValueInfo;
 
-/// A helper class that can be used in DWARFFormValue.cpp functions that need
-/// to know the byte size of DW_FORM values that vary in size depending on the
-/// DWARF version, address byte size, or DWARF32 or DWARF64.
-class FormSizeHelper {
-  uint16_t Version;
-  uint8_t AddrSize;
-  llvm::dwarf::DwarfFormat Format;
-
-public:
-  FormSizeHelper(uint16_t V, uint8_t A, llvm::dwarf::DwarfFormat F)
-      : Version(V), AddrSize(A), Format(F) {}
-
-  uint8_t getAddressByteSize() const { return AddrSize; }
-
-  uint8_t getRefAddrByteSize() const {
-    if (Version == 2)
-      return AddrSize;
-    return getDwarfOffsetByteSize();
-  }
-
-  uint8_t getDwarfOffsetByteSize() const {
-    switch (Format) {
-    case dwarf::DwarfFormat::DWARF32:
-      return 4;
-    case dwarf::DwarfFormat::DWARF64:
-      return 8;
-    }
-    llvm_unreachable("Invalid Format value");
-  }
-};
-
-} // end anonymous namespace
+void DWARFFormValue::FormValueInfo::Init(const DWARFUnit *U) {
+  if (U)
+    Init(U, U->getRelocMap(), U->getVersion(), U->getAddressByteSize(),
+         U->getFormat() == dwarf::DwarfFormat::DWARF64);
 
-template <class T>
-static Optional<uint8_t> getFixedByteSize(dwarf::Form Form, const T *U) {
+static Optional<uint8_t> getFixedByteSize(dwarf::Form Form,
+                                          const FormValueInfo *I) {
   switch (Form) {
   case DW_FORM_addr:
-    if (U)
-      return U->getAddressByteSize();
+    if (I)
+      return I->AddrSize;
     return None;
 
   case DW_FORM_block:          // ULEB128 length L followed by L bytes.
   case DW_FORM_block1:         // 1 byte length L followed by L bytes.
   case DW_FORM_block2:         // 2 byte length L followed by L bytes.
   case DW_FORM_block4:         // 4 byte length L followed by L bytes.
   case DW_FORM_string:         // C-string with null terminator.
   case DW_FORM_sdata:          // SLEB128.
   case DW_FORM_udata:          // ULEB128.
   case DW_FORM_ref_udata:      // ULEB128.
   case DW_FORM_indirect:       // ULEB128.
   case DW_FORM_exprloc:        // ULEB128 length L followed by L bytes.
   case DW_FORM_strx:           // ULEB128.
   case DW_FORM_addrx:          // ULEB128.
   case DW_FORM_loclistx:       // ULEB128.
   case DW_FORM_rnglistx:       // ULEB128.
   case DW_FORM_GNU_addr_index: // ULEB128.
   case DW_FORM_GNU_str_index:  // ULEB128.
     return None;
 
   case DW_FORM_ref_addr:
-    if (U)
-      return U->getRefAddrByteSize();
+    if (I)
+      return I->getRefAddrByteSize();
     return None;
 
   case DW_FORM_flag:
   case DW_FORM_data1:
   case DW_FORM_ref1:
   case DW_FORM_strx1:
   case DW_FORM_addrx1:
     return 1;
case DW_FORM_addrx4:
     return 4;
 
   case DW_FORM_strp:
   case DW_FORM_GNU_ref_alt:
   case DW_FORM_GNU_strp_alt:
   case DW_FORM_line_strp:
   case DW_FORM_sec_offset:
   case DW_FORM_strp_sup:
-    if (U)
-      return U->getDwarfOffsetByteSize();
+    if (I)
+      return I->OffsetSize;
     return None;
 
   case DW_FORM_data8:
   case DW_FORM_ref8:
   case DW_FORM_ref_sig8:
   case DW_FORM_ref_sup8:
     return 8;
 
case DW_FORM_implicit_const:
     return 0;
 
   default:
     llvm_unreachable("Handle this form in this switch statement");
   }
   return None;
 }
 
-template <class T>
 static bool skipFormValue(dwarf::Form Form, const DataExtractor &DebugInfoData,
-                          uint32_t *OffsetPtr, const T *U) {
+                          uint32_t *OffsetPtr, const FormValueInfo *I) {
   bool Indirect = false;
   do {
     switch (Form) {
     // Blocks of inlined data that have a length field and the data bytes
     // inlined in the .debug_info.
     case DW_FORM_exprloc:
     case DW_FORM_block: {
       uint64_t size = DebugInfoData.getULEB128(OffsetPtr);
do {
     case DW_FORM_addrx2:
     case DW_FORM_addrx4:
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
     case DW_FORM_strp_sup:
     case DW_FORM_line_strp:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt:
-      if (Optional<uint8_t> FixedSize = ::getFixedByteSize(Form, U)) {
+      if (Optional<uint8_t> FixedSize = ::getFixedByteSize(Form, I)) {
         *OffsetPtr += *FixedSize;
         return true;
       }
       return false;
 
     // signed or unsigned LEB 128 values.
     case DW_FORM_sdata:
       DebugInfoData.getSLEB128(OffsetPtr);
default:
       return false;
     }
   } while (Indirect);
   return true;
 }
 
 Optional<uint8_t> DWARFFormValue::getFixedByteSize(dwarf::Form Form,
                                                    const DWARFUnit *U) {
-  return ::getFixedByteSize(Form, U);
+  FormValueInfo I(U);
+  return ::getFixedByteSize(Form, U ? &I : nullptr);
 }
 
 Optional<uint8_t>
 DWARFFormValue::getFixedByteSize(dwarf::Form Form, uint16_t Version,
                                  uint8_t AddrSize,
                                  llvm::dwarf::DwarfFormat Format) {
-  FormSizeHelper FSH(Version, AddrSize, Format);
-  return ::getFixedByteSize(Form, &FSH);
+  FormValueInfo I(Version, AddrSize, Format == dwarf::DwarfFormat::DWARF64);
+  return ::getFixedByteSize(Form, &I);
 }
 
 bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   // First, check DWARF4 form classes.
   if (Form < makeArrayRef(DWARF4FormClasses).size() &&
       DWARF4FormClasses[Form] == FC)
     return true;
   // Check more forms from DWARF4 and DWARF5 proposals.
bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   // offset.
   return (Form == DW_FORM_data4 || Form == DW_FORM_data8 ||
           Form == DW_FORM_strp) &&
          FC == FC_SectionOffset;
 }
 
 bool DWARFFormValue::extractValue(const DataExtractor &Data,
                                   uint32_t *OffsetPtr, const DWARFUnit *CU) {
-  U = CU;
+
+  Info.Init(CU);
+  return extractValueImpl(Data, OffsetPtr);
+}
+
+bool DWARFFormValue::extractValue(const DataExtractor &Data,
+                                  uint32_t *OffsetPtr, const DWARFUnit *CU,
+                                  const RelocAddrMap *RM, uint16_t Version,
+                                  uint8_t AddrSize, bool IsDwarf64) {
+  Info.Init(CU, RM, Version, AddrSize, IsDwarf64);
+  return extractValueImpl(Data, OffsetPtr);
+}
+
+bool DWARFFormValue::extractValueImpl(const DataExtractor &Data,
+                                      uint32_t *OffsetPtr) {
   bool Indirect = false;
   bool IsBlock = false;
   Value.data = nullptr;
   // Read the value for the form into value and follow and DW_FORM_indirect
   // instances we run into
   do {
     Indirect = false;
     switch (Form) {
     case DW_FORM_addr:
     case DW_FORM_ref_addr: {
-      if (!U)
+      if (!Info.Unit)
         return false;
-      uint16_t AddrSize = (Form == DW_FORM_addr) ? U->getAddressByteSize()
-                                                 : U->getRefAddrByteSize();
-      Value.uval =
-          getRelocatedValue(Data, AddrSize, OffsetPtr, U->getRelocMap());
+      uint16_t AddrSize =
+          (Form == DW_FORM_addr) ? Info.AddrSize : Info.getRefAddrByteSize();
+      Value.uval = getRelocatedValue(Data, AddrSize, OffsetPtr, Info.RelocMap);
       break;
     }
     case DW_FORM_exprloc:
     case DW_FORM_block:
       Value.uval = Data.getULEB128(OffsetPtr);
       IsBlock = true;
       break;
     case DW_FORM_block1:
do {
     case DW_FORM_strx2:
     case DW_FORM_addrx2:
       Value.uval = Data.getU16(OffsetPtr);
       break;
     case DW_FORM_data4:
     case DW_FORM_ref4:
     case DW_FORM_ref_sup4:
     case DW_FORM_strx4:
-    case DW_FORM_addrx4: {
-      const RelocAddrMap *RelocMap = U ? U->getRelocMap() : nullptr;
-      Value.uval = getRelocatedValue(Data, 4, OffsetPtr, RelocMap);
+    case DW_FORM_addrx4:
+      Value.uval = getRelocatedValue(Data, 4, OffsetPtr, Info.RelocMap);
       break;
-    }
     case DW_FORM_data8:
     case DW_FORM_ref8:
     case DW_FORM_ref_sup8:
       Value.uval = Data.getU64(OffsetPtr);
       break;
     case DW_FORM_sdata:
       Value.sval = Data.getSLEB128(OffsetPtr);
       break;
case DW_FORM_indirect:
       Indirect = true;
       break;
     case DW_FORM_strp:
     case DW_FORM_sec_offset:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt:
     case DW_FORM_line_strp:
     case DW_FORM_strp_sup: {
-      if (!U)
+      if (!Info.Unit)
         return false;
-      Value.uval = getRelocatedValue(Data, U->getDwarfOffsetByteSize(),
-                                     OffsetPtr, U->getRelocMap());
+      Value.uval =
+          getRelocatedValue(Data, Info.OffsetSize, OffsetPtr, Info.RelocMap);
       break;
     }
     case DW_FORM_flag_present:
       Value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
       Value.uval = Data.getU64(OffsetPtr);
       break;
bool DWARFFormValue::extractValueImpl(const DataExtractor &Data,
   return true;
 }
 
 bool DWARFFormValue::skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
                                const DWARFUnit *U) const {
   return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U);
 }
 
+bool DWARFFormValue::skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
+                               const DWARFUnit *U, const RelocAddrMap *RM,
+                               uint16_t Version, uint8_t AddrSize,
+                               bool IsDwarf64) {
+  FormValueInfo I(U, RM, Version, AddrSize, IsDwarf64);
+  return skipFormValue(Form, DebugInfoData, OffsetPtr, U ? &I : nullptr);
+}
+
 bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
                                uint32_t *OffsetPtr, const DWARFUnit *U) {
-  return skipFormValue(Form, DebugInfoData, OffsetPtr, U);
+  FormValueInfo I(U);
+  return skipFormValue(Form, DebugInfoData, OffsetPtr, U ? &I : nullptr);
 }
 
 bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
                                uint32_t *OffsetPtr, uint16_t Version,
-                               uint8_t AddrSize,
-                               llvm::dwarf::DwarfFormat Format) {
-  FormSizeHelper FSH(Version, AddrSize, Format);
-  return skipFormValue(Form, DebugInfoData, OffsetPtr, &FSH);
+                               uint8_t AddrSize, bool IsDwarf64) {
+  FormValueInfo I(Version, AddrSize, IsDwarf64);
+  return skipFormValue(Form, DebugInfoData, OffsetPtr, &I);
 }
 
 void DWARFFormValue::dump(raw_ostream &OS) const {
   uint64_t UValue = Value.uval;
   bool CURelativeOffset = false;
 
   switch (Form) {
   case DW_FORM_addr:
     OS << format("0x%016" PRIx64, UValue);
     break;
   case DW_FORM_GNU_addr_index: {
     OS << format(" indexed (%8.8x) address = ", (uint32_t)UValue);
     uint64_t Address;
-    if (U == nullptr)
+    if (Info.Unit == nullptr)
       OS << "<invalid dwarf unit>";
-    else if (U->getAddrOffsetSectionItem(UValue, Address))
+    else if (Info.Unit->getAddrOffsetSectionItem(UValue, Address))
       OS << format("0x%016" PRIx64, Address);
     else
       OS << "<no .debug_addr section>";
     break;
   }
   case DW_FORM_flag_present:
     OS << "true";
     break;
void DWARFFormValue::dump(raw_ostream &OS) const {
 
   default:
     OS << format("DW_FORM(0x%4.4x)", Form);
     break;
   }
 
   if (CURelativeOffset) {
     OS << " => {";
-    WithColor(OS, syntax::Address).get()
-        << format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
+    WithColor(OS, syntax::Address).get() << format(
+        "0x%8.8" PRIx64, UValue + (Info.Unit ? Info.Unit->getOffset() : 0));
     OS << "}";
   }
 }
 
 void DWARFFormValue::dumpString(raw_ostream &OS) const {
   Optional<const char *> DbgStr = getAsCString();
   if (DbgStr.hasValue()) {
     raw_ostream &COS = WithColor(OS, syntax::String);
     COS << '"';
     COS.write_escaped(DbgStr.getValue());
     COS << '"';
   }
 }
 
 Optional<const char *> DWARFFormValue::getAsCString() const {
   if (!isFormClass(FC_String))
     return None;
   if (Form == DW_FORM_string)
     return Value.cstr;
   // FIXME: Add support for DW_FORM_GNU_strp_alt
-  if (Form == DW_FORM_GNU_strp_alt || U == nullptr)
+  if (Form == DW_FORM_GNU_strp_alt || Info.Unit == nullptr)
     return None;
   uint32_t Offset = Value.uval;
   if (Form == DW_FORM_GNU_str_index) {
     uint32_t StrOffset;
-    if (!U->getStringOffsetSectionItem(Offset, StrOffset))
+    if (!Info.Unit->getStringOffsetSectionItem(Offset, StrOffset))
       return None;
     Offset = StrOffset;
   }
-  if (const char *Str = U->getStringExtractor().getCStr(&Offset)) {
+  if (const char *Str = Info.Unit->getStringExtractor().getCStr(&Offset)) {
     return Str;
   }
   return None;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsAddress() const {
   if (!isFormClass(FC_Address))
     return None;
   if (Form == DW_FORM_GNU_addr_index) {
     uint32_t Index = Value.uval;
     uint64_t Result;
-    if (!U || !U->getAddrOffsetSectionItem(Index, Result))
+    if (!Info.Unit || !Info.Unit->getAddrOffsetSectionItem(Index, Result))
       return None;
     return Result;
   }
   return Value.uval;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsReference() const {
   if (!isFormClass(FC_Reference))
     return None;
   switch (Form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
-    if (!U)
+    if (!Info.Unit)
       return None;
-    return Value.uval + U->getOffset();
+    return Value.uval + Info.Unit->getOffset();
   case DW_FORM_ref_addr:
   case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return Value.uval;
   default:
     return None;
   }
 }

test/DebugInfo/Inputs/dwarfdump-header-64.s

+# Test object to verify dwarfdump handles a DWARF-64 v5 line header.
+# FIXME: Make the other headers DWARF-64 also.
+# FIXME: Add variants for earlier DWARF versions.
+
+# To generate the test object:
+# llvm-mc -triple x86_64-unknown-linux dwarfdump-header-64.s -filetype=obj \
+#         -o dwarfdump-header-64.elf-x86-64
+
+        .section .debug_str,"MS",@progbits,1
+str_producer:
+        .asciz  "Handmade DWARF producer"
+str_CU_5:
+        .asciz  "V5_compile_unit"
+str_LT_5a:
+        .asciz  "Directory5a"
+str_LT_5b:
+        .asciz  "Directory5b"
+
+        .section .debug_abbrev,"",@progbits
+        .byte   0x01    # Abbrev code
+        .byte   0x11    # DW_TAG_compile_unit
+        .byte   0x00    # DW_CHILDREN_no
+        .byte   0x25    # DW_AT_producer
+        .byte   0x0e    # DW_FORM_strp
+        .byte   0x03    # DW_AT_name
+        .byte   0x0e    # DW_FORM_strp
+        .byte   0x10    # DW_AT_stmt_list
+        .byte   0x17    # DW_FORM_sec_offset
+        .byte   0x00    # EOM(1)
+        .byte   0x00    # EOM(2)
+
+        .section .debug_info,"",@progbits
+
+# DWARF-32 v5 normal CU header.
+        .long   CU_5_end-CU_5_version   # Length of Unit
+CU_5_version:
+        .short  5               # DWARF version number
+        .byte   1               # DWARF Unit Type
+        .byte   8               # Address Size (in bytes)
+        .long   .debug_abbrev   # Offset Into Abbrev. Section
+# The compile-unit DIE, with DW_AT_producer, DW_AT_name, DW_AT_stmt_list.
+        .byte   1
+        .long   str_producer
+        .long   str_CU_5
+        .long   LH_5_start
+        .byte   0 # NULL
+CU_5_end:
+
+        .section .debug_line,"",@progbits
+# DWARF-64 v5 line-table header.
+LH_5_start:
+        .long   -1
+        .quad   LH_5_end-LH_5_version   # Length of Unit
+LH_5_version:
+        .short  5               # DWARF version number
+        .byte   8               # Address Size
+        .byte   0               # Segment Selector Size
+        .quad   LH_5_header_end-LH_5_params     # Length of Prologue
+LH_5_params:
+        .byte   1               # Minimum Instruction Length
+        .byte   1               # Maximum Operations per Instruction
+        .byte   1               # Default is_stmt
+        .byte   -5              # Line Base
+        .byte   14              # Line Range
+        .byte   13              # Opcode Base
+        .byte   0               # Standard Opcode Lengths
+        .byte   1
+        .byte   1
+        .byte   1
+        .byte   1
+        .byte   0
+        .byte   0
+        .byte   0
+        .byte   1
+        .byte   0
+        .byte   0
+        .byte   1
+        # Directory table format
+        .byte   1               # One element per directory entry
+        .byte   1               # DW_LNCT_path
+        .byte   0x0e            # DW_FORM_strp
+        # Directory table entries
+        .byte   2               # Two directories
+        .quad   str_LT_5a
+        .quad   str_LT_5b
+        # File table format
+        .byte   4               # Four elements per file entry
+        .byte   1               # DW_LNCT_path
+        .byte   0x08            # DW_FORM_string
+        .byte   2               # DW_LNCT_directory_index
+        .byte   0x0b            # DW_FORM_data1
+        .byte   3               # DW_LNCT_timestamp
+        .byte   0x0f            # DW_FORM_udata
+        .byte   4               # DW_LNCT_size
+        .byte   0x0f            # DW_FORM_udata
+        # File table entries
+        .byte   2               # Two files
+        .asciz "File5a"
+        .byte   1
+        .byte   0x51
+        .byte   0x52
+        .asciz "File5b"
+        .byte   2
+        .byte   0x53
+        .byte   0x54
+LH_5_header_end:
+        # Line number program, which is empty.
+LH_5_end:

test/DebugInfo/Inputs/dwarfdump-header.s

 str_producer:
         .asciz "Handmade DWARF producer"
 str_CU_4:
         .asciz "V4_compile_unit"
 str_CU_5:
         .asciz "V5_compile_unit"
 str_TU_4:
         .asciz "V4_type_unit"
+str_LT_5a:
+        .asciz "Directory5a"
+str_LT_5b:
+        .asciz "Directory5b"
 
         .section .debug_str.dwo,"MS",@progbits,1
 dwo_TU_5:
         .asciz "V5_split_type_unit"
 
 # All CUs/TUs use the same abbrev section for simplicity.
         .section .debug_abbrev,"",@progbits
         .byte 0x01  # Abbrev code
LH_5_params:
         .byte   0
         .byte   1
         .byte   0
         .byte   0
         .byte   1
         # Directory table format
         .byte   1               # One element per directory entry
         .byte   1               # DW_LNCT_path
-        .byte   0x08            # DW_FORM_string
+        .byte   0x0e            # DW_FORM_strp
         # Directory table entries
         .byte   2               # Two directories
-        .asciz "Directory5a"
-        .asciz "Directory5b"
+        .long   str_LT_5a
+        .long   str_LT_5b
         # File table format
         .byte   4               # Four elements per file entry
         .byte   1               # DW_LNCT_path
         .byte   0x08            # DW_FORM_string
         .byte   2               # DW_LNCT_directory_index
         .byte   0x0b            # DW_FORM_data1
         .byte   3               # DW_LNCT_timestamp
         .byte   0x0f            # DW_FORM_udata

test/DebugInfo/dwarfdump-header-64.test

+RUN: llvm-dwarfdump %p/Inputs/dwarfdump-header-64.elf-x86-64 | FileCheck %s
+
+The input file is hand-coded assembler to generate DWARF-64 information,
+so we're willing to make exact checks for offsets and such.
+
+CHECK-LABEL: .debug_info contents:
+
+The v5 CU header.
+
+CHECK: 0x00000000: Compile Unit: length = 0x00000016 version = 0x0005 unit_type = DW_UT_compile abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000001a)
+CHECK: 0x0000000c: DW_TAG_compile_unit
+
+CHECK-LABEL: .debug_line contents:
+
+The DWARF-64 v5 line table header.
+
+CHECK: Line table prologue:
+CHECK: total_length: 0x00000050
+CHECK: version: 5
+CHECK: address_size: 8
+CHECK: seg_select_size: 0
+CHECK: prologue_length: 0x00000044
+CHECK: max_ops_per_inst: 1
+CHECK: include_directories[  1] = 'Directory5a'
+CHECK: include_directories[  2] = 'Directory5b'
+CHECK-NOT: include_directories
+CHECK: file_names[  1]    1 0x00000051 0x00000052 File5a{{$}}
+CHECK: file_names[  2]    2 0x00000053 0x00000054 File5b{{$}}
+CHECK-NOT: file_names

tools/dsymutil/DwarfLinker.cpp

void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
 
   // Parse the original line info for the unit.
   DWARFDebugLine::LineTable LineTable;
   uint32_t StmtOffset = *StmtList;
   StringRef LineData = OrigDwarf.getLineSection().Data;
   DataExtractor LineExtractor(LineData, OrigDwarf.isLittleEndian(),
                               Unit.getOrigUnit().getAddressByteSize());
   LineTable.parse(LineExtractor, &OrigDwarf.getLineSection().Relocs,
-                  &StmtOffset);
+                  &StmtOffset, &Unit.getOrigUnit());
 
   // This vector is the output line table.
   std::vector<DWARFDebugLine::Row> NewRows;
   NewRows.reserve(LineTable.Rows.size());
 
   // Current sequence of rows being extracted, before being inserted
   // in NewRows.
   std::vector<DWARFDebugLine::Row> Seq;