[ELF] - Implement --warn-once.

[grimar]

Summary

--warn-once is a option supported by ld.bfd which is:

--warn-once
Only warn once for each undefined symbol, rather than once per module which refers to it.

Reporting undefined symbol only once seems useful feature, that is why I implemented it.
(FWIW gold does not seem to support it).

[ruiu]

I'd ignore this option for now as I personally didn't find this option useful.

[ruiu]

It might be a nice-to-have feature, but it seems like a feature creeping to me. Let's just ignore this option until someone comes to us and show a strong evidence that this is super-useful.

[ruiu]

(By the way, I wouldn't do this, but even if we would do, I wouldn't take the approach that is implemented in this patch because I don't want to mess up the Symbol data structure for this feature as it is too much. I'd instead make a change to Error.cpp so that no messages are printed out more than once. But, again, I wouldn't do that.)

[grimar]

In D35797#820477, @ruiu wrote:

(By the way, I wouldn't do this, but even if we would do, I wouldn't take the approach that is implemented in this patch because I don't want to mess up the Symbol data structure for this feature as it is too much. I'd instead make a change to Error.cpp so that no messages are printed out more than once. But, again, I wouldn't do that.)

Ok, anyways thanks. I did not think about possibility to do a change to Error.cpp, it was interesting to think about.

[grimar]

r309096 ignores this option.

ELF/Config.h

struct Configuration {
   bool Shared;
   bool Static = false;
   bool SysvHash;
   bool Target1Rel;
   bool Threads;
   bool Trace;
   bool Verbose;
   bool WarnCommon;
+  bool WarnOnce;
   bool WarnMissingEntry;
   bool ZCombreloc;
   bool ZExecstack;
   bool ZNocopyreloc;
   bool ZNodelete;
   bool ZNodlopen;
   bool ZNow;
   bool ZOrigin;

ELF/Driver.cpp

Config->ThinLTOCachePolicy = check(
       "--thinlto-cache-policy: invalid cache policy");
   Config->ThinLTOJobs = getInteger(Args, OPT_thinlto_jobs, -1u);
   Config->Threads = getArg(Args, OPT_threads, OPT_no_threads, true);
   Config->Trace = Args.hasArg(OPT_trace);
   Config->Undefined = getArgs(Args, OPT_undefined);
   Config->UnresolvedSymbols = getUnresolvedSymbolPolicy(Args);
   Config->Verbose = Args.hasArg(OPT_verbose);
   Config->WarnCommon = Args.hasArg(OPT_warn_common);
+  Config->WarnOnce = Args.hasArg(OPT_warn_once);
   Config->ZCombreloc = !hasZOption(Args, "nocombreloc");
   Config->ZExecstack = hasZOption(Args, "execstack");
   Config->ZNocopyreloc = hasZOption(Args, "nocopyreloc");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNodlopen = hasZOption(Args, "nodlopen");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = !hasZOption(Args, "norelro");

ELF/Options.td

 
 def version: F<"version">, HelpText<"Display the version number and exit">;
 
 defm version_script: Eq<"version-script">, HelpText<"Read a version script">;
 
 def warn_common: F<"warn-common">,
   HelpText<"Warn about duplicate common symbols">;
 
+def warn_once: F<"warn-once">,
+  HelpText<"Show error or warning for each undefined symbol only once">;
+
 def warn_unresolved_symbols: F<"warn-unresolved-symbols">,
   HelpText<"Report unresolved symbols as warnings">;
 
 def whole_archive: F<"whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
 defm wrap: Eq<"wrap">, HelpText<"Use wrapper functions for symbol">,
   MetaVarName<"<symbol>">;

ELF/Relocations.cpp

static int64_t computeMipsAddend(const RelTy &Rel, InputSectionBase &Sec,
   warn("can't find matching " + toString(PairTy) + " relocation for " +
        toString(Type));
   return 0;
 }
 
 template <class ELFT>
 static void reportUndefined(SymbolBody &Sym, InputSectionBase &S,
                             uint64_t Offset) {
+  assert(Sym.isUndefined());
   if (Config->UnresolvedSymbols == UnresolvedPolicy::IgnoreAll)
     return;
 
   bool CanBeExternal = Sym.symbol()->computeBinding() != STB_LOCAL &&
                        Sym.getVisibility() == STV_DEFAULT;
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore && CanBeExternal)
     return;
 
+  Undefined *U = cast<Undefined>(&Sym);
+  if (U->Reported && Config->WarnOnce)
+      return;
+  U->Reported = true;
+
   std::string Msg =
       "undefined symbol: " + toString(Sym) + "\n>>> referenced by ";
 
   std::string Src = S.getSrcMsg<ELFT>(Offset);
   if (!Src.empty())
     Msg += Src + "\n>>>               ";
   Msg += S.getObjMsg<ELFT>(Offset);
 

ELF/Symbols.h

 class Undefined : public SymbolBody {
 public:
   Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
             InputFile *F);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == UndefinedKind;
   }
+
+  // Used for error reporting. True if symbol was reported.
+  unsigned Reported : 1;
 };
 
 class SharedSymbol : public Defined {
 public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::SharedKind;
   }
 

ELF/Symbols.cpp

template <class ELFT> bool DefinedRegular::isMipsPIC() const {
   auto *Sec = cast<InputSectionBase>(Section);
   const Elf_Ehdr *Hdr = Sec->template getFile<ELFT>()->getObj().getHeader();
   return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
          (Hdr->e_flags & EF_MIPS_PIC);
 }
 
 Undefined::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
                      uint8_t Type, InputFile *File)
-    : SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, StOther, Type) {
+    : SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, StOther, Type),
+      Reported(false) {
   this->File = File;
 }
 
 DefinedCommon::DefinedCommon(StringRef Name, uint64_t Size, uint32_t Alignment,
                              uint8_t StOther, uint8_t Type, InputFile *File)
     : Defined(SymbolBody::DefinedCommonKind, Name, /*IsLocal=*/false, StOther,
               Type),
       Alignment(Alignment), Size(Size) {

test/ELF/warn-once.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: not ld.lld %t.o -o %t1 2>&1 | FileCheck -check-prefix=ERR1 %s
+# ERR1: error: undefined symbol: foo
+# ERR1: error: undefined symbol: foo
+# ERR1: error: undefined symbol: boo
+# ERR1: error: undefined symbol: boo
+
+# RUN: not ld.lld --warn-once %t.o -o %t1 2>&1 | FileCheck -check-prefix=ERR2 %s
+# ERR2: error: undefined symbol: foo
+# ERR2-NOT: foo
+# ERR2: error: undefined symbol: boo
+# ERR2-NOT: boo
+
+callq foo@PLT
+callq foo@PLT
+callq boo@PLT
+callq boo@PLT