Refine our --wrap implementation

[• rafael]

Summary

Before this patch we copy foo into real_foo and wrap_foo into foo. The net result is that __wrap_foo shows up twice in the symbol table.

With this patch we save a copy of real_foo and put it in the symbol table slow that was used by the original wrap_foo. We also omit it from the final output if it was undefined.

The net result is that

• Anything using foo now uses __wrap_foo
• Anything using __real_foo now uses foo.
• Anything using __wrap_foo still does.

And

• The slot for foo now has __wrap_foo
• The slot for __real_foo now has foo
• The slot for wrap_foo now has real_foo

Which I think is the desired behavior.

[jhenderson]

Could we get the full diff context, please?

[• rafael]

full context

[jhenderson]

I'm not sure I understand the motivation behind this change (or @ruiu's original change to add the symbol). Why are we creating __real_foo at all?

test/ELF/wrap.s

23

This doesn't look right to me at all. __real_foo, __wrap_foo and foo can't all have different values. Surely there should be only two different values between these three, because there are only two functions in the code?

[ruiu]

test/ELF/wrap.s

23

__wrap_foo and foo should have the same value, but __real_foo shouldn't, because it should have a value of the original function instead of your wrapper function. So I think this is correct.

[jhenderson]

test/ELF/wrap.s

23

I disagree with this. The current meaning of --wrap in other linkers is to redirect references to symbols, not to change the symbols themselves, so if anything, __real_foo and foo should have the same value and __wrap_foo a second, different value. (As an aside, the current test has three different values, not two, so is definitely wrong).

I don't understand why we need __real_foo at all - it's not actually a function in the user's source for example.

There is a serious danger that this could confuse users when they try to debug their code. By having multiple symbols for the same address, there is a potentially negative impact on the call stack displayed by the debugger - it has the right to pick whichever symbol it feels like (it may not even be deterministic about this). For example, this could mean that when the code crashes in the __wrap_foo() function, it could say that the crash occurs in foo(). The user then stares at the foo() function in their source code and cannot see anything wrong with it, because the problem isn't there.

[jhenderson]

test/ELF/wrap.s

23

Rafael posted the following on the mailing list, so I've included it here for completeness:

This actually implements the same behavior as bfd. The symbol references
become:

201000:       ba 10 10 01 00          mov    $0x11010,%edx
 201005:       ba 10 10 01 00          mov    $0x11010,%edx
 20100a:       ba 00 10 01 00          mov    $0x11000,%edx

And the symbols in the symbol table are unchanged:

0000000000011000 A foo
0000000000011020 A __real_foo
0000000000011010 A __wrap_foo

Cheers,
Rafael

Oh, I see what's going on now! I'd completely missed the second input to the test that defined all three symbols, so I was incorrectly assuming that only __wrap_foo and foo were defined. My apologies for the confusion.

FWIW, if __real_foo isn't defined in the test input, then it's not included in the bfd output, which was the case I was thinking of. It feels like this test case is missing.

