[ELF] Don't warn on undefined symbols if UnresolvedPolicy::Ignore is used

[MaskRay]

Summary

Add a condition UnresolvedPolicy::Ignore to elf::warnUnorderedSymbol to suppress Sym->isUndefined() warnings from both

1. --symbol-ordering-file=
2. .llvm.call-graph-profile

If --unresolved-symbols=ignore-all is used,

no "undefined symbol" error/warning is emitted. It makes sense to not warn unorderable symbols.

Otherwise,

If an executable is linked, the default policy UnresolvedPolicy::ErrorOrWarn will issue a "undefined symbol" error. The unorderable symbol warning is redundant.

If a shared object is linked, it is possible that only part of object files are used and some symbols are left undefined. The warning is not very necessary.
  In particular for .llvm.call-graph-profile, when linking a shared object, a call graph profile may contain undefined symbols. This case generated a warning before but it will be suppressed by this patch.

[ruiu]

You should skip an undefined symbol if it is created from a DSO, no? Looks like just skipping all undefined symbols there also suppresses legitimate warnings.

[MaskRay]

Use UnresolvedPolicy::Ignore

[MaskRay]

.

[ruiu]

Does that make sense? I still feel like ignoring undefined symbols spoils the point of calling that function in the first place.

[davidxl]

What is the intended use of such warnings?

[MaskRay]

In D53044#1259572, @ruiu wrote:

Does that make sense? I still feel like ignoring undefined symbols spoils the point of calling that function in the first place.

Do you think that when linking a shared object, users should specify --no-warn-symbol-ordering to suppress the unable to order undefined symbol: warning?

[MaskRay]

elf::warnUnorderableSymbol(const Symbol *Sym) is used in 1) reading call graph profile sections 2) --symbol-ordering-file=

FWIW, ld.bfd just ignores undefined symbols with --symbol-ordering-file=. I don't like that behavior and I think lld is right to give some warnings as it currently does. But regarding call graph profile, when linking a shared object with some undefined symbols, I feel the UnresolvedPolicy::Ignore mechanism (--shared implies Ignore) can be reused to suppress such warnings.

[ruiu]

I don't think I understand the point of this patch. You can't reorder undefined symbols, so why does CG-profile section contains undefined symbol in the first place?

[MaskRay]

In D53044#1259600, @ruiu wrote:

I don't think I understand the point of this patch. You can't reorder undefined symbols, so why does CG-profile section contains undefined symbol in the first place?

My understanding is that if you link an executable, all .cg_profile symbols should be defined. However, with -shared, it is possible that only partial object files are linked and some symbols are left undefined. By separating From and To symbols into different modules, the .cg_profile From, To, count directives are essentially rendered useless, but I feel this is intended and no warnings should be given.

[ruiu]

It needs to be explained. I couldn't get it just by reading two lines of code.

[MaskRay]

Add comment why we use

if (!Sym->isUndefined() ||
    Config->UnresolvedSymbols != UnresolvedPolicy::Ignore)

[grimar]

ELF/Driver.cpp

689 ↗

