[symbolizer] Support symbol+offset lookup

[sepavloff]

Summary

[symbolizer] Support symbol+offset lookup

GNU addr2line supports lookup by symbol name in addition to the existing
address lookup. llvm-symbolizer starting from e144ae54dcb96838a6176fd9eef21028935ccd4f
supports lookup by symbol name. This change extends this lookup with
possibility to specify optional offset.

Now the address for which source information is searched for can be
specified with offset:

llvm-symbolize --obj=abc.so "SYMBOL func_22+0x12"

It decreases the gap in features of llvm-symbolizer and GNU addr2line.

[tschuett]

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

91 ↗

(On Diff #482181)

Please use std::optional. The LLVM variant is going away.

[dblaikie]

Does unix addr2line support this, or is there other precedent we should consider when evaluating this new feature?

[sepavloff]

Replace llvm::Optional with std::optional

[sepavloff]

In D139859#3989536, @dblaikie wrote:

Does unix addr2line support this, or is there other precedent we should consider when evaluating this new feature?

Documentation on addr2line (https://sourceware.org/binutils/docs/binutils/addr2line.html) says:

addr2line translates addresses or `symbol+offset` into file names and line numbers. Given an address or symbol+offset in an executable or an offset in a section of a relocatable object, it uses the debugging information to figure out which file name and line number are associated with it.

Resolving symbol+offset is available in binutils 2.39. Resolving symbols only also work, at least in some cases.

[jhenderson]

In D139859#3992038, @sepavloff wrote:

In D139859#3989536, @dblaikie wrote:

Does unix addr2line support this, or is there other precedent we should consider when evaluating this new feature?

Documentation on addr2line (https://sourceware.org/binutils/docs/binutils/addr2line.html) says:

addr2line translates addresses or `symbol+offset` into file names and line numbers. Given an address or symbol+offset in an executable or an offset in a section of a relocatable object, it uses the debugging information to figure out which file name and line number are associated with it.

Resolving symbol+offset is available in binutils 2.39. Resolving symbols only also work, at least in some cases.

Could you give an example usage of how this feature is supported, i.e. what the invocation and output look like when using GNU addr2line, please. We should aim to be compatible with them, where possible.

llvm/unittests/ProfileData/MemProfTest.cpp

48–49

These tidy ups should be in a separate NFC commit, rather than adding noise to this patch.

[sepavloff]

Make support of symbol+offset lookup closer to GNU addr2line

[jhenderson]

Hi @sepavloff,

It looks like you've ignored both my requests from my previous comment (the need to show how GNU addr2line works, and to make cleanups in separate patches). Please address these points, and then I'll potentially be able to review this code.

[sepavloff]

In D139859#4226556, @jhenderson wrote:

Hi @sepavloff,

It looks like you've ignored both my requests from my previous comment (the need to show how GNU addr2line works, and to make cleanups in separate patches). Please address these points, and then I'll potentially be able to review this code.

Sorry for misunderstanding. I am preparing a set of prerequisite patches.

[sepavloff]

Updated patch

[jhenderson]

In your patch description, please note the tool name is llvm-symbolizer, not llvm-symbolize. Please update accordingly.

Does GNU addr2line support just using a symbol without the offset? If so, I think it would be good to split the offset lookup functionality into a follow-on patch. It helps reduce the surface area of this patch into more digestible pieces for review and testing.

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

222

Why has this changed?

[sepavloff]

In D139859#4298203, @jhenderson wrote:

Does GNU addr2line support just using a symbol without the offset? If so, I think it would be good to split the offset lookup functionality into a follow-on patch. It helps reduce the surface area of this patch into more digestible pieces for review and testing.

D149759 implements simplified version of the lookup support, restricted to symbol names only. Files related to building test relocatable file are moved into separated revision D149757. Hopefully it can simplify review.

[sepavloff]

Update implementation after symbol lookup was committed

[jhenderson]

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

107–108

Please don't abbreviate Offset to Ofs. It makes it harder to understand what the variable actually is for no real benefit. Applies throughout.

llvm/test/tools/llvm-symbolizer/symbol-search.test

36

Please make sure there is testing for hex as well as decimal numbers.

37

Same throughout, for consitency with the existing tests.

44

It's slightly offputting that the same set of arguments don't exist for both the llvm-symbolizer and llvm-addr2line test cases. Could you rationalise them, please, so that they both test the same set?

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

162

Why has this name changed?

256

"probably" implies most of the time, but there's no guarantee that's how the option is used.

271

A trailing + needs testing. Also something of the form notanumber+alsonotanumber and notanumber+12notanumber.

[jhenderson]

I forgot to ask, does the GNU version allow negative offsets?

[sepavloff]

Address review notes

• add tests,
• change some names.

[sepavloff]

llvm/test/tools/llvm-symbolizer/symbol-search.test

44

Actually they are the same, the test is fixed accordingly.

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

162

Now this parameter may be assigned either a module offset, or a displacement relative to a symbol, so the old name is not precise. More suitable name is Offset but it requires to rename the variable Offset used in this function body. Now the names and comments must be more consistent.

[sepavloff]

In D139859#4657170, @jhenderson wrote:

I forgot to ask, does the GNU version allow negative offsets?

No, only + is allowed for offsets: https://sourceware.org/git?p=binutils-gdb.git;a=blob;f=binutils/addr2line.c;h=fd2ac80dacd2fd14b353a7acf55aeb6f8d826288;hb=fd2ac80dacd2fd14b353a7acf55aeb6f8d826288#l252

[jhenderson]

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

111

Why has this changed from StringRef?

llvm/test/tools/llvm-symbolizer/symbol-search.test

44

Thanks, this is much easier to read now.

[sepavloff]

Sorry for late response. Unfortunately Phabricator stopped sending mail notifications and I overlooked your note.

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

111

This is a small optimization.

Template function LLVMSymbolizer::findSymbolCommon accepts ModuleSpecifier as const & and passes it to getOrCreateModuleInfo, which expects the module name as const std::string &. Before this change LLVMSymbolizer::findSymbol called str() to convert the name passed as StringRef. Making the argument const std::string & avoids creation of the extra string instance.

[sepavloff]

Migrated to https://github.com/llvm/llvm-project/pull/75067.

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

symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
                        DILineInfoSpecifier LineInfoSpecifier,
                        bool UseSymbolTable) const = 0;
   virtual DIGlobal
   symbolizeData(object::SectionedAddress ModuleOffset) const = 0;
   virtual std::vector<DILocal>
   symbolizeFrame(object::SectionedAddress ModuleOffset) const = 0;
 
   virtual std::vector<object::SectionedAddress>
-  findSymbol(StringRef Symbol) const = 0;
+  findSymbol(StringRef Symbol, uint64_t Offset) 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/SymbolizableObjectFile.h

DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
                            bool UseSymbolTable) const override;
   DIInliningInfo symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
                                       DILineInfoSpecifier LineInfoSpecifier,
                                       bool UseSymbolTable) const override;
   DIGlobal symbolizeData(object::SectionedAddress ModuleOffset) const override;
   std::vector<DILocal>
   symbolizeFrame(object::SectionedAddress ModuleOffset) const override;
   std::vector<object::SectionedAddress>
