[ELF] - Keep the source file/line location information separate from the object file location information.

[grimar]

Summary

Approach was suggested in review for D27676,
patch splits reporting object name and source file/line location.
Extended information about source name, line etc moved to "note:" output.

Example of new output:
error: {{.*}}.o: duplicate symbol 'zed'
note: definition found in conflict-debug.s:4
previous definition was here: {{.*}}.o
definition found in conflict-debug.s:4

[silvas]

error: file-dbg2.o: duplicate symbol 'zed'
error: file-dbg2.a(file-dbg2.o): previous definition was here
note: definitions found in conflict-debug.s(.text+0x0) and conflict-debug.s(.text+0x0)

In general, we should assume that file names are going to be very long, so we should avoid having two of them on the same line. Can you follow the approach that the clang diagnostics use? (I pasted an example in: https://reviews.llvm.org/D27676#622869). I.e. "error: note: error: note:"

[grimar]

• Addressed comments.

[grimar]

• Uploading correct diff now :]

[grimar]

In D27900#626099, @silvas wrote:

In general, we should assume that file names are going to be very long, so we should avoid having two of them on the same line. Can you follow the approach that the clang diagnostics use? (I pasted an example in: https://reviews.llvm.org/D27676#622869). I.e. "error: note: error: note:"

Hopefully I implemented your suggestion now. Is that what you want to see ?

[ruiu]

Overall, I think you designed this a bit too much. I don't want to add that many small wrapper functions for the existing error/warn/fatal functions.

ELF/Error.cpp

84

If you add hint after warn in the header, please add to the same place in .cpp.

ELF/Error.h

40–42

Remove this blank line.

ELF/InputSection.cpp

42

I don't think this is a good addition because we already have too many error() wrapper functions. Aggregating two function calls into one doesn't help us that much, and I think it actually decreases readability. Please write it in two functions.

225–237

This is another Ext and that should be avoided.

ELF/InputSection.h

146

Please avoid Ext suffix because it doesn't convey meaning (with that naming scheme we'll end up having something like getDataExtExt.) You need to name variables/functions based on what they are instead of whether they are new or old.

ELF/SymbolTable.cpp

374–378

Why do you need this, OldLoc and OldLocHint? You can just write in place.

378

This results in an odd message.

note: foo.o: previous definition was here

This should be

note: previous definition was here: foo.o

ELF/Target.cpp

58

Please avoid writing a new wrapper.

64

Please avoid writing a new wrapper function.

What is this function? I think we don't want to print out "fatal error encountered" at end.

[grimar]

ELF/Target.cpp

64

Target.cpp now sometimes fatal(), for example when reloc is unrecognized.
So actually problem is to call some error message + hint(). I can't just call

fatal(...).
hint(...)

because user will not see hint.

That is why I introduced this function. Though I think no need to worry about it probably.
I believe what we can do at first - is to change fatal() to errors() in a separate patch. That removes
need of such hack. I'll try to prepare a patch, not sure why we fatal() now.

[grimar]

• Addressed review comments.

[grimar]

ELF/Error.cpp

84

Done.

ELF/Error.h

40–42

Done, though that was done intentionally initially. "hint" is not a error and not a log/warning,
but I have no major preference here to keep it separate from first group too.

Also I renamed "hint" to "note". As it prints "note: ....".
Actually I am thinking about this as about "hint", that why named in that way. But consistency with clang probably matters here.

ELF/InputSection.cpp

42

I am also would not do that change. I see no problems in having one more wrapper. It incapsulates some logic and avoids code duplication.
Sometimes we have a function for single call, like "convertPathToUnix" or alike for readability and that is fine.
Actually problem that I see is that them are thown everywhere around in code but not in a local file intended for error reporting. I would suggest to make error reporting to be as much local as possible and just move that to error.cpp.

So, I did that change as well, but I do not feel it was good one.

225–237

Done.

ELF/InputSection.h

146

I renamed it back. But I would like to explane why I did that (actually your mail about communication issues about LLD had a good effect for me, so I probably will want sometimes to explain why I did the changes instead of just replying "Done" as I did before).

Initially during development of this patch I had two methods. They were getLocationBase (it was inlined finally) and this one, getLocationExt.
I thought about name of last one. "getLocationForOffset", "getExtendedLocation", "getLocationHint". "getLocation" just was not ideal naming for me, because it did not reveal this function used for note/hint to provide additional info uncovered by getLocationBase.
Now I do not have "getLocationBase", but that does not mean purpose of "getLocationExt" changed, it still returns something more than a regular location.

ELF/SymbolTable.cpp

374–378

Done. I feel my way was a bit more readable though.

378

Done.

ELF/Target.cpp

58

Done. But I do not understand why. New code looks a bit bulky and overduplicated after doing that change.

64

So patch for this was D27973. I replaced calls with error() instead of fatal() here assuming it be landed first.

But please look at EhReader::failOn(). I still have to call fatal() there.
I think I can prepare a patch to avoid fatal() in EhReader, what do you think ?

[silvas]

ELF/SymbolTable.cpp

376

If we are emitting an error that needs to be followed by a note, they should follow each other. So they both need to be printed while holding the diagnostic mutex. We cannot release the mutex in between or else the notes could get interleaved with other diagnostics.

This issue I think existed before this patch, so we can probably not worry about it during this patch. But it can lead to a poor user experience (avoiding interleaved diagnostics is a main benefit of Ninja over make, so users seem to care about this feature).

I don't think this particular code path is called in a multithreaded context, but it is something to think about.

It is easy to end up with a very complex design for this, but the simplest one I can think of is just to have a single diagnose function for recoverable errors. Then instead of:

error("foo");
note("bar");

We instead have:

diagnose({
  Error("foo"),
  Note("bar")
});

or maybe

diagnose({
  {ERROR, "foo"},
  {NOTE, "bar"}
});

