[lld-macho]Limit "cannot-export-hidden-symbol" warnings to only 3 to avoid crowding logs

[oontvoo]

Summary

Details:
We often use wildcard symbols in the exported_symbols list, and sometimes they match autohide symbols, which triggers these "cannot export hidden symbols" warnings that can be a bit noisy.

It'd be more user-friendly if LLD could truncate these.

[oontvoo]

refactor

[thakis]

How does ld64 handle this situation?

[oontvoo]

In D159095#4626864, @thakis wrote:

How does ld64 handle this situation?

LD64 would issue similar warnings. It's not that LLD is doing anything wrong here.
It's just that in our internal use case, we have a huge list of exported-symbols (with wild-cards) so these warnings don't really offer anything useful to us and often crowd the log.
Having a way to silence them would drastically improve the readability of logs (and potentially speed up the linkage too, due to less I/O), especially when debugging other linker errors.

[oontvoo]

Per off-line discussion, will rework this so that LLD only emit the warning 3 times (or some smaller number, can decide/debate later)

[oontvoo]

updated patch to truncate the warnings

[thakis]

Thanks!

lld/MachO/Driver.cpp

1382

why an explicit call to .load() here but not in the line above? be self-consistent.

[oontvoo]

removed .load() call

[oontvoo]

Thanks!

lld/MachO/Driver.cpp

if (auto *objFile = dyn_cast<ObjFile>(file)) {
           fatal("unable to find alias referent " + alias->getAliasedName() +
                 " for " + alias->getName());
         }
       }
     }
   }
 }
 
-static void handleExplicitExports() {
+static void handleExplicitExports(bool warnExportHidden) {
   if (config->hasExplicitExports) {
     parallelForEach(symtab->getSymbols(), [](Symbol *sym) {
       if (auto *defined = dyn_cast<Defined>(sym)) {
         if (config->exportedSymbols.match(sym->getName())) {
           if (defined->privateExtern) {
             if (defined->weakDefCanBeHidden) {
               // weak_def_can_be_hidden symbols behave similarly to
               // private_extern symbols in most cases, except for when
               // it is explicitly exported.
               // The former can be exported but the latter cannot.
               defined->privateExtern = false;
-            } else {
+            } else if (warnExportHidden) {
               warn("cannot export hidden symbol " + toString(*defined) +
                    "\n>>> defined in " + toString(defined->getFile()));
             }
           }
         } else {
           defined->privateExtern = true;
         }
       } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
         dysym->shouldReexport = config->exportedSymbols.match(sym->getName());
       }
     });
   } else if (!config->unexportedSymbols.empty()) {
     parallelForEach(symtab->getSymbols(), [](Symbol *sym) {
       if (auto *defined = dyn_cast<Defined>(sym))
         if (config->unexportedSymbols.match(defined->getName()))
           defined->privateExtern = true;
     });
   }
 }
 
 namespace lld {
for (const Arg *arg : args.filtered(OPT_mllvm)) {
       config->mllvmOpts.emplace_back(arg->getValue());
     }
 
     createSyntheticSections();
     createSyntheticSymbols();
     addSynthenticMethnames();
 
     createAliases();
+    const bool warnExportHidden =
+        !args.hasFlag(OPT_no_warn_export_hidden, false);
     // If we are in "explicit exports" mode, hide everything that isn't
     // explicitly exported. Do this before running LTO so that LTO can better
     // optimize.
-    handleExplicitExports();
+    handleExplicitExports(warnExportHidden);
 
     bool didCompileBitcodeFiles = compileBitcodeFiles();
 
     resolveLCLinkerOptions();
 
     // If --thinlto-index-only is given, we should create only "index
     // files" and not object files. Index file creation is already done
     // in compileBitcodeFiles, so we are done if that's the case.
     if (config->thinLTOIndexOnly)
       return errorCount() == 0;
 
     // LTO may emit a non-hidden (extern) object file symbol even if the
     // corresponding bitcode symbol is hidden. In particular, this happens for
     // cross-module references to hidden symbols under ThinLTO. Thus, if we
     // compiled any bitcode files, we must redo the symbol hiding.
     if (didCompileBitcodeFiles)
-      handleExplicitExports();
+      handleExplicitExports(warnExportHidden);
     replaceCommonSymbols();
 
     StringRef orderFile = args.getLastArgValue(OPT_order_file);
     if (!orderFile.empty())
       priorityBuilder.parseOrderFile(orderFile);
 
     referenceStubBinder();
 

lld/MachO/Options.td

 def no_inits : Flag<["-"], "no_inits">,
     HelpText<"Fail if the output contains static initializers">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
 def no_warn_inits : Flag<["-"], "no_warn_inits">,
     HelpText<"Suppress warnings for static initializers in the output">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
+def no_warn_export_hidden : Flag<["-"], "no_warn_export_hidden">,
+    HelpText<"Suppress warnings for exporting weakdef-can-be-hidden symbols in the output">,
+    Flags<[HelpHidden]>,
+    Group<grp_rare>;    
 def unaligned_pointers : Separate<["-"], "unaligned_pointers">,
     MetaVarName<"<treatment>">,
     HelpText<"Handle unaligned pointers in __DATA segments according to <treatment>: warning, error, or suppress (default for arm64e is error, otherwise suppress)">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
 def dirty_data_list : Separate<["-"], "dirty_data_list">,
     MetaVarName<"<path>">,
     HelpText<"Specify data symbols in <path> destined for the __DATA_DIRTY segment">,

lld/test/MachO/export-options.s

 ## Test that we can export the autohide symbol but not when it's also
 ## private-extern
 # RUN: %lld -dylib -exported_symbol "_foo" %t/autohide.o -o %t/exp-autohide.dylib
 # RUN: llvm-nm -g %t/exp-autohide.dylib | FileCheck %s --check-prefix=EXP-AUTOHIDE
 
 # RUN: not %lld -dylib -exported_symbol "_foo" %t/autohide-private-extern.o \
 # RUN:   -o /dev/null  2>&1 | FileCheck %s --check-prefix=AUTOHIDE-PRIVATE
 
+## Test that the warning/error message can be suppressed.
+# RUN: %lld -dylib -exported_symbol "_foo" %t/autohide-private-extern.o -no_warn_export_hidden -o %t/autohide-pe-no-warn.out
+
 # RUN: not %lld -dylib -exported_symbol "_foo" %t/autohide.o \
 # RUN:   %t/glob-private-extern.o -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=AUTOHIDE-PRIVATE
 
 # RUN: not %lld -dylib -exported_symbol "_foo" %t/autohide.o \
 # RUN:   %t/weak-private-extern.o -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=AUTOHIDE-PRIVATE