[ELF] - Implement filter library support (-F / --filter)

[grimar]

Summary

This is PR33766.

-F name
--filter=name
When creating an ELF shared object, set the internal DT_FILTER field to the specified name. This tells the dynamic linker that the symbol table of the shared object which is being created should be used as a filter on the symbol table of the shared object name.

If you later link a program against this filter object, then, when you run the program, the dynamic linker will see the DT_FILTER field. The dynamic linker will resolve symbols according to the symbol table of the filter object as usual, but it will actually link to the definitions found in the shared object name. Thus the filter object can be used to select a subset of the symbols provided by the object name.
(https://linux.die.net/man/1/ld).

Shared Objects as Filters:
https://docs.oracle.com/cd/E19683-01/817-3677/chapter4-31738/index.html

[emaste]

I believe -F / --filter can be used multiple times, as with -f.

[grimar]

• Allow multiple standart filters.

(Behavior is inconsistent with GNU linkers/spec, but matches to what Oracle spec says).

[ruiu]

I don't think merging AuxiliaryList with FilterList is a good idea. Can you represent them as two separate vectors?

[grimar]

In D35352#808107, @ruiu wrote:

I don't think merging AuxiliaryList with FilterList is a good idea. Can you represent them as two separate vectors?

I can do that change tomorrow, though I can't say I would prefer splitting them.
This filters are very close: https://docs.oracle.com/cd/E19683-01/817-3677/chapter4-31738/index.html,
they have different behavior policies, but the same nature.

[ruiu]

The similarity in semantics doesn't imply that they should be represented as one unified list in code. It looks like representing them as plain StringRef vectors is more straightforward.

[grimar]

In D35352#808142, @ruiu wrote:

It looks like representing them as plain StringRef vectors is more straightforward.

That's probably true. I'll do that change.

[grimar]

• Addressed review comments.

[ruiu]

LGTM

[emaste]

This LGTM.

test/ELF/as-needed-no-reloc.s

19

Presumably these get committed with the llvm-readobj change

[emaste]

I've successfully tested this change imported into my FreeBSD work branch
https://github.com/emaste/freebsd/commit/12f8c0fd362c128c03acc9689c76d8c5d5c69dbe

[emaste]

One note, the ordering of the value tags differs wrt GNU ld. It shouldn't matter, just something I noticed.

GNU ld.bfd 2.17.50

  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.7]
 0x000000000000000e (SONAME)             Library soname: [libdl.so.1]
 0x000000007fffffff (FILTER)             Filter library: [libc.so.7]
 0x000000000000000c (INIT)               0x738
 0x000000000000000d (FINI)               0xa48
 0x0000000000000004 (HASH)               0x158
...

Patched lld

  Tag        Type                         Name/Value
 0x000000007fffffff (FILTER)             Filter library: [libc.so.7]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.7]
 0x000000000000000e (SONAME)             Library soname: [libdl.so.1]
 0x0000000000000007 (RELA)               0x6c0
 0x0000000000000008 (RELASZ)             96 (bytes)
...

(I originally put this comment on D35351 by accident.)

ELF/Config.h

