[ELF] Add warnings for various symbols that cannot be ordered

[jhenderson]

Summary

There are a number of different situations when symbols are requested to be ordered in the --symbol-ordering-file that cannot be ordered for some reason. To assist with identifying these symbols, and either tidying up the order file, or the inputs, a number of warnings have been added. As some users may find these warnings unhelpful, due to how they use the symbol ordering file, a switch has also been added to disable these warnings.

The cases where we now warn are:

1. Entries in the order file that don't correspond to any symbol in the input
2. Undefined symbols
3. Absolute symbols
4. Symbols imported from shared objects
5. Symbols that are discarded, due to e.g. --gc-sections or /DISCARD/ linker script sections
6. Multiple of the same entry in the order file

[jhenderson]

Added a new warning to warn if the same name is specified multiple times in the order file.

[jhenderson]

Rebased following r323779. Thanks to that change, buildSectionOrder() is now only called in one place, and only after processSectionCommands(). This means that we don't need the additional boolean to prevent warnings being emitted twice in some situations, and can also now warn for symbols in /DISCARD/ sections that would otherwise be ordered.

[grimar]

ELF/Writer.cpp

1040

I would suggest to use bool here:

bool Inserted = SymbolOrder.insert({S, {Priority++, false}}).second;
if (Config->WarnSymbolOrdering && !Inserted)

as we usually trying to avoid using auto and also here type of Inserted would be pair,
though its name seems assuming it is a bool and probably looks better.

1042

Looks you can use early continue:

if (OrderEntry == SymbolOrder.end())
  continue;
OrderEntry->second.second = true;

With that code below seems simplifies to:

int &Priority = SectionOrder[D->Section];
Priority = std::min(Priority, OrderEntry->second.first);

1055

Problem of that line is that it is described as "present in inputs" though set only if
Config->WarnSymbolOrdering is set. Though that should probably be independent.

So I suggest to move it out, like in one of above comments.

1073

We usually inline such short conditions I believe:

if (Config->WarnSymbolOrdering)
  for (auto V : SymbolOrder)
    if (!V.second.second)
      warn("symbol ordering file: no symbol '" + V.first +
           "' found in input");

Also V name usually stands for Vector, though it is not the case here. I would rename.

Did you consider to use MapVector for SymbolOrder to iterate in stable insertion order here ?

[jhenderson]

Addressed review comments.

ELF/Writer.cpp

1042

Thanks, you're right. I think the problem I thought was that there would not be entries in SectionOrder for all sections in the end, if we stopped early, but actually, that doesn't matter, because we use lookup() on this map eventually, so a missing value is the same as 0.

1073

No, I hadn't considered MapVector, but I think it is a good idea. Thanks for suggesting it.

[ruiu]

ELF/Writer.cpp

1037–1039

Actually I'd do this in the driver so that we can make the writer focus on writing.

1046

For a multi-line if, please add {}.

1072

I'd move this to the driver as well.

[ruiu]

I noticed that all these error checks can be moved to the driver (which is a better place to show a warning message for bad user inputs) if you do like this: https://github.com/rui314/llvm-project/commit/301cf4915cf99b5270905ba823b3b56be327e3f8

I just hacked it up, so I didn't test it, but I think this should work to describe the idea.

[jhenderson]

In D42475#994397, @ruiu wrote:

I noticed that all these error checks can be moved to the driver (which is a better place to show a warning message for bad user inputs) if you do like this: https://github.com/rui314/llvm-project/commit/301cf4915cf99b5270905ba823b3b56be327e3f8

I just hacked it up, so I didn't test it, but I think this should work to describe the idea.

I like the principle of your idea, but unfortunately, there are two issues with it that I discovered (plus one easily fixed bug in the implementation for absolute symbols). Firstly, it is relying on the symbols in the final symbol table, which means, for example, that where there are local symbols requested to be ordered, a "symbol not found" warning will be emitted, whereas in the old behaviour, local symbols could be ordered. Secondly, since this location in the driver happens before processSectionCommands, there will be no warning for /DISCARD/-ed, which with the current proposal there is. It might be possible to work around the former, by changing the implementation to loop over symbols in the input files, as done currently, but it is not possible to solve the latter using this approach. I'd therefore prefer to keep the change in the current location.

