[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

253–255

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

66

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

1 ↗

(On Diff #537212)

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

488

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 ↗

(On Diff #537212)

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

226

239

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.

253–255

+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 ↗

(On Diff #537212)

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

488

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

20 ↗

(On Diff #542971)

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

166

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

166

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

384

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

238–239

Is there testing covering this failure for this specific case?

246–247

Ditto.

254–255

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.

24

36

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

239

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

384

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

238–239

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

246–247

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

254–255

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

238–239

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.

246–247

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

246–247

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/docs/CommandGuide/llvm-symbolizer.rst

 llvm-symbolizer - convert addresses into source code locations
 ==============================================================
 
 .. program:: llvm-symbolizer
 
 SYNOPSIS
 --------
 
 :program:`llvm-symbolizer` [*options*] [*addresses...*]
 
 DESCRIPTION
 -----------
 
 :program:`llvm-symbolizer` reads input names and addresses from the command-line
 and prints corresponding source code locations to standard output. It can also
 symbolize logs containing :doc:`Symbolizer Markup </SymbolizerMarkupFormat>` via
-:option:`--filter-markup`.
+:option:`--filter-markup`. Addresses may be specified as numbers or symbol names.
 
 If no address is specified on the command-line, it reads the addresses from
 standard input. If no input name is specified on the command-line, but addresses
 are, the first address value is treated as an input name. If an input value is not
 recognized, it reports that source information is not found.
 
 Input names can be specified together with the addresses either on standard
 input or as positional arguments on the command-line. By default, input names
.. code-block:: console
   /tmp/foo/test.cpp:15:0
   $ llvm-symbolizer --obj=test.elf 0x4004a0 --basenames
   main
   test.cpp:15:0
   $ llvm-symbolizer --obj=test.elf 0x4004a0 --relativenames
   main
   foo/test.cpp:15:0
 
+Example 7 - Addresses as symbol names:
+
+.. code-block:: console
+
+  $ llvm-symbolizer --obj=test.elf main
+  main
+  /tmp/test.cpp:14:0
+  $ llvm-symbolizer --obj=test.elf "CODE foz"
+  foz
+  /tmp/test.h:1:0
+
 OPTIONS
 -------
 
 .. option:: --adjust-vma <offset>
 
   Add the specified offset to object file addresses when performing lookups.
   This can be used to perform lookups as if the object were relocated by the
   offset.

llvm/docs/ReleaseNotes.rst

 
 Changes to the Debug Info
 ---------------------------------
 
 Changes to the LLVM tools
 ---------------------------------
 
 * llvm-symbolizer now treats invalid input as an address for which source
   information is not found.
   
+* llvm-symbolizer and llvm-addr2line now support addresses specified as symbol names.
+
 Changes to LLDB
 ---------------------------------
 
 * Methods in SBHostOS related to threads have had their implementations
   removed. These methods will return a value indicating failure.
 
 Changes to Sanitizers
 ---------------------

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 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;
 
   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;
 
   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);
 
   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/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()) {
+    print(Request, DILineInfo());
+  } else {
+    for (const DILineInfo &L : Locations)
+      print(L, false);
+    printFooter();
+  }
+}
+
 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));
