[symbolizer] Support symbol lookup

[sepavloff]

Summary

Recent versions of GNU binutils starting from 2.39 support symbol+offset
lookup in addition to the usual numeric address lookup. This change adds
symbol lookup to llvm-symbolize and llvm-addr2line.

Now llvm-symbolize behaves closer to GNU addr2line, - if the value specified
as address in command line or input stream is not a number, it is treated as
a symbol name. For example:

llvm-symbolize --obj=abc.so func_22
llvm-symbolize --obj=abc.so "CODE func_22"

This lookup is now supported only for functions. Specification with
offset is not supported yet.

[sepavloff]

Ping.

[sepavloff]

Ping.

[sepavloff]

Ping.

[ikudrin]

I believe it would be much better not to add the new mode (SYMBOL), but to support the new way of specifying an address for CODE.

Please, don't forget to reflected the changes in llvm/docs/CommandGuide/llvm-symbolizer.rst and probably llvm/docs/CommandGuide/llvm-addr2line.rst.

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

227–229

I don't think we need a new point of divergence here. It's unlikely that anyone would rely on the tool to generate an error for such an input.

[jhenderson]

Completely agree with what @ikudrin said. We don't need to maintain backwards compatibility between versions of our tools if the old behaviour didn't make much sense (i.e. treating non-numbers as symbols is a good thing, and the old behaviour of just echoing the input wasn't particularly useful). I also don't think we need a new SYMBOL directive (assuming GNU addr2line doesn't support it anyway), unless there's no practical way to make symbols work in the CODE directive (but I don't see why there wouldn't be).

[sepavloff]

Address reviewers' notes

• Removed command SYMBOL,
• Support symbol lookup in llvm-symbolizer as well.

[jhenderson]

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

69

I'm thinking this might be better named IsGNUStyle, since llvm-symbolizer has an --output-style option, and this variable controls how the output is formatted.

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

357

Nit: This should probably have braces, as it is a non-trivial statement (even if it is only a single statement technically). See https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements for more details.

llvm/test/tools/llvm-symbolizer/Inputs/addr2.inp

2

Please don't add a separate input file that is only used by one test.

The llvm-symbolizer tests could do with a bit of cleaning-up. Using a separate input file for text input is one such example.

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

467

This should be controlled by the output-style command-line option (see my comment elsewhere).

[jhenderson]

llvm/test/tools/llvm-symbolizer/output-style-empty-line.test

12

I don't think these check-suffixes are particularly understandable any more, given the changed behaviour. I'd suggest instead renaming them all and moving the check patterns to be immediately after the group that uses them. Something like:

RUN: llvm-symbolizer -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
RUN:   | FileCheck %s --check-prefix=SYMB-LLVM

RUN: llvm-symbolizer --output-style=LLVM -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
RUN:   | FileCheck %s --check-prefix=SYMB-LLVM

SYMB-LLVM: x.c:14:0
SYMB-LLVM-EMPTY:
SYMB-LLVM-NEXT: some text2

RUN: llvm-symbolizer --output-style=GNU -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
RUN:   | FileCheck %s --check-prefix=SYMB-GNU

SYMB-GNU: x.c:14
SYMB-GNU-NEXT: some text2

RUN: llvm-addr2line -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
RUN:   | FileCheck %s --check-prefix=ADDR-GNU

RUN: llvm-addr2line --output-style=GNU -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
RUN:   | FileCheck %s --check-prefix=ADDR-GNU

ADDR-GNU: x.c:14
ADDR-GNU-NEXT: ??:0

RUN: llvm-addr2line --output-style=LLVM -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
RUN:   | FileCheck %s --check-prefix=ADDR-LLVM

ADDR-LLVM: x.c:14:0
ADDR-LLVM-EMPTY:
ADDR-LLVM-NEXT: ??:0

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

49

I think you could make this a little more self descriptive, by changing your invalid input to something like "0 not a symbol name or number". That being said, the intent of this test, I think, was to use the exact same set of inputs as one that doesn't use JSON style.

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

2

You're using a weird mix of comment markers in this file. The standard rules in newer tools tests are

• ## for actual comments;
• # for RUN and CHECK lines;
• all comment markers should have a space between them and the rest of the line (e.g. # CHECK: or ## This is a comment).
• optionally, if the test consists solely of things prefixed with a comment marker, you can drop one # from each of the above, but it's more common to have them than not.

In addition, this test should have a comment explaining what the test is testing, probably before this comment.

5

I can't tell what "PRFUNC" is supposed to stand for. It might be useful to add a comment before each test case explaining what that specific case is testing.

10

Why is this test case epeated twice?

18

It would be better for both "nonexistent" cases to have a suffix, rather than just the llvm-symbolizer one.

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

207

214

This whole area of code could do with some blank lines to aid readability. I would suggest that you have them between each group of related lines, where "related" means a comment, one if statement, and any lines strongly related to that if statement (e.g. variable declarations). For example, I'd add a line before the comment about 0x prefixes, and another one after the if's closing brace.

227–229

+1: I don't think we need to handle invalid input differently between llvm-symbolizer and llvm-addr2line specifically, as long as the updated behaviour makes sense.

[ikudrin]

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

266–269

The conditions with fewer negations are much easier to understand.

[sepavloff]

Address reviewers' notes

[sepavloff]

llvm/test/tools/llvm-symbolizer/output-style-empty-line.test

12

Yes, it looks better. Thank you!

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

2

Thank you for eplanations. I modernized also sym.test, it didn't follow these rules.

10

It should be llvm-addr2line and llvm-symbolizer variants. Fixed.

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

467

Initialization of Config.IsGNUStyle is now below in this function.

[sepavloff]

Make response of llvm-symbolizer on invalid input with spaces identical to llvm-addr2line

[sepavloff]

Ping.

[jhenderson]

Sorry for the delay - I was away last week, and am still catching up on reviews.

llvm/test/tools/llvm-symbolizer/flag-grouping.test

6 ↗

(On Diff #538185)

Let's match the full line in all of these cases where the text has changed.

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

2

Can I ask you to spin off sym.test's updates into a new review? I've got no objection to the update (sym.test itself is a little bit archaic), but it's not really related to this patch.

Also "when address" -> "when an address"

5

The individual sub cases within this test file could still do with some comments to make their purpose clearer. I think I follow it better now with the recent improvements, but more clarity would help.

10

I forgot to mention that I prefer - to _ in prefix names. It avoids weird awkardness like CODE_CMD-NEXT for example, and - is easier to type on an English keyboard :D

20

ADDR is probably not a good abbreviation for addr2line since it could be confused with address which is a a very relevant term to these tests. Perhaps A2L? Apologies for the churn.

[sepavloff]

Address reviewer's notes

[jhenderson]

llvm/test/tools/llvm-symbolizer/sym.test

0–1

I generally would avoid double blank lines. My personal rule is similar to what I follow in C++ code:

1. No blank line if the comment is tightly linked to the immediately following block.
2. One blank line if the comment is more general (e.g. it applies to a wider area of code/isn't really targeted at a specific block etc).

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

8

Prefer a slightly longer form that says something like "Show that the "CODE" command supports search by symbol name." Same goes for below comments.

9

See my above comment: as this comment is tightly tied to the test case that immediately follows, it doesn't need a blank line (and regardless, blank lines generally don't have a comment marker, unless they are separating paragraphs within a longer comment).

14–15

I don't think you should reference GNU here - that's a motivation for the behaviour, but not for the test case for that behaviour. Rather, what this comment could say is "Show that llvm-addr2line and llvm-symbolizer accept symbol names on the command-line."

21

32

I think I might be getting confused between different patches, but looking at this again, my feeling is that we don't really want this divergence in behaviour between GNU and LLVM mode, unless there's a strong motivation for the LLVM behaviour style. I might be inclined to create a different precursor patch that unifies the two, so that they do what GNU addr2line does.

[ikudrin]

llvm/docs/ReleaseNotes.rst

326 ↗

(On Diff #542971)

Please remove the spaces in the blank line.

[sepavloff]

Rebase the patch

[jhenderson]

@sepavloff, what's the situation with this patch? Are you planning on addressing review comments or similar, or waiting for an upstream patch to land etc etc?

[sepavloff]

In D149759#4636578, @jhenderson wrote:

@sepavloff, what's the situation with this patch? Are you planning on addressing review comments or similar, or waiting for an upstream patch to land etc etc?

All necessary prerequisites are landed, the patch is updated and is ready for review.

[jhenderson]

llvm/docs/ReleaseNotes.rst

326 ↗

(On Diff #542971)

Not addresssed?

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

110

This is a bit of a nit-pick, but it is throwing me off a bit having both const std::string & and StringRef arguments for this overload of findSymbol. I see why you've done it (similarity with other overloaded functions above and below), but I feel like it should probably still use the correct and consistent style (StringRef) for both.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

388

It's possible I've missed it, but I don't see any test that shows this array has appropriate contents (I see a few where it is empty, but there needs to be one or more test cases that cover it having contents, at least one of which should cover it having more than one entry).

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

357

I'm a little concerned about the performance of this code. It might be a premature concern, but looping through a list of symbols to find one, for every input symbol, sounds like it could get expensive quite rapidly - if you were naively to use llvm-symbolizer to symbolize an entire object by using its listed symbol names, you'd end up with an n^2 operation, as every search has to go through the entire list.

The performance of the symbolizer code is considered important, hence why I'm bringing this up. I wonder if it's worth considering changing the std::vector used for Symbols into another container with more efficient searching performance?

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

237–238

Is there testing covering this failure for this specific case?

245–246

Ditto.

253–254

This needs a test case to show that if Opts.Demangle is false, the name isn't demangled.

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

9

Not addressed. For a concrete example, I personally recommend the following format:

# Comment
RUN: ...
RUN: ...

CHECK: ...
CHEC-NEXT:

# Next test case comment
RUN: ...

14–15

Not addressed.

25

37

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

214

StartsWithHexPrefix appears to be unused?

[sepavloff]

Update patch

[jhenderson]

There look like there are a few of my previous comments that haven't been addressed yet?

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

65

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

13

You don't specify things "in" a command line, you specify them "on the command-line."

18

I'm not sure this comment needed changing. The previous version was good: "If symbol has a space in its name, ignore everything after it." though I might change "after it" to "from the space onwards."

You could add "Check that" to the start too, so the final thing might look like:
"Check that if a symbol has a space in its name, ignore everything from the space onwards."

27

"Show that if a symbol ..."

[sepavloff]

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

388

At the end of output-style-json-code.test a test is added that checks the case of more than one entry.

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

357

This is a very important aspect of this solution. It however requires substantial code changes, so it is not practical to implement the performance enhancements in this patch. There are few users of this feature right now and GNU addr2line also uses linear search, so it is unlikely that performance problems would be noticed immediately.

Some possible applications need llvm-symbolizer for large files and many symbols, performance is critical for such cases, so a solution will be elaborated. It requires more efforts than just changing the implementation of Symbol, as it is already sorted by address. There are other points where the speed or memory consumption can be improved, they could be treated together.

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

237–238

It is unlikely that this code fails, because getOrCreateModuleInfo is called early to check existence and validity of binary file.

245–246

Actually this code was copied from symbolize*Common, it will fail exactly in the same cases when fail those functions.

253–254

Such tests are added at the end of symbol-search.test.

[sepavloff]

Fix comments

[sepavloff]

Add missing tests

[sepavloff]

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

237–238

I was wrong. If binary file name was not specified via --obj option, it will be extracted from command line arguments. In this case getOrCreateModuleInfo is called just in this code and may fail. The relevant test is added to symbol-search.test.

245–246

It seems this case (no error from getOrCreateModuleInfo but zero pointer to SymbolizableModule) cannot be realized.

[jhenderson]

Sorry for the delay - Phabricator issues and being busy meant I only just got back to this.

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

245–246

Okay, thanks for looking into it.

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

13

I think canoncially it should be "command-line" not "command line" (this is based on what someone from our docs team once told me).

56

Strictly speaking, using the --obj option to provide the binary file is also specifying it on the command-line. I think this comment should be a little more specific (assuming it matters). I'd also use "input file" rather than "binary file" to clarify the file's purpose. Something like: "Show that both the symbol and input file can be specified in the search string on the command-line." or something like that.

Similar comments apply below.

62

Nit: here and below, add a space after >2 to make it stand out more.

[sepavloff]

Update the patch

• Fix comments in symbol-search.test,
• Merge D149757,
• Rebase.

[jhenderson]

LGTM, thanks, but please give @ikudrin/@MaskRay/... a few days to make any other comments.

[sepavloff]

Thanks!

[sepavloff]

The patch was reverted because the test llvm/test/Support/interrupts.test started failing. The fail is observed only on Windows. It looks like this is the test problem, it works incorrectly, if stderr is not empty. The fix is provided in https://github.com/llvm/llvm-project/pull/68556.

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

 
 namespace symbolize {
 
 class SourceCode;
 
 struct Request {
   StringRef ModuleName;
   std::optional<uint64_t> Address;
+  StringRef Symbol;
 };
 
 class DIPrinter {
 public:
   DIPrinter() = default;
   virtual ~DIPrinter() = default;
 
   virtual void print(const Request &Request, const DILineInfo &Info) = 0;
   virtual void print(const Request &Request, const DIInliningInfo &Info) = 0;
   virtual void print(const Request &Request, const DIGlobal &Global) = 0;
   virtual void print(const Request &Request,
                      const std::vector<DILocal> &Locals) = 0;
+  virtual void print(const Request &Request,
+                     const std::vector<DILineInfo> &Locations) = 0;
 
   virtual void printInvalidCommand(const Request &Request,
                                    StringRef Command) = 0;
 
   virtual bool printError(const Request &Request,
                           const ErrorInfoBase &ErrorInfo) = 0;
 
   virtual void listBegin() = 0;
   virtual void listEnd() = 0;
 };
 
 struct PrinterConfig {
   bool PrintAddress;
   bool PrintFunctions;
   bool Pretty;
   bool Verbose;
   int SourceContextLines;
 };
 
 using ErrorHandler = function_ref<void(const ErrorInfoBase &, StringRef)>;
 
 class PlainPrinterBase : public DIPrinter {
 protected:
   raw_ostream &OS;
   ErrorHandler ErrHandler;
   PrinterConfig Config;
public:
   PlainPrinterBase(raw_ostream &OS, ErrorHandler EH, PrinterConfig &Config)
       : OS(OS), ErrHandler(EH), Config(Config) {}
 
   void print(const Request &Request, const DILineInfo &Info) override;
   void print(const Request &Request, const DIInliningInfo &Info) override;
   void print(const Request &Request, const DIGlobal &Global) override;
   void print(const Request &Request,
              const std::vector<DILocal> &Locals) override;
+  void print(const Request &Request,
+             const std::vector<DILineInfo> &Locations) override;
 
   void printInvalidCommand(const Request &Request, StringRef Command) override;
 
   bool printError(const Request &Request,
                   const ErrorInfoBase &ErrorInfo) override;
 
   void listBegin() override {}
   void listEnd() override {}
public:
   JSONPrinter(raw_ostream &OS, PrinterConfig &Config)
       : OS(OS), Config(Config) {}
 
   void print(const Request &Request, const DILineInfo &Info) override;
   void print(const Request &Request, const DIInliningInfo &Info) override;
   void print(const Request &Request, const DIGlobal &Global) override;
   void print(const Request &Request,
              const std::vector<DILocal> &Locals) override;
+  void print(const Request &Request,
+             const std::vector<DILineInfo> &Locations) override;
 
   void printInvalidCommand(const Request &Request, StringRef Command) override;
 
   bool printError(const Request &Request,
                   const ErrorInfoBase &ErrorInfo) override;
 
   void listBegin() override;
   void listEnd() override;
 };
 } // namespace symbolize
 } // namespace llvm
 
 #endif

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

public:
   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;
+
   // 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,
                            DILineInfoSpecifier LineInfoSpecifier,
                            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;
 
   // 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(const std::string &ModuleName,
+                                               StringRef Symbol);
+  Expected<std::vector<DILineInfo>> findSymbol(ArrayRef<uint8_t> BuildID,
+                                               StringRef Symbol);
+
   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();
 
   static std::string
symbolizeInlinedCodeCommon(const T &ModuleSpecifier,
                              object::SectionedAddress ModuleOffset);
   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);
 
   /// Returns a SymbolizableModule or an error if loading debug info failed.
   /// Only one attempt is made to load a module, and errors during loading are
   /// only reported once. Subsequent calls to get module info for a module that
   /// failed to load will return nullptr.
   Expected<SymbolizableModule *>
   getOrCreateModuleInfo(const std::string &ModuleName);
   Expected<SymbolizableModule *> getOrCreateModuleInfo(const ObjectFile &Obj);

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

for (const DILocal &L : Locals) {
         OS << *L.TagOffset;
       else
         OS << DILineInfo::Addr2LineBadString;
       OS << '\n';
     }
   printFooter();
 }
 
+void PlainPrinterBase::print(const Request &Request,
+                             const std::vector<DILineInfo> &Locations) {
+  if (Locations.empty())
+    OS << DILineInfo::Addr2LineBadString << ":0\n";
+  else
+    for (const DILineInfo &L : Locations)
+      print(L, false);
+  printFooter();
+}
+
 void PlainPrinterBase::printInvalidCommand(const Request &Request,
                                            StringRef Command) {
   OS << Command << '\n';
 }
 
 bool PlainPrinterBase::printError(const Request &Request,
                                   const ErrorInfoBase &ErrorInfo) {
   ErrHandler(ErrorInfo, Request.ModuleName);
   // Print an empty struct too.
   return true;
 }
 
 static std::string toHex(uint64_t V) {
   return ("0x" + Twine::utohexstr(V)).str();
 }
 
 static json::Object toJSON(const Request &Request, StringRef ErrorMsg = "") {
   json::Object Json({{"ModuleName", Request.ModuleName.str()}});
+  if (!Request.Symbol.empty())
+    Json["SymName"] = Request.Symbol.str();
   if (Request.Address)
     Json["Address"] = toHex(*Request.Address);
   if (!ErrorMsg.empty())
     Json["Error"] = json::Object({{"Message", ErrorMsg.str()}});
   return Json;
 }
 
 static json::Object toJSON(const DILineInfo &LineInfo) {
void JSONPrinter::print(const Request &Request,
   json::Object Json = toJSON(Request);
   Json["Frame"] = std::move(Frame);
   if (ObjectList)
     ObjectList->push_back(std::move(Json));
   else
     printJSON(std::move(Json));
 }
 
+void JSONPrinter::print(const Request &Request,
+                        const std::vector<DILineInfo> &Locations) {
+  json::Array Definitions;
+  for (const DILineInfo &L : Locations)
+    Definitions.push_back(toJSON(L));
+  json::Object Json = toJSON(Request);
+  Json["Loc"] = std::move(Definitions);
+  if (ObjectList)
+    ObjectList->push_back(std::move(Json));
+  else
+    printJSON(std::move(Json));
+}
+
 void JSONPrinter::printInvalidCommand(const Request &Request,
                                       StringRef Command) {
   printError(Request,
              StringError("unable to parse arguments: " + Command,
                          std::make_error_code(std::errc::invalid_argument)));
 }
 
 bool JSONPrinter::printError(const Request &Request,

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 {
+  std::vector<object::SectionedAddress> Result;
+  for (const SymbolDesc &Sym : Symbols)
+    if (Sym.Name.equals(Symbol)) {
+      object::SectionedAddress A{Sym.Addr,
+                                 getModuleSectionIndexForAddress(Sym.Addr)};
+      Result.push_back(A);
+    }
+  return Result;
+}
+
 /// Search for the first occurence of specified Address in ObjectFile.
 uint64_t SymbolizableObjectFile::getModuleSectionIndexForAddress(
     uint64_t Address) const {
 
   for (SectionRef Sec : Module->sections()) {
     if (!Sec.isText() || Sec.isVirtual())
       continue;
 
     if (Address >= Sec.getAddress() &&
         Address < Sec.getAddress() + Sec.getSize())
       return Sec.getIndex();
   }
 
   return object::SectionedAddress::UndefSection;
 }

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) {
+  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)) {
+    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);
+}
+
+Expected<std::vector<DILineInfo>>
+LLVMSymbolizer::findSymbol(const std::string &ModuleName, StringRef Symbol) {
+  return findSymbolCommon(ModuleName, Symbol);
+}
+
+Expected<std::vector<DILineInfo>>
+LLVMSymbolizer::findSymbol(ArrayRef<uint8_t> BuildID, StringRef Symbol) {
+  return findSymbolCommon(BuildID, Symbol);
+}
+
 void LLVMSymbolizer::flush() {
   ObjectForUBPathAndArch.clear();
   LRUBinaries.clear();
   CacheSize = 0;
   BinaryForPath.clear();
   ObjectPairForPathArch.clear();
   Modules.clear();
   BuildIDPaths.clear();

llvm/test/tools/llvm-symbolizer/Inputs/addr2.inp

+0some text
+0x40054d
+0some text2

llvm/test/tools/llvm-symbolizer/invalid-input-address.test

 RUN: echo -e 'some text\nsome text2\n' > %t.inp
 
 # Test bad input address values, via stdin, command line and response file.
 RUN: llvm-symbolizer --obj=%p/Inputs/addr.exe < %t.inp | FileCheck --check-prefix=BAD-INPUT %s
 RUN: llvm-symbolizer --obj=%p/Inputs/addr.exe "some text" "some text2" | FileCheck --check-prefix=BAD-INPUT %s
 RUN: llvm-symbolizer --obj=%p/Inputs/addr.exe @%t.rsp | FileCheck --check-prefix=BAD-INPUT %s
 
 # Test bad input address values for the GNU-compatible version.
-RUN: llvm-addr2line --obj=%p/Inputs/addr.exe < %t.inp | FileCheck --check-prefix=BAD-INPUT %s
-RUN: llvm-addr2line --obj=%p/Inputs/addr.exe "some text" "some text2" | FileCheck --check-prefix=BAD-INPUT %s
-RUN: llvm-addr2line --obj=%p/Inputs/addr.exe @%t.rsp | FileCheck --check-prefix=BAD-INPUT %s
+RUN: llvm-addr2line --obj=%p/Inputs/addr.exe < %t.inp | FileCheck --check-prefix=BAD-INPUT-GNU %s
+RUN: llvm-addr2line --obj=%p/Inputs/addr.exe "some text" "some text2" | FileCheck --check-prefix=BAD-INPUT-GNU %s
+RUN: llvm-addr2line --obj=%p/Inputs/addr.exe @%t.rsp | FileCheck --check-prefix=BAD-INPUT-GNU %s
 
 BAD-INPUT:      some text
 BAD-INPUT-NEXT: some text2
+
+BAD-INPUT-GNU:      ??:0
+BAD-INPUT-GNU-NEXT: ??:0

llvm/test/tools/llvm-symbolizer/output-style-empty-line.test

 This test checks that with --output-style=GNU the tool does not print an empty
 line after the report for an address. The current behavior is preserved for
 --output-style=LLVM or if the option is omitted.
 
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
 RUN:   | FileCheck %s --check-prefix=LLVM
 
 RUN: llvm-symbolizer --output-style=LLVM -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
 RUN:   | FileCheck %s --check-prefix=LLVM
 
 RUN: llvm-symbolizer --output-style=GNU -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
-RUN:   | FileCheck %s --check-prefix=GNU
+RUN:   | FileCheck %s --check-prefix=GNUOUT
 
 RUN: llvm-addr2line -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
 RUN:   | FileCheck %s --check-prefix=GNU
 
 RUN: llvm-addr2line --output-style=GNU -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
 RUN:   | FileCheck %s --check-prefix=GNU
 
 RUN: llvm-addr2line --output-style=LLVM -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
-RUN:   | FileCheck %s --check-prefix=LLVM
+RUN:   | FileCheck %s --check-prefix=LLVMOUT
 
 LLVM: x.c:14:0
 LLVM-EMPTY:
 LLVM-NEXT: some text2
 
 GNU: x.c:14
-GNU-NEXT: some text2
+GNU-NEXT: ??:0
+
+GNUOUT: x.c:14
+GNUOUT-NEXT: some text2
+
+LLVMOUT: x.c:14:0
+LLVMOUT-EMPTY:
+LLVMOUT-NEXT: ??:0

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

 # INLINE:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
 ## Resolve valid address.
 # INLINE-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inctwo","Line":3,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inc","Line":7,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"main","Line":14,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12}]}
 ## Invalid argument after a valid one.
 # INLINE-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
 
 ## Also check the last test case with llvm-adr2line.
 ## The expected result is the same with -f -i.
-# RUN: llvm-addr2line --output-style=JSON -f -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp | \
+# RUN: llvm-addr2line --output-style=JSON -f -i -e %p/Inputs/addr.exe < %p/Inputs/addr2.inp | \
 # RUN:   FileCheck %s --check-prefix=INLINE-A2L --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ## Invalid first argument before any valid one.
-# INLINE-A2L:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# INLINE-A2L:{"Error":{"Message":"unable to parse arguments: 0some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
 ## Resolve valid address.
 # INLINE-A2L-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inctwo","Line":3,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inc","Line":7,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"main","Line":14,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12}]}
 ## Invalid argument after a valid one.
-# INLINE-A2L-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# INLINE-A2L-NEXT:{"Error":{"Message":"unable to parse arguments: 0some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
 
 ## Note llvm-addr2line without -f does not print the function name in JSON too.
-# RUN: llvm-addr2line --output-style=JSON -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp | \
+# RUN: llvm-addr2line --output-style=JSON -i -e %p/Inputs/addr.exe < %p/Inputs/addr2.inp | \
 # RUN:   FileCheck %s --check-prefix=NO-FUNC-A2L --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ## Invalid first argument before any valid one.
-# NO-FUNC-A2L:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# NO-FUNC-A2L:{"Error":{"Message":"unable to parse arguments: 0some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
 ## Resolve valid address.
 # NO-FUNC-A2L-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"","Line":3,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"","Line":7,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"","Line":14,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12}]}
 ## Invalid argument after a valid one.
-# NO-FUNC-A2L-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# NO-FUNC-A2L-NEXT:{"Error":{"Message":"unable to parse arguments: 0some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}

llvm/test/tools/llvm-symbolizer/sym.test

 #Source:
 ##include <stdio.h>
 #static inline int inctwo (int *a) {
 #  printf ("%d\n",(*a)++);
 #  return (*a)++;
 #}
 #static inline int inc (int *a) {
 #  printf ("%d\n",inctwo(a));
 #  return (*a)++;

 #PRETTY: {{[0x]+}}40054d: inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3:3
 #PRETTY:  (inlined by) inc at {{[/\]+}}tmp{{[/\]+}}x.c:7:0
 #PRETTY:  (inlined by) main at {{[/\]+}}tmp{{[/\]+}}x.c:14:0
 #PRETTY: some text2
 #
 #ZERO: ??
 #ZERO: ??:0:0
 #
-#A2L:         some text
+#A2L:         ??:0
 #A2L_A-NEXT:  0x40054d
 #A2L_F-NEXT:  inctwo
 #A2L-NEXT:    {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
 #A2L_FI-NEXT: inc{{$}}
 #A2L_I-NEXT:  {{[/\]+}}tmp{{[/\]+}}x.c:7{{$}}
 #A2L_FI-NEXT: main
 #A2L_I-NEXT:  {{[/\]+}}tmp{{[/\]+}}x.c:14{{$}}
-#A2L-NEXT:    some text2
+#A2L-NEXT:    ??:0
 
-#A2LP:          some text
+#A2LP:          ??:0
 #A2LP_A-NEXT:   0x40054d: {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
 #A2LP_F-NEXT:   inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
 #A2LP_AF-NEXT:  0x40054d: inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3{{$}}
 #A2LP_I-NEXT:   {{[/\]+}}tmp{{[/\]+}}x.c:7{{$}}
 #A2LP_I-NEXT:   {{[/\]+}}tmp{{[/\]+}}x.c:14{{$}}
 #A2LP_FI-NEXT:   (inlined by) inc at {{[/\]+}}tmp{{[/\]+}}x.c:7{{$}}
 #A2LP_FI-NEXT:   (inlined by) main at {{[/\]+}}tmp{{[/\]+}}x.c:14{{$}}
-#A2LP-NEXT:     some text2
+#A2LP-NEXT:     ??:0

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

+# This test uses ELF shared object `Inputs/symbols.so` built for x86_64 using
+# the instructions from `Inputs/symbols.h`.
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so "SYMBOL func_01" | FileCheck --check-prefix=PRFUNC %s
+#PRFUNC: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so --pretty-print "SYMBOL func_01" | FileCheck --check-prefix=PRETTY %s
+#PRETTY: func_01 at /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so "SYMBOL func_666" | FileCheck --check-prefix=INEXISTENT %s
+#INEXISTENT: ??
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so "SYMBOL func_01" "SYMBOL func_02" | FileCheck --check-prefix=FUNCS %s
+#FUNCS:  /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+#FUNCS:  /tmp/dbginfo{{[/\]+}}symbols.part2.cpp:10
+
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so "SYMBOL _ZL14static_func_01i" | FileCheck --check-prefix=MULTI %s
+#MULTI: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:7
+#MULTI: /tmp/dbginfo{{[/\]+}}symbols.part2.cpp:5
+
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01 | FileCheck --check-prefix=A2L0 %s
+#A2L0: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+
+RUN: llvm-addr2line -e %p/Inputs/symbols.so static_func | FileCheck --check-prefix=A2LMULTI %s
+#A2LMULTI:      /tmp/dbginfo{{[/\]+}}symbols.part3.c:4
+#A2LMULTI-NEXT: /tmp/dbginfo{{[/\]+}}symbols.part4.c:4

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

 }
 
 enum class OutputStyle { LLVM, GNU, JSON };
 
 enum class Command {
   Code,
   Data,
   Frame,
+  Symbol,
 };
 
 static void enableDebuginfod(LLVMSymbolizer &Symbolizer,
                              const opt::ArgList &Args) {
   static bool IsEnabled = false;
   if (IsEnabled)
     return;
   IsEnabled = true;
   // Look up symbols using the debuginfod client.
   Symbolizer.setBuildIDFetcher(std::make_unique<DebuginfodFetcher>(
       Args.getAllArgValues(OPT_debug_file_directory_EQ)));
   // The HTTPClient must be initialized for use by the debuginfod client.
   HTTPClient::initialize();
 }
 
 static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
                          StringRef InputString, Command &Cmd,
                          std::string &ModuleName, object::BuildID &BuildID,
-                         uint64_t &ModuleOffset) {
+                         StringRef &Symbol, uint64_t &ModuleOffset) {
   const char kDelimiters[] = " \n\r";
   ModuleName = "";
   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 (InputString.consume_front("SYMBOL ")) {
+    Cmd = Command::Symbol;
   } else {
     // If no cmd, assume it's CODE.
     Cmd = Command::Code;
   }
 
   const char *Pos;
   // Skip delimiters and parse input filename (if needed).
   if (BinaryName.empty() && BuildID.empty()) {
if (HasBuildIDPrefix) {
       if (BuildID.empty())
         return false;
       ModuleName.clear();
     }
   } else {
     Pos = InputString.data();
     ModuleName = BinaryName.str();
   }
-  // Skip delimiters and parse module offset.
+
+  // Parse address, which can be specified as an offset in module or as a
+  // symbol.
   Pos += strspn(Pos, kDelimiters);
   int OffsetLength = strcspn(Pos, kDelimiters);
   StringRef Offset(Pos, OffsetLength);
   // GNU addr2line assumes the offset is hexadecimal and allows a redundant
   // "0x" or "0X" prefix; do the same for compatibility.
+  bool StartsWithHexPrefix = false;
   if (IsAddr2Line)
+    StartsWithHexPrefix =
         Offset.consume_front("0x") || Offset.consume_front("0X");
-  return !Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset);
+  if (!Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset)) {
+    // Module offset is an address.
+    Symbol = StringRef();
+    return true;
+  }
+  // If address specification starts with a digit, but is not a number, consider
+  // it as invalid.
+  if (Offset.empty() || StartsWithHexPrefix || std::isdigit(Offset.front()))
+    return false;
+  // Address specification is a symbol if addr2line compatibility mode in on.
+  // Otherwise treat it as an error for compatibility with previous versions of
+  // llvm-symbolizer.
+  if (IsAddr2Line || Cmd == Command::Symbol) {
+    Symbol = Offset;
+    ModuleOffset = 0;
+    return true;
+  }
+  return false;
 }
 
 template <typename T>
 void executeCommand(StringRef ModuleName, const T &ModuleSpec, Command Cmd,
-                    uint64_t Offset, uint64_t AdjustVMA, bool ShouldInline,
-                    OutputStyle Style, LLVMSymbolizer &Symbolizer,
-                    DIPrinter &Printer) {
+                    StringRef Symbol, uint64_t Offset, uint64_t AdjustVMA,
+                    bool ShouldInline, OutputStyle Style,
+                    LLVMSymbolizer &Symbolizer, DIPrinter &Printer) {
   uint64_t AdjustedOffset = Offset - AdjustVMA;
   object::SectionedAddress Address = {AdjustedOffset,
                                       object::SectionedAddress::UndefSection};
-  Request SymRequest = {ModuleName, Offset};
+  Request SymRequest = {ModuleName, Offset, Symbol};
   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 (Cmd == Command::Symbol || !Symbol.empty()) {
+    Expected<std::vector<DILineInfo>> ResOrErr =
+        Symbolizer.findSymbol(ModuleSpec, Symbol);
+    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()
     // may override the name of an inlined function with the name of the topmost
static void symbolizeInput(const opt::InputArgList &Args,
                            object::BuildIDRef IncomingBuildID,
                            uint64_t AdjustVMA, bool IsAddr2Line,
                            OutputStyle Style, StringRef InputString,
                            LLVMSymbolizer &Symbolizer, DIPrinter &Printer) {
   Command Cmd;
   std::string ModuleName;
   object::BuildID BuildID(IncomingBuildID.begin(), IncomingBuildID.end());
   uint64_t Offset = 0;
+  StringRef Symbol;
   if (!parseCommand(Args.getLastArgValue(OPT_obj_EQ), IsAddr2Line,
-                    StringRef(InputString), Cmd, ModuleName, BuildID, Offset)) {
-    Printer.printInvalidCommand({ModuleName, std::nullopt}, InputString);
+                    StringRef(InputString), Cmd, ModuleName, BuildID, Symbol,
+                    Offset)) {
+    Printer.printInvalidCommand({ModuleName, std::nullopt, Symbol},
+                                InputString);
     return;
   }
   bool ShouldInline = Args.hasFlag(OPT_inlines, OPT_no_inlines, !IsAddr2Line);
   if (!BuildID.empty()) {
     assert(ModuleName.empty());
     if (!Args.hasArg(OPT_no_debuginfod))
       enableDebuginfod(Symbolizer, Args);
     std::string BuildIDStr = toHex(BuildID);
-    executeCommand(BuildIDStr, BuildID, Cmd, Offset, AdjustVMA, ShouldInline,
-                   Style, Symbolizer, Printer);
+    executeCommand(BuildIDStr, BuildID, Cmd, Symbol, Offset, AdjustVMA,
+                   ShouldInline, Style, Symbolizer, Printer);
   } else {
-    executeCommand(ModuleName, ModuleName, Cmd, Offset, AdjustVMA, ShouldInline,
-                   Style, Symbolizer, Printer);
+    executeCommand(ModuleName, ModuleName, Cmd, Symbol, Offset, AdjustVMA,
+                   ShouldInline, Style, Symbolizer, Printer);
   }
 }
 
 static void printHelp(StringRef ToolName, const SymbolizerOptTable &Tbl,
                       raw_ostream &OS) {
   const char HelpText[] = " [options] addresses...";
   Tbl.printHelp(OS, (ToolName + HelpText).str().c_str(),
                 ToolName.str().c_str());

 #endif
   Opts.UseSymbolTable = true;
   if (Args.hasArg(OPT_cache_size_EQ))
     parseIntArg(Args, OPT_cache_size_EQ, Opts.MaxCacheSize);
   Config.PrintAddress = Args.hasArg(OPT_addresses);
   Config.PrintFunctions = Opts.PrintFunctions != FunctionNameKind::None;
   Config.Pretty = Args.hasArg(OPT_pretty_print);
   Config.Verbose = Args.hasArg(OPT_verbose);
 
   for (const opt::Arg *A : Args.filtered(OPT_dsym_hint_EQ)) {
     StringRef Hint(A->getValue());
     if (sys::path::extension(Hint) == ".dSYM") {
       Opts.DsymHints.emplace_back(Hint);
     } else {
       errs() << "Warning: invalid dSYM hint: \"" << Hint
              << "\" (must have the '.dSYM' extension).\n";
     }

llvm/unittests/ProfileData/MemProfTest.cpp

 
 namespace {
 
 using ::llvm::DIGlobal;
 using ::llvm::DIInliningInfo;
 using ::llvm::DILineInfo;
 using ::llvm::DILineInfoSpecifier;
 using ::llvm::DILocal;
+using ::llvm::StringRef;
 using ::llvm::memprof::CallStackMap;
 using ::llvm::memprof::Frame;
 using ::llvm::memprof::FrameId;
 using ::llvm::memprof::IndexedMemProfRecord;
 using ::llvm::memprof::MemInfoBlock;
 using ::llvm::memprof::MemProfRecord;
 using ::llvm::memprof::MemProfSchema;
 using ::llvm::memprof::Meta;
virtual DILineInfo symbolizeCode(SectionedAddress, DILineInfoSpecifier,
     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 {
+    llvm_unreachable("unused");
+  }
   virtual bool isWin32Module() const { llvm_unreachable("unused"); }
   virtual uint64_t getModulePreferredBase() const {
     llvm_unreachable("unused");
   }
 };
 
 struct MockInfo {
   std::string FunctionName;