[jhenderson]

Add missing braces. Also remove a .global marker on the absolute symbol, so that it shows up if we stop warning for local symbols, or warn differently for local symbols.

[ruiu]

ELF/Writer.cpp

1037–1039

At least you can move this to the driver, no?

1040–1068

I wouldn't repeat OrderEntry->second. Instead, I'd assign it to a variable with no auto type.

1044

I don't like second.second because it's not that meaningful. Can you define a struct for this?

[jhenderson]

Move warning of duplicate entries to earlier, and renamed a few fields and variables.

[grimar]

My thoughts below. Though probably part about changes in Driver.cpp
may conflict with previous Rui's comment.

Rui, did you mean you want to compute priority in driver ? I realize why you did
that in your version, but since it was decided to keep parts of logic
in writer, it seems to be more appropriate place for doing that.
I assume you meant to report "specified multiple times" there, but
leave the rest to buildSectionOrder ?

ELF/Config.h

77

I do not think this struct should be here.
I believe in Driver.cpp you want to report "specified multiple times" error,
but Priority and Present are things that you need only once in
buildSectionOrder and so them probably should be computed, used
and then forgotten right there.

80

So I think it can be reverted to

std::vector<llvm::StringRef> SymbolOrderingFile;

And then you could for example use local DenseSet<llvm::StringRef>
in getSymbolOrderingFile to check and report duplicates.

ELF/Driver.cpp

600

This can be:

if (!MB) 
  return {};

MapVector<StringRef, SymbolOrderEntry> Ret;
...

[jhenderson]

To me, it seems inefficient to check for duplicates in one place and then loop through the same list later to set priorities.

[jhenderson]

Address review comments:

• Move struct back into buildSectionOrder()
• Move priority and presence initialisation back to buildSectionOrder()
• Simplify initial check in getSymbolOrderingFile()
• Use "B" macro for new options

I haven't gone as far as @rafael suggested on the mailing list and moved everything back into the Writer (except for the reading in), since that seemed to be against what @ruiu and @grimar prefer. I'm happy with it either way.

[grimar]

In D42475#1000525, @jhenderson wrote:

I haven't gone as far as @rafael suggested on the mailing list and moved everything back into the Writer (except for the reading in), since that seemed to be against what @ruiu and @grimar prefer. I'm happy with it either way.

Thanks for update, Reporting duplicates during reading (with suggestion below) in Driver.cpp looks nice for me, though I have no very strong preference FWIW.

ELF/Driver.cpp

600

I guess this can be SetVector<StringRef> and then something like below should work:

SetVector<StringRef> Names;
for (StringRef S : args::getLines(*MB)) 
  if (!Names.insert(S).second && Config->WarnSymbolOrdering)
    warn("symbol ordering file: symbol '" + S + "' specified multiple times");
return Names.takeVector();

[ruiu]

ELF/Driver.cpp

600

This is nice.

[jhenderson]

Address review comments:

• Use SetVector instead of two different variables, and simplify related code.
• Fix comment in test.

[jhenderson]

Pull creation of MemoryBuffer back out of getSymbolOrderingFile().

@ruiu, would you mind confirming that you are happy with this? Rafael gave a LGTM with this and the changes in the previous update, but since you had comments, I'd appreciate it if you confirm before I commit.

[ruiu]

ELF/Driver.cpp

596

Remove {}

598

I prefer the following style

warn(MB.getBufferIdentifier() + ": duplicate symbol: " + S);

because (1) it is easier to parse by script, and (2) easier to read if symbol name is extremely long (which is actually common for C++ programs).

ELF/Writer.cpp

1041

It is a conventional name for this.

1044

Ent is perhaps more conventional.

1073

Remove {}

[jhenderson]

Addressed Rui's review comments:

• Renamed some variables
• Removed some braces
• Reformatted messages to put symbols at end and source/object file at front (but see inline comments)

[jhenderson]

ELF/Driver.cpp

598

