[DebugInfo] add SectionedAddress to DebugInfo interfaces.

[avl]

Summary

That patch is the fix for https://bugs.llvm.org/show_bug.cgi?id=40703 "wrong line number info for obj file compiled with -ffunction-sections" bug. The problem happened with only .o files. If object file contains several .text sections then line number information showed incorrectly. The reason for this is that DwarfLineTable could not detect section which corresponds to specified address(because address is the local to the section). And as the result it could not select proper sequence in the line table. The fix is to pass SectionIndex with the address. So that it would be possible to differentiate addresses from various sections. With this fix llvm-objdump shows correct line numbers for disassembled code.

[avl]

This is topic on llvm-dev http://lists.llvm.org/pipermail/llvm-dev/2019-February/130187.html

[dblaikie]

This has some relatively extensive changes to some of the llvm tools (like sancov, for instance) that aren't tested - perhaps it'd be better to leave those tools usage unmodified (adding the undef section value as a fix to the API change, but nothing more) with fixits and/or followup patches that implement the improved functionality possible with the new API, along with tests?

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

142–144

Might be simpler to implement as:

return std::tie(LHS.SectionIndex, LHS.Address) < std::tie(RHS.SectionIndex, RHS.Address);

148

Maybe "presented" could be replaced with "is present" here and below?
(and "index of /the/ section")

llvm/include/llvm/Object/ObjectFile.h

139

Maybe use non-static data member initializers rather than constructors?
(& then drop the other two ctors too - let this be a plain struct)

145–149

If this can be changed to a plain struct, might be nice to move this operator out of the class definition (& generally/at least it should be a friend rather than a member, so that LHS and RHS get equal treatment for conversions, etc)

& implement this with std::tie similar to the previous suggestion, maybe?

329

Cleanups like this would ideally go in separate NFC (No Functional Change) commits - shouldn't require any review, feel free to just commit them if you have commit rights.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

273

Is this llvm:: qualifier to disambiguate different things called SectionedAddress? Perhaps we could avoid having different things with that name and use only one of them - maybe move the one that's already in libDebugInfo into libObject? (perhaps as an incremental patch before the rest of this change)

975

Presumably this is going to have ambiguity problems if it doesn't have the section too? Which CU does it return if there are two CUs both with address zero in them (because they each describe functions in different sections), for instance?

979–980

Similarly here

1056–1059

Yeah, seems like it'd be best to have one SectionedAddress type rather than mapping between these equivalent but different types.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

867–868

