[clang-repl] JITTargetAddress --> ExecutorAddr

[junaire]

Summary

Signed-off-by: Jun Zhang <[e-mail]>

[junaire]

Avoid unnecessary changes

[sgraenitz]

Thanks. Maybe you can fix this one detail and add a description like "Most of Orc and JITLink are movinng away from JITTargetAddress and use ExecutorAddr instead"? Otherwise LGTM.

clang/lib/Interpreter/IncrementalExecutor.cpp

88

I think Sym is a Expected<ExecutorAddr> already

[junaire]

clang/lib/Interpreter/IncrementalExecutor.cpp

88

good catch, thx!

clang/include/clang/Interpreter/Interpreter.h

 #ifndef LLVM_CLANG_INTERPRETER_INTERPRETER_H
 #define LLVM_CLANG_INTERPRETER_INTERPRETER_H
 
 #include "clang/Interpreter/PartialTranslationUnit.h"
 
 #include "clang/AST/GlobalDecl.h"
 
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/Error.h"
 
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace orc {
 class LLJIT;
public:
   }
 
   /// Undo N previous incremental inputs.
   llvm::Error Undo(unsigned N = 1);
 
   /// Link a dynamic library
   llvm::Error LoadDynamicLibrary(const char *name);
 
-  /// \returns the \c JITTargetAddress of a \c GlobalDecl. This interface uses
+  /// \returns the \c ExecutorAddr of a \c GlobalDecl. This interface uses
   /// the CodeGenModule's internal mangling cache to avoid recomputing the
   /// mangled name.
-  llvm::Expected<llvm::JITTargetAddress> getSymbolAddress(GlobalDecl GD) const;
+  llvm::Expected<llvm::orc::ExecutorAddr> getSymbolAddress(GlobalDecl GD) const;
 
-  /// \returns the \c JITTargetAddress of a given name as written in the IR.
-  llvm::Expected<llvm::JITTargetAddress>
+  /// \returns the \c ExecutorAddr of a given name as written in the IR.
+  llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddress(llvm::StringRef IRName) const;
 
-  /// \returns the \c JITTargetAddress of a given name as written in the object
+  /// \returns the \c ExecutorAddr of a given name as written in the object
   /// file.
-  llvm::Expected<llvm::JITTargetAddress>
+  llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const;
 };
 } // namespace clang
 
 #endif // LLVM_CLANG_INTERPRETER_INTERPRETER_H

clang/lib/Interpreter/IncrementalExecutor.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H
 #define LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 
 #include <memory>
 
 namespace llvm {
 class Error;
 namespace orc {
 class LLJIT;
 class ThreadSafeContext;
public:
   IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC, llvm::Error &Err,
                       const clang::TargetInfo &TI);
   ~IncrementalExecutor();
 
   llvm::Error addModule(PartialTranslationUnit &PTU);
   llvm::Error removeModule(PartialTranslationUnit &PTU);
   llvm::Error runCtors() const;
   llvm::Error cleanUp();
-  llvm::Expected<llvm::JITTargetAddress>
+  llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddress(llvm::StringRef Name, SymbolNameKind NameKind) const;
 
   llvm::orc::LLJIT &GetExecutionEngine() { return *Jit; }
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H

clang/lib/Interpreter/IncrementalExecutor.cpp

llvm::Error IncrementalExecutor::cleanUp() {
   // This calls the global dtors of registered modules.
   return Jit->deinitialize(Jit->getMainJITDylib());
 }
 
 llvm::Error IncrementalExecutor::runCtors() const {
   return Jit->initialize(Jit->getMainJITDylib());
 }
 
-llvm::Expected<llvm::JITTargetAddress>
+llvm::Expected<llvm::orc::ExecutorAddr>
 IncrementalExecutor::getSymbolAddress(llvm::StringRef Name,
                                       SymbolNameKind NameKind) const {
   auto Sym = (NameKind == LinkerName) ? Jit->lookupLinkerMangled(Name)
                                       : Jit->lookup(Name);
 
   if (!Sym)
     return Sym.takeError();
-  return Sym->getValue();
+  return Sym;
 }
 
 } // end namespace clang

clang/lib/Interpreter/Interpreter.cpp

if (auto Err = IncrExecutor->addModule(T))
     return Err;
 
   if (auto Err = IncrExecutor->runCtors())
     return Err;
 
   return llvm::Error::success();
 }
 
