[ELF] Add -Bsymbolic-non-weak-functions

[MaskRay]

Summary

This option is a subset of -Bsymbolic-functions. It applies to STB_GLOBAL
STT_FUNC definitions.

The address of a vague linkage function (STB_WEAK STT_FUNC, e.g. an inline
function, a template instantiation) seen by a -Bsymbolic-functions linked
shared object may be different from the address seen from outside the shared
object. Such cases are uncommon. (ELF/Mach-O programs may use
-fvisibility-inlines-hidden to break such pointer equality. On Windows,
correct dllexport and dllimport are needed to make pointer equality work.
Windows link.exe enables /OPT:ICF by default so different inline functions may
have the same address.)

// a.cc -> a.o -> a.so (-Bsymbolic-functions)
inline void f() {}
void *g() { return (void *)&f; }

// b.cc -> b.o -> exe
// The address is different!
inline void f() {}

-Bsymbolic-non-weak-functions is a safer (C++ conforming) subset of
-Bsymbolic-functions, which can make the program work.

Implementations usually emit a vague linkage definition in a COMDAT group. We
could detect the group (with more code) but I feel that we should just check
STB_WEAK for simplicity. A weak definition will thus serve as an escape hatch
for rare cases when users want interposition on definitions.

GNU ld feature request: https://sourceware.org/bugzilla/show_bug.cgi?id=27871

Longer write-up: https://maskray.me/blog/2021-05-16-elf-interposition-and-bsymbolic

[jhenderson]

No objections from me, but we don't use symbol preemption in our downstream codebase, so I haven't got much experience with the implications one way or another, so probably best others give their points of view.

[peter.smith]

I don't have any strong objections. Just want to make sure that weak symbols are the right subset to use. My understanding is that this is coming from vague linkage https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vague the only part that I could find in there about weak definitions is in static data: (https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vague-static)

Some objects with static storage duration have associated guard variables used to ensure that they are initialized only once (see 3.3.3). If the object is emitted using a COMDAT group, the guard variable must be too. It is suggested that it be emitted in the same COMDAT group as the associated data object, but it may be emitted in its own COMDAT group, identified by its name. In either case, it must be weak.

The part about out of line copies of inline functions https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vague-inline says to define them in a comdat group but nothing about weak definitions. I think that both clang and GCC use weak definitions for functions in COMDAT groups but is that guaranteed of all compilers that might use LLD?

Some suggestions:

• Is -Bsymbolic-non-vague-functions more descriptive, or perhaps -Bsymbolic-non-weak-functions? When I see global-functions as a programmer, not a linker person, I think of non-static functions rather than non-weak functions.
• Would "Not defined in a COMDAT group" be a better criteria for the subset than non-weak? This would correctly find global symbols defined in COMDAT groups? Certainly more work to implement.

[MaskRay]

-> -Bsymbolic-non-weak-functions

[peter.smith]

Thanks for the update. I think it is a well defined useful subset of -Bsymbolic-functions so I'm happy to approve.

[smeenai]

Do you plan to land this? I thought of it as potentially useful for https://github.com/android/ndk/issues/1551. The issue has the full details, but the summary is that we only want a single copy of __emutls_get_address that's used by all shared objects in a process, otherwise different DSOs will see different emulated TLS state for the same variable. One way to ensure that would be to put the emulated TLS bits in their own DSO and have everyone else reference that, but a full DSO is pretty heavy-weight. Another would be to make it default visibility and weak and let the dynamic linker coalesce multiple copies at runtime; -Bsymbolic and -Bsymbolic-functions would break that, but -Bsymbolic-non-weak-functions wouldn't.

[MaskRay]

In D102570#2914731, @smeenai wrote:

Do you plan to land this? I thought of it as potentially useful for https://github.com/android/ndk/issues/1551. The issue has the full details, but the summary is that we only want a single copy of __emutls_get_address that's used by all shared objects in a process, otherwise different DSOs will see different emulated TLS state for the same variable. One way to ensure that would be to put the emulated TLS bits in their own DSO and have everyone else reference that, but a full DSO is pretty heavy-weight. Another would be to make it default visibility and weak and let the dynamic linker coalesce multiple copies at runtime; -Bsymbolic and -Bsymbolic-functions would break that, but -Bsymbolic-non-weak-functions wouldn't.

I was waiting for users:) Glad that this can find a user.

For Linux distributions, I am hoping they can use a -fvisibility variant which applies to non-weak functions/variables (say, -fvisibility-non-weak=protected).
I think GNU people aren't thrilled at the idea (and so users are stuck with GCC -fpic -fsemantic-interposition suppressing lining).
Even with a compiler option, a linker option can be convenient as well. It allows easy experiments without recompilation.

[MaskRay]

rebase

[smeenai]

Thanks!

Btw, this is also pretty close to ld64's default behavior for Mach-O: non-weak definitions get bound directly, and weak definitions are left as interposable. The only difference is that ld64's behavior applies to data as well as functions.

[MaskRay]

Right:) The only reason that GNU ld needed -Bsymbolic-functions is to avoid collision with copy relocations.

In a -fpie/-fpic world, we should not see copy relocations from C/C++ code but GCC x86-64 still has the HAVE_LD_PIE_COPYRELOC issue😭 (https://gcc.gnu.org/legacy-ml/gcc/2019-05/msg00215.html) @hjl.tools

[smeenai]

Android is considering this as their default behavior: https://github.com/android/ndk/issues/1552

Do you think it's worth cherry-picking this to LLVM 13, to get it more exposure? CC @tstellar

On our end, we build with full -Bsymbolic right now. Once we're testing with LLVM 13, I'll try -Bsymbolic-functions and -Bsymbolic-non-weak-functions and see if they make any meaningful performance or size differences for our apps (and how a hypothetical -Bsymbolic-non-weak, which would match default Mach-O behavior, might perform as well).

[MaskRay]

In D102570#2914940, @smeenai wrote:

Android is considering this as their default behavior: https://github.com/android/ndk/issues/1552

Do you think it's worth cherry-picking this to LLVM 13, to get it more exposure? CC @tstellar

LGTM. This is a very safe patch.

On our end, we build with full -Bsymbolic right now. Once we're testing with LLVM 13, I'll try -Bsymbolic-functions and -Bsymbolic-non-weak-functions and see if they make any meaningful performance or size differences for our apps (and how a hypothetical -Bsymbolic-non-weak, which would match default Mach-O behavior, might perform as well).

I also tested some internal server side applications. Some applications break with -Bsymbolic-functions but work with -Bsymbolic-non-weak-functions, so they do leverage function address pointer equality.

Adding -Bsymbolic-non-weak is also fine. I am always of the view that global variable accesses should not be in the performance bottleneck. Most applications should not observe any difference.
If an application sees improvement, it suggests some code problems. They can consider making the variable hidden (or protected if they don't use -fno-pic)

---

-fvisibility-non-weak=protected may benefit GCC (due to its -fsemantic-interposition for -fpic), but not clang.
That said, I do like using visibility to properly annotate object files

[tstellar]

I've merged this to the release/13.x branch, so do we still need the release note in main?

[MaskRay]

In D102570#2915489, @tstellar wrote:

I've merged this to the release/13.x branch, so do we still need the release note in main?

The release note can be removed in main.

[danalbert]

In D102570#2914756, @MaskRay wrote:

In D102570#2914731, @smeenai wrote:

Do you plan to land this? I thought of it as potentially useful for https://github.com/android/ndk/issues/1551. The issue has the full details, but the summary is that we only want a single copy of __emutls_get_address that's used by all shared objects in a process, otherwise different DSOs will see different emulated TLS state for the same variable. One way to ensure that would be to put the emulated TLS bits in their own DSO and have everyone else reference that, but a full DSO is pretty heavy-weight. Another would be to make it default visibility and weak and let the dynamic linker coalesce multiple copies at runtime; -Bsymbolic and -Bsymbolic-functions would break that, but -Bsymbolic-non-weak-functions wouldn't.

I was waiting for users:) Glad that this can find a user.

I think I can deliver quite a few more :) I hadn't seen this patch before (thanks @smeenai for the heads up). It sounds like what Android would want to do by default.

