Remove cling 1.0 support

Author: mcbarton

CMakeLists.txt

@@ -67,13 +67,13 @@ if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
 include(GNUInstallDirs)
   ## Define supported version of clang and llvm
 
-  set(CLANG_MIN_SUPPORTED 13.0)
+  set(CLANG_MIN_SUPPORTED 16.0)
   set(CLANG_MAX_SUPPORTED "20.1.x")
   set(CLANG_VERSION_UPPER_BOUND 21.0.0)
-  set(LLD_MIN_SUPPORTED 13.0)
+  set(LLD_MIN_SUPPORTED 16.0)
   set(LLD_MAX_SUPPORTED "20.1.x")
   set(LLD_VERSION_UPPER_BOUND 21.0.0)
-  set(LLVM_MIN_SUPPORTED 13.0)
+  set(LLVM_MIN_SUPPORTED 16.0)
   set(LLVM_MAX_SUPPORTED "20.1.x")
   set(LLVM_VERSION_UPPER_BOUND 21.0.0)
 
@@ -230,21 +230,12 @@ endif()
   message(STATUS "Found supported version: Clang ${CLANG_PACKAGE_VERSION}")
   message(STATUS "Using ClangConfig.cmake in: ${Clang_DIR}")
 
-  ## Clang 13 require c++14 or later, Clang 16 require c++17 or later.
-  if (CLANG_VERSION_MAJOR GREATER_EQUAL 16)
-    if (NOT CMAKE_CXX_STANDARD)
-      set (CMAKE_CXX_STANDARD 17)
-    endif()
-    if (CMAKE_CXX_STANDARD LESS 17)
-      message(fatal "LLVM/CppInterOp requires c++17 or later")
-    endif()
-  elseif (CLANG_VERSION_MAJOR GREATER_EQUAL 13)
-    if (NOT CMAKE_CXX_STANDARD)
-      set (CMAKE_CXX_STANDARD 14)
-    endif()
-    if (CMAKE_CXX_STANDARD LESS 14)
-      message(fatal "LLVM/CppInterOp requires c++14 or later")
-    endif()
+  ## Clang 16 require c++17 or later.
+  if (NOT CMAKE_CXX_STANDARD)
+    set (CMAKE_CXX_STANDARD 17)
+  endif()
+  if (CMAKE_CXX_STANDARD LESS 17)
+    message(fatal "LLVM/CppInterOp requires c++17 or later")
   endif()
 
   ## Find supported Cling

lib/Interpreter/Compatibility.h

