[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);

150

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?

324

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)

973

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?

977–978

Similarly here

1058–1060

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)

890–893

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

906

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

989–990

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.

1072–1074

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

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

1–25

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

533–538

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

420–421

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.

973

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.

977–978

would put TODO comment here.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

890–893

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

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

420–421

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

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

939–950

Probably flip this around to reduce indentation:

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

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

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

989–992

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.

1072–1075

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

202

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

205

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

[avl]

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

202

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

200

@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

200

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

200

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

200

@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

200

@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

200

@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.
+  // TODO : put section index information into InputSectionBase itself
+  // to not loop over all sections.
+  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) {
+    llvm::SectionedAddress Address;
+    Address.Address = S->getOffsetInFile() + Offset;
+    Address.SectionIndex = SectionIndex;
+
     if (LT->getFileLineInfoForAddress(
-            S->getOffsetInFile() + Offset, nullptr,
+            Address, 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 {
     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.
   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);

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 (LHS.SectionIndex < RHS.SectionIndex) ||
+             (LHS.SectionIndex == RHS.SectionIndex &&
+              LHS.Address < RHS.Address);
     }
 
     /// The program-counter value corresponding to a machine instruction
     /// generated by the compiler.
     uint64_t Address;
+    /// If relocation information presented then this is the Index of section
+    /// which contains above address. Otherwise this is
+    /// object::SectionedAddress::Undef value.
+    uint64_t SectionIndex;
     /// 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 presented then this is the Index of 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 (LHS.SectionIndex < RHS.SectionIndex) ||
+             (LHS.SectionIndex == RHS.SectionIndex && LHS.LowPC < RHS.LowPC);
     }
 
     bool isValid() const {
       return !Empty && (LowPC < HighPC) && (FirstRowIndex < LastRowIndex);
     }
 
-    bool containsPC(uint64_t PC) const { return (LowPC <= PC && PC < HighPC); }
+    bool containsPC(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(llvm::SectionedAddress Address) const;
 
-    bool lookupAddressRange(uint64_t Address, uint64_t Size,
+    bool lookupAddressRange(llvm::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(llvm::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;
+                          SectionedAddress Address) const;
     Optional<StringRef>
     getSourceByIndex(uint64_t FileIndex,
                      DILineInfoSpecifier::FileLineInfoKind Kind) const;
+
+    uint32_t lookupAddressMain(SectionedAddress Address) const;
+
+    bool lookupAddressRangeMain(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/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 {
+  SectionedAddress() : SectionIndex(UndefSection), Address(0) {}
+  SectionedAddress(uint64_t SI, uint64_t VMA)
+      : SectionIndex(SI), Address(VMA) {}
+  SectionedAddress(const SectionedAddress &Other)
+      : SectionIndex(Other.SectionIndex), Address(Other.Address) {}
+
+  bool operator<(const SectionedAddress &Other) const {
+    return (this->SectionIndex < Other.SectionIndex) ||
+           (this->SectionIndex == Other.SectionIndex &&
+            this->Address < Other.Address);
+  }
+
+  const static uint64_t UndefSection = UINT64_MAX;
+
+  uint64_t SectionIndex;
+  uint64_t 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<llvm::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
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(),
+    if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) {
+      llvm::SectionedAddress Addr;
+      Addr.Address = Address.Address;
+      Addr.SectionIndex = Address.SectionIndex;
+      LineTable->getFileLineInfoForAddress(Addr, CU->getCompilationDir(),
                                            Spec.FLIKind, Result);
     }
+  }
   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))
+  SectionedAddress Addr;
+  Addr.Address = Address.Address;
+  Addr.SectionIndex = Address.SectionIndex;
+  if (!LineTable->lookupAddressRange(Addr, 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));
   }
 
   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))
+      llvm::SectionedAddress Addr;
+      Addr.Address = Address.Address;
+      Addr.SectionIndex = Address.SectionIndex;
+      if (LineTable && LineTable->getFileLineInfoForAddress(
+                           Addr, 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);
+        llvm::SectionedAddress Addr;
+        Addr.Address = Address.Address;
+        Addr.SectionIndex = Address.SectionIndex;
+
         // For the topmost routine, get file/line info from line table.
         if (LineTable)
-          LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
+          LineTable->getFileLineInfoForAddress(Addr, CU->getCompilationDir(),
                                                Spec.FLIKind, Frame);
       } 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;

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;
+  SectionIndex = object::SectionedAddress::UndefSection;
   Line = 1;
   Column = 0;
   File = 1;
   Isa = 0;
   Discriminator = 0;
   IsStmt = DefaultIsStmt;
   BasicBlock = false;
   EndSequence = false;
