[ELF] Add -Bsymbolic-non-weak

[smeenai]

Summary

This adds a new -Bsymbolic option that directly binds all non-weak
symbols. There's a couple of reasons motivating this:

• The new flag will match the default behavior on Mach-O, so you can get consistent behavior across platforms.
• We have use cases for which making weak data preemptible is useful, but we don't want to pessimize access to non-weak data. (For a large internal app, we measured 2000+ data symbols whose accesses would be unnecessarily pessimized by -Bsymbolic-functions.)

[MaskRay]

Glad to know see more adoption of the -Bsymbolic-non-weak* idea:) (https://maskray.me/blog/2021-05-16-elf-interposition-and-bsymbolic)

We have use cases for which making weak data preemptible is useful, but we don't want to pessimize access to non-weak data. (For a large internal app, we measured 2000+ data symbols whose accesses would be unnecessarily pessimized by -Bsymbolic-functions.)

The main problem is copy relocations, which is incompatible with making non-weak data non-preemptible.
Are you able to rule out all copy relocations (default ELF codegen for -fno-pic)?

[smeenai]

In D158322#4600532, @MaskRay wrote:

Glad to know see more adoption of the -Bsymbolic-non-weak* idea:) (https://maskray.me/blog/2021-05-16-elf-interposition-and-bsymbolic)

Yup :) It seems like the nicest solution for maintaining preemptibility in the small amount of cases which need it while not unnecessarily slowing down everything else.

We have use cases for which making weak data preemptible is useful, but we don't want to pessimize access to non-weak data. (For a large internal app, we measured 2000+ data symbols whose accesses would be unnecessarily pessimized by -Bsymbolic-functions.)

The main problem is copy relocations, which is incompatible with making non-weak data non-preemptible.
Are you able to rule out all copy relocations (default ELF codegen for -fno-pic)?

Thankfully yes, because we build everything as PIC/PIE (and IIRC modern Android versions require PIE).

[MaskRay]

Update docs/ld.lld.1 as well

[smeenai]

Update ld.lld.1

[smeenai]

In D158322#4601508, @MaskRay wrote:

Update docs/ld.lld.1 as well

How do you verify the output? I used groff -man -T html and the result looked reasonable, but also pretty different from things like https://man.archlinux.org/man/extra/lld/ld.lld.1.en, so I was wondering what people usually do.

[MaskRay]

In D158322#4602495, @smeenai wrote:

In D158322#4601508, @MaskRay wrote:

Update docs/ld.lld.1 as well

How do you verify the output? I used groff -man -T html and the result looked reasonable, but also pretty different from things like https://man.archlinux.org/man/extra/lld/ld.lld.1.en, so I was wondering what people usually do.

I just use man docs/ld.lld.1 and check whether it looks good...

[smeenai]

In D158322#4602497, @MaskRay wrote:

In D158322#4602495, @smeenai wrote:

In D158322#4601508, @MaskRay wrote:

Update docs/ld.lld.1 as well

How do you verify the output? I used groff -man -T html and the result looked reasonable, but also pretty different from things like https://man.archlinux.org/man/extra/lld/ld.lld.1.en, so I was wondering what people usually do.

I just use man docs/ld.lld.1 and check whether it looks good...

Ah, that's much simpler, thanks.

lld/ELF/Config.h

enum ELFKind : uint8_t {
   ELFNoneKind,
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
 // For -Bno-symbolic, -Bsymbolic-non-weak-functions, -Bsymbolic-functions,
-// -Bsymbolic.
-enum class BsymbolicKind { None, NonWeakFunctions, Functions, All };
+// -Bsymbolic-non-weak, -Bsymbolic.
+enum class BsymbolicKind { None, NonWeakFunctions, Functions, NonWeak, All };
 
