[ELF] - Linkerscript: report orphans if --verbose used.

[grimar]

Summary

Reviewing ld command line I found interesting option that seems to be usefull to have:
(https://sourceware.org/binutils/docs/ld/Options.html#Options)
--orphan-handling

But we decided not to support it for now,
therefore latest diff just reports orphans if --verbose used.

[emaste]

Nice, thanks for this discovery! I hadn't seen it before because FreeBSD's base system ld is too old and doesn't have the option :(

ELF/Options.td

142–144

Should also support --orphan-handling MODE I believe.

[grimar]

In D24725#546261, @emaste wrote:

Nice, thanks for this discovery! I hadn't seen it before because FreeBSD's base system ld is too old and doesn't have the option :(

btw gold does not support it, at least one that I have.

[davide]

I think "error" is good and definitely would've helped catching bugs while we were bringing the FreeBSD kernel up&running with lld.
"discard" seems like a dangerous semantic, at least to me, so I'd like to not implement it, at least for now. Do you have a real use case when it's ok to drop input sections if there's no room to place them in the output?

[davide]

I think "error" is good and definitely would've helped catching bugs while we were bringing the FreeBSD kernel up&running with lld.
"discard" seems like a dangerous semantic, at least to me, so I'd like to not implement it, at least for now. Do you have a real use case when it's ok to drop input sections if there's no room to place them in the output?

[grimar]

In D24725#546280, @davide wrote:

I think "error" is good and definitely would've helped catching bugs while we were bringing the FreeBSD kernel up&running with lld.
"discard" seems like a dangerous semantic, at least to me, so I'd like to not implement it, at least for now. Do you have a real use case when it's ok to drop input sections if there's no room to place them in the output?

I think it is not about case when "no room", but about all orphans if any. We can remove discard mode, I do not know if it is useful or not, just implemented all what ld has.

[davide]

In D24725#546282, @grimar wrote:

In D24725#546280, @davide wrote:

I think "error" is good and definitely would've helped catching bugs while we were bringing the FreeBSD kernel up&running with lld.
"discard" seems like a dangerous semantic, at least to me, so I'd like to not implement it, at least for now. Do you have a real use case when it's ok to drop input sections if there's no room to place them in the output?

I think it is not about case when "no room", but about all orphans if any. We can remove discard mode, I do not know if it is useful or not, just implemented all what ld has.

Even worse. I think that discarding input sections tout court is very dangerous and I'm not exactly happy supporting it.

[ruiu]

Obligatory question: do we want it? I've never seen a project that uses this option.

[grimar]

In D24725#546997, @ruiu wrote:

Obligatory question: do we want it? I've never seen a project that uses this option.

That is probably the only way for users to clean up their scripts and include orphans explicitly ?
They might want it at least because we may have different heuristic for placing orphans
(currently without possible D23352 we even do not have it at all, and just placing them to the end).

[grimar]

• Removed support for "discard"
• Added "--orphan-handling MODE" form support.

[grimar]

• As was duscussed in llvm maillist, just report orphans if --verbose used.

[• rafael]

Does bfd consider linker created sections to be orphans? For example, will it warn if the script doesn't mention .dynsym?

[grimar]

In D24725#551207, @rafael wrote:

Does bfd consider linker created sections to be orphans? For example, will it warn if the script doesn't mention .dynsym?

Yes, it is. Patch needs update to handle this case then.

[grimar]

• Updated patch to let it report linker generated orphan sections just like ld do.

[• rafael]

This now always talks about output sections.

We should also note if an input section is not placed in any output. For example, given

SECTIONS
{

foo : { *(bar) }

}

and a .o with sections foo and and bar we should warn about the *input* section foo being an orphan. The idea is to warn anytime the linker has to guess where to put the input or output section.

[grimar]

Too much outdated.

ELF/Config.h

 };
 
 // For --build-id.
 enum class BuildIdKind { None, Fast, Md5, Sha1, Hexstring, Uuid };
 
 // For --discard-{all,locals,none}.
 enum class DiscardPolicy { Default, All, Locals, None };
 
+// For --orphan-handling.
+enum class OrphanHandlingPolicy { Place, Warn, Error };
+
 // For --strip-{all,debug}.
 enum class StripPolicy { None, All, Debug };
 
 // For --unresolved-symbols.
 enum class UnresolvedPolicy { NoUndef, ReportError, Warn, Ignore };
 
 // For --sort-section and linkerscript sorting rules.
 enum class SortSectionPolicy { Default, None, Alignment, Name, Priority };
