fix GetFunctionAddress for templated functions (#702)

Author: Vipul-Cariappa

lib/CppInterOp/CppInterOp.cpp

@@ -11,6 +11,7 @@
 
 #include "Compatibility.h"
 
+#include "clang/AST/Attrs.inc"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclAccessPair.h"
@@ -48,12 +49,14 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
+#include "llvm/IR/GlobalValue.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/raw_os_ostream.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <algorithm>
 #include <cassert>
@@ -66,6 +69,7 @@
 #include <sstream>
 #include <stack>
 #include <string>
+#include <utility>
 
 // Stream redirect.
 #ifdef _WIN32
@@ -136,6 +140,42 @@ static compat::Interpreter& getInterp() {
 static clang::Sema& getSema() { return getInterp().getCI()->getSema(); }
 static clang::ASTContext& getASTContext() { return getSema().getASTContext(); }
 
+static void ForceCodeGen(Decl* D, compat::Interpreter& I) {
+  // The decl was deferred by CodeGen. Force its emission.
+  // FIXME: In ASTContext::DeclMustBeEmitted we should check if the
+  // Decl::isUsed is set or we should be able to access CodeGen's
+  // addCompilerUsedGlobal.
+  ASTContext& C = I.getSema().getASTContext();
+
+  D->addAttr(UsedAttr::CreateImplicit(C));
+#ifdef CPPINTEROP_USE_CLING
+  cling::Interpreter::PushTransactionRAII RAII(&I);
+  I.getCI()->getASTConsumer().HandleTopLevelDecl(DeclGroupRef(D));
+#else // CLANG_REPL
+  I.getCI()->getASTConsumer().HandleTopLevelDecl(DeclGroupRef(D));
+  // Take the newest llvm::Module produced by CodeGen and send it to JIT.
+  auto GeneratedPTU = I.Parse("");
+  if (!GeneratedPTU)
+    llvm::logAllUnhandledErrors(GeneratedPTU.takeError(), llvm::errs(),
+                                "[ForceCodeGen] Failed to generate PTU:");
+
+  // From cling's BackendPasses.cpp
+  // FIXME: We need to upstream this code in IncrementalExecutor::addModule
+  for (auto& GV : GeneratedPTU->TheModule->globals()) {
+    llvm::GlobalValue::LinkageTypes LT = GV.getLinkage();
+    if (GV.isDeclaration() || !GV.hasName() ||
+        GV.getName().starts_with(".str") ||
+        !llvm::GlobalVariable::isDiscardableIfUnused(LT) ||
+        LT != llvm::GlobalValue::InternalLinkage)
+      continue; // nothing to do
+    GV.setLinkage(llvm::GlobalValue::WeakAnyLinkage);
+  }
+  if (auto Err = I.Execute(*GeneratedPTU))
+    llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(),
+                                "[ForceCodeGen] Failed to execute PTU:");
+#endif
+}
+
 #define DEBUG_TYPE "jitcall"
 bool JitCall::AreArgumentsValid(void* result, ArgList args, void* self,
                                 size_t nary) const {
@@ -1335,8 +1375,16 @@ static TCppFuncAddr_t GetFunctionAddress(const FunctionDecl* FD) {
 
 TCppFuncAddr_t GetFunctionAddress(TCppFunction_t method) {
   auto* D = static_cast<Decl*>(method);
-  if (auto* FD = llvm::dyn_cast_or_null<FunctionDecl>(D))
+  if (auto* FD = llvm::dyn_cast_or_null<FunctionDecl>(D)) {
+    if ((IsTemplateInstantiationOrSpecialization(FD) ||
+         FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization) &&
+        !FD->getDefinition())
+      InstantiateFunctionDefinition(D);
+    ASTContext& C = getASTContext();
+    if (isDiscardableGVALinkage(C.GetGVALinkageForFunction(FD)))
+      ForceCodeGen(FD, getInterp());
     return GetFunctionAddress(FD);
+  }
   return nullptr;
 }
 
@@ -1554,39 +1602,8 @@ intptr_t GetVariableOffset(compat::Interpreter& I, Decl* D,
     }
     if (!address) {
       auto Linkage = C.GetGVALinkageForVariable(VD);
-      // The decl was deferred by CodeGen. Force its emission.
-      // FIXME: In ASTContext::DeclMustBeEmitted we should check if the
-      // Decl::isUsed is set or we should be able to access CodeGen's
-      // addCompilerUsedGlobal.
       if (isDiscardableGVALinkage(Linkage))
-        VD->addAttr(UsedAttr::CreateImplicit(C));
-#ifdef CPPINTEROP_USE_CLING
-      cling::Interpreter::PushTransactionRAII RAII(&I);
-      I.getCI()->getASTConsumer().HandleTopLevelDecl(DeclGroupRef(VD));
-#else // CLANG_REPL
-      I.getCI()->getASTConsumer().HandleTopLevelDecl(DeclGroupRef(VD));
-      // Take the newest llvm::Module produced by CodeGen and send it to JIT.
-      auto GeneratedPTU = I.Parse("");
-      if (!GeneratedPTU)
-        llvm::logAllUnhandledErrors(
-            GeneratedPTU.takeError(), llvm::errs(),
-            "[GetVariableOffset] Failed to generate PTU:");
-
-      // From cling's BackendPasses.cpp
-      // FIXME: We need to upstream this code in IncrementalExecutor::addModule
-      for (auto& GV : GeneratedPTU->TheModule->globals()) {
-        llvm::GlobalValue::LinkageTypes LT = GV.getLinkage();
-        if (GV.isDeclaration() || !GV.hasName() ||
-            GV.getName().starts_with(".str") || !GV.isDiscardableIfUnused(LT) ||
-            LT != llvm::GlobalValue::InternalLinkage)
-          continue; // nothing to do
-        GV.setLinkage(llvm::GlobalValue::WeakAnyLinkage);
-      }
-      if (auto Err = I.Execute(*GeneratedPTU))
-        llvm::logAllUnhandledErrors(
-            std::move(Err), llvm::errs(),
-            "[GetVariableOffset] Failed to execute PTU:");
-#endif
+        ForceCodeGen(VD, I);
     }
     auto VDAorErr = compat::getSymbolAddress(I, StringRef(mangledName));
     if (!VDAorErr) {

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1469,6 +1469,23 @@ TEST(FunctionReflectionTest, GetFunctionAddress) {
   EXPECT_EQ(address.str(), output);
 
   EXPECT_FALSE(Cpp::GetFunctionAddress(Cpp::GetGlobalScope()));
+
+  Interp->declare(R"(
+    template <typename T>
+    T add1(T t) { return t + 1; }
+  )");
+
+  std::vector<Cpp::TCppFunction_t> funcs;
+  Cpp::GetClassTemplatedMethods("add1", Cpp::GetGlobalScope(), funcs);
+  EXPECT_EQ(funcs.size(), 1);
+
+  ASTContext& C = Interp->getCI()->getASTContext();
+  std::vector<Cpp::TemplateArgInfo> argument = {C.DoubleTy.getAsOpaquePtr()};
+  Cpp::TCppScope_t add1_double =
+      Cpp::InstantiateTemplate(funcs[0], argument.data(), argument.size());
+  EXPECT_TRUE(add1_double);
+
+  EXPECT_TRUE(Cpp::GetFunctionAddress(add1_double));
 }
 
 TEST(FunctionReflectionTest, IsVirtualMethod) {