Upgrade llvm90

CMakeLists.txt

@@ -281,8 +281,6 @@ endforeach()
 add_custom_target(move_artifacts DEPENDS ${stamp_file} ${artifact_files_builddir})
 
 add_subdirectory (interpreter)
-# Add the compilation flags from LLVM to the flags we use to compile cling-based tools.
-set(CLING_CXXFLAGS "${CLING_CXXFLAGS} ${ROOT_LLVM_FLAGS}")
 
 #---CXX MODULES-----------------------------------------------------------------------------------
 if(cxxmodules)

README/ReleaseNotes/v624/index.md

@@ -61,6 +61,9 @@ Note that the preferred way to steer ROOT's concurrency level is still through `
 
 See the discussion at [ROOT-11014](https://sft.its.cern.ch/jira/browse/ROOT-11014) for more context.
 
+### Interpreter
+- cling's LLVM is upgraded to version 9.0
+
 ## I/O Libraries
 
 

cmake/modules/RootBuildOptions.cmake

@@ -83,6 +83,7 @@ ROOT_BUILD_OPTION(asimage ON "Enable support for image processing via libAfterIm
 ROOT_BUILD_OPTION(builtin_afterimage OFF "Build bundled copy of libAfterImage")
 ROOT_BUILD_OPTION(builtin_cfitsio OFF "Build CFITSIO internally (requires network)")
 ROOT_BUILD_OPTION(builtin_clang ON "Build bundled copy of Clang")
+ROOT_BUILD_OPTION(builtin_cling ON "Build bundled copy of Cling")
 ROOT_BUILD_OPTION(builtin_davix OFF "Build Davix internally (requires network)")
 ROOT_BUILD_OPTION(builtin_fftw3 OFF "Build FFTW3 internally (requires network)")
 ROOT_BUILD_OPTION(builtin_freetype OFF "Build bundled copy of freetype")
@@ -274,6 +275,7 @@ if(builtin_all)
   set(builtin_afterimage_defvalue ON)
   set(builtin_cfitsio_defvalue ON)
   set(builtin_clang_defvalue ON)
+  set(builtin_cling_defvalue ON)
   set(builtin_davix_defvalue ON)
   set(builtin_fftw3_defvalue ON)
   set(builtin_freetype_defvalue ON)
@@ -347,7 +349,7 @@ endif()
 
 #---Apply minimal or gminimal------------------------------------------------------------------
 foreach(opt ${root_build_options})
-  if(NOT opt MATCHES "builtin_llvm|builtin_clang|shared")
+  if(NOT opt MATCHES "builtin_llvm|builtin_clang|builtin_cling|shared")
     if(minimal)
       set(${opt}_defvalue OFF)
     elseif(gminimal AND NOT opt MATCHES "x11|cocoa")
@@ -377,6 +379,12 @@ if(roottest OR rootbench)
   set(testing ON CACHE BOOL "" FORCE)
 endif()
 
+if (builtin_cling)
+  if (NOT builtin_clang OR NOT builtin_llvm)
+    message(WARNING "No need to build internal llvm or clang. Consider turning builtin_clang=Off and builtin_llvm=Off")
+  endif()
+endif(builtin_cling)
+
 if(root7)
   if(NOT CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++14 standard used with root7")

cmake/modules/SearchInstalledSoftware.cmake

@@ -1016,29 +1016,6 @@ if(arrow)
 
 endif()
 
-#---Check for cling and llvm --------------------------------------------------------
-
-set(CLING_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/interpreter/cling/include)
-
-if(MSVC)
-  set(CLING_CXXFLAGS "-DNOMINMAX -D_XKEYCHECK_H")
-else()
-  set(CLING_CXXFLAGS "-fvisibility=hidden -Wno-shadow -fno-strict-aliasing -Wno-unused-parameter -Wwrite-strings -Wno-long-long")
-endif()
-if (CMAKE_COMPILER_IS_GNUCXX)
-  set(CLING_CXXFLAGS "${CLING_CXXFLAGS} -Wno-missing-field-initializers")
-endif()
-#---These are the libraries that we link ROOT with CLING---------------------------
-set(CLING_LIBRARIES clingInterpreter clingMetaProcessor clingUtils)
-add_custom_target(CLING)
-add_dependencies(CLING ${CLING_LIBRARIES})
-if (builtin_llvm)
-  add_dependencies(CLING intrinsics_gen)
-endif()
-if (builtin_clang)
-  add_dependencies(CLING clang-headers)
-endif()
-
 #---Check for gfal-------------------------------------------------------------------
 if(gfal)
   find_package(GFAL)

core/CMakeLists.txt

@@ -174,6 +174,11 @@ if(MSVC)
   target_compile_definitions(Core PRIVATE _USE_MATH_DEFINES)
 endif()
 
+# Inclusion of `complex.h` causes havoc: `complex` and `I` become CPP macros.
+# Darwin's complex.h does not implement C11's __STDC_NO_COMPLEX__, use the
+# header guard instead. This prevents inclusion of complex.h in Darwin.pcm.
+target_compile_definitions(Core PRIVATE __STDC_NO_COMPLEX__ __COMPLEX_H__)
+
 #while basic libs do not depend on Core, we have to add includes directly
 
 target_include_directories(Core PUBLIC
@@ -256,5 +261,4 @@ target_link_libraries(Core
     ${CMAKE_THREAD_LIBS_INIT}
     ${corelinklibs}
 )
-
 add_dependencies(Core CLING)

core/base/inc/Rtypes.h

@@ -367,7 +367,7 @@ public: \
 
 #define NamespaceImpUnique(name,key) \
    namespace name { \
-      namespace ROOT { \
+      namespace ROOTDict { \
          ::ROOT::TGenericClassInfo *GenerateInitInstance(); \
          namespace { \
             static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) = \

core/clingutils/CMakeLists.txt

@@ -38,11 +38,6 @@ target_include_directories(ClingUtils PRIVATE
 target_include_directories(ClingUtils SYSTEM PRIVATE ${CLANG_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS})
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CLING_CXXFLAGS}")
 
-# This is to avoid warnings coming from GCC 7 in llvm/src/include/llvm/ADT/DenseMap.h:1010
-if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-  ROOT_ADD_CXX_FLAG(CMAKE_CXX_FLAGS -Wno-maybe-uninitialized)
-endif()
-
 ROOT_INSTALL_HEADERS()
 
 #### STL dictionary (replacement for cintdlls)##############################
@@ -110,6 +105,9 @@ set(clinginclude ${CMAKE_SOURCE_DIR}/interpreter/cling/include)
 set(custom_modulemaps)
 if (runtime_cxxmodules)
   set(custom_modulemaps boost.modulemap tinyxml2.modulemap cuda.modulemap module.modulemap.build)
+  if (Vc_FOUND)
+    set(custom_modulemaps ${custom_modulemaps} vc.modulemap)
+  endif(Vc_FOUND)
   if (NOT libcxx)
     if (MSVC)
       set(custom_modulemaps ${custom_modulemaps} vcruntime.modulemap)

core/clingutils/res/TClingUtils.h

@@ -878,6 +878,12 @@ int FwdDeclFromRcdDecl(const clang::RecordDecl& recordDecl,
 int FwdDeclFromTmplDecl(const clang::TemplateDecl& tmplDecl,
                         const cling::Interpreter& interpreter,
                         std::string& defString);
+
+//______________________________________________________________________________
+int FwdDeclIfTmplSpec(const clang::RecordDecl& recordDecl,
+                      const cling::Interpreter& interpreter,
+                      std::string& defString,
+                      const std::string &normalizedName);
 //______________________________________________________________________________
 int GetDefArg(const clang::ParmVarDecl& par, std::string& valAsString, const clang::PrintingPolicy& pp);
 

core/clingutils/src/TClingUtils.cxx

@@ -1572,7 +1572,7 @@ long ROOT::TMetaUtils::GetLineNumber(const clang::Decl *decl)
    }
 
    if (!sourceLocation.isFileID()) {
-      sourceLocation = sourceManager.getExpansionRange(sourceLocation).second;
+      sourceLocation = sourceManager.getExpansionRange(sourceLocation).getEnd();
    }
 
    if (sourceLocation.isValid() && sourceLocation.isFileID()) {
@@ -3328,7 +3328,7 @@ getFinalSpellingLoc(clang::SourceManager& sourceManager,
                     clang::SourceLocation sourceLoc) {
    // Follow macro expansion until we hit a source file.
    if (!sourceLoc.isFileID()) {
-      return sourceManager.getExpansionRange(sourceLoc).second;
+      return sourceManager.getExpansionRange(sourceLoc).getEnd();
    }
    return sourceLoc;
 }
@@ -3394,7 +3394,8 @@ llvm::StringRef ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
                                 true /*isAngled*/, 0/*FromDir*/, foundDir,
                                 ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>>(),
                                 0/*Searchpath*/, 0/*RelPath*/,
-                                0/*IsMapped*/, 0/*RequestingModule*/, 0/*SuggestedModule*/,
+                                0/*SuggestedModule*/, 0/*RequestingModule*/,
+                                0/*IsMapped*/, nullptr /*IsFrameworkFound*/,
                                 false /*SkipCache*/,
                                 false /*BuildSystemModule*/,
                                 false /*OpenFile*/, true /*CacheFailures*/);
@@ -3448,8 +3449,9 @@ llvm::StringRef ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
       FELong = HdrSearch.LookupFile(trailingPart, SourceLocation(),
                                     true /*isAngled*/, 0/*FromDir*/, FoundDir,
                                     ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>>(),
-                                    0/*IsMapped*/, 0/*Searchpath*/, 0/*RelPath*/,
-                                    0/*RequestingModule*/, 0/*SuggestedModule*/);
+                                    0/*Searchpath*/, 0/*RelPath*/,
+                                    0/*SuggestedModule*/, 0/*RequestingModule*/,
+                                    0/*IsMapped*/, nullptr /*IsFrameworkFound*/);
    }
 
    if (!FELong) {
@@ -3473,10 +3475,9 @@ llvm::StringRef ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
       if (HdrSearch.LookupFile(trailingPart, SourceLocation(),
                                true /*isAngled*/, 0/*FromDir*/, FoundDir,
                                ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>>(),
-                               0/*IsMapped*/,
-                               0/*Searchpath*/,
-                               0/*RelPath*/,
-                               0/*RequestingModule*/, 0 /*SuggestedModule*/) == FELong) {
+                               0/*Searchpath*/, 0/*RelPath*/,
+                               0/*SuggestedModule*/, 0/*RequestingModule*/,
+                               0/*IsMapped*/, nullptr /*IsFrameworkFound*/) == FELong) {
          return trailingPart;
       }
    }
@@ -4184,10 +4185,10 @@ int dumpDeclForAssert(const clang::Decl& D, const char* commentStart) {
 llvm::StringRef ROOT::TMetaUtils::GetComment(const clang::Decl &decl, clang::SourceLocation *loc)
 {
    clang::SourceManager& sourceManager = decl.getASTContext().getSourceManager();
-   clang::SourceLocation sourceLocation = decl.getLocEnd();
+   clang::SourceLocation sourceLocation = decl.getEndLoc();
 
    // If the location is a macro get the expansion location.
-   sourceLocation = sourceManager.getExpansionRange(sourceLocation).second;
+   sourceLocation = sourceManager.getExpansionRange(sourceLocation).getEnd();
    // FIXME: We should optimize this routine instead making it do the wrong thing
    // returning an empty comment if the decl came from the AST.
    // In order to do that we need to: check if the decl has an attribute and
@@ -4218,7 +4219,7 @@ llvm::StringRef ROOT::TMetaUtils::GetComment(const clang::Decl &decl, clang::Sou
       } else if (FD->doesThisDeclarationHaveABody()) {
          // commentStart is at body's '}'
          // But we might end up e.g. at the ')' of a CPP macro
-         assert((decl.getLocEnd() != sourceLocation || *commentStart == '}'
+         assert((decl.getEndLoc() != sourceLocation || *commentStart == '}'
                  || dumpDeclForAssert(*FD, commentStart))
                 && "Expected macro or end of body at '}'");
          if (*commentStart) ++commentStart;
@@ -5325,6 +5326,48 @@ static int TreatSingleTemplateArg(const clang::TemplateArgument& arg,
    return 1;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+/// Convert a tmplt decl to its fwd decl
+
+int ROOT::TMetaUtils::AST2SourceTools::FwdDeclIfTmplSpec(const clang::RecordDecl& recordDecl,
+                                                         const cling::Interpreter& interpreter,
+                                                         std::string& defString,
+                                                         const std::string &normalizedName)
+{
+   // If this is an explicit specialization, inject it into cling, too, such that it can have
+   // externalLexicalStorage, see TCling.cxx's ExtVisibleStorageAdder::VisitClassTemplateSpecializationDecl.
+   if (auto tmplSpecDeclPtr = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(&recordDecl)) {
+      if (const auto *specDef = tmplSpecDeclPtr->getDefinition()) {
+         if (specDef->getTemplateSpecializationKind() != clang::TSK_ExplicitSpecialization)
+            return 0;
+         // normalizedName contains scope, no need to enclose in namespace!
+         if (GetErrorIgnoreLevel() == ROOT::TMetaUtils::kInfo)
+            std::cout << " Forward declaring template spec " << normalizedName << ":\n";
+         for (auto arg : tmplSpecDeclPtr->getTemplateArgs().asArray()) {
+            std::string argFwdDecl;
+            int retCode = TreatSingleTemplateArg(arg, argFwdDecl, interpreter, /*acceptStl=*/false);
+            if (GetErrorIgnoreLevel() == ROOT::TMetaUtils::kInfo) {
+               std::cout << " o Template argument ";
+               if (retCode == 0) {
+                  std::cout << "successfully treated. Arg fwd decl: " << argFwdDecl << std::endl;
+               } else {
+                  std::cout << "could not be treated. Abort fwd declaration generation.\n";
+               }
+            }
+
+            if (retCode != 0) { // A sign we must bail out
+               return retCode;
+            }
+            defString += argFwdDecl + '\n';
+         }
+         defString += "template <> class " + normalizedName + ';';
+         return 0;
+      }
+   }
+
+   return 0;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Convert a rcd decl to its fwd decl
 /// If this is a template specialisation, treat in the proper way.
@@ -5503,8 +5546,9 @@ int ROOT::TMetaUtils::AST2SourceTools::GetDefArg(const clang::ParmVarDecl& par,
 
    // The value is an integer
    if (defArgType->isIntegerType()){
-      llvm::APSInt result;
-      defArgExprPtr->EvaluateAsInt(result,ctxt);
+      clang::Expr::EvalResult evalResult;
+      defArgExprPtr->EvaluateAsInt(evalResult, ctxt);
+      llvm::APSInt result = evalResult.Val.getInt();
       auto uintVal = *result.getRawData();
       if (result.isNegative()){
          long long int intVal=uintVal*-1;

core/dictgen/src/LinkdefReader.cxx

@@ -736,13 +736,13 @@ class PragmaExtraInclude : public LinkdefReaderPragmaHandler {
    }
 
    void HandlePragma(clang::Preprocessor &PP,
-                     clang::PragmaIntroducerKind Introducer,
+                     clang::PragmaIntroducer Introducer,
                      clang::Token &tok) {
       // Handle a #pragma found by the Preprocessor.
 
       // check whether we care about the pragma - we are a named handler,
       // thus this could actually be transformed into an assert:
-      if (Introducer != clang::PIK_HashPragma) return; // only #pragma, not C-style.
+      if (Introducer.Kind != clang::PIK_HashPragma) return; // only #pragma, not C-style.
       if (!tok.getIdentifierInfo()) return; // must be "link"
       if (tok.getIdentifierInfo()->getName() != "extra_include") return;
 
@@ -785,13 +785,13 @@ class PragmaIoReadInclude : public LinkdefReaderPragmaHandler {
    }
 
    void HandlePragma(clang::Preprocessor &PP,
-                     clang::PragmaIntroducerKind Introducer,
+                     clang::PragmaIntroducer Introducer,
                      clang::Token &tok) {
       // Handle a #pragma found by the Preprocessor.
 
       // check whether we care about the pragma - we are a named handler,
       // thus this could actually be transformed into an assert:
-      if (Introducer != clang::PIK_HashPragma) return; // only #pragma, not C-style.
+      if (Introducer.Kind != clang::PIK_HashPragma) return; // only #pragma, not C-style.
       if (!tok.getIdentifierInfo()) return; // must be "link"
       if (tok.getIdentifierInfo()->getName() != "read") return;
 
@@ -844,13 +844,13 @@ class PragmaLinkCollector : public LinkdefReaderPragmaHandler {
    }
 
    void HandlePragma(clang::Preprocessor &PP,
-                     clang::PragmaIntroducerKind Introducer,
+                     clang::PragmaIntroducer Introducer,
                      clang::Token &tok) {
       // Handle a #pragma found by the Preprocessor.
 
       // check whether we care about the pragma - we are a named handler,
       // thus this could actually be transformed into an assert:
-      if (Introducer != clang::PIK_HashPragma) return; // only #pragma, not C-style.
+      if (Introducer.Kind != clang::PIK_HashPragma) return; // only #pragma, not C-style.
       if (!tok.getIdentifierInfo()) return; // must be "link"
       if (tok.getIdentifierInfo()->getName() != "link") return;
 
@@ -949,13 +949,13 @@ class PragmaCreateCollector : public LinkdefReaderPragmaHandler {
    }
 
    void HandlePragma(clang::Preprocessor &PP,
-                     clang::PragmaIntroducerKind Introducer,
+                     clang::PragmaIntroducer Introducer,
                      clang::Token &tok) {
       // Handle a #pragma found by the Preprocessor.
 
       // check whether we care about the pragma - we are a named handler,
       // thus this could actually be transformed into an assert:
-      if (Introducer != clang::PIK_HashPragma) return; // only #pragma, not C-style.
+      if (Introducer.Kind != clang::PIK_HashPragma) return; // only #pragma, not C-style.
       if (!tok.getIdentifierInfo()) return; // must be "link"
       if (tok.getIdentifierInfo()->getName() != "create") return;
 

core/dictgen/src/TModuleGenerator.cxx

@@ -115,8 +115,9 @@ TModuleGenerator::GetSourceFileKind(const char *filename) const
                                  true /*isAngled*/, 0 /*FromDir*/, CurDir,
                                  clang::ArrayRef<std::pair<const clang::FileEntry*,
                                                            const clang::DirectoryEntry*>>(),
-                                 0 /*IsMapped*/, 0 /*SearchPath*/, 0 /*RelativePath*/,
-                                 0 /*RequestingModule*/, 0/*SuggestedModule*/);
+                                 nullptr /*SearchPath*/,/*RelativePath*/ nullptr,
+                                 nullptr /*RequestingModule*/, nullptr /*SuggestedModule*/,
+                                 nullptr /*IsMapped*/, nullptr /*IsFrameworkFound*/);
       if (hdrFileEntry) {
          return kSFKHeader;
       }
@@ -576,8 +577,9 @@ bool TModuleGenerator::FindHeader(const std::string &hdrName, std::string &hdrFu
                                  true /*isAngled*/, 0 /*FromDir*/, CurDir,
                                  clang::ArrayRef<std::pair<const clang::FileEntry*,
                                                          const clang::DirectoryEntry*>>(),
-                                 0 /*IsMapped*/, 0 /*SearchPath*/, 0 /*RelativePath*/,
-                                 0 /*RequestingModule*/, 0/*SuggestedModule*/)) {
+                                 nullptr /*SearchPath*/, nullptr /*RelativePath*/,
+                                 nullptr /*RequestingModule*/, nullptr/*SuggestedModule*/,
+                                 nullptr /*IsMapped*/, nullptr /*IsFrameworkFound*/)) {
       hdrFullPath = hdrFileEntry->getName();
       return true;
    }