I have a slight concern that "duplicate symbol" could cause confusion with a multiply-defined symbol error. How about "duplicate ordered symbol"? Also, unless we store the order file name somewhere (e.g. in the Config variable), we can't use it in the other warnings, so I've used the owning file of the symbol instead. That still leaves the "no such symbol warning" however without an easily identified file.

[jhenderson]

Clang-format

[grimar]

ELF/Driver.cpp

598

I think we often include command line option name to error message, for example:

error("max-page-size: value isn't a power of 2");
...
error("-image-base: number expected, but got " + S);

So to avoid confusion and make message shorter, we could probably use something like:
warn("--warn-symbol-ordering: " + MB.getBufferIdentifier() + ": duplicate symbol: " + S);

[jhenderson]

ELF/Driver.cpp

598

This seems like a bit of a new case to me, so it's unclear what should be done. At the moment, there broadly appear to be four kinds of error/warning messages that are somewhat related to this, based on a quick reading of the LLD code:

1. Messages for problems with object files/archives. These are usually of the form "<object or source file name>: message"
2. Messages for problems with reading/opening input or output files. These are usually of the form "cannot open <file name> ..."
3. Messages for problems with input switches. These are of the form "<switch name>: message"
4. Messages for problems with linker script parsing/evaluation. These are of the "<script file name>: message"

There are also quite a few that don't really fit any pattern, mostly either missing any file name or with the file name in the middle or end of the message, which should probably be one of the other formats. Unfortunately, the closest equivalent to our situation (i.e. a message regarding the contents of a non-script or object input) is the version script warning for duplicate symbol, which does not mention the version script's filename at all, although the message is clear that the duplicate symbol is in the version script, not elsewhere. The next closest is probably the linker script situation (since it is a non-object/archive input), where "-T/--script" is not mentioned in the message, which is the form I've gone for (and explicitly mentioned "ordered"), but I'm happy to change the format to include both switch name and file name if that's the consensus.

[grimar]

ELF/Driver.cpp

598

I'm happy to change the format to include both switch name and file name if that's the consensus.

I am fine with either way :) We can tweak message text after anyways.

[ruiu]

LGTM

[jhenderson]

Rebased following recent changes by @rafael. I'm going to commit this shortly.

ELF/Config.h

struct VersionDefinition {
   std::vector<SymbolVersion> Globals;
   size_t NameOff = 0; // Offset in the string table
 };
 
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   uint8_t OSABI = 0;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
   llvm::StringMap<uint64_t> SectionStartMap;
   llvm::StringRef Chroot;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef LTOAAPipeline;
   llvm::StringRef LTONewPmPasses;
struct Configuration {
   bool Shared;
   bool Static = false;
   bool SysvHash = false;
   bool Target1Rel;
   bool Trace;
   bool UndefinedVersion;
   bool WarnCommon;
   bool WarnMissingEntry;
+  bool WarnSymbolOrdering;
   bool WriteAddends;
   bool ZCombreloc;
   bool ZExecstack;
   bool ZNocopyreloc;
   bool ZNodelete;
   bool ZNodlopen;
   bool ZNow;
   bool ZOrigin;

ELF/Driver.cpp

 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"

 static int parseInt(StringRef S, opt::Arg *Arg) {
   int V = 0;
   if (!to_integer(S, V, 10))
     error(Arg->getSpelling() + "=" + Arg->getValue() +
           ": number expected, but got '" + S + "'");
   return V;
 }
 
+// Parse the symbol ordering file and warn for any duplicate entries.
+static std::vector<StringRef> getSymbolOrderingFile(MemoryBufferRef MB) {
+  SetVector<StringRef> Names;
+  for (StringRef S : args::getLines(MB))
+    if (!Names.insert(S) && Config->WarnSymbolOrdering)
+      warn(MB.getBufferIdentifier() + ": duplicate ordered symbol: " + S);
+
+  return Names.takeVector();
+}
+
 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   errorHandler().Verbose = Args.hasArg(OPT_verbose);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
 