struct Configuration {
   bool WarnCommon;
   bool ZCombreloc;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   DiscardPolicy Discard;
+  OrphanHandlingPolicy OrphanHandling;
   SortSectionPolicy SortSection;
   StripPolicy Strip = StripPolicy::None;
   UnresolvedPolicy UnresolvedSymbols;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t EntryAddr = 0;

ELF/Driver.cpp

if (auto *Arg = Args.getLastArg(OPT_Ttext))
     Ret[".text"] = parseSectionAddress(Arg->getValue(), Arg);
   if (auto *Arg = Args.getLastArg(OPT_Tdata))
     Ret[".data"] = parseSectionAddress(Arg->getValue(), Arg);
   if (auto *Arg = Args.getLastArg(OPT_Tbss))
     Ret[".bss"] = parseSectionAddress(Arg->getValue(), Arg);
   return Ret;
 }
 
+static OrphanHandlingPolicy getOrphanHandling(opt::InputArgList &Args) {
+  StringRef S = getString(Args, OPT_orphan_handling);
+  if (S == "warn")
+    return OrphanHandlingPolicy::Warn;
+  if (S == "error")
+    return OrphanHandlingPolicy::Error;
+  if (!S.empty() && S != "place")
+    error("unknown --orphan-handling mode: " + S);
+  return OrphanHandlingPolicy::Place;
+}
+
 static SortSectionPolicy getSortKind(opt::InputArgList &Args) {
   StringRef S = getString(Args, OPT_sort_section);
   if (S == "alignment")
     return SortSectionPolicy::Alignment;
   if (S == "name")
     return SortSectionPolicy::Name;
   if (!S.empty())
     error("unknown --sort-section rule: " + S);
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_auxiliary))
     Config->AuxiliaryList.push_back(Arg->getValue());
   if (!Config->Shared && !Config->AuxiliaryList.empty())
     error("-f may not be used without -shared");
 
   for (auto *Arg : Args.filtered(OPT_undefined))
     Config->Undefined.push_back(Arg->getValue());
 
+  Config->OrphanHandling = getOrphanHandling(Args);
+
   Config->SortSection = getSortKind(Args);
 
   Config->UnresolvedSymbols = getUnresolvedSymbolOption(Args);
 
   if (auto *Arg = Args.getLastArg(OPT_dynamic_list))
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       parseDynamicList(*Buffer);
 

ELF/LinkerScript.h

public:
   uint64_t getOutputSectionSize(StringRef Name) override;
   uint64_t getOutputSectionAlign(StringRef Name) override;
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(StringRef S) override;
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
 
 private:
+  void placeOrphans(OutputSectionFactory<ELFT> &Factory);
+
   void computeInputSections(InputSectionDescription *);
 
   void addSection(OutputSectionFactory<ELFT> &Factory,
                   InputSectionBase<ELFT> *Sec, StringRef Name);
   void discard(ArrayRef<InputSectionBase<ELFT> *> V);
 
   std::vector<InputSectionBase<ELFT> *>
   createInputSectionList(OutputSectionCommand &Cmd);

ELF/LinkerScript.cpp

if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       }
     }
   }
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
   processCommands(Factory);