struct Configuration {
   llvm::StringRef OptRemarksFilename;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   llvm::StringRef ThinLTOCacheDir;
   std::string Rpath;
   std::vector<VersionDefinition> VersionDefinitions;
   std::vector<llvm::StringRef> Argv;
   std::vector<llvm::StringRef> AuxiliaryList;
+  std::vector<llvm::StringRef> FilterList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> SymbolOrderingFile;
   std::vector<llvm::StringRef> Undefined;
   std::vector<SymbolVersion> VersionScriptGlobals;
   std::vector<SymbolVersion> VersionScriptLocals;
   std::vector<uint8_t> BuildIdVector;
   llvm::MapVector<Symbol *, RenamedSymbol> RenamedSymbols;
   bool AllowMultipleDefinition;

ELF/Driver.cpp

static void checkOptions(opt::InputArgList &Args) {
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
   // table which is a relatively new feature.
   if (Config->EMachine == EM_MIPS && Config->GnuHash)
     error("the .gnu.hash section is not compatible with the MIPS target.");
 
   if (Config->Pie && Config->Shared)
     error("-shared and -pie may not be used together");
 
+  if (!Config->Shared && !Config->FilterList.empty())
+    error("-F may not be used without -shared");
+
   if (!Config->Shared && !Config->AuxiliaryList.empty())
     error("-f may not be used without -shared");
 
   if (Config->Relocatable) {
     if (Config->Shared)
       error("-r and -shared may not be used together");
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->Entry = Args.getLastArgValue(OPT_entry);
   Config->ExportDynamic =
       getArg(Args, OPT_export_dynamic, OPT_no_export_dynamic, false);
   Config->FatalWarnings =
       getArg(Args, OPT_fatal_warnings, OPT_no_fatal_warnings, false);
+  Config->FilterList = getArgs(Args, OPT_filter);
   Config->Fini = Args.getLastArgValue(OPT_fini, "_fini");
   Config->GcSections = getArg(Args, OPT_gc_sections, OPT_no_gc_sections, false);
   Config->GdbIndex = Args.hasArg(OPT_gdb_index);
   Config->ICF = Args.hasArg(OPT_icf);
   Config->Init = Args.getLastArgValue(OPT_init, "_init");
   Config->LTOAAPipeline = Args.getLastArgValue(OPT_lto_aa_pipeline);
   Config->LTONewPmPasses = Args.getLastArgValue(OPT_lto_newpm_passes);
   Config->LTOO = getInteger(Args, OPT_lto_O, 2);

ELF/Options.td

def export_dynamic: F<"export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;
 
 def export_dynamic_symbol: S<"export-dynamic-symbol">,
   HelpText<"Put a symbol in the dynamic symbol table">;
 
 def fatal_warnings: F<"fatal-warnings">,
   HelpText<"Treat warnings as errors">;
 
+def filter: J<"filter=">, HelpText<"Set DT_FILTER field to the specified name">;
+
 def fini: S<"fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
 def full_shutdown : F<"full-shutdown">,
   HelpText<"Perform a full shutdown instead of calling _exit">;
 
 def format: J<"format=">, MetaVarName<"<input-format>">,
   HelpText<"Change the input format of the inputs following this option">;

 def alias_emit_relocs: Flag<["-"], "q">, Alias<emit_relocs>;
 def alias_entry_e: JoinedOrSeparate<["-"], "e">, Alias<entry>;
 def alias_entry_entry: J<"entry=">, Alias<entry>;
 def alias_error_limit: J<"error-limit=">, Alias<error_limit>;
 def alias_exclude_libs: J<"exclude-libs=">, Alias<exclude_libs>;
 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_filter: Separate<["-"], "F">, Alias<filter>;
 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_Map_eq: J<"Map=">, Alias<Map>;
 def alias_omagic: Flag<["-"], "N">, Alias<omagic>;
 def alias_o_output: Joined<["--"], "output=">, Alias<o>;

ELF/SyntheticSections.cpp

DynamicSection<ELFT>::DynamicSection()
   addEntries();
 }
 
 // There are some dynamic entries that don't depend on other sections.
 // Such entries can be set early.
 template <class ELFT> void DynamicSection<ELFT>::addEntries() {
   // Add strings to .dynstr early so that .dynstr's size will be
   // fixed early.
+  for (StringRef S : Config->FilterList)
+    add({DT_FILTER, InX::DynStrTab->addString(S)});
   for (StringRef S : Config->AuxiliaryList)
     add({DT_AUXILIARY, InX::DynStrTab->addString(S)});
   if (!Config->Rpath.empty())
     add({Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
          InX::DynStrTab->addString(Config->Rpath)});
   for (SharedFile<ELFT> *F : Symtab<ELFT>::X->getSharedFiles())
     if (F->isNeeded())
       add({DT_NEEDED, InX::DynStrTab->addString(F->SoName)});

test/ELF/as-needed-no-reloc.s

 # CHECK:      Name: bar
 # CHECK-NEXT: Value: 0x0
 # CHECK-NEXT: Size: 0
 # CHECK-NEXT: Binding: Global
 # CHECK-NEXT: Type: Function
 # CHECK-NEXT: Other: 0
 # CHECK-NEXT: Section: Undefined
 
-# CHECK: NEEDED SharedLibrary ({{.*}}as-needed-no-reloc{{.*}}2.so)
+# CHECK: NEEDED Shared library: [{{.*}}as-needed-no-reloc{{.*}}2.so]
 
         .globl _start
 _start:
         .global bar

test/ELF/as-needed.s

 // RUN: echo "GROUP(\"%t2.so\" \"%t3.so\" \"%t4.so\")" > %t.script
 // RUN: ld.lld %t.o %t.script -o %t2
 // RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
 
 // RUN: echo "GROUP(AS_NEEDED(\"%t2.so\" \"%t3.so\" \"%t4.so\"))" > %t.script
 // RUN: ld.lld %t.o %t.script -o %t2
 // RUN: llvm-readobj -dynamic-table %t2 | FileCheck -check-prefix=CHECK2 %s
 
-// CHECK: NEEDED SharedLibrary (shared1)
-// CHECK: NEEDED SharedLibrary (shared2)
-// CHECK: NEEDED SharedLibrary (shared3)
-
-// CHECK2:     NEEDED SharedLibrary (shared1)
-// CHECK2-NOT: NEEDED SharedLibrary (shared2)
-// CHECK2-NOT: NEEDED SharedLibrary (shared3)
+// CHECK: NEEDED Shared library: [shared1]
+// CHECK: NEEDED Shared library: [shared2]
+// CHECK: NEEDED Shared library: [shared3]
+
+// CHECK2:     NEEDED Shared library: [shared1]
+// CHECK2-NOT: NEEDED Shared library: [shared2]
+// CHECK2-NOT: NEEDED Shared library: [shared3]
 
 .global _start
 _start:
 .data
 .long bar
 .long zed
 .weak baz
   call baz

test/ELF/dynamic-reloc.s

 // CHECK-NEXT:       Symbol: bar
 // CHECK-NEXT:       Addend: 0x0
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK: DynamicSection [
 // CHECK-NEXT:  Tag                Type                 Name/Value
-// CHECK-NEXT:  0x0000000000000001 NEEDED               SharedLibrary ({{.*}}2.so)
+// CHECK-NEXT:  0x0000000000000001 NEEDED               Shared library: [{{.*}}2.so]
 // CHECK-NEXT:  0x0000000000000015 DEBUG                0x0
 // CHECK-NEXT:  0x0000000000000017 JMPREL
 // CHECK-NEXT:  0x0000000000000002 PLTRELSZ             24 (bytes)
 // CHECK-NEXT:  0x0000000000000003 PLTGOT
 // CHECK-NEXT:  0x0000000000000014 PLTREL               RELA
 // CHECK-NEXT:  0x0000000000000006 SYMTAB
 // CHECK-NEXT:  0x000000000000000B SYMENT               24 (bytes)
 // CHECK-NEXT:  0x0000000000000005 STRTAB

test/ELF/filter.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: ld.lld %t.o -shared -F foo.so -F boo.so -o %t1
+# RUN: llvm-readobj --dynamic-table %t1 | FileCheck %s
+
+# Test alias.
+# RUN: ld.lld %t.o -shared --filter=foo.so --filter=boo.so -o %t2
+# RUN: llvm-readobj --dynamic-table %t2 | FileCheck %s
+
+# CHECK:      DynamicSection [
+# CHECK-NEXT: Tag                Type          Name/Value
+# CHECK-NEXT: 0x000000007FFFFFFF FILTER        Filter library: [foo.so]
+# CHECK-NEXT: 0x000000007FFFFFFF FILTER        Filter library: [boo.so]
+
+# RUN: not ld.lld %t.o -F x -o %t 2>&1 | FileCheck -check-prefix=ERR %s
+# ERR: -F may not be used without -shared

test/ELF/gc-sections-shared.s

 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding: Global
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section: .text
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
-# CHECK: NEEDED SharedLibrary ({{.*}}.so)
+# CHECK: NEEDED Shared library: [{{.*}}.so]
 
 .section .text.foo, "ax"
 .globl foo
 foo:
 call bar
 
 .section .text.bar, "ax"
 .globl bar

test/ELF/no-soname.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: mkdir -p %T/no-soname
 // RUN: ld.lld %t.o -shared -o %T/no-soname/libfoo.so
 
 // RUN: ld.lld %t.o %T/no-soname/libfoo.so -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s
 
-// CHECK:  0x0000000000000001 NEEDED               SharedLibrary ({{.*}}/no-soname/libfoo.so)
+// CHECK:  0x0000000000000001 NEEDED               Shared library: [{{.*}}/no-soname/libfoo.so]
 // CHECK-NOT: NEEDED
 
 // RUN: ld.lld %t.o %T/no-soname/../no-soname/libfoo.so -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s --check-prefix=CHECK2
 
-// CHECK2:  0x0000000000000001 NEEDED               SharedLibrary ({{.*}}/no-soname/../no-soname/libfoo.so)
+// CHECK2:  0x0000000000000001 NEEDED               Shared library: [{{.*}}/no-soname/../no-soname/libfoo.so]
 // CHECK2-NOT: NEEDED
 
 // RUN: ld.lld %t.o -L%T/no-soname/../no-soname -lfoo -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s --check-prefix=CHECK3
 
-// CHECK3:  0x0000000000000001 NEEDED               SharedLibrary (libfoo.so)
+// CHECK3:  0x0000000000000001 NEEDED               Shared library: [libfoo.so]
 // CHECK3-NOT: NEEDED
 
 // RUN: ld.lld %t.o -shared -soname libbar.so -o %T/no-soname/libbar.so
 // RUN: ld.lld %t.o %T/no-soname/libbar.so -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s --check-prefix=CHECK4
 
-// CHECK4:  0x0000000000000001 NEEDED               SharedLibrary (libbar.so)
+// CHECK4:  0x0000000000000001 NEEDED               Shared library: [libbar.so]
 // CHECK4-NOT: NEEDED
 
 .global _start
 _start:

test/ELF/shared-be.s

 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize: [[RELENT:.*]]
 
 // CHECK:      DynamicSection [
 // CHECK-NEXT:   Tag                Type                 Name/Value
 // CHECK-NEXT:   0x000000000000001D RUNPATH              foo:bar
-// CHECK-NEXT:   0x0000000000000001 NEEDED               SharedLibrary ({{.*}}2.so)
+// CHECK-NEXT:   0x0000000000000001 NEEDED               Shared library: [{{.*}}2.so]
 // CHECK-NEXT:   0x0000000000000015 DEBUG                0x0
 // CHECK-NEXT:   0x0000000000000007 RELA                 [[RELADDR]]
 // CHECK-NEXT:   0x0000000000000008 RELASZ               [[RELSIZE]] (bytes)
 // CHECK-NEXT:   0x0000000000000009 RELAENT              [[RELENT]] (bytes)
 // CHECK:        0x0000000000000000 NULL                 0x0
 // CHECK-NEXT: ]
 
 .global _start
 _start:
 .data
 .long bar
 .long zed
 

test/ELF/shared.s

 // DONT_EXPORT-NEXT:     Other: 0
 // DONT_EXPORT-NEXT:     Section: Undefined
 // DONT_EXPORT-NEXT:   }
 // DONT_EXPORT-NEXT: ]
 
 // CHECK:      DynamicSection [
 // CHECK-NEXT:   Tag        Type                 Name/Value
 // CHECK-NEXT:   0x0000001D RUNPATH              foo:bar
-// CHECK-NEXT:   0x00000001 NEEDED               SharedLibrary ({{.*}}2.so)
+// CHECK-NEXT:   0x00000001 NEEDED               Shared library: [{{.*}}2.so]
 // CHECK-NEXT:   0x00000015 DEBUG                0x0
 // CHECK-NEXT:   0x00000011 REL                  [[RELADDR]]
 // CHECK-NEXT:   0x00000012 RELSZ                [[RELSIZE]] (bytes)
 // CHECK-NEXT:   0x00000013 RELENT               [[RELENT]] (bytes)
 // CHECK-NEXT:   0x00000006 SYMTAB               [[DYNSYMADDR]]
 // CHECK-NEXT:   0x0000000B SYMENT               [[SYMENT]] (bytes)
 // CHECK-NEXT:   0x00000005 STRTAB               [[DYNSTRADDR]]
 // CHECK-NEXT:   0x0000000A STRSZ

test/ELF/soname.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -shared -soname=bar -o %t.so
 // RUN: ld.lld %t.o -shared --soname=bar -o %t2.so
 // RUN: ld.lld %t.o %t.so %t2.so -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s
 
-// CHECK:  0x0000000000000001 NEEDED               SharedLibrary (bar)
+// CHECK:  0x0000000000000001 NEEDED               Shared library: [bar]
 // CHECK-NOT: NEEDED
 
 .global _start
 _start:

test/ELF/soname2.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -shared -soname=foo.so -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s
 
-// CHECK: 0x000000000000000E SONAME  LibrarySoname (foo.so)
+// CHECK: 0x000000000000000E SONAME  Library soname: [foo.so]
 
 .global _start
 _start: