Add --audit and --depaudit

These are for the sake of compatibility with GNU ld.

Author: rui314

src/cmdline.cc

@@ -41,6 +41,8 @@ static const char helpmsg[] = R"(
   -N, --omagic                Do not page align data; do not make text readonly
     --no-omagic
   -O NUMBER                   Ignored
+  -P AUDITLIB, --depaudit AUDITLIB
+                              Set DT_DEPAUDIT to the specified value
   -S, --strip-debug           Strip .debug_* sections
   -T FILE, --script FILE      Read linker script
   -X, --discard-locals        Discard temporary local symbols
@@ -76,6 +78,7 @@ static const char helpmsg[] = R"(
     --no-apply-dynamic-relocs
   --as-needed                 Only set DT_NEEDED if used
     --no-as-needed
+  --audit LIBNAME             Set DT_AUDIT to the specified value
   --build-id [none,md5,sha1,sha256,fast,uuid,HEXSTRING]
                               Generate build ID
     --no-build-id
@@ -892,6 +895,16 @@ std::vector<std::string> parse_nonpositional_args(Context<E> &ctx) {
       }
     } else if (read_arg("soname") || read_arg("h")) {
       ctx.arg.soname = arg;
+    } else if (read_arg("audit")) {
+      if (ctx.arg.audit.empty())
+        ctx.arg.audit = arg;
+      else
+        ctx.arg.audit += ":" + std::string(arg);
+    } else if (read_arg("depaudit") || read_arg("P")) {
+      if (ctx.arg.depaudit.empty())
+        ctx.arg.depaudit = arg;
+      else
+        ctx.arg.depaudit += ":" + std::string(arg);
     } else if (read_flag("allow-multiple-definition")) {
       ctx.arg.allow_multiple_definition = true;
     } else if (read_flag("apply-dynamic-relocs")) {

src/elf.h

@@ -285,6 +285,8 @@ enum : u32 {
   DT_RELR = 36,
   DT_RELRENT = 37,
   DT_GNU_HASH = 0x6ffffef5,
+  DT_DEPAUDIT = 0x6ffffefb,
+  DT_AUDIT = 0x6ffffefc,
   DT_VERSYM = 0x6ffffff0,
   DT_RELACOUNT = 0x6ffffff9,
   DT_RELCOUNT = 0x6ffffffa,

src/input-files.cc

@@ -1319,6 +1319,21 @@ std::vector<std::string_view> SharedFile<E>::get_dt_needed(Context<E> &ctx) {
   return vec;
 }
 
+template <typename E>
+std::string_view SharedFile<E>::get_dt_audit(Context<E> &ctx) {
+  ElfShdr<E> *sec = this->find_section(SHT_DYNAMIC);
+  if (!sec)
+    return "";
+
+  std::span<ElfDyn<E>> dynamic = this->template get_data<ElfDyn<E>>(ctx, *sec);
+  std::string_view strtab = this->get_string(ctx, sec->sh_link);
+
+  for (ElfDyn<E> &dyn : dynamic)
+    if (dyn.d_tag == DT_AUDIT)
+      return strtab.data() + dyn.d_val;
+  return "";
+}
+
 // Symbol versioning is a GNU extension to the ELF file format. I don't
 // particularly like the feature as it complicates the semantics of
 // dynamic linking, but we need to support it anyway because it is

src/main.cc

@@ -480,16 +480,7 @@ int mold_main(int argc, char **argv) {
     shuffle_sections(ctx);
 
   // Copy string referred by .dynamic to .dynstr.
-  for (SharedFile<E> *file : ctx.dsos)
-    ctx.dynstr->add_string(file->soname);
-  for (std::string_view str : ctx.arg.auxiliary)
-    ctx.dynstr->add_string(str);
-  for (std::string_view str : ctx.arg.filter)
-    ctx.dynstr->add_string(str);
-  if (!ctx.arg.rpaths.empty())
-    ctx.dynstr->add_string(ctx.arg.rpaths);
-  if (!ctx.arg.soname.empty())
-    ctx.dynstr->add_string(ctx.arg.soname);
+  add_dynamic_strings(ctx);
 
   if constexpr (is_ppc64v1<E>)
     ppc64v1_scan_symbols(ctx);

src/mold.h

@@ -1476,6 +1476,7 @@ class SharedFile : public InputFile<E> {
   std::span<Symbol<E> *> get_symbols_at(Symbol<E> *sym);
   i64 get_alignment(Symbol<E> *sym);
   std::vector<std::string_view> get_dt_needed(Context<E> &ctx);
+  std::string_view get_dt_audit(Context<E> &ctx);
   bool is_readonly(Symbol<E> *sym);
 
   void mark_live_objects(Context<E> &ctx,
@@ -1678,6 +1679,7 @@ template <typename E> void sort_init_fini(Context<E> &);
 template <typename E> void sort_ctor_dtor(Context<E> &);
 template <typename E> void fixup_ctors_in_init_array(Context<E> &);
 template <typename E> void shuffle_sections(Context<E> &);
+template <typename E> void add_dynamic_strings(Context<E> &);
 template <typename E> void compute_section_sizes(Context<E> &);
 template <typename E> void sort_output_sections(Context<E> &);
 template <typename E> void claim_unresolved_symbols(Context<E> &);
@@ -2039,8 +2041,11 @@ struct Context {
     i64 z_stack_size = 0;
     std::optional<Glob> unique;
     std::optional<u64> physical_image_base;
+    std::optional<std::vector<Symbol<E> *>> retain_symbols_file;
     std::string Map;
+    std::string audit;
     std::string chroot;
+    std::string depaudit;
     std::string dependency_file;
     std::string directory;
     std::string dynamic_linker;
@@ -2052,7 +2057,6 @@ struct Context {
     std::string soname;
     std::string sysroot;
     std::string_view emulation;
-    std::optional<std::vector<Symbol<E> *>> retain_symbols_file;
     std::unordered_map<std::string_view, u64> section_align;
     std::unordered_map<std::string_view, u64> section_start;
     std::unordered_set<std::string_view> discard_section;

src/output-chunks.cc

@@ -655,6 +655,12 @@ static std::vector<Word<E>> create_dynamic_section(Context<E> &ctx) {
   for (std::string_view str : ctx.arg.auxiliary)
     define(DT_AUXILIARY, ctx.dynstr->find_string(str));
 
+  if (!ctx.arg.audit.empty())
+    define(DT_AUDIT, ctx.dynstr->find_string(ctx.arg.audit));
+
+  if (!ctx.arg.depaudit.empty())
+    define(DT_DEPAUDIT, ctx.dynstr->find_string(ctx.arg.depaudit));
+
   for (std::string_view str : ctx.arg.filter)
     define(DT_FILTER, ctx.dynstr->find_string(str));
 

src/passes.cc

@@ -1367,6 +1367,36 @@ void shuffle_sections(Context<E> &ctx) {
   }
 }
 
+template <typename E>
+void add_dynamic_strings(Context<E> &ctx) {
+  for (SharedFile<E> *file : ctx.dsos) {
+    std::string s = std::string(file->get_dt_audit(ctx));
+    if (!s.empty()) {
+      if (ctx.arg.depaudit.empty())
+        ctx.arg.depaudit = s;
+      else
+        ctx.arg.depaudit += ":" + s;
+    }
+  }
+
+  auto add = [&](std::string_view s) {
+    if (!s.empty())
+      ctx.dynstr->add_string(s);
+  };
+
+  for (SharedFile<E> *file : ctx.dsos)
+    add(file->soname);
+  for (std::string_view str : ctx.arg.auxiliary)
+    add(str);
+  for (std::string_view str : ctx.arg.filter)
+    add(str);
+
+  add(ctx.arg.audit);
+  add(ctx.arg.depaudit);
+  add(ctx.arg.rpaths);
+  add(ctx.arg.soname);
+}
+
 template <typename E>
 void compute_section_sizes(Context<E> &ctx) {
   Timer t(ctx, "compute_section_sizes");
@@ -3360,6 +3390,7 @@ template void sort_init_fini(Context<E> &);
 template void sort_ctor_dtor(Context<E> &);
 template void fixup_ctors_in_init_array(Context<E> &);
 template void shuffle_sections(Context<E> &);
+template void add_dynamic_strings(Context<E> &);
 template void compute_section_sizes(Context<E> &);
 template void sort_output_sections(Context<E> &);
 template void claim_unresolved_symbols(Context<E> &);

test/audit.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+cat <<EOF | $CC -o $t/a.o -c -xc -
+int main() {}
+EOF
+
+$CC -B. -o $t/exe1 $t/a.o
+readelf --dynamic $t/exe1 | not grep 'Audit library'
+
+$CC -B. -o $t/exe2 $t/a.o -Wl,--audit=foo
+readelf --dynamic $t/exe2 | grep -F 'Audit library: [foo]'
+
+$CC -B. -o $t/exe3 $t/a.o -Wl,--audit=foo -Wl,--audit=bar
+readelf --dynamic $t/exe3 | grep -F 'Audit library: [foo:bar]'
+
+
+cat <<'EOF' | $CC -B. -shared -o $t/b.so -xc - -fPIC
+#include <stdio.h>
+unsigned la_version(unsigned v) {
+  fprintf(stderr, "version=%d\n", v);
+  return 0;
+}
+EOF
+
+LD_AUDIT=$t/b.so $QEMU $t/exe1 |& grep 'version=' || skip
+
+$CC -B. -o $t/exe4 $t/a.o -Wl,--audit=$t/b.so
+$QEMU $t/exe4 |& grep 'version='

test/depaudit.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+cat <<EOF | $CC -o $t/a.o -c -xc -
+int main() {}
+EOF
+
+$CC -B. -o $t/exe1 $t/a.o
+readelf --dynamic $t/exe1 | not grep 'Dependency audit library'
+
+$CC -B. -o $t/exe2 $t/a.o -Wl,--depaudit=libdepaudit.so
+readelf --dynamic $t/exe2 | grep -F 'Dependency audit library: [libdepaudit.so]'
+
+$CC -B. -o $t/exe3 $t/a.o -Wl,--depaudit=foo -Wl,-P,bar
+readelf --dynamic $t/exe3 | grep -F 'Dependency audit library: [foo:bar]'

test/depaudit2.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+cat <<'EOF' | $CC -B. -shared -o $t/a.so -xc - -fPIC
+#include <stdio.h>
+
+unsigned la_version(unsigned v) {
+  fprintf(stderr, "version=%d\n", v);
+  return 0;
+}
+
+void foo() {}
+EOF
+
+cat <<'EOF' | $CC -B. -shared -o $t/b.so -xc - -fPIC -Wl,--audit=$t/a.so
+void foo();
+void bar() { foo(); }
+EOF
+
+cat <<'EOF' | $CC -c -o $t/c.o -xc -
+void bar();
+int main() { bar(); }
+EOF
+
+$CC -B. -o $t/exe1 $t/c.o $t/b.so
+readelf --dynamic $t/exe1 | grep 'Dependency audit library:..*/a.so'
+
+$CC -B. -o $t/exe2 $t/c.o $t/b.so -Wl,--depaudit=foo
+readelf --dynamic $t/exe2 | grep 'Dependency audit library:..*foo:.*/a.so'