[symbolizer] Change reaction on invalid input

[sepavloff]

Summary

If llvm-symbolizer finds a malformed command, it echoes it to the
standard output. New versions of binutils (starting from 2.39) allow to
specify an address by a symbols. Implementation of this feature in
llvm-symbolizer makes the current reaction on invalid input
inappropriate. Almost any invalid command may be treated as a symbol
name, so the right reaction should be "symbol not found" in such case.

The exception are commands that are recognized but have incorrect
syntax, like "FILE:FILE:". The utility must produce descriptive
diagnostic for such input and route it to the stderr.

This change implements the new reaction on invalid input and is a
prerequisite for implementation of symbol lookup in llvm-symbolizer.

[sepavloff]

Update patch

[ikudrin]

LGTM. Returning an explanatory Error instead of just a boolean status seems like a big improvement to me.

[jhenderson]

Generally looks fine, but there are a number of small issues, and I'm not convinced by the JSON output behaviour change, hence requesting changes to clear the "accepted" state.

llvm/docs/CommandGuide/llvm-symbolizer.rst

21–22

llvm/docs/ReleaseNotes.rst

165

Nit: I don't think you want 2 blank lines (1 will do).

llvm/test/tools/llvm-symbolizer/file-prefix.test

8

Rather than redirecting stdin, use the --input-file option.