I still disagree with @ruiu about __wrap_foo and foo having the same value in the symbol table (I don't think they should, and neither does bfd), although of course references to them in the code should be patched to the same value (i.e. to __wrap_foo) when using --wrap.

I now have no objection to this test change.

[• rafael]

Drop __real_foo from the symbol table if it was originally undefined.

[smeenai]

Context is missing again.

[• rafael]

now with context

[ruiu]

ELF/SymbolTable.cpp

173

Foo?

174

Real is already a Symbol*.

201–203

Is this correct? I thought foo becomes real_foo and wrap_foo becomes foo.

[• rafael]

Fix silly variable name.

[ruiu]

ELF/SymbolTable.cpp

201–203

I think I figured out why you want to rotate three symbols instead of just overwriting two symbols foo and wrap_foo. So, you want to keep these three symbols somehow in the symbol table so that they'll be emitted to the output symbol table, and you are reusing the symbol table slot for wrap_foo to keep real_foo, right?

What confused me was, after rotating three symbols, find("wrap_foo") returns real_foo. That is counter-intuitive because I didn't expect "--wrap foo" changes not only foo and real_foo but wrap_foo. Can you fix this?

[• rafael]

Use a new slot for __real_foo.

[ruiu]

LGTM

[• espindola]

315097

ELF/Config.h

struct Configuration {
   std::vector<llvm::StringRef> AuxiliaryList;
   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;
+  std::vector<std::pair<unsigned, Symbol *>> WrapSymbols;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool ColorDiagnostics = false;
   bool CompressDebugSections;
   bool DefineCommon;
   bool Demangle = true;

ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable<ELFT>::addSymbolWrap(StringRef Name) {
   Symbol *Real = addUndefined(Saver.save("__real_" + Name));
   Symbol *Wrap = addUndefined(Saver.save("__wrap_" + Name));
 
   // Tell LTO not to eliminate this symbol
   Wrap->IsUsedInRegularObj = true;
 
   Config->RenamedSymbols[Real] = {Sym, Real->Binding};
   Config->RenamedSymbols[Sym] = {Wrap, Sym->Binding};
+
+  auto It = Symtab.find(CachedHashStringRef(Wrap->body()->getName()));
+  std::pair<unsigned, Symbol *> Foo =
+      std::make_pair<unsigned, Symbol *>(It->second.Idx, (Symbol *)Real);
+  Config->WrapSymbols.push_back(Foo);
 }
 
 // Creates alias for symbol. Used to implement --defsym=ALIAS=SYM.
 template <class ELFT> void SymbolTable<ELFT>::addSymbolAlias(StringRef Alias,
                                                              StringRef Name) {
   SymbolBody *B = find(Name);
   if (!B) {
     error("-defsym: undefined symbol: " + Name);
     return;
   }
   Symbol *Sym = B->symbol();
   Symbol *AliasSym = addUndefined(Alias);
 
   // Tell LTO not to eliminate this symbol
   Sym->IsUsedInRegularObj = true;
   Config->RenamedSymbols[AliasSym] = {Sym, AliasSym->Binding};
 }
 
 // Apply symbol renames created by -wrap and -defsym. The renames are created
 // before LTO in addSymbolWrap() and addSymbolAlias() to have a chance to inform
 // LTO (if LTO is running) not to include these symbols in IPO. Now that the
 // symbols are finalized, we can perform the replacement.
 template <class ELFT> void SymbolTable<ELFT>::applySymbolRenames() {
+  std::vector<Symbol> Origs;
+  Origs.resize(Config->WrapSymbols.size());
+  for (unsigned I = 0, N = Config->WrapSymbols.size(); I < N; ++I) {
+    Symbol *S = Config->WrapSymbols[I].second;
+    memcpy(&Origs[I], S, sizeof(Symbol));
+  }
   for (auto &KV : Config->RenamedSymbols) {
     Symbol *Dst = KV.first;
     Symbol *Src = KV.second.Target;
     Dst->body()->copy(Src->body());
     Dst->Binding = KV.second.OriginalBinding;
   }
+  for (unsigned I = 0, N = Config->WrapSymbols.size(); I < N; ++I) {
+    unsigned Idx = Config->WrapSymbols[I].first;
+    SymVector[Idx] = make<Symbol>();
+    memcpy(SymVector[Idx], &Origs[I], sizeof(Symbol));
+  }
 }
 
 static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
   if (VA == STV_DEFAULT)
     return VB;
   if (VB == STV_DEFAULT)
     return VA;
   return std::min(VA, VB);

test/ELF/lto/wrap-2.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %S/Inputs/wrap-bar.ll -o %t1.o
 ; RUN: ld.lld %t.o %t1.o -shared -o %t.so -wrap=bar
 ; RUN: llvm-objdump -d %t.so | FileCheck %s
 ; RUN: llvm-readobj -t %t.so | FileCheck -check-prefix=BIND %s
 
 ; Make sure that calls in foo() are not eliminated and that bar is
 ; routed to __wrap_bar and __real_bar is routed to bar.
 
 ; CHECK:      foo:
 ; CHECK-NEXT: pushq %rax
 ; CHECK-NEXT: callq{{.*}}<__wrap_bar>
 ; CHECK-NEXT: callq{{.*}}<bar>
 
 ; Check that bar and __wrap_bar retain their original binding.
-; BIND:      Name: bar
+; BIND:      Name: __wrap_bar
 ; BIND-NEXT: Value:
 ; BIND-NEXT: Size:
 ; BIND-NEXT: Binding: Local
-; BIND:      Name: __wrap_bar
+; BIND:      Name: bar
 ; BIND-NEXT: Value:
 ; BIND-NEXT: Size:
 ; BIND-NEXT: Binding: Local
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @bar()
 declare void @__real_bar()
 
 define void @foo() {
   call void @bar()
   call void @__real_bar()
   ret void
 }

test/ELF/wrap.s

 
 // This shows an oddity of our implementation. The symbol foo gets
 // mapped to __wrap_foo, but stays in the symbol table. This results
 // in it showing up twice in the output.
 
 // RUN: llvm-readobj -t -s %t3 | FileCheck -check-prefix=SYM %s
 // SYM:      Name: foo
 // SYM-NEXT: Value: 0x11000
-// SYM:      Name: __wrap_foo
-// SYM-NEXT: Value: 0x11010
+// SYM:      Name: __real_foo
+// SYM-NEXT: Value: 0x11020
 // SYM:      Name: __wrap_foo
 // SYM-NEXT: Value: 0x11010
 
 .global _start
 _start:
   movl $foo, %edx
   movl $__wrap_foo, %edx
   movl $__real_foo, %edx