OS << format("0x%16.16" PRIx64 " %6u %6u", Address, Line, Column)
      << (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,
if (Sequence.Empty) {
     Sequence.FirstRowIndex = RowNumber;
   }
   ++RowNumber;
   LineTable->appendRow(Row);
   if (Row.EndSequence) {
     // Record the end of instruction sequence.
     Sequence.HighPC = Row.Address;
     Sequence.LastRowIndex = RowNumber;
+    Sequence.SectionIndex = Row.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 = DebugLineData.getRelocatedAddress(
+            OffsetPtr, &State.Row.SectionIndex);
         if (OS)
           *OS << format(" (0x%16.16" PRIx64 ")", State.Row.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
if (!Sequences.empty()) {
     // rudimentary sequences for address ranges [0x0, 0xsomething).
   }
 
   return Error::success();
 }
 
 uint32_t
 DWARFDebugLine::LineTable::findRowInSeq(const DWARFDebugLine::Sequence &Seq,
-                                        uint64_t Address) const {
+                                        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;
+  Row.Address = Address.Address;
+  Row.SectionIndex = Address.SectionIndex;
   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->SectionIndex);
   uint32_t Index = Seq.FirstRowIndex + (RowPos - FirstRow);
-  if (RowPos->Address > Address) {
+  if (RowPos->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(SectionedAddress Address) const {
+
+  // Search for relocatable addresses
+  uint32_t Result = lookupAddressMain(Address);
+
+  if (Result == UnknownRowIndex) {
+    if (Address.SectionIndex != object::SectionedAddress::UndefSection) {
+      // Search for absolute addresses
+      Address.SectionIndex = object::SectionedAddress::UndefSection;
+
+      Result = lookupAddressMain(Address);
+    }
+  }
+
+  return Result;
+}
+
+uint32_t
+DWARFDebugLine::LineTable::lookupAddressMain(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 {
+    SectionedAddress Address, uint64_t Size,
+    std::vector<uint32_t> &Result) const {
+
+  // Search for relocatable addresses
+  bool AddressFound = lookupAddressRangeMain(Address, Size, Result);
+
+  if (!AddressFound) {
+    if (Address.SectionIndex != object::SectionedAddress::UndefSection) {
+      // Search for absolute addresses
+      Address.SectionIndex = object::SectionedAddress::UndefSection;
+
+      AddressFound = lookupAddressRangeMain(Address, Size, Result);
+    }
+  }
+
+  return AddressFound;
+}
+
+bool DWARFDebugLine::LineTable::lookupAddressRangeMain(
+    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) {
     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);
+    SectionedAddress LastAddress = Address;
+    LastAddress.Address = EndAddr - 1;
+    uint32_t LastRowIndex = findRowInSeq(CurSeq, LastAddress);
     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,
+    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)
+  if (RowIndex == UnknownRowIndex) {
     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/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<llvm::SectionedAddress> BA = U->getBaseAddress())
           BaseAddr = BA->Address;
         LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, 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<llvm::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/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(
+        object::SectionedAddress(Address.SectionIndex,
+                                 LineInfo->getVirtualAddress()),
+        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/Inputs/function-sections-line-numbers.cpp

+
+__attribute__((__noinline__)) 
+   int Pow(int number, int count);
+
+
+
+
+
+
+int Pow(int number, int count) {
+    int result = 1;
+    
+    for (int i = 0; i < count; ++i) {
+        result = result * number;
+    }
+
+    return result;
+}
+
+
+extern "C" int Func (void)
+{
+    return Pow(6, 0);
+}
+

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

+# RUN: clang -ffunction-sections -gdwarf-5 -O -c %p/Inputs/function-sections-line-numbers.cpp -o %t.o 
+# RUN: llvm-objdump -disassemble -line-numbers -r -s -section-headers -t %t.o | FileCheck %s
+
+
+# CHECK: 0000000000000000 _Z3Powii 
+# CHECK-NOT: function-sections-line-numbers.cpp:2
+# CHECK: function-sections-line-numbers.cpp:1
+# CHECK-NOT: function-sections-line-numbers.cpp:2
+# CHECK: 0000000000000000 Func 
+# CHECK: function-sections-line-numbers.cpp:2

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);
+                            uint64_t SectionIndex, uint64_t SectionAddress);
 
   // 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.getIndex(),
+                         Section.getAddress());
   }
   return Error::success();
 }
 
 void FileAnalysis::parseSectionContents(ArrayRef<uint8_t> SectionBytes,
+                                        uint64_t SectionIndex,
                                         uint64_t SectionAddress) {
   assert(Symbolizer && "Symbolizer is uninitialised.");
   MCInst Instruction;
   Instr InstrMeta;
   uint64_t InstructionSize;
 
   for (uint64_t Byte = 0; Byte < SectionBytes.size();) {
     bool 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) {
+      object::SectionedAddress ModuleAddress;
+      ModuleAddress.Address = VMAddress;
+      ModuleAddress.SectionIndex = SectionIndex;
       auto LineInfo =
-          Symbolizer->symbolizeCode(Object->getFileName(), VMAddress);
+          Symbolizer->symbolizeCode(Object->getFileName(), ModuleAddress);
       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);
+    object::SectionedAddress Address;
+
+    Address.Address = VMAddress;
+    Address.SectionIndex = SectionIndex;
+
+    IndirectInstructions.insert(Address);
   }
 }
 
 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 "

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);
+                                    uint64_t SectionIndex, uint64_t 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 SectionIndex,
                                          uint64_t Address) {
   GraphResult Result;
   Result.BaseAddress = Address;
   DenseSet<uint64_t> OpenedNodes;
 
   const auto &IndirectInstructions = Analysis.getIndirectInstructions();
 
-  if (IndirectInstructions.find(Address) == IndirectInstructions.end())
+  // check that IndirectInstructions contains specified Address
+  object::SectionedAddress CheckedAddress;
+  CheckedAddress.Address = Address;
+  CheckedAddress.SectionIndex = SectionIndex;
+
+  if (IndirectInstructions.find(CheckedAddress) == IndirectInstructions.end()) {
     return Result;
+  }
 
   buildFlowGraphImpl(Analysis, OpenedNodes, Result, Address, 0);
   return Result;
 }
 
 void GraphBuilder::buildFlowsToUndefined(const FileAnalysis &Analysis,
                                          GraphResult &Result,
                                          ConditionalBranchNode &BranchNode,

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);
-    GraphResult Graph = GraphBuilder::buildFlowGraph(Analysis, Address);
+  for (object::SectionedAddress Address : Analysis.getIndirectInstructions()) {
+    const auto &InstrMeta = Analysis.getInstructionOrDie(Address.Address);
+    GraphResult Graph = GraphBuilder::buildFlowGraph(
+        Analysis, Address.SectionIndex, Address.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,
   }
   llvm::sort(Dies);
   Dies.erase(std::unique(Dies.begin(), Dies.end()), Dies.end());
 
   for (DWARFDie Die : Dies)
     Die.dump(OS, 0, getDumpOpts());
 }
 