 // 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 --icf={none,safe,all}.

lld/ELF/Driver.cpp

config->androidMemtagHeap =
       args.hasFlag(OPT_android_memtag_heap, OPT_no_android_memtag_heap, false);
   config->androidMemtagStack = args.hasFlag(OPT_android_memtag_stack,
                                             OPT_no_android_memtag_stack, false);
   config->fatLTOObjects =
       args.hasFlag(OPT_fat_lto_objects, OPT_no_fat_lto_objects, false);
   config->androidMemtagMode = getMemtagMode(args);
   config->auxiliaryList = args::getStrings(args, OPT_auxiliary);
   config->armBe8 = args.hasArg(OPT_be8);
-  if (opt::Arg *arg =
-          args.getLastArg(OPT_Bno_symbolic, OPT_Bsymbolic_non_weak_functions,
-                          OPT_Bsymbolic_functions, OPT_Bsymbolic)) {
+  if (opt::Arg *arg = args.getLastArg(
+          OPT_Bno_symbolic, OPT_Bsymbolic_non_weak_functions,
+          OPT_Bsymbolic_functions, OPT_Bsymbolic_non_weak, OPT_Bsymbolic)) {
     if (arg->getOption().matches(OPT_Bsymbolic_non_weak_functions))
       config->bsymbolic = BsymbolicKind::NonWeakFunctions;
     else if (arg->getOption().matches(OPT_Bsymbolic_functions))
       config->bsymbolic = BsymbolicKind::Functions;
+    else if (arg->getOption().matches(OPT_Bsymbolic_non_weak))
+      config->bsymbolic = BsymbolicKind::NonWeak;
     else if (arg->getOption().matches(OPT_Bsymbolic))
       config->bsymbolic = BsymbolicKind::All;
   }
   config->checkSections =
       args.hasFlag(OPT_check_sections, OPT_no_check_sections, true);
   config->chroot = args.getLastArgValue(OPT_chroot);
   config->compressDebugSections = getCompressionType(
       args.getLastArgValue(OPT_compress_debug_sections, "none"),

lld/ELF/Options.td

 defm auxiliary: Eq<"auxiliary", "Set DT_AUXILIARY field to the specified name">;
 
 def be8: F<"be8">, HelpText<"write a Big Endian ELF file using BE8 format (AArch32 only)">;
 
 def Bno_symbolic: F<"Bno-symbolic">, HelpText<"Don't bind default visibility defined symbols locally for -shared (default)">;
 
 def Bsymbolic: F<"Bsymbolic">, HelpText<"Bind default visibility defined symbols locally for -shared">;
 
+def Bsymbolic_non_weak: F<"Bsymbolic-non-weak">,
+  HelpText<"Bind default visibility defined STB_GLOBAL symbols locally for -shared">;
+
 def Bsymbolic_functions: F<"Bsymbolic-functions">,
   HelpText<"Bind default visibility defined function symbols locally for -shared">;
 
 def Bsymbolic_non_weak_functions: F<"Bsymbolic-non-weak-functions">,
   HelpText<"Bind default visibility defined STB_GLOBAL function symbols locally for -shared">;
 
 def Bdynamic: F<"Bdynamic">, HelpText<"Link against shared libraries (default)">;
 

lld/ELF/Symbols.cpp

bool elf::computeIsPreemptible(const Symbol &sym) {
   if (!config->shared)
     return false;
 
   // If -Bsymbolic or --dynamic-list is specified, or -Bsymbolic-functions is
   // specified and the symbol is STT_FUNC, the symbol is preemptible iff it is
   // in the dynamic list. -Bsymbolic-non-weak-functions is a non-weak subset of
   // -Bsymbolic-functions.
   if (config->symbolic ||
+      (config->bsymbolic == BsymbolicKind::NonWeak &&
+       sym.binding != STB_WEAK) ||
       (config->bsymbolic == BsymbolicKind::Functions && sym.isFunc()) ||
       (config->bsymbolic == BsymbolicKind::NonWeakFunctions && sym.isFunc() &&
        sym.binding != STB_WEAK))
     return sym.inDynamicList;
   return true;
 }
 
 // Merge symbol properties.

lld/docs/ld.lld.1

 .Fl shared
 (default).
 .It Fl Bsymbolic
 Bind default visibility defined symbols locally for
 .Fl shared.
 Also set the
 .Dv DF_SYMBOLIC
 flag.
+.It Fl Bsymbolic-non-weak
+Bind default visibility defined STB_GLOBAL symbols locally for
+.Fl shared.
 .It Fl Bsymbolic-functions
 Bind default visibility defined function symbols locally for
 .Fl shared.
 .It Fl Bsymbolic-non-weak-functions
 Bind default visibility defined STB_GLOBAL function symbols locally for
 .Fl shared.
 .It Fl --be8
 Write a Big Endian ELF File using BE8 format(AArch32 only)

lld/test/ELF/bsymbolic.s

 # REQUIRES: x86
 # RUN: rm -rf %t && split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a.s -o %t/a.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %t/b.s -o %t/b.o
 # RUN: ld.lld -shared %t/a.o %t/b.o -o %t0.so
 # RUN: llvm-readobj -r %t0.so | FileCheck %s --check-prefix=REL_DEF
 # RUN: llvm-objdump -d %t0.so | FileCheck %s --check-prefix=ASM_DEF
 
-## -Bsymbolic-functions makes all STB_GLOBAL STT_FUNC definitions non-preemptible.
+## -Bsymbolic-non-weak-functions makes all STB_GLOBAL STT_FUNC definitions non-preemptible.
 # RUN: ld.lld -shared -Bsymbolic-non-weak-functions %t/a.o %t/b.o -o %t1.so
 # RUN: llvm-readobj -r %t1.so | FileCheck %s --check-prefix=REL_GFUN
 # RUN: llvm-objdump -d %t1.so | FileCheck %s --check-prefix=ASM_GFUN
 
 ## -Bsymbolic-functions makes all STT_FUNC definitions non-preemptible.
 # RUN: ld.lld -shared -Bsymbolic-functions %t/a.o %t/b.o -o %t2.so
 # RUN: llvm-readobj -r %t2.so | FileCheck %s --check-prefix=REL_FUN
 # RUN: llvm-objdump -d %t2.so | FileCheck %s --check-prefix=ASM_FUN
 
 ## -Bsymbolic makes all definitions non-preemptible.
 # RUN: ld.lld -shared -Bsymbolic %t/a.o %t/b.o -o %t3.so
 # RUN: llvm-readobj -r %t3.so | FileCheck %s --check-prefix=REL_ALL
 # RUN: llvm-objdump -d %t3.so | FileCheck %s --check-prefix=ASM_ALL
 
+## -Bsymbolic-non-weak makes all STB_GLOBAL definitions non-preemptible.
+# RUN: ld.lld -shared -Bsymbolic-non-weak %t/a.o %t/b.o -o %t4.so
+# RUN: llvm-readobj -r %t4.so | FileCheck %s --check-prefix=REL_GALL
+# RUN: llvm-objdump -d %t4.so | FileCheck %s --check-prefix=ASM_GALL
+
 # RUN: ld.lld -shared -Bsymbolic-functions -Bsymbolic %t/a.o %t/b.o -o %t.so
 # RUN: cmp %t.so %t3.so
 # RUN: ld.lld -shared -Bsymbolic -Bsymbolic-functions %t/a.o %t/b.o -o %t.so
 # RUN: cmp %t.so %t2.so
 # RUN: ld.lld -shared -Bno-symbolic -Bsymbolic %t/a.o %t/b.o -o %t.so
 # RUN: cmp %t.so %t3.so
 
 ## -Bno-symbolic can cancel previously specified -Bsymbolic and -Bsymbolic-functions.
 # RUN: ld.lld -shared -Bsymbolic -Bno-symbolic %t/a.o %t/b.o -o %t.so
 # RUN: cmp %t.so %t0.so
 # RUN: ld.lld -shared -Bsymbolic-functions -Bno-symbolic %t/a.o %t/b.o -o %t.so
 # RUN: cmp %t.so %t0.so
 
 # REL_DEF:      .rela.dyn {
 # REL_DEF-NEXT:   R_X86_64_RELATIVE -
 # REL_DEF-NEXT:   R_X86_64_RELATIVE -
+# REL_DEF-NEXT:   R_X86_64_64 data_weak_default
 # REL_DEF-NEXT:   R_X86_64_64 data_default
 # REL_DEF-NEXT: }
 # REL_DEF-NEXT: .rela.plt {
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT default
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT notype_default
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT weak_default
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT ext_default
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT undef
 # REL_DEF-NEXT: }
 
 # ASM_DEF:      <_start>:
 # ASM_DEF-NEXT:   callq {{.*}} <default@plt>
 # ASM_DEF-NEXT:   callq {{.*}} <protected>
 # ASM_DEF-NEXT:   callq {{.*}} <hidden>
 # ASM_DEF-NEXT:   callq {{.*}} <weak_default@plt>
 # ASM_DEF-NEXT:   callq {{.*}} <ext_default@plt>
 # ASM_DEF-NEXT:   callq {{.*}} <notype_default@plt>
 # ASM_DEF-NEXT:   callq {{.*}} <undef@plt>
 
 # REL_GFUN:      .rela.dyn {
 # REL_GFUN-NEXT:   R_X86_64_RELATIVE -
 # REL_GFUN-NEXT:   R_X86_64_RELATIVE -
+# REL_GFUN-NEXT:   R_X86_64_64 data_weak_default
 # REL_GFUN-NEXT:   R_X86_64_64 data_default
 # REL_GFUN-NEXT: }
 # REL_GFUN-NEXT: .rela.plt {
 # REL_GFUN-NEXT:   R_X86_64_JUMP_SLOT notype_default
 # REL_GFUN-NEXT:   R_X86_64_JUMP_SLOT weak_default
 # REL_GFUN-NEXT:   R_X86_64_JUMP_SLOT undef
 # REL_GFUN-NEXT: }
 
 # ASM_GFUN:      <_start>:
 # ASM_GFUN-NEXT:   callq {{.*}} <default>
 # ASM_GFUN-NEXT:   callq {{.*}} <protected>
 # ASM_GFUN-NEXT:   callq {{.*}} <hidden>
 # ASM_GFUN-NEXT:   callq {{.*}} <weak_default@plt>
 # ASM_GFUN-NEXT:   callq {{.*}} <ext_default>
 # ASM_GFUN-NEXT:   callq {{.*}} <notype_default@plt>
 # ASM_GFUN-NEXT:   callq {{.*}} <undef@plt>
 
 # REL_FUN:      .rela.dyn {
 # REL_FUN-NEXT:   R_X86_64_RELATIVE -
 # REL_FUN-NEXT:   R_X86_64_RELATIVE -
+# REL_FUN-NEXT:   R_X86_64_64 data_weak_default
 # REL_FUN-NEXT:   R_X86_64_64 data_default
 # REL_FUN-NEXT: }
 # REL_FUN-NEXT: .rela.plt {
 # REL_FUN-NEXT:   R_X86_64_JUMP_SLOT notype_default
 # REL_FUN-NEXT:   R_X86_64_JUMP_SLOT undef
 # REL_FUN-NEXT: }
 
 # ASM_FUN:      <_start>:
 # ASM_FUN-NEXT:   callq {{.*}} <default>
 # ASM_FUN-NEXT:   callq {{.*}} <protected>
 # ASM_FUN-NEXT:   callq {{.*}} <hidden>
 # ASM_FUN-NEXT:   callq {{.*}} <weak_default>
 # ASM_FUN-NEXT:   callq {{.*}} <ext_default>
 # ASM_FUN-NEXT:   callq {{.*}} <notype_default@plt>
 # ASM_FUN-NEXT:   callq {{.*}} <undef@plt>
 
 # REL_ALL:      .rela.dyn {
 # REL_ALL-NEXT:   R_X86_64_RELATIVE -
 # REL_ALL-NEXT:   R_X86_64_RELATIVE -
 # REL_ALL-NEXT:   R_X86_64_RELATIVE -
+# REL_ALL-NEXT:   R_X86_64_RELATIVE -
 # REL_ALL-NEXT: }
 # REL_ALL-NEXT: .rela.plt {
 # REL_ALL-NEXT:   R_X86_64_JUMP_SLOT undef
 # REL_ALL-NEXT: }
 
 # ASM_ALL:      <_start>:
 # ASM_ALL-NEXT:   callq {{.*}} <default>
 # ASM_ALL-NEXT:   callq {{.*}} <protected>
 # ASM_ALL-NEXT:   callq {{.*}} <hidden>
 # ASM_ALL-NEXT:   callq {{.*}} <weak_default>
 # ASM_ALL-NEXT:   callq {{.*}} <ext_default>
 # ASM_ALL-NEXT:   callq {{.*}} <notype_default>
 # ASM_ALL-NEXT:   callq {{.*}} <undef@plt>
 
+# REL_GALL:      .rela.dyn {
+# REL_GALL-NEXT:   R_X86_64_RELATIVE -
+# REL_GALL-NEXT:   R_X86_64_RELATIVE -
+# REL_GALL-NEXT:   R_X86_64_RELATIVE -
+# REL_GALL-NEXT:   R_X86_64_64 data_weak_default
+# REL_GALL-NEXT: }
+# REL_GALL-NEXT: .rela.plt {
+# REL_GALL-NEXT:   R_X86_64_JUMP_SLOT weak_default
+# REL_GALL-NEXT:   R_X86_64_JUMP_SLOT undef
+# REL_GALL-NEXT: }
+
+# ASM_GALL:      <_start>:
+# ASM_GALL-NEXT:   callq {{.*}} <default>
+# ASM_GALL-NEXT:   callq {{.*}} <protected>
+# ASM_GALL-NEXT:   callq {{.*}} <hidden>
+# ASM_GALL-NEXT:   callq {{.*}} <weak_default@plt>
+# ASM_GALL-NEXT:   callq {{.*}} <ext_default>
+# ASM_GALL-NEXT:   callq {{.*}} <notype_default>
+# ASM_GALL-NEXT:   callq {{.*}} <undef@plt>
+
 #--- a.s
 .globl default, protected, hidden, notype_default
 .weak weak_default
 .protected protected
 .hidden hidden
 .type default, @function
 .type protected, @function
 .type hidden, @function
_start:
   callq ext_default@PLT
 
   callq notype_default@PLT
 
   callq undef@PLT
 
 .data
   .quad data_default
+  .quad data_weak_default
   .quad data_protected
   .quad data_hidden
 
-.globl data_default, data_protected, data_hidden
+.globl data_default, data_weak_default, data_protected, data_hidden
+.weak data_weak_default
 .protected data_protected
 .hidden data_hidden
 .type data_default, @object
+.type data_weak_default, @object
 .type data_protected, @object
 .type data_hidden, @object
 data_default: .byte 0
+data_weak_default: .byte 0
 data_protected: .byte 0
 data_hidden: .byte 0
 
 #--- b.s
 .globl ext_default
 .type ext_default,@function
 ext_default:
   nop