Unit test r218187, changing RTDyldMemoryManager::getSymbolAddress's behavior favor...

The contract of this function seems problematic (fallback in either
direction seems like it could produce bugs in one client or another),
but here's some tests for its current behavior, at least. See the
commit/review thread of r218187 for more discussion.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218626 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/ExecutionEngine/RTDyldMemoryManager.h b/include/llvm/ExecutionEngine/RTDyldMemoryManager.h
index 75b63dd755daaa74fbb2e9b991aeafb4b5520195..bbc8684706dd2510eaa80a3e0d3de369d73c92e4 100644 (file)
--- a/include/llvm/ExecutionEngine/RTDyldMemoryManager.h
+++ b/include/llvm/ExecutionEngine/RTDyldMemoryManager.h
@@ -24,6 +24,8 @@ namespace llvm {
 class ExecutionEngine;
 class ObjectImage;
 
+uint64_t getSymbolAddress(const std::string &Name);
+
 // RuntimeDyld clients often want to handle the memory management of
 // what gets placed where. For JIT clients, this is the subset of
 // JITMemoryManager required for dynamic loading of binaries.
@@ -78,7 +80,9 @@ public:
 
   /// This method returns the address of the specified function or variable.
   /// It is used to resolve symbols during module linking.
-  virtual uint64_t getSymbolAddress(const std::string &Name);
+  virtual uint64_t getSymbolAddress(const std::string &Name) {
+    return llvm::getSymbolAddress(Name);
+  }
 
   /// This method returns the address of the specified function. As such it is
   /// only useful for resolving library symbols, not code generated symbols.

diff --git a/lib/ExecutionEngine/RTDyldMemoryManager.cpp b/lib/ExecutionEngine/RTDyldMemoryManager.cpp
index a84f880f9122f678b2ec9da09d4311f2244de1a9..2bade6b6a6563d53bba9a5fbdb69f3c1f67ab87d 100644 (file)
--- a/lib/ExecutionEngine/RTDyldMemoryManager.cpp
+++ b/lib/ExecutionEngine/RTDyldMemoryManager.cpp
@@ -210,7 +210,7 @@ ARM_MATH_IMPORTS(ARM_MATH_DECL)
 #undef ARM_MATH_DECL
 #endif
 
-uint64_t RTDyldMemoryManager::getSymbolAddress(const std::string &Name) {
+uint64_t getSymbolAddress(const std::string &Name) {
   // This implementation assumes that the host program is the target.
   // Clients generating code for a remote target should implement their own
   // memory manager.

diff --git a/unittests/ExecutionEngine/ExecutionEngineTest.cpp b/unittests/ExecutionEngine/ExecutionEngineTest.cpp
index 326213c93681ef5cb0881607846c1af3257fb060..ad341c8820fb24140bf126cee654b11561c5dc40 100644 (file)
--- a/unittests/ExecutionEngine/ExecutionEngineTest.cpp
+++ b/unittests/ExecutionEngine/ExecutionEngineTest.cpp
@@ -8,10 +8,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Interpreter.h"
+#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "gtest/gtest.h"
 
@@ -132,4 +134,32 @@ TEST_F(ExecutionEngineTest, DestructionRemovesGlobalMapping) {
   EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
 }
 
+TEST_F(ExecutionEngineTest, LookupWithMangledName) {
+  int x;
+  llvm::sys::DynamicLibrary::AddSymbol("x", &x);
+
+  // Demonstrate that getSymbolAddress accepts mangled names and always strips
+  // the leading underscore.
+  EXPECT_EQ(reinterpret_cast<uint64_t>(&x), getSymbolAddress("_x"));
+}
+
+TEST_F(ExecutionEngineTest, LookupWithMangledAndDemangledSymbol) {
+  int x;
+  int _x;
+  llvm::sys::DynamicLibrary::AddSymbol("x", &x);
+  llvm::sys::DynamicLibrary::AddSymbol("_x", &_x);
+
+  // Lookup the demangled name first, even if there's a demangled symbol that
+  // matches the input already.
+  EXPECT_EQ(reinterpret_cast<uint64_t>(&x), getSymbolAddress("_x"));
+}
+
+TEST_F(ExecutionEngineTest, LookupwithDemangledName) {
+  int _x;
+  llvm::sys::DynamicLibrary::AddSymbol("_x", &_x);
+
+  // But do fallback to looking up a demangled name if there's no ambiguity
+  EXPECT_EQ(reinterpret_cast<uint64_t>(&_x), getSymbolAddress("_x"));
+}
+
 }