+// 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(ObjectFile &Obj,
+                                                uint64_t Address) {
+
+  for (SectionRef Sec : Obj.sections()) {
+    if (!Sec.isText() || Sec.isVirtual())
+      continue;
+
+    if (Address >= Sec.getAddress() &&
+        Address <= Sec.getAddress() + Sec.getSize()) {
+      return Sec.getIndex();
+    }
+  }
+
+  return object::SectionedAddress::UndefSection;
+}
+
 /// 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) {
+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))
+  object::SectionedAddress ModuleAddress;
+  ModuleAddress.Address = Lookup;
+  ModuleAddress.SectionIndex =
+      getModuleSectionIndexForAddress(Obj, ModuleAddress.Address);
+  if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(ModuleAddress))
     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(
+                object::SectionedAddress(SectIdx, PC));
             // 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
         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);
+            object::SectionedAddress(Section.getIndex(),
+                                     SectionAddr + Index + VMAAdjustment),
+            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 {
+          auto SecOrErr = Sym.getSection();
+          if (SecOrErr) {
+            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.get().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;
+  ModuleOffset.Address = Offset;
+  ModuleOffset.SectionIndex =
+      getModuleSectionIndexForAddress(ModuleName, ModuleOffset.Address);
   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
+  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
+  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

if (ClBlacklist.empty())
       return std::unique_ptr<SpecialCaseList>();
 
     return SpecialCaseList::createOrDie({{ClBlacklist}});
   }
   std::unique_ptr<SpecialCaseList> DefaultBlacklist;
   std::unique_ptr<SpecialCaseList> UserBlacklist;
 };
 
