[BOLT] Fix plt relocations symbol match

[yota9]

Summary

The BFD linker adds the symbol versioning string to the symbol name in symtab.
Skip the versioning part in order to find the registered PLT function.

Vladislav Khmelevsky,
Advanced Software Technology Lab, Huawei

[Amir]

Can you please follow the example of compiler-rt to check that bfd is available on the test system and only enable the new test if it is?
Check here: compiler-rt/cmake/config-ix.cmake: GNU_LD_EXECUTABLE
And here: compiler-rt/test/lit.common.cfg.py: config.available_features.add('binutils_lto')

bolt/lib/Rewrite/RewriteInstance.cpp

1890

Can you please add an example of a full symbol name with versioning?

bolt/test/Inputs/plt.c

0–1

Can you please keep lld here and add invocation with bfd below as an extra test?

[yota9]

bolt/lib/Rewrite/RewriteInstance.cpp

1890

Sure

[yota9]

Add gnu_ld check + separate test

[maksfb]

bolt/test/runtime/plt_gnu_ld.test

11

Hi @yota9, could you please make the checks for properly updated PLT explicit instead of relying on executing the binary?

[maksfb]

bolt/lib/Rewrite/RewriteInstance.cpp

1886–1889

Could you please factor out the code above? Why is it AArch64-specific?

[yota9]

bolt/lib/Rewrite/RewriteInstance.cpp

1886–1889

Sorry you want me to remove IsAArch64 check? I didn't check it on X86. AFAIU there is no need for x86 to have this code since this is used for aarch64 because there are instruction pairs like adrp + add, which give us the final symbol value in pair, but the X86 may use extracted value for single instruction

bolt/test/runtime/plt_gnu_ld.test

11

I will try t

11

Sorry, something went wrong here :) I will try to do it soon :)

[yota9]

Update tests, move PLT symbol search code to separate function

[maksfb]

Summary: s/linkeradds/linker adds/ and s/symbtab/symtab/

bolt/include/bolt/Core/BinaryContext.h

779

nit: could you use PLT (all caps) in function names to be consistent with the rest of the code in BOLT?

[yota9]

bolt/include/bolt/Core/BinaryContext.h

779

Yes, sure, I always forget about PLT.. :D

[yota9]

Address comments

[maksfb]

@yota9, regarding the tests - will we be able to detect the change in behavior on non-aarch64 (x86) platform? I.e. will any of the tests fail without the fix?

[yota9]

@maksfb I see your point. From the one hand we have a fix. From the other hand the tests are common for x86 and aarch64, i.e. it doesn't check the fix, it checks the overall possibility to work with PLT properly. Ideally we should have aarch64 machine available for testing, we've got this task in the backlog and Elvina should start investigation on aarch64 buildbot soon. As for now I would like these runtime tests to exist, but I will add one more non-runtime aarch64-specific test (that is using BOLT asm dump) so we will be able to check it on non-arm platform

[maksfb]

Great. Adding non-runtime test sounds good to me.

[yota9]

Add non-runtime tests

[maksfb]

@yota9, sorry, AArch64/plt_gnu_ld.test wouldn't build on x86. Could you use YAML and yaml2obj for the test?

[yota9]

Add BFD linked yaml test file

[yota9]

In D122039#3417876, @maksfb wrote:

@yota9, sorry, AArch64/plt_gnu_ld.test wouldn't build on x86. Could you use YAML and yaml2obj for the test?

Done :)

[maksfb]

Could you please rename test files to use "-" instead of "_"?

bolt/test/AArch64/plt_gnu_ld.test

8

I tried that fix locally and got "no PT_LOAD pheader seen" error.

bolt/test/AArch64/plt_lld.test

5

plt.c will not cross-compile since it includes header files.

[yota9]

bolt/test/AArch64/plt_gnu_ld.test

8

The old file was remained on the pass, thanks for the remark.

[yota9]

@maksfb Thanks done

[maksfb]

AArch64/plt-lld.test is still broken.

[yota9]

@maksfb I don't see the reason, everything works for me. Do you use this patch with your aarch64 tests changes? The nostdlib flag should be passed from your patch, I don't see any other problem to run the test on x86.

[yota9]

@maksfb You were right, after rebase on your patch I've got the problems too.
I was sure the undefined symbols with unresolved-symbols=ignore-all option will create PLT entry by using symbol name, but it does not.
Anyway we will just create stub library now for the testing purposes and the problem will gone.

[yota9]

nit header protection

[yota9]

Rebase

bolt/CMakeLists.txt

execute_process(COMMAND ${git_executable} rev-parse HEAD
     RESULT_VARIABLE git_result
     OUTPUT_VARIABLE git_output)
   if( git_result EQUAL 0 )
     string(STRIP "${git_output}" git_ref_id)
     set(BOLT_REVISION "${git_ref_id}")
   endif()
 endif()
 