(diagnose would take a std::vector<std::pair<ErrorKind, const Twine &>> or something like that.

For simple cases, we would still use the error function (it can just forward to diagnose).

Alternatively, the error function can have a second argument which is a list of notes to emit with the error -- this would work unless we ever want to emit a note by itself (I don't think we ever want to do that though).

[grimar]

ELF/SymbolTable.cpp

376

Good point.

I would simplify diagnose() just to take std::vector<const Twine &> then. I believe we can always assume first Twine is a error and next are notes. There probably should not be 2 different errors for single place anyways, so I would not expect to have troubles because of reordering output messages here with such approach.

I can prepare such patch if this one be landed, I think it worth to do that after we'll have notes feature.

[ruiu]

ELF/SymbolTable.cpp

376

I think I don't like that interface because it seems much more involved than the current dead-simple warn/error/fatal functions. If you define diagnose(), we should remove warn/error/fatal because they are now duplicates, but I think we don't want to write something like diagnose({ERROR, "cannot open file"}). It seems unnecessarily complicated than error("cannot open file").

What we want to do here is essentially printing out multi-line error message, right? Why don't you pass multiple lines as one string? Error messages can contain newlines.

[silvas]

ELF/SymbolTable.cpp

376

If you define diagnose(), we should remove warn/error/fatal because they are now duplicates, but I think we don't want to write something like diagnose({ERROR, "cannot open file"}). It seems unnecessarily complicated than error("cannot open file").

Adding helpers to simplify / clarify common cases is a well-established software-engineering practice. For example, we have two overloads of error, one which just calls into the other.

What we want to do here is essentially printing out multi-line error message, right? Why don't you pass multiple lines as one string? Error messages can contain newlines.

The code that prints the errors/notes needs to know where an error/note starts in order to print the colored "error:" or "note:" part of the diagnostic.

[grimar]

ELF/SymbolTable.cpp

376

Adding helpers to simplify / clarify common cases is a well-established software-engineering practice.

I agree here and think that first version of that patch was much better looking because used helpers.

[ruiu]

How about this? You can change the type of the function from

void error(const Twine &Msg);

to

void error(const Twine &Msg, const Twine &Note = "");

Then you can eliminate note() function, and it will also solve the problem that you cannot call note() function after fatal().

[grimar]

• Addressed review comment.

[grimar]

In D27900#640961, @ruiu wrote:

How about this? You can change the type of the function from

void error(const Twine &Msg);

to

void error(const Twine &Msg, const Twine &Note = "");

Then you can eliminate note() function, and it will also solve the problem that you cannot call note() function after fatal().

That works good generally except one place:

template <class ELFT>
static void reportDuplicate(SymbolBody *Existing,
                            InputSectionBase<ELFT> *ErrSec,
                            typename ELFT::uint ErrOffset) {
....
  print(toString(ErrSec->getFile()) + ": duplicate symbol '" +
            toString(*Existing) + "'",
        "definition found in " + D->Section->getLocation(D->Value));
  print("'" + toString(*Existing) + "' previous definition was here: " +
            toString(D->Section->getFile()),
        "definition found in " + ErrSec->getLocation(ErrOffset));
}

Previous iteration generated error + 3 notes. Current one generates error+note, error+note.
That is not ideal as generating 2 errors instead of one does not look clean, also them may be
emited far from each other in multithreaded case.

I see next possible solutions:

1. Change signatures to something like: void error(const Twine &Msg, const std::vector<std::string> &Notes) and pass multiple notes at once. Problem is that is looks not possible to have a vector of Twines.

2. Implement error(), warn(), fatal() using variardic template for Notes argument. That way we should be able to use const Twine& arguments for notes as usual I think. Something like:

template<typename... Note>  
void error(const Twine& Msg, const Note&... args)  { ... }

3. Protect print calls in reportDuplicate() with std::lock_guard + Mu That way Mu type needs to be changed to std::recursive_mutex and exported I think.

std::lock_guard<std::reqursive_mutex> Lock(Mu);
print(toString(ErrSec->getFile()) + ": duplicate symbol '" +
          toString(*Existing) + "'",
      "definition found in " + D->Section->getLocation(D->Value));
print("'" + toString(*Existing) + "' previous definition was here: " +
          toString(D->Section->getFile()),
      "definition found in " + ErrSec->getLocation(ErrOffset));

4. Use multiline note:

       print(toString(ErrSec->getFile()) + ": duplicate symbol '" +
             toString(*Existing) + "'",
         "definition found in " + D->Section->getLocation(D->Value) + 
		 "\nprevious definition was here: " + toString(D->Section->getFile()) +
		 "\ndefinition found in " + ErrSec->getLocation(ErrOffset));

That way it will emit error + single multiline note.

[grimar]

• Changed signatures to:

void warn(const Twine &Msg, llvm::ArrayRef<std::string> Notes = {});
void error(const Twine &Msg, llvm::ArrayRef<std::string> Notes = {});
void fatal(const Twine &Msg, llvm::ArrayRef<std::string> Notes = {});

That solves the problem mentioned and provides clean output (single error + multiple notes).

[ruiu]

Generally looking good, a few minor comments.

ELF/Error.cpp

58–59

You don't need this piece of code.

ELF/InputSection.cpp

222–223

s/, if/. If/

244–249

Looks like you are changing the output format. Previously, function foo was always be enclosed with (), but now it can be returned as a bare word. Please keep the existing message style. If you need to change that, please do that in another patch.

ELF/Target.cpp

75

test/ELF/aarch64-fpic-abs16.s

4

This and in other tests, you removed source location and didn't add a check for the new note output. You want to check them.

[ruiu]

I applied this patch and found that you don't need to pass multiple "notes" to warn/error/fatal. Just one note suffices. If you want to print out a multi-line message, simply pass a string containing newlines.

[grimar]

• Addressed review comments.

ELF/Error.cpp

58–59

Yes. But now I do.

ELF/InputSection.cpp

222–223

Done.

244–249

This patch changed messages from

error: {{.*}}2.o:(.text+0x1): undefined symbol 'undef'

to

error: {{.*}}2.o: undefined symbol 'undef'
note: location is .text+0x1

and

error: undef.s:(.text+0x1): undefined symbol 'foo'

to

error: {{.*}}.o: undefined symbol 'foo'
note: location is undef.s(.text+0x1)

In that place I did not enclose " .text+0x1" with "()" when source file name is unknown intentionally,
Idea of expression enclosed is to extent primary location information, like:
primary info(secondary info).

After addressing your comment output is:

note: location is (.text+0x1)

In this case we have no source file name, so ".text + 0x1" becomes primary information and IMO does not need
enclosing in "()".

We can change or not change it separatelly, above just an explanation of why I did that initially :)

test/ELF/aarch64-fpic-abs16.s

4

Done.

[ruiu]

Your comment makes me wonder why you changed something like foo.c:35: <error message> to foo.c: <error message>\nnote: location is 35 in the first place. The former is a familiar format, no? I don't see a justification on that change.

A problem of this patch is it introduced a "note" message and change a lot of messages at the same time. You want to focus on only one thing at a time for ease of development/code review.

ELF/Error.h

28

Remove

ELF/SymbolTable.cpp

358

{} -> ""

[grimar]

• Addressed review comments.
• Updated few tests.

[grimar]

I am bit confused, I supposed patch has expected behavior now:

In D27900#644445, @ruiu wrote:

Your comment makes me wonder why you changed something like foo.c:35: <error message> to foo.c: <error message>\nnote: location is 35 in the first place. The former is a familiar format, no? I don't see a justification on that change.

Familiar for compilers, though problem is that we do not always have source file name and source line number in linker.
Actually I think I am changing:

conflict-debug.s:4: duplicate symbol 'zed'
to
{{.*}}.o: duplicate symbol 'zed'
note: definition found in conflict-debug.s:4 or note: definition found in (.text+0x0)

So error is reported for object file name, then notes are used to expand the location to source/line/section offset if available and reports it.
That is universal way as we always have object file name for 'error' and have different possible or no information to use in 'note'
That makes all error reporting to be consistent I believe. And requires introducing 'notes'

A problem of this patch is it introduced a "note" message and change a lot of messages at the same time. You want to focus on only one thing at a time for ease of development/code review.

So idea of patch not about introducing just one more reporting function, but about modifying existent error reporting to use it in a way described above. I belive this patch focuses exactly on that.

Otherwise would be unclear what to write in 'note' and why to have them ?

ELF/Error.h

28

Done.

[ruiu]

Did you actually find that the current error message format is useless in some case? In my experience, the current format works pretty well. It prints out enough information to fix an error and not too verbose. If you still want to pursue this change, please split it, so that we can discuss each change instead of as a whole.

[silvas]

In D27900#647823, @ruiu wrote:

Did you actually find that the current error message format is useless in some case? In my experience, the current format works pretty well. It prints out enough information to fix an error and not too verbose. If you still want to pursue this change, please split it, so that we can discuss each change instead of as a whole.

Yes, we can see the current behavior isn't ideal from recent bug reports:
http://bugs.llvm.org/show_bug.cgi?id=32008
http://bugs.llvm.org/show_bug.cgi?id=31901

I think we should treat .s/.c file source locations as "enhancements". At the end of the day we always need to provide completely unambiguous information about the error (object file / archive) IMO.

For example, this is useless (taken from http://bugs.llvm.org/show_bug.cgi?id=32008):

/usr/local/bin/ld.lld: error: /usr/src/lib/libutil/logout.c:46: duplicate symbol 'logout'
/usr/local/bin/ld.lld: error: /usr/src/lib/libutil/logout.c:46: previous definition was here

Even when they aren't the same path, not knowing which actual input file to the linker is still annoying:

/usr/local/bin/ld.lld: error: /usr/src/lib/libc/quad/fixunssfdi.c:52: duplicate symbol '__fixunssfdi'
/usr/local/bin/ld.lld: error: /usr/obj/ports/gcc-4.9.4/gcc-4.9.4/libgcc/libgcc2.c:1434: previous definition was here

I think the example I gave of how Clang handles diagnostics for macros is the one we want to be consistent with (from my example in https://reviews.llvm.org/D27676#622869)

foo.c:4:1: error: redefinition of 'foo'
DEFINITION_OF_FOO
^
foo.c:1:32: note: expanded from macro 'DEFINITION_OF_FOO'
#define DEFINITION_OF_FOO void foo() {}
^
foo.c:3:1: note: previous definition is here
DEFINITION_OF_FOO
^
foo.c:1:32: note: expanded from macro 'DEFINITION_OF_FOO'
#define DEFINITION_OF_FOO void foo() {}
^
1 error generated.

What LLD currently does is more like:

foo.c:1:32: error: redefinition of 'foo'
#define DEFINITION_OF_FOO void foo() {}
^
foo.c:1:32: note: previous definition is here
#define DEFINITION_OF_FOO void foo() {}
^
1 error generated.

[grimar]

In D27900#683209, @silvas wrote:

Even when they aren't the same path, not knowing which actual input file to the linker is still annoying:

/usr/local/bin/ld.lld: error: /usr/src/lib/libc/quad/fixunssfdi.c:52: duplicate symbol '__fixunssfdi'
/usr/local/bin/ld.lld: error: /usr/obj/ports/gcc-4.9.4/gcc-4.9.4/libgcc/libgcc2.c:1434: previous definition was here

I agree. Linker works with object files and not sources. Reporting errors in sources at first place is confusing IMO.

I think the example I gave of how Clang handles diagnostics for macros is the one we want to be consistent with (from my example in https://reviews.llvm.org/D27676#622869)

foo.c:4:1: error: redefinition of 'foo'
DEFINITION_OF_FOO
^
foo.c:1:32: note: expanded from macro 'DEFINITION_OF_FOO'
#define DEFINITION_OF_FOO void foo() {}
^
foo.c:3:1: note: previous definition is here
DEFINITION_OF_FOO
^
foo.c:1:32: note: expanded from macro 'DEFINITION_OF_FOO'
#define DEFINITION_OF_FOO void foo() {}
^
1 error generated.

What LLD currently does is more like:

foo.c:1:32: error: redefinition of 'foo'
#define DEFINITION_OF_FOO void foo() {}
^
foo.c:1:32: note: previous definition is here
#define DEFINITION_OF_FOO void foo() {}
^
1 error generated.

I think this patch currently implements idea of such output.
(or am I missing something ?)

[silvas]

In D27900#683228, @grimar wrote:

I think this patch currently implements idea of such output.
(or am I missing something ?)

This patch is much better, which is why I want to see it landed! By "What LLD currently does is more like:" I meant ToT (without this patch).

[jhenderson]

I quite agree with the comments by @silvas. I was trying to evaluate LLD's behaviour over the past few days, and regular saw errors with source information for objects that were never built on my machine, and so were completely meaningless. In this particular instance, it was because I was using the wrong version of an input file, but I couldn't see which file I was actually using, because I got a meaningless path in the output rather than the path to my object file.

In my opinion, all errors and warnings originating from inputs should have the form: 'error: C:\an\absolute\path\foo.o: some error' with additional information about source files in the notes that follow, which if I've understood correctly is what this patch has done, although at a glance "ELF/lto/combined-lto-object-name.ll" looks like it's the wrong way around (but I think that's just because of use of LTO...).

One comment about the code that I haven't put inline because the inline comments in Phabricator look like they may have moved around a bit, so I'm not sure where to put it - I agree that there is an awful lot of duplication in the error calling in Target.cpp, and I personally feel like a helper function would be completely appropriate in this instance. By my count there are 12 different calls to getErrorLocation followed immediately by a call to error(), with the only difference between them being the exact message in the error.

ELF/InputSection.h

144–146

Nit: Not sure if the comment needs to change, but it should start "Returns detailed information", without the "a"

test/ELF/libsearch.s

25

Should this have a check for "note: location is (.bar+0x0)" or similar?

test/ELF/unresolved-symbols.s

24

This check looks like it could easily start passing spuriously due to other error output, since it is only checking a single character. Could we at least check for "note: {{.*}} f" or equivalent for whatever the text is?

[grimar]

• Addressed review comments.

[grimar]

ELF/InputSection.h

144–146

Fixed.

test/ELF/libsearch.s

25

Yes, fixed.

test/ELF/unresolved-symbols.s

24

I think "f" here probably was either mistype or a placeholder to trigger testcase fail to get the proper line, which passed by mistake and was forgotten.
Fixed.

[ruiu]

I don't understand why need "note:" labels in so many places. Why don't you just make error messages multi-line? I don't think there's no such rule that you need to put "note:" after every "\n".

In addition to that, calling error() more than once for one error is not good. That function should be called exactly once for one error.

[ruiu]

Why it took so much time to land this patch is because it started as a patch in the first place. George, if you want to change the error message format, you should have started it as an RFC, rather than an actual code change. Discussing based on diffs of actual code and test cases is not the best way for both you as a person to propose something new and others who tries to understand what you are trying to do from diffs.

[grimar]

In D27900#683999, @ruiu wrote:

In addition to that, calling error() more than once for one error is not good. That function should be called exactly once for one error.

Does this patch do that ? Where ?

[ruiu]

Quote from the patch comment:

Example of new output:
error: file-dbg2.o: duplicate symbol 'zed'
error: file-dbg2.a(file-dbg2.o): previous definition was here
note: definitions found in conflict-debug.s(.text+0x0) and conflict-debug.s(.text+0x0)

[grimar]

In D27900#684014, @ruiu wrote:

Quote from the patch comment:

Example of new output:
error: file-dbg2.o: duplicate symbol 'zed'
error: file-dbg2.a(file-dbg2.o): previous definition was here
note: definitions found in conflict-debug.s(.text+0x0) and conflict-debug.s(.text+0x0)

It was really outdated. Patch does not do that atm. Updated the comment.

[silvas]

In D27900#683999, @ruiu wrote:

I don't understand why need "note:" labels in so many places. Why don't you just make error messages multi-line? I don't think there's no such rule that you need to put "note:" after every "\n".

Off the top of my head:

1. the "note" is colored and is visually distinctive (consider if the message contains a very long file path, and the user is in a narrow terminal so that lines are wrapped; colored "note:" and "error:" are then a visual guide).

2. Doing it this way is highly structured. If a message contains a location (input object, or source location), it always is the first thing following a "note:" or "error:". This keeps it consistent and unambiguous. Users always know where to look for locations. Again, file paths should be assumed to be quite long and so text containing something like conflict in /some/long/path/foo.o and /some/long/path/bar.o gets hard to parse (have to scan for "and", possibly through line wrapping done by the terminal)

In addition to that, calling error() more than once for one error is not good. That function should be called exactly once for one error.

In D27900#684000, @ruiu wrote:

Why it took so much time to land this patch is because it started as a patch in the first place. George, if you want to change the error message format, you should have started it as an RFC, rather than an actual code change. Discussing based on diffs of actual code and test cases is not the best way for both you as a person to propose something new and others who tries to understand what you are trying to do from diffs.

I agree. We should have a focused discussion for what our "duplicate symbol" error message should look like. The actual code changes are not very complicated compared to the discussion of what we want the end user to see.

[• rafael]

I quite like this. The summary as I see so far

• Always reporting the .o file is a big improvement, since we might not have the source file.
• Always reporting the .a file is also important.
• Having a note be different from the error is nice in that it can be colored differently.

Rui, do you have any objections?

[ruiu]

I sent a proposal to llvm-dev. Please search for "[RFC] better link error messages". Let's discuss there.

ELF/EhFrame.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "EhFrame.h"
 #include "Error.h"
 #include "InputSection.h"
 #include "Relocations.h"
 #include "Strings.h"
+#include "Writer.h"
 
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::dwarf;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
 template <class ELFT> class EhReader {
 public:
   EhReader(InputSectionBase<ELFT> *S, ArrayRef<uint8_t> D) : IS(S), D(D) {}
   size_t readEhRecordSize();
   uint8_t getFdeEncoding();
 
 private:
   template <class P> void failOn(const P *Loc, const Twine &Msg) {
-    fatal(IS->getLocation((const uint8_t *)Loc - IS->Data.data()) + ": " + Msg);
+    errorAtOffset(*IS, ": " + Msg, (const uint8_t *)Loc - IS->Data.data());
+    fatal("fatal error encountered");
   }
 
   uint8_t readByte();
   void skipBytes(size_t Count);
   StringRef readString();
   void skipLeb128();
   void skipAugP();
 

ELF/Error.h

 // Warn doesn't do anything but printing out a given message.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_ERROR_H
 #define LLD_ELF_ERROR_H
 
 #include "lld/Core/LLVM.h"
 
 #include "llvm/Support/Error.h"
 
 namespace lld {
 namespace elf {
 
 extern uint64_t ErrorCount;
 extern llvm::raw_ostream *ErrorOS;
 extern llvm::StringRef Argv0;
 
 void log(const Twine &Msg);
 void warn(const Twine &Msg);
 
+void hint(const Twine &Msg);
+
 void error(const Twine &Msg);
 void error(std::error_code EC, const Twine &Prefix);
 
 LLVM_ATTRIBUTE_NORETURN void exitLld(int Val);
 LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void fatal(std::error_code EC, const Twine &Prefix);
 
 // check() functions are convenient functions to strip errors

ELF/Error.cpp

if (Config->Verbose)
     outs() << Argv0 << ": " << Msg << "\n";
 }
 
 void elf::warn(const Twine &Msg) {
   if (Config->FatalWarnings) {
     error(Msg);
     return;
   }
   std::lock_guard<std::mutex> Lock(Mu);
   print("warning: ", raw_ostream::MAGENTA);
   *ErrorOS << Msg << "\n";
 }
 
 void elf::error(const Twine &Msg) {
   std::lock_guard<std::mutex> Lock(Mu);
 
   if (Config->ErrorLimit == 0 || ErrorCount < Config->ErrorLimit) {
     print("error: ", raw_ostream::RED);
     *ErrorOS << Msg << "\n";
   } else if (ErrorCount == Config->ErrorLimit) {
     print("error: ", raw_ostream::RED);
     *ErrorOS << "too many errors emitted, stopping now"
              << " (use -error-limit=0 to see all errors)\n";
     if (Config->ExitEarly)
       exitLld(1);
   }
 
   ++ErrorCount;
 }
 
 void elf::error(std::error_code EC, const Twine &Prefix) {
   error(Prefix + ": " + EC.message());
 }
 
+void elf::hint(const Twine &Msg) {
+  std::lock_guard<std::mutex> Lock(Mu);
+  print("note: ", raw_ostream::RED);
+  *ErrorOS << Msg << "\n";
+}
+
 void elf::exitLld(int Val) {
   // Dealloc/destroy ManagedStatic variables before calling
   // _exit(). In a non-LTO build, this is a nop. In an LTO
   // build allows us to get the output of -time-passes.
   llvm_shutdown();
 
   outs().flush();
   errs().flush();

ELF/InputFiles.h

public:
   template <typename RelT>
   SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }
 
   // Returns source line information for a given offset.
   // If no information is available, returns "".
-  std::string getLineInfo(InputSectionBase<ELFT> *S, uintX_t Offset);
+  std::string getLineInfo(const InputSectionBase<ELFT> *S, uintX_t Offset);
 
   // MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
   uint32_t MipsGp0 = 0;
 
   // The number is the offset in the string table. It will be used as the
   // st_name of the symbol.

ELF/InputFiles.cpp

template <class ELFT> void elf::ObjectFile<ELFT>::initializeDwarfLine() {
   // for compilation unit (CU) of interest. We have only one
   // CU (object file), so offset is always 0.
   DwarfLine->getOrParseLineTable(LineData, 0);
 }
 
 // Returns source line information for a given offset
 // using DWARF debug info.
 template <class ELFT>
-std::string elf::ObjectFile<ELFT>::getLineInfo(InputSectionBase<ELFT> *S,
+std::string elf::ObjectFile<ELFT>::getLineInfo(const InputSectionBase<ELFT> *S,
                                                uintX_t Offset) {
   if (!DwarfLine)
     initializeDwarfLine();
 
   // The offset to CU is 0.
   const DWARFDebugLine::LineTable *Tbl = DwarfLine->getLineTable(0);
   if (!Tbl)
     return "";

ELF/InputSection.h

public:
   uintX_t getOffset(const DefinedRegular<ELFT> &Sym) const;
   InputSectionBase *getLinkOrderDep() const;
   // Translate an offset in the input section to an offset in the output
   // section.
   uintX_t getOffset(uintX_t Offset) const;
 
   void uncompress();
 
-  // Returns a source location string. Used to construct an error message.
-  std::string getLocation(uintX_t Offset);
+  // Returns a extended information about source location. Used to construct an
+  // error message.
+  std::string getLocationExt(uintX_t Offset) const;
 
   void relocate(uint8_t *Buf, uint8_t *BufEnd);
 
 private:
   std::pair<ArrayRef<uint8_t>, uint64_t>
   getElfCompressedData(ArrayRef<uint8_t> Data);
 
   std::pair<ArrayRef<uint8_t>, uint64_t>
private:
 
   llvm::TinyPtrVector<const Thunk<ELFT> *> Thunks;
 };
 
 template <class ELFT> InputSection<ELFT> InputSection<ELFT>::Discarded;
 
 template <class ELFT> std::string toString(const InputSectionBase<ELFT> *);
 
+template <class ELFT>
+void errorAtOffset(const InputSectionBase<ELFT> &, const llvm::Twine &,
+                   typename ELFT::uint);
+
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

 
 // Returns a string to construct an error message.
 template <class ELFT>
 std::string elf::toString(const InputSectionBase<ELFT> *Sec) {
   return (Sec->getFile()->getName() + ":(" + Sec->Name + ")").str();
 }
 
 template <class ELFT>
+void elf::errorAtOffset(const InputSectionBase<ELFT> &IS,
+                        const llvm::Twine &Msg, typename ELFT::uint Off) {
+  error(toString(IS.getFile()) + Msg);
+  hint("location is " + IS.getLocationExt(Off));
+}
+
+template <class ELFT>
 static ArrayRef<uint8_t> getSectionContents(elf::ObjectFile<ELFT> *File,
                                             const typename ELFT::Shdr *Hdr) {
   if (!File || Hdr->sh_type == SHT_NOBITS)
     return makeArrayRef<uint8_t>(nullptr, Hdr->sh_size);
   return check(File->getObj().getSectionContents(Hdr));
 }
 
 // ELF supports ZLIB-compressed section. Returns true if the section

 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSectionBase<ELFT>::getLinkOrderDep() const {
   if ((Flags & SHF_LINK_ORDER) && Link != 0)
     return getFile()->getSections()[Link];
   return nullptr;
 }
 
-// Returns a source location string. Used to construct an error message.
+// Find a function symbol that encloses a given location, if there's no symbol,
+// returns the offset in the section.
 template <class ELFT>
-std::string InputSectionBase<ELFT>::getLocation(typename ELFT::uint Offset) {
+static std::string getExtendedName(const InputSectionBase<ELFT> *IS,
+                                   typename ELFT::uint Offset) {
+  for (SymbolBody *B : IS->getFile()->getSymbols())
+    if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
+      if (D->Section == IS && D->Type == STT_FUNC)
+        if (D->Value <= Offset && Offset < D->Value + D->Size)
+          return "function " + toString(*D);
+  return (IS->Name + "+0x" + utohexstr(Offset)).str();
+}
+
+template <class ELFT>
+std::string
+InputSectionBase<ELFT>::getLocationExt(typename ELFT::uint Offset) const {
   // First check if we can get desired values from debugging information.
   std::string LineInfo = File->getLineInfo(this, Offset);
   if (!LineInfo.empty())
     return LineInfo;
 
   // File->SourceFile contains STT_FILE symbol that contains a
-  // source file name. If it's missing, we use an object file name.
-  std::string SrcFile = File->SourceFile;
-  if (SrcFile.empty())
-    SrcFile = toString(File);
-
-  // Find a function symbol that encloses a given location.
-  for (SymbolBody *B : File->getSymbols())
-    if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
-      if (D->Section == this && D->Type == STT_FUNC)
-        if (D->Value <= Offset && Offset < D->Value + D->Size)
-          return SrcFile + ":(function " + toString(*D) + ")";
-
-  // If there's no symbol, print out the offset in the section.
-  return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
+  // source file name. If we have it, we use it in the output.
+  std::string FuncName = getExtendedName(this, Offset);
+  if (File->SourceFile.empty())
+    return FuncName;
+  return (File->SourceFile + "(" + FuncName + ")").str();
 }
 
 template <class ELFT>
 InputSection<ELFT>::InputSection() : InputSectionBase<ELFT>() {}
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(uintX_t Flags, uint32_t Type,
                                  uintX_t Addralign, ArrayRef<uint8_t> Data,
                                  StringRef Name, Kind K)
for (const RelTy &Rel : Rels) {
     uintX_t Offset = this->getOffset(Rel.r_offset);
     uint8_t *BufLoc = Buf + Offset;
     uintX_t Addend = getAddend<ELFT>(Rel);
     if (!RelTy::IsRela)
       Addend += Target->getImplicitAddend(BufLoc, Type);
 
     SymbolBody &Sym = this->File->getRelocTargetSym(Rel);
     if (Target->getRelExpr(Type, Sym) != R_ABS) {
-      error(this->getLocation(Offset) + ": has non-ABS reloc");
+      errorAtOffset(*this, ": has non-ABS reloc", Offset);
       return;
     }
 
     uintX_t AddrLoc = this->OutSec->Addr + Offset;
     uint64_t SymVA = 0;
     if (!Sym.isTls() || Out<ELFT>::TlsPhdr)
       SymVA = SignExtend64<sizeof(uintX_t) * 8>(
           getRelocTargetVA<ELFT>(Type, Addend, AddrLoc, Sym, R_ABS));

 template class elf::MergeInputSection<ELF32BE>;
 template class elf::MergeInputSection<ELF64LE>;
 template class elf::MergeInputSection<ELF64BE>;
 
 template std::string elf::toString(const InputSectionBase<ELF32LE> *);
 template std::string elf::toString(const InputSectionBase<ELF32BE> *);
 template std::string elf::toString(const InputSectionBase<ELF64LE> *);
 template std::string elf::toString(const InputSectionBase<ELF64BE> *);
+
+template void elf::errorAtOffset(const InputSectionBase<ELF32LE> &,
+                                 const llvm::Twine &, ELF32LE::uint);
+template void elf::errorAtOffset(const InputSectionBase<ELF32BE> &,
+                                 const llvm::Twine &, ELF32BE::uint);
+template void elf::errorAtOffset(const InputSectionBase<ELF64LE> &,
+                                 const llvm::Twine &, ELF64LE::uint);
+template void elf::errorAtOffset(const InputSectionBase<ELF64BE> &,
+                                 const llvm::Twine &, ELF64BE::uint);

ELF/Relocations.cpp

static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
   // Another special case is MIPS _gp_disp symbol which represents offset
   // between start of a function and '_gp' value and defined as absolute just
   // to simplify the code.
   if (AbsVal && RelE) {
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
       return true;
     if (&Body == ElfSym<ELFT>::MipsGpDisp)
       return true;
-    error(S.getLocation(RelOff) + ": relocation " + toString(Type) +
+    errorAtOffset(S, ": relocation " + toString(Type) +
                          " cannot refer to absolute symbol '" + toString(Body) +
-          "' defined in " + toString(Body.File));
+                         "' defined in " + toString(Body.File),
+                  RelOff);
     return true;
   }
 
   return Target->usesOnlyLowPageBits(Type);
 }
 
 static RelExpr toPlt(RelExpr Expr) {
   if (Expr == R_PPC_OPD)
static RelExpr adjustExpr(const elf::ObjectFile<ELFT> &File, SymbolBody &Body,
 
   if (IsWrite || isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, S, RelOff))
     return Expr;
 
   // This relocation would require the dynamic linker to write a value to read
   // only memory. We can hack around it if we are producing an executable and
   // the refered symbol can be preemepted to refer to the executable.
   if (Config->Shared || (Config->Pic && !isRelExpr(Expr))) {
-    error(S.getLocation(RelOff) + ": can't create dynamic relocation " +
-          toString(Type) + " against " +
+    errorAtOffset(
+        S, ": can't create dynamic relocation " + toString(Type) + " against " +
                (Body.getName().empty() ? "local symbol in readonly segment"
                                        : "symbol '" + toString(Body) + "'") +
-          " defined in " + toString(Body.File));
+               " defined in " + toString(Body.File),
+        RelOff);
     return Expr;
   }
   if (Body.getVisibility() != STV_DEFAULT) {
-    error(S.getLocation(RelOff) + ": cannot preempt symbol '" + toString(Body) +
-          "' defined in " + toString(Body.File));
+    errorAtOffset(S, ": cannot preempt symbol '" + toString(Body) +
+                         "' defined in " + toString(Body.File),
+                  RelOff);
     return Expr;
   }
   if (Body.isObject()) {
     // Produce a copy relocation.
     auto *B = cast<SharedSymbol<ELFT>>(&Body);
     if (!B->needsCopy())
       addCopyRelSymbol(B);
     return Expr;
static void reportUndefined(SymbolBody &Sym, InputSectionBase<ELFT> &S,
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
     return;
 
   if (Config->Shared && Sym.symbol()->Visibility == STV_DEFAULT &&
       Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
     return;
 
   std::string Msg =
-      S.getLocation(Offset) + ": undefined symbol '" + toString(Sym) + "'";
+      toString(S.getFile()) + ": undefined symbol '" + toString(Sym) + "'";
 
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
     warn(Msg);
   else
     error(Msg);
+  hint("location is " + S.getLocationExt(Offset));
 }
 
 template <class RelTy>
 static std::pair<uint32_t, uint32_t>
 mergeMipsN32RelTypes(uint32_t Type, uint32_t Offset, RelTy *I, RelTy *E) {
   // MIPS N32 ABI treats series of successive relocations with the same offset
   // as a single relocation. The similar approach used by N64 ABI, but this ABI
   // packs all relocations into the single relocation record. Here we emulate
if (needsPlt(Expr) ||
       // when outputting this section. We also have to do it if the format
       // uses Elf_Rel, since in that case the written value is the addend.
       if (Constant || !RelTy::IsRela)
         C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     } else {
       // We don't know anything about the finaly symbol. Just ask the dynamic
       // linker to handle the relocation for us.
       if (!Target->isPicRel(Type))
-        error(C.getLocation(Offset) + ": relocation " + toString(Type) +
-              " cannot be used against shared object; recompile with -fPIC.");
+        errorAtOffset(
+            C,
+            ": relocation " + toString(Type) +
+                " cannot be used against shared object; recompile with -fPIC.",
+            Offset);
       AddDyn({Target->getDynRel(Type), &C, Offset, false, &Body, Addend});
 
       // MIPS ABI turns using of GOT and dynamic relocations inside out.
       // While regular ABI uses dynamic relocations to fill up GOT entries
       // MIPS ABI requires dynamic linker to fills up GOT entries using
       // specially sorted dynamic symbol table. This affects even dynamic
       // relocations against symbols which do not require GOT entries
       // creation explicitly, i.e. do not have any GOT-relocations. So if

ELF/SymbolTable.cpp

 static void print(const Twine &Msg) {
   if (Config->AllowMultipleDefinition)
     warn(Msg);
   else
     error(Msg);
 }
 
 static void reportDuplicate(SymbolBody *Existing, InputFile *NewFile) {
   print("duplicate symbol " + conflictMsg(Existing, NewFile));
 }
 
 template <class ELFT>
 static void reportDuplicate(SymbolBody *Existing,
                             InputSectionBase<ELFT> *ErrSec,
                             typename ELFT::uint ErrOffset) {
   DefinedRegular<ELFT> *D = dyn_cast<DefinedRegular<ELFT>>(Existing);
   if (!D || !D->Section || !ErrSec) {
     reportDuplicate(Existing, ErrSec ? ErrSec->getFile() : nullptr);
     return;
   }
 
-  std::string OldLoc = D->Section->getLocation(D->Value);
-  std::string NewLoc = ErrSec->getLocation(ErrOffset);
-
+  std::string OldLoc = toString(D->Section->getFile());
+  std::string NewLoc = toString(ErrSec->getFile());
   print(NewLoc + ": duplicate symbol '" + toString(*Existing) + "'");
   print(OldLoc + ": previous definition was here");
+
+  std::string OldLocHint = D->Section->getLocationExt(D->Value);
+  std::string NewLocHint = ErrSec->getLocationExt(ErrOffset);
+  hint("definitions found in " + OldLocHint + " and " + NewLocHint);
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
                                       uint8_t Type, uintX_t Value, uintX_t Size,
                                       uint8_t Binding,
                                       InputSectionBase<ELFT> *Section,
                                       InputFile *File) {

ELF/Target.cpp

 
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 static void or32be(uint8_t *P, int32_t V) { write32be(P, read32be(P) | V); }
 
 std::string toString(uint32_t Type) {
   return getELFRelocationTypeName(Config->EMachine, Type);
 }
 
+static void errorAtLocation(const uint8_t *Loc, const llvm::Twine &E) {
+  std::pair<std::string, std::string> Msg = getErrorLocation(Loc);
+  error(Msg.first + ": " + E);
+  hint("location is " + Msg.second);
+}
+
+static void fatalAtLocation(const uint8_t *Loc, const llvm::Twine &E) {
+  errorAtLocation(Loc, E);
+  fatal("fatal error encountered");
+}
+
 template <unsigned N>
 static void checkInt(uint8_t *Loc, int64_t V, uint32_t Type) {
   if (!isInt<N>(V))
-    error(getErrorLocation(Loc) + "relocation " + toString(Type) +
-          " out of range");
+    errorAtLocation(Loc, "relocation " + toString(Type) + " out of range");
 }
 
 template <unsigned N>
 static void checkUInt(uint8_t *Loc, uint64_t V, uint32_t Type) {
   if (!isUInt<N>(V))
-    error(getErrorLocation(Loc) + "relocation " + toString(Type) +
-          " out of range");
+    errorAtLocation(Loc, "relocation " + toString(Type) + " out of range");
 }
 
 template <unsigned N>
 static void checkIntUInt(uint8_t *Loc, uint64_t V, uint32_t Type) {
   if (!isInt<N>(V) && !isUInt<N>(V))
-    error(getErrorLocation(Loc) + "relocation " + toString(Type) +
-          " out of range");
+    errorAtLocation(Loc, "relocation " + toString(Type) + " out of range");
 }
 
 template <unsigned N>
 static void checkAlignment(uint8_t *Loc, uint64_t V, uint32_t Type) {
   if ((V & (N - 1)) != 0)
-    error(getErrorLocation(Loc) + "improper alignment for relocation " +
-          toString(Type));
+    errorAtLocation(Loc, "improper alignment for relocation " + toString(Type));
 }
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
if (memcmp(Inst, "\x48\x03\x25", 3) == 0) {
     // "movq foo@gottpoff(%rip),%r[8-15]" -> "movq $foo,%r[8-15]"
     memcpy(Inst, "\x49\xc7", 2);
     *RegSlot = 0xc0 | Reg;
   } else if (memcmp(Inst, "\x48\x8b", 2) == 0) {
     // "movq foo@gottpoff(%rip),%reg" -> "movq $foo,%reg"
     memcpy(Inst, "\x48\xc7", 2);
     *RegSlot = 0xc0 | Reg;
   } else {
-    fatal(getErrorLocation(Loc - 3) +
-          "R_X86_64_GOTTPOFF must be used in MOVQ or ADDQ instructions only");
+    fatalAtLocation(
+        Loc - 3,
   }
 
   // The original code used a PC relative relocation.
   // Need to compensate for the -4 it had in the addend.
   relocateOne(Loc, R_X86_64_TPOFF32, Val + 4);
 }
 
 template <class ELFT>
void X86_64TargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_X86_64_DTPOFF64:
   case R_X86_64_GLOB_DAT:
   case R_X86_64_PC64:
   case R_X86_64_SIZE64:
   case R_X86_64_GOT64:
     write64le(Loc, Val);
     break;
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
 RelExpr X86_64TargetInfo<ELFT>::adjustRelaxExpr(uint32_t Type,
                                                 const uint8_t *Data,
                                                 RelExpr RelExpr) const {
   if (Type != R_X86_64_GOTPCRELX && Type != R_X86_64_REX_GOTPCRELX)
void PPCTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_PPC_ADDR32:
   case R_PPC_REL32:
     write32be(Loc, Val);
     break;
   case R_PPC_REL24:
     or32be(Loc, Val & 0x3FFFFFC);
     break;
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 RelExpr PPCTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
   case R_PPC_REL24:
   case R_PPC_REL32:
     return R_PC;
case R_PPC64_TOC:
     break;
   case R_PPC64_REL24: {
     uint32_t Mask = 0x03FFFFFC;
     checkInt<24>(Loc, Val, Type);
     write32be(Loc, (read32be(Loc) & ~Mask) | (Val & Mask));
     break;
   }
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
   CopyRel = R_AARCH64_COPY;
   RelativeRel = R_AARCH64_RELATIVE;
   IRelativeRel = R_AARCH64_IRELATIVE;
   GotRel = R_AARCH64_GLOB_DAT;
case R_AARCH64_TLSLE_ADD_TPREL_HI12:
     checkInt<24>(Loc, Val, Type);
     or32AArch64Imm(Loc, Val >> 12);
     break;
   case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
   case R_AARCH64_TLSDESC_ADD_LO12_NC:
     or32AArch64Imm(Loc, Val);
     break;
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 void AArch64TargetInfo::relaxTlsGdToLe(uint8_t *Loc, uint32_t Type,
                                        uint64_t Val) const {
   // TLSDESC Global-Dynamic relocation are in the form:
   //   adrp    x0, :tlsdesc:v             [R_AARCH64_TLSDESC_ADR_PAGE21]
   //   ldr     x1, [x0, #:tlsdesc_lo12:v  [R_AARCH64_TLSDESC_LD64_LO12_NC]
void AMDGPUTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_AMDGPU_ABS64:
     write64le(Loc, Val);
     break;
   case R_AMDGPU_GOTPCREL32_HI:
   case R_AMDGPU_REL32_HI:
     write32le(Loc, Val >> 32);
     break;
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 RelExpr AMDGPUTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
   case R_AMDGPU_ABS32:
   case R_AMDGPU_ABS64:
     return R_ABS;
write16le(Loc,
                   ((Val >> 1) & 0x0400) |  // i
                   ((Val >> 12) & 0x000f)); // imm4
     write16le(Loc + 2,
               (read16le(Loc + 2) & 0x8f00) | // opcode
                   ((Val << 4) & 0x7000) |    // imm3
                   (Val & 0x00ff));           // imm8
     break;
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 uint64_t ARMTargetInfo::getImplicitAddend(const uint8_t *Buf,
                                           uint32_t Type) const {
   switch (Type) {
   default:
     return 0;
calculateMipsRelChain(uint8_t *Loc, uint32_t Type, uint64_t Val) {
   uint32_t Type2 = (Type >> 8) & 0xff;
   uint32_t Type3 = (Type >> 16) & 0xff;
   if (Type2 == R_MIPS_NONE && Type3 == R_MIPS_NONE)
     return std::make_pair(Type, Val);
   if (Type2 == R_MIPS_64 && Type3 == R_MIPS_NONE)
     return std::make_pair(Type2, Val);
   if (Type2 == R_MIPS_SUB && (Type3 == R_MIPS_HI16 || Type3 == R_MIPS_LO16))
     return std::make_pair(Type3, -Val);
-  error(getErrorLocation(Loc) + "unsupported relocations combination " +
-        Twine(Type));
+  errorAtLocation(Loc, "unsupported relocations combination " + Twine(Type));
   return std::make_pair(Type & 0xff, Val);
 }
 
 template <class ELFT>
 void MipsTargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint32_t Type,
                                        uint64_t Val) const {
   const endianness E = ELFT::TargetEndianness;
   // Thread pointer and DRP offsets from the start of TLS data area.
case R_MIPS_PC21_S2:
     break;
   case R_MIPS_PC26_S2:
     applyMipsPcReloc<E, 26, 2>(Loc, Type, Val);
     break;
   case R_MIPS_PC32:
     applyMipsPcReloc<E, 32, 0>(Loc, Type, Val);
     break;
   default:
-    fatal(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    fatalAtLocation(Loc, "unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::usesOnlyLowPageBits(uint32_t Type) const {
   return Type == R_MIPS_LO16 || Type == R_MIPS_GOT_OFST;
 }
 }
 }

ELF/Writer.h

 template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
-std::string getErrorLocation(uint8_t *Loc);
+
+std::pair<std::string, std::string> getErrorLocation(const uint8_t *Loc);
 }
 }
 
 #endif

ELF/Writer.cpp

if (!In<ELFT>::BuildId || !In<ELFT>::BuildId->OutSec)
     return;
 
   // Compute a hash of all sections of the output file.
   uint8_t *Start = Buffer->getBufferStart();
   uint8_t *End = Start + FileSize;
   In<ELFT>::BuildId->writeBuildId({Start, End});
 }
 
-template <class ELFT> static std::string getErrorLoc(uint8_t *Loc) {
+template <class ELFT>
+static std::pair<std::string, std::string> getErrorLoc(const uint8_t *Loc) {
   for (InputSectionData *D : Symtab<ELFT>::X->Sections) {
     auto *IS = dyn_cast_or_null<InputSection<ELFT>>(D);
     if (!IS || !IS->OutSec)
       continue;
 
     uint8_t *ISLoc = cast<OutputSection<ELFT>>(IS->OutSec)->Loc + IS->OutSecOff;
     if (ISLoc <= Loc && ISLoc + IS->getSize() > Loc)
-      return IS->getLocation(Loc - ISLoc) + ": ";
+      return {toString(IS->getFile()), IS->getLocationExt(Loc - ISLoc)};
   }
-  return "";
+  return {};
 }
 
-std::string elf::getErrorLocation(uint8_t *Loc) {
+std::pair<std::string, std::string> elf::getErrorLocation(const uint8_t *Loc) {
   switch (Config->EKind) {
   case ELF32LEKind:
     return getErrorLoc<ELF32LE>(Loc);
   case ELF32BEKind:
     return getErrorLoc<ELF32BE>(Loc);
   case ELF64LEKind:
     return getErrorLoc<ELF64LE>(Loc);
   case ELF64BEKind:

test/ELF/Inputs/conflict-debug2.s

+.file "conflict-debug.s"
+.globl zed
+zed:
+  nop

test/ELF/aarch64-fpic-abs16.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}:(.data+0x0): relocation R_AARCH64_ABS16 cannot be used against shared object; recompile with -fPIC.
-
+// CHECK: {{.*}}: relocation R_AARCH64_ABS16 cannot be used against shared object; recompile with -fPIC.
 .data
   .hword foo

test/ELF/aarch64-fpic-add_abs_lo12_nc.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_AARCH64_ADD_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
-
+// CHECK: {{.*}}.o: can't create dynamic relocation R_AARCH64_ADD_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
   add x0, x0, :lo12:dat
 .data
 .globl dat
 dat:
   .word 0

test/ELF/aarch64-fpic-adr_prel_lo21.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_AARCH64_ADR_PREL_LO21 against symbol 'dat' defined in {{.*}}.o
-
+// CHECK: {{.*}}.o: can't create dynamic relocation R_AARCH64_ADR_PREL_LO21 against symbol 'dat' defined in {{.*}}.o
   adr x0, dat
 .data
 .globl dat
 dat:
   .word 0

test/ELF/aarch64-fpic-adr_prel_pg_hi21.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_AARCH64_ADR_PREL_PG_HI21 against symbol 'dat' defined in {{.*}}.o
-
+// CHECK: {{.*}}.o: can't create dynamic relocation R_AARCH64_ADR_PREL_PG_HI21 against symbol 'dat' defined in {{.*}}.o
   adrp x0, dat
 .data
 .globl dat
 dat:
   .word 0

test/ELF/aarch64-fpic-ldst32_abs_lo12_nc.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_AARCH64_LDST32_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
-
+// CHECK: {{.*}}.o: can't create dynamic relocation R_AARCH64_LDST32_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
   ldr s4, [x0, :lo12:dat]
 .data
 .globl dat
 dat:
   .word 0

test/ELF/aarch64-fpic-ldst64_abs_lo12_nc.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_AARCH64_LDST64_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
-
+// CHECK: {{.*}}.o: can't create dynamic relocation R_AARCH64_LDST64_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
   ldr x0, [x0, :lo12:dat]
 .data
 .globl dat
 dat:
   .word 0

test/ELF/aarch64-fpic-ldst8_abs_lo12_nc.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_AARCH64_LDST8_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
-
+// CHECK: {{.*}}.o: can't create dynamic relocation R_AARCH64_LDST8_ABS_LO12_NC against symbol 'dat' defined in {{.*}}.o
   ldrsb x0, [x1, :lo12:dat]
 .data
 .globl dat
 dat:
   .word 0

test/ELF/aarch64-fpic-prel16.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}:(.data+0x0): relocation R_AARCH64_PREL16 cannot be used against shared object; recompile with -fPIC.
-
+// CHECK: {{.*}}.o: relocation R_AARCH64_PREL16 cannot be used against shared object; recompile with -fPIC.
 .data
   .hword foo - .

test/ELF/aarch64-fpic-prel32.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}:(.data+0x0): relocation R_AARCH64_PREL32 cannot be used against shared object; recompile with -fPIC.
-
+// CHECK: {{.*}}.o: relocation R_AARCH64_PREL32 cannot be used against shared object; recompile with -fPIC.
 .data
   .word foo - .

test/ELF/aarch64-fpic-prel64.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-// CHECK: {{.*}}:(.data+0x0): relocation R_AARCH64_PREL64 cannot be used against shared object; recompile with -fPIC.
-
+// CHECK: {{.*}}: relocation R_AARCH64_PREL64 cannot be used against shared object; recompile with -fPIC.
 .data
   .xword foo - .

test/ELF/arm-branch-error.s

 _start:
  // address of too_far symbols are just out of range of ARM branch with
  // 26-bit immediate field and an addend of -8
  bl  too_far1
  b   too_far2
  beq too_far3
 
 // CHECK: R_ARM_CALL out of range
-// CHECK-NEXT: R_ARM_JUMP24 out of range
-// CHECK-NEXT: R_ARM_JUMP24 out of range
+// CHECK: R_ARM_JUMP24 out of range
+// CHECK: R_ARM_JUMP24 out of range

test/ELF/arm-target1.s

.text
   patatino:
 
 // RELATIVE: Disassembly of section .text:
 // RELATIVE: $d.0:
 // RELATIVE:     1000:       04 00 00 00     .word   0x00000004
 // RELATIVE: SYMBOL TABLE:
 // RELATIVE: 00001004         .text           00000000 patatino
 
-// ABS: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_ARM_TARGET1 against symbol 'patatino' defined in {{.*}}.o
+// ABS: {{.*}}.o: can't create dynamic relocation R_ARM_TARGET1 against symbol 'patatino' defined in {{.*}}.o

test/ELF/arm-thumb-branch-error.s

 _start:
  // address of too_far symbols are just out of range of ARM branch with
  // 26-bit immediate field and an addend of -8
  bl  too_far1
  b   too_far2
  beq.w too_far3
 
 // CHECK: R_ARM_THM_CALL out of range
-// CHECK-NEXT: R_ARM_THM_JUMP24 out of range
-// CHECK-NEXT: R_ARM_THM_JUMP19 out of range
+// CHECK: R_ARM_THM_JUMP24 out of range
+// CHECK: R_ARM_THM_JUMP19 out of range

test/ELF/basic.s

 # RUN: not ld.lld %t -o 2>&1 | FileCheck --check-prefix=NO_O_VAL %s
 # NO_O_VAL: -o: missing argument
 
 # RUN: not ld.lld --foo 2>&1 | FileCheck --check-prefix=UNKNOWN %s
 # UNKNOWN: unknown argument: --foo
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t %t -o %t2 2>&1 | FileCheck --check-prefix=DUP %s
-# DUP: {{.*}}:(.text+0x0): duplicate symbol '_start'
-# DUP: {{.*}}:(.text+0x0): previous definition was here
+# DUP: {{.*}}: duplicate symbol '_start'
+# DUP: {{.*}}: previous definition was here
+# DUP: note: definitions found in .text+0x0 and .text+0x0
 
 # RUN: not ld.lld %t -o %t -m wrong_emul_fbsd 2>&1 | FileCheck --check-prefix=UNKNOWN_EMUL %s
 # UNKNOWN_EMUL: unknown emulation: wrong_emul_fbsd
 
 # RUN: not ld.lld %t --lto-partitions=0 2>&1 | FileCheck --check-prefix=NOTHREADS %s
 # NOTHREADS: --lto-partitions: number of threads must be > 0
 
 # RUN: not ld.lld %t --thinlto-jobs=0 2>&1 | FileCheck --check-prefix=NOTHREADSTHIN %s
 # NOTHREADSTHIN: --thinlto-jobs: number of threads must be > 0

test/ELF/conflict.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: not ld.lld %t1.o %t1.o -o %t2 2>&1 | FileCheck -check-prefix=DEMANGLE %s
 
-# DEMANGLE:       {{.*}}:(.text+0x0): duplicate symbol 'mul(double, double)'
-# DEMANGLE-NEXT:  {{.*}}:(.text+0x0): previous definition was here
-# DEMANGLE-NEXT:  {{.*}}:(.text+0x0): duplicate symbol 'foo'
-# DEMANGLE-NEXT:  {{.*}}:(.text+0x0): previous definition was here
+# DEMANGLE:       {{.*}}: duplicate symbol 'mul(double, double)'
+# DEMANGLE-NEXT:  {{.*}}: previous definition was here
+# DEMANGLE-NEXT: note: definitions found in .text+0x0 and .text+0x0
+# DEMANGLE-NEXT:  {{.*}}: duplicate symbol 'foo'
+# DEMANGLE-NEXT:  {{.*}}: previous definition was here
+# DEMANGLE-NEXT: note: definitions found in .text+0x0 and .text+0x0
 
 # RUN: not ld.lld %t1.o %t1.o -o %t2 --no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO_DEMANGLE %s
 
-# NO_DEMANGLE: {{.*}}:(.text+0x0): duplicate symbol '_Z3muldd'
-# NO_DEMANGLE-NEXT: {{.*}}:(.text+0x0): previous definition was here
-# NO_DEMANGLE-NEXT: {{.*}}:(.text+0x0): duplicate symbol 'foo'
-# NO_DEMANGLE-NEXT: {{.*}}:(.text+0x0): previous definition was here
+# NO_DEMANGLE: {{.*}}: duplicate symbol '_Z3muldd'
+# NO_DEMANGLE-NEXT: {{.*}}: previous definition was here
+# NO_DEMANGLE-NEXT: note: definitions found in .text+0x0 and .text+0x0
+# NO_DEMANGLE-NEXT: {{.*}}: duplicate symbol 'foo'
+# NO_DEMANGLE-NEXT: {{.*}}: previous definition was here
+# NO_DEMANGLE-NEXT: note: definitions found in .text+0x0 and .text+0x0
 
 # RUN: not ld.lld %t1.o %t1.o -o %t2 --demangle --no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO_DEMANGLE %s
 # RUN: not ld.lld %t1.o %t1.o -o %t2 --no-demangle --demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=DEMANGLE %s
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/conflict.s -o %t2.o
 # RUN: llvm-ar rcs %t3.a %t2.o
 # RUN: not ld.lld %t1.o %t3.a -u baz -o %t2 2>&1 | FileCheck -check-prefix=ARCHIVE %s
 
-# ARCHIVE:      {{.*}}3.a({{.*}}2.o):(.text+0x0): duplicate symbol 'foo'
-# ARCHIVE-NEXT: {{.*}}1.o:(.text+0x0): previous definition was here
+# ARCHIVE:      {{.*}}3.a({{.*}}2.o): duplicate symbol 'foo'
+# ARCHIVE-NEXT: {{.*}}1.o: previous definition was here
+# ARCHIVE-NEXT: note: definitions found in .text+0x0 and .text+0x0
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/conflict-debug.s -o %t-dbg.o
 # RUN: not ld.lld %t-dbg.o %t-dbg.o -o %t-dbg 2>&1 | FileCheck -check-prefix=DBGINFO %s
 
-# DBGINFO:      conflict-debug.s:4: duplicate symbol 'zed'
-# DBGINFO-NEXT: conflict-debug.s:4: previous definition was here
+# DBGINFO:      {{.*}}.o: duplicate symbol 'zed'
+# DBGINFO-NEXT: {{.*}}.o: previous definition was here
+# DBGINFO-NEXT: note: definitions found in conflict-debug.s:4 and conflict-debug.s:4
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/conflict-debug2.s -o %t-dbg2.o
+# RUN: echo "call zed" > %t-dbg1.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t-dbg1.s -o %t-dbg1.o
+# RUN: llvm-ar rcs %t-dbg2.a %t-dbg2.o
+# RUN: not ld.lld %t-dbg2.a %t-dbg1.o %t-dbg2.o -o %t2 2>&1 | FileCheck -check-prefix=ARCHIVE2 %s
+# ARCHIVE2:      {{.*}}-dbg2.o: duplicate symbol 'zed'
+# ARCHIVE2-NEXT: {{.*}}-dbg2.a({{.*}}-dbg2.o): previous definition was here
+# ARCHIVE2-NEXT: note: definitions found in conflict-debug.s(.text+0x0) and conflict-debug.s(.text+0x0)
 
 .globl _Z3muldd, foo
 _Z3muldd:
 foo:
   mov $60, %rax
   mov $42, %rdi
   syscall

test/ELF/copy-errors.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/protected-shared.s -o %t2.o
 // RUN: ld.lld %t2.o -o %t2.so -shared
 // RUN: not ld.lld %t.o %t2.so -o %t 2>&1 | FileCheck %s
 
 .global _start
 _start:
 
 
 call bar
-// CHECK: {{.*}}.o:(.text+0x1): cannot preempt symbol 'bar' defined in {{.*}}.so
+// CHECK: {{.*}}.o: cannot preempt symbol 'bar' defined in {{.*}}.so
+// CHECK: note: location is .text+0x1
 
 call zed
 // CHECK: symbol 'zed' defined in {{.*}}.so is missing type

test/ELF/copy-in-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/copy-in-shared.s -o %t1.o
 // RUN: ld.lld -shared %t1.o -o %t1.so
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t2.o
 // RUN: not ld.lld %t2.o %t1.so -o %t2.so -shared 2>&1 | FileCheck %s
 
 
 .quad foo
 
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_X86_64_64 against symbol 'foo' defined in {{.*}}.so
+// CHECK: {{.*}}.o: can't create dynamic relocation R_X86_64_64 against symbol 'foo' defined in {{.*}}.so

test/ELF/copy-rel-pie-error.s

 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: llvm-mc %p/Inputs/copy-rel-pie.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: ld.lld %t2.o -o %t2.so -shared
 // RUN: not ld.lld %t.o %t2.so -o %t.exe -pie 2>&1 | FileCheck %s
 
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_X86_64_64 against symbol 'bar' defined in {{.*}}.so
-// CHECK: {{.*}}.o:(.text+0x8): can't create dynamic relocation R_X86_64_64 against symbol 'foo' defined in {{.*}}.so
+// CHECK: {{.*}}.o: can't create dynamic relocation R_X86_64_64 against symbol 'bar' defined in {{.*}}.so
+// CHECK: {{.*}}.o: can't create dynamic relocation R_X86_64_64 against symbol 'foo' defined in {{.*}}.so
 
 .global _start
 _start:
         .quad bar
         .quad foo

test/ELF/dynamic-reloc-in-ro.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
 foo:
 .quad foo
 
-// CHECK: {{.*}}.o:(.text+0x0): can't create dynamic relocation R_X86_64_64 against local symbol in readonly segment defined in {{.*}}.o
+// CHECK: {{.*}}.o: can't create dynamic relocation R_X86_64_64 against local symbol in readonly segment defined in {{.*}}.o

test/ELF/eh-frame-dyn-rel.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: not ld.lld %t.o %t.o -o %t -shared 2>&1 | FileCheck %s
 
         .section        bar,"axG",@progbits,foo,comdat
         .cfi_startproc
         .cfi_personality 0x8c, foo
         .cfi_endproc
 
-// CHECK: {{.*}}.o:(.eh_frame+0x12): can't create dynamic relocation R_X86_64_64 against symbol 'foo' defined in {{.*}}.o
+// CHECK: {{.*}}.o: can't create dynamic relocation R_X86_64_64 against symbol 'foo' defined in {{.*}}.o

test/ELF/invalid-cie-length.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
         .section .eh_frame
         .byte 0
 
-// CHECK: {{.*}}:(.eh_frame+0x0): CIE/FDE too small
+// CHECK: {{.*}}: CIE/FDE too small

test/ELF/invalid-cie-length2.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
         .section .eh_frame
         .long 42
 
-// CHECK: {{.*}}:(.eh_frame+0x0): CIE/FDE ends past the end of the section
+// CHECK: {{.*}}: CIE/FDE ends past the end of the section

test/ELF/invalid-cie-length3.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
  .section .eh_frame
  .long 0xFFFFFFFC
 
-// CHECK: {{.*}}:(.eh_frame+0x0): CIE/FDE ends past the end of the section
+// CHECK: {{.*}}: CIE/FDE ends past the end of the section

test/ELF/invalid-cie-length4.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
  .section .eh_frame
  .long 0xFFFFFFFF
  .byte 0
 
-// CHECK: {{.*}}:(.eh_frame+0x0): CIE/FDE too large
+// CHECK: {{.*}}: CIE/FDE too large

test/ELF/libsearch.s

 // RUN:   | FileCheck --check-prefix=NOLIBRARY %s
 // NOLIBRARY: -l: missing argument
 
 // Should link normally, because _bar is not used
 // RUN: ld.lld -o %t3 %t.o
 // Should not link because of undefined symbol _bar
 // RUN: not ld.lld -o %t3 %t.o %tbar.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=UNDEFINED %s
-// UNDEFINED: error: {{.*}}:(.bar+0x0): undefined symbol '_bar'
+// UNDEFINED: error: {{.*}}: undefined symbol '_bar'
 
 // Should fail if cannot find specified library (without -L switch)
 // RUN: not ld.lld -o %t3 %t.o -lls 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIB %s
 // NOLIB: unable to find library -lls
 
 // Should use explicitly specified static library
 // Also ensure that we accept -L <arg>

test/ELF/linkerscript/edata-etext.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t.script
 # RUN: not ld.lld %t.o -script %t.script -o %t 2>&1 | FileCheck %s
-# CHECK: error: {{.*}}:(.text+0x0): undefined symbol '_edata'
-# CHECK: error: {{.*}}:(.text+0x8): undefined symbol '_etext'
-# CHECK: error: {{.*}}:(.text+0x10): undefined symbol '_end'
+# CHECK: error: {{.*}}: undefined symbol '_edata'
+# CHECK: error: {{.*}}: undefined symbol '_etext'
+# CHECK: error: {{.*}}: undefined symbol '_end'
 
 .global _start,_end,_etext,_edata
 .text
 _start:
  .quad _edata + 0x1
  .quad _etext + 0x1
  .quad _end + 0x1
 
 .data
   .word 1
 .bss
   .align 4
   .space 6

test/ELF/linkerscript/ehdr_start.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t.script
 # RUN: not ld.lld %t.o -script %t.script -o %t 2>&1 | FileCheck %s
-# CHECK: error: {{.*}}:(.text+0x0): undefined symbol '__ehdr_start'
+# CHECK: error: {{.*}}: undefined symbol '__ehdr_start'
 
 .text
 .global _start, __ehdr_start
 _start:
   .quad __ehdr_start

test/ELF/lto/combined-lto-object-name.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: not ld.lld -m elf_x86_64 %t.o -o %t2 2>&1 | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare void @foo()
 define void @_start() {
   call void @foo()
   ret void
 }
 
-; CHECK: error: ld-temp.o:(function _start): undefined symbol 'foo'
+; CHECK: error: lto.tmp: undefined symbol 'foo'
+; CHECK: note: location is ld-temp.o(function _start)

test/ELF/mips-align-err.s

 # REQUIRES: mips
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o \
 # RUN:         -mcpu=mips32r6
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mcpu=mips32r6 %S/Inputs/mips-align-err.s -o %t2.o
 # RUN: not ld.lld %t.o %t2.o -o %t.exe 2>&1 | FileCheck %s
-# CHECK: {{.*}}:(.text+0x1): improper alignment for relocation R_MIPS_PC16
+# CHECK: {{.*}}: improper alignment for relocation R_MIPS_PC16
 
         .globl  __start
 __start:
 .zero 1
         beqc      $5, $6, _foo            # R_MIPS_PC16

test/ELF/non-abs-reloc.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
-// CHECK: {{.*}}:(.dummy+0x0): has non-ABS reloc
+// CHECK: {{.*}}: has non-ABS reloc
 
 .globl _start
 _start:
   nop
 
 .section .dummy
   .long foo@gotpcrel

test/ELF/relocation-relative-absolute.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %tinput1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux \
 # RUN:   %S/Inputs/relocation-relative-absolute.s -o %tinput2.o
 # RUN: not ld.lld %tinput1.o %tinput2.o -o %t -pie 2>&1 | FileCheck %s
 
 .globl _start
 _start:
 
-# CHECK: {{.*}}input1.o:(.text+0x1): relocation R_X86_64_PLT32 cannot refer to absolute symbol 'answer' defined in {{.*}}input2.o
+# CHECK: {{.*}}input1.o: relocation R_X86_64_PLT32 cannot refer to absolute symbol 'answer' defined in {{.*}}input2.o
 
 call answer@PLT

test/ELF/sysroot.s

 // RUN: mkdir -p %t/lib
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t/m.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:     %p/Inputs/libsearch-st.s -o %t/st.o
 // RUN: rm -f %t/lib/libls.a
 // RUN: llvm-ar rcs %t/lib/libls.a %t/st.o
 // REQUIRES: x86
 
 // Should not link because of undefined symbol _bar
 // RUN: not ld.lld -o %t/r %t/m.o 2>&1 \
 // RUN:     | FileCheck --check-prefix=UNDEFINED %s
-// UNDEFINED: error: {{.*}}:(.text+0x1): undefined symbol '_bar'
+// UNDEFINED: error: {{.*}}: undefined symbol '_bar'
 
 // We need to be sure that there is no suitable library in the /lib directory
 // RUN: not ld.lld -o %t/r %t/m.o -L/lib -l:libls.a 2>&1 \
 // RUN:     | FileCheck --check-prefix=NOLIB %s
 // NOLIB: unable to find library -l:libls.a
 
 // Should just remove the '=' symbol if --sysroot is not specified.
 // Case 1: relative path

test/ELF/tls-static.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/shared.s -o %tso
 // RUN: ld.lld -static %t -o %tout
 // RUN: ld.lld %t -o %tout
 // RUN: ld.lld -shared %tso -o %tshared
 // RUN: not ld.lld -static %t %tshared -o %tout 2>&1 | FileCheck %s
 // REQUIRES: x86
 
 .global _start
 _start:
   call __tls_get_addr
 
-// CHECK: error: {{.*}}:(.text+0x1): undefined symbol '__tls_get_addr'
+// CHECK: error: {{.*}}: undefined symbol '__tls_get_addr'

test/ELF/undef-shared.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
-# CHECK: error: {{.*}}:(.data+0x0): undefined symbol 'hidden'
+# CHECK: error: {{.*}}: undefined symbol 'hidden'
+# CHECK: note: location is .data+0x0
 .global hidden
 .hidden hidden
 
-# CHECK: error: {{.*}}:(.data+0x8): undefined symbol 'internal'
+# CHECK: error: {{.*}}: undefined symbol 'internal'
+# CHECK: note: location is .data+0x8
 .global internal
 .internal internal
 
-# CHECK: error: {{.*}}:(.data+0x10): undefined symbol 'protected'
+# CHECK: error: {{.*}}: undefined symbol 'protected'
+# CHECK: note: location is .data+0x10
 .global protected
 .protected protected
 
 .section .data, "a"
  .quad hidden
  .quad internal
  .quad protected

test/ELF/undef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef-debug.s -o %t3.o
 # RUN: llvm-ar rc %t2.a %t2.o
 # RUN: not ld.lld %t.o %t2.a %t3.o -o %t.exe 2>&1 | FileCheck %s
 # RUN: not ld.lld -pie %t.o %t2.a %t3.o -o %t.exe 2>&1 | FileCheck %s
-# CHECK: error: undef.s:(.text+0x1): undefined symbol 'foo'
-# CHECK: error: undef.s:(.text+0x6): undefined symbol 'bar'
-# CHECK: error: undef.s:(.text+0x10): undefined symbol 'foo(int)'
-# CHECK: error: {{.*}}2.a({{.*}}.o):(.text+0x0): undefined symbol 'zed2'
-# CHECK: error: dir/undef-debug.s:3: undefined symbol 'zed3'
-# CHECK: error: dir/undef-debug.s:7: undefined symbol 'zed4'
-# CHECK: error: dir/undef-debug.s:11: undefined symbol 'zed5'
+# CHECK: error: {{.*}}.o: undefined symbol 'foo'
+# CHECK: note: location is undef.s(.text+0x1)
+# CHECK: error: {{.*}}.o: undefined symbol 'bar'
+# CHECK: note: location is undef.s(.text+0x6)
+# CHECK: error: {{.*}}.o: undefined symbol 'foo(int)'
+# CHECK: note: location is undef.s(.text+0x10)
+# CHECK: error: {{.*}}2.a({{.*}}.o): undefined symbol 'zed2'
+# CHECK: note: location is .text+0x0
+# CHECK: error: {{.*}}.o: undefined symbol 'zed3'
+# CHECK: note: location is dir/undef-debug.s:3
+# CHECK: error: {{.*}}.o: undefined symbol 'zed4'
+# CHECK: note: location is dir/undef-debug.s:7
+# CHECK: error: {{.*}}.o: undefined symbol 'zed5'
+# CHECK: note: location is dir/undef-debug.s:11
 
 # RUN: not ld.lld %t.o %t2.a -o %t.exe -no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO-DEMANGLE %s
-# NO-DEMANGLE: error: undef.s:(.text+0x10): undefined symbol '_Z3fooi'
+# NO-DEMANGLE: error: {{.*}}.o: undefined symbol '_Z3fooi'
+# NO-DEMANGLE: note: location is undef.s(.text+0x10)
 
 .file "undef.s"
 
   .globl _start
 _start:
   call foo
   call bar
   call zed1
   call _Z3fooi

test/ELF/unresolved-symbols.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/unresolved-symbols.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t.so
 
 ## Check that %t2.o contains undefined symbol undef.
 # RUN: not ld.lld %t1.o %t2.o -o %t 2>&1 | \
 # RUN:   FileCheck -check-prefix=UNDCHECK %s
-# UNDCHECK: error: {{.*}}2.o:(.text+0x1): undefined symbol 'undef'
+# UNDCHECK: error: {{.*}}2.o: undefined symbol 'undef'
+# UNDCHECK: note: location is .text+0x1
 
 ## Error out if unknown option value was set.
 # RUN: not ld.lld %t1.o %t2.o -o %t --unresolved-symbols=xxx 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERR1 %s
 # ERR1: unknown --unresolved-symbols value: xxx
 
 ## Ignore all should not produce error for symbols from object except
 ## case when --no-undefined specified.
 # RUN: ld.lld %t2.o -o %t1_1 --unresolved-symbols=ignore-all
 # RUN: llvm-readobj %t1_1 > /dev/null 2>&1
 # RUN: not ld.lld %t2.o -o %t1_2 --unresolved-symbols=ignore-all --no-undefined 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERRUND %s
-# ERRUND: error: {{.*}}:(.text+0x1): undefined symbol 'undef'
+# ERRUND: error: {{.*}}: undefined symbol 'undef'
 ## Also ignore all should not produce error for symbols from DSOs.
 # RUN: ld.lld %t1.o %t.so -o %t1_3 --unresolved-symbols=ignore-all
 # RUN: llvm-readobj %t1_3 > /dev/null 2>&1
 
 ## Ignoring undefines in objects should not produce error for symbol from object.
 # RUN: ld.lld %t1.o %t2.o -o %t2 --unresolved-symbols=ignore-in-object-files
 # RUN: llvm-readobj %t2 > /dev/null 2>&1
 ## And still should not should produce for undefines from DSOs.
 # RUN: ld.lld %t1.o %t.so -o %t2_1 --unresolved-symbols=ignore-in-object-files

test/ELF/verneed-local.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: not ld.lld %t.o %S/Inputs/verneed1.so -o %t 2>&1 | FileCheck %s
 
-# CHECK: error: {{.*}}:(.text+0x1): undefined symbol 'f3'
+# CHECK: error: {{.*}}: undefined symbol 'f3'
 .globl _start
 _start:
 call f3

test/ELF/x86-64-dyn-rel-error.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld %t2.o -shared -o %t2.so
 // RUN: not ld.lld %t.o %t2.so -o %t 2>&1 | FileCheck %s
 
         .global _start
 _start:
         .data
         .long bar
 
-// CHECK: {{.*}}:(.data+0x0): relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC.
+// CHECK: {{.*}}: relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC.

test/ELF/x86-64-dyn-rel-error2.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld %t2.o -shared -o %t2.so
 // RUN: not ld.lld %t.o %t2.so -o %t 2>&1 | FileCheck %s
 
         .global _start
 _start:
         .data
         .long bar - .
 
-// CHECK: {{.*}}:(.data+0x0): relocation R_X86_64_PC32 cannot be used against shared object; recompile with -fPIC.
+// CHECK: {{.*}}: relocation R_X86_64_PC32 cannot be used against shared object; recompile with -fPIC.

test/ELF/x86-64-reloc-32-fpic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-# CHECK: {{.*}}:(.data+0x0): relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC.
-
+# CHECK: {{.*}}: relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC.
 .data
 .long _shared

test/ELF/x86-64-reloc-error.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/x86-64-reloc-error.s -o %tabs
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld -shared %tabs %t -o %t2 2>&1 | FileCheck %s
 // REQUIRES: x86
 
   movl $big, %edx
   movq $foo - 0x1000000000000, %rdx
 
-# CHECK: {{.*}}:(.text+0x1): relocation R_X86_64_32 out of range
-# CHECK: {{.*}}:(.text+0x8): relocation R_X86_64_32S out of range
+# CHECK: {{.*}}: relocation R_X86_64_32 out of range
+# CHECK: {{.*}}: relocation R_X86_64_32S out of range

test/ELF/x86-64-reloc-pc32-fpic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
-# CHECK: {{.*}}:(.data+0x1): relocation R_X86_64_PC32 cannot be used against shared object; recompile with -fPIC.
+# CHECK: {{.*}}: relocation R_X86_64_PC32 cannot be used against shared object; recompile with -fPIC.
 
 .data
 call _shared

test/ELF/x86-64-reloc-range.s

 // RUN: llvm-mc %s -o %t.o -triple x86_64-pc-linux -filetype=obj
 // RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
-// CHECK: {{.*}}:(.text+0x3): relocation R_X86_64_PC32 out of range
+// CHECK: {{.*}}: relocation R_X86_64_PC32 out of range
 // CHECK-NOT: relocation
 
         lea     foo(%rip), %rax
         lea     foo(%rip), %rax
 
         .hidden foo
         .bss
         .zero 0x7fffe007
 foo:

test/ELF/zdefs.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t1.so
 
 # RUN: not ld.lld -z defs -shared %t.o -o %t1.so 2>&1 | FileCheck -check-prefix=ERR %s
-# ERR: error: {{.*}}:(.text+0x1): undefined symbol 'foo'
+# ERR: error: {{.*}}: undefined symbol 'foo'
 
 callq foo@PLT