+}
+
 bool JSONPrinter::printError(const Request &Request,
                              const ErrorInfoBase &ErrorInfo) {
   json::Object Json = toJSON(Request, ErrorInfo.message());
   if (ObjectList)
     ObjectList->push_back(std::move(Json));
   else
     printJSON(std::move(Json));
   return false;

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/addr.inp

-some text
+something not a valid address
 0x40054d
-some text2
+some text possibly a symbol

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

 some text
 0x400590
 0x4005a5
 0x4005ad
 0x4005b9
 0x4005ce
 0x4005d4
-some more text
+another text

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

 # DISCRIM:[{"Address":"0x400575","ModuleName":"{{.*}}/Inputs/discrim","Symbol":[{"Column":17,"Discriminator":2,"FileName":"/tmp{{/|\\\\}}discrim.c","FunctionName":"foo","Line":5,"StartAddress":"0x400560","StartFileName":"/tmp{{/|\\\\}}discrim.c","StartLine":4}]}]
 
 ## In case of stdin input the output will contain a single JSON object for each input string.
 
 ## This test case is testing stdin input, with the --no-inlines option.
 # RUN: llvm-symbolizer --output-style=JSON --no-inlines -e %p/Inputs/addr.exe < %p/Inputs/addr.inp | \
 # RUN:   FileCheck %s --check-prefix=NO-INLINES --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ## Invalid first argument before any valid one.
-# NO-INLINES:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# NO-INLINES:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"something"}
 ## Resolve valid address.
 # NO-INLINES-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"main","Line":3,"StartAddress":"0x400540","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2}]}
 ## Invalid argument after a valid one.
-# NO-INLINES-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# NO-INLINES-NEXT:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"some"}
 
 ## This test case is testing stdin input, inlines by default.
 # RUN: llvm-symbolizer --output-style=JSON -e %p/Inputs/addr.exe < %p/Inputs/addr.inp | \
 # RUN:   FileCheck %s --check-prefix=INLINE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ## Invalid first argument before any valid one.
-# INLINE:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# INLINE:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"something"}
 ## 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:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# INLINE-NEXT:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"some"}
 
 ## 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:   FileCheck %s --check-prefix=INLINE-A2L --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ## Invalid first argument before any valid one.
-# INLINE-A2L:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# INLINE-A2L:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"something"}
 ## 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:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# INLINE-A2L:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"some"}
 
 ## 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:   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:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# NO-FUNC-A2L:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"something"}
 ## 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:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
+# NO-FUNC-A2L-NEXT:{"Loc":[],"ModuleName":"{{.*}}/Inputs/addr.exe","SymName":"some"}

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

 ## This test checks JSON output for DATA.
 
 # REQUIRES: x86-registered-target
 
 ## Show how library errors are reported in the output.
 # RUN: llvm-symbolizer "DATA %t-no-file.o 0" --output-style=JSON | \
 # RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=NO-FILE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 # NO-FILE:[{"Address":"0x0","Error":{"Message":"[[MSG]]"},"ModuleName":"{{.*}}no-file.o"}]
 
 ## Handle invalid argument.
 # RUN: llvm-symbolizer "DATA tmp.o Z" --output-style=JSON | \
-# RUN:   FileCheck %s --check-prefix=INVARG --strict-whitespace --match-full-lines --implicit-check-not={{.}}
-# INVARG:[{"ModuleName":"tmp.o","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}]
+# RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=INVARG --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+# INVARG:[{"Error":{"Message":"[[MSG]]"},"ModuleName":"tmp.o","SymName":"Z"}]
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 ## Resolve out of range address.
 # RUN: llvm-symbolizer "DATA %t.o 0x10000000" --output-style=JSON | \
 # RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 # NOT-FOUND:[{"Address":"0x10000000","Data":{"Name":"","Size":"0x0","Start":"0x0"},"ModuleName":"{{.*}}.o"}]
 

llvm/test/tools/llvm-symbolizer/output-style-json-frame.ll

 ;; This test checks JSON output for FRAME.
 
 ; REQUIRES: aarch64-registered-target
 
 ;; Show how library errors are reported in the output.
 ; RUN: llvm-symbolizer "FRAME %t-no-file.o 0" --output-style=JSON | \
 ; RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=NO-FILE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ; NO-FILE:[{"Address":"0x0","Error":{"Message":"[[MSG]]"},"ModuleName":"{{.*}}no-file.o"}]
 
 ;; Handle invalid argument.
 ; RUN: llvm-symbolizer "FRAME tmp.o Z" --output-style=JSON | \
-; RUN:   FileCheck %s --check-prefix=INVARG --strict-whitespace --match-full-lines --implicit-check-not={{.}}
-; INVARG:[{"ModuleName":"tmp.o","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}]
+; RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=INVARG --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+; INVARG:[{"Error":{"Message":"[[MSG]]"},"ModuleName":"tmp.o","SymName":"Z"}]
 
 ; RUN: llc -filetype=obj -o %t.o %s 
 
 ;; Resolve out of range address. Expected an empty array.
 ; RUN: llvm-symbolizer "FRAME %t.o 0x10000000" --output-style=JSON | \
 ; RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
 ; NOT-FOUND:[{"Address":"0x10000000","Frame":[],"ModuleName":"{{.*}}.o"}]
 

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

+# This test checks the case when an address is specified by a symbol name rather
+# than a number.
+#
+# It uses ELF shared object `Inputs/symbols.so` built for x86_64 using
+# the instructions from `Inputs/symbols.h`.
+
+# Command "CODE" supports search by symbol name.
+
+RUN: llvm-addr2line --obj=%p/Inputs/symbols.so "CODE func_01" | FileCheck --check-prefix=CODE-CMD %s
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so "CODE func_01" | FileCheck --check-prefix=CODE-CMD %s
+CODE-CMD: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+
+# GNU addr2line accepts symbol names in command line, llvm-symbolizer also allows
+# this in both GNU and LLVM modes.
+
+RUN: llvm-addr2line -e %p/Inputs/symbols.so func_01 | FileCheck --check-prefix=SYMB %s
+RUN: llvm-symbolizer -e %p/Inputs/symbols.so func_01 | FileCheck --check-prefix=SYMB %s
+SYMB: /tmp/dbginfo{{[/\]+}}symbols.part1.cpp:12
+
+# If symbol has a space in its name, ignore everything after it.
+RUN: llvm-addr2line -e %p/Inputs/symbols.so "func_01 ignored text" | FileCheck --check-prefix=SYMB %s
+RUN: llvm-symbolizer -e %p/Inputs/symbols.so "func_01 ignored text" | FileCheck --check-prefix=SYMB %s
+
+# A symbol name may be resolved into more than one location.
+
+RUN: llvm-addr2line -e %p/Inputs/symbols.so static_func | FileCheck --check-prefix=SYMB-MULTI %s
+SYMB-MULTI:      /tmp/dbginfo{{[/\]+}}symbols.part3.c:4
+SYMB-MULTI-NEXT: /tmp/dbginfo{{[/\]+}}symbols.part4.c:4
+
+# If symbol is not found, the symbolizer outputs a special mark.
+
+RUN: llvm-addr2line --obj=%p/Inputs/symbols.so func_666 | FileCheck --check-prefix=NONEXISTENT %s
+RUN: llvm-symbolizer --obj=%p/Inputs/symbols.so func_666 | FileCheck --check-prefix=NONEXISTENT %s
+NONEXISTENT: ??
+
+# More than one symbols 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
+
+# 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

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,
-                          uint64_t &ModuleOffset) {
+                          StringRef &Symbol, uint64_t &ModuleOffset) {
   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 || HasFilePrefix) {
     }
   } 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.
+  // Parse module offset, which can be specified as a number or as a symbol.
   InputString = InputString.ltrim();
   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);