@@ -112,35 +112,7 @@ inline void maybeMangleDeclName(const clang::GlobalDecl& GD,
 /// The getExecutionEngine() interface has been added for Cling based on LLVM
 /// >=18 and should be used in future releases.
 inline llvm::orc::LLJIT* getExecutionEngine(cling::Interpreter& I) {
-#if CLANG_VERSION_MAJOR >= 18
   return I.getExecutionEngine();
-#endif
-
-  unsigned m_ExecutorOffset = 0;
-
-#if CLANG_VERSION_MAJOR == 13
-#ifdef __APPLE__
-  m_ExecutorOffset = 62;
-#else
-  m_ExecutorOffset = 72;
-#endif // __APPLE__
-#endif
-
-// Note: The offsets changed in Cling based on LLVM 16 with the introduction of
-// a thread safe context - llvm::orc::ThreadSafeContext
-#if CLANG_VERSION_MAJOR == 16
-#ifdef __APPLE__
-  m_ExecutorOffset = 68;
-#else
-  m_ExecutorOffset = 78;
-#endif // __APPLE__
-#endif
-
-  int* IncrementalExecutor =
-      ((int*)(const_cast<cling::Interpreter*>(&I))) + m_ExecutorOffset;
-  int* IncrementalJit = *(int**)IncrementalExecutor + 0;
-  int* LLJIT = *(int**)IncrementalJit + 0;
-  return *(llvm::orc::LLJIT**)LLJIT;
 }
 
 inline llvm::Expected<llvm::JITTargetAddress>
@@ -152,12 +124,8 @@ getSymbolAddress(cling::Interpreter& I, llvm::StringRef IRName) {
   llvm::orc::SymbolNameVector Names;
   llvm::orc::ExecutionSession& ES = Jit.getExecutionSession();
   Names.push_back(ES.intern(IRName));
-#if CLANG_VERSION_MAJOR < 16
-  return llvm::make_error<llvm::orc::SymbolsNotFound>(Names);
-#else
   return llvm::make_error<llvm::orc::SymbolsNotFound>(ES.getSymbolStringPool(),
                                                       std::move(Names));
-#endif // CLANG_VERSION_MAJOR
 }
 
 inline void codeComplete(std::vector<std::string>& Results,
@@ -238,9 +206,6 @@ namespace compat {
 
 inline std::unique_ptr<clang::Interpreter>
 createClangInterpreter(std::vector<const char*>& args) {
-#if CLANG_VERSION_MAJOR < 16
-  auto ciOrErr = clang::IncrementalCompilerBuilder::create(args);
-#else
   auto has_arg = [](const char* x, llvm::StringRef match = "cuda") {
     llvm::StringRef Arg = x;
     Arg = Arg.trim().ltrim('-');
@@ -270,23 +235,19 @@ createClangInterpreter(std::vector<const char*>& args) {
     DeviceCI = std::move(*devOrErr);
   }
   auto ciOrErr = CudaEnabled ? CB.CreateCudaHost() : CB.CreateCpp();
-#endif // CLANG_VERSION_MAJOR < 16
+
   if (!ciOrErr) {
     llvm::logAllUnhandledErrors(ciOrErr.takeError(), llvm::errs(),
                                 "Failed to build Incremental compiler:");
     return nullptr;
   }
-#if CLANG_VERSION_MAJOR < 16
-  auto innerOrErr = clang::Interpreter::create(std::move(*ciOrErr));
-#else
   (*ciOrErr)->LoadRequestedPlugins();
   if (CudaEnabled)
     DeviceCI->LoadRequestedPlugins();
   auto innerOrErr =
       CudaEnabled ? clang::Interpreter::createWithCUDA(std::move(*ciOrErr),
                                                        std::move(DeviceCI))
                   : clang::Interpreter::create(std::move(*ciOrErr));
-#endif // CLANG_VERSION_MAJOR < 16
 
   if (!innerOrErr) {
     llvm::logAllUnhandledErrors(innerOrErr.takeError(), llvm::errs(),
@@ -333,29 +294,15 @@ inline void maybeMangleDeclName(const clang::GlobalDecl& GD,
   RawStr.flush();
 }
 
-// Clang 13 - Initial implementation of Interpreter and clang-repl
-// Clang 14 - Add new Interpreter methods: getExecutionEngine,
-//            getSymbolAddress, getSymbolAddressFromLinkerName
-// Clang 15 - Add new Interpreter methods: Undo
 // Clang 18 - Add new Interpreter methods: CodeComplete
 
 inline llvm::orc::LLJIT* getExecutionEngine(clang::Interpreter& I) {
-#if CLANG_VERSION_MAJOR >= 14
   auto* engine = &llvm::cantFail(I.getExecutionEngine());
   return const_cast<llvm::orc::LLJIT*>(engine);
-#else
-  assert(0 && "Not implemented in Clang <14!");
-  return nullptr;
-#endif
 }
 
 inline llvm::Expected<llvm::JITTargetAddress>
 getSymbolAddress(clang::Interpreter& I, llvm::StringRef IRName) {
-#if CLANG_VERSION_MAJOR < 14
-  assert(0 && "Not implemented in Clang <14!");
-  return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                 "Not implemented in Clang <14!");
-#endif // CLANG_VERSION_MAJOR < 14
 
   auto AddrOrErr = I.getSymbolAddress(IRName);
   if (llvm::Error Err = AddrOrErr.takeError())
@@ -373,7 +320,6 @@ getSymbolAddress(clang::Interpreter& I, clang::GlobalDecl GD) {
 inline llvm::Expected<llvm::JITTargetAddress>
 getSymbolAddressFromLinkerName(clang::Interpreter& I,
                                llvm::StringRef LinkerName) {
-#if CLANG_VERSION_MAJOR >= 14
   const auto& DL = getExecutionEngine(I)->getDataLayout();
   char GlobalPrefix = DL.getGlobalPrefix();
   std::string LinkerNameTmp(LinkerName);
@@ -384,21 +330,10 @@ getSymbolAddressFromLinkerName(clang::Interpreter& I,
   if (llvm::Error Err = AddrOrErr.takeError())
     return std::move(Err);
   return AddrOrErr->getValue();
-#else
-  assert(0 && "Not implemented in Clang <14!");
-  return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                 "Not implemented in Clang <14!");
-#endif
 }
 
 inline llvm::Error Undo(clang::Interpreter& I, unsigned N = 1) {
-#if CLANG_VERSION_MAJOR >= 15
   return I.Undo(N);
-#else
-  assert(0 && "Not implemented in Clang <15!");
-  return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                 "Not implemented in Clang <15!");
-#endif
 }
 
 inline void codeComplete(std::vector<std::string>& Results,
@@ -451,34 +386,14 @@ using Interpreter = Cpp::Interpreter;
 namespace compat {
 
 // Clang >= 14 change type name to string (spaces formatting problem)
-#if CLANG_VERSION_MAJOR >= 14
 inline std::string FixTypeName(const std::string type_name) {
   return type_name;
 }
-#else
-inline std::string FixTypeName(const std::string type_name) {
-  std::string result = type_name;
-  size_t pos = 0;
-  while ((pos = result.find(" [", pos)) != std::string::npos) {
-    result.erase(pos, 1);
-    pos++;
-  }
-  return result;
-}
-#endif
 
-// Clang >= 16 change CLANG_LIBDIR_SUFFIX to CLANG_INSTALL_LIBDIR_BASENAME
-#if CLANG_VERSION_MAJOR < 16
-#define CLANG_INSTALL_LIBDIR_BASENAME (llvm::Twine("lib") + CLANG_LIBDIR_SUFFIX)
-#endif
 inline std::string MakeResourceDir(llvm::StringRef Dir) {
   llvm::SmallString<128> P(Dir);
   llvm::sys::path::append(P, CLANG_INSTALL_LIBDIR_BASENAME, "clang",
-#if CLANG_VERSION_MAJOR < 16
-                          CLANG_VERSION_STRING
-#else
                           CLANG_VERSION_MAJOR_STRING
-#endif
   );
   return std::string(P.str());
 }

lib/Interpreter/CppInterOp.cpp

@@ -3046,11 +3046,7 @@ namespace Cpp {
     std::string detected_resource_dir = outs.back();
 
     std::string version =
-#if CLANG_VERSION_MAJOR < 16
-        CLANG_VERSION_STRING;
-#else
         CLANG_VERSION_MAJOR_STRING;
-#endif
     // We need to check if the detected resource directory is compatible.
     if (llvm::sys::path::filename(detected_resource_dir) != version)
       return "";

package-lock.json

@@ -11,7 +11,6 @@ if(EMSCRIPTEN)
   set(gtest_libs gtest gmock)
 else()
   set(gtest_libs gtest gtest_main)
-  # Clang prior than clang13 (I think) merges both gmock into gtest.
   if (TARGET gmock)
     list(APPEND gtest_libs gmock gmock_main)
   endif()

unittests/CMakeLists.txt

@@ -9,10 +9,6 @@ using namespace TestUtils;
 
 static bool HasCudaSDK() {
   auto supportsCudaSDK = []() {
-#if CLANG_VERSION_MAJOR < 16
-    // FIXME: Enable this for cling.
-    return false;
-#endif // CLANG_VERSION_MAJOR < 16
     if (!Cpp::CreateInterpreter({}, {"--cuda"}))
       return false;
     return Cpp::Declare("__global__ void test_func() {}"
@@ -24,10 +20,6 @@ static bool HasCudaSDK() {
 
 static bool HasCudaRuntime() {
   auto supportsCuda = []() {
-#if CLANG_VERSION_MAJOR < 16
-    // FIXME: Enable this for cling.
-    return false;
-#endif //CLANG_VERSION_MAJOR < 16
     if (!HasCudaSDK())
       return false;
 
@@ -43,11 +35,7 @@ static bool HasCudaRuntime() {
   return hasCuda;
 }
 
-#if CLANG_VERSION_MAJOR < 16
-TEST(DISABLED_CUDATest, Sanity) {
-#else
 TEST(CUDATest, Sanity) {
-#endif // CLANG_VERSION_MAJOR < 16
 #ifdef _WIN32
   GTEST_SKIP() << "Disabled on Windows. Needs fixing.";
 #endif
@@ -76,4 +64,4 @@ TEST(CUDATest, CUDARuntime) {
     GTEST_SKIP() << "Skipping CUDA tests as CUDA runtime not found";
 
   EXPECT_TRUE(HasCudaRuntime());
-}
+}

unittests/CppInterOp/CUDATest.cpp

@@ -859,14 +859,10 @@ template<class T> constexpr T pi = T(3.1415926535897932385L);
   auto* VD = cast<VarTemplateSpecializationDecl>((Decl*)Instance1);
   VarTemplateDecl* VDTD1 = VD->getSpecializedTemplate();
   EXPECT_TRUE(VDTD1->isThisDeclarationADefinition());
-#if CLANG_VERSION_MAJOR > 13
 #if CLANG_VERSION_MAJOR <= 18
   TemplateArgument TA1 = (*VD->getTemplateArgsInfo())[0].getArgument();
 #else
   TemplateArgument TA1 = (*VD->getTemplateArgsAsWritten())[0].getArgument();
-#endif // CLANG_VERSION_MAJOR
-#else
-  TemplateArgument TA1 = VD->getTemplateArgsInfo()[0].getArgument();
 #endif // CLANG_VERSION_MAJOR
   EXPECT_TRUE(TA1.getAsType()->isIntegerType());
 }