(On Diff #168895)

It reads strangely: "If a symbol is not undefined (or ...) then warnUnorderableSymbol"
Makes think that we reporting a warning for defined symbols.

I think if that check should be made it should be inside the warnUnorderableSymbol

Also, should it check the if (Config->Shared) condition at some point?

[MaskRay]

ELF/Driver.cpp

689 ↗

(On Diff #168895)

I think if that check should be made it should be inside the warnUnorderableSymbol

Then this option will also affect --symbol-ordering-file= (ld.bfd implements this option but gold doesn't. ld.bfd does not warn undefined symbols.). I think this also seems fine.

Config->Shared

Checking UnresolvedPolicy::Ignore looks good enough as this is also a symbol resolution process.

[MaskRay]

Lower UnresolvedPolicy check to warnUnorderableSymbol

[MaskRay]

.

[MaskRay]

After thinking it over, I decide to sink the UnresolvedPolicy::Ignore condition to elf::warnUnorderedSymbol to suppress Sym->isUndefined() warnings from both 1) --symbol-ordering-file= and 2) .llvm.call-graph-profile

The test symbol-ordering-file-warnings.s uses --unresolved-symbols=ignore-all to check warnings of Sym->isUndefined(). But I think it makes more sense to just don't warn the unorderable symbol case, as the error: undefined symbol: $symbol error/warning is also suppressed. If the symbol does not exist, users will still see warning: symbol ordering file: no such symbol: $symbol. This change does not make the status worse.

[MaskRay]

Reword the comment

[ruiu]

ELF/Symbols.cpp

280–288 ↗

(On Diff #169072)

Please do not change this -- this code was written in the way it is to reduce indentation depth.

[MaskRay]

ELF/Symbols.cpp

280–288 ↗

(On Diff #169072)

Should I use if (Sym->isUndefined() && Config->UnresolvedSymbols != UnresolvedPolicy::Ignore) then?

I actually find dispatching by SymbolKind first makes the code a bit easier to understand:

• Undefined
• Shared
• Others (Defined)

For the Defined case, fine-grained conditions are checked for absolute/syunthetic/discarded.

I lean to this style but if you have strong opinion on this, I can change it.

[ruiu]

ELF/Symbols.cpp

280–288 ↗

(On Diff #169072)

Yeah, maybe you should write that if at the beginning of this function to exit early.

[MaskRay]

ELF/Symbols.cpp

280–288 ↗

(On Diff #169072)

But that way:

  if (Sym->isUndefined() && Config->UnresolvedSymbols != UnresolvedPolicy::Ignore)
    Warn(": unable to order undefined symbol: ");
  else if (Sym->isShared())
    Warn(": unable to order undefined symbol: ");
  else if (Sym->isShared())
    Warn(": unable to order shared symbol: ");
////// Sym->isUndefined() is possible here
  else if (D && !D->Section)
    Warn(": unable to order absolute symbol: ");
  else if (D && isa<OutputSection>(D->Section))
    Warn(": unable to order synthetic symbol: ");
  else if (D && !D->Section->Repl->Live)
    Warn(": unable to order discarded symbol: ");

Will that cause a problem?

[MaskRay]

ELF/Symbols.cpp

280–288 ↗

(On Diff #169072)

Sorry I misread your words. I think you mean:

void elf::warnUnorderableSymbol(const Symbol *Sym) {
  if (!Config->WarnSymbolOrdering ||
      Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
    return;

But this way UnresolvedPolicy::Ignore also changes how Shared Defined symbols are interpreted. UnresolvedPolicy::Ignore is also used otherwhere, but only related to how undefined symbols are interpreted.

[ruiu]

ELF/Symbols.cpp

280–288 ↗

(On Diff #169072)

I mean you can exit early if Sym->isUndefined() && Config->UnresolvedSymbols != UnresolvedPolicy::Ignore, can't you?

[MaskRay]

Use early exit

if (!Config->WarnSymbolOrdering ||
    (Sym->isUndefined() &&
     Config->UnresolvedSymbols == UnresolvedPolicy::Ignore))

[ruiu]

ELF/Symbols.cpp

268–271 ↗

(On Diff #169114)

It's a nit, but I wouldn't merge the two conditions to make it look nicer.

if (!Config->WarnSymbolOrdering)
  return;

// comment
if (Sym->isUndefined() && ...)
  return;

The first condition is obvious, and it is better not to mix it with some more complicated condition, which needs a comment.

[MaskRay]

Use ruiu's preferred early-exit style

[MaskRay]

.

[ruiu]

ELF/Symbols.cpp

284 ↗

(On Diff #169116)

This is not related.

[MaskRay]

ELF/Symbols.cpp

284 ↗

(On Diff #169116)

I just made a change while you were commenting..

[ruiu]

LGTM

lld/trunk/ELF/Symbols.cpp

void elf::printTraceSymbol(Symbol *Sym) {
 
   message(toString(Sym->File) + S + Sym->getName());
 }
 
 void elf::warnUnorderableSymbol(const Symbol *Sym) {
   if (!Config->WarnSymbolOrdering)
     return;
 
+  // If UnresolvedPolicy::Ignore is used, no "undefined symbol" error/warning
+  // is emitted. It makes sense to not warn on undefined symbols.
+  //
+  // Note, ld.bfd --symbol-ordering-file= does not warn on undefined symbols,
+  // but we don't have to be compatible here.
+  if (Sym->isUndefined() &&
+      Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
+    return;
+
   const InputFile *File = Sym->File;
   auto *D = dyn_cast<Defined>(Sym);
 
   auto Warn = [&](StringRef S) { warn(toString(File) + S + Sym->getName()); };
 
   if (Sym->isUndefined())
     Warn(": unable to order undefined symbol: ");
   else if (Sym->isShared())

lld/trunk/test/ELF/cgprofile-shared-warn.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld --shared %t.o -o /dev/null 2>&1 | count 0
+# RUN: ld.lld -e A --unresolved-symbols=ignore-all %t.o -o /dev/null 2>&1 | count 0
+    .section    .text.A,"ax",@progbits
+    .globl  A
+A:
+    callq B
+
+    .cg_profile A, B, 10

lld/trunk/test/ELF/symbol-ordering-file-warnings.s

 # RUN:   --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 \
 # RUN:   --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 \
-# RUN:   --unresolved-symbols=ignore-all 2>&1 | 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 \
 # RUN:   --unresolved-symbols=ignore-all 2>&1 | 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 \

 # 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 "_GLOBAL_OFFSET_TABLE_" >> %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 \
-# RUN:   --unresolved-symbols=ignore-all 2>&1 | FileCheck %s --check-prefixes=WARN,SAMESYM,ABSOLUTE,SHARED,UNDEFINED,GC,DISCARD,MISSING2,SYNTHETIC
+# RUN:   2>&1 | FileCheck %s --check-prefixes=WARN,SAMESYM,ABSOLUTE,SHARED,UNDEFINED,GC,DISCARD,MISSING2,SYNTHETIC
 
 # WARN-NOT:    warning:
 # SAMESYM:     warning: {{.*}}.txt: duplicate ordered symbol: _start
 # WARN-NOT:    warning:
 # SYNTHETIC:   warning: <internal>: unable to order synthetic symbol: _GLOBAL_OFFSET_TABLE_
 # 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: {{.*}}.so: unable to order shared symbol: shared
 # WARN-NOT:    warning:
 # UNDEFINED:   warning: {{.*}}3.o: unable to order undefined symbol: undefined
 # WARN-NOT:    warning:
 # ABSOLUTE:    warning: {{.*}}1.o: unable to order absolute symbol: absolute
 # WARN-NOT:    warning:
 # MISSING:     warning: symbol ordering file: no such symbol: missing
+# WARN-NOT:    warning:
 # MISSING2:    warning: symbol ordering file: no such symbol: missing_sym
+# WARN-NOT:    warning:
 # COMDAT:      warning: {{.*}}1.o: unable to order discarded symbol: comdat
-# MULTI:       warning: {{.*}}3.o: unable to order undefined symbol: multi
-# MULTI-NEXT:  warning: {{.*}}2.o: unable to order absolute symbol: multi
+# WARN-NOT:    warning:
+# MULTI:       warning: {{.*}}2.o: unable to order absolute symbol: multi
 # WARN-NOT:    warning:
 
 absolute = 0x1234
 
 .section .text.gc,"ax",@progbits
 .global gc
 gc:
   nop