+
   // 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)
     Offset.consume_front("0x") || Offset.consume_front("0X");
 
-  // If the input is not a valid module offset, it is not an error, but its
-  // lookup does not make sense. Return error of different kind to distinguish
-  // from error or success.
-  if (Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset))
-    return errorCodeToError(errc::invalid_argument);
+  // If the input is not a number, treat it is a symbol.
+  if (Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset)) {
+    Symbol = Offset;
+    ModuleOffset = 0;
+  }
 
   return Error::success();
 }
 
 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, Symbol.empty() ? std::make_optional(Offset) : std::nullopt,
+      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 (!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 (Error E = parseCommand(Args.getLastArgValue(OPT_obj_EQ), IsAddr2Line,
                              StringRef(InputString), Cmd, ModuleName, BuildID,
-                             Offset)) {
-    handleAllErrors(
-        std::move(E),
-        [&](const StringError &EI) {
-          printError(EI, InputString);
-          printUnknownLineInfo(ModuleName, Printer);
-        },
-        [&](const ECError &EI) { printUnknownLineInfo(ModuleName, Printer); });
+                             Symbol, Offset)) {
+    handleAllErrors(std::move(E), [&](const StringError &EI) {
+    });
     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";
     }
else
     Printer = std::make_unique<LLVMPrinter>(outs(), printError, Config);
 
   // When an input file is specified, exit immediately if the file cannot be
   // read. If getOrCreateModuleInfo succeeds, symbolizeInput will reuse the
   // cached file handle.
   if (auto *Arg = Args.getLastArg(OPT_obj_EQ); Arg) {
     auto Status = Symbolizer.getOrCreateModuleInfo(Arg->getValue());
     if (!Status) {
-      Request SymRequest = {Arg->getValue(), 0};
+      Request SymRequest = {Arg->getValue(), 0, StringRef()};
       handleAllErrors(Status.takeError(), [&](const ErrorInfoBase &EI) {
         Printer->printError(SymRequest, EI);
       });
       return EXIT_FAILURE;
     }
   }
 
   std::vector<std::string> InputAddresses = Args.getAllArgValues(OPT_INPUT);

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::MemProfReader;
 using ::llvm::memprof::MemProfRecord;
 using ::llvm::memprof::MemProfSchema;
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;