--wrap

[ikudrin]

It fails wrap2.s test.

[ikudrin]

$ cat > a.s << EOF
> .globl foo,__wrap_foo,__real_foo
> foo = 0x10
> __wrap_foo = 0x20
> __real_foo = 0x30
> EOF
$ llvm-mc -filetype=obj -triple=x86_64-pc-linux a.s -o a.o
$ ld -shared a.o -o ld.out -wrap=foo
$ lld -flavor gnu2 -shared a.o -o lld.out -wrap=foo
$ readelf -s ld.out | fgrep "foo"
     1: 0000000000000030     0 NOTYPE  GLOBAL DEFAULT  ABS __real_foo
     3: 0000000000000020     0 NOTYPE  GLOBAL DEFAULT  ABS __wrap_foo
     4: 0000000000000010     0 NOTYPE  GLOBAL DEFAULT  ABS foo
     8: 0000000000000030     0 NOTYPE  GLOBAL DEFAULT  ABS __real_foo
    10: 0000000000000020     0 NOTYPE  GLOBAL DEFAULT  ABS __wrap_foo
    11: 0000000000000010     0 NOTYPE  GLOBAL DEFAULT  ABS foo
$ readelf -s lld.out | fgrep "foo"
     1: 0000000000000010     0 NOTYPE  LOCAL  HIDDEN   ABS __real_foo
     2: 0000000000000020     0 NOTYPE  LOCAL  HIDDEN   ABS __wrap_foo
     3: 0000000000000020     0 NOTYPE  LOCAL  HIDDEN   ABS foo

[ikudrin]

$ cat > wrap.s << EOF
> .globl __wrap_foo
> __wrap_foo:
>   ret
> EOF

$ cat > main.s << EOF
> .globl _start
> _start:
>   call foo
> EOF

$ llvm-mc -filetype=obj -triple=x86_64-pc-linux -o wrap.o wrap.s
$ llvm-mc -filetype=obj -triple=x86_64-pc-linux -o main.o main.s

$ ld -o ld.out main.o wrap.o -wrap=foo

$ lld -flavor gnu2 -o lld.out main.o wrap.o -wrap=foo
undefined symbol: foo in main.o

ELF/Driver.cpp

 #include "Error.h"
 #include "InputFiles.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
 Configuration *lld::elf2::Config;
if (Symtab.getObjectFiles().empty())
     error("no input files.");
 
   for (auto *Arg : Args.filtered(OPT_undefined))
     Symtab.addUndefinedSym(Arg->getValue());
 
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
+  llvm::BumpPtrAllocator Alloc;
+  llvm::StringSaver Saver(Alloc);
+
+  for (auto *Arg : Args.filtered(OPT_wrap)) {
+    StringRef Sym = Arg->getValue();
+    Symtab.wrap(Sym, Saver.save("__wrap_" + Sym), Saver.save("__real_" + Sym));
+  }
+
   // Write the result.
   const ELFFileBase *FirstObj = Symtab.getFirstELF();
   switch (FirstObj->getELFKind()) {
   case ELF32LEKind:
     writeResult<object::ELF32LE>(&Symtab);
     return;
   case ELF32BEKind:
     writeResult<object::ELF32BE>(&Symtab);

ELF/Options.td

def undefined : Joined<["--"], "undefined=">,
   HelpText<"Force undefined symbol during linking">;
 
 def whole_archive : Flag<["--"], "whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
 def z : JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
+def wrap : Separate<["--", "-"], "wrap">, MetaVarName<"<symbol>">,
+  HelpText<"Use a wrapper function for symbol">;
+
 // Aliases
 def alias_Bdynamic_call_shared: Flag<["-"], "call_shared">, Alias<Bdynamic>;
 def alias_Bdynamic_dy: Flag<["-"], "dy">, Alias<Bdynamic>;
 def alias_Bstatic_dn: Flag<["-"], "dn">, Alias<Bstatic>;
 def alias_Bstatic_non_shared: Flag<["-"], "non_shared">, Alias<Bstatic>;
 def alias_Bstatic_static: Flag<["-"], "static">, Alias<Bstatic>;
 def alias_L__library_path : Joined<["--"], "library-path=">, Alias<L>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
 def alias_entry_e : Separate<["-"], "e">, Alias<entry>;
 def alias_fini_fini : Joined<["-"], "fini=">, Alias<fini>;
 def alias_init_init : Joined<["-"], "init=">, Alias<init>;
 def alias_l__library : Joined<["--"], "library=">, Alias<l>;
 def alias_rpath_rpath : Joined<["-"], "rpath=">, Alias<rpath>;
 def alias_soname_h : Separate<["-"], "h">, Alias<soname>;
 def alias_soname_soname : Separate<["-"], "soname">, Alias<soname>;
 def alias_undefined_u : Separate<["-"], "u">, Alias<undefined>;
+def alias_wrap_wrap : Joined<["--", "-"], "wrap=">, Alias<wrap>;
 
 // Options listed below are silently ignored now.
 def O3 : Flag<["-"], "O3">;
 def as_needed : Flag<["--"], "as-needed">;
 def build_id : Flag<["--"], "build-id">;
 def eh_frame_hdr : Flag<["--"], "eh-frame-hdr">;
 def end_group : Flag<["--"], "end-group">;
 def gc_sections : Flag<["--"], "gc-sections">;
 def hash_style : Joined<["--"], "hash-style=">;
 def no_add_needed : Flag<["--"], "no-add-needed">;
 def no_as_needed : Flag<["--"], "no-as-needed">;
 def no_fatal_warnings : Flag<["--"], "no-fatal-warnings">;
 def start_group : Flag<["--"], "start-group">;
 def strip_all : Flag<["--"], "strip-all">;
 def version_script : Separate<["--"], "version-script">;

ELF/SymbolTable.h

public:
   }
 
   SymbolBody *getEntrySym() const {
     if (!EntrySym)
       return nullptr;
     return EntrySym->getReplacement();
   }
 