-  findSymbol(StringRef Symbol) const override;
+  findSymbol(StringRef Symbol, uint64_t Offset) 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/include/llvm/DebugInfo/Symbolize/Symbolize.h

public:
   Expected<std::vector<DILocal>>
   symbolizeFrame(const ObjectFile &Obj, object::SectionedAddress ModuleOffset);
   Expected<std::vector<DILocal>>
   symbolizeFrame(const std::string &ModuleName,
                  object::SectionedAddress ModuleOffset);
   Expected<std::vector<DILocal>>
   symbolizeFrame(ArrayRef<uint8_t> BuildID,
                  object::SectionedAddress ModuleOffset);
 
-  Expected<std::vector<DILineInfo>> findSymbol(const ObjectFile &Obj,
-                                               StringRef Symbol);
-  Expected<std::vector<DILineInfo>> findSymbol(StringRef ModuleName,
-                                               StringRef Symbol);
-  Expected<std::vector<DILineInfo>> findSymbol(ArrayRef<uint8_t> BuildID,
-                                               StringRef Symbol);
+  Expected<std::vector<DILineInfo>>
+  findSymbol(const ObjectFile &Obj, StringRef Symbol, uint64_t Offset);
+  Expected<std::vector<DILineInfo>>
+  findSymbol(const std::string &ModuleName, StringRef Symbol, uint64_t Offset);
+  Expected<std::vector<DILineInfo>>
+  findSymbol(ArrayRef<uint8_t> BuildID, StringRef Symbol, uint64_t Offset);
 
   void flush();
 
   // Evict entries from the binary cache until it is under the maximum size
   // given in the options. Calling this invalidates references in the DI...
   // objects returned by the methods above.
   void pruneCache();
 