   Config->AllowMultipleDefinition =
       Args.hasFlag(OPT_allow_multiple_definition,
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->ThinLTOJobs = args::getInteger(Args, OPT_thinlto_jobs, -1u);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
   Config->Trace = Args.hasArg(OPT_trace);
   Config->Undefined = args::getStrings(Args, OPT_undefined);
   Config->UndefinedVersion =
       Args.hasFlag(OPT_undefined_version, OPT_no_undefined_version, true);
   Config->UnresolvedSymbols = getUnresolvedSymbolPolicy(Args);
   Config->WarnCommon = Args.hasFlag(OPT_warn_common, OPT_no_warn_common, false);
+  Config->WarnSymbolOrdering =
+      Args.hasFlag(OPT_warn_symbol_ordering, OPT_no_warn_symbol_ordering, true);
   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");
if (auto *Arg = Args.getLastArg(OPT_pack_dyn_relocs_eq)) {
     if (S == "android")
       Config->AndroidPackDynRelocs = true;
     else if (S != "none")
       error("unknown -pack-dyn-relocs format: " + S);
   }
 
   if (auto *Arg = Args.getLastArg(OPT_symbol_ordering_file))
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
-      Config->SymbolOrderingFile = args::getLines(*Buffer);
+      Config->SymbolOrderingFile = getSymbolOrderingFile(*Buffer);
 
   // If --retain-symbol-file is used, we'll keep only the symbols listed in
   // the file and discard all others.
   if (auto *Arg = Args.getLastArg(OPT_retain_symbols_file)) {
     Config->DefaultSymbolVersion = VER_NDX_LOCAL;
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       for (StringRef S : args::getLines(*Buffer))
         Config->VersionScriptGlobals.push_back(

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">;
 
 defm warn_common: B<"warn-common",
     "Warn about duplicate common symbols",
     "Do not warn about duplicate common symbols">;
 
+defm warn_symbol_ordering : B<"warn-symbol-ordering",
+    "Warn about problems with the symbol ordering file",
+    "Do not warn about problems with the symbol ordering file">;
+
 def warn_unresolved_symbols: F<"warn-unresolved-symbols">,
   HelpText<"Report unresolved symbols as warnings">;
 
 defm whole_archive: B<"whole-archive",
     "Force load of all members in a static library",
     "Do not force load of all members in a static library">;
 
 defm wrap: Eq<"wrap">, HelpText<"Use wrapper functions for symbol">,

ELF/Writer.cpp

 }
 
 // Builds section order for handling --symbol-ordering-file.
 static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
   DenseMap<const InputSectionBase *, int> SectionOrder;
   if (Config->SymbolOrderingFile.empty())
     return SectionOrder;
 
+  struct SymbolOrderEntry {
+    int Priority;
+    bool Present;
+  };
+
   // Build a map from symbols to their priorities. Symbols that didn't
   // appear in the symbol ordering file have the lowest priority 0.
   // All explicitly mentioned symbols have negative (higher) priorities.
-  DenseMap<StringRef, int> SymbolOrder;
+  DenseMap<StringRef, SymbolOrderEntry> SymbolOrder;
   int Priority = -Config->SymbolOrderingFile.size();
   for (StringRef S : Config->SymbolOrderingFile)
-    SymbolOrder.insert({S, Priority++});
+    SymbolOrder.insert({S, {Priority++, false}});
 
   // Build a map from sections to their priorities.
   for (InputFile *File : ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
-      if (auto *D = dyn_cast<Defined>(Sym)) {
-        if (auto *Sec = dyn_cast_or_null<InputSectionBase>(D->Section)) {
-          int &Priority = SectionOrder[Sec];
-          Priority = std::min(Priority, SymbolOrder.lookup(D->getName()));
-        }
+      auto It = SymbolOrder.find(Sym->getName());
+      if (It == SymbolOrder.end())
+        continue;
+      SymbolOrderEntry &Ent = It->second;
+      Ent.Present = true;
+
+      auto *D = dyn_cast<Defined>(Sym);
+      if (Config->WarnSymbolOrdering) {
+        if (Sym->isUndefined())
+          warn(File->getName() +
+               ": unable to order undefined symbol: " + Sym->getName());
+        else if (Sym->isShared())
+          warn(File->getName() +
+               ": unable to order shared symbol: " + Sym->getName());
+        else if (D && !D->Section)
+          warn(File->getName() +
+               ": unable to order absolute symbol: " + Sym->getName());
+        else if (D && !D->Section->Live)
+          warn(File->getName() +
+               ": unable to order discarded symbol: " + Sym->getName());
+      }
+      if (!D)
+        continue;
+
+        Priority = std::min(Priority, Ent.Priority);
       }
     }
   }
+
+  if (Config->WarnSymbolOrdering)
+    for (auto OrderEntry : SymbolOrder)
+      if (!OrderEntry.second.Present)
+        warn("symbol ordering file: no such symbol: " + OrderEntry.first);
+
   return SectionOrder;
 }
 
