[Testing] Update ROOT and Cling to LLVM18

.github/workflows/root-ci-config/build_root.py

@@ -375,10 +375,11 @@ def dump_requested_config(options):
 @github_log_group("Build")
 def cmake_build(buildtype):
     generator_flags = "-- '-verbosity:minimal'" if WINDOWS else ""
+    parallel_jobs = "4" if WINDOWS else str(os.cpu_count())
 
     builddir = os.path.join(WORKDIR, "build")
     result = subprocess_with_log(f"""
-        cmake --build '{builddir}' --config '{buildtype}' --parallel '{os.cpu_count()}' {generator_flags}
+        cmake --build '{builddir}' --config '{buildtype}' --parallel '{parallel_jobs}' {generator_flags}
     """)
 
     if result != 0:

.github/workflows/root-ci.yml

@@ -240,6 +240,10 @@ jobs:
             config: Debug
           - event_name: push
             config: Debug
+          # This is this platform is subject to timeouts when building from
+          # scratch.
+          - target_arch: x86
+            config: Debug 
 
     name: Windows 10 ${{ matrix.target_arch }} ${{ matrix.config }}
 

CMakeLists.txt

@@ -4,11 +4,7 @@
 # For the licensing terms see $ROOTSYS/LICENSE.
 # For the list of contributors see $ROOTSYS/README/CREDITS.
 
-if(APPLE)
-  cmake_minimum_required(VERSION 3.19 FATAL_ERROR)
-else()
-  cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
-endif()
+cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 
 if(WIN32)
   # Set CMP0091 (MSVC runtime library flags are selected by an abstraction) to OLD

README/ReleaseNotes/v634/index.md