-llvm::Expected<llvm::JITTargetAddress>
+llvm::Expected<llvm::orc::ExecutorAddr>
 Interpreter::getSymbolAddress(GlobalDecl GD) const {
   if (!IncrExecutor)
     return llvm::make_error<llvm::StringError>("Operation failed. "
                                                "No execution engine",
                                                std::error_code());
   llvm::StringRef MangledName = IncrParser->GetMangledName(GD);
   return getSymbolAddress(MangledName);
 }
 
-llvm::Expected<llvm::JITTargetAddress>
+llvm::Expected<llvm::orc::ExecutorAddr>
 Interpreter::getSymbolAddress(llvm::StringRef IRName) const {
   if (!IncrExecutor)
     return llvm::make_error<llvm::StringError>("Operation failed. "
                                                "No execution engine",
                                                std::error_code());
 
   return IncrExecutor->getSymbolAddress(IRName, IncrementalExecutor::IRName);
 }
 
-llvm::Expected<llvm::JITTargetAddress>
+llvm::Expected<llvm::orc::ExecutorAddr>
 Interpreter::getSymbolAddressFromLinkerName(llvm::StringRef Name) const {
   if (!IncrExecutor)
     return llvm::make_error<llvm::StringError>("Operation failed. "
                                                "No execution engine",
                                                std::error_code());
 
   return IncrExecutor->getSymbolAddress(Name, IncrementalExecutor::LinkerName);
 }

clang/unittests/Interpreter/ExceptionTests/InterpreterExceptionTest.cpp

 #include "clang/Config/config.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm-c/Error.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
 namespace {
 using Args = std::vector<const char *>;
extern "C" int throw_exception() {
   // FIXME: libunwind on darwin is broken, see PR49692.
   if (Triple.isOSDarwin() && (Triple.getArch() == llvm::Triple::aarch64 ||
                               Triple.getArch() == llvm::Triple::aarch64_32))
     GTEST_SKIP();
 
   llvm::cantFail(Interp->ParseAndExecute(ExceptionCode));
   testing::internal::CaptureStdout();
   auto ThrowException =
-      (int (*)())llvm::cantFail(Interp->getSymbolAddress("throw_exception"));
+      llvm::cantFail(Interp->getSymbolAddress("throw_exception"))
+          .toPtr<int (*)()>();
   EXPECT_ANY_THROW(ThrowException());
   std::string CapturedStdOut = testing::internal::GetCapturedStdout();
   EXPECT_EQ(CapturedStdOut, "Caught: 'To be caught in JIT'\n");
 }
 
 } // end anonymous namespace

clang/unittests/Interpreter/InterpreterTest.cpp

#endif
   if (llvm::Error Err = Interp->Execute(PTU)) {
     // We cannot execute on the platform.
     consumeError(std::move(Err));
     return;
   }
 
   std::string MangledName = MangleName(FD);
   auto Addr = cantFail(Interp->getSymbolAddress(MangledName));
-  EXPECT_NE(0U, Addr);
+  EXPECT_NE(0U, Addr.getValue());
   GlobalDecl GD(FD);
   EXPECT_EQ(Addr, cantFail(Interp->getSymbolAddress(GD)));
 }
 
 static void *AllocateObject(TypeDecl *TD, Interpreter &Interp) {
   std::string Name = TD->getQualifiedNameAsString();
   const clang::Type *RDTy = TD->getTypeForDecl();
   clang::ASTContext &C = Interp.getCompilerInstance()->getASTContext();
#endif
 
   // Find back the template specialization
   VarDecl *VD = static_cast<VarDecl *>(*PTUDeclRange.begin());
   UnaryOperator *UO = llvm::cast<UnaryOperator>(VD->getInit());
   NamedDecl *TmpltSpec = llvm::cast<DeclRefExpr>(UO->getSubExpr())->getDecl();
 
   std::string MangledName = MangleName(TmpltSpec);
   typedef int (*TemplateSpecFn)(void *);
-  auto fn = (TemplateSpecFn)cantFail(Interp->getSymbolAddress(MangledName));
+  auto fn =
+      cantFail(Interp->getSymbolAddress(MangledName)).toPtr<TemplateSpecFn>();
   EXPECT_EQ(42, fn(NewA));
   free(NewA);
 }
 
 } // end anonymous namespace