From 03b4667e14c418041a8a8ec4ce099b1d7ce51a11 Mon Sep 17 00:00:00 2001
From: David Blaikie <dblaikie@gmail.com>
Date: Mon, 29 Sep 2014 21:25:13 +0000
Subject: [PATCH] Unit test r218187, changing
 RTDyldMemoryManager::getSymbolAddress's behavior favor mangled lookup over
 unmangled lookup.

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
---
 .../ExecutionEngine/RTDyldMemoryManager.h     |  6 +++-
 lib/ExecutionEngine/RTDyldMemoryManager.cpp   |  2 +-
 .../ExecutionEngine/ExecutionEngineTest.cpp   | 30 +++++++++++++++++++
 3 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/include/llvm/ExecutionEngine/RTDyldMemoryManager.h b/include/llvm/ExecutionEngine/RTDyldMemoryManager.h
index 75b63dd755d..bbc8684706d 100644
--- 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 a84f880f912..2bade6b6a65 100644
--- 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 326213c9368..ad341c8820f 100644
--- 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"));
+}
+
 }
-- 
2.34.1