-  void addUndefinedSym(StringRef Name);
+  SymbolBody *addUndefinedSym(StringRef Name);
+  void wrap(StringRef Sym, StringRef Wrap, StringRef Real);
 
   template <class ELFT>
   void addSyntheticSym(StringRef Name, OutputSection<ELFT> &Section,
                        typename llvm::object::ELFFile<ELFT>::uintX_t Value);
 
   template <class ELFT> void addIgnoredSym(StringRef Name);
 
 private:
   Symbol *insert(SymbolBody *New);
   template <class ELFT> void addELFFile(ELFFileBase *File);
   void addELFFile(ELFFileBase *File);
   void addLazy(Lazy *New);
   void addMemberFile(Lazy *Body);
-  template <class ELFT> void addUndefinedSym(StringRef Name);
+  template <class ELFT> SymbolBody *addUndefinedSym(StringRef Name);
 
   template <class ELFT> void init(uint16_t EMachine);
   template <class ELFT> void resolve(SymbolBody *Body);
   template <class ELFT>
   void dupError(const SymbolBody &Old, const SymbolBody &New);
 
   std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
 

ELF/SymbolTable.cpp

static TargetInfo *createTarget(uint16_t EMachine) {
   case EM_PPC64:
     return new PPC64TargetInfo();
   case EM_X86_64:
     return new X86_64TargetInfo();
   }
   error("Unknown target machine");
 }
 
