[ELF] Prohibit icf=safe warning from being fatal

[melver]

Summary

Many projects compile with fatal linker warnings. The fact that icf=safe
has limitations with object files created by ld -r or objcopy limits
such projects from either (a) using --fatal-warnings, or (b) using ld or
objcopy produced dependencies.

Arguably, users that use ld/objcopy should be aware of icf=safe's
limitations, but should never affect _consumers_ of dependencies created
in this way. An example is a library that must internalize symbols to
ship and safely link into other targets.

Not being able to apply ICF to such a library should not be a
dealbreaker for projects that employ --fatal-warnings. The rest of the
project's object files can still employ ICF, while incompatible object
files are skipped with the warning.

Never treat icf=safe warnings as fatal.

[melver]

I just discovered that removing .llvm_addrsig (seen that done elsewhere, too) also resolves the issue.

I suppose that solves my immediate issue, but I wonder:

1. Should we update the warning to suggest that?

2. Still make the warning never-fatal?

Because I can't be the only one that has encountered this issue.

[MaskRay]

I don't think we want more diagnostic levels. The warning is not fatal, it's just that some users use --fatal-warnings to upgrade warnings to errors.
If this warning is annoying under --fatal-warnings, we can think of message(...). But right now, it seems appropriate for the user to be aware of the problem and discard .llvm_addrsig by themselves.
(I have more notes in https://maskray.me/blog/2020-11-15-explain-gnu-linker-options )

[melver]

In D144471#4142299, @MaskRay wrote:

I don't think we want more diagnostic levels. The warning is not fatal, it's just that some users use --fatal-warnings to upgrade warnings to errors.
If this warning is annoying under --fatal-warnings, we can think of message(...). But right now, it seems appropriate for the user to be aware of the problem and discard .llvm_addrsig by themselves.
(I have more notes in https://maskray.me/blog/2020-11-15-explain-gnu-linker-options )

Thanks - I'll abandon this for now.

lld/Common/ErrorHandler.cpp

 void ErrorHandler::message(const Twine &msg, llvm::raw_ostream &s) {
   if (disableOutput)
     return;
   std::lock_guard<std::mutex> lock(mu);
   s << msg << "\n";
   s.flush();
 }
 
-void ErrorHandler::warn(const Twine &msg) {
-  if (fatalWarnings) {
+void ErrorHandler::warn(const Twine &msg, bool neverFatal) {
+  if (!neverFatal && fatalWarnings) {
     error(msg);
     return;
   }
 
   if (suppressWarnings)
     return;
 
   std::lock_guard<std::mutex> lock(mu);

lld/ELF/InputFiles.cpp

if ((sec.sh_flags & SHF_EXCLUDE) && !config->relocatable) {
       if (sec.sh_type == SHT_LLVM_ADDRSIG) {
         // We ignore the address-significance table if we know that the object
         // file was created by objcopy or ld -r. This is because these tools
         // will reorder the symbols in the symbol table, invalidating the data
         // in the address-significance table, which refers to symbols by index.
         if (sec.sh_link != 0)
           this->addrsigSec = &sec;
         else if (config->icf == ICFLevel::Safe)
-          warn(toString(this) +
+          errorHandler().warn(toString(this) +
                                   ": --icf=safe conservatively ignores "
                                   "SHT_LLVM_ADDRSIG [index " +
                                   Twine(i) +
                                   "] with sh_link=0 "
-               "(likely created using objcopy or ld -r)");
+                                  "(likely created using objcopy or ld -r)",
+                              /*neverFatal=*/true);
       }
       this->sections[i] = &InputSection::discarded;
       continue;
     }
 
     switch (sec.sh_type) {
     case SHT_GROUP: {
       if (!config->relocatable)

lld/include/lld/Common/ErrorHandler.h

public:
   bool disableOutput = false;
   std::function<void()> cleanupCallback;
 
   void error(const Twine &msg);
   void error(const Twine &msg, ErrorTag tag, ArrayRef<StringRef> args);
   [[noreturn]] void fatal(const Twine &msg);
   void log(const Twine &msg);
   void message(const Twine &msg, llvm::raw_ostream &s);
-  void warn(const Twine &msg);
+  void warn(const Twine &msg, bool neverFatal = false);
 
   raw_ostream &outs();
   raw_ostream &errs();
   void flushStreams();
 
   std::unique_ptr<llvm::FileOutputBuffer> outputBuffer;
 
 private: