Declare clang-repl value printing symbols, mangle and define to the JIT

Supports LLVM 18-21

Author: aaronj0

lib/CppInterOp/CppInterOp.cpp

@@ -64,6 +64,7 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <cstdint>
 #include <cstdio>
 #include <deque>
 #include <iterator>
@@ -94,6 +95,34 @@
 #include <unistd.h>
 #endif // WIN32
 
+//  Runtime symbols required if the library using JIT (Cpp::Evaluate) does not
+//  link to llvm
+#if !defined(CPPINTEROP_USE_CLING) && !defined(EMSCRIPTEN)
+struct __clang_Interpreter_NewTag {
+} __ci_newtag;
+#if CLANG_VERSION_MAJOR > 21
+extern "C" void* __clang_Interpreter_SetValueWithAlloc(void* This, void* OutVal,
+                                                       void* OpaqueType)
+#else
+void* __clang_Interpreter_SetValueWithAlloc(void* This, void* OutVal,
+                                            void* OpaqueType);
+#endif
+
+#if CLANG_VERSION_MAJOR > 18
+    extern "C" void __clang_Interpreter_SetValueNoAlloc(void* This,
+                                                        void* OutVal,
+                                                        void* OpaqueType, ...);
+#else
+void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*);
+void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, void*);
+void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, float);
+void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, double);
+void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*, long double);
+void __clang_Interpreter_SetValueNoAlloc(void*, void*, void*,
+                                         unsigned long long);
+#endif
+#endif // CPPINTEROP_USE_CLING
+
 namespace Cpp {
 
 using namespace clang;
@@ -3306,6 +3335,88 @@ TInterp_t CreateInterpreter(const std::vector<const char*>& Args /*={}*/,
 
   sInterpreters->emplace_back(I, /*Owned=*/true);
 
+// Define runtime symbols in the JIT dylib for clang-repl
+#if !defined(CPPINTEROP_USE_CLING) && !defined(EMSCRIPTEN)
+  DefineAbsoluteSymbol(*I, "__ci_newtag",
+                       reinterpret_cast<uint64_t>(&__ci_newtag));
+// llvm > 22 has this defined as a C symbol that does not require mangling
+#if CLANG_VERSION_MAJOR >= 22
+  DefineAbsoluteSymbol(
+      *I, "__clang_Interpreter_SetValueWithAlloc",
+      reinterpret_cast<uint64_t>(&__clang_Interpreter_SetValueWithAlloc));
+#else
+  // obtain mangled name
+  auto* D = static_cast<clang::Decl*>(
+      Cpp::GetNamed("__clang_Interpreter_SetValueWithAlloc"));
+  if (auto* FD = llvm::dyn_cast<FunctionDecl>(D)) {
+    auto GD = GlobalDecl(FD);
+    std::string mangledName;
+    compat::maybeMangleDeclName(GD, mangledName);
+    DefineAbsoluteSymbol(
+        *I, mangledName.c_str(),
+        reinterpret_cast<uint64_t>(&__clang_Interpreter_SetValueWithAlloc));
+  }
+#endif
+// llvm < 19 has multiple overloads of __clang_Interpreter_SetValueNoAlloc
+#if CLANG_VERSION_MAJOR < 19
+  // obtain all 6 candidates, and obtain the correct Decl for each overload
+  // using BestOverloadFunctionMatch. We then map the decl to the correct
+  // function pointer (force the compiler to find the right declarion by casting
+  // to the corresponding function pointer signature) and then register it.
+  const std::vector<TCppFunction_t> Methods = Cpp::GetFunctionsUsingName(
+      Cpp::GetGlobalScope(), "__clang_Interpreter_SetValueNoAlloc");
+  std::string mangledName;
+  ASTContext& Ctxt = I->getSema().getASTContext();
+  auto* TAI = Ctxt.VoidPtrTy.getAsOpaquePtr();
+
+  // possible parameter lists for __clang_Interpreter_SetValueNoAlloc overloads
+  // in LLVM 18
+  const std::vector<std::vector<Cpp::TemplateArgInfo>> a_params = {
+      {TAI, TAI, TAI},
+      {TAI, TAI, TAI, TAI},
+      {TAI, TAI, TAI, Ctxt.FloatTy.getAsOpaquePtr()},
+      {TAI, TAI, TAI, Ctxt.DoubleTy.getAsOpaquePtr()},
+      {TAI, TAI, TAI, Ctxt.LongDoubleTy.getAsOpaquePtr()},
+      {TAI, TAI, TAI, Ctxt.UnsignedLongLongTy.getAsOpaquePtr()}};
+
+  using FP0 = void (*)(void*, void*, void*);
+  using FP1 = void (*)(void*, void*, void*, void*);
+  using FP2 = void (*)(void*, void*, void*, float);
+  using FP3 = void (*)(void*, void*, void*, double);
+  using FP4 = void (*)(void*, void*, void*, long double);
+  using FP5 = void (*)(void*, void*, void*, unsigned long long);
+
+  const std::vector<void*> func_pointers = {
+      reinterpret_cast<void*>(
+          static_cast<FP0>(&__clang_Interpreter_SetValueNoAlloc)),
+      reinterpret_cast<void*>(
+          static_cast<FP1>(&__clang_Interpreter_SetValueNoAlloc)),
+      reinterpret_cast<void*>(
+          static_cast<FP2>(&__clang_Interpreter_SetValueNoAlloc)),
+      reinterpret_cast<void*>(
+          static_cast<FP3>(&__clang_Interpreter_SetValueNoAlloc)),
+      reinterpret_cast<void*>(
+          static_cast<FP4>(&__clang_Interpreter_SetValueNoAlloc)),
+      reinterpret_cast<void*>(
+          static_cast<FP5>(&__clang_Interpreter_SetValueNoAlloc))};
+
+  // these symbols are not externed, so we need to mangle their names
+  for (size_t i = 0; i < a_params.size(); ++i) {
+    auto* decl = static_cast<clang::Decl*>(
+        Cpp::BestOverloadFunctionMatch(Methods, {}, a_params[i]));
+    if (auto* fd = llvm::dyn_cast<clang::FunctionDecl>(decl)) {
+      auto gd = clang::GlobalDecl(fd);
+      compat::maybeMangleDeclName(gd, mangledName);
+      DefineAbsoluteSymbol(*I, mangledName.c_str(),
+                           reinterpret_cast<uint64_t>(func_pointers[i]));
+    }
+  }
+#else
+  DefineAbsoluteSymbol(
+      *I, "__clang_Interpreter_SetValueNoAlloc",
+      reinterpret_cast<uint64_t>(&__clang_Interpreter_SetValueNoAlloc));
+#endif
+#endif
   return I;
 }