-void SymbolTable::addUndefinedSym(StringRef Name) {
+SymbolBody *SymbolTable::addUndefinedSym(StringRef Name) {
   switch (getFirstELF()->getELFKind()) {
   case ELF32LEKind:
-    addUndefinedSym<ELF32LE>(Name);
-    break;
+    return addUndefinedSym<ELF32LE>(Name);
   case ELF32BEKind:
-    addUndefinedSym<ELF32BE>(Name);
-    break;
+    return addUndefinedSym<ELF32BE>(Name);
   case ELF64LEKind:
-    addUndefinedSym<ELF64LE>(Name);
-    break;
+    return addUndefinedSym<ELF64LE>(Name);
   case ELF64BEKind:
-    addUndefinedSym<ELF64BE>(Name);
-    break;
+    return addUndefinedSym<ELF64BE>(Name);
   default:
     llvm_unreachable("Invalid kind");
   }
 }
 
-template <class ELFT> void SymbolTable::addUndefinedSym(StringRef Name) {
+template <class ELFT> SymbolBody *SymbolTable::addUndefinedSym(StringRef Name) {
   Undefined<ELFT>::SyntheticOptional.setVisibility(STV_HIDDEN);
-  resolve<ELFT>(new (Alloc)
-                    Undefined<ELFT>(Name, Undefined<ELFT>::SyntheticOptional));
+  auto *U = new (Alloc) Undefined<ELFT>(
+      Name, Undefined<ELFT>::SyntheticOptional);
+  resolve<ELFT>(U);
+  return U;
+}
+
+// Rename Real -> Sym and then Sym -> Wrap. Used for --wrap.
+void SymbolTable::wrap(StringRef Sym, StringRef Wrap, StringRef Real) {
+  if (Symtab.count(Sym) == 0)
+    return;
+  SymbolBody *S = addUndefinedSym(Sym);
+  SymbolBody *W = addUndefinedSym(Wrap);
+  SymbolBody *R = addUndefinedSym(Real);
+  R->setReplacement(S->getReplacement());
+  S->setReplacement(W->getReplacement());
 }
 
 template <class ELFT>
 void SymbolTable::addSyntheticSym(StringRef Name, OutputSection<ELFT> &Section,
                                   typename ELFFile<ELFT>::uintX_t Value) {
   typedef typename DefinedSynthetic<ELFT>::Elf_Sym Elf_Sym;
   auto ESym = new (Alloc) Elf_Sym;
   memset(ESym, 0, sizeof(Elf_Sym));

ELF/Symbols.h

public:
 
   // A SymbolBody has a backreference to a Symbol. Originally they are
   // doubly-linked. A backreference will never change. But the pointer
   // in the Symbol may be mutated by the resolver. If you have a
   // pointer P to a SymbolBody and are not sure whether the resolver
   // has chosen the object among other objects having the same name,
   // you can access P->Backref->Body to get the resolver's result.
   void setBackref(Symbol *P) { Backref = P; }
+  void setReplacement(SymbolBody *B) { Backref->Body = B; }
   SymbolBody *getReplacement() { return Backref ? Backref->Body : this; }
 
   // Decides which symbol should "win" in the symbol table, this or
   // the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
   // they are duplicate (conflicting) symbols.
   template <class ELFT> int compare(SymbolBody *Other);
 
 protected:

test/elf2/Inputs/wrap.s

+.globl foo,__wrap_foo,__real_foo;
+foo        = 0x11000
+__wrap_foo = 0x11010
+__real_foo = 0x11020

test/elf2/wrap.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/wrap.s -o %t2
+
+// 1) Should replace used symbols foo -> __wrap_foo, __real_foo -> foo
+// 2) Should not fail on undefined symbol if it isn't used (bar)
+// RUN: lld -flavor gnu2 -o %t3 %t %t2 -wrap foo -wrap bar
+// RUN: llvm-objdump -d -print-imm-hex %t3 | FileCheck %s
+
+// CHECK: _start:
+// CHECK-NEXT: movl $0x11010, %edx
+// CHECK-NEXT: movl $0x11010, %edx
+// CHECK-NEXT: movl $0x11000, %edx
+
+.global _start;
+_start:
+  movl $foo, %edx
+  movl $__wrap_foo, %edx
+  movl $__real_foo, %edx

test/elf2/wrap2.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+
+// RUN: lld -flavor gnu2 -shared -o %t2 %t -wrap foo -wrap bar -wrap baz
+// RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=CHECK1
+// RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=CHECK2
+// Check aliases of the switch
+// RUN: lld -flavor gnu2 -shared -o %t2 %t --wrap foo -wrap=bar --wrap=baz
+// RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=CHECK1
+// RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=CHECK2
+
+// CHECK1: Symbols [
+// CHECK1-DAG: Name: __wrap_foo
+// CHECK1-DAG: Name: bar
+// CHECK1-DAG: Name: __wrap_baz
+// CHECK1: ]
+
+// CHECK2: Symbols [
+// CHECK2-NOT: Name: foo
+// CHECK2-NOT: Name: __real_foo
+// CHECK2-NOT: Name: __wrap_bar
+// CHECK2-NOT: Name: __real_bar
+// CHECK2-NOT: Name: baz
+// CHECK2-NOT: Name: __real_baz
+// CHECK2: ]
+
+.global _start;
+_start:
+  jmp foo@PLT
+  jmp __real_bar@PLT
+  jmp __wrap_baz@PLT