lld/ELF/Config.h

 enum ELFKind {
   ELFNoneKind,
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
+// For -Bno-symbolic, -Bsymbolic-non-weak-functions, -Bsymbolic-functions,
+// -Bsymbolic.
+enum class BsymbolicKind { None, NonWeakFunctions, Functions, 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}.
 enum class ICFLevel { None, Safe, All };
llvm::MapVector<std::pair<const InputSectionBase *, const InputSectionBase *>,
                   uint64_t>
       callGraphProfile;
   bool allowMultipleDefinition;
   bool androidPackDynRelocs;
   bool armHasBlx = false;
   bool armHasMovtMovw = false;
   bool armJ1J2BranchEncoding = false;
   bool asNeeded = false;
-  bool bsymbolic = false;
-  bool bsymbolicFunctions = false;
+  BsymbolicKind bsymbolic = BsymbolicKind::None;
   bool callGraphProfileSort;
   bool checkSections;
   bool checkDynamicRelocs;
   bool compressDebugSections;
   bool cref;
   std::vector<std::pair<llvm::GlobPattern, uint64_t>> deadRelocInNonAlloc;
   bool defineCommon;
   bool demangle = true;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   errorHandler().vsDiagnostics =
       args.hasArg(OPT_visual_studio_diagnostics_format, false);
 
   config->allowMultipleDefinition =
       args.hasFlag(OPT_allow_multiple_definition,
                    OPT_no_allow_multiple_definition, false) ||
       hasZOption(args, "muldefs");
   config->auxiliaryList = args::getStrings(args, OPT_auxiliary);
-  if (opt::Arg *arg = args.getLastArg(OPT_Bno_symbolic, OPT_Bsymbolic_functions,
-                                      OPT_Bsymbolic)) {
-    if (arg->getOption().matches(OPT_Bsymbolic_functions))
-      config->bsymbolicFunctions = true;
+  if (opt::Arg *arg =
+          args.getLastArg(OPT_Bno_symbolic, OPT_Bsymbolic_non_weak_functions,
+                          OPT_Bsymbolic_functions, 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))
-      config->bsymbolic = true;
+      config->bsymbolic = BsymbolicKind::All;
   }
   config->checkSections =
       args.hasFlag(OPT_check_sections, OPT_no_check_sections, true);
   config->chroot = args.getLastArgValue(OPT_chroot);
   config->compressDebugSections = getCompressDebugSections(args);
   config->cref = args.hasArg(OPT_cref);
   config->defineCommon = args.hasFlag(OPT_define_common, OPT_no_define_common,
                                       !args.hasArg(OPT_relocatable));
if (Expected<GlobPattern> pat = GlobPattern::create(pattern))
       config->warnBackrefsExclude.push_back(std::move(*pat));
     else
       error(arg->getSpelling() + ": " + toString(pat.takeError()));
   }
 
   // When producing an executable, --dynamic-list specifies non-local defined
   // symbols which are required to be exported. When producing a shared object,
   // symbols not specified by --dynamic-list are non-preemptible.
-  config->symbolic = config->bsymbolic || args.hasArg(OPT_dynamic_list);
+  config->symbolic =
+      config->bsymbolic == BsymbolicKind::All || args.hasArg(OPT_dynamic_list);
   for (auto *arg : args.filtered(OPT_dynamic_list))
     if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
       readDynamicList(*buffer);
 
   // --export-dynamic-symbol specifies additional --dynamic-list symbols if any
   // other option expresses a symbolic intention: -no-pie, -pie, -Bsymbolic,
   // -Bsymbolic-functions (if STT_FUNC), --dynamic-list.
   for (auto *arg : args.filtered(OPT_export_dynamic_symbol))

lld/ELF/Options.td

 
 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_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)">;
 
 def Bstatic: F<"Bstatic">, HelpText<"Do not link against shared libraries">;
 
 def build_id: F<"build-id">, HelpText<"Alias for --build-id=fast">;
 
 def build_id_eq: J<"build-id=">, HelpText<"Generate build ID note">,
   MetaVarName<"[fast,md5,sha1,uuid,0x<hexstring>]">;

lld/ELF/Symbols.cpp