 static void sortSection(OutputSection *Sec,
                         const DenseMap<const InputSectionBase *, int> &Order) {
   if (!Sec->Live)
     return;
   StringRef Name = Sec->Name;

test/ELF/Inputs/symbol-ordering-file-warnings1.s

+# This is a "bad" (absolute) instance of the symbol
+multi = 1234
+
+.text
+.global shared
+.type shared, @function
+shared:
+  movq  %rax, multi
+  ret
+
+.section .text.comdat,"axG",@progbits,comdat,comdat
+.weak comdat
+comdat:
+  ret
+
+.section .text.glob_or_wk,"ax",@progbits
+.global glob_or_wk
+glob_or_wk:
+  ret

test/ELF/Inputs/symbol-ordering-file-warnings2.s

+.text
+.global missing
+missing:
+  callq undefined
+  # This is a "bad" (undefined) instance of the symbol
+  callq multi

test/ELF/symbol-ordering-file-warnings.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 %S/Inputs/symbol-ordering-file-warnings1.s -o %t2.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/symbol-ordering-file-warnings2.s -o %t3.o
+# RUN: ld.lld -shared %t2.o -o %t.so
+
+# Check that a warning is emitted for entries in the file that are not present in any used input.
+# RUN: echo "missing" > %t-order-missing.txt
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-missing.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,MISSING
+
+# Check that the warning can be disabled.
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-missing.txt --unresolved-symbols=ignore-all --no-warn-symbol-ordering 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN --allow-empty
+
+# Check that the warning can be re-enabled
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-missing.txt --unresolved-symbols=ignore-all --no-warn-symbol-ordering --warn-symbol-ordering 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,MISSING
+
+# Check that a warning is emitted for undefined symbols.
+# RUN: echo "undefined" > %t-order-undef.txt
+# RUN: ld.lld %t1.o %t3.o -o %t --symbol-ordering-file %t-order-undef.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,UNDEFINED
+
+# Check that a warning is emitted for imported shared symbols.
+# RUN: echo "shared" > %t-order-shared.txt
+# RUN: ld.lld %t1.o %t.so -o %t --symbol-ordering-file %t-order-shared.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,SHARED
+
+# Check that a warning is emitted for absolute symbols.
+# RUN: echo "absolute" > %t-order-absolute.txt
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-absolute.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,ABSOLUTE
+
+# Check that a warning is emitted for symbols discarded due to --gc-sections.
+# RUN: echo "gc" > %t-order-gc.txt
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-gc.txt --gc-sections --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,GC
+
+# Check that a warning is emitted for symbols discarded due to a linker script /DISCARD/ section.
+# RUN: echo "discard" > %t-order-discard.txt
+# RUN: echo "SECTIONS { /DISCARD/ : { *(.text.discard) } }" > %t.script
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-discard.txt -T %t.script --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,DISCARD
+
+# Check that LLD does not warn for discarded COMDAT symbols, if they are present in the kept instance.
+# RUN: echo "comdat" > %t-order-comdat.txt
+# RUN: ld.lld %t1.o %t2.o -o %t --symbol-ordering-file %t-order-comdat.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN --allow-empty
+
+# Check that if a COMDAT was unused and discarded via --gc-sections, warn for each instance.
+# RUN: ld.lld %t1.o %t2.o -o %t --symbol-ordering-file %t-order-comdat.txt --gc-sections --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,COMDAT
+
+# Check that if a weak symbol is not kept, because of an equivalent global symbol, no warning is emitted.
+# RUN: echo "glob_or_wk" > %t-order-weak.txt
+# RUN: ld.lld %t1.o %t2.o -o %t --symbol-ordering-file %t-order-weak.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN --allow-empty
+
+# Check that symbols only in unused archive members result in a warning.
+# RUN: rm -f %t.a
+# RUN: llvm-ar rc %t.a %t3.o
+# RUN: ld.lld %t1.o %t.a -o %t --symbol-ordering-file %t-order-missing.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,MISSING --allow-empty
+
+# Check that a warning for each same-named symbol with an issue.
+# RUN: echo "multi" > %t-order-same-name.txt
+# RUN: ld.lld %t1.o %t2.o %t3.o -o %t --symbol-ordering-file %t-order-same-name.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,MULTI
+
+# Check that a warning is emitted if the same symbol is mentioned multiple times in the ordering file.
+# RUN: echo "_start" > %t-order-multiple-same.txt
+# RUN: echo "_start" >> %t-order-multiple-same.txt
+# RUN: ld.lld %t1.o -o %t --symbol-ordering-file %t-order-multiple-same.txt --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,SAMESYM
+
+# Check that all warnings can be emitted from the same input.
+# RUN: echo "missing_sym" > %t-order-multi.txt
+# RUN: echo "undefined" >> %t-order-multi.txt
+# RUN: echo "_start" >> %t-order-multi.txt
+# RUN: echo "shared" >> %t-order-multi.txt
+# RUN: echo "absolute" >> %t-order-multi.txt
+# RUN: echo "gc" >> %t-order-multi.txt
+# RUN: echo "discard" >> %t-order-multi.txt
+# RUN: echo "_start" >> %t-order-multi.txt
+# RUN: ld.lld %t1.o %t3.o %t.so -o %t --symbol-ordering-file %t-order-multi.txt --gc-sections -T %t.script --unresolved-symbols=ignore-all 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN,SAMESYM,ABSOLUTE,SHARED,UNDEFINED,GC,DISCARD,MISSING2
+
+# WARN-NOT:    warning:
+# SAMESYM:     warning: {{.*}}.txt: duplicate ordered symbol: _start
+# WARN-NOT:    warning:
+# ABSOLUTE:    warning: {{.*}}1.o: unable to order absolute symbol: absolute
+# WARN-NOT:    warning:
+# DISCARD:     warning: {{.*}}1.o: unable to order discarded symbol: discard
+# WARN-NOT:    warning:
+# GC:          warning: {{.*}}1.o: unable to order discarded symbol: gc
+# WARN-NOT:    warning:
+# SHARED:      warning: {{.*}}1.o: unable to order shared symbol: shared
+# WARN-NOT:    warning:
+# UNDEFINED:   warning: {{.*}}3.o: unable to order undefined symbol: undefined
+# WARN-NOT:    warning:
+# MISSING:     warning: symbol ordering file: no such symbol: missing
+# MISSING2:    warning: symbol ordering file: no such symbol: missing_sym
+# COMDAT:      warning: {{.*}}1.o: unable to order discarded symbol: comdat
+# COMDAT-NEXT: warning: {{.*}}2.o: unable to order discarded symbol: comdat
+# MULTI:       warning: {{.*}}2.o: unable to order absolute symbol: multi
+# MULTI-NEXT:  warning: {{.*}}3.o: unable to order undefined symbol: multi
+# WARN-NOT:    warning:
+
+absolute = 0x1234
+
+.section .text.gc,"ax",@progbits
+.global gc
+gc:
+  nop
+
+.section .text.discard,"ax",@progbits
+.global discard
+discard:
+  nop
+
+.section .text.comdat,"axG",@progbits,comdat,comdat
+.weak comdat
+comdat:
+  nop
+
+.section .text.glob_or_wk,"ax",@progbits
+.weak glob_or_wk
+glob_or_wk:
+  nop
+
+.text
+.global _start
+_start:
+  movq  %rax, absolute
+  callq shared
+
+# This is a "good" instance of the symbol
+multi:
+  nop