-  // Add orphan sections.
-  for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
-    for (InputSectionBase<ELFT> *S : F->getSections())
-      if (!isDiscarded(S) && !S->OutSec)
+  placeOrphans(Factory);
+}
+
+template <class ELFT>
+void LinkerScript<ELFT>::placeOrphans(OutputSectionFactory<ELFT> &Factory) {
+  for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
+    for (InputSectionBase<ELFT> *S : F->getSections()) {
+      if (!isDiscarded(S) && !S->OutSec) {
         addSection(Factory, S, getOutputSectionName(S));
+        if (Config->OrphanHandling == OrphanHandlingPolicy::Place)
+          continue;
+
+        std::string Msg = "unplaced orphan section " + S->Name.str() +
+                          " from " + getFilename(F);
+        if (Config->OrphanHandling == OrphanHandlingPolicy::Warn)
+          warning(Msg);
+        else
+          error(Msg);
+      }
+    }
+  }
 }
 
 // Sets value of a section-defined symbol. Two kinds of
 // symbols are processed: synthetic symbols, whose value
 // is an offset from beginning of section and regular
 // symbols whose value is absolute.
 template <class ELFT>
 static void assignSectionSymbol(SymbolAssignment *Cmd,

ELF/Options.td

def no_undefined_version: F<"no-undefined-version">,
   HelpText<"Report version scripts that refer undefined symbols">;
 
 def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def oformat: Separate<["--"], "oformat">, MetaVarName<"<format>">,
   HelpText<"Specify the binary format for the output object file">;
 
+def orphan_handling: S<"orphan-handling">,
+  HelpText<"Control how orphan sections are handled">;
+
 def pie: F<"pie">, HelpText<"Create a position independent executable">;
 
 def print_gc_sections: F<"print-gc-sections">,
   HelpText<"List removed unused sections">;
 
 def reproduce: S<"reproduce">,
   HelpText<"Dump linker invocation and input files for debugging">;
 

 def alias_export_dynamic_E: Flag<["-"], "E">, Alias<export_dynamic>;
 def alias_export_dynamic_symbol: J<"export-dynamic-symbol=">,
   Alias<export_dynamic_symbol>;
 def alias_fini_fini: J<"fini=">, Alias<fini>;
 def alias_format_b: S<"b">, Alias<format>;
 def alias_hash_style_hash_style: J<"hash-style=">, Alias<hash_style>;
 def alias_init_init: J<"init=">, Alias<init>;
 def alias_l__library: J<"library=">, Alias<l>;
+def alias_orphan_handling: J<"orphan-handling=">, Alias<orphan_handling>;
 def alias_o_output: Joined<["--"], "output=">, Alias<o>;
 def alias_o_output2 : Separate<["--"], "output">, Alias<o>;
 def alias_pie_pic_executable: F<"pic-executable">, Alias<pie>;
 def alias_relocatable_r: Flag<["-"], "r">, Alias<relocatable>;
 def alias_rpath_R: Joined<["-"], "R">, Alias<rpath>;
 def alias_rpath_rpath: J<"rpath=">, Alias<rpath>;
 def alias_script_T: JoinedOrSeparate<["-"], "T">, Alias<script>;
 def alias_shared_Bshareable: F<"Bshareable">, Alias<shared>;

test/ELF/linkerscript/orphan-handling.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: echo "SECTIONS { .foo.1 : { *(.foo.1) } }" > %t.script
+
+# RUN: ld.lld -o %t.out --script %t.script %t
+# RUN: llvm-objdump -section-headers %t.out | FileCheck %s
+# RUN: ld.lld --orphan-handling=place -o %t2.out --script %t.script %t
+# RUN: llvm-objdump -section-headers %t2.out | FileCheck %s
+# CHECK: .foo.1
+# CHECK: .foo.2
+# CHECK: .foo.3
+
+# RUN: not ld.lld --orphan-handling=error -o %t4.out --script %t.script %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERROR
+# ERROR: unplaced orphan section .text from {{.*}}.o
+# ERROR: unplaced orphan section .foo.2 from {{.*}}.o
+# ERROR: unplaced orphan section .foo.3 from {{.*}}.o
+
+# RUN: not ld.lld --orphan-handling error -o %t4.out --script %t.script %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERROR
+
+# RUN: ld.lld --orphan-handling=warn -o %t5.out --script %t.script %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=WARN
+# WARN: unplaced orphan section .text from {{.*}}.o
+# WARN: unplaced orphan section .foo.2 from {{.*}}.o
+# WARN: unplaced orphan section .foo.3 from {{.*}}.o
+
+# RUN: ld.lld --orphan-handling warn -o %t5.out --script %t.script %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=WARN
+
+# RUN: not ld.lld --orphan-handling=foo -o %t5.out --script %t.script %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=UNKNOWN
+# UNKNOWN: unknown --orphan-handling mode: foo
+
+# RUN: not ld.lld --orphan-handling foo -o %t5.out --script %t.script %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=UNKNOWN
+
+.text
+.globl _start
+_start:
+
+.section .foo.1,"a"
+ .quad 1
+
+.section .foo.2,"a"
+ .quad 2
+
+.section .foo.3,"a"
+ .quad 3