Perhaps Row should contain a SectionedAddress rather than a separate Address and SectionIndex field (again, could be a preliminary or after-this-patch refactoring to clean it up if it'd otherwise introduce a lot of churn to this already fairly large patch)

889–892

Under what conditions is this code needed? (it looks like this would only fail if the section index was incorrect? Which makes me think/feel like this is maybe working around a bug of some kind?)

905

Maybe this should be "lookupAddressImpl" if it's the underlying implementation that is used by the more general lookupAddress entry point?

982–984

Maybe this should be {Address.SectionIndex, EndAddr - 1} (though admittedly it's a bit subtle having to know if section index or address comes first) & passed in directly to findRowInSeq - no need to split out into a named variable, etc.

1064–1066

Looks like unrelated refactoring? (better in a separate commit)

llvm/test/tools/llvm-objdump/Inputs/function-sections-line-numbers.cpp

1–25 ↗

(On Diff #186686)

Seems like a rather long/complicated test case. Is it sufficient to compile this with -ffunction-sections:

void f1() { }
void f2() { }

and then symbolize address 0?

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

529–530

Could use the ctor:

object::SectionedAddress Address(SectionIndex, VMAddress);

or braced init:

IndirectInstructions.insert({SectionIndex, VMAddress});

(I think the latter's probably fine & worth doing across this patch - but I do appreciate the concern that without names one could easily mix up the section/address order - so perhaps you/other reviewers feel differentlny to me)

llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h

105

Might as well pass a SectionedAddress here?

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

404–405

Perhaps this should be changed to produce more than one result? Maybe just leaving a FIXME (given that it's no worse with this change than it was before)

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

392–393

You can roll the variable into the condition here:

if (auto SecOrErr = Sym.getSection())

& LLVM style tends not to put {} on single-line statements like this

[avl]

David, thank you for the review. I would address all points. two major points ;

1. If it is OK to left tools with UNDEF value and TODO comment - then I am also OK with this and would remove changes for sancov.
2. As to having two SectionedAddress structures. I was thinking that existing SectionedAddress structure is local for Dwarf sources. So that Dwarf sources could be independend from another sources. But if it is not the case - then It would be better to leave only one SectionedAddress structure defined at Object/ObjectFile.h So if it is OK I will just remove SectionedAddress from DWARFSection.h

[grimar]

My comments about LLD side are below.

Question is: can LLD part have a test?
I also wonder could this patch just pass object::SectionedAddress::UndefSection,
would behavior be the same? If so, then probably would be better to split LLD change
to a different patch with the test case.

lld/ELF/InputFiles.cpp

208

detect -> Detect

(comments should start from uppercase)

210

I would like to hear what Rui thinks about this,
but my opinion this TODO should be removed because I do not believe we will
add a section index to InputSectionBase. This method is used for error reporting,
so it is OK for it to be reasonably slow. But adding bits to InputSectionBase might increase
memory consumption.

And FTR I do not know a better way to find the section index here, seems
using the loop is fine.

213

We usually use prefix increments I think:

++CurIndex

[avl]

Hi George, Thank you for comments. I will address them. According to the questions ;

1. yes, I would create a test for LLD.
2. Using object::SectionedAddress::UndefSection as section index makes following tests fail :
   
   lld :: ELF/conflict.s lld :: ELF/debug-line-str.s lld :: ELF/multiple-cu.s lld :: ELF/undef.s lld :: ELF/x86-64-reloc-range-debug-loc.s

[avl]

llvm/include/llvm/Object/ObjectFile.h

139

I changed it to non-static data member initializers. But it looks like I could not drop following constructors. Since if I add non-static data member initializers then it stopped to compile inplace initializers = {Addr, Index}. To compile inplace initializer - it require constructor SectionedAddress (Addr, Index). It also require default constructor for default instantiation.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

273

moved SectionedAddress from libDebugInfo into linObject.

975

Agreed. I left it as is to reduce size of the fix. Since It is not required for 40703 bug. I would put TODO comment here.

979–980

would put TODO comment here.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

889–892

That is how DebugLineInfo organized. If it has absolute addresses - it does not care which section they relate. So if caller ask for information for an AbsoluteAddress from section X then there would not be possible to find such entry. All absolute addresses put in Undef section(in DebugLineInfo table). But if Line Info table has Relocation information then it would create entry for specific SectionIndex. Earlier there was not this differrentiation because addresses were not marked with SectionIndex. Now addresses which have relocations marked with proper section index and absolute addresses marked with undex section index. Thus the algorithm is following :

find address in relocations for specified section. then if not found check it for Undef section which contains info about all absolute addresses.

another alternative would be to set proper sectionIndex for absolute addresses while DebugLineInfo table create it`s map. Then there would not be neccessary to search twice, but there would be neccessary to create more complex map. I think this is just another way to implement the same.

llvm/test/tools/llvm-objdump/Inputs/function-sections-line-numbers.cpp

1–25 ↗

(On Diff #186686)

I took above short test case and check how llvm-objdump shows line numbers. for llvm-symbolizer it would probably be necessary to extend command line to tell to which section specified address related.

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

404–405

added TODO comment for this.

[avl]

Addressed most of the comments. test for LLD is in progress yet.

[avl]

added test for LLD. did all what was requested in comments.

[avl]

George, I added test for LLD. But.... It already pass for LLD without this fix. The reason for that is following quickfix :

lld/ELF/DWARF.cpp:90

// FIXME: We should be consistent about always adding the file
// offset or not.
if (DR->Section->Flags & ELF::SHF_ALLOC)
  Val += cast<InputSection>(DR->Section)->getOffsetInFile();

lld/ELF/InputFiles.cpp:208

// Use fake address calcuated by adding section file offset and offset in
// section. See comments for ObjectInfo class.
DILineInfo Info;
for (const llvm::DWARFDebugLine::LineTable *LT : LineTables)
  if (LT->getFileLineInfoForAddress(
          S->getOffsetInFile() + Offset, nullptr,
          DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, Info))
    return Info;

FileOffset added instead of section offset(because section offset could be 0). I think that quickfix should not prevent making interfaces full. i.e. I still think that adding SectionIndex for getFileLineInfoForAddress is a right thing. Having this already done - the fix with getOffsetInFile could probably be refactored out.

[grimar]

Ok. I debugged this a little and think that:

1. LLD code change LGTM.
2. I find the LLD test case potentially useful because I did not find any test checking exactly this situation. Given that LLD has mentioned "TODOs" in the code that we might want to remove, it would be good to have such a test for the future possible changes probably.
3. It feels that the test can be reduced and might need some cleanup (I left a few inline comments).
4. Since without assigning the section index, we would have few existent LLD tests failures (and also since this test pass without any code changes atm), it should be fine to go without any additional test for LLD in this patch.

To summarize: I suggest to proceed with this patch without the LLD test and post it on a different review as an independent improvement.

lld/test/ELF/debug-line-obj.s

5 ↗

(On Diff #187074)

I do not think you need to mention "crash" here.
Seems you used debug-line-str.s test case as a base and the comment is coming from there.
That test was committed with the fix that actually fixed a crash and that is why it is was mentioned.

I would just say here that this test checks that we report locations correctly when we have the line number
information in .debug_line that describes lines from different sections created because of using of -ffunction-sections flag.
Or something like that :)

238 ↗

(On Diff #187074)

You should not need .debug_macinfo section.

251 ↗

(On Diff #187074)

I think you can remove .ident and the .note.GNU-stack section below.

llvm/test/tools/llvm-objdump/function-sections-line-numbers.test

1 ↗

(On Diff #186686)

I did not find any other llvm-objdump test that would use clang.
You should probably use llvm-mc I think.

[avl]

deleted LLD test as it was requested. Modified llvm-objdump test to not to use clang.

[avl]

ping...

[dblaikie]

llvm/include/llvm/Object/ObjectFile.h

139

ah, seems that rule doesn't exist in C++14 anymore - so maybe a FIXME to remove the ctors once we've adopted C++14?

149

These shouldn't be static (means they'd have internal linkage, and they'd be duplicated (& not deduplicated by the linker) and lead to ODR violations (any non-static inline function that calls these and is used in multiple translation units would be in violation of the ODR because that inline function would differ (it'd be calling different functions) between fileS))

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

935–946

Probably flip this around to reduce indentation:

if (lookupAddressRangeImpl(...))
  return true;

if (Address.SectionIndex == Undef)
  return false;

Address.SectionIndex = Undef;
return lookupAddressRangeImpl(...);

982–984

In some places you've rolled the SectionedAddress creation into the call site, and in others you have a named variable like this. I think it probably makes sense to not name these variables in general (unless they're needed more than once)? But not a big deal.

1064–1066

Still looks like some unrelated refactoring here?

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

391–392

Could you use "else if" here?

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

206

can't say I've seen this written this way - I think it's probably more common to write it as "if (!BinaryOrErr)"?

209

Rather than x.get().y you could write this as "x->y"?

[avl]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

206

There are more usages of error() in this file. so I did it exactly like in other places. Though if you think it would be better to change it into "if (!BinaryOrErr)" then I will change it.

[avl]

addressed latest comments.

[dblaikie]

Looks good - thanks!

[avl]

Thank you.

[delcypher]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

204

@avl This patch has broken sanitizer tests on Darwin (rdar://problem/48474543). In particular this now fails.

FILECHECK_DUMP_INPUT_ON_FAILURE=1 bin/llvm-lit -v projects/compiler-rt/test/asan/X86_64DarwinConfig/TestCases/Darwin/haswell-symbolication.cc

I've tracked down the issue to this commit and this function (getModuleSectionIndexForAddress()). The problem is that this code assumes the module name is the same as the path to the binary. This doesn't seem to be true on Darwin because while running the sanitizer test llvm-symbolizer tries to open...

/path/to/llvm_build/projects/compiler-rt/test/asan/X86_64DarwinConfig/TestCases/Darwin/Output/haswell-symbolication.cc.tmp.thin.x86_64:x86_64

Note the :x86_64 at the end of the module name. That's the slice name inside the file and is not part of the file name itself. We need to land a fix for this or we'll need to revert this patch.

I suspect this issue must be handled elsewhere in the codebase because Darwin specific logic probably doesn't belong here.

@JDevlieghere Any ideas if there's an API that can be used here to get the binary file path from the module name?

[avl]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

204

I will research how to fix it. Make me known if there is proper solution for this, please.

[avl]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

204

I see that situation already handled in LLVMSymbolizer::getOrCreateModuleInfo(). I am going to handle this in similar manner :

size_t ColonPos = ModuleName.find_last_of(':');

// Verify that substring after colon form a valid arch name.

[delcypher]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

204

@avl Thanks for looking into this. That sounds sensible. It might nice to factor out that little bit of code too to avoid duplication.

[avl]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

204

@delcypher I commit a fix for it. But now i think it would not work. I will prepare review for better version asap.

[delcypher]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

204

@avl Thanks. r355192 seems to have fixed the ASan Darwin/haswell-symbolication.cc test.

lld/ELF/InputFiles.cpp

 
 // Returns source line information for a given offset
 // using DWARF debug info.
 template <class ELFT>
 Optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(InputSectionBase *S,
                                                   uint64_t Offset) {
   llvm::call_once(InitDwarfLine, [this]() { initializeDwarf(); });
 
+  // Detect SectionIndex for specified section.
+  uint64_t SectionIndex = object::SectionedAddress::UndefSection;
+  ArrayRef<InputSectionBase *> Sections = S->File->getSections();
+  for (uint64_t CurIndex = 0; CurIndex < Sections.size(); ++CurIndex) {
+    if (S == Sections[CurIndex]) {
+      SectionIndex = CurIndex;
+      break;
+    }
+  }
+
   // Use fake address calcuated by adding section file offset and offset in
   // section. See comments for ObjectInfo class.
   DILineInfo Info;
-  for (const llvm::DWARFDebugLine::LineTable *LT : LineTables)
+  for (const llvm::DWARFDebugLine::LineTable *LT : LineTables) {
     if (LT->getFileLineInfoForAddress(
-            S->getOffsetInFile() + Offset, nullptr,
+            {S->getOffsetInFile() + Offset, SectionIndex}, nullptr,
             DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, Info))
       return Info;
+  }
   return None;
 }
 
 // Returns "<internal>", "foo.a(bar.o)" or "baz.o".
 std::string lld::toString(const InputFile *F) {
   if (!F)
     return "<internal>";
 

llvm/include/llvm/DebugInfo/DIContext.h

public:
 
   virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
 
   virtual bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) {
     // No verifier? Just say things went well.
     return true;
   }
 
-  virtual DILineInfo getLineInfoForAddress(uint64_t Address,
+  virtual DILineInfo getLineInfoForAddress(
+      object::SectionedAddress Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
-  virtual DILineInfoTable getLineInfoForAddressRange(uint64_t Address,
-      uint64_t Size, DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
-  virtual DIInliningInfo getInliningInfoForAddress(uint64_t Address,
+  virtual DILineInfoTable getLineInfoForAddressRange(
+      object::SectionedAddress Address, uint64_t Size,
+      DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
+  virtual DIInliningInfo getInliningInfoForAddress(
+      object::SectionedAddress Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
 
 private:
   const DIContextKind Kind;
 };
 
 /// An inferface for inquiring the load address of a loaded object file
 /// to be used by the DIContext implementations when applying relocations

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

struct DIEsForAddress {
     DWARFCompileUnit *CompileUnit = nullptr;
     DWARFDie FunctionDIE;
     DWARFDie BlockDIE;
     explicit operator bool() const { return CompileUnit != nullptr; }
   };
 
   /// Get the compilation unit, the function DIE and lexical block DIE for the
   /// given address where applicable.
+  /// TODO: change input parameter from "uint64_t Address"
+  ///       into "SectionedAddress Address"
   DIEsForAddress getDIEsForAddress(uint64_t Address);
 
-  DILineInfo getLineInfoForAddress(uint64_t Address,
+  DILineInfo getLineInfoForAddress(
+      object::SectionedAddress Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
-  DILineInfoTable getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
+  DILineInfoTable getLineInfoForAddressRange(
+      object::SectionedAddress Address, uint64_t Size,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
-  DIInliningInfo getInliningInfoForAddress(uint64_t Address,
+  DIInliningInfo getInliningInfoForAddress(
+      object::SectionedAddress Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
 
   bool isLittleEndian() const { return DObj->isLittleEndian(); }
   static bool isSupportedVersion(unsigned version) {
     return version == 2 || version == 3 || version == 4 || version == 5;
   }
 
   std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
public:
 
   Triple::ArchType getArch() const {
     return getDWARFObj().getFile()->getArch();
   }
 
 private:
   /// Return the compile unit which contains instruction with provided
   /// address.
+  /// TODO: change input parameter from "uint64_t Address"
+  ///       into "SectionedAddress Address"
   DWARFCompileUnit *getCompileUnitForAddress(uint64_t Address);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

struct Row {
     /// Called after a row is appended to the matrix.
     void postAppend();
     void reset(bool DefaultIsStmt);
     void dump(raw_ostream &OS) const;
 
     static void dumpTableHeader(raw_ostream &OS);
 
     static bool orderByAddress(const Row &LHS, const Row &RHS) {
-      return LHS.Address < RHS.Address;
+      return std::tie(LHS.Address.SectionIndex, LHS.Address.Address) <
+             std::tie(RHS.Address.SectionIndex, RHS.Address.Address);
     }
 
     /// The program-counter value corresponding to a machine instruction
-    /// generated by the compiler.
-    uint64_t Address;
+    /// generated by the compiler and section index pointing to the section
+    /// containg this PC. If relocation information is present then section
+    /// index is the index of the section which contains above address.
+    /// Otherwise this is object::SectionedAddress::Undef value.
+    object::SectionedAddress Address;
     /// An unsigned integer indicating a source line number. Lines are numbered
     /// beginning at 1. The compiler may emit the value 0 in cases where an
     /// instruction cannot be attributed to any source line.
     uint32_t Line;
     /// An unsigned integer indicating a column number within a source line.
     /// Columns are numbered beginning at 1. The value 0 is reserved to indicate
     /// that a statement begins at the 'left edge' of the line.
     uint16_t Column;
public:
   /// guaranteed to be in the order of ascending instruction address.
   struct Sequence {
     Sequence();
 
     /// Sequence describes instructions at address range [LowPC, HighPC)
     /// and is described by line table rows [FirstRowIndex, LastRowIndex).
     uint64_t LowPC;
     uint64_t HighPC;
+    /// If relocation information is present then this is the index of the
+    /// section which contains above addresses. Otherwise this is
+    /// object::SectionedAddress::Undef value.
+    uint64_t SectionIndex;
     unsigned FirstRowIndex;
     unsigned LastRowIndex;
     bool Empty;
 
     void reset();
 
     static bool orderByLowPC(const Sequence &LHS, const Sequence &RHS) {
-      return LHS.LowPC < RHS.LowPC;
+      return std::tie(LHS.SectionIndex, LHS.LowPC) <
+             std::tie(RHS.SectionIndex, RHS.LowPC);
     }
 
     bool isValid() const {
       return !Empty && (LowPC < HighPC) && (FirstRowIndex < LastRowIndex);
     }
 
-    bool containsPC(uint64_t PC) const { return (LowPC <= PC && PC < HighPC); }
+    bool containsPC(object::SectionedAddress PC) const {
+      return SectionIndex == PC.SectionIndex &&
+             (LowPC <= PC.Address && PC.Address < HighPC);
+    }
   };
 
   struct LineTable {
     LineTable();
 
     /// Represents an invalid row
     const uint32_t UnknownRowIndex = UINT32_MAX;
 
     void appendRow(const DWARFDebugLine::Row &R) { Rows.push_back(R); }
 
     void appendSequence(const DWARFDebugLine::Sequence &S) {
       Sequences.push_back(S);
     }
 
     /// Returns the index of the row with file/line info for a given address,
     /// or UnknownRowIndex if there is no such row.
-    uint32_t lookupAddress(uint64_t Address) const;
+    uint32_t lookupAddress(object::SectionedAddress Address) const;
 
-    bool lookupAddressRange(uint64_t Address, uint64_t Size,
+    bool lookupAddressRange(object::SectionedAddress Address, uint64_t Size,
                             std::vector<uint32_t> &Result) const;
 
     bool hasFileAtIndex(uint64_t FileIndex) const;
 
     /// Extracts filename by its index in filename table in prologue.
     /// Returns true on success.
     bool getFileNameByIndex(uint64_t FileIndex, const char *CompDir,
                             DILineInfoSpecifier::FileLineInfoKind Kind,
                             std::string &Result) const;
 
     /// Fills the Result argument with the file and line information
     /// corresponding to Address. Returns true on success.
-    bool getFileLineInfoForAddress(uint64_t Address, const char *CompDir,
+    bool getFileLineInfoForAddress(object::SectionedAddress Address,
+                                   const char *CompDir,
                                    DILineInfoSpecifier::FileLineInfoKind Kind,
                                    DILineInfo &Result) const;
 
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
     Error parse(
         DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
         const DWARFContext &Ctx, const DWARFUnit *U,
         std::function<void(Error)> RecoverableErrorCallback,
         raw_ostream *OS = nullptr);
 
     using RowVector = std::vector<Row>;
     using RowIter = RowVector::const_iterator;
     using SequenceVector = std::vector<Sequence>;
     using SequenceIter = SequenceVector::const_iterator;
 
     struct Prologue Prologue;
     RowVector Rows;
     SequenceVector Sequences;
 
   private:
     uint32_t findRowInSeq(const DWARFDebugLine::Sequence &Seq,
-                          uint64_t Address) const;
+                          object::SectionedAddress Address) const;
     Optional<StringRef>
     getSourceByIndex(uint64_t FileIndex,
                      DILineInfoSpecifier::FileLineInfoKind Kind) const;
+
+    uint32_t lookupAddressImpl(object::SectionedAddress Address) const;
+
+    bool lookupAddressRangeImpl(object::SectionedAddress Address, uint64_t Size,
+                                std::vector<uint32_t> &Result) const;
   };
 
   const LineTable *getLineTable(uint32_t Offset) const;
   Expected<const LineTable *> getOrParseLineTable(
       DWARFDataExtractor &DebugLineData, uint32_t Offset,
       const DWARFContext &Ctx, const DWARFUnit *U,
       std::function<void(Error)> RecoverableErrorCallback);
 

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

public:
   void dump(raw_ostream &OS) const;
   Error extract(const DWARFDataExtractor &data, uint32_t *offset_ptr);
   const std::vector<RangeListEntry> &getEntries() { return Entries; }
 
   /// getAbsoluteRanges - Returns absolute address ranges defined by this range
   /// list. Has to be passed base address of the compile unit referencing this
   /// range list.
   DWARFAddressRangesVector
-  getAbsoluteRanges(llvm::Optional<SectionedAddress> BaseAddr) const;
+  getAbsoluteRanges(llvm::Optional<object::SectionedAddress> BaseAddr) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

struct RangeListEntry : public DWARFListEntryBase {
   /// single value base addresses or end-of-list with no values. The unneeded
   /// values are semantically undefined, but initialized to 0.
   uint64_t Value0;
   uint64_t Value1;
 
   Error extract(DWARFDataExtractor Data, uint32_t End, uint32_t *OffsetPtr);
   void dump(raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,
             uint64_t &CurrentBase, DIDumpOptions DumpOpts,
-            llvm::function_ref<Optional<SectionedAddress>(uint32_t)>
+            llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
                 LookupPooledAddress) const;
   bool isSentinel() const { return EntryKind == dwarf::DW_RLE_end_of_list; }
 };
 
 /// A class representing a single rangelist.
 class DWARFDebugRnglist : public DWARFListType<RangeListEntry> {
 public:
   /// Build a DWARFAddressRangesVector from a rangelist.
   DWARFAddressRangesVector
-  getAbsoluteRanges(llvm::Optional<SectionedAddress> BaseAddr,
+  getAbsoluteRanges(llvm::Optional<object::SectionedAddress> BaseAddr,
                     DWARFUnit &U) const;
 };
 
 class DWARFDebugRnglistTable : public DWARFListTableBase<DWARFDebugRnglist> {
 public:
   DWARFDebugRnglistTable()
       : DWARFListTableBase(/* SectionName    = */ ".debug_rnglists",
                            /* HeaderString   = */ "ranges:",
                            /* ListTypeString = */ "range") {}
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGRNGLISTS_H

llvm/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

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, DIDumpOptions DumpOpts = DIDumpOptions()) const;
   void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts,
-                            SectionedAddress SA) const;
+                            object::SectionedAddress SA) const;
   static void dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS,
                                  DIDumpOptions DumpOpts, uint64_t SectionIndex);
 
   /// Extracts a value in \p Data at offset \p *OffsetPtr. The information
   /// in \p FormParams is needed to interpret some forms. The optional
   /// \p Context and \p Unit allows extracting information if the form refers
   /// to other sections (e.g., .debug_str).
   bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
public:
 
   /// 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;
   Optional<int64_t> getAsSignedConstant() const;
   Optional<const char *> getAsCString() const;
   Optional<uint64_t> getAsAddress() const;
-  Optional<SectionedAddress> getAsSectionedAddress() const;
+  Optional<object::SectionedAddress> getAsSectionedAddress() const;
   Optional<uint64_t> getAsSectionOffset() const;
   Optional<ArrayRef<uint8_t>> getAsBlock() const;
   Optional<uint64_t> getAsCStringOffset() const;
   Optional<uint64_t> getAsReferenceUVal() const;
 
   /// Skip a form's value in \p DebugInfoData at the offset specified by
   /// \p OffsetPtr.
   ///

 /// \returns an optional value that contains a value if the form value
 /// was valid and has a address form.
 inline Optional<uint64_t> toAddress(const Optional<DWARFFormValue> &V) {
   if (V)
     return V->getAsAddress();
   return None;
 }
 
-inline Optional<SectionedAddress>
+inline Optional<object::SectionedAddress>
 toSectionedAddress(const Optional<DWARFFormValue> &V) {
   if (V)
     return V->getAsSectionedAddress();
   return None;
 }
 
 /// Take an optional DWARFFormValue and extract a address.
 ///

llvm/include/llvm/DebugInfo/DWARF/DWARFListTable.h

public:
   /// Look up a list based on a given offset. Extract it and enter it into the
   /// list map if necessary.
   Expected<DWARFListType> findList(DWARFDataExtractor Data, uint32_t Offset);
 
   uint32_t getHeaderOffset() const { return Header.getHeaderOffset(); }
   uint8_t getAddrSize() const { return Header.getAddrSize(); }
 
   void dump(raw_ostream &OS,
-            llvm::function_ref<Optional<SectionedAddress>(uint32_t)>
+            llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
                 LookupPooledAddress,
             DIDumpOptions DumpOpts = {}) const;
 
   /// Return the contents of the offset entry designated by a given index.
   Optional<uint32_t> getOffsetEntry(uint32_t Index) const {
     return Header.getOffsetEntry(Index);
   }
   /// Return the size of the table header including the length but not including
return createStringError(errc::illegal_byte_sequence,
                      "no end of list marker detected at end of %s table "
                      "starting at offset 0x%" PRIx32,
                      SectionName.data(), HeaderOffset);
 }
 
 template <typename DWARFListType>
 void DWARFListTableBase<DWARFListType>::dump(
     raw_ostream &OS,
-    llvm::function_ref<Optional<SectionedAddress>(uint32_t)>
+    llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
         LookupPooledAddress,
     DIDumpOptions DumpOpts) const {
   Header.dump(OS, DumpOpts);
   OS << HeaderString << "\n";
 
   // Determine the length of the longest encoding string we have in the table,
   // so we can align the output properly. We only need this in verbose mode.
   size_t MaxEncodingStringLength = 0;

llvm/include/llvm/DebugInfo/DWARF/DWARFSection.h

struct DWARFSection {
   StringRef Data;
 };
 
 struct SectionName {
   StringRef Name;
   bool IsNameUnique;
 };
 
-struct SectionedAddress {
-  uint64_t Address;
-  uint64_t SectionIndex;
-};
-
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFSECTION_H

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

class DWARFUnit {
   /// Start, length, and DWARF format of the unit's contribution to the string
   /// offsets table (DWARF v5).
   Optional<StrOffsetsContributionDescriptor> StringOffsetsTableContribution;
 
   /// A table of range lists (DWARF v5 and later).
   Optional<DWARFDebugRnglistTable> RngListTable;
 
   mutable const DWARFAbbreviationDeclarationSet *Abbrevs;
-  llvm::Optional<SectionedAddress> BaseAddr;
+  llvm::Optional<object::SectionedAddress> BaseAddr;
   /// The compile unit debug information entry items.
   std::vector<DWARFDebugInfoEntry> DieArray;
 
   /// Map from range's start address to end address and corresponding DIE.
   /// IntervalMap does not support range removal, as a result, we use the
   /// std::map::upper_bound for address range lookup.
   std::map<uint64_t, std::pair<uint64_t, DWARFDie>> AddrDieMap;
 
public:
   /// Recursively update address to Die map.
   void updateAddressDieMap(DWARFDie Die);
 
   void setRangesSection(const DWARFSection *RS, uint32_t Base) {
     RangeSection = RS;
     RangeSectionBase = Base;
   }
 
-  Optional<SectionedAddress> getAddrOffsetSectionItem(uint32_t Index) const;
+  Optional<object::SectionedAddress>
+  getAddrOffsetSectionItem(uint32_t Index) const;
   Optional<uint64_t> getStringOffsetSectionItem(uint32_t Index) const;
 
   DWARFDataExtractor getDebugInfoExtractor() const;
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
case dwarf::DW_UT_split_compile:
       return 20;
     case dwarf::DW_UT_type:
     case dwarf::DW_UT_split_type:
       return 24;
     }
     llvm_unreachable("Invalid UnitType.");
   }
 
-  llvm::Optional<SectionedAddress> getBaseAddress();
+  llvm::Optional<object::SectionedAddress> getBaseAddress();
 
   DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
     extractDIEsIfNeeded(ExtractUnitDIEOnly);
     if (DieArray.empty())
       return DWARFDie();
     return DWARFDie(this, &DieArray[0]);
   }
 

llvm/include/llvm/DebugInfo/PDB/PDBContext.h

public:
 
     static bool classof(const DIContext *DICtx) {
       return DICtx->getKind() == CK_PDB;
     }
 
     void dump(raw_ostream &OS, DIDumpOptions DIDumpOpts) override;
 
     DILineInfo getLineInfoForAddress(
-        uint64_t Address,
+        object::SectionedAddress Address,
         DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     DILineInfoTable getLineInfoForAddressRange(
-        uint64_t Address, uint64_t Size,
+        object::SectionedAddress Address, uint64_t Size,
         DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     DIInliningInfo getInliningInfoForAddress(
-        uint64_t Address,
+        object::SectionedAddress Address,
         DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
 
   private:
     std::string getFunctionName(uint64_t Address, DINameKind NameKind) const;
     std::unique_ptr<IPDBSession> Session;
   };
 
 } // end namespace pdb
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBCONTEXT_H

llvm/include/llvm/DebugInfo/Symbolize/SymbolizableModule.h

 namespace symbolize {
 
 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
 
 class SymbolizableModule {
 public:
   virtual ~SymbolizableModule() = default;
 
-  virtual DILineInfo symbolizeCode(uint64_t ModuleOffset,
+  virtual DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
                                    FunctionNameKind FNKind,
                                    bool UseSymbolTable) const = 0;
-  virtual DIInliningInfo symbolizeInlinedCode(uint64_t ModuleOffset,
-                                              FunctionNameKind FNKind,
-                                              bool UseSymbolTable) const = 0;
-  virtual DIGlobal symbolizeData(uint64_t ModuleOffset) const = 0;
+  virtual DIInliningInfo
+  symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
+                       FunctionNameKind FNKind, bool UseSymbolTable) const = 0;
+  virtual DIGlobal
+  symbolizeData(object::SectionedAddress ModuleOffset) const = 0;
 
   // Return true if this is a 32-bit x86 PE COFF module.
   virtual bool isWin32Module() const = 0;
 
   // Returns the preferred base of the module, i.e. where the loader would place
   // it in memory assuming there were no conflicts.
   virtual uint64_t getModulePreferredBase() const = 0;
 };
 
 } // end namespace symbolize
 } // end namespace llvm
 
 #endif  // LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZABLEMODULE_H

llvm/include/llvm/DebugInfo/Symbolize/Symbolize.h

public:
 
   LLVMSymbolizer(const Options &Opts = Options()) : Opts(Opts) {}
 
   ~LLVMSymbolizer() {
     flush();
   }
 
   Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
-                                     uint64_t ModuleOffset,
+                                     object::SectionedAddress ModuleOffset,
                                      StringRef DWPName = "");
-  Expected<DIInliningInfo> symbolizeInlinedCode(const std::string &ModuleName,
-                                                uint64_t ModuleOffset,
-                                                StringRef DWPName = "");
+  Expected<DIInliningInfo>
+  symbolizeInlinedCode(const std::string &ModuleName,
+                       object::SectionedAddress ModuleOffset,
   Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
-                                   uint64_t ModuleOffset);
+                                   object::SectionedAddress ModuleOffset);
   void flush();
 
   static std::string
   DemangleName(const std::string &Name,
                const SymbolizableModule *DbiModuleDescriptor);
 
 private:
   // Bundles together object file with code/data and object file with

llvm/include/llvm/Object/ObjectFile.h

iterator_range<relocation_iterator> relocations() const {
     return make_range(relocation_begin(), relocation_end());
   }
   section_iterator getRelocatedSection() const;
 
   DataRefImpl getRawDataRefImpl() const;
   const ObjectFile *getObject() const;
 };
 
+struct SectionedAddress {
+  // TODO: constructors could be removed when C++14 would be adopted.
+  SectionedAddress() {}
+  SectionedAddress(uint64_t Addr, uint64_t SectIdx)
+      : Address(Addr), SectionIndex(SectIdx) {}
+
+  const static uint64_t UndefSection = UINT64_MAX;
+
+  uint64_t Address = 0;
+  uint64_t SectionIndex = UndefSection;
+};
+
+inline bool operator<(const SectionedAddress &LHS,
+                      const SectionedAddress &RHS) {
+  return std::tie(LHS.SectionIndex, LHS.Address) <
+         std::tie(RHS.SectionIndex, RHS.Address);
+}
+
+inline bool operator==(const SectionedAddress &LHS,
+                       const SectionedAddress &RHS) {
+  return std::tie(LHS.SectionIndex, LHS.Address) ==
+         std::tie(RHS.SectionIndex, RHS.Address);
+}
+
 /// This is a value type class that represents a single symbol in the list of
 /// symbols in the object file.
 class SymbolRef : public BasicSymbolRef {
   friend class SectionRef;
 
 public:
   enum Type {
     ST_Unknown, // Type not specified
public:
   virtual uint8_t getBytesInAddress() const = 0;
 
   virtual StringRef getFileFormatName() const = 0;
   virtual Triple::ArchType getArch() const = 0;
   virtual SubtargetFeatures getFeatures() const = 0;
   virtual void setARMSubArch(Triple &TheTriple) const { }
   virtual Expected<uint64_t> getStartAddress() const {
     return errorCodeToError(object_error::parse_failed);
   };
 
   /// Create a triple from the data in this object file.
   Triple makeTriple() const;
 
   virtual std::error_code
     getBuildAttributes(ARMAttributeParser &Attributes) const {
       return std::error_code();
     }

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize,
       Offset = TableOffset + Length;
     } else {
       AddrTable.dump(OS, DumpOpts);
     }
   }
 }
 
 // Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
-static void
-dumpRnglistsSection(raw_ostream &OS, DWARFDataExtractor &rnglistData,
-                    llvm::function_ref<Optional<SectionedAddress>(uint32_t)>
-                        LookupPooledAddress,
-                    DIDumpOptions DumpOpts) {
+static void dumpRnglistsSection(
+    raw_ostream &OS, DWARFDataExtractor &rnglistData,
+    llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
   uint32_t Offset = 0;
   while (rnglistData.isValidOffset(Offset)) {
     llvm::DWARFDebugRnglistTable Rnglists;
     uint32_t TableOffset = Offset;
     if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
       WithColor::error() << toString(std::move(Err)) << '\n';
       uint64_t Length = Rnglists.length();
       // Keep going after an error, if we can, assuming that the length field
while (!Worklist.empty()) {
 
     for (auto Child : DIE)
       Worklist.push_back(Child);
   }
 
   return Result;
 }
 
+/// TODO: change input parameter from "uint64_t Address"
+///       into "SectionedAddress Address"
 static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU,
                                                   uint64_t Address,
                                                   FunctionNameKind Kind,
                                                   std::string &FunctionName,
                                                   uint32_t &StartLine) {
   // The address may correspond to instruction in some inlined function,
   // so we have to build the chain of inlined functions and take the
   // name of the topmost function in it.
static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU,
   if (auto DeclLineResult = DIE.getDeclLine()) {
     StartLine = DeclLineResult;
     FoundResult = true;
   }
 
   return FoundResult;
 }
 
-DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
+DILineInfo DWARFContext::getLineInfoForAddress(object::SectionedAddress Address,
                                                DILineInfoSpecifier Spec) {
   DILineInfo Result;
 
-  DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
+  DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
   if (!CU)
     return Result;
-  getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind,
-                                        Result.FunctionName,
-                                        Result.StartLine);
+
+  getFunctionNameAndStartLineForAddress(CU, Address.Address, Spec.FNKind,
+                                        Result.FunctionName, Result.StartLine);
   if (Spec.FLIKind != FileLineInfoKind::None) {
-    if (const DWARFLineTable *LineTable = getLineTableForUnit(CU))
-      LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
-                                           Spec.FLIKind, Result);
+    if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) {
+      LineTable->getFileLineInfoForAddress(
+          {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
     }
+  }
   return Result;
 }
 
-DILineInfoTable
-DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
-                                         DILineInfoSpecifier Spec) {
+DILineInfoTable DWARFContext::getLineInfoForAddressRange(
+    object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Spec) {
   DILineInfoTable  Lines;
-  DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
+  DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
   if (!CU)
     return Lines;
 
   std::string FunctionName = "<invalid>";
   uint32_t StartLine = 0;
-  getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind, FunctionName,
-                                        StartLine);
+  getFunctionNameAndStartLineForAddress(CU, Address.Address, Spec.FNKind,
+                                        FunctionName, StartLine);
 
   // If the Specifier says we don't need FileLineInfo, just
   // return the top-most function at the starting address.
   if (Spec.FLIKind == FileLineInfoKind::None) {
     DILineInfo Result;
     Result.FunctionName = FunctionName;
     Result.StartLine = StartLine;
-    Lines.push_back(std::make_pair(Address, Result));
+    Lines.push_back(std::make_pair(Address.Address, Result));
     return Lines;
   }
 
   const DWARFLineTable *LineTable = getLineTableForUnit(CU);
 
   // Get the index of row we're looking for in the line table.
   std::vector<uint32_t> RowVector;
-  if (!LineTable->lookupAddressRange(Address, Size, RowVector))
+  if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex},
+                                     Size, RowVector)) {
     return Lines;
+  }
 
   for (uint32_t RowIndex : RowVector) {
     // Take file number and line/column from the row.
     const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
     DILineInfo Result;
     LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
                                   Spec.FLIKind, Result.FileName);
     Result.FunctionName = FunctionName;
     Result.Line = Row.Line;
     Result.Column = Row.Column;
     Result.StartLine = StartLine;
-    Lines.push_back(std::make_pair(Row.Address, Result));
+    Lines.push_back(std::make_pair(Row.Address.Address, Result));
   }
 
   return Lines;
 }
 
 DIInliningInfo
-DWARFContext::getInliningInfoForAddress(uint64_t Address,
+DWARFContext::getInliningInfoForAddress(object::SectionedAddress Address,
                                         DILineInfoSpecifier Spec) {
   DIInliningInfo InliningInfo;
 
-  DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
+  DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
   if (!CU)
     return InliningInfo;
 
   const DWARFLineTable *LineTable = nullptr;
   SmallVector<DWARFDie, 4> InlinedChain;
-  CU->getInlinedChainForAddress(Address, InlinedChain);
+  CU->getInlinedChainForAddress(Address.Address, InlinedChain);
   if (InlinedChain.size() == 0) {
     // If there is no DIE for address (e.g. it is in unavailable .dwo file),
     // try to at least get file/line info from symbol table.
     if (Spec.FLIKind != FileLineInfoKind::None) {
       DILineInfo Frame;
       LineTable = getLineTableForUnit(CU);
-      if (LineTable &&
-          LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
-                                               Spec.FLIKind, Frame))
+      if (LineTable && LineTable->getFileLineInfoForAddress(
+                           {Address.Address, Address.SectionIndex},
+                           CU->getCompilationDir(), Spec.FLIKind, Frame))
         InliningInfo.addFrame(Frame);
     }
     return InliningInfo;
   }
 
   uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
   for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
     DWARFDie &FunctionDIE = InlinedChain[i];
     DILineInfo Frame;
     // Get function name if necessary.
     if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
       Frame.FunctionName = Name;
     if (auto DeclLineResult = FunctionDIE.getDeclLine())
       Frame.StartLine = DeclLineResult;
     if (Spec.FLIKind != FileLineInfoKind::None) {
       if (i == 0) {
         // For the topmost frame, initialize the line table of this
         // compile unit and fetch file/line info from it.
         LineTable = getLineTableForUnit(CU);
         // For the topmost routine, get file/line info from line table.
         if (LineTable)
-          LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
-                                               Spec.FLIKind, Frame);
+          LineTable->getFileLineInfoForAddress(
+              {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
       } else {
         // Otherwise, use call file, call line and call column from
         // previous DIE in inlined chain.
         if (LineTable)
           LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
                                         Spec.FLIKind, Frame.FileName);
         Frame.Line = CallLine;
         Frame.Column = CallColumn;

llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp

 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 
 using namespace llvm;
 
 uint64_t DWARFDataExtractor::getRelocatedValue(uint32_t Size, uint32_t *Off,
                                                uint64_t *SecNdx) const {
   if (SecNdx)
-    *SecNdx = -1ULL;
+    *SecNdx = object::SectionedAddress::UndefSection;
   if (!Section)
     return getUnsigned(Off, Size);
   Optional<RelocAddrEntry> Rel = Obj->find(*Section, *Off);
   if (!Rel)
     return getUnsigned(Off, Size);
   if (SecNdx)
     *SecNdx = Rel->SectionIndex;
   return getUnsigned(Off, Size) + Rel->Value;

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 
 void DWARFDebugLine::Row::postAppend() {
   BasicBlock = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
 void DWARFDebugLine::Row::reset(bool DefaultIsStmt) {
-  Address = 0;
+  Address.Address = 0;
+  Address.SectionIndex = object::SectionedAddress::UndefSection;
   Line = 1;
   Column = 0;
   File = 1;
   Isa = 0;
   Discriminator = 0;
   IsStmt = DefaultIsStmt;
   BasicBlock = false;
   EndSequence = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
 void DWARFDebugLine::Row::dumpTableHeader(raw_ostream &OS) {
   OS << "Address            Line   Column File   ISA Discriminator Flags\n"
      << "------------------ ------ ------ ------ --- ------------- "
         "-------------\n";
 }
 
 void DWARFDebugLine::Row::dump(raw_ostream &OS) const {
-  OS << format("0x%16.16" PRIx64 " %6u %6u", Address, Line, Column)
+  OS << format("0x%16.16" PRIx64 " %6u %6u", Address.Address, Line, Column)
      << format(" %6u %3u %13u ", File, Isa, Discriminator)
      << (IsStmt ? " is_stmt" : "") << (BasicBlock ? " basic_block" : "")
      << (PrologueEnd ? " prologue_end" : "")
      << (EpilogueBegin ? " epilogue_begin" : "")
      << (EndSequence ? " end_sequence" : "") << '\n';
 }
 
 DWARFDebugLine::Sequence::Sequence() { reset(); }
 
 void DWARFDebugLine::Sequence::reset() {
   LowPC = 0;
   HighPC = 0;
+  SectionIndex = object::SectionedAddress::UndefSection;
   FirstRowIndex = 0;
   LastRowIndex = 0;
   Empty = true;
 }
 
 DWARFDebugLine::LineTable::LineTable() { clear(); }
 
 void DWARFDebugLine::LineTable::dump(raw_ostream &OS,
void DWARFDebugLine::ParsingState::resetRowAndSequence() {
   Row.reset(LineTable->Prologue.DefaultIsStmt);
   Sequence.reset();
 }
 
 void DWARFDebugLine::ParsingState::appendRowToMatrix(uint32_t Offset) {
   if (Sequence.Empty) {
     // Record the beginning of instruction sequence.
     Sequence.Empty = false;
-    Sequence.LowPC = Row.Address;
+    Sequence.LowPC = Row.Address.Address;
     Sequence.FirstRowIndex = RowNumber;
   }
   ++RowNumber;
   LineTable->appendRow(Row);
   if (Row.EndSequence) {
     // Record the end of instruction sequence.
-    Sequence.HighPC = Row.Address;
+    Sequence.HighPC = Row.Address.Address;
     Sequence.LastRowIndex = RowNumber;
+    Sequence.SectionIndex = Row.Address.SectionIndex;
     if (Sequence.isValid())
       LineTable->appendSequence(Sequence);
     Sequence.reset();
   }
   Row.postAppend();
 }
 
 const DWARFDebugLine::LineTable *
if (Opcode == 0) {
           DebugLineData.setAddressSize(Len - 1);
         else if (DebugLineData.getAddressSize() != Len - 1) {
           return createStringError(errc::invalid_argument,
                              "mismatching address size at offset 0x%8.8" PRIx32
                              " expected 0x%2.2" PRIx8 " found 0x%2.2" PRIx64,
                              ExtOffset, DebugLineData.getAddressSize(),
                              Len - 1);
         }
-        State.Row.Address = DebugLineData.getRelocatedAddress(OffsetPtr);
+        State.Row.Address.Address = DebugLineData.getRelocatedAddress(
+            OffsetPtr, &State.Row.Address.SectionIndex);
         if (OS)
-          *OS << format(" (0x%16.16" PRIx64 ")", State.Row.Address);
+          *OS << format(" (0x%16.16" PRIx64 ")", State.Row.Address.Address);
         break;
 
       case DW_LNE_define_file:
         // Takes 4 arguments. The first is a null terminated string containing
         // a source file name. The second is an unsigned LEB128 number
         // representing the directory index of the directory in which the file
         // was found. The third is an unsigned LEB128 number representing the
         // time of last modification of the file. The fourth is an unsigned
if (Opcode == 0) {
 
       case DW_LNS_advance_pc:
         // Takes a single unsigned LEB128 operand, multiplies it by the
         // min_inst_length field of the prologue, and adds the
         // result to the address register of the state machine.
         {
           uint64_t AddrOffset =
               DebugLineData.getULEB128(OffsetPtr) * Prologue.MinInstLength;
-          State.Row.Address += AddrOffset;
+          State.Row.Address.Address += AddrOffset;
           if (OS)
             *OS << " (" << AddrOffset << ")";
         }
         break;
 
       case DW_LNS_advance_line:
         // Takes a single signed LEB128 operand and adds that value to
         // the line register of the state machine.
if (Opcode == 0) {
         // DW_LNS_const_add_pc followed by a special opcode, for a total
         // of two bytes. Only if it needs to advance the address by more
         // than twice that range will it need to use both DW_LNS_advance_pc
         // and a special opcode, requiring three or more bytes.
         {
           uint8_t AdjustOpcode = 255 - Prologue.OpcodeBase;
           uint64_t AddrOffset =
               (AdjustOpcode / Prologue.LineRange) * Prologue.MinInstLength;
-          State.Row.Address += AddrOffset;
+          State.Row.Address.Address += AddrOffset;
           if (OS)
             *OS
                 << format(" (0x%16.16" PRIx64 ")", AddrOffset);
         }
         break;
 
       case DW_LNS_fixed_advance_pc:
         // Takes a single uhalf operand. Add to the address register of
         // the state machine the value of the (unencoded) operand. This
         // is the only extended opcode that takes an argument that is not
         // a variable length number. The motivation for DW_LNS_fixed_advance_pc
         // is this: existing assemblers cannot emit DW_LNS_advance_pc or
         // special opcodes because they cannot encode LEB128 numbers or
         // judge when the computation of a special opcode overflows and
         // requires the use of DW_LNS_advance_pc. Such assemblers, however,
         // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
         {
           uint16_t PCOffset = DebugLineData.getU16(OffsetPtr);
-          State.Row.Address += PCOffset;
+          State.Row.Address.Address += PCOffset;
           if (OS)
             *OS
                 << format(" (0x%16.16" PRIx64 ")", PCOffset);
         }
         break;
 
       case DW_LNS_set_prologue_end:
         // Takes no arguments. Set the prologue_end register of the
if (Opcode == 0) {
       // line increment = line_base + (adjusted opcode % line_range)
 
       uint8_t AdjustOpcode = Opcode - Prologue.OpcodeBase;
       uint64_t AddrOffset =
           (AdjustOpcode / Prologue.LineRange) * Prologue.MinInstLength;
       int32_t LineOffset =
           Prologue.LineBase + (AdjustOpcode % Prologue.LineRange);
       State.Row.Line += LineOffset;
-      State.Row.Address += AddrOffset;
+      State.Row.Address.Address += AddrOffset;
 
       if (OS) {
         *OS << "address += " << AddrOffset << ",  line += " << LineOffset
             << "\n";
         OS->indent(12);
         State.Row.dump(*OS);
       }
 
if (!Sequences.empty()) {
     // We don't report warning in this case. For example,
     // sometimes .so compiled from multiple object files contains a few
     // rudimentary sequences for address ranges [0x0, 0xsomething).
   }
 
   return Error::success();
 }
 
-uint32_t
-DWARFDebugLine::LineTable::findRowInSeq(const DWARFDebugLine::Sequence &Seq,
-                                        uint64_t Address) const {
+uint32_t DWARFDebugLine::LineTable::findRowInSeq(
+    const DWARFDebugLine::Sequence &Seq,
+    object::SectionedAddress Address) const {
   if (!Seq.containsPC(Address))
     return UnknownRowIndex;
+  assert(Seq.SectionIndex == Address.SectionIndex);
   // Search for instruction address in the rows describing the sequence.
   // Rows are stored in a vector, so we may use arithmetical operations with
   // iterators.
   DWARFDebugLine::Row Row;
   Row.Address = Address;
   RowIter FirstRow = Rows.begin() + Seq.FirstRowIndex;
   RowIter LastRow = Rows.begin() + Seq.LastRowIndex;
   LineTable::RowIter RowPos = std::lower_bound(
       FirstRow, LastRow, Row, DWARFDebugLine::Row::orderByAddress);
   if (RowPos == LastRow) {
     return Seq.LastRowIndex - 1;
   }
+  assert(Seq.SectionIndex == RowPos->Address.SectionIndex);
   uint32_t Index = Seq.FirstRowIndex + (RowPos - FirstRow);
-  if (RowPos->Address > Address) {
+  if (RowPos->Address.Address > Address.Address) {
     if (RowPos == FirstRow)
       return UnknownRowIndex;
     else
       Index--;
   }
   return Index;
 }
 
-uint32_t DWARFDebugLine::LineTable::lookupAddress(uint64_t Address) const {
+uint32_t DWARFDebugLine::LineTable::lookupAddress(
+    object::SectionedAddress Address) const {
+
+  // Search for relocatable addresses
+  uint32_t Result = lookupAddressImpl(Address);
+
+  if (Result != UnknownRowIndex ||
+      Address.SectionIndex == object::SectionedAddress::UndefSection)
+    return Result;
+
+  // Search for absolute addresses
+  Address.SectionIndex = object::SectionedAddress::UndefSection;
+  return lookupAddressImpl(Address);
+}
+
+uint32_t DWARFDebugLine::LineTable::lookupAddressImpl(
+    object::SectionedAddress Address) const {
   if (Sequences.empty())
     return UnknownRowIndex;
   // First, find an instruction sequence containing the given address.
   DWARFDebugLine::Sequence Sequence;
-  Sequence.LowPC = Address;
+  Sequence.SectionIndex = Address.SectionIndex;
+  Sequence.LowPC = Address.Address;
   SequenceIter FirstSeq = Sequences.begin();
   SequenceIter LastSeq = Sequences.end();
   SequenceIter SeqPos = std::lower_bound(
       FirstSeq, LastSeq, Sequence, DWARFDebugLine::Sequence::orderByLowPC);
   DWARFDebugLine::Sequence FoundSeq;
+
   if (SeqPos == LastSeq) {
     FoundSeq = Sequences.back();
-  } else if (SeqPos->LowPC == Address) {
+  } else if (SeqPos->LowPC == Address.Address &&
+             SeqPos->SectionIndex == Address.SectionIndex) {
     FoundSeq = *SeqPos;
   } else {
     if (SeqPos == FirstSeq)
       return UnknownRowIndex;
     FoundSeq = *(SeqPos - 1);
   }
+  if (FoundSeq.SectionIndex != Address.SectionIndex)
+    return UnknownRowIndex;
   return findRowInSeq(FoundSeq, Address);
 }
 
 bool DWARFDebugLine::LineTable::lookupAddressRange(
-    uint64_t Address, uint64_t Size, std::vector<uint32_t> &Result) const {
+    object::SectionedAddress Address, uint64_t Size,
+    std::vector<uint32_t> &Result) const {
+
+  // Search for relocatable addresses
+  if (lookupAddressRangeImpl(Address, Size, Result))
+    return true;
+
+  if (Address.SectionIndex == object::SectionedAddress::UndefSection)
+    return false;
+
+  // Search for absolute addresses
+  Address.SectionIndex = object::SectionedAddress::UndefSection;
+  return lookupAddressRangeImpl(Address, Size, Result);
+}
+
+bool DWARFDebugLine::LineTable::lookupAddressRangeImpl(
+    object::SectionedAddress Address, uint64_t Size,
+    std::vector<uint32_t> &Result) const {
   if (Sequences.empty())
     return false;
-  uint64_t EndAddr = Address + Size;
+  uint64_t EndAddr = Address.Address + Size;
   // First, find an instruction sequence containing the given address.
   DWARFDebugLine::Sequence Sequence;
-  Sequence.LowPC = Address;
+  Sequence.SectionIndex = Address.SectionIndex;
+  Sequence.LowPC = Address.Address;
   SequenceIter FirstSeq = Sequences.begin();
   SequenceIter LastSeq = Sequences.end();
   SequenceIter SeqPos = std::lower_bound(
       FirstSeq, LastSeq, Sequence, DWARFDebugLine::Sequence::orderByLowPC);
-  if (SeqPos == LastSeq || SeqPos->LowPC != Address) {
+  if (SeqPos == LastSeq || !SeqPos->containsPC(Address)) {
     if (SeqPos == FirstSeq)
       return false;
     SeqPos--;
   }
   if (!SeqPos->containsPC(Address))
     return false;
 
   SequenceIter StartPos = SeqPos;
 
   // Add the rows from the first sequence to the vector, starting with the
   // index we just calculated
 
   while (SeqPos != LastSeq && SeqPos->LowPC < EndAddr) {
     const DWARFDebugLine::Sequence &CurSeq = *SeqPos;
     // For the first sequence, we need to find which row in the sequence is the
     // first in our range.
     uint32_t FirstRowIndex = CurSeq.FirstRowIndex;
     if (SeqPos == StartPos)
       FirstRowIndex = findRowInSeq(CurSeq, Address);
 
     // Figure out the last row in the range.
-    uint32_t LastRowIndex = findRowInSeq(CurSeq, EndAddr - 1);
+    uint32_t LastRowIndex =
+        findRowInSeq(CurSeq, {EndAddr - 1, Address.SectionIndex});
     if (LastRowIndex == UnknownRowIndex)
       LastRowIndex = CurSeq.LastRowIndex - 1;
 
     assert(FirstRowIndex != UnknownRowIndex);
     assert(LastRowIndex != UnknownRowIndex);
 
     for (uint32_t I = FirstRowIndex; I <= LastRowIndex; ++I) {
       Result.push_back(I);
     }
bool DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
 
   // sys::path::append skips empty strings.
   sys::path::append(FilePath, IncludeDir, FileName);
   Result = FilePath.str();
   return true;
 }
 
 bool DWARFDebugLine::LineTable::getFileLineInfoForAddress(
-    uint64_t Address, const char *CompDir, FileLineInfoKind Kind,
-    DILineInfo &Result) const {
+    object::SectionedAddress Address, const char *CompDir,
+    FileLineInfoKind Kind, DILineInfo &Result) const {
   // Get the index of row we're looking for in the line table.
   uint32_t RowIndex = lookupAddress(Address);
   if (RowIndex == -1U)
     return false;
   // Take file number and line/column from the row.
   const auto &Row = Rows[RowIndex];
   if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
     return false;
   Result.Line = Row.Line;
   Result.Column = Row.Column;
   Result.Discriminator = Row.Discriminator;
   Result.Source = getSourceByIndex(Row.File, Kind);
   return true;

llvm/lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

const char *format_str = (AddressSize == 4
                               ? "%08x %08"  PRIx64 " %08"  PRIx64 "\n"
                               : "%08x %016" PRIx64 " %016" PRIx64 "\n");
     OS << format(format_str, Offset, RLE.StartAddress, RLE.EndAddress);
   }
   OS << format("%08x <End of list>\n", Offset);
 }
 
 DWARFAddressRangesVector DWARFDebugRangeList::getAbsoluteRanges(
-    llvm::Optional<SectionedAddress> BaseAddr) const {
+    llvm::Optional<object::SectionedAddress> BaseAddr) const {
   DWARFAddressRangesVector Res;
   for (const RangeListEntry &RLE : Entries) {
     if (RLE.isBaseAddressSelectionEntry(AddressSize)) {
       BaseAddr = {RLE.EndAddress, RLE.SectionIndex};
       continue;
     }
 
     DWARFAddressRange E;

llvm/lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

return createStringError(errc::not_supported,
                        " at offset 0x%" PRIx32,
                        uint32_t(Encoding), *OffsetPtr - 1);
   }
 
   EntryKind = Encoding;
   return Error::success();
 }
 
-DWARFAddressRangesVector
-DWARFDebugRnglist::getAbsoluteRanges(llvm::Optional<SectionedAddress> BaseAddr,
-                                     DWARFUnit &U) const {
+DWARFAddressRangesVector DWARFDebugRnglist::getAbsoluteRanges(
+    llvm::Optional<object::SectionedAddress> BaseAddr, DWARFUnit &U) const {
   DWARFAddressRangesVector Res;
   for (const RangeListEntry &RLE : Entries) {
     if (RLE.EntryKind == dwarf::DW_RLE_end_of_list)
       break;
     if (RLE.EntryKind == dwarf::DW_RLE_base_addressx) {
       BaseAddr = U.getAddrOffsetSectionItem(RLE.Value0);
       if (!BaseAddr)
         BaseAddr = {RLE.Value0, -1ULL};
for (const RangeListEntry &RLE : Entries) {
     Res.push_back(E);
   }
   return Res;
 }
 
 void RangeListEntry::dump(
     raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,
     uint64_t &CurrentBase, DIDumpOptions DumpOpts,
-    llvm::function_ref<Optional<SectionedAddress>(uint32_t)>
+    llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
         LookupPooledAddress) const {
   auto PrintRawEntry = [](raw_ostream &OS, const RangeListEntry &Entry,
                           uint8_t AddrSize, DIDumpOptions DumpOpts) {
     if (DumpOpts.Verbose) {
       DumpOpts.DisplayRawContents = true;
       DWARFAddressRange(Entry.Value0, Entry.Value1)
           .dump(OS, AddrSize, DumpOpts);
       OS << " => ";

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     uint32_t Offset = *FormValue.getAsSectionOffset();
     if (!U->isDWOUnit() && !U->getLocSection()->Data.empty()) {
       DWARFDebugLoc DebugLoc;
       DWARFDataExtractor Data(Obj, *U->getLocSection(), Ctx.isLittleEndian(),
                               Obj.getAddressSize());
       auto LL = DebugLoc.parseOneLocationList(Data, &Offset);
       if (LL) {
         uint64_t BaseAddr = 0;
-        if (Optional<SectionedAddress> BA = U->getBaseAddress())
+        if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
           BaseAddr = BA->Address;
         LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, U,
                  BaseAddr, Indent);
       } else
         OS << "error extracting location list.";
       return;
     }
 
     bool UseLocLists = !U->isDWOUnit();
     StringRef LoclistsSectionData =
         UseLocLists ? Obj.getLoclistsSection().Data : U->getLocSectionData();
 
     if (!LoclistsSectionData.empty()) {
       DataExtractor Data(LoclistsSectionData, Ctx.isLittleEndian(),
                          Obj.getAddressSize());
 
       // Old-style location list were used in DWARF v4 (.debug_loc.dwo section).
       // Modern locations list (.debug_loclists) are used starting from v5.
       // Ideally we should take the version from the .debug_loclists section
       // header, but using CU's version for simplicity.
       auto LL = DWARFDebugLoclists::parseOneLocationList(
           Data, &Offset, UseLocLists ? U->getVersion() : 4);
 
       uint64_t BaseAddr = 0;
-      if (Optional<SectionedAddress> BA = U->getBaseAddress())
+      if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
         BaseAddr = BA->Address;
 
       if (LL)
         LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI,
                  Indent);
       else
         OS << "error extracting location list.";
     }

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

if (IsBlock) {
     }
   }
 
   return true;
 }
 
 void DWARFFormValue::dumpSectionedAddress(raw_ostream &OS,
                                           DIDumpOptions DumpOpts,
-                                          SectionedAddress SA) const {
+                                          object::SectionedAddress SA) const {
   OS << format("0x%016" PRIx64, SA.Address);
   dumpAddressSection(U->getContext().getDWARFObj(), OS, DumpOpts,
                      SA.SectionIndex);
 }
 
 void DWARFFormValue::dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS,
                                         DIDumpOptions DumpOpts,
                                         uint64_t SectionIndex) {
case DW_FORM_addr:
     dumpSectionedAddress(AddrOS, DumpOpts, {Value.uval, Value.SectionIndex});
     break;
   case DW_FORM_addrx:
   case DW_FORM_addrx1:
   case DW_FORM_addrx2:
   case DW_FORM_addrx3:
   case DW_FORM_addrx4:
   case DW_FORM_GNU_addr_index: {
-    Optional<SectionedAddress> A = U->getAddrOffsetSectionItem(UValue);
+    Optional<object::SectionedAddress> A = U->getAddrOffsetSectionItem(UValue);
     if (!A || DumpOpts.Verbose)
       AddrOS << format("indexed (%8.8x) address = ", (uint32_t)UValue);
     if (U == nullptr)
       OS << "<invalid dwarf unit>";
     else if (A)
       dumpSectionedAddress(AddrOS, DumpOpts, *A);
     else
       OS << "<no .debug_addr section>";
Optional<const char *> DWARFFormValue::getAsCString() const {
   return None;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsAddress() const {
   if (auto SA = getAsSectionedAddress())
     return SA->Address;
   return None;
 }
-Optional<SectionedAddress> DWARFFormValue::getAsSectionedAddress() const {
+Optional<object::SectionedAddress>
+DWARFFormValue::getAsSectionedAddress() const {
   if (!isFormClass(FC_Address))
     return None;
   if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx) {
     uint32_t Index = Value.uval;
     if (!U)
       return None;
-    Optional<SectionedAddress> SA = U->getAddrOffsetSectionItem(Index);
+    Optional<object::SectionedAddress> SA = U->getAddrOffsetSectionItem(Index);
     if (!SA)
       return None;
     return SA;
   }
   return {{Value.uval, Value.SectionIndex}};
 }
 
 Optional<uint64_t> DWARFFormValue::getAsReference() const {

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

 
 DWARFUnit::~DWARFUnit() = default;
 
 DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
   return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, isLittleEndian,
                             getAddressByteSize());
 }
 
-Optional<SectionedAddress>
+Optional<object::SectionedAddress>
 DWARFUnit::getAddrOffsetSectionItem(uint32_t Index) const {
   if (IsDWO) {
     auto R = Context.info_section_units();
     auto I = R.begin();
     // Surprising if a DWO file has more than one skeleton unit in it - this
     // probably shouldn't be valid, but if a use case is found, here's where to
     // support it (probably have to linearly search for the matching skeleton CU
     // here)

 }
 
 const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const {
   if (!Abbrevs)
     Abbrevs = Abbrev->getAbbreviationDeclarationSet(Header.getAbbrOffset());
   return Abbrevs;
 }
 
-llvm::Optional<SectionedAddress> DWARFUnit::getBaseAddress() {
+llvm::Optional<object::SectionedAddress> DWARFUnit::getBaseAddress() {
   if (BaseAddr)
     return BaseAddr;
 
   DWARFDie UnitDie = getUnitDIE();
   Optional<DWARFFormValue> PC = UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc});
   BaseAddr = toSectionedAddress(PC);
   return BaseAddr;
 }

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

for (const auto &FileName : LineTable->Prologue.FileNames) {
       FileIndex++;
     }
 
     // Verify rows.
     uint64_t PrevAddress = 0;
     uint32_t RowIndex = 0;
     for (const auto &Row : LineTable->Rows) {
       // Verify row address.
-      if (Row.Address < PrevAddress) {
+      if (Row.Address.Address < PrevAddress) {
         ++NumDebugLineErrors;
         error() << ".debug_line["
                 << format("0x%08" PRIx64,
                           *toSectionOffset(Die.find(DW_AT_stmt_list)))
                 << "] row[" << RowIndex
                 << "] decreases in address from previous row:\n";
 
         DWARFDebugLine::Row::dumpTableHeader(OS);
for (const auto &Row : LineTable->Rows) {
                 << " (valid values are [1," << MaxFileIndex << "]):\n";
         DWARFDebugLine::Row::dumpTableHeader(OS);
         Row.dump(OS);
         OS << '\n';
       }
       if (Row.EndSequence)
         PrevAddress = 0;
       else
-        PrevAddress = Row.Address;
+        PrevAddress = Row.Address.Address;
       ++RowIndex;
     }
   }
 }
 
 DWARFVerifier::DWARFVerifier(raw_ostream &S, DWARFContext &D,
                              DIDumpOptions DumpOpts)
     : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)), IsObjectFile(false),

llvm/lib/DebugInfo/PDB/PDBContext.cpp

PDBContext::PDBContext(const COFFObjectFile &Object,
     : DIContext(CK_PDB), Session(std::move(PDBSession)) {
   ErrorOr<uint64_t> ImageBase = Object.getImageBase();
   if (ImageBase)
     Session->setLoadAddress(ImageBase.get());
 }
 
 void PDBContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts){}
 
-DILineInfo PDBContext::getLineInfoForAddress(uint64_t Address,
+DILineInfo PDBContext::getLineInfoForAddress(object::SectionedAddress Address,
                                              DILineInfoSpecifier Specifier) {
   DILineInfo Result;
-  Result.FunctionName = getFunctionName(Address, Specifier.FNKind);
+  Result.FunctionName = getFunctionName(Address.Address, Specifier.FNKind);
 
   uint32_t Length = 1;
   std::unique_ptr<PDBSymbol> Symbol =
-      Session->findSymbolByAddress(Address, PDB_SymType::None);
+      Session->findSymbolByAddress(Address.Address, PDB_SymType::None);
   if (auto Func = dyn_cast_or_null<PDBSymbolFunc>(Symbol.get())) {
     Length = Func->getLength();
   } else if (auto Data = dyn_cast_or_null<PDBSymbolData>(Symbol.get())) {
     Length = Data->getLength();
   }
 
   // If we couldn't find a symbol, then just assume 1 byte, so that we get
   // only the line number of the first instruction.
-  auto LineNumbers = Session->findLineNumbersByAddress(Address, Length);
+  auto LineNumbers = Session->findLineNumbersByAddress(Address.Address, Length);
   if (!LineNumbers || LineNumbers->getChildCount() == 0)
     return Result;
 
   auto LineInfo = LineNumbers->getNext();
   assert(LineInfo);
   auto SourceFile = Session->getSourceFileById(LineInfo->getSourceFileId());
 
   if (SourceFile &&
       Specifier.FLIKind != DILineInfoSpecifier::FileLineInfoKind::None)
     Result.FileName = SourceFile->getFileName();
   Result.Column = LineInfo->getColumnNumber();
   Result.Line = LineInfo->getLineNumber();
   return Result;
 }
 
 DILineInfoTable
-PDBContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
+PDBContext::getLineInfoForAddressRange(object::SectionedAddress Address,
+                                       uint64_t Size,
                                        DILineInfoSpecifier Specifier) {
   if (Size == 0)
     return DILineInfoTable();
 
   DILineInfoTable Table;
-  auto LineNumbers = Session->findLineNumbersByAddress(Address, Size);
+  auto LineNumbers = Session->findLineNumbersByAddress(Address.Address, Size);
   if (!LineNumbers || LineNumbers->getChildCount() == 0)
     return Table;
 
   while (auto LineInfo = LineNumbers->getNext()) {
-    DILineInfo LineEntry =
-        getLineInfoForAddress(LineInfo->getVirtualAddress(), Specifier);
+    DILineInfo LineEntry = getLineInfoForAddress(
+        {LineInfo->getVirtualAddress(), Address.SectionIndex}, Specifier);
     Table.push_back(std::make_pair(LineInfo->getVirtualAddress(), LineEntry));
   }
   return Table;
 }
 
 DIInliningInfo
-PDBContext::getInliningInfoForAddress(uint64_t Address,
+PDBContext::getInliningInfoForAddress(object::SectionedAddress Address,
                                       DILineInfoSpecifier Specifier) {
   DIInliningInfo InlineInfo;
   DILineInfo Frame = getLineInfoForAddress(Address, Specifier);
   InlineInfo.addFrame(Frame);
   return InlineInfo;
 }
 
 std::string PDBContext::getFunctionName(uint64_t Address,

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.h

 
 namespace symbolize {
 
 class SymbolizableObjectFile : public SymbolizableModule {
 public:
   static ErrorOr<std::unique_ptr<SymbolizableObjectFile>>
   create(object::ObjectFile *Obj, std::unique_ptr<DIContext> DICtx);
 
-  DILineInfo symbolizeCode(uint64_t ModuleOffset, FunctionNameKind FNKind,
+  DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
+                           FunctionNameKind FNKind,
                            bool UseSymbolTable) const override;
-  DIInliningInfo symbolizeInlinedCode(uint64_t ModuleOffset,
+  DIInliningInfo symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
                                       FunctionNameKind FNKind,
                                       bool UseSymbolTable) const override;
-  DIGlobal symbolizeData(uint64_t ModuleOffset) const override;
+  DIGlobal symbolizeData(object::SectionedAddress ModuleOffset) const override;
 
   // Return true if this is a 32-bit x86 PE COFF module.
   bool isWin32Module() const override;
 
   // Returns the preferred base of the module, i.e. where the loader would place
   // it in memory assuming there were no conflicts.
   uint64_t getModulePreferredBase() const override;
 

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

bool SymbolizableObjectFile::shouldOverrideWithSymbolTable(
   // When DWARF is used with -gline-tables-only / -gmlt, the symbol table gives
   // better answers for linkage names than the DIContext. Otherwise, we are
   // probably using PEs and PDBs, and we shouldn't do the override. PE files
   // generally only contain the names of exported symbols.
   return FNKind == FunctionNameKind::LinkageName && UseSymbolTable &&
          isa<DWARFContext>(DebugInfoContext.get());
 }
 
-DILineInfo SymbolizableObjectFile::symbolizeCode(uint64_t ModuleOffset,
-                                                 FunctionNameKind FNKind,
-                                                 bool UseSymbolTable) const {
+DILineInfo
+SymbolizableObjectFile::symbolizeCode(object::SectionedAddress ModuleOffset,
   DILineInfo LineInfo;
   if (DebugInfoContext) {
     LineInfo = DebugInfoContext->getLineInfoForAddress(
         ModuleOffset, getDILineInfoSpecifier(FNKind));
   }
   // Override function name from symbol table if necessary.
   if (shouldOverrideWithSymbolTable(FNKind, UseSymbolTable)) {
     std::string FunctionName;
     uint64_t Start, Size;
-    if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset,
+    if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset.Address,
                                FunctionName, Start, Size)) {
       LineInfo.FunctionName = FunctionName;
     }
   }
   return LineInfo;
 }
 
 DIInliningInfo SymbolizableObjectFile::symbolizeInlinedCode(
-    uint64_t ModuleOffset, FunctionNameKind FNKind, bool UseSymbolTable) const {
+    object::SectionedAddress ModuleOffset, FunctionNameKind FNKind,
+    bool UseSymbolTable) const {
   DIInliningInfo InlinedContext;
 
   if (DebugInfoContext)
     InlinedContext = DebugInfoContext->getInliningInfoForAddress(
         ModuleOffset, getDILineInfoSpecifier(FNKind));
   // Make sure there is at least one frame in context.
   if (InlinedContext.getNumberOfFrames() == 0)
     InlinedContext.addFrame(DILineInfo());
 
   // Override the function name in lower frame with name from symbol table.
   if (shouldOverrideWithSymbolTable(FNKind, UseSymbolTable)) {
     std::string FunctionName;
     uint64_t Start, Size;
-    if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset,
+    if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset.Address,
                                FunctionName, Start, Size)) {
       InlinedContext.getMutableFrame(InlinedContext.getNumberOfFrames() - 1)
           ->FunctionName = FunctionName;
     }
   }
 
   return InlinedContext;
 }
 
-DIGlobal SymbolizableObjectFile::symbolizeData(uint64_t ModuleOffset) const {
+DIGlobal SymbolizableObjectFile::symbolizeData(
+    object::SectionedAddress ModuleOffset) const {
   DIGlobal Res;
-  getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset, Res.Name, Res.Start,
-                         Res.Size);
+  getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset.Address, Res.Name,
+                         Res.Start, Res.Size);
   return Res;
 }

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

 #endif
 #endif
 
 namespace llvm {
 namespace symbolize {
 
 Expected<DILineInfo>
 LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
-                              uint64_t ModuleOffset, StringRef DWPName) {
+                              object::SectionedAddress ModuleOffset,
+                              StringRef DWPName) {
   SymbolizableModule *Info;
   if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName, DWPName))
     Info = InfoOrErr.get();
   else
     return InfoOrErr.takeError();
 
   // A null module means an error has already been reported. Return an empty
   // result.
   if (!Info)
     return DILineInfo();
 
   // If the user is giving us relative addresses, add the preferred base of the
   // object to the offset before we do the query. It's what DIContext expects.
   if (Opts.RelativeAddresses)
-    ModuleOffset += Info->getModulePreferredBase();
+    ModuleOffset.Address += Info->getModulePreferredBase();
 
   DILineInfo LineInfo = Info->symbolizeCode(ModuleOffset, Opts.PrintFunctions,
                                             Opts.UseSymbolTable);
   if (Opts.Demangle)
     LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info);
   return LineInfo;
 }
 
 Expected<DIInliningInfo>
 LLVMSymbolizer::symbolizeInlinedCode(const std::string &ModuleName,
-                                     uint64_t ModuleOffset, StringRef DWPName) {
+                                     object::SectionedAddress ModuleOffset,
+                                     StringRef DWPName) {
   SymbolizableModule *Info;
   if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName, DWPName))
     Info = InfoOrErr.get();
   else
     return InfoOrErr.takeError();
 
   // A null module means an error has already been reported. Return an empty
   // result.
   if (!Info)
     return DIInliningInfo();
 
   // If the user is giving us relative addresses, add the preferred base of the
   // object to the offset before we do the query. It's what DIContext expects.
   if (Opts.RelativeAddresses)
-    ModuleOffset += Info->getModulePreferredBase();
+    ModuleOffset.Address += Info->getModulePreferredBase();
 
   DIInliningInfo InlinedContext = Info->symbolizeInlinedCode(
       ModuleOffset, Opts.PrintFunctions, Opts.UseSymbolTable);
   if (Opts.Demangle) {
     for (int i = 0, n = InlinedContext.getNumberOfFrames(); i < n; i++) {
       auto *Frame = InlinedContext.getMutableFrame(i);
       Frame->FunctionName = DemangleName(Frame->FunctionName, Info);
     }
   }
   return InlinedContext;
 }
 
-Expected<DIGlobal> LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
-                                                 uint64_t ModuleOffset) {
+Expected<DIGlobal>
+LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
+                              object::SectionedAddress ModuleOffset) {
   SymbolizableModule *Info;
   if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
     Info = InfoOrErr.get();
   else
     return InfoOrErr.takeError();
 
   // A null module means an error has already been reported. Return an empty
   // result.
   if (!Info)
     return DIGlobal();
 
   // If the user is giving us relative addresses, add the preferred base of
   // the object to the offset before we do the query. It's what DIContext
   // expects.
   if (Opts.RelativeAddresses)
-    ModuleOffset += Info->getModulePreferredBase();
+    ModuleOffset.Address += Info->getModulePreferredBase();
 
   DIGlobal Global = Info->symbolizeData(ModuleOffset);
   if (Opts.Demangle)
     Global.Name = DemangleName(Global.Name, Info);
   return Global;
 }
 
 void LLVMSymbolizer::flush() {

llvm/test/tools/llvm-objdump/X86/function-sections-line-numbers.s

+# The code below is the reduced version of the output
+# from the following invocation and source:
+#
+# // test.cpp:
+#void f1() {}
+#void f2() {}
+#
+# clang -gdwarf-5 -ffunction-sections test.cpp -o test.s -S
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -dwarf-version=5 %s -o %t.o
+# RUN: llvm-objdump -disassemble -line-numbers -r -s -section-headers -t %t.o | FileCheck %s
+
+
+# CHECK: 0000000000000000 _Z2f1v
+# CHECK-NOT: test.cpp:2
+# CHECK: test.cpp:1
+# CHECK-NOT: test.cpp:2
+# CHECK: 0000000000000000 _Z2f2v
+# CHECK-NOT: test.cpp:1
+# CHECK: test.cpp:2
+# CHECK-NOT: test.cpp:1
+
+
+  .text
+  .file "test.cpp"
+  .section  .text._Z2f1v,"ax",@progbits
+  .globl  _Z2f1v                  # -- Begin function _Z2f1v
+  .p2align  4, 0x90
+  .type _Z2f1v,@function
+_Z2f1v:                                 # @_Z2f1v
+.Lfunc_begin0:
+  .file 0 "/home/avl" "test.cpp" md5 0xefae234cc05b45384d782316d3a5d338
+  .file 1 "test.cpp" md5 0xefae234cc05b45384d782316d3a5d338
+  .loc  1 1 0                   # test.cpp:1:0
+  .cfi_startproc
+# %bb.0:                                # %entry
+  pushq %rbp
+  .cfi_def_cfa_offset 16
+  .cfi_offset %rbp, -16
+  movq  %rsp, %rbp
+  .cfi_def_cfa_register %rbp
+.Ltmp0:
+  .loc  1 1 12 prologue_end     # test.cpp:1:12
+  popq  %rbp
+  .cfi_def_cfa %rsp, 8
+  retq
+.Ltmp1:
+.Lfunc_end0:
+  .size _Z2f1v, .Lfunc_end0-_Z2f1v
+  .cfi_endproc
+                                        # -- End function
+  .section  .text._Z2f2v,"ax",@progbits
+  .globl  _Z2f2v                  # -- Begin function _Z2f2v
+  .p2align  4, 0x90
+  .type _Z2f2v,@function
+_Z2f2v:                                 # @_Z2f2v
+.Lfunc_begin1:
+  .loc  1 2 0                   # test.cpp:2:0
+  .cfi_startproc
+# %bb.0:                                # %entry
+  pushq %rbp
+  .cfi_def_cfa_offset 16
+  .cfi_offset %rbp, -16
+  movq  %rsp, %rbp
+  .cfi_def_cfa_register %rbp
+.Ltmp2:
+  .loc  1 2 12 prologue_end     # test.cpp:2:12
+  popq  %rbp
+  .cfi_def_cfa %rsp, 8
+  retq
+.Ltmp3:
+.Lfunc_end1:
+  .size _Z2f2v, .Lfunc_end1-_Z2f2v
+  .cfi_endproc
+                                        # -- End function
+  .section  .debug_str_offsets,"",@progbits
+  .long 32
+  .short  5
+  .short  0
+.Lstr_offsets_base0:
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang version 9.0.0 (https://github.com/llvm/llvm-project.git ebfc1e5af7a65381d858612517e6414ef58df482)" # string offset=0
+.Linfo_string1:
+  .asciz  "test.cpp"              # string offset=104
+.Linfo_string2:
+  .asciz  "/home/avl"             # string offset=113
+.Linfo_string3:
+  .asciz  "_Z2f1v"                # string offset=123
+.Linfo_string4:
+  .asciz  "f1"                    # string offset=130
+.Linfo_string5:
+  .asciz  "_Z2f2v"                # string offset=133
+.Linfo_string6:
+  .asciz  "f2"                    # string offset=140
+  .section  .debug_str_offsets,"",@progbits
+  .long .Linfo_string0
+  .long .Linfo_string1
+  .long .Linfo_string2
+  .long .Linfo_string3
+  .long .Linfo_string4
+  .long .Linfo_string5
+  .long .Linfo_string6
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 37                      # DW_AT_producer
+  .byte 37                      # DW_FORM_strx1
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 37                      # DW_FORM_strx1
+  .byte 114                     # DW_AT_str_offsets_base
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 27                      # DW_AT_comp_dir
+  .byte 37                      # DW_FORM_strx1
+  .byte 115                     # DW_AT_addr_base
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 85                      # DW_AT_ranges
+  .byte 35                      # DW_FORM_rnglistx
+  .byte 116                     # DW_AT_rnglists_base
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 2                       # Abbreviation Code
+  .byte 46                      # DW_TAG_subprogram
+  .byte 0                       # DW_CHILDREN_no
+  .byte 17                      # DW_AT_low_pc
+  .byte 27                      # DW_FORM_addrx
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .byte 64                      # DW_AT_frame_base
+  .byte 24                      # DW_FORM_exprloc
+  .byte 110                     # DW_AT_linkage_name
+  .byte 37                      # DW_FORM_strx1
+  .byte 3                       # DW_AT_name
+  .byte 37                      # DW_FORM_strx1
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 63                      # DW_AT_external
+  .byte 25                      # DW_FORM_flag_present
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  5                       # DWARF version number
+  .byte 1                       # DWARF Unit Type
+  .byte 8                       # Address Size (in bytes)
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 1                       # Abbrev [1] 0xc:0x38 DW_TAG_compile_unit
+  .byte 0                       # DW_AT_producer
+  .short  4                       # DW_AT_language
+  .byte 1                       # DW_AT_name
+  .long .Lstr_offsets_base0     # DW_AT_str_offsets_base
+  .long .Lline_table_start0     # DW_AT_stmt_list
+  .byte 2                       # DW_AT_comp_dir
+  .long .Laddr_table_base0      # DW_AT_addr_base
+  .quad 0                       # DW_AT_low_pc
+  .byte 0                       # DW_AT_ranges
+  .long .Lrnglists_table_base0  # DW_AT_rnglists_base
+  .byte 2                       # Abbrev [2] 0x2b:0xc DW_TAG_subprogram
+  .byte 0                       # DW_AT_low_pc
+  .long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+  .byte 1                       # DW_AT_frame_base
+  .byte 86
+  .byte 3                       # DW_AT_linkage_name
+  .byte 4                       # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+                                        # DW_AT_external
+  .byte 2                       # Abbrev [2] 0x37:0xc DW_TAG_subprogram
+  .byte 1                       # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin1 # DW_AT_high_pc
+  .byte 1                       # DW_AT_frame_base
+  .byte 86
+  .byte 5                       # DW_AT_linkage_name
+  .byte 6                       # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 2                       # DW_AT_decl_line
+                                        # DW_AT_external
+  .byte 0                       # End Of Children Mark
+.Ldebug_info_end0:
+  .section  .debug_rnglists,"",@progbits
+  .long .Ldebug_rnglist_table_end0-.Ldebug_rnglist_table_start0 # Length
+.Ldebug_rnglist_table_start0:
+  .short  5                       # Version
+  .byte 8                       # Address size
+  .byte 0                       # Segment selector size
+  .long 1                       # Offset entry count
+.Lrnglists_table_base0:
+  .long .Ldebug_ranges0-.Lrnglists_table_base0
+.Ldebug_ranges0:
+  .byte 3                       # DW_RLE_startx_length
+  .byte 0                       #   start index
+  .uleb128 .Lfunc_end0-.Lfunc_begin0 #   length
+  .byte 3                       # DW_RLE_startx_length
+  .byte 1                       #   start index
+  .uleb128 .Lfunc_end1-.Lfunc_begin1 #   length
+  .byte 0                       # DW_RLE_end_of_list
+.Ldebug_rnglist_table_end0:
+.Ldebug_addr_start0:
+  .short  5                       # DWARF version number
+  .byte 8                       # Address size
+  .byte 0                       # Segment selector size
+.Laddr_table_base0:
+  .quad .Lfunc_begin0
+  .quad .Lfunc_begin1
+.Ldebug_addr_end0:
+
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

llvm/tools/dsymutil/DwarfLinker.cpp

void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
   // Iterate over the object file line info and extract the sequences
   // that correspond to linked functions.
   for (auto &Row : LineTable.Rows) {
     // Check whether we stepped out of the range. The range is
     // half-open, but consider accept the end address of the range if
     // it is marked as end_sequence in the input (because in that
     // case, the relocation offset is accurate and that entry won't
     // serve as the start of another function).
-    if (CurrRange == InvalidRange || Row.Address < CurrRange.start() ||
-        Row.Address > CurrRange.stop() ||
-        (Row.Address == CurrRange.stop() && !Row.EndSequence)) {
+    if (CurrRange == InvalidRange || Row.Address.Address < CurrRange.start() ||
+        Row.Address.Address > CurrRange.stop() ||
+        (Row.Address.Address == CurrRange.stop() && !Row.EndSequence)) {
       // We just stepped out of a known range. Insert a end_sequence
       // corresponding to the end of the range.
       uint64_t StopAddress = CurrRange != InvalidRange
                                  ? CurrRange.stop() + CurrRange.value()
                                  : -1ULL;
-      CurrRange = FunctionRanges.find(Row.Address);
+      CurrRange = FunctionRanges.find(Row.Address.Address);
       bool CurrRangeValid =
-          CurrRange != InvalidRange && CurrRange.start() <= Row.Address;
+          CurrRange != InvalidRange && CurrRange.start() <= Row.Address.Address;
       if (!CurrRangeValid) {
         CurrRange = InvalidRange;
         if (StopAddress != -1ULL) {
           // Try harder by looking in the DebugMapObject function
           // ranges map. There are corner cases where this finds a
           // valid entry. It's unclear if this is right or wrong, but
           // for now do as dsymutil.
           // FIXME: Understand exactly what cases this addresses and
           // potentially remove it along with the Ranges map.
-          auto Range = Ranges.lower_bound(Row.Address);
+          auto Range = Ranges.lower_bound(Row.Address.Address);
           if (Range != Ranges.begin() && Range != Ranges.end())
             --Range;
 
-          if (Range != Ranges.end() && Range->first <= Row.Address &&
-              Range->second.HighPC >= Row.Address) {
-            StopAddress = Row.Address + Range->second.Offset;
+          if (Range != Ranges.end() && Range->first <= Row.Address.Address &&
+              Range->second.HighPC >= Row.Address.Address) {
+            StopAddress = Row.Address.Address + Range->second.Offset;
           }
         }
       }
       if (StopAddress != -1ULL && !Seq.empty()) {
         // Insert end sequence row with the computed end address, but
         // the same line as the previous one.
         auto NextLine = Seq.back();
-        NextLine.Address = StopAddress;
+        NextLine.Address.Address = StopAddress;
         NextLine.EndSequence = 1;
         NextLine.PrologueEnd = 0;
         NextLine.BasicBlock = 0;
         NextLine.EpilogueBegin = 0;
         Seq.push_back(NextLine);
         insertLineSequence(Seq, NewRows);
       }
 
       if (!CurrRangeValid)
         continue;
     }
 
     // Ignore empty sequences.
     if (Row.EndSequence && Seq.empty())
       continue;
 
     // Relocate row address and add it to the current sequence.
-    Row.Address += CurrRange.value();
+    Row.Address.Address += CurrRange.value();
     Seq.emplace_back(Row);
 
     if (Row.EndSequence)
       insertLineSequence(Seq, NewRows);
   }
 
   // Finished extracting, now emit the line tables.
   // FIXME: LLVM hard-codes its prologue values. We just copy the

llvm/tools/dsymutil/DwarfStreamer.cpp

void DwarfStreamer::emitLineTableForUnit(MCDwarfLineTableParams Params,
   for (unsigned Idx = 0; Idx < Rows.size(); ++Idx) {
     auto &Row = Rows[Idx];
 
     int64_t AddressDelta;
     if (Address == -1ULL) {
       MS->EmitIntValue(dwarf::DW_LNS_extended_op, 1);
       MS->EmitULEB128IntValue(PointerSize + 1);
       MS->EmitIntValue(dwarf::DW_LNE_set_address, 1);
-      MS->EmitIntValue(Row.Address, PointerSize);
+      MS->EmitIntValue(Row.Address.Address, PointerSize);
       LineSectionSize += 2 + PointerSize + getULEB128Size(PointerSize + 1);
       AddressDelta = 0;
     } else {
-      AddressDelta = (Row.Address - Address) / MinInstLength;
+      AddressDelta = (Row.Address.Address - Address) / MinInstLength;
     }
 
     // FIXME: code copied and transformed from MCDwarf.cpp::EmitDwarfLineTable.
     // We should find a way to share this code, but the current compatibility
     // requirement with classic dsymutil makes it hard. Revisit that once this
     // requirement is dropped.
 
     if (FileNum != Row.File) {
for (unsigned Idx = 0; Idx < Rows.size(); ++Idx) {
     }
 
     int64_t LineDelta = int64_t(Row.Line) - LastLine;
     if (!Row.EndSequence) {
       MCDwarfLineAddr::Encode(*MC, Params, LineDelta, AddressDelta, EncodingOS);
       MS->EmitBytes(EncodingOS.str());
       LineSectionSize += EncodingBuffer.size();
       EncodingBuffer.resize(0);
-      Address = Row.Address;
+      Address = Row.Address.Address;
       LastLine = Row.Line;
       RowsSinceLastSequence++;
     } else {
       if (LineDelta) {
         MS->EmitIntValue(dwarf::DW_LNS_advance_line, 1);
         MS->EmitSLEB128IntValue(LineDelta);
         LineSectionSize += 1 + getSLEB128Size(LineDelta);
       }

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h

public:
   // well as the previous instruction if it can fall through.
   std::set<const Instr *>
   getDirectControlFlowXRefs(const Instr &InstrMeta) const;
 
   // Returns whether this instruction uses a register operand.
   bool usesRegisterOperand(const Instr &InstrMeta) const;
 
   // Returns the list of indirect instructions.
-  const std::set<uint64_t> &getIndirectInstructions() const;
+  const std::set<object::SectionedAddress> &getIndirectInstructions() const;
 
   const MCRegisterInfo *getRegisterInfo() const;
   const MCInstrInfo *getMCInstrInfo() const;
   const MCInstrAnalysis *getMCInstrAnalysis() const;
 
   // Returns the inlining information for the provided address.
-  Expected<DIInliningInfo> symbolizeInlinedCode(uint64_t Address);
+  Expected<DIInliningInfo>
+  symbolizeInlinedCode(object::SectionedAddress Address);
 
   // Returns whether the provided Graph represents a protected indirect control
   // flow instruction in this file.
   CFIProtectionStatus validateCFIProtection(const GraphResult &Graph) const;
 
   // Returns the first place the operand register is clobbered between the CFI-
   // check and the indirect CF instruction execution. We do this by walking
   // backwards from the indirect CF and ensuring there is at most one load
protected:
   FileAnalysis(const Triple &ObjectTriple, const SubtargetFeatures &Features);
 
   // Add an instruction to this object.
   void addInstruction(const Instr &Instruction);
 
   // Disassemble and parse the provided bytes into this object. Instruction
   // address calculation is done relative to the provided SectionAddress.
   void parseSectionContents(ArrayRef<uint8_t> SectionBytes,
-                            uint64_t SectionAddress);
+                            object::SectionedAddress Address);
 
   // Constructs and initialises members required for disassembly.
   Error initialiseDisassemblyMembers();
 
   // Parses code sections from the internal object file. Saves them into the
   // internal members. Should only be called once by Create().
   Error parseCodeSections();
 
private:
   // insertion allocation.
   std::map<uint64_t, Instr> Instructions;
 
   // Contains a mapping between a specific address, and a list of instructions
   // that use this address as a branch target (including call instructions).
   DenseMap<uint64_t, std::vector<uint64_t>> StaticBranchTargetings;
 
   // A list of addresses of indirect control flow instructions.
-  std::set<uint64_t> IndirectInstructions;
+  std::set<object::SectionedAddress> IndirectInstructions;
 
   // The addresses of functions that will trap on CFI violations.
   SmallSet<uint64_t, 4> TrapOnFailFunctionAddresses;
 };
 
 class UnsupportedDisassembly : public ErrorInfo<UnsupportedDisassembly> {
 public:
   static char ID;

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

for (uint64_t SourceInstrAddress : TargetRefsKV->second) {
     }
 
     CFCrossReferences.insert(&SourceInstrKV->second);
   }
 
   return CFCrossReferences;
 }
 
-const std::set<uint64_t> &FileAnalysis::getIndirectInstructions() const {
+const std::set<object::SectionedAddress> &
+FileAnalysis::getIndirectInstructions() const {
   return IndirectInstructions;
 }
 
 const MCRegisterInfo *FileAnalysis::getRegisterInfo() const {
   return RegisterInfo.get();
 }
 
 const MCInstrInfo *FileAnalysis::getMCInstrInfo() const { return MII.get(); }
 
 const MCInstrAnalysis *FileAnalysis::getMCInstrAnalysis() const {
   return MIA.get();
 }
 
-Expected<DIInliningInfo> FileAnalysis::symbolizeInlinedCode(uint64_t Address) {
+Expected<DIInliningInfo>
+FileAnalysis::symbolizeInlinedCode(object::SectionedAddress Address) {
   assert(Symbolizer != nullptr && "Symbolizer is invalid.");
+
   return Symbolizer->symbolizeInlinedCode(Object->getFileName(), Address);
 }
 
 CFIProtectionStatus
 FileAnalysis::validateCFIProtection(const GraphResult &Graph) const {
   const Instr *InstrMetaPtr = getInstruction(Graph.BaseAddress);
   if (!InstrMetaPtr)
     return CFIProtectionStatus::FAIL_INVALID_INSTRUCTION;
for (const object::SectionRef &Section : Object->sections()) {
 
     StringRef SectionContents;
     if (Section.getContents(SectionContents))
       return make_error<StringError>("Failed to retrieve section contents",
                                      inconvertibleErrorCode());
 
     ArrayRef<uint8_t> SectionBytes((const uint8_t *)SectionContents.data(),
                                    Section.getSize());
-    parseSectionContents(SectionBytes, Section.getAddress());
+    parseSectionContents(SectionBytes,
+                         {Section.getAddress(), Section.getIndex()});
   }
   return Error::success();
 }
 
 void FileAnalysis::parseSectionContents(ArrayRef<uint8_t> SectionBytes,
-                                        uint64_t SectionAddress) {
+                                        object::SectionedAddress Address) {
   assert(Symbolizer && "Symbolizer is uninitialised.");
   MCInst Instruction;
   Instr InstrMeta;
   uint64_t InstructionSize;
 
   for (uint64_t Byte = 0; Byte < SectionBytes.size();) {
     bool ValidInstruction =
         Disassembler->getInstruction(Instruction, InstructionSize,
                                      SectionBytes.drop_front(Byte), 0, nulls(),
                                      outs()) == MCDisassembler::Success;
 
     Byte += InstructionSize;
 
-    uint64_t VMAddress = SectionAddress + Byte - InstructionSize;
+    uint64_t VMAddress = Address.Address + Byte - InstructionSize;
     InstrMeta.Instruction = Instruction;
     InstrMeta.VMAddress = VMAddress;
     InstrMeta.InstructionSize = InstructionSize;
     InstrMeta.Valid = ValidInstruction;
 
     addInstruction(InstrMeta);
 
     if (!ValidInstruction)
for (uint64_t Byte = 0; Byte < SectionBytes.size();) {
     if (!usesRegisterOperand(InstrMeta))
       continue;
 
     if (InstrDesc.isReturn())
       continue;
 
     // Check if this instruction exists in the range of the DWARF metadata.
     if (!IgnoreDWARFFlag) {
-      auto LineInfo =
-          Symbolizer->symbolizeCode(Object->getFileName(), VMAddress);
+      auto LineInfo = Symbolizer->symbolizeCode(
+          Object->getFileName(), {VMAddress, Address.SectionIndex});
       if (!LineInfo) {
         handleAllErrors(LineInfo.takeError(), [](const ErrorInfoBase &E) {
           errs() << "Symbolizer failed to get line: " << E.message() << "\n";
         });
         continue;
       }
 
       if (LineInfo->FileName == "<invalid>")
         continue;
     }
 
-    IndirectInstructions.insert(VMAddress);
+    IndirectInstructions.insert({VMAddress, Address.SectionIndex});
   }
 }
 
 void FileAnalysis::addInstruction(const Instr &Instruction) {
   const auto &KV =
       Instructions.insert(std::make_pair(Instruction.VMAddress, Instruction));
   if (!KV.second) {
     errs() << "Failed to add instruction at address "
            << format_hex(Instruction.VMAddress, 2)

llvm/tools/llvm-cfi-verify/lib/GraphBuilder.h

 class GraphBuilder {
 public:
   // Build the control flow graph for a provided control flow node. This method
   // will enumerate all branch nodes that can lead to this node, and place them
   // into GraphResult::ConditionalBranchNodes. It will also provide any orphaned
   // (i.e. the upwards traversal did not make it to a branch node) flows to the
   // provided node in GraphResult::OrphanedNodes.
   static GraphResult buildFlowGraph(const FileAnalysis &Analysis,
-                                    uint64_t Address);
+                                    object::SectionedAddress Address);
 
 private:
   // Implementation function that actually builds the flow graph. Retrieves a
   // list of cross references to instruction referenced in `Address`. If any of
   // these XRefs are conditional branches, it will build the other potential
   // path (fallthrough or target) using `buildFlowsToUndefined`. Otherwise, this
   // function will recursively call itself where `Address` in the recursive call
   // is now the XRef. If any XRef is an orphan, it is added to

llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp

void GraphResult::printToDOT(const FileAnalysis &Analysis,
   for (auto &BranchNode : ConditionalBranchNodes) {
     for (auto &V : {BranchNode.Target, BranchNode.Fallthrough})
       printPairToDOT(Analysis, OS, BranchNode.Address, V);
   }
   OS << "}\n";
 }
 
 GraphResult GraphBuilder::buildFlowGraph(const FileAnalysis &Analysis,
-                                         uint64_t Address) {
+                                         object::SectionedAddress Address) {
   GraphResult Result;
-  Result.BaseAddress = Address;
+  Result.BaseAddress = Address.Address;
   DenseSet<uint64_t> OpenedNodes;
 
   const auto &IndirectInstructions = Analysis.getIndirectInstructions();
 
-  if (IndirectInstructions.find(Address) == IndirectInstructions.end())
+  // check that IndirectInstructions contains specified Address
+  if (IndirectInstructions.find(Address) == IndirectInstructions.end()) {
     return Result;
+  }
 
-  buildFlowGraphImpl(Analysis, OpenedNodes, Result, Address, 0);
+  buildFlowGraphImpl(Analysis, OpenedNodes, Result, Address.Address, 0);
   return Result;
 }
 
 void GraphBuilder::buildFlowsToUndefined(const FileAnalysis &Analysis,
                                          GraphResult &Result,
                                          ConditionalBranchNode &BranchNode,
                                          const Instr &BranchInstrMeta) {
   assert(SearchLengthForUndef > 0 &&

llvm/tools/llvm-cfi-verify/llvm-cfi-verify.cpp

void printIndirectCFInstructions(FileAnalysis &Analysis,
                                  const SpecialCaseList *SpecialCaseList) {
   uint64_t ExpectedProtected = 0;
   uint64_t UnexpectedProtected = 0;
   uint64_t ExpectedUnprotected = 0;
   uint64_t UnexpectedUnprotected = 0;
 
   std::map<unsigned, uint64_t> BlameCounter;
 
-  for (uint64_t Address : Analysis.getIndirectInstructions()) {
-    const auto &InstrMeta = Analysis.getInstructionOrDie(Address);
+  for (object::SectionedAddress Address : Analysis.getIndirectInstructions()) {
+    const auto &InstrMeta = Analysis.getInstructionOrDie(Address.Address);
     GraphResult Graph = GraphBuilder::buildFlowGraph(Analysis, Address);
 
     CFIProtectionStatus ProtectionStatus =
         Analysis.validateCFIProtection(Graph);
     bool CFIProtected = (ProtectionStatus == CFIProtectionStatus::PROTECTED);
 
     if (!Summarize) {
       outs() << "-----------------------------------------------------\n";
       printInstructionInformation(Analysis, InstrMeta, Graph, ProtectionStatus);
     }
 
     if (IgnoreDWARFFlag) {
       if (CFIProtected)
         ExpectedProtected++;
       else
         UnexpectedUnprotected++;
       continue;
     }
 
     auto InliningInfo = Analysis.symbolizeInlinedCode(Address);
     if (!InliningInfo || InliningInfo->getNumberOfFrames() == 0) {
-      errs() << "Failed to symbolise " << format_hex(Address, 2)
+      errs() << "Failed to symbolise " << format_hex(Address.Address, 2)
              << " with line tables from " << InputFilename << "\n";
       exit(EXIT_FAILURE);
     }
 
     const auto &LineInfo = InliningInfo->getFrame(0);
 
     // Print the inlining symbolisation of this instruction.
     if (!Summarize) {
       for (uint32_t i = 0; i < InliningInfo->getNumberOfFrames(); ++i) {
         const auto &Line = InliningInfo->getFrame(i);
-        outs() << "  " << format_hex(Address, 2) << " = " << Line.FileName
-               << ":" << Line.Line << ":" << Line.Column << " ("
-               << Line.FunctionName << ")\n";
+        outs() << "  " << format_hex(Address.Address, 2) << " = "
+               << Line.FileName << ":" << Line.Line << ":" << Line.Column
+               << " (" << Line.FunctionName << ")\n";
       }
     }
 
     if (!SpecialCaseList) {
       if (CFIProtected) {
         if (PrintBlameContextAll && !Summarize)
           printBlameContext(LineInfo, PrintBlameContextAll);
         ExpectedProtected++;

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

static void filterByAccelName(ArrayRef<std::string> Names, DWARFContext &DICtx,
   Dies.erase(std::unique(Dies.begin(), Dies.end()), Dies.end());
 
   for (DWARFDie Die : Dies)
     Die.dump(OS, 0, getDumpOpts());
 }
 
 /// Handle the --lookup option and dump the DIEs and line info for the given
 /// address.
-static bool lookup(DWARFContext &DICtx, uint64_t Address, raw_ostream &OS) {
+/// TODO: specified Address for --lookup option could relate for several
+/// different sections(in case not-linked object file). llvm-dwarfdump
+/// need to do something with this: extend lookup option with section
+/// information or probably display all matched entries, or something else...
+static bool lookup(ObjectFile &Obj, DWARFContext &DICtx, uint64_t Address,
+                   raw_ostream &OS) {
   auto DIEsForAddr = DICtx.getDIEsForAddress(Lookup);
 
   if (!DIEsForAddr)
     return false;
 
   DIDumpOptions DumpOpts = getDumpOpts();
   DumpOpts.RecurseDepth = 0;
   DIEsForAddr.CompileUnit->dump(OS, DumpOpts);
   if (DIEsForAddr.FunctionDIE) {
     DIEsForAddr.FunctionDIE.dump(OS, 2, DumpOpts);
     if (DIEsForAddr.BlockDIE)
       DIEsForAddr.BlockDIE.dump(OS, 4, DumpOpts);
   }
 
-  if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(Lookup))
+  // TODO: it is neccessary to set proper SectionIndex here.
+  // object::SectionedAddress::UndefSection works for only absolute addresses.
+  if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(
+          {Lookup, object::SectionedAddress::UndefSection}))
     LineInfo.dump(OS);
 
   return true;
 }
 
 bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                                Twine Filename, raw_ostream &OS);
 
 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx, Twine Filename,
                            raw_ostream &OS) {
   logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
   // Handle the --lookup option.
   if (Lookup)
-    return lookup(DICtx, Lookup, OS);
+    return lookup(Obj, DICtx, Lookup, OS);
 
   // Handle the --name option.
   if (!Name.empty()) {
     StringSet<> Names;
     for (auto name : Name)
       Names.insert((IgnoreCase && !UseRegex) ? StringRef(name).lower() : name);
 
     filterByName(Names, DICtx.normal_units(), OS);

llvm/tools/llvm-objdump/MachODump.cpp

for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
           if (UseThumbTarget)
             ThumbIP->printInst(&Inst, FormattedOS, AnnotationsStr, *ThumbSTI);
           else
             IP->printInst(&Inst, FormattedOS, AnnotationsStr, *STI);
           emitComments(CommentStream, CommentsToEmit, FormattedOS, *AsmInfo);
 
           // Print debug info.
           if (diContext) {
-            DILineInfo dli = diContext->getLineInfoForAddress(PC);
+            DILineInfo dli = diContext->getLineInfoForAddress({PC, SectIdx});
             // Print valid line info if it changed.
             if (dli != lastLine && dli.Line != 0)
               outs() << "\t## " << dli.FileName << ':' << dli.Line << ':'
                      << dli.Column;
             lastLine = dli;
           }
           outs() << "\n";
         } else {

llvm/tools/llvm-objdump/llvm-objdump.cpp

public:
   SourcePrinter() = default;
   SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch) : Obj(Obj) {
     symbolize::LLVMSymbolizer::Options SymbolizerOpts(
         DILineInfoSpecifier::FunctionNameKind::None, true, false, false,
         DefaultArch);
     Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
   }
   virtual ~SourcePrinter() = default;
-  virtual void printSourceLine(raw_ostream &OS, uint64_t Address,
+  virtual void printSourceLine(raw_ostream &OS,
+                               object::SectionedAddress Address,
                                StringRef Delimiter = "; ");
 };
 
 bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
   std::unique_ptr<MemoryBuffer> Buffer;
   if (LineInfo.Source) {
     Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source);
   } else {
if (*End == '\n' || End == BufferStart + BufferSize - 1 ||
       if (*End == '\r')
         End++;
       Start = End + 1;
     }
   SourceCache[LineInfo.FileName] = std::move(Buffer);
   return true;
 }
 
-void SourcePrinter::printSourceLine(raw_ostream &OS, uint64_t Address,
+void SourcePrinter::printSourceLine(raw_ostream &OS,
+                                    object::SectionedAddress Address,
                                     StringRef Delimiter) {
   if (!Symbolizer)
     return;
   DILineInfo LineInfo = DILineInfo();
   auto ExpectecLineInfo =
       Symbolizer->symbolizeCode(Obj->getFileName(), Address);
   if (!ExpectecLineInfo)
     consumeError(ExpectecLineInfo.takeError());
static void printRelocation(const RelocationRef &Rel, uint64_t Address,
   error(getRelocationValueString(Rel, Val));
   outs() << format(Fmt.data(), Address) << Name << "\t" << Val << "\n";
 }
 
 class PrettyPrinter {
 public:
   virtual ~PrettyPrinter() = default;
   virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
-                         ArrayRef<uint8_t> Bytes, uint64_t Address,
-                         raw_ostream &OS, StringRef Annot,
-                         MCSubtargetInfo const &STI, SourcePrinter *SP,
+                         ArrayRef<uint8_t> Bytes,
+                         object::SectionedAddress Address, raw_ostream &OS,
+                         StringRef Annot, MCSubtargetInfo const &STI,
+                         SourcePrinter *SP,
                          std::vector<RelocationRef> *Rels = nullptr) {
     if (SP && (PrintSource || PrintLines))
       SP->printSourceLine(OS, Address);
     if (!NoLeadingAddr)
-      OS << format("%8" PRIx64 ":", Address);
+      OS << format("%8" PRIx64 ":", Address.Address);
     if (!NoShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes, OS);
     }
     if (MI)
       IP.printInst(MI, OS, "", STI);
     else
       OS << " <unknown>";
if (!NoLeadingAddr)
       OS << format("%8" PRIx64 ":", Address);
     if (!NoShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes.slice(0, 4), OS);
       OS << format("%08" PRIx32, opcode);
     }
   }
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
-                 uint64_t Address, raw_ostream &OS, StringRef Annot,
-                 MCSubtargetInfo const &STI, SourcePrinter *SP,
+                 object::SectionedAddress Address, raw_ostream &OS,
+                 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
                  std::vector<RelocationRef> *Rels) override {
     if (SP && (PrintSource || PrintLines))
       SP->printSourceLine(OS, Address, "");
     if (!MI) {
-      printLead(Bytes, Address, OS);
+      printLead(Bytes, Address.Address, OS);
       OS << " <unknown>";
       return;
     }
     std::string Buffer;
     {
       raw_string_ostream TempStream(Buffer);
       IP.printInst(MI, TempStream, "", STI);
     }
     StringRef Contents(Buffer);
     // Split off bundle attributes
     auto PacketBundle = Contents.rsplit('\n');
     // Split off first instruction from the rest
     auto HeadTail = PacketBundle.first.split('\n');
     auto Preamble = " { ";
     auto Separator = "";
 
     // Hexagon's packets require relocations to be inline rather than
     // clustered at the end of the packet.
     std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
     std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
     auto PrintReloc = [&]() -> void {
-      while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address)) {
-        if (RelCur->getOffset() == Address) {
-          printRelocation(*RelCur, Address, 4);
+      while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) {
+        if (RelCur->getOffset() == Address.Address) {
+          printRelocation(*RelCur, Address.Address, 4);
           return;
         }
         ++RelCur;
       }
     };
 
     while (!HeadTail.first.empty()) {
       OS << Separator;
       Separator = "\n";
       if (SP && (PrintSource || PrintLines))
         SP->printSourceLine(OS, Address, "");
-      printLead(Bytes, Address, OS);
+      printLead(Bytes, Address.Address, OS);
       OS << Preamble;
       Preamble = "   ";
       StringRef Inst;
       auto Duplex = HeadTail.first.split('\v');
       if (!Duplex.second.empty()) {
         OS << Duplex.first;
         OS << "; ";
         Inst = Duplex.second;
       }
       else
         Inst = HeadTail.first;
       OS << Inst;
       HeadTail = HeadTail.second.split('\n');
       if (HeadTail.first.empty())
         OS << " } " << PacketBundle.second;
       PrintReloc();
       Bytes = Bytes.slice(4);
-      Address += 4;
+      Address.Address += 4;
     }
   }
 };
 HexagonPrettyPrinter HexagonPrettyPrinterInst;
 
 class AMDGCNPrettyPrinter : public PrettyPrinter {
 public:
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
-                 uint64_t Address, raw_ostream &OS, StringRef Annot,
-                 MCSubtargetInfo const &STI, SourcePrinter *SP,
+                 object::SectionedAddress Address, raw_ostream &OS,
+                 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
                  std::vector<RelocationRef> *Rels) override {
     if (SP && (PrintSource || PrintLines))
       SP->printSourceLine(OS, Address);
 
     typedef support::ulittle32_t U32;
 
     if (MI) {
       SmallString<40> InstStr;
if (MI) {
       } else {
           OS << format("\t.byte 0x%02" PRIx8, Bytes[0]);
           for (unsigned int i = 1; i < Bytes.size(); i++)
             OS << format(", 0x%02" PRIx8, Bytes[i]);
           OS.indent(55 - (6 * Bytes.size()));
       }
     }
 
-    OS << format("// %012" PRIX64 ": ", Address);
+    OS << format("// %012" PRIX64 ": ", Address.Address);
     if (Bytes.size() >=4) {
       for (auto D : makeArrayRef(reinterpret_cast<const U32*>(Bytes.data()),
                                  Bytes.size() / sizeof(U32)))
         // D should be explicitly casted to uint32_t here as it is passed
         // by format to snprintf as vararg.
         OS << format("%08" PRIX32 " ", static_cast<uint32_t>(D));
     } else {
       for (unsigned int i = 0; i < Bytes.size(); i++)
         OS << format("%02" PRIX8 " ", Bytes[i]);
     }
 
     if (!Annot.empty())
       OS << "// " << Annot;
   }
 };
 AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;
 
 class BPFPrettyPrinter : public PrettyPrinter {
 public:
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
-                 uint64_t Address, raw_ostream &OS, StringRef Annot,
-                 MCSubtargetInfo const &STI, SourcePrinter *SP,
+                 object::SectionedAddress Address, raw_ostream &OS,
+                 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
                  std::vector<RelocationRef> *Rels) override {
     if (SP && (PrintSource || PrintLines))
       SP->printSourceLine(OS, Address);
     if (!NoLeadingAddr)
-      OS << format("%8" PRId64 ":", Address / 8);
+      OS << format("%8" PRId64 ":", Address.Address / 8);
     if (!NoShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes, OS);
     }
     if (MI)
       IP.printInst(MI, OS, "", STI);
     else
       OS << " <unknown>";
#endif
         // Disassemble a real instruction or a data when disassemble all is
         // provided
         bool Disassembled = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                                    SectionAddr + Index, DebugOut,
                                                    CommentStream);
         if (Size == 0)
           Size = 1;
 
-        PIP.printInst(
-            *IP, Disassembled ? &Inst : nullptr, Bytes.slice(Index, Size),
-            SectionAddr + Index + VMAAdjustment, outs(), "", *STI, &SP, &Rels);
+        PIP.printInst(*IP, Disassembled ? &Inst : nullptr,
+                      Bytes.slice(Index, Size),
+                      {SectionAddr + Index + VMAAdjustment, Section.getIndex()},
+                      outs(), "", *STI, &SP, &Rels);
         outs() << CommentStream.str();
         Comments.clear();
 
         // Try to resolve the target of a call, tail call, etc. to a specific
         // symbol.
         if (MIA && (MIA->isCall(Inst) || MIA->isUnconditionalBranch(Inst) ||
                     MIA->isConditionalBranch(Inst))) {
           uint64_t Target;

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

for (const auto &P : SymAddr) {
         Expected<uint64_t> AddrOrErr = Sym.getAddress();
         if (!AddrOrErr) {
           // TODO: Actually report errors helpfully.
           consumeError(AddrOrErr.takeError());
           continue;
         }
         uint64_t Addr = *AddrOrErr;
 
+        object::SectionedAddress Address;
+
         uint64_t Size = P.second;
         // If we're not using the debug object, compute the address of the
         // symbol in memory (rather than that in the unrelocated object file)
         // and use that to query the DWARFContext.
         if (!UseDebugObj && LoadObjects) {
           auto SecOrErr = Sym.getSection();
           if (!SecOrErr) {
             // TODO: Actually report errors helpfully.
             consumeError(SecOrErr.takeError());
             continue;
           }
           object::section_iterator Sec = *SecOrErr;
           StringRef SecName;
           Sec->getName(SecName);
+          Address.SectionIndex = Sec->getIndex();
           uint64_t SectionLoadAddress =
             LoadedObjInfo->getSectionLoadAddress(*Sec);
           if (SectionLoadAddress != 0)
             Addr += SectionLoadAddress - Sec->getAddress();
-        }
+        } else if (auto SecOrErr = Sym.getSection())
+          Address.SectionIndex = SecOrErr.get()->getIndex();
 
         outs() << "Function: " << *Name << ", Size = " << Size
                << ", Addr = " << Addr << "\n";
 
-        DILineInfoTable Lines = Context->getLineInfoForAddressRange(Addr, Size);
+        Address.Address = Addr;
+        DILineInfoTable Lines =
+            Context->getLineInfoForAddressRange(Address, Size);
         for (auto &D : Lines) {
           outs() << "  Line info @ " << D.first - Addr << ": "
                  << D.second.FileName << ", line:" << D.second.Line << "\n";
         }
       }
     }
   }
 

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

if (ClBinaryName.empty()) {
     ModuleName = ClBinaryName;
   }
   // Skip delimiters and parse module offset.
   pos += strspn(pos, kDelimiters);
   int offset_length = strcspn(pos, kDelimiters);
   return !StringRef(pos, offset_length).getAsInteger(0, ModuleOffset);
 }
 
+// This routine returns section index for an address.
+// Assumption: would work ambiguously for object files which have sections not
+// assigned to an address(since the same address could belong to various
+// sections).
+static uint64_t getModuleSectionIndexForAddress(const std::string &ModuleName,
+                                                uint64_t Address) {
+
+  Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(ModuleName);
+
+  if (error(BinaryOrErr))
+    return object::SectionedAddress::UndefSection;
+
+  Binary &Binary = *BinaryOrErr->getBinary();
+
+  if (ObjectFile *O = dyn_cast<ObjectFile>(&Binary)) {
+    for (SectionRef Sec : O->sections()) {
+      if (!Sec.isText() || Sec.isVirtual())
+        continue;
+
+      if (Address >= Sec.getAddress() &&
+          Address <= Sec.getAddress() + Sec.getSize()) {
+        return Sec.getIndex();
+      }
+    }
+  }
+
+  return object::SectionedAddress::UndefSection;
+}
+
 static void symbolizeInput(StringRef InputString, LLVMSymbolizer &Symbolizer,
                            DIPrinter &Printer) {
   bool IsData = false;
   std::string ModuleName;
-  uint64_t ModuleOffset = 0;
-  if (!parseCommand(StringRef(InputString), IsData, ModuleName, ModuleOffset)) {
+  uint64_t Offset = 0;
+  if (!parseCommand(StringRef(InputString), IsData, ModuleName, Offset)) {
     outs() << InputString;
     return;
   }
 
   if (ClPrintAddress) {
     outs() << "0x";
-    outs().write_hex(ModuleOffset);
+    outs().write_hex(Offset);
     StringRef Delimiter = ClPrettyPrint ? ": " : "\n";
     outs() << Delimiter;
   }
-  ModuleOffset -= ClAdjustVMA;
+  Offset -= ClAdjustVMA;
+  object::SectionedAddress ModuleOffset = {
+      Offset, getModuleSectionIndexForAddress(ModuleName, Offset)};
   if (IsData) {
     auto ResOrErr = Symbolizer.symbolizeData(ModuleName, ModuleOffset);
     Printer << (error(ResOrErr) ? DIGlobal() : ResOrErr.get());
   } else if (ClPrintInlining) {
     auto ResOrErr =
         Symbolizer.symbolizeInlinedCode(ModuleName, ModuleOffset, ClDwpName);
     Printer << (error(ResOrErr) ? DIInliningInfo() : ResOrErr.get());
   } else {

llvm/tools/llvm-xray/func-id-helper.cpp

std::string FuncIdConversionHelper::SymbolOrNumber(int32_t FuncId) const {
 
   std::ostringstream F;
   auto It = FunctionAddresses.find(FuncId);
   if (It == FunctionAddresses.end()) {
     F << "#" << FuncId;
     return F.str();
   }
 
-  if (auto ResOrErr = Symbolizer.symbolizeCode(BinaryInstrMap, It->second)) {
+  object::SectionedAddress ModuleAddress;
+  ModuleAddress.Address = It->second;
+  // TODO: set proper section index here.
+  // object::SectionedAddress::UndefSection works for only absolute addresses.
+  ModuleAddress.SectionIndex = object::SectionedAddress::UndefSection;
+  if (auto ResOrErr = Symbolizer.symbolizeCode(BinaryInstrMap, ModuleAddress)) {
     auto &DI = *ResOrErr;
     if (DI.FunctionName == "<invalid>")
       F << "@(" << std::hex << It->second << ")";
     else
       F << DI.FunctionName;
   } else
     handleAllErrors(ResOrErr.takeError(), [&](const ErrorInfoBase &) {
       F << "@(" << std::hex << It->second << ")";
     });
 
   auto S = F.str();
   CachedNames[FuncId] = S;
   return S;
 }
 
 std::string FuncIdConversionHelper::FileLineAndColumn(int32_t FuncId) const {
   auto It = FunctionAddresses.find(FuncId);
   if (It == FunctionAddresses.end())
     return "(unknown)";
 
   std::ostringstream F;
-  auto ResOrErr = Symbolizer.symbolizeCode(BinaryInstrMap, It->second);
+  object::SectionedAddress ModuleAddress;
+  ModuleAddress.Address = It->second;
+  // TODO: set proper section index here.
+  // object::SectionedAddress::UndefSection works for only absolute addresses.
+  ModuleAddress.SectionIndex = object::SectionedAddress::UndefSection;
+  auto ResOrErr = Symbolizer.symbolizeCode(BinaryInstrMap, ModuleAddress);
   if (!ResOrErr) {
     consumeError(ResOrErr.takeError());
     return "(unknown)";
   }
 
   auto &DI = *ResOrErr;
   F << sys::path::filename(DI.FileName).str() << ":" << DI.Line << ":"
     << DI.Column;
 
   return F.str();
 }

llvm/tools/sancov/sancov.cpp

getCoveragePoints(const std::string &ObjectFile,
                   const std::set<uint64_t> &CoveredAddrs) {
   std::vector<CoveragePoint> Result;
   auto Symbolizer(createSymbolizer());
   Blacklists B;
 
   std::set<std::string> CoveredFiles;
   if (ClSkipDeadFiles) {
     for (auto Addr : CoveredAddrs) {
-      auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
+      // TODO: it would be neccessary to set proper section index here.
+      // object::SectionedAddress::UndefSection works for only absolute
+      // addresses.
+      object::SectionedAddress ModuleAddress = {
+          Addr, object::SectionedAddress::UndefSection};
+
+      auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, ModuleAddress);
       failIfError(LineInfo);
       CoveredFiles.insert(LineInfo->FileName);
-      auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
+      auto InliningInfo =
+          Symbolizer->symbolizeInlinedCode(ObjectFile, ModuleAddress);
       failIfError(InliningInfo);
       for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
         auto FrameInfo = InliningInfo->getFrame(I);
         CoveredFiles.insert(FrameInfo.FileName);
       }
     }
   }
 
   for (auto Addr : Addrs) {
     std::set<DILineInfo> Infos; // deduplicate debug info.
 
-    auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
+    // TODO: it would be neccessary to set proper section index here.
+    // object::SectionedAddress::UndefSection works for only absolute addresses.
+    object::SectionedAddress ModuleAddress = {
+        Addr, object::SectionedAddress::UndefSection};
+
+    auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, ModuleAddress);
     failIfError(LineInfo);
     if (ClSkipDeadFiles &&
         CoveredFiles.find(LineInfo->FileName) == CoveredFiles.end())
       continue;
     LineInfo->FileName = normalizeFilename(LineInfo->FileName);
     if (B.isBlacklisted(*LineInfo))
       continue;
 
     auto Id = utohexstr(Addr, true);
     auto Point = CoveragePoint(Id);
     Infos.insert(*LineInfo);
     Point.Locs.push_back(*LineInfo);
 
-    auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
+    auto InliningInfo =
+        Symbolizer->symbolizeInlinedCode(ObjectFile, ModuleAddress);
     failIfError(InliningInfo);
     for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
       auto FrameInfo = InliningInfo->getFrame(I);
       if (ClSkipDeadFiles &&
           CoveredFiles.find(FrameInfo.FileName) == CoveredFiles.end())
         continue;
       FrameInfo.FileName = normalizeFilename(FrameInfo.FileName);
       if (B.isBlacklisted(FrameInfo))
symbolize(const RawCoverage &Data, const std::string ObjectFile) {
   SHA1 Hasher;
   Hasher.update((*BufOrErr)->getBuffer());
   Coverage->BinaryHash = toHex(Hasher.final());
 
   Blacklists B;
   auto Symbolizer(createSymbolizer());
 
   for (uint64_t Addr : *Data.Addrs) {
-    auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
+    // TODO: it would be neccessary to set proper section index here.
+    // object::SectionedAddress::UndefSection works for only absolute addresses.
+    auto LineInfo = Symbolizer->symbolizeCode(
+        ObjectFile, {Addr, object::SectionedAddress::UndefSection});
     failIfError(LineInfo);
     if (B.isBlacklisted(*LineInfo))
       continue;
 
     Coverage->CoveredIds.insert(utohexstr(Addr, true));
   }
 
   std::set<uint64_t> AllAddrs = findCoveragePointAddrs(ObjectFile);

llvm/tools/sanstats/sanstats.cpp

while (1) {
     if (Addr == 0 && Data == 0)
       return Begin;
     if (Begin == End)
       return nullptr;
 
     // As the instrumentation tracks the return address and not
     // the address of the call to `__sanitizer_stat_report` we
     // remove one from the address to get the correct DI.
-    if (Expected<DILineInfo> LineInfo =
-            Symbolizer.symbolizeCode(Filename, Addr - 1)) {
+    // TODO: it would be neccessary to set proper section index here.
+    // object::SectionedAddress::UndefSection works for only absolute addresses.
+    if (Expected<DILineInfo> LineInfo = Symbolizer.symbolizeCode(
+            Filename, {Addr - 1, object::SectionedAddress::UndefSection})) {
       llvm::outs() << format_hex(Addr - 1, 18) << ' ' << LineInfo->FileName
                    << ':' << LineInfo->Line << ' ' << LineInfo->FunctionName
                    << ' ';
     } else {
       logAllUnhandledErrors(LineInfo.takeError(), llvm::outs(), "<error> ");
     }
 
     switch (KindFromData(Data, SizeofPtr)) {

llvm/unittests/tools/llvm-cfi-verify/FileAnalysis.cpp

 namespace {
 class ELFTestFileAnalysis : public FileAnalysis {
 public:
   ELFTestFileAnalysis(StringRef Trip)
       : FileAnalysis(Triple(Trip), SubtargetFeatures()) {}
 
   // Expose this method publicly for testing.
   void parseSectionContents(ArrayRef<uint8_t> SectionBytes,
-                            uint64_t SectionAddress) {
-    FileAnalysis::parseSectionContents(SectionBytes, SectionAddress);
+                            object::SectionedAddress Address) {
+    FileAnalysis::parseSectionContents(SectionBytes, Address);
   }
 
   Error initialiseDisassemblyMembers() {
     return FileAnalysis::initialiseDisassemblyMembers();
   }
 };
 
 class BasicFileAnalysisTest : public ::testing::Test {
Analysis.parseSectionContents(
           0x48, 0x89, 0xe5,       // 3: mov %rsp, %rbp
           0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp
           0x48, 0xbe, 0xc4, 0x07, 0x40,
           0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi
           0x2f,                         // 20: (bad)
           0x41, 0x0e,                   // 21: rex.B (bad)
           0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1}
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
 
   EXPECT_EQ(nullptr, Analysis.getInstruction(0x0));
   EXPECT_EQ(nullptr, Analysis.getInstruction(0x1000));
 
   // 0xDEADBEEF: nop
   const auto *InstrMeta = Analysis.getInstruction(0xDEADBEEF);
   EXPECT_NE(nullptr, InstrMeta);
   EXPECT_EQ(0xDEADBEEF, InstrMeta->VMAddress);
TEST_F(BasicX86FileAnalysisTest, PrevAndNextFromBadInst) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x90, // 0: nop
           0x2f, // 1: (bad)
           0x90  // 2: nop
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   const auto &BadInstrMeta = Analysis.getInstructionOrDie(0xDEADBEEF + 1);
   const auto *GoodInstrMeta =
       Analysis.getPrevInstructionSequential(BadInstrMeta);
   EXPECT_NE(nullptr, GoodInstrMeta);
   EXPECT_EQ(0xDEADBEEF, GoodInstrMeta->VMAddress);
   EXPECT_EQ(1u, GoodInstrMeta->InstructionSize);
 
   GoodInstrMeta = Analysis.getNextInstructionSequential(BadInstrMeta);
Analysis.parseSectionContents(
           0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp
           0x48, 0xbe, 0xc4, 0x07, 0x40,
           0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi
           0x2f,                         // 20: (bad)
           0x41, 0x0e,                   // 21: rex.B (bad)
           0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1}
           0x0f, 0x0b                    // 28: ud2
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
 
   EXPECT_FALSE(Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF)));
   EXPECT_FALSE(
       Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 3)));
   EXPECT_FALSE(
       Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 6)));
   EXPECT_FALSE(
       Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 10)));
Analysis.parseSectionContents(
           0x0f, 0x0b,                   // 4: ud2
           0xff, 0x20,                   // 6: jmpq *(%rax)
           0xeb, 0x00,                   // 8: jmp +0
           0xe8, 0x45, 0xfe, 0xff, 0xff, // 10: callq [some loc]
           0xff, 0x10,                   // 15: callq *(rax)
           0x75, 0x00,                   // 17: jne +0
           0xc3,                         // 19: retq
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
 
   EXPECT_TRUE(
       Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF)));
   EXPECT_TRUE(
       Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 1)));
   EXPECT_FALSE(
       Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 3)));
   EXPECT_FALSE(
Analysis.parseSectionContents(
           0xff, 0x10,                   // 27: callq *(rax)
           0x75, 0x00,                   // 29: jne 31 [+0]
           0x75, 0xe0,                   // 31: jne 1 [-32]
           0xc3,                         // 33: retq
           0xeb, 0xdd,                   // 34: jmp 1 [-35]
           0xeb, 0xdd,                   // 36: jmp 3 [-35]
           0xeb, 0xdc,                   // 38: jmp 4 [-36]
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
 
   const auto *Current = Analysis.getInstruction(0xDEADBEEF);
   const auto *Next = Analysis.getDefiniteNextInstruction(*Current);
   EXPECT_NE(nullptr, Next);
   EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress);
 
   Current = Analysis.getInstruction(0xDEADBEEF + 1);
   EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
Analysis.parseSectionContents(
           0xff, 0x10,                   // 27: callq *(rax)
           0x75, 0x00,                   // 29: jne 31 [+0]
           0x75, 0xe0,                   // 31: jne 1 [-32]
           0xc3,                         // 33: retq
           0xeb, 0xdd,                   // 34: jmp 1 [-35]
           0xeb, 0xdd,                   // 36: jmp 3 [-35]
           0xeb, 0xdc,                   // 38: jmp 4 [-36]
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   const auto *InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF);
   std::set<const Instr *> XRefs =
       Analysis.getDirectControlFlowXRefs(*InstrMetaPtr);
   EXPECT_TRUE(XRefs.empty());
 
   InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 1);
   XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr);
   EXPECT_THAT(XRefs, UnorderedElementsAre(
TEST_F(BasicX86FileAnalysisTest, CFIProtectionInvalidTargets) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x90,       // 0: nop
           0x0f, 0x0b, // 1: ud2
           0x75, 0x00, // 3: jne 5 [+0]
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
             Analysis.validateCFIProtection(Result));
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 1);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 1, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
             Analysis.validateCFIProtection(Result));
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 3, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
             Analysis.validateCFIProtection(Result));
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0x12345678);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0x12345678, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_INVALID_INSTRUCTION,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionBasicFallthroughToUd2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0x0f, 0x0b, // 2: ud2
           0xff, 0x10, // 4: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionBasicJumpToUd2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xff, 0x10, // 2: callq *(%rax)
           0x0f, 0x0b, // 4: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 2, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionDualPathUd2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x03, // 0: jne 5 [+3]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x0f, 0x0b, // 5: ud2
           0x75, 0xf9, // 7: jne 2 [-7]
           0x0f, 0x0b, // 9: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 3, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionDualPathSingleUd2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x05, // 0: jne 7 [+5]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x75, 0xfb, // 5: jne 2 [-5]
           0x0f, 0x0b, // 7: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 3, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionDualFailLimitUpwards) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x06, // 0: jne 8 [+6]
           0x90,       // 2: nop
           0x90,       // 3: nop
           0x90,       // 4: nop
           0x90,       // 5: nop
           0xff, 0x10, // 6: callq *(%rax)
           0x0f, 0x0b, // 8: ud2
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   uint64_t PrevSearchLengthForConditionalBranch =
       SearchLengthForConditionalBranch;
   SearchLengthForConditionalBranch = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 6);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 6, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
             Analysis.validateCFIProtection(Result));
 
   SearchLengthForConditionalBranch = PrevSearchLengthForConditionalBranch;
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionDualFailLimitDownwards) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xff, 0x10, // 2: callq *(%rax)
           0x90,       // 4: nop
           0x90,       // 5: nop
           0x90,       // 6: nop
           0x90,       // 7: nop
           0x0f, 0x0b, // 8: ud2
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 2, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_BAD_CONDITIONAL_BRANCH,
             Analysis.validateCFIProtection(Result));
 
   SearchLengthForUndef = PrevSearchLengthForUndef;
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionGoodAndBadPaths) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0xeb, 0x02, // 0: jmp 4 [+2]
           0x75, 0x02, // 2: jne 6 [+2]
           0xff, 0x10, // 4: callq *(%rax)
           0x0f, 0x0b, // 6: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionWithUnconditionalJumpInFallthrough) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x04, // 0: jne 6 [+4]
           0xeb, 0x00, // 2: jmp 4 [+0]
           0xff, 0x10, // 4: callq *(%rax)
           0x0f, 0x0b, // 6: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionComplexExample) {
   if (!SuccessfullyInitialised)
     return;
   // See unittests/GraphBuilder.cpp::BuildFlowGraphComplexExample for this
Analysis.parseSectionContents(
           0xff, 0x10,                   // 9: callq *(%rax)
           0xeb, 0xfc,                   // 11: jmp 9 [-4]
           0x75, 0xfa,                   // 13: jne 9 [-6]
           0xe8, 0x78, 0x56, 0x34, 0x12, // 15: callq OUTOFBOUNDS [+0x12345678]
           0x90,                         // 20: nop
           0x90,                         // 21: nop
           0x0f, 0x0b,                   // 22: ud2
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 5;
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 9);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 9, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = PrevSearchLengthForUndef;
 }
 
 TEST_F(BasicX86FileAnalysisTest, UndefSearchLengthOneTest) {
   Analysis.parseSectionContents(
       {
           0x77, 0x0d,                   // 0x688118: ja 0x688127 [+12]
           0x48, 0x89, 0xdf,             // 0x68811a: mov %rbx, %rdi
           0xff, 0xd0,                   // 0x68811d: callq *%rax
           0x48, 0x89, 0xdf,             // 0x68811f: mov %rbx, %rdi
           0xe8, 0x09, 0x00, 0x00, 0x00, // 0x688122: callq 0x688130
           0x0f, 0x0b,                   // 0x688127: ud2
       },
-      0x688118);
+      {0x688118, 0x0});
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 1;
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x68811d);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, {0x68811d, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = PrevSearchLengthForUndef;
 }
 
 TEST_F(BasicX86FileAnalysisTest, UndefSearchLengthOneTestFarAway) {
   Analysis.parseSectionContents(
       {
           0x74, 0x73,                         // 0x7759eb: je 0x775a60
           0xe9, 0x1c, 0x04, 0x00, 0x00, 0x00, // 0x7759ed: jmpq 0x775e0e
       },
-      0x7759eb);
+      {0x7759eb, 0x0});
 
   Analysis.parseSectionContents(
       {
           0x0f, 0x85, 0xb2, 0x03, 0x00, 0x00, // 0x775a56: jne    0x775e0e
           0x48, 0x83, 0xc3, 0xf4, // 0x775a5c: add    $0xfffffffffffffff4,%rbx
           0x48, 0x8b, 0x7c, 0x24, 0x10, // 0x775a60: mov    0x10(%rsp),%rdi
           0x48, 0x89, 0xde,             // 0x775a65: mov    %rbx,%rsi
           0xff, 0xd1,                   // 0x775a68: callq  *%rcx
       },
-      0x775a56);
+      {0x775a56, 0x0});
 
   Analysis.parseSectionContents(
       {
           0x0f, 0x0b, // 0x775e0e: ud2
       },
-      0x775e0e);
+      {0x775e0e, 0x0});
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 1;
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x775a68);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, {0x775a68, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_BAD_CONDITIONAL_BRANCH,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = 2;
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0x775a68);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0x775a68, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = 3;
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0x775a68);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0x775a68, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = PrevSearchLengthForUndef;
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionClobberSinglePathExplicit) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02,                         // 0: jne 4 [+2]
           0x0f, 0x0b,                         // 2: ud2
           0x48, 0x05, 0x00, 0x00, 0x00, 0x00, // 4: add $0x0, %rax
           0xff, 0x10,                         // 10: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 10);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 10, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionClobberSinglePathExplicit2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02,             // 0: jne 4 [+2]
           0x0f, 0x0b,             // 2: ud2
           0x48, 0x83, 0xc0, 0x00, // 4: add $0x0, %rax
           0xff, 0x10,             // 8: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 8);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 8, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionClobberSinglePathImplicit) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02,                   // 0: jne 4 [+2]
           0x0f, 0x0b,                   // 2: ud2
           0x05, 0x00, 0x00, 0x00, 0x00, // 4: add $0x0, %eax
           0xff, 0x10,                   // 9: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 9);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 9, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicX86FileAnalysisTest, CFIProtectionClobberDualPathImplicit) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x04, // 0: jne 6 [+4]
           0x0f, 0x31, // 2: rdtsc (note: affects eax)
           0xff, 0x10, // 4: callq *(%rax)
           0x0f, 0x0b, // 6: ud2
           0x75, 0xf9, // 8: jne 2 [-7]
           0x0f, 0x0b, // 10: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64BasicUnprotected) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x00, 0x01, 0x3f, 0xd6, // 0: blr x8
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64BasicProtected) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x00, 0x01, 0x3f, 0xd6, // 8: blr x8
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 8);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 8, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberBasic) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x08, 0x05, 0x00, 0x91, // 8: add x8, x8, #1
           0x00, 0x01, 0x3f, 0xd6, // 12: blr x8
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 12);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 12, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberOneLoad) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x21, 0x09, 0x40, 0xf9, // 8: ldr x1, [x9,#16]
           0x20, 0x00, 0x1f, 0xd6, // 12: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 12);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 12, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberLoadAddGood) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x21, 0x04, 0x00, 0x91, // 8: add x1, x1, #1
           0x21, 0x09, 0x40, 0xf9, // 12: ldr x1, [x9,#16]
           0x20, 0x00, 0x1f, 0xd6, // 16: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 16);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 16, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberLoadAddBad) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x21, 0x09, 0x40, 0xf9, // 8: ldr x1, [x9,#16]
           0x21, 0x04, 0x00, 0x91, // 12: add x1, x1, #1
           0x20, 0x00, 0x1f, 0xd6, // 16: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 16);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 16, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberLoadAddBad2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x29, 0x04, 0x00, 0x91, // 16: add x9, x1, #1
           0x21, 0x09, 0x40, 0xf9, // 12: ldr x1, [x9,#16]
           0x20, 0x00, 0x1f, 0xd6, // 16: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 16);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 16, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberTwoLoads) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x21, 0x09, 0x40, 0xf9, // 8: ldr x1, [x9,#16]
           0x21, 0x08, 0x40, 0xf9, // 12: ldr x1, [x1,#16]
           0x20, 0x00, 0x1f, 0xd6, // 16: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 16);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 16, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberUnrelatedSecondLoad) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x21, 0x09, 0x40, 0xf9, // 8: ldr x1, [x9,#16]
           0x21, 0x09, 0x40, 0xf9, // 12: ldr x1, [x9,#16]
           0x20, 0x00, 0x1f, 0xd6, // 16: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 16);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 16, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64ClobberUnrelatedLoads) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x49, 0x00, 0x00, 0x54, // 0: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 4: brk #0x1
           0x22, 0x09, 0x40, 0xf9, // 8: ldr x2, [x9,#16]
           0x22, 0x08, 0x40, 0xf9, // 12: ldr x2, [x1,#16]
           0x20, 0x00, 0x1f, 0xd6, // 16: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 16);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 16, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64GoodAndBadPaths) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x03, 0x00, 0x00, 0x14, // 0: b 12
           0x49, 0x00, 0x00, 0x54, // 4: b.ls 8
           0x20, 0x00, 0x20, 0xd4, // 8: brk #0x1
           0x20, 0x00, 0x1f, 0xd6, // 12: br x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 12);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 12, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64TwoPaths) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0xc9, 0x00, 0x00, 0x54, // 0: b.ls 24
           0x21, 0x08, 0x40, 0xf9, // 4: ldr x1, [x1,#16]
           0x03, 0x00, 0x00, 0x14, // 8: b 12
           0x69, 0x00, 0x00, 0x54, // 12: b.ls 12
           0x21, 0x08, 0x40, 0xf9, // 16: ldr x1, [x1,#16]
           0x20, 0x00, 0x1f, 0xd6, // 20: br x1
           0x20, 0x00, 0x20, 0xd4, // 24: brk #0x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 20);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 20, 0x0});
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64TwoPathsBadLoad1) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0xe9, 0x00, 0x00, 0x54, // 0: b.ls 28
           0x21, 0x08, 0x40, 0xf9, // 4: ldr x1, [x1,#16]
           0x21, 0x08, 0x40, 0xf9, // 8: ldr x1, [x1,#16]
           0x03, 0x00, 0x00, 0x14, // 12: b 12
           0x69, 0x00, 0x00, 0x54, // 16: b.ls 12
           0x21, 0x08, 0x40, 0xf9, // 20: ldr x1, [x1,#16]
           0x20, 0x00, 0x1f, 0xd6, // 24: br x1
           0x20, 0x00, 0x20, 0xd4, // 28: brk #0x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 24);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 24, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 TEST_F(BasicAArch64FileAnalysisTest, AArch64TwoPathsBadLoad2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0xe9, 0x00, 0x00, 0x54, // 0: b.ls 28
           0x21, 0x08, 0x40, 0xf9, // 4: ldr x1, [x1,#16]
           0x03, 0x00, 0x00, 0x14, // 8: b 12
           0x89, 0x00, 0x00, 0x54, // 12: b.ls 16
           0x21, 0x08, 0x40, 0xf9, // 16: ldr x1, [x1,#16]
           0x21, 0x08, 0x40, 0xf9, // 20: ldr x1, [x1,#16]
           0x20, 0x00, 0x1f, 0xd6, // 24: br x1
           0x20, 0x00, 0x20, 0xd4, // 28: brk #0x1
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 24);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 24, 0x0});
   EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
             Analysis.validateCFIProtection(Result));
 }
 
 } // anonymous namespace
 } // end namespace cfi_verify
 } // end namespace llvm
 

llvm/unittests/tools/llvm-cfi-verify/GraphBuilder.cpp

 namespace {
 class ELFx86TestFileAnalysis : public FileAnalysis {
 public:
   ELFx86TestFileAnalysis()
       : FileAnalysis(Triple("x86_64--"), SubtargetFeatures()) {}
 
   // Expose this method publicly for testing.
   void parseSectionContents(ArrayRef<uint8_t> SectionBytes,
-                            uint64_t SectionAddress) {
-    FileAnalysis::parseSectionContents(SectionBytes, SectionAddress);
+                            object::SectionedAddress Address) {
+    FileAnalysis::parseSectionContents(SectionBytes, Address);
   }
 
   Error initialiseDisassemblyMembers() {
     return FileAnalysis::initialiseDisassemblyMembers();
   }
 };
 
 class BasicGraphBuilderTest : public ::testing::Test {
TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestSinglePathFallthroughUd2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0x0f, 0x0b, // 2: ud2
           0xff, 0x10, // 4: callq *(%rax)
       },
-      0xDEADBEEF);
-  const auto Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  const auto Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
 
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(Result.ConditionalBranchNodes,
               Each(Field(&ConditionalBranchNode::CFIProtection, Eq(true))));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
                      Field(&ConditionalBranchNode::Target,
                            HasPath(Result, ElementsAre(0xDEADBEEF + 4))),
                      Field(&ConditionalBranchNode::Fallthrough,
                            HasPath(Result, ElementsAre(0xDEADBEEF + 2))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestSinglePathJumpUd2) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xff, 0x10, // 2: callq *(%rax)
           0x0f, 0x0b, // 4: ud2
       },
-      0xDEADBEEF);
-  const auto Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+      {0xDEADBEEF, 0x0});
+  const auto Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 2, 0x0});
 
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(Result.ConditionalBranchNodes,
               Each(Field(&ConditionalBranchNode::CFIProtection, Eq(true))));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
Analysis.parseSectionContents(
       {
           0x75, 0x03, // 0: jne 5 [+3]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x0f, 0x0b, // 5: ud2
           0x75, 0xf9, // 7: jne 2 [-7]
           0x0f, 0x0b, // 9: ud2
       },
-      0xDEADBEEF);
-  const auto Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+      {0xDEADBEEF, 0x0});
+  const auto Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 3, 0x0});
 
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(2));
   EXPECT_THAT(Result.ConditionalBranchNodes,
               Each(Field(&ConditionalBranchNode::CFIProtection, Eq(true))));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(
TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestDualPathSingleUd2) {
   Analysis.parseSectionContents(
       {
           0x75, 0x05, // 0: jne 7 [+5]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x75, 0xfb, // 5: jne 2 [-5]
           0x0f, 0x0b, // 7: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 3, 0x0});
 
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(2));
   EXPECT_THAT(Result.ConditionalBranchNodes,
               Each(Field(&ConditionalBranchNode::CFIProtection, Eq(true))));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(

 TEST_F(BasicGraphBuilderTest, BuildFlowGraphFailures) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x90,       // 0: nop
           0x75, 0xfe, // 1: jne 1 [-2]
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 1);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 1, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADC0DE);
+  Result = GraphBuilder::buildFlowGraph(Analysis, {0xDEADC0DE, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphNoXrefs) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0xeb, 0xfe, // 0: jmp 0 [-2]
           0xff, 0x10, // 2: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 2, 0x0});
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
   EXPECT_THAT(Result.OrphanedNodes, ElementsAre(0xDEADBEEF + 2));
   EXPECT_THAT(Result.IntermediateNodes, IsEmpty());
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphConditionalInfiniteLoop) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0xfe, // 0: jne 0 [-2]
           0xff, 0x10, // 2: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 2, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Each(AllOf(Field(&ConditionalBranchNode::CFIProtection, Eq(false)),
                  Field(&ConditionalBranchNode::Target,
                        HasPath(Result, ElementsAre(0xDEADBEEF))),
                  Field(&ConditionalBranchNode::Fallthrough,
                        HasPath(Result, ElementsAre(0xDEADBEEF + 2))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphUnconditionalInfiniteLoop) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xeb, 0xfc, // 2: jmp 0 [-4]
           0xff, 0x10, // 4: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(
           AllOf(Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
                 Field(&ConditionalBranchNode::Fallthrough,
                       HasPath(Result, ElementsAre(0xDEADBEEF + 2, 0xDEADBEEF))),
                 Field(&ConditionalBranchNode::Target,
                       HasPath(Result, ElementsAre(0xDEADBEEF + 4))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphNoFlowsToIndirection) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x00, // 0: jne 2 [+0]
           0xeb, 0xfc, // 2: jmp 0 [-4]
           0xff, 0x10, // 4: callq *(%rax)
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 4, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, ElementsAre(0xDEADBEEF + 4));
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphLengthExceededUpwards) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x06, // 0: jne 8 [+6]
           0x90,       // 2: nop
           0x90,       // 3: nop
           0x90,       // 4: nop
           0x90,       // 5: nop
           0xff, 0x10, // 6: callq *(%rax)
           0x0f, 0x0b, // 8: ud2
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   uint64_t PrevSearchLengthForConditionalBranch =
       SearchLengthForConditionalBranch;
   SearchLengthForConditionalBranch = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 6);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 6, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, SizeIs(1));
   EXPECT_THAT(Result.OrphanedNodes,
               Each(HasPath(Result, ElementsAre(0xDEADBEEF + 4, 0xDEADBEEF + 5,
                                                0xDEADBEEF + 6))))
       << PrintToString(Result);
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
   SearchLengthForConditionalBranch = PrevSearchLengthForConditionalBranch;
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphLengthExceededDownwards) {
   if (!SuccessfullyInitialised)
     return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xff, 0x10, // 2: callq *(%rax)
           0x90,       // 4: nop
           0x90,       // 5: nop
           0x90,       // 6: nop
           0x90,       // 7: nop
           0x0f, 0x0b, // 8: ud2
       },
-      0xDEADBEEF);
+      {0xDEADBEEF, 0x0});
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 2, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Each(AllOf(
           Field(&ConditionalBranchNode::CFIProtection, Eq(false)),
           Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
           Field(&ConditionalBranchNode::Target,
                 HasPath(Result, ElementsAre(0xDEADBEEF + 4, 0xDEADBEEF + 5))),
TEST_F(BasicGraphBuilderTest, BuildFlowGraphWithRepeatedWork) {
   Analysis.parseSectionContents(
       {
           0x75, 0x05, // 0: jne 7 [+5]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x75, 0xfb, // 5: jne 2 [-5]
           0x0f, 0x0b, // 7: ud2
       },
-      0xDEADBEEF);
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+      {0xDEADBEEF, 0x0});
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0xDEADBEEF + 3, 0x0});
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(2));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(
           Field(&ConditionalBranchNode::CFIProtection, Eq(true)),
           Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
           Field(&ConditionalBranchNode::Target,
Analysis.parseSectionContents(
           0xff, 0x10,                   // 9: callq *(%rax)
           0xeb, 0xfc,                   // 11: jmp 9 [-4]
           0x75, 0xfa,                   // 13: jne 9 [-6]
           0xe8, 0x78, 0x56, 0x34, 0x12, // 15: callq OUTOFBOUNDS [+0x12345678]
           0x90,                         // 20: nop
           0x90,                         // 21: nop
           0x0f, 0x0b,                   // 22: ud2
       },
-      0x1000);
+      {0x1000, 0x0});
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 5;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x1000 + 9);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, {0x1000 + 9, 0x0});
 
   EXPECT_THAT(Result.OrphanedNodes, SizeIs(1));
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(3));
 
   EXPECT_THAT(
       Result.OrphanedNodes,
       Each(AllOf(Eq(0x1000u + 11),
                  HasPath(Result, ElementsAre(0x1000 + 11, 0x1000 + 9)))))