bool elf::computeIsPreemptible(const Symbol &sym) {
   if (!sym.isDefined())
     return true;
 
   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.
-  if (config->symbolic || (config->bsymbolicFunctions && sym.isFunc()))
+  // in the dynamic list. -Bsymbolic-non-weak-functions is a non-weak subset of
+  // -Bsymbolic-functions.
+  if (config->symbolic ||
+      (config->bsymbolic == BsymbolicKind::Functions && sym.isFunc()) ||
+      (config->bsymbolic == BsymbolicKind::NonWeakFunctions && sym.isFunc() &&
+       sym.binding != STB_WEAK))
     return sym.inDynamicList;
   return true;
 }
 
 void elf::reportBackrefs() {
   for (auto &it : backwardReferences) {
     const Symbol &sym = *it.first;
     std::string to = toString(it.second.second);

lld/ELF/SyntheticSections.cpp

if (isMain) {
     if (!config->soName.empty())
       addInt(DT_NEEDED, part.dynStrTab->addString(config->soName));
     addInt(DT_SONAME, part.dynStrTab->addString(part.name));
   }
 
   // Set DT_FLAGS and DT_FLAGS_1.
   uint32_t dtFlags = 0;
   uint32_t dtFlags1 = 0;
-  if (config->bsymbolic)
+  if (config->bsymbolic == BsymbolicKind::All)
     dtFlags |= DF_SYMBOLIC;
   if (config->zGlobal)
     dtFlags1 |= DF_1_GLOBAL;
   if (config->zInitfirst)
     dtFlags1 |= DF_1_INITFIRST;
   if (config->zInterpose)
     dtFlags1 |= DF_1_INTERPOSE;
   if (config->zNodefaultlib)

lld/docs/ReleaseNotes.rst

 from the `LLVM releases web site <https://llvm.org/releases/>`_.
 
 Non-comprehensive list of changes in this release
 =================================================
 
 ELF Improvements
 ----------------
 
-* ...
+* ``-Bsymbolic-non-weak-functions`` has been added as a ``STB_GLOBAL`` subset of ``-Bsymbolic-functions``.
+  (`D102570 <https://reviews.llvm.org/D102570>`_)
 
 Breaking changes
 ----------------
 
 * ...
 
 COFF Improvements
 -----------------

lld/docs/ld.lld.1

 Bind default visibility defined symbols locally for
 .Fl shared.
 Also set the
 .Dv DF_SYMBOLIC
 flag.
 .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 -build-id Ns = Ns Ar value
 Generate a build ID note.
 .Ar value
 may be one of
 .Cm fast ,
 .Cm md5 ,
 .Cm sha1 ,
 .Cm tree ,

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.
+# 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 %t1.so
-# RUN: llvm-readobj -r %t1.so | FileCheck %s --check-prefix=REL_FUN
-# RUN: llvm-objdump -d %t1.so | FileCheck %s --check-prefix=ASM_FUN
+# 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 %t2.so
-# RUN: llvm-readobj -r %t2.so | FileCheck %s --check-prefix=REL_ALL
-# RUN: llvm-objdump -d %t2.so | FileCheck %s --check-prefix=ASM_ALL
+# 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
 
 # RUN: ld.lld -shared -Bsymbolic-functions -Bsymbolic %t/a.o %t/b.o -o %t.so
-# RUN: cmp %t.so %t2.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 %t1.so
-# RUN: ld.lld -shared -Bno-symbolic -Bsymbolic %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_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 weak_default
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT ext_default
 # REL_DEF-NEXT:   R_X86_64_JUMP_SLOT notype_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_default
+# REL_GFUN-NEXT: }
+# REL_GFUN-NEXT: .rela.plt {
+# REL_GFUN-NEXT:   R_X86_64_JUMP_SLOT weak_default
+# REL_GFUN-NEXT:   R_X86_64_JUMP_SLOT notype_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_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: }
 # 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>
 
 #--- a.s
 .globl default, protected, hidden, notype_default
+.weak weak_default
 .protected protected
 .hidden hidden
 .type default, @function
 .type protected, @function
 .type hidden, @function
+.type weak_default, @function
 default: nop
 protected: nop
 hidden: nop
+weak_default: nop
 notype_default: nop
 
 .globl _start
 _start:
   callq default@PLT
   callq protected@PLT
   callq hidden@PLT
 
+  callq weak_default@PLT
+
   callq ext_default@PLT
 
   callq notype_default@PLT
 
   callq undef@PLT
 
 .data
   .quad data_default