+// This is helper class: allows to detect SectionIndex by 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).
+class SectionsIndexCache {
+public:
+  SectionsIndexCache(const std::string &ObjectFile) {
+    Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
+        object::createBinary(ObjectFile);
+
+    failIfError(BinaryOrErr);
+
+    object::Binary &Binary = *BinaryOrErr.get().getBinary();
+
+    if (object::ObjectFile *O = dyn_cast<object::ObjectFile>(&Binary)) {
+      for (object::SectionRef Sec : (*O).sections()) {
+        if (!Sec.isText() || Sec.isVirtual())
+          continue;
+
+        SectionInfo Section;
+
+        Section.Address = Sec.getAddress();
+        Section.Size = Sec.getSize();
+        Section.Index = Sec.getIndex();
+
+        Sections.push_back(Section);
+      }
+    }
+
+    llvm::sort(Sections.begin(), Sections.end(), OrderByAddress);
+  }
+
+  uint64_t GetSectionIndexForAddress(uint64_t Address) {
+
+    SectionInfo Sec;
+    Sec.Address = Address;
+    Sec.Size = 0;
+
+    std::vector<SectionInfo>::const_iterator FoundSec =
+        std::lower_bound(Sections.begin(), Sections.end(), Sec, OrderByAddress);
+
+    if (FoundSec == Sections.end()) {
+      return object::SectionedAddress::UndefSection;
+    } else if (Address >= FoundSec->Address &&
+               Address <= (FoundSec->Address + FoundSec->Size)) {
+      return FoundSec->Index;
+    } else {
+      if (FoundSec == Sections.begin()) {
+        return object::SectionedAddress::UndefSection;
+      }
+
+      FoundSec--;
+
+      if (Address >= FoundSec->Address &&
+          Address <= (FoundSec->Address + FoundSec->Size)) {
+        return FoundSec->Index;
+      };
+    }
+
+    return object::SectionedAddress::UndefSection;
+  }
+
+protected:
+  struct SectionInfo {
+    uint64_t Address;
+    uint64_t Size;
+    uint64_t Index;
+  };
+
+  static bool OrderByAddress(const SectionInfo &LHS, const SectionInfo &RHS) {
+    return LHS.Address < RHS.Address;
+  }
+
+  std::vector<SectionInfo> Sections;
+};
+
 static std::vector<CoveragePoint>
 getCoveragePoints(const std::string &ObjectFile,
                   const std::set<uint64_t> &Addrs,
                   const std::set<uint64_t> &CoveredAddrs) {
   std::vector<CoveragePoint> Result;
   auto Symbolizer(createSymbolizer());
   Blacklists B;
 
+  SectionsIndexCache Sections(ObjectFile);
+
   std::set<std::string> CoveredFiles;
   if (ClSkipDeadFiles) {
     for (auto Addr : CoveredAddrs) {
-      auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
+      object::SectionedAddress ModuleAddress;
+      ModuleAddress.Address = Addr;
+      ModuleAddress.SectionIndex = Sections.GetSectionIndexForAddress(Addr);
+
+      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);
+    object::SectionedAddress ModuleAddress;
+    ModuleAddress.Address = Addr;
+    ModuleAddress.SectionIndex = Sections.GetSectionIndexForAddress(Addr);
+
+    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) {
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(ObjectFile);
   failIfError(BufOrErr);
   SHA1 Hasher;
   Hasher.update((*BufOrErr)->getBuffer());
   Coverage->BinaryHash = toHex(Hasher.final());
 
+  SectionsIndexCache Sections(ObjectFile);
+
   Blacklists B;
   auto Symbolizer(createSymbolizer());
 
   for (uint64_t Addr : *Data.Addrs) {
-    auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
+    object::SectionedAddress ModuleAddress;
+    ModuleAddress.Address = Addr;
+    ModuleAddress.SectionIndex = Sections.GetSectionIndexForAddress(Addr);
+
+    auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, ModuleAddress);
     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 (Begin > End)
       return nullptr;
     if (Addr == 0 && Data == 0)
       return Begin;
     if (Begin == End)
       return nullptr;
 
+    object::SectionedAddress ModuleAddress;
+    ModuleAddress.Address = Addr - 1;
+    ModuleAddress.SectionIndex = object::SectionedAddress::UndefSection;
+
     // 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)) {
+            Symbolizer.symbolizeCode(Filename, ModuleAddress)) {
       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);
+                            uint64_t SectionIndex, uint64_t SectionAddress) {
+    FileAnalysis::parseSectionContents(SectionBytes, SectionIndex,
+                                       SectionAddress);
   }
 
   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);