private:
   template <typename T>
   Expected<DIGlobal> symbolizeDataCommon(const T &ModuleSpecifier,
                                          object::SectionedAddress ModuleOffset);
   template <typename T>
   Expected<std::vector<DILocal>>
   symbolizeFrameCommon(const T &ModuleSpecifier,
                        object::SectionedAddress ModuleOffset);
   template <typename T>
-  Expected<std::vector<DILineInfo>> findSymbolCommon(const T &ModuleSpecifier,
-                                                     StringRef Symbol);
+  Expected<std::vector<DILineInfo>>
+  findSymbolCommon(const T &ModuleSpecifier, StringRef Symbol, uint64_t Offset);
 
   Expected<SymbolizableModule *> getOrCreateModuleInfo(const ObjectFile &Obj);
 
   /// Returns a SymbolizableModule or an error if loading debug info failed.
   /// Unlike the above, errors are reported each time, since they are more
   /// likely to be transient.
   Expected<SymbolizableModule *>
   getOrCreateModuleInfo(ArrayRef<uint8_t> BuildID);

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

std::vector<DILocal> SymbolizableObjectFile::symbolizeFrame(
     object::SectionedAddress ModuleOffset) const {
   if (ModuleOffset.SectionIndex == object::SectionedAddress::UndefSection)
     ModuleOffset.SectionIndex =
         getModuleSectionIndexForAddress(ModuleOffset.Address);
   return DebugInfoContext->getLocalsForAddress(ModuleOffset);
 }
 
 std::vector<object::SectionedAddress>