@@ -116,6 +116,10 @@ The [TUnfold package](https://www.desy.de/~sschmitt/tunfold.html) inside ROOT is
 
 ## Math Libraries
 
+### Usage of `std::span<const double>` in Minuit 2 interfaces
+
+To avoid forcing the user to do manual memory allocations via `std::vector`, the interfaces of Minuit 2 function adapter classes like `ROOT::Minuit2::FCNBase` or `ROOT::Minuit2::FCNGradientBase` were changed to accept `std::span<const double>` arguments instead of `std::vector<double> const&`.
+This should have minimal impact on users, since one should usuall use Minuit 2 via the `ROOT::Math::Minimizer` interface, which is unchanged.
 
 ## RooFit Libraries
 

core/base/inc/Bytes.h

@@ -71,7 +71,7 @@ inline void tobuf(char *&buf, UShort_t x)
 # else
    // To work around a stupid optimization bug in MSVC++ 6.0
    const UShort_t *intermediary = &x;
-   char *sw = (char *) intermediary;
+   const char *sw = (const char *) intermediary;
    buf[0] = sw[1];
    buf[1] = sw[0];
 # endif
@@ -89,7 +89,7 @@ inline void tobuf(char *&buf, UInt_t x)
 # else
    // To work around a stupid optimization bug in MSVC++ 6.0
    const UInt_t *intermediary = &x;
-   char *sw = (char *)intermediary;
+   const char *sw = (const char *)intermediary;
    buf[0] = sw[3];
    buf[1] = sw[2];
    buf[2] = sw[1];
@@ -106,7 +106,7 @@ inline void tobuf(char *&buf, ULong_t x)
 #ifdef R__BYTESWAP
    // To work around a stupid optimization bug in MSVC++ 6.0
    const ULong_t *intermediary = &x;
-   char *sw = (char *)intermediary;
+   const char *sw = (const char *)intermediary;
    if (sizeof(ULong_t) == 8) {
       buf[0] = sw[7];
       buf[1] = sw[6];
@@ -145,7 +145,7 @@ inline void tobuf(char *&buf, Long_t x)
 #ifdef R__BYTESWAP
    // To work around a stupid optimization bug in MSVC++ 6.0
    const Long_t *intermediary = &x;
-   char *sw = (char *)intermediary;
+   const char *sw = (const char *)intermediary;
    if (sizeof(Long_t) == 8) {
       buf[0] = sw[7];
       buf[1] = sw[6];
@@ -201,7 +201,7 @@ inline void tobuf(char *&buf, ULong64_t x)
 # else
    // To work around a stupid optimization bug in MSVC++ 6.0
    const ULong64_t *intermediary = &x;
-   char *sw = (char *)intermediary;
+   const char *sw = (const char *)intermediary;
    buf[0] = sw[7];
    buf[1] = sw[6];
    buf[2] = sw[5];

core/clingutils/CMakeLists.txt

@@ -119,9 +119,15 @@ if (runtime_cxxmodules)
   set(custom_modulemaps ${custom_modulemaps} vc.modulemap)
 
   # We need to override the default modulemap because instead of producing a
-  # single std.pcm, produces hundreds of pcms. This changed with sdk 15.3.
-  if (CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 15.0.0.15000309)
-    set(custom_modulemaps ${custom_modulemaps} std_darwin.modulemap)
+  # single std.pcm, produces hundreds of pcms. This changed with MacOSX14.4.sdk
+  # To support macOS 13 with LLVM 18, we need to patch the modulemap from
+  # MacOSX14.2.sdk
+  if (APPLE)
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.0.15000309)
+      set(custom_modulemaps ${custom_modulemaps} std_darwin.MacOSX14.2.sdk.modulemap)
+    else()
+      set(custom_modulemaps ${custom_modulemaps} std_darwin.modulemap)
+    endif()
   endif()
 
   if (NOT libcxx)

core/clingutils/src/TClingUtils.cxx

@@ -3094,7 +3094,7 @@ clang::QualType ROOT::TMetaUtils::AddDefaultParameters(clang::QualType instanceT
 
    if (!prefix_changed && !mightHaveChanged) return originalType;
    if (prefix) {
-      instanceType = Ctx.getElaboratedType(clang::ETK_None,prefix,instanceType);
+      instanceType = Ctx.getElaboratedType(clang::ElaboratedTypeKeyword::None, prefix, instanceType);
       instanceType = Ctx.getQualifiedType(instanceType,prefix_qualifiers);
    }
    return instanceType;
@@ -3388,7 +3388,7 @@ std::string ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
          = HdrSearch.LookupFile(llvm::sys::path::filename(headerFE->getName()),
                                 SourceLocation(),
                                 true /*isAngled*/, nullptr/*FromDir*/, foundDir,
-                                ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>>(),
+                                ArrayRef<std::pair<OptionalFileEntryRef, DirectoryEntryRef>>(),
                                 nullptr/*Searchpath*/, nullptr/*RelPath*/,
                                 nullptr/*SuggestedModule*/, nullptr/*RequestingModule*/,
                                 nullptr/*IsMapped*/, nullptr /*IsFrameworkFound*/,
@@ -3448,7 +3448,7 @@ std::string ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
       ConstSearchDirIterator* FoundDir = nullptr;
       FELong = HdrSearch.LookupFile(trailingPart, SourceLocation(),
                                     true /*isAngled*/, nullptr/*FromDir*/, FoundDir,
-                                    ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>>(),
+                                    ArrayRef<std::pair<OptionalFileEntryRef, DirectoryEntryRef>>(),
                                     nullptr/*Searchpath*/, nullptr/*RelPath*/,
                                     nullptr/*SuggestedModule*/, nullptr/*RequestingModule*/,
                                     nullptr/*IsMapped*/, nullptr /*IsFrameworkFound*/);
@@ -3474,7 +3474,7 @@ std::string ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
       // (or are we back to the previously found spelling, which is fine, too)
       if (HdrSearch.LookupFile(trailingPart, SourceLocation(),
                                true /*isAngled*/, nullptr/*FromDir*/, FoundDir,
-                               ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>>(),
+                               ArrayRef<std::pair<OptionalFileEntryRef, DirectoryEntryRef>>(),
                                nullptr/*Searchpath*/, nullptr/*RelPath*/,
                                nullptr/*SuggestedModule*/, nullptr/*RequestingModule*/,
                                nullptr/*IsMapped*/, nullptr /*IsFrameworkFound*/) == FELong) {
@@ -4007,7 +4007,7 @@ static void KeepNParams(clang::QualType& normalizedType,
    // Here we have (prefix_changed==true || mightHaveChanged), in both case
    // we need to reconstruct the type.
    if (prefix) {
-      normalizedType = astCtxt.getElaboratedType(clang::ETK_None,prefix,normalizedType);
+      normalizedType = astCtxt.getElaboratedType(clang::ElaboratedTypeKeyword::None, prefix, normalizedType);
       normalizedType = astCtxt.getQualifiedType(normalizedType,prefix_qualifiers);
    }
 
@@ -4633,7 +4633,8 @@ clang::QualType ROOT::TMetaUtils::ReSubstTemplateArg(clang::QualType input, cons
       clang::NestedNameSpecifier *scope = ReSubstTemplateArgNNS(Ctxt,etype->getQualifier(),instance);
       clang::QualType subTy = ReSubstTemplateArg(clang::QualType(etype->getNamedType().getTypePtr(),0),instance);
 
-      if (scope) subTy = Ctxt.getElaboratedType(clang::ETK_None,scope,subTy);
+      if (scope)
+         subTy = Ctxt.getElaboratedType(clang::ElaboratedTypeKeyword::None, scope, subTy);
       subTy = Ctxt.getQualifiedType(subTy,scope_qualifiers);
       return subTy;
    }

core/dictgen/src/DictSelectionReader.cxx

@@ -369,7 +369,7 @@ bool DictSelectionReader::SecondPass(const clang::RecordDecl &recordDecl)
                userDefinedProperty = propNames::comment + propNames::separator + "||";
             }
             if (!userDefinedProperty.empty()) {
-               fieldPtr->addAttr(clang::AnnotateAttr::CreateImplicit(C, userDefinedProperty));
+               fieldPtr->addAttr(clang::AnnotateAttr::CreateImplicit(C, userDefinedProperty, nullptr, 0));
                userDefinedProperty = "";
             }
          }

core/dictgen/src/LinkdefReader.cxx

@@ -1082,7 +1082,7 @@ bool LinkdefReader::Parse(SelectionRules &sr, llvm::StringRef code, const std::v
    clang::Token tok;
    do {
       PP.Lex(tok);
-   } while (tok.isNot(clang::tok::eof));
+   } while (tok.isNot(clang::tok::annot_repl_input_end));
 
    fSelectionRules = nullptr;
    return 0 == DClient.getNumErrors();

core/dictgen/src/Scanner.cxx

@@ -24,6 +24,7 @@
 
 #include <iostream>
 #include <sstream> // class ostringstream
+#include "llvm/ADT/StringExtras.h"
 
 #include "SelectionRules.h"
 

core/dictgen/src/TModuleGenerator.cxx

@@ -119,8 +119,8 @@ TModuleGenerator::GetSourceFileKind(const char *filename) const
       auto hdrFileEntry
          =  HdrSearch.LookupFile(filename, clang::SourceLocation(),
                                  true /*isAngled*/, nullptr /*FromDir*/, CurDir,
-                                 clang::ArrayRef<std::pair<const clang::FileEntry*,
-                                                           const clang::DirectoryEntry*>>(),
+                                 clang::ArrayRef<std::pair<clang::OptionalFileEntryRef,
+                                                           clang::DirectoryEntryRef>>(),
                                  nullptr /*SearchPath*/,/*RelativePath*/ nullptr,
                                  nullptr /*RequestingModule*/, nullptr /*SuggestedModule*/,
                                  nullptr /*IsMapped*/, nullptr /*IsFrameworkFound*/);
@@ -581,8 +581,8 @@ bool TModuleGenerator::FindHeader(const std::string &hdrName, std::string &hdrFu
    if (auto hdrFileEntry
          =  HdrSearch.LookupFile(hdrName, clang::SourceLocation(),
                                  true /*isAngled*/, nullptr /*FromDir*/, CurDir,
-                                 clang::ArrayRef<std::pair<const clang::FileEntry*,
-                                                         const clang::DirectoryEntry*>>(),
+                                 clang::ArrayRef<std::pair<clang::OptionalFileEntryRef,
+                                                         clang::DirectoryEntryRef>>(),
                                  nullptr /*SearchPath*/, nullptr /*RelativePath*/,
                                  nullptr /*RequestingModule*/, nullptr/*SuggestedModule*/,
                                  nullptr /*IsMapped*/, nullptr /*IsFrameworkFound*/)) {

core/dictgen/src/rootcling_impl.cxx

@@ -298,7 +298,7 @@ static void AnnotateFieldDecl(clang::FieldDecl &decl,
             // before persisting the ProtoClasses in the root pcms.
             // BEGIN ROOT PCMS
             if (name == propNames::comment) {
-               decl.addAttr(clang::AnnotateAttr::CreateImplicit(C, value));
+               decl.addAttr(clang::AnnotateAttr::CreateImplicit(C, value, nullptr, 0));
             }
             // END ROOT PCMS
 
@@ -308,16 +308,15 @@ static void AnnotateFieldDecl(clang::FieldDecl &decl,
                // This next line is here to use the root pcms. Indeed we need to annotate the AST
                // before persisting the ProtoClasses in the root pcms.
                // BEGIN ROOT PCMS
-               decl.addAttr(clang::AnnotateAttr::CreateImplicit(C, "!"));
+               decl.addAttr(clang::AnnotateAttr::CreateImplicit(C, "!", nullptr, 0));
                // END ROOT PCMS
                // The rest of the lines are not changed to leave in place the system which
                // works with bulk header parsing on library load.
             } else {
                userDefinedProperty = name + propNames::separator + value;
             }
             ROOT::TMetaUtils::Info(nullptr, "%s %s\n", varName.c_str(), userDefinedProperty.c_str());
-            decl.addAttr(clang::AnnotateAttr::CreateImplicit(C, userDefinedProperty));
-
+            decl.addAttr(clang::AnnotateAttr::CreateImplicit(C, userDefinedProperty, nullptr, 0));
          }
       }
    }
@@ -362,7 +361,7 @@ void AnnotateDecl(clang::CXXRecordDecl &CXXRD,
          const std::string &value = attr.second;
          userDefinedProperty = name + ROOT::TMetaUtils::propNames::separator + value;
          if (genreflex::verbose) std::cout << " * " << userDefinedProperty << std::endl;
-         CXXRD.addAttr(AnnotateAttr::CreateImplicit(C, userDefinedProperty));
+         CXXRD.addAttr(AnnotateAttr::CreateImplicit(C, userDefinedProperty, nullptr, 0));
       }
    }
 
@@ -389,14 +388,14 @@ void AnnotateDecl(clang::CXXRecordDecl &CXXRD,
          if (comment.size()) {
             // The ClassDef annotation is for the class itself
             if (isClassDefMacro) {
-               CXXRD.addAttr(AnnotateAttr::CreateImplicit(C, comment.str()));
+               CXXRD.addAttr(AnnotateAttr::CreateImplicit(C, comment.str(), nullptr, 0));
             } else if (!isGenreflex) {
                // Here we check if we are in presence of a selection file so that
                // the comment does not ends up as a decoration in the AST,
                // Nevertheless, w/o PCMS this has no effect, since the headers
                // are parsed at runtime and the information in the AST dumped by
                // rootcling is not relevant.
-               (*I)->addAttr(AnnotateAttr::CreateImplicit(C, comment.str()));
+               (*I)->addAttr(AnnotateAttr::CreateImplicit(C, comment.str(), nullptr, 0));
             }
          }
          // Match decls with sel rules if we are in presence of a selection file
@@ -3909,7 +3908,7 @@ static bool ModuleContainsHeaders(TModuleGenerator &modGen, clang::HeaderSearch
                header, clang::SourceLocation(),
                /*isAngled*/ false,
                /*FromDir*/ 0, CurDir,
-               clang::ArrayRef<std::pair<const clang::FileEntry *, const clang::DirectoryEntry *>>(),
+               clang::ArrayRef<std::pair<clang::OptionalFileEntryRef, clang::DirectoryEntryRef>>(),
                /*SearchPath*/ 0,
                /*RelativePath*/ 0,
                /*RequestingModule*/ 0, &SuggestedModule,

core/meta/src/TClass.cxx

@@ -698,7 +698,7 @@ void TDumpMembers::Inspect(TClass *cl, const char *pname, const char *mname, con
             }
          }
          if (isPrintable) {
-            strncpy(line + kvalue, *ppointer, std::min( i, kline - kvalue));
+            strncpy(line + kvalue, *ppointer, kline - kvalue);
             line[kvalue+i] = 0;
          } else {
             line[kvalue] = 0;

core/metacling/src/TCling.cxx

@@ -3236,8 +3236,8 @@ Bool_t TCling::IsLoaded(const char* filename) const
                            clang::SourceLocation(),
                            /*isAngled*/ false,
                            /*FromDir*/ nullptr, CurDir,
-                           clang::ArrayRef<std::pair<const clang::FileEntry *,
-                           const clang::DirectoryEntry *>>(),
+                           clang::ArrayRef<std::pair<clang::OptionalFileEntryRef,
+                           clang::DirectoryEntryRef>>(),
                            /*SearchPath*/ nullptr,
                            /*RelativePath*/ nullptr,
                            /*RequestingModule*/ nullptr,
@@ -7034,6 +7034,7 @@ static std::string GetClassSharedLibsForModule(const char *cls, cling::LookupHel
             case TemplateArgument::Integral:
             case TemplateArgument::Pack:
             case TemplateArgument::NullPtr:
+            case TemplateArgument::StructuralValue:
             case TemplateArgument::Expression:
             case TemplateArgument::Template:
             case TemplateArgument::TemplateExpansion: return;
@@ -8723,7 +8724,7 @@ void TCling::SetDeclAttr(DeclId_t declId, const char* attribute)
 {
    Decl* decl = static_cast<Decl*>(const_cast<void*>(declId));
    ASTContext &C = decl->getASTContext();
-   decl->addAttr(AnnotateAttr::CreateImplicit(C, attribute));
+   decl->addAttr(AnnotateAttr::CreateImplicit(C, attribute, nullptr, 0));
 }
 
 //______________________________________________________________________________
@@ -8902,7 +8903,7 @@ Long_t TCling::FuncTempInfo_Property(FuncTempInfo_t *ft_info) const
       if (md->isVirtual()) {
          property |= kIsVirtual;
       }
-      if (md->isPure()) {
+      if (md->isPureVirtual()) {
          property |= kIsPureVirtual;
       }
       if (const clang::CXXConstructorDecl *cd =

core/metacling/src/TClingCallbacks.cxx

@@ -128,8 +128,7 @@ class AutoloadLibraryMU : public llvm::orc::MaterializationUnit {
          }
 
          if (addr) {
-            loadedSymbols[symbol] =
-               llvm::JITEvaluatedSymbol(llvm::pointerToJITTargetAddress(addr), llvm::JITSymbolFlags::Exported);
+            loadedSymbols[symbol] = {llvm::orc::ExecutorAddr::fromPtr(addr), llvm::JITSymbolFlags::Exported};
          } else {
             // Collect all failing symbols, delegate their responsibility and then
             // fail their materialization. R->defineNonExistent() sounds like it
@@ -858,7 +857,7 @@ bool TClingCallbacks::tryResolveAtRuntimeInternal(LookupResult &R, Scope *S) {
    // is a gross hack, because TClingCallbacks shouldn't know about
    // EvaluateTSynthesizer at all!
 
-   Wrapper->addAttr(AnnotateAttr::CreateImplicit(C, "__ResolveAtRuntime"));
+   Wrapper->addAttr(AnnotateAttr::CreateImplicit(C, "__ResolveAtRuntime", nullptr, 0));
 
    // Here we have the scope but we cannot do Sema::PushDeclContext, because
    // on pop it will try to go one level up, which we don't want.
@@ -995,7 +994,7 @@ bool TClingCallbacks::tryInjectImplicitAutoKeyword(LookupResult &R, Scope *S) {
    // Annotate the decl to give a hint in cling.
    // FIXME: We should move this in cling, when we implement turning it on
    // and off.
-   Result->addAttr(AnnotateAttr::CreateImplicit(C, "__Auto"));
+   Result->addAttr(AnnotateAttr::CreateImplicit(C, "__Auto", nullptr, 0));
 
    R.addDecl(Result);
 

core/metacling/src/TClingDataMemberInfo.cxx

@@ -397,16 +397,17 @@ Longptr_t TClingDataMemberInfo::Offset()
    // clang there is misbehaviour in MangleContext::shouldMangleDeclName.
    // enum constants are essentially numbers and don't get addresses. However
    // ROOT expects the address to the enum constant initializer to be returned.
-   else if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D))
+   else if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
       // The raw data is stored as a long long, so we need to find the 'long'
       // part.
-#ifdef R__BYTESWAP
-      // In this case at the beginning.
-      return reinterpret_cast<Longptr_t>(ECD->getInitVal().getRawData());
-#else
-      // In this case in the second part.
-      return reinterpret_cast<Longptr_t>(((char*)ECD->getInitVal().getRawData())+sizeof(Longptr_t) );
-#endif
+
+      // The memory leak for `EnumConstantDecl` was fixed in:
+      // https://github.com/llvm/llvm-project/pull/78311
+      // We were relying on the leak to provide the address for EnumConstantDecl.
+      // Now store the data value as a member instead.
+      fEnumValue = ECD->getInitVal().getExtValue();
+      return reinterpret_cast<Longptr_t>(&fEnumValue);
+   }
    return -1L;
 }
 

core/metacling/src/TClingDataMemberInfo.h

@@ -77,6 +77,7 @@ class TClingDataMemberInfo final : public TClingDeclInfo {
    TClingDataMemberIter   fIter; // Current decl.
    std::string            fTitle; // The meta info for the member.
    bool                   fFirstTime = true; // We need to skip the first increment to support the cint Next() semantics.
+   int64_t                fEnumValue; // Special case to handle enums
 
    mutable std::string fIoType;
    mutable std::string fIoName;