(Motivation for me is that the shell I commonly use, Windows PowerShell, doesn't support < for stdin redirection)

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

2

26

Nit: missing new line at EOF.

llvm/test/tools/llvm-symbolizer/options-from-env.test

1–3

Let's use LLVM and GNU prefixes rather than SYMB and CHECK (corresponds to LLVM and GNU styles).

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

28

These seem like a regression to me in the JSON output, as it's no longer recording the error?

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

155–162

createStringError or makeStringError would be better than getStringError in my opinion - get implies to me that the Error exists and that you're just fetching it from somewhere.

182

Nit: here and below, error messages should use lower case for the first letter. See https://llvm.org/docs/CodingStandards.html#error-and-warning-messages.

238

Rather than just producing "invalid argument", could we give additional information about what the argument is that is deemed to be invalid, e.g. "1foo is not a valid address" or something like that?

[sepavloff]

Rebase. Address reviewers' notes

[sepavloff]

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

28

It is not an error anymore, it is "no source information". If llvm-symbolizer is called with an address without such information, for example:

llvm-symbolizer -e llvm-symbolizer --output-style=JSON 0x3

the output is similar:

[{"Address":"0x3","ModuleName":"llvm-symbolizer","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}]

It is consistent with the new behavior for other output styles, and is natural if symbol lookup is implemented.

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

238

Actually it is not an error, llvm-symbolize processes it as an address which has no related source information. It is consistent with the present behavior of GNU addr2line (even of version before 2.39). An error is returned so that the message "??:0" could be printed immediately. To distinguish this case from the errors that require emitting a diagnostic message, a different error type is used here. Actually particular error code is not used, only different class matters. The code in symbolizeInput can react differently in such case.

Implementation of symbol lookup will make this trick unnecessary, as any string could potentially be a symbol name.

[jhenderson]

Thanks for addressing my concerns. LGTM.

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

238

Okay, on the basis that this is only temporary, this is fine. The comment is useful too.

[sepavloff]

Thanks!

[sepavloff]

Rebase

[MaskRay]

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

36

remove this change.

https://en.cppreference.com/w/cpp/utility/optional/optional
"1) Constructs an object that does not contain a value."

[MaskRay]

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

211

cannot be empty seems better than is incorrect

[sepavloff]

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

36

The initializer was added because of the warning^

export/serge/llvm/space2/llvm-project/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp:292:43: warning: missing field 'Address' initializer [-Wmissing-field-initializers]
          Request SymRequest = {ModuleName};

I added the second item to the initializer and removed the initializer in the struct declaration.

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

211

It is not for missing argument but for the case of unterminated strings:

$ cat sym.inp
FILE:"addr.exe 0x400540
$ ./llvm-symbolizer <sym.inp
$ ./llvm-symbolizer: error: 'FILE:"addr.exe 0x400540': input file name is incorrect

[dyung]

Hi @sepavloff, I'm seeing some weird behavior on our Windows build bot after your change (https://lab.llvm.org/buildbot/#/builders/216/builds/25497).

When building your change, it seems one of the tests is hanging, and it keeps a lock on llvm-symbolizer.exe which then causes subsequent builds to fail as they cannot write to the file. The only way to recover the build bot that I've found is to login, kill the zombie llvm-symbolizer process and then I can delete the binary so that it can be re-written on a later build. Any idea why this might be happening?

From process explorer, this is the command that is getting stuck:

"c:\program files\python310\python.exe" Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\test\Support\interrupts.test symbolizer z:\b\llvm-clang-x86_64-sie-win\build\bin\llvm-symbolizer.exe

I'm also seeing a similar issue affecting another Windows build bot https://lab.llvm.org/buildbot/#/builders/65/builds/10919. Something about your change does not seem to sit well with Windows builders. Can you take a look or revert if you need time to investigate? I may revert it soon since it requires manual intervention to get the build bot back running again, but wanted to check and see if you had any idea what might be happening first.

[dyung]

Sorry, I had to revert your change to get the Windows build bots back up and running.

To anyone here who is trying to recover your build bot, I found that killing the llvm-symbolizer.exe process in task manager and then restarting the build after my revert fixes the issue.

[sepavloff]

Hi @dyung. Thank you for recovering builds and for the provided information. I saw the fails on some bots but had no information about what is wrong. Now I have a starting point.

[sepavloff]

Reopen to run tests for the fixed patch.

[sepavloff]

Attempt to fix hanging test.

[jhenderson]

As far as I can tell, the only "fix" you've made since the version that caused the hangs was to the test itself. That means that llvm-symbolizer could still hang under certain conditions surely, when it didn't used to...

If I squint hard enough, I could maybe see why this change is acceptable, but I'd like you to explain the change and why it isn't going to cause end-users hanging issues in practice.

[sepavloff]

The test hang is caused by the way llvm-symbolizer is ised in the test.

The test invokes llvm-symbolizer without arguments. So it tries to get both binary file an address from stdin. The script in the original test supplies foo to the llvm-symbolizer. This is an incorrect input, foo is treated as a binary file, but an address is absent, so the old llvm-symbolizer echoes foo on stdout. The script gets output on stdout and finishes.

The new llvm-symbolizer also detects the invalid command and puts descriptive diagnostic on stderr:

$ ./llvm-symbolizer
foo
./llvm-symbolizer: error: 'foo': no input filename is specified

Nothing appears on stdout in this case and the script continues waiting, - the test hangs.

Adding two words to the input of llvm-symbolizer make the command syntactically correct. Obviously, the tool cannot find source information in response to such command, so ??:0 is printed on stdout. The test script gets data it is wainting for and the test normally finishes.

[jhenderson]

Right, that's what I figured was the issue, but could you answer this part of my concern:

[explain] why it isn't going to cause end-users hanging issues in practice

My opinion is that if someone is in interactive mode and they get an error, it may make sense to exit llvm-symbolizer, rather than continue. How does this differ to the previous (prior to your patch) behaviour for other error cases (i.e. cases other than "missing an input file/address pair")?

[sepavloff]

In D157210#4584361, @jhenderson wrote:

My opinion is that if someone is in interactive mode and they get an error, it may make sense to exit llvm-symbolizer, rather than continue. How does this differ to the previous (prior to your patch) behaviour for other error cases (i.e. cases other than "missing an input file/address pair")?

This is behavior of llvm-symbolizer before this patch. Whenever it detects an invalid input it echoes the input and continue waiting on stdin. This behavior makes sense, - if the program got wrong command from interactive input, it can continue working because the next commands may do useful job.

Anyway, it is not llvm-symbolizer that caused the hang, it is blocking read in the test script, which waits input from the stream that is empty in the case of new llvm-symbolizer.

[jhenderson]

In D157210#4584620, @sepavloff wrote:

In D157210#4584361, @jhenderson wrote:

My opinion is that if someone is in interactive mode and they get an error, it may make sense to exit llvm-symbolizer, rather than continue. How does this differ to the previous (prior to your patch) behaviour for other error cases (i.e. cases other than "missing an input file/address pair")?

This is behavior of llvm-symbolizer before this patch. Whenever it detects an invalid input it echoes the input and continue waiting on stdin. This behavior makes sense, - if the program got wrong command from interactive input, it can continue working because the next commands may do useful job.

Anyway, it is not llvm-symbolizer that caused the hang, it is blocking read in the test script, which waits input from the stream that is empty in the case of new llvm-symbolizer.

Sorry, I'm struggling to follow what you're saying. My concern is that because we had a test script that has gone from working to hanging, it's possible that an end user's script will be in the same state, so when they get the updated llvm-symbolizer, they will have a script that was previously working but is now hanging. I'm not concerned by llvm-symbolizer changing in other ways that could potentially invalidate their script, but introducing a potential path to a hang is a cause for concern. What does llvm-addr2line do in this sort of situation? Does it print something like "??:0:0" (as well as the error), because I think that might be a good answer.

@MaskRay/@ikudrin, any thoughts?

[MaskRay]

In D157210#4587435, @jhenderson wrote:

In D157210#4584620, @sepavloff wrote:

In D157210#4584361, @jhenderson wrote:

My opinion is that if someone is in interactive mode and they get an error, it may make sense to exit llvm-symbolizer, rather than continue. How does this differ to the previous (prior to your patch) behaviour for other error cases (i.e. cases other than "missing an input file/address pair")?

This is behavior of llvm-symbolizer before this patch. Whenever it detects an invalid input it echoes the input and continue waiting on stdin. This behavior makes sense, - if the program got wrong command from interactive input, it can continue working because the next commands may do useful job.

Anyway, it is not llvm-symbolizer that caused the hang, it is blocking read in the test script, which waits input from the stream that is empty in the case of new llvm-symbolizer.

Sorry, I'm struggling to follow what you're saying. My concern is that because we had a test script that has gone from working to hanging, it's possible that an end user's script will be in the same state, so when they get the updated llvm-symbolizer, they will have a script that was previously working but is now hanging. I'm not concerned by llvm-symbolizer changing in other ways that could potentially invalidate their script, but introducing a potential path to a hang is a cause for concern. What does llvm-addr2line do in this sort of situation? Does it print something like "??:0:0" (as well as the error), because I think that might be a good answer.

@MaskRay/@ikudrin, any thoughts?

Is llvm/test/Support/interrupts.test the only failing test? (https://lab.llvm.org/buildbot/#/builders/216/builds/25497/steps/7/logs/stdio linked by @dyung above has tons of logs but I cannot find the relevant line.)

If yes, I think the latest revision contains the right change.

-     proc.stdin.write(b'foo\n')
+    proc.stdin.write(bytes(sys.argv[2] + " 0\n", 'ascii'))

% /tmp/Debug/bin/llvm-symbolizer
/tmp/Debug/bin/llvm-symbolizer 0
??
??:0:0

foo
/tmp/Debug/bin/llvm-symbolizer: error: 'foo': no input filename is specified

Since llvm-symbolizer no longer echoes (to stdout) the invalid foo input, proc.stdout.readline() in the Python script will block.
Switching to symbolizing llvm-symbolizer itself will give some stdout output.

[jhenderson]

I took a break away from this for a few days, and decided that I shouldn't block this patch based on the behaviour change. However, I do think the specific case that can now hang (i.e. the case that caused the test to fail) should be highlighted in the release note, so that users can have a hint as to why their script started hanging after they updated to the latest llvm-symbolizer. LGTM with that.

llvm/docs/ReleaseNotes.rst

164

It might be worth noting explicitly the change in output behaviour for invalid behaviour here, namely that none is produced on stdout. Specifically, I want users to at least be aware that the llvm-symbolizer change could introduce a hang in scripts that were potentially poorly written ebfore.

llvm/test/tools/llvm-symbolizer/debuginfod.test

42

[MaskRay]

llvm/test/tools/llvm-symbolizer/debuginfod.test

44

Delete llvm-symbolizer{{.*}}: . We generally don't test things before error:.

68

delete llvm-symbolizer{{.*}}: . ditto below

llvm/test/tools/llvm-symbolizer/file-prefix.test

9

delete llvm-symbolizer{{.*}}:

[sepavloff]

Attempt to make llvm-symbolizer more hang-resistant

Behavior of llvm-symbolizer is slightly modified to avoid hanging.
If it receives data from the standard input, it always prints some
output on stdout. If the command is invalid, it prints ??:0 in
addition to the diagnostic on stderr. If a user makes blocking
read of llvm-symbolizer stdout, it won't wait forever with the
updated utility.

[jhenderson]

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

207–208

211

"is incorrect" doesn't seem right to me either. It doesn't tell the user how it is incorrect.

Also, I couldn't see a test case for this?

312

Does this really need to be conditional on interactive mode? It seems an unnecessary complication to me.

[sepavloff]

Enhance error messages a bit

[sepavloff]

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

211

Changed to more specific message about unbalanced quotes.

312

This is an unneeded complication, removed.

[jhenderson]

Just some nits left from me.

llvm/test/tools/llvm-symbolizer/get-input-file.test

5

9

29

This comment shoudl say something about unbalanced quotes, not "unterminated string", which implies something about a missing \0 to me.

48

Nit: no new line at EOF.

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

195

207–208

My apologies, this was stupid of me. It should be "input file has already been specified"

224

"is" -> "has been"

230

"is" -> "has been"

[sepavloff]

Address reviewer's notes

[jhenderson]

LGTM, with one remaining nit.

llvm/test/tools/llvm-symbolizer/get-input-file.test

5

Sorry, missed this typo.

[sepavloff]

Thanks!

llvm/docs/CommandGuide/llvm-symbolizer.rst

 
 :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`.
 
 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, or if at any time an input value is not recognized, the input is simply
-echoed to the output.
+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
 are interpreted as object file paths. However, prefixing a name with
 ``BUILDID:`` states that it is a hex build ID rather than a path. This will look
 up the corresponding debug binary. For consistency, prefixing a name with
 ``FILE:`` explicitly states that it is an object file path (the default).
 

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

 class raw_ostream;
 
 namespace symbolize {
 
 class SourceCode;
 
 struct Request {
   StringRef ModuleName;
   std::optional<uint64_t> Address;
 };
 
 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 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 {
protected:
   virtual void printSimpleLocation(StringRef Filename,
                                    const DILineInfo &Info) = 0;
   void printContext(SourceCode SourceCode);
   void printVerbose(StringRef Filename, const DILineInfo &Info);
   virtual void printStartAddress(const DILineInfo &Info) {}
   virtual void printFooter() {}
 
 private:
-  void printHeader(uint64_t Address);
+  void printHeader(std::optional<uint64_t> Address);
 
 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 printInvalidCommand(const Request &Request, StringRef Command) override;
-
   bool printError(const Request &Request,
                   const ErrorInfoBase &ErrorInfo) override;
 
   void listBegin() override {}
   void listEnd() override {}
 };
 
 class LLVMPrinter : public PlainPrinterBase {
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 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/lib/DebugInfo/Symbolize/DIPrinter.cpp

for (size_t Pos = 0; Pos < PrunedSource->size(); ++L) {
       OS << String << '\n';
       if (PosEnd == StringRef::npos)
         break;
       Pos = PosEnd + 1;
     }
   }
 };
 
-void PlainPrinterBase::printHeader(uint64_t Address) {
-  if (Config.PrintAddress) {
+void PlainPrinterBase::printHeader(std::optional<uint64_t> Address) {
+  if (Address.has_value() && Config.PrintAddress) {
     OS << "0x";
-    OS.write_hex(Address);
+    OS.write_hex(*Address);
     StringRef Delimiter = Config.Pretty ? ": " : "\n";
     OS << Delimiter;
   }
 }
 
 // Prints source code around in the FileName the Line.
 void PlainPrinterBase::printContext(SourceCode SourceCode) {
   SourceCode.format(OS);
if (Filename == DILineInfo::BadString)
     Filename = DILineInfo::Addr2LineBadString;
   if (Config.Verbose)
     printVerbose(Filename, Info);
   else
     printSimpleLocation(Filename, Info);
 }
 
 void PlainPrinterBase::print(const Request &Request, const DILineInfo &Info) {
-  printHeader(*Request.Address);
+  printHeader(Request.Address);
   print(Info, false);
   printFooter();
 }
 
 void PlainPrinterBase::print(const Request &Request,
                              const DIInliningInfo &Info) {
   printHeader(*Request.Address);
   uint32_t FramesNum = Info.getNumberOfFrames();
for (const DILocal &L : Locals) {
         OS << *L.TagOffset;
       else
         OS << DILineInfo::Addr2LineBadString;
       OS << '\n';
     }
   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) {
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::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,
                              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/test/Support/interrupts.test

 ## Show that SIGINT and similar signals don't cause crash messages to be
 ## reported.
 # RUN: %python %s wrapper llvm-symbolizer 2> %t.err
 # RUN: count 0 < %t.err
 
 import os
 import signal
 import subprocess
 import sys
 import time
 
 def run_symbolizer():
     proc = subprocess.Popen([sys.argv[2]], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
     # Write then read some output to ensure the process has started fully.
-    proc.stdin.write(b'foo\n')
+    proc.stdin.write(b'foo bar\n')
     proc.stdin.flush()
     proc.stdout.readline()
     # Windows handles signals differently.
     if os.name == 'nt':
         os.kill(0, signal.CTRL_BREAK_EVENT)
     else:
         proc.send_signal(signal.SIGINT)
 

llvm/test/tools/llvm-symbolizer/debuginfod.test

 
 # This should also work if the build ID is provided via stdin.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
 RUN:   "BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
 RUN:   FileCheck %s --check-prefix=FOUND
 
 # Passing BUILDID twice is a syntax error.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
-RUN:   "BUILDID:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
+RUN:   "BUILDID:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" 2>&1 | \
 RUN:   FileCheck %s --check-prefix=BUILDIDBUILDID
-BUILDIDBUILDID: BUILDID:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d
+BUILDIDBUILDID: error: 'BUILDID:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d': duplicate input file specification prefix
 
 # CODE should work preceding build ID.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
 RUN:   "CODE BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
 RUN:   FileCheck %s --check-prefix=FOUND
 
 # The symbolizer shouldn't call the debuginfod library by default with no URLs.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer --print-address \
 RUN:   --obj=%t/addr.exe 0x40054d | FileCheck %s --check-prefix=NOTFOUND
 
 # The symbolizer shouldn't call the debuginfod library if explicitly disabled.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
 RUN:   --no-debuginfod \
 RUN:   "BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
 RUN:   FileCheck %s --check-prefix=NOTHINGFOUND
 NOTHINGFOUND:      ??
 NOTHINGFOUND-NEXT: ??:0:0
 
 # BUILDID shouldn't be parsed if --obj is given, just like regular filenames.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
 RUN:   --obj=%t/addr.exe \
-RUN:   "BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
+RUN:   "BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" 2>&1 | \
 RUN:   FileCheck %s --check-prefix=BUILDIDIGNORED
-BUILDIDIGNORED: BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d
+BUILDIDIGNORED: error: 'BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d': input file has already been specified
 
 # Providing both BUILDID and FILE is a syntax error.
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
-RUN:   "BUILDID:FILE:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
+RUN:   "BUILDID:FILE:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" 2>&1 | \
 RUN:   FileCheck %s --check-prefix=BUILDIDFILE
-BUILDIDFILE: BUILDID:FILE:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d
+BUILDIDFILE: error: 'BUILDID:FILE:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d': duplicate input file specification prefix
 RUN: env DEBUGINFOD_CACHE_PATH=%t llvm-symbolizer \
-RUN:   "FILE:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" | \
+RUN:   "FILE:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d" 2>&1 | \
 RUN:   FileCheck %s --check-prefix=FILEBUILDID
-FILEBUILDID: FILE:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d
+FILEBUILDID: error: 'FILE:BUILDID:127da749021c1fc1a58cba734a1f542cbe2b7ce4 0x40054d': duplicate input file specification prefix

llvm/test/tools/llvm-symbolizer/file-prefix.test

 # The FILE prefix acts as a no-op, but it provides consistency with BUILDID.
 RUN: llvm-symbolizer "CODE FILE:%p/Inputs/addr.exe 0x40054d" | \
 RUN:   FileCheck %s --check-prefix=FOUND
 FOUND: {{[/\]+}}tmp{{[/\]+}}x.c:14:0
 
 # Passing FILE twice is a syntax error.
-RUN: llvm-symbolizer "CODE FILE:FILE:%p/Inputs/addr.exe 0x40054d" | \
-RUN:   FileCheck %s --check-prefix=FILEFILE
-FILEFILE: CODE FILE:FILE:{{.*}}/Inputs/addr.exe 0x40054d
+RUN: llvm-symbolizer "CODE FILE:FILE:%p/Inputs/addr.exe 0x40054d" 2>%t.err | FileCheck --check-prefix=NOTFOUND %s
+RUN:   FileCheck %s --check-prefix=FILEFILE --input-file %t.err
+NOTFOUND:      ??
+NOTFOUND-NEXT: ??:0:0
+FILEFILE: error: 'CODE FILE:FILE:{{.*}}/Inputs/addr.exe 0x40054d': duplicate input file specification prefix

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

 RUN: llvm-symbolizer -apCi --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 RUN: llvm-symbolizer -apCie %p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 RUN: llvm-symbolizer -apCie=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 RUN: llvm-symbolizer -apCie%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 
-CHECK: some text
+CHECK: ?? at ??:0:0
 CHECK: 0x40054d: inctwo
 CHECK: (inlined by) inc
 CHECK  (inlined by) main
-CHECK: some text2
+CHECK: ?? at ??:0:0

llvm/test/tools/llvm-symbolizer/flush-output.s

 # REQUIRES: x86-registered-target
 
 ## If a process spawns llvm-symbolizer, and wishes to feed it addresses one at a
 ## time, llvm-symbolizer needs to flush its output after each input has been
 ## processed or the parent process will not be able to read the output and may
 ## deadlock. This test runs a script that simulates this situation for both a
 ## a good and bad input.
 
 foo:
     nop
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o -g
 # RUN: %python %p/Inputs/flush-output.py llvm-symbolizer %t.o \
 # RUN:   | FileCheck %s
 
 # CHECK: flush-output.s:10
-# CHECK: bad
+# CHECK: ??:0

llvm/test/tools/llvm-symbolizer/functions.s

 # LINKAGE-NEXT: functions.cpp:2:0
 
 # SHORT:      {{^}}foo{{$}}
 # SHORT-NEXT: functions.cpp:2:0
 
 # NONE-NOT: foo
 # NONE:     functions.cpp:2:0
 
-# ERR: none
+# ERR: ??
+# ERR-NEXT: ??:0
 
 # The assembly below is a stripped down version of the output of:
 #   clang -S -g --target=x86_64-pc-linux
 # for the following C++ source:
 #   void foo(int bar) {}
   .type _Z3fooi,@function
 _Z3fooi:
 .Lfunc_begin0:

llvm/test/tools/llvm-symbolizer/get-input-file.test

+# If binary input file is not specified, llvm-symbolizer assumes it is the first
+# item in the command.
+
+# No input items at all, complain about missing input file.
+RUN: echo | llvm-symbolizer 2>%t.1.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.1.err --check-prefix=NOFILE %s
+
+# Only one input item, complain about missing addresses.
+RUN: llvm-symbolizer "foo" 2>%t.2.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.2.err --check-prefix=NOADDR %s
+
+# Two items specified, check if the first one is an existing file.
+RUN: llvm-symbolizer "foo 400" 2>%t.3.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.3.err --check-prefix=NOTFOUND %s
+
+# FILE: must be followed by a file name.
+RUN: llvm-symbolizer "FILE:" 2>%t.4.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.4.err --check-prefix=MISSING-FILE %s
+
+# BUILDID: must be followed by a hash.
+RUN: llvm-symbolizer "BUILDID:" 2>%t.5.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.5.err --check-prefix=MISSING-HASH %s
+
+# Wrong build-id.
+RUN: llvm-symbolizer "BUILDID: foo" 2>%t.6.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.6.err --check-prefix=BAD-HASH %s
+
+# Unbalanced string quotes in the file name.
+RUN: llvm-symbolizer "FILE:\"foo" 2>%t.7.err | FileCheck %s --check-prefix=NOSOURCE
+RUN: FileCheck --input-file=%t.7.err --check-prefix=BAD-QUOTE %s
+
+NOSOURCE:      ??
+NOSOURCE-NEXT: ??:0:0
+
+NOFILE: error: no input filename has been specified
+
+NOADDR: error: 'foo': no module offset has been specified
+
+NOTFOUND:  error: 'foo': {{[nN]}}o such file or directory
+
+MISSING-FILE: error: 'FILE:': must be followed by an input file
+
+MISSING-HASH: error: 'BUILDID:': must be followed by a hash
+
+BAD-HASH:  error: 'BUILDID: foo': wrong format of build-id
+
+BAD-QUOTE: error: 'FILE:"foo': unbalanced quotes in input file name

llvm/test/tools/llvm-symbolizer/input-base.test

 # llvm-symbolizer infers the number base from the form of the address.
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0x1234 | FileCheck %s
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0X1234 | FileCheck %s
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 4660 | FileCheck %s
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 011064 | FileCheck %s
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0b1001000110100 | FileCheck %s
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0B1001000110100 | FileCheck %s
 RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0o11064 | FileCheck %s
 
 # llvm-symbolizer / StringRef::getAsInteger only accepts the 0o prefix in lowercase.
-RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0O1234 | FileCheck %s --check-prefix=INVALID-NOT-OCTAL-UPPER
+RUN: llvm-symbolizer -e %p/Inputs/addr.exe -a 0O1234 | FileCheck %s --check-prefix=INVALID
 
 # llvm-addr2line always requires hexadecimal, but accepts an optional 0x prefix.
 RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0x1234 | FileCheck %s
 RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0X1234 | FileCheck %s
 RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 1234 | FileCheck %s
 RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 01234 | FileCheck %s
 RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0b1010 | FileCheck %s --check-prefix=HEXADECIMAL-NOT-BINARY
 RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0B1010 | FileCheck %s --check-prefix=HEXADECIMAL-NOT-BINARY
-RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0o1234 | FileCheck %s --check-prefix=INVALID-NOT-OCTAL-LOWER
-RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0O1234 | FileCheck %s --check-prefix=INVALID-NOT-OCTAL-UPPER
+RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0o1234 | FileCheck %s --check-prefix=INVALID-NOT-OCTAL
+RUN: llvm-addr2line -e %p/Inputs/addr.exe -a 0O1234 | FileCheck %s --check-prefix=INVALID-NOT-OCTAL
 
 CHECK: 0x1234
 CHECK-NEXT: ??
 
+INVALID:      ??
+INVALID-NEXT: ??:0
+
 HEXADECIMAL-NOT-BINARY: 0xb1010
 HEXADECIMAL-NOT-BINARY: ??
 
-INVALID-NOT-OCTAL-LOWER: 0o1234
-INVALID-NOT-OCTAL-LOWER-NOT: ??
-
-INVALID-NOT-OCTAL-UPPER: 0O1234
-INVALID-NOT-OCTAL-UPPER-NOT: ??
+INVALID-NOT-OCTAL: ??:0

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

 # Use address that can't fit in a 64-bit number. Show that llvm-symbolizer
-# simply echoes it as per other malformed input addresses.
+# simply treats it as an unknown symbol.
 RUN: llvm-symbolizer --obj=%p/Inputs/addr.exe 0x10000000000000000 | FileCheck --check-prefix=LARGE-ADDR %s
 
-LARGE-ADDR-NOT: {{.}}
-LARGE-ADDR:     0x10000000000000000
-LARGE-ADDR-NOT: {{.}}
+LARGE-ADDR-NOT:  {{.}}
+LARGE-ADDR:      ??
+LARGE-ADDR-NEXT: ??:0:0
+LARGE-ADDR-EMPTY:
+LARGE-ADDR-NOT:  {{.}}
 
 RUN: echo '"some text"' '"some text2"' > %t.rsp
 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
 
-BAD-INPUT:      some text
-BAD-INPUT-NEXT: some text2
+BAD-INPUT:      ??
+BAD-INPUT-NEXT: ??:0

llvm/test/tools/llvm-symbolizer/options-from-env.test

-# RUN: env LLVM_SYMBOLIZER_OPTS='0 1 --verbose' llvm-symbolizer 2 | FileCheck %s
-# RUN: env LLVM_ADDR2LINE_OPTS='0 1 --verbose' llvm-addr2line 2 | FileCheck %s
+RUN: env LLVM_SYMBOLIZER_OPTS='-e %p/Inputs/discrim --verbose' llvm-symbolizer 0x400590 | FileCheck --check-prefix=LLVM %s
+RUN: env LLVM_ADDR2LINE_OPTS='-e %p/Inputs/discrim --verbose' llvm-addr2line 0x400590 | FileCheck --check-prefix=GNU %s
 
-# CHECK:      0
-# CHECK-NEXT: 1
-# CHECK-NEXT: 2
+LLVM:      foo
+LLVM-NEXT: Filename: /tmp{{[\\/]}}discrim.c
+LLVM-NEXT: Function start filename: /tmp{{[\\/]}}discrim.c
+LLVM-NEXT: Function start line: 4
+LLVM-NEXT: Function start address: 0x400590
+LLVM-NEXT: Line: 5
+LLVM-NEXT: Column: 7
+
+GNU:      Filename: /tmp{{[\\/]}}discrim.c
+GNU-NEXT: Function start filename: /tmp{{[\\/]}}discrim.c
+GNU-NEXT: Function start line: 4
+GNU-NEXT: Line: 5
+GNU-NEXT: Column: 7

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-addr2line --output-style=LLVM -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
 RUN:   | FileCheck %s --check-prefix=LLVM
 
 LLVM: x.c:14:0
 LLVM-EMPTY:
-LLVM-NEXT: some text2
+LLVM-NEXT: ??
 
 RUN: llvm-symbolizer --output-style=GNU -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
 RUN:   | FileCheck %s --check-prefix=GNU
 
 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
 
 GNU: x.c:14
-GNU-NEXT: some text2
+GNU-NEXT: ??

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:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# NO-INLINES:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 ## 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:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# NO-INLINES-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 
 ## 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:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# INLINE:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 ## 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"}
+# INLINE-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 
 ## 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:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# INLINE-A2L:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 ## 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:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 
 ## 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:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+# NO-FUNC-A2L:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}
 ## 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:{"ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}

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:[{"Error":{"Message":"unable to parse arguments: DATA tmp.o Z"},"ModuleName":"tmp.o"}]
+# INVARG:[{"ModuleName":"tmp.o","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}]
 
 # 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:[{"Error":{"Message":"unable to parse arguments: FRAME tmp.o Z"},"ModuleName":"tmp.o"}]
+; INVARG:[{"ModuleName":"tmp.o","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartAddress":"","StartFileName":"","StartLine":0}]}]
 
 ; 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/sym-verbose.test

 # static volatile int do_mul;
 # static volatile int x, v;
 #
 # int foo () {
 #   if (do_mul) x *= v; else x /= v;
 #   return x;
 # }
 #
 # int main() {
 #   return foo() + foo();
 # }
 # Build as : clang -gmlt -fdebug-info-for-profiling -O2 discrim.c -o discrim
 
 RUN: llvm-symbolizer --verbose --print-address --obj=%p/Inputs/discrim < %p/Inputs/discrim.inp | FileCheck %s
 
-CHECK: some text
+CHECK: ??
 
 CHECK: 0x400590
 CHECK-NEXT: foo
 CHECK-NEXT: Filename: /tmp{{[\\/]}}discrim.c
 CHECK-NEXT: Function start filename: /tmp{{[\\/]}}discrim.c
 CHECK-NEXT: Function start line: 4
 CHECK-NEXT: Function start address: 0x400590
 CHECK-NEXT: Line: 5

 CHECK-NEXT: Filename: /tmp{{[\\/]}}discrim.c
 CHECK-NEXT: Function start filename: /tmp{{[\\/]}}discrim.c
 CHECK-NEXT: Function start line: 9
 CHECK-NEXT: Function start address: 0x400590
 CHECK-NEXT: Line: 10
 CHECK-NEXT: Column: 0
 CHECK-NEXT: Discriminator: 2
 
-CHECK: some more text
+CHECK: ??

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

 # }
 #
 # Build as : clang -g -O2 addr.c
 
 RUN: llvm-symbolizer --print-address --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 RUN: llvm-symbolizer --addresses --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 RUN: llvm-symbolizer -a --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
 
-CHECK: some text
+CHECK: ??:0:0
+CHECK-EMPTY:
 CHECK-NEXT: 0x40054d
 CHECK-NEXT: inctwo
 CHECK-NEXT: {{[/\]+}}tmp{{[/\]+}}x.c:3:3
 CHECK-NEXT: inc
 CHECK-NEXT: {{[/\]+}}tmp{{[/\]+}}x.c:7:0
 CHECK-NEXT: main
 CHECK-NEXT: {{[/\]+}}tmp{{[/\]+}}x.c:14:0
 CHECK-EMPTY:
-CHECK-NEXT: some text2
+CHECK-NEXT: ??
+CHECK-NEXT: ??:0:0
 
 RUN: llvm-symbolizer --inlining --print-address --pretty-print --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s 
 RUN: llvm-symbolizer --inlining --print-address -p --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer --inlines --print-address --pretty-print --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer --inlines --print-address -p --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer -i --print-address --pretty-print --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 RUN: llvm-symbolizer -i --print-address -p --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 
 # Before 2020-08-04, asan_symbolize.py passed --inlining=true.
 # Support this compatibility alias for a while.
 RUN: llvm-symbolizer --inlining=true --print-address -p --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix="PRETTY" %s
 
-PRETTY: some text
+PRETTY: ??:0:0
 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
+PRETTY: ??:0:0
 
 RUN: llvm-addr2line --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefix=A2L %s
 RUN: llvm-addr2line -a --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_A %s
 RUN: llvm-addr2line -f --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_F %s
 RUN: llvm-addr2line -i --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_I %s
 RUN: llvm-addr2line -fi --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2L,A2L_F,A2L_I,A2L_FI %s
 
 RUN: llvm-addr2line -pa --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_A %s
 RUN: llvm-addr2line -pf --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_F %s
 RUN: llvm-addr2line -paf --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_AF %s
 RUN: llvm-addr2line -pai --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_A,A2LP_I %s
 RUN: llvm-addr2line -pfi --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_F,A2LP_FI %s
 RUN: llvm-addr2line -pafi --obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck -check-prefixes=A2LP,A2LP_AF,A2LP_FI %s
 
-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_F-NEXT:  ??
+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/tools/llvm-symbolizer/llvm-symbolizer.cpp

 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/Debuginfod/HTTPClient.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/LLVMDriver.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
public:
   SymbolizerOptTable() : GenericOptTable(InfoTable) {
     setGroupedShortOptions(true);
   }
 };
 } // namespace
 
 static std::string ToolName;
 
-static void printError(const ErrorInfoBase &EI, StringRef Path) {
+static void printError(const ErrorInfoBase &EI, StringRef AuxInfo) {
   WithColor::error(errs(), ToolName);
-  if (!EI.isA<FileError>())
-    errs() << "'" << Path << "': ";
+  if (!AuxInfo.empty())
+    errs() << "'" << AuxInfo << "': ";
   EI.log(errs());
   errs() << '\n';
 }
 
 template <typename T>
 static void print(const Request &Request, Expected<T> &ResOrErr,
                   DIPrinter &Printer) {
   if (ResOrErr) {
if (*Pos == '"' || *Pos == '\'') {
     int NameLength = strcspn(Pos, kDelimiters);
     Result = StringRef(Pos, NameLength);
     Pos += NameLength;
   }
   Source = StringRef(Pos, Source.end() - Pos);
   return Result;
 }
 
-static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
+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) {
   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 no cmd, assume it's CODE.
     Cmd = Command::Code;
   }
 
   // Parse optional input file specification.
   bool HasFilePrefix = false;
   bool HasBuildIDPrefix = false;
   while (!InputString.empty()) {
     InputString = InputString.ltrim();
     if (InputString.consume_front("FILE:")) {
       if (HasFilePrefix || HasBuildIDPrefix)
-        // Input file specification prefix has already been seen.
-        return false;
+        return makeStringError("duplicate input file specification prefix");
       HasFilePrefix = true;
       continue;
     }
     if (InputString.consume_front("BUILDID:")) {
       if (HasBuildIDPrefix || HasFilePrefix)
-        // Input file specification prefix has already been seen.
-        return false;
+        return makeStringError("duplicate input file specification prefix");
       HasBuildIDPrefix = true;
       continue;
     }
     break;
   }
 
+  // If an input file is not specified on the command line, try to extract it
+  // from the command.
   if (HasBuildIDPrefix || HasFilePrefix) {
+    InputString = InputString.ltrim();
+    if (InputString.empty()) {
+      if (HasFilePrefix)
+        return makeStringError("must be followed by an input file");
+      else
+        return makeStringError("must be followed by a hash");
+    }
+
     if (!BinaryName.empty() || !BuildID.empty())
-      // Input file has already been specified on the command line.
-      return false;
+      return makeStringError("input file has already been specified");
+
     StringRef Name = getSpaceDelimitedWord(InputString);
     if (Name.empty())
-      // Wrong name for module file.
-      return false;
+      return makeStringError("unbalanced quotes in input file name");
     if (HasBuildIDPrefix) {
       BuildID = parseBuildID(Name);
       if (BuildID.empty())
-        // Wrong format of BuildID hash.
-        return false;
+        return makeStringError("wrong format of build-id");
     } else {
       ModuleName = Name;
     }
   } else if (BinaryName.empty() && BuildID.empty()) {
     // No input file has been specified. If the input string contains at least
     // two items, assume that the first item is a file name.
     ModuleName = getSpaceDelimitedWord(InputString);
-    if (ModuleName.empty() || InputString.empty())
-      // No input filename has been specified.
-      return false;
+    if (ModuleName.empty())
+      return makeStringError("no input filename has been specified");
   }
 
-  // Skip delimiters and parse module offset.
+  // Parse module offset.
   InputString = InputString.ltrim();
+  if (InputString.empty())
+    return makeStringError("no module offset has been specified");
   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.
   if (IsAddr2Line)
     Offset.consume_front("0x") || Offset.consume_front("0X");
-  return !Offset.getAsInteger(IsAddr2Line ? 16 : 0, ModuleOffset);
+
+  // 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);
+
+  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) {
   uint64_t AdjustedOffset = Offset - AdjustVMA;
void executeCommand(StringRef ModuleName, const T &ModuleSpec, Command Cmd,
   } else {
     Expected<DILineInfo> ResOrErr =
         Symbolizer.symbolizeCode(ModuleSpec, Address);
     print(SymRequest, ResOrErr, Printer);
   }
   Symbolizer.pruneCache();
 }
 
+static void printUnknownLineInfo(std::string ModuleName, DIPrinter &Printer) {
+  Request SymRequest = {ModuleName, std::nullopt};
+  Printer.print(SymRequest, DILineInfo());
+}
+
 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;
-  if (!parseCommand(Args.getLastArgValue(OPT_obj_EQ), IsAddr2Line,
-                    StringRef(InputString), Cmd, ModuleName, BuildID, Offset)) {
-    Printer.printInvalidCommand({ModuleName, std::nullopt}, InputString);
+  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); });
     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);