-SymbolizableObjectFile::findSymbol(StringRef Symbol) const {
+SymbolizableObjectFile::findSymbol(StringRef Symbol, uint64_t Offset) const {
   std::vector<object::SectionedAddress> Result;
   for (const SymbolDesc &Sym : Symbols) {
     if (Sym.Name.equals(Symbol)) {
-      object::SectionedAddress A{Sym.Addr,
-                                 getModuleSectionIndexForAddress(Sym.Addr)};
+      uint64_t Addr = Sym.Addr;
+      if (Offset < Sym.Size)
+        Addr += Offset;
+      object::SectionedAddress A{Addr, getModuleSectionIndexForAddress(Addr)};
       Result.push_back(A);
     }
   }
   return Result;
 }
 
 /// Search for the first occurence of specified Address in ObjectFile.
 uint64_t SymbolizableObjectFile::getModuleSectionIndexForAddress(

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

 Expected<std::vector<DILocal>>
 LLVMSymbolizer::symbolizeFrame(ArrayRef<uint8_t> BuildID,
                                object::SectionedAddress ModuleOffset) {
   return symbolizeFrameCommon(BuildID, ModuleOffset);
 }
 
 template <typename T>
 Expected<std::vector<DILineInfo>>
-LLVMSymbolizer::findSymbolCommon(const T &ModuleSpecifier, StringRef Symbol) {
+LLVMSymbolizer::findSymbolCommon(const T &ModuleSpecifier, StringRef Symbol,
+                                 uint64_t Offset) {
   auto InfoOrErr = getOrCreateModuleInfo(ModuleSpecifier);
   if (!InfoOrErr)
     return InfoOrErr.takeError();
 
   SymbolizableModule *Info = *InfoOrErr;
   std::vector<DILineInfo> Result;
 
   // A null module means an error has already been reported. Return an empty
   // result.
   if (!Info)
     return Result;
 
-  for (object::SectionedAddress A : Info->findSymbol(Symbol)) {
+  for (object::SectionedAddress A : Info->findSymbol(Symbol, Offset)) {
     DILineInfo LineInfo = Info->symbolizeCode(
         A, DILineInfoSpecifier(Opts.PathStyle, Opts.PrintFunctions),
         Opts.UseSymbolTable);
     if (LineInfo.FileName != DILineInfo::BadString) {
       if (Opts.Demangle)
         LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info);
       Result.push_back(LineInfo);
     }
   }
 
   return Result;
 }
 
 Expected<std::vector<DILineInfo>>
-LLVMSymbolizer::findSymbol(const ObjectFile &Obj, StringRef Symbol) {
-  return findSymbolCommon(Obj, Symbol);
+LLVMSymbolizer::findSymbol(const ObjectFile &Obj, StringRef Symbol,
+                           uint64_t Offset) {
+  return findSymbolCommon(Obj, Symbol, Offset);
 }
 
 Expected<std::vector<DILineInfo>>
-LLVMSymbolizer::findSymbol(StringRef ModuleName, StringRef Symbol) {
-  return findSymbolCommon(ModuleName.str(), Symbol);
+LLVMSymbolizer::findSymbol(const std::string &ModuleName, StringRef Symbol,
+                           uint64_t Offset) {
+  return findSymbolCommon(ModuleName, Symbol, Offset);
 }
 
 Expected<std::vector<DILineInfo>>
-LLVMSymbolizer::findSymbol(ArrayRef<uint8_t> BuildID, StringRef Symbol) {
-  return findSymbolCommon(BuildID, Symbol);
+LLVMSymbolizer::findSymbol(ArrayRef<uint8_t> BuildID, StringRef Symbol,
+                           uint64_t Offset) {
+  return findSymbolCommon(BuildID, Symbol, Offset);
 }
 
 void LLVMSymbolizer::flush() {
   ObjectForUBPathAndArch.clear();
   LRUBinaries.clear();
   CacheSize = 0;
   BinaryForPath.clear();
   ObjectPairForPathArch.clear();

llvm/test/tools/llvm-symbolizer/symbol-search.test

 RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_666 | FileCheck --check-prefix=NONEXISTENT %s
 NONEXISTENT: ??
 
 # Show that more than one symbol may be specified.
 RUN: llvm-addr2line --obj=%p/Inputs/symbols.so func_01 func_02 | FileCheck --check-prefix=FUNCS %s
 RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01 func_02 | FileCheck --check-prefix=FUNCS %s
 FUNCS:  /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
 FUNCS:  /tmp/dbginfo{{[/\]+}}symbols.part2.cpp:10
 
+# Symbol may be combined with offset.
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+0 | FileCheck --check-prefix=SYMLINE0 %s
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01+0 | FileCheck --check-prefix=SYMLINE0 %s
+SYMLINE0: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+12 | FileCheck --check-prefix=SYMLINE1 %s
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01+12 | FileCheck --check-prefix=SYMLINE1 %s
+SYMLINE1: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:13
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+19 | FileCheck --check-prefix=SYMLINE2 %s
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01+19 | FileCheck --check-prefix=SYMLINE2 %s
+SYMLINE2: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:14
+
+# Offset can be specified with various bases.
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+0x0C | FileCheck --check-prefix=SYMLINE1 %s
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01+0x0C | FileCheck --check-prefix=SYMLINE1 %s
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+014 | FileCheck --check-prefix=SYMLINE1 %s
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01+014 | FileCheck --check-prefix=SYMLINE1 %s
+
+# If '+' is not followed by a number, it is a part of symbol, not an offset separator.
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+ | FileCheck --check-prefix=NONEXISTENT %s
+RUN: llvm-addr2line --obj=%p/Inputs/symbols.so func_01+ | FileCheck --check-prefix=NONEXISTENT %s
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+abc | FileCheck --check-prefix=NONEXISTENT %s
+RUN: llvm-addr2line --obj=%p/Inputs/symbols.so func_01+abc | FileCheck --check-prefix=NONEXISTENT %s
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_01+0A | FileCheck --check-prefix=NONEXISTENT %s
+RUN: llvm-addr2line --obj=%p/Inputs/symbols.so func_01+0A | FileCheck --check-prefix=NONEXISTENT %s
+
+# If '+' is not preceded by a symbol, it is a part of symbol, not an offset separator.
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so +0x1138 | FileCheck --check-prefix=NONEXISTENT %s
+RUN: llvm-addr2line --obj=%p/Inputs/symbols.so +0x1138 | FileCheck --check-prefix=NONEXISTENT %s
+
 # Show that C++ mangled names may be specified.
 RUN: llvm-addr2line --obj=%p/Inputs/symbols.so _ZL14static_func_01i | FileCheck --check-prefix=MULTI-CXX %s
 RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so _ZL14static_func_01i | FileCheck --check-prefix=MULTI-CXX %s
 MULTI-CXX: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:7
 MULTI-CXX: /tmp/dbginfo{{[/\]+}}symbols.part2.cpp:5
 
 # Show that containing function name can be printed in mangled form.
 RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so --no-demangle _Z7func_04i | FileCheck --check-prefix=MANGLED %s

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

 
 static Error makeStringError(StringRef Msg) {
   return make_error<StringError>(Msg, inconvertibleErrorCode());
 }
 
 static Error parseCommand(StringRef BinaryName, bool IsAddr2Line,
                           StringRef InputString, Command &Cmd,
                           std::string &ModuleName, object::BuildID &BuildID,
-                          StringRef &Symbol, uint64_t &ModuleOffset) {
+                          StringRef &Symbol, uint64_t &Offset) {
   ModuleName = BinaryName;
   if (InputString.consume_front("CODE ")) {
     Cmd = Command::Code;
   } else if (InputString.consume_front("DATA ")) {
     Cmd = Command::Data;
   } else if (InputString.consume_front("FRAME ")) {
     Cmd = Command::Frame;
   } else {
if (HasBuildIDPrefix) {
       if (BuildID.empty())
         return makeStringError("wrong format of build-id");
     } else {
       ModuleName = Name;
     }
   } else if (BinaryName.empty() && BuildID.empty()) {
     // No input file has been specified. If the input string contains at least
     // two items, assume that the first item is a file name.
     ModuleName = getSpaceDelimitedWord(InputString);
     if (ModuleName.empty())
       return makeStringError("no input filename has been specified");
   }
 
-  // Parse module offset, which can be specified as a number or as a symbol.
-  InputString = InputString.ltrim();
+  // Parse address specification, which can be an offset in module or a
+  // symbol with optional offset.
+  InputString = InputString.trim();
   if (InputString.empty())
     return makeStringError("no module offset has been specified");
 
   // If input string contains a space, ignore everything after it. This behavior
   // is consistent with GNU addr2line.
-  int OffsetLength = InputString.find_first_of(" \n\r");
-  StringRef Offset = InputString.substr(0, OffsetLength);
+  int AddrSpecLength = InputString.find_first_of(" \n\r");
+  StringRef AddrSpec = InputString.substr(0, AddrSpecLength);
+  bool StartsWithDigit = std::isdigit(AddrSpec.front());
 
-  // GNU addr2line assumes the offset is hexadecimal and allows a redundant
+  // GNU addr2line assumes the address is hexadecimal and allows a redundant
   // "0x" or "0X" prefix; do the same for compatibility.
   if (IsAddr2Line)
-    Offset.consume_front("0x") || Offset.consume_front("0X");
+    AddrSpec.consume_front("0x") || AddrSpec.consume_front("0X");
+
+  // If address specification is a number, treat it as a module offset.
+  if (!AddrSpec.getAsInteger(IsAddr2Line ? 16 : 0, Offset)) {
+    // Module offset is an address.
+    Symbol = StringRef();
+    return Error::success();
+  }
 
-  // If the input is not a number, treat it is a symbol.
-  if (Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset)) {
-    Symbol = Offset;
-    ModuleOffset = 0;
+  // If address specification starts with a digit, but is not a number, consider
+  // it as invalid.
+  if (StartsWithDigit || AddrSpec.empty())
+    return makeStringError("expected a number as module offset");
+
+  // Otherwise it is a symbol name, potentially with an offset.
+  Symbol = AddrSpec;
+  Offset = 0;
+
+  // If the address specification contains '+', try treating it as
+  // "symbol + offset".
+  size_t Plus = AddrSpec.rfind('+');
+  if (Plus != StringRef::npos) {
+    StringRef SymbolStr = AddrSpec.take_front(Plus);
+    StringRef OffsetStr = AddrSpec.substr(Plus + 1);
+    if (!SymbolStr.empty() && !OffsetStr.empty() &&
+        !OffsetStr.getAsInteger(0, Offset)) {
+      Symbol = SymbolStr;
+      return Error::success();
+    }
+    // The found '+' is not an offset delimiter.
   }
 
   return Error::success();
 }
 
 template <typename T>
 void executeCommand(StringRef ModuleName, const T &ModuleSpec, Command Cmd,
                     StringRef Symbol, uint64_t Offset, uint64_t AdjustVMA,
if (Cmd == Command::Data) {
     Expected<DIGlobal> ResOrErr = Symbolizer.symbolizeData(ModuleSpec, Address);
     print(SymRequest, ResOrErr, Printer);
   } else if (Cmd == Command::Frame) {
     Expected<std::vector<DILocal>> ResOrErr =
         Symbolizer.symbolizeFrame(ModuleSpec, Address);
     print(SymRequest, ResOrErr, Printer);
   } else if (!Symbol.empty()) {
     Expected<std::vector<DILineInfo>> ResOrErr =
-        Symbolizer.findSymbol(ModuleSpec, Symbol);
+        Symbolizer.findSymbol(ModuleSpec, Symbol, Offset);
     print(SymRequest, ResOrErr, Printer);
   } else if (ShouldInline) {
     Expected<DIInliningInfo> ResOrErr =
         Symbolizer.symbolizeInlinedCode(ModuleSpec, Address);
     print(SymRequest, ResOrErr, Printer);
   } else if (Style == OutputStyle::GNU) {
     // With PrintFunctions == FunctionNameKind::LinkageName (default)
     // and UseSymbolTable == true (also default), Symbolizer.symbolizeCode()

llvm/unittests/ProfileData/MemProfTest.cpp

 class MockSymbolizer : public SymbolizableModule {
 public:
   MOCK_CONST_METHOD3(symbolizeInlinedCode,
                      DIInliningInfo(SectionedAddress, DILineInfoSpecifier,
                                     bool));
   // Most of the methods in the interface are unused. We only mock the
   // method that we expect to be called from the memprof reader.
   virtual DILineInfo symbolizeCode(SectionedAddress, DILineInfoSpecifier,
                                    bool) const {
     llvm_unreachable("unused");
   }
   virtual DIGlobal symbolizeData(SectionedAddress) const {
     llvm_unreachable("unused");
   }
   virtual std::vector<DILocal> symbolizeFrame(SectionedAddress) const {
     llvm_unreachable("unused");
   }
-  virtual std::vector<SectionedAddress> findSymbol(StringRef Symbol) const {
+  virtual std::vector<SectionedAddress> findSymbol(StringRef Symbol,
+                                                   uint64_t Offset) const {
     llvm_unreachable("unused");
   }
   virtual bool isWin32Module() const { llvm_unreachable("unused"); }
   virtual uint64_t getModulePreferredBase() const {
     llvm_unreachable("unused");
   }
 };