+      0x0, 0xDEADBEEF);
 
   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);
+      0x0, 0xDEADBEEF);
   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);
+      0x0, 0xDEADBEEF);
 
   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);
+      0x0, 0xDEADBEEF);
 
   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);
+      0x0, 0xDEADBEEF);
 
   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);
+      0x0, 0xDEADBEEF);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF);
   EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
             Analysis.validateCFIProtection(Result));
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 1);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 1);
   EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
             Analysis.validateCFIProtection(Result));
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 3);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 3);
   EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
             Analysis.validateCFIProtection(Result));
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0x12345678);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0x12345678);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 2);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 3);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 3);
   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);
+      0x0, 0xDEADBEEF);
   uint64_t PrevSearchLengthForConditionalBranch =
       SearchLengthForConditionalBranch;
   SearchLengthForConditionalBranch = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 6);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 6);
   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);
+      0x0, 0xDEADBEEF);
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 2);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
   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);
+      0x0, 0xDEADBEEF);
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 5;
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 9);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 9);
   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);
+      0x0, 0x688118);
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 1;
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x68811d);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0x68811d);
   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);
+      0x0, 0x7759eb);
 
   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);
+      0x0, 0x775a56);
 
   Analysis.parseSectionContents(
       {
           0x0f, 0x0b, // 0x775e0e: ud2
       },
-      0x775e0e);
+      0x0, 0x775e0e);
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 1;
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x775a68);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0x775a68);
   EXPECT_EQ(CFIProtectionStatus::FAIL_BAD_CONDITIONAL_BRANCH,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = 2;
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0x775a68);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0x775a68);
   EXPECT_EQ(CFIProtectionStatus::PROTECTED,
             Analysis.validateCFIProtection(Result));
   SearchLengthForUndef = 3;
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0x775a68);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0x775a68);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 10);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 8);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 9);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 8);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 12);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 12);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 16);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 16);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 16);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 16);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 16);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 16);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 12);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 20);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 24);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 24);
   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);
+                            uint64_t SectionIndex, uint64_t SectionAddress) {
+    FileAnalysis::parseSectionContents(SectionBytes, SectionIndex,
+                                       SectionAddress);
   }
 
   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);
+      0x0, 0xDEADBEEF);
+  const auto Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
 
   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);
+      0x0, 0xDEADBEEF);
+  const auto Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 2);
 
   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);
+      0x0, 0xDEADBEEF);
+  const auto Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 3);
 
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 3);
 
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 1);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 1);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
-  Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADC0DE);
+  Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADC0DE);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 2);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 2);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 4);
   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);
+      0x0, 0xDEADBEEF);
   uint64_t PrevSearchLengthForConditionalBranch =
       SearchLengthForConditionalBranch;
   SearchLengthForConditionalBranch = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 6);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 6);
   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);
+      0x0, 0xDEADBEEF);
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 2;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 2);
   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);
+      0x0, 0xDEADBEEF);
+  GraphResult Result =
+      GraphBuilder::buildFlowGraph(Analysis, 0x0, 0xDEADBEEF + 3);
   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);
+      0x0, 0x1000);
   uint64_t PrevSearchLengthForUndef = SearchLengthForUndef;
   SearchLengthForUndef = 5;
 
-  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x1000 + 9);
+  GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0x0, 0x1000 + 9);
 
   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)))))