+find_program(GNU_LD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.bfd ld.bfd DOC "GNU ld")
+
 # If we can't find a revision, set it to "<unknown>".
 if (NOT BOLT_REVISION)
   set(BOLT_REVISION "<unknown>")
 endif()
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/include/bolt/Utils/BoltRevision.inc.in
   ${CMAKE_CURRENT_BINARY_DIR}/include/bolt/Utils/BoltRevision.inc)

bolt/include/bolt/Core/BinaryContext.h

const BinaryData *getBinaryDataByName(StringRef Name) const {
     return Itr != GlobalSymbols.end() ? Itr->second : nullptr;
   }
 
   BinaryData *getBinaryDataByName(StringRef Name) {
     auto Itr = GlobalSymbols.find(Name);
     return Itr != GlobalSymbols.end() ? Itr->second : nullptr;
   }
 
+  /// Return registered PLT entry BinaryData with the given \p Name
+  /// or nullptr if no global PLT symbol with that name exists.
+  const BinaryData *getPLTBinaryDataByName(StringRef Name) const {
+    if (const BinaryData *Data = getBinaryDataByName(Name.str() + "@PLT"))
+      return Data;
+
+    // The symbol name might contain versioning information e.g
+    // memcpy@@GLIBC_2.17. Remove it and try to locate binary data
+    // without it.
+    size_t At = Name.find("@");
+    if (At != std::string::npos)
+      return getBinaryDataByName(Name.str().substr(0, At) + "@PLT");
+
+    return nullptr;
+  }
+
   /// Return true if \p SymbolName was generated internally and was not present
   /// in the input binary.
   bool isInternalSymbolName(const StringRef Name) {
     return Name.startswith("SYMBOLat") || Name.startswith("DATAat") ||
            Name.startswith("HOLEat");
   }
 
   MCSymbol *getHotTextStartSymbol() const {

bolt/lib/Rewrite/RewriteInstance.cpp

bool RewriteInstance::analyzeRelocation(
   } else {
     const SymbolRef &Symbol = *SymbolIter;
     SymbolName = std::string(cantFail(Symbol.getName()));
     SymbolAddress = cantFail(Symbol.getAddress());
     SkipVerification = (cantFail(Symbol.getType()) == SymbolRef::ST_Other);
     // Section symbols are marked as ST_Debug.
     IsSectionRelocation = (cantFail(Symbol.getType()) == SymbolRef::ST_Debug);
     // Check for PLT entry registered with symbol name
     if (!SymbolAddress && IsAArch64) {
-      BinaryData *BD = BC->getBinaryDataByName(SymbolName + "@PLT");
+      const BinaryData *BD = BC->getPLTBinaryDataByName(SymbolName);
       SymbolAddress = BD ? BD->getAddress() : 0;
     }
   }
   // For PIE or dynamic libs, the linker may choose not to put the relocation
   // result at the address if it is a X86_64_64 one because it will emit a
   // dynamic relocation (X86_RELATIVE) for the dynamic linker and loader to
   // resolve it at run time. The static relocation result goes as the addend
   // of the dynamic relocation in this case. We can't verify these cases.
   // FIXME: perhaps we can try to find if it really emitted a corresponding
   // RELATIVE relocation at this offset with the correct value as the addend.
   if (!BC->HasFixedLoadAddress && RelSize == 8)
void lookup(const LookupSet &Symbols,
               OnResolvedFunction OnResolved) override {
     JITSymbolResolver::LookupResult AllResults;
 
     if (BC.EFMM->ObjectsLoaded) {
       for (const StringRef &Symbol : Symbols) {
         std::string SymName = Symbol.str();
         LLVM_DEBUG(dbgs() << "BOLT: looking for " << SymName << "\n");
         // Resolve to a PLT entry if possible
-        if (BinaryData *I = BC.getBinaryDataByName(SymName + "@PLT")) {
+        if (const BinaryData *I = BC.getPLTBinaryDataByName(SymName)) {
           AllResults[Symbol] =
               JITEvaluatedSymbol(I->getAddress(), JITSymbolFlags());
           continue;
         }
         OnResolved(make_error<StringError>(
             "Symbol not found required by runtime: " + Symbol,
             inconvertibleErrorCode()));
         return;

bolt/test/AArch64/plt_gnu_ld.test

+// This test checks that the PLT symbols are properly recognized
+// by the BOLT tool.
+// The test is using bfd linker, since it may add versioning string
+// to the symbol name e.g. memcpy@@GLIBC_2.17
+
+// REQUIRES: gnu_ld
+
+// RUN: %clang %cflags %p/../Inputs/plt.c -fuse-ld=bfd \
+// RUN:    -o %t.bfd.exe -Wl,-q
+// RUN: llvm-bolt %t.bfd.exe -o %t.bfd.bolt.exe -use-old-text=0 -lite=0 \
+// RUN:   -print-cfg -print-only=main | FileCheck %s
+
+// CHECK: memcpy@PLT
+// CHECK: memset@PLT
+// CHECK: printf@PLT

bolt/test/AArch64/plt_lld.test

+// This test checks that the PLT symbols are properly recognized
+// by the BOLT tool.
+
+// RUN: %clang %cflags %p/../Inputs/plt.c -fuse-ld=lld \
+// RUN:    -o %t.lld.exe -Wl,-q
+// RUN: llvm-bolt %t.lld.exe -o %t.lld.bolt.exe -use-old-text=0 -lite=0 \
+// RUN:   -print-cfg -print-only=main | FileCheck %s
+
+// CHECK: memcpy@PLT
+// CHECK: memset@PLT
+// CHECK: printf@PLT

bolt/test/Inputs/plt.c

-// This test checks that the pointers to PLT are properly updated.
-
-// RUN: %clang %cflags %s -fuse-ld=lld \
-// RUN:    -o %t.exe -Wl,-q
-// RUN: llvm-bolt %t.exe -o %t.bolt.exe -use-old-text=0 -lite=0
-// RUN: %t.bolt.exe
-
 #include <string.h>
+#include <stdio.h>
 
 void *(*memcpy_p)(void *dest, const void *src, size_t n);
 void *(*memset_p)(void *dest, int c, size_t n);
 
 int main() {
   int a = 0xdeadbeef, b = 0;
 
   memcpy_p = memcpy;
   memcpy_p(&b, &a, sizeof(b));
   if (b != 0xdeadbeef)
     return 1;
 
   memset_p = memset;
   memset_p(&a, 0, sizeof(a));
   if (a != 0)
     return 1;
+
+  printf("Test completed\n");
 }

bolt/test/lit.cfg.py

if supported:
     lit_config.maxIndividualTestTime = 60
 else:
     lit_config.warning('Setting a timeout per test not supported. ' + errormsg
                        + ' Some tests will be skipped.')
 
 if config.bolt_enable_runtime:
     config.available_features.add("bolt-runtime")
 
+if config.gnu_ld:
+    config.available_features.add("gnu_ld")
+
 llvm_config.use_default_substitutions()
 
 llvm_config.config.environment['CLANG'] = config.bolt_clang
 llvm_config.use_clang()
 
 llvm_config.config.environment['LD_LLD'] = config.bolt_lld
 ld_lld = llvm_config.use_llvm_tool('ld.lld', required=True, search_env='LD_LLD')
 llvm_config.config.available_features.add('ld.lld')

bolt/test/lit.site.cfg.py.in

 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.enable_shared = @ENABLE_SHARED@
 config.enable_backtrace = @ENABLE_BACKTRACES@
 config.host_arch = "@HOST_ARCH@"
 config.enable_abi_breaking_checks = "@LLVM_ENABLE_ABI_BREAKING_CHECKS@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.bolt_clang = "@BOLT_CLANG_EXE@"
 config.bolt_lld = "@BOLT_LLD_EXE@"
+config.gnu_ld = "@GNU_LD_EXECUTABLE@"
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@BOLT_SOURCE_DIR@/test/lit.cfg.py")

bolt/test/runtime/iplt.c

 
 static void *resolver_memcpy(void) { return memcpy; }
 
 __attribute__((ifunc("resolver_memcpy"))) void *
 imemcpy(void *dest, const void *src, size_t n);
 
 int main() {
   int a = 0xdeadbeef, b = 0;
-  ifoo();
   imemcpy(&b, &a, sizeof(b));
-  return a != b;
+  if (a != b)
+    return -1;
+
+  ifoo();
 }

bolt/test/runtime/plt_gnu_ld.test

+// This test checks that the pointers to PLT are properly updated.
+// The test is using bfd linker, since it may add versioning string
+// to the symbol name e.g. memcpy@@GLIBC_2.17
+
+// REQUIRES: gnu_ld
+
+// RUN: %clang %cflags %p/../Inputs/plt.c -fuse-ld=bfd \
+// RUN:    -o %t.bfd.exe -Wl,-q
+// RUN: llvm-bolt %t.bfd.exe -o %t.bfd.bolt.exe -use-old-text=0 -lite=0
+// RUN: %t.bfd.bolt.exe | FileCheck %s
+
+// CHECK: Test completed

bolt/test/runtime/plt_lld.test

+// This test checks that the pointers to PLT are properly updated.
+// The test is using lld linker.
+
+// RUN: %clang %cflags %p/../Inputs/plt.c -fuse-ld=lld \
+// RUN:    -o %t.lld.exe -Wl,-q
+// RUN: llvm-bolt %t.lld.exe -o %t.lld.bolt.exe -use-old-text=0 -lite=0
+// RUN: %t.lld.bolt.exe | FileCheck %s
+
+// CHECK: Test completed