Fix spack.repo - spack.package_base circularity

spack.repo now imports spack.package_base, but not the other way around.

.github/workflows/import-check.yaml

@@ -39,7 +39,7 @@ jobs:
       uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       with:
         repository: haampie/circular-import-fighter
-        ref: e38bcd0aa46368e30648b61b7f0d8c1ca68aadff
+        ref: 4cdb0bf15f04ab6b49041d5ef1bfd9644cce7f33
         path: circular-import-fighter
     - name: Install dependencies
       working-directory: circular-import-fighter

etc/spack/defaults/concretizer.yaml

@@ -63,3 +63,7 @@ concretizer:
   # Setting this to false yields unreproducible results, so we advise to use that value only
   # for debugging purposes (e.g. check which constraints can help Spack concretize faster).
   error_on_timeout: true
+
+  # Static analysis may reduce the concretization time by generating smaller ASP problems, in
+  # cases where there are requirements that prevent part of the search space to be explored.
+  static_analysis: false

lib/spack/llnl/util/tty/log.py

@@ -344,26 +344,6 @@ def close(self):
             self.file.close()
 
 
-@contextmanager
-def replace_environment(env):
-    """Replace the current environment (`os.environ`) with `env`.
-
-    If `env` is empty (or None), this unsets all current environment
-    variables.
-    """
-    env = env or {}
-    old_env = os.environ.copy()
-    try:
-        os.environ.clear()
-        for name, val in env.items():
-            os.environ[name] = val
-        yield
-    finally:
-        os.environ.clear()
-        for name, val in old_env.items():
-            os.environ[name] = val
-
-
 def log_output(*args, **kwargs):
     """Context manager that logs its output to a file.
 
@@ -447,7 +427,6 @@ def __init__(
         self.echo = echo
         self.debug = debug
         self.buffer = buffer
-        self.env = env  # the environment to use for _writer_daemon
         self.filter_fn = filter_fn
 
         self._active = False  # used to prevent re-entry
@@ -519,21 +498,20 @@ def __enter__(self):
                 # just don't forward input if this fails
                 pass
 
-            with replace_environment(self.env):
-                self.process = multiprocessing.Process(
-                    target=_writer_daemon,
-                    args=(
-                        input_fd,
-                        read_fd,
-                        self.write_fd,
-                        self.echo,
-                        self.log_file,
-                        child_pipe,
-                        self.filter_fn,
-                    ),
-                )
-                self.process.daemon = True  # must set before start()
-                self.process.start()
+            self.process = multiprocessing.Process(
+                target=_writer_daemon,
+                args=(
+                    input_fd,
+                    read_fd,
+                    self.write_fd,
+                    self.echo,
+                    self.log_file,
+                    child_pipe,
+                    self.filter_fn,
+                ),
+            )
+            self.process.daemon = True  # must set before start()
+            self.process.start()
 
         finally:
             if input_fd:
@@ -729,10 +707,7 @@ class winlog:
     Does not support the use of 'v' toggling as nixlog does.
     """
 
-    def __init__(
-        self, file_like=None, echo=False, debug=0, buffer=False, env=None, filter_fn=None
-    ):
-        self.env = env
+    def __init__(self, file_like=None, echo=False, debug=0, buffer=False, filter_fn=None):
         self.debug = debug
         self.echo = echo
         self.logfile = file_like
@@ -789,11 +764,10 @@ def background_reader(reader, echo_writer, _kill):
                     reader.close()
 
             self._active = True
-            with replace_environment(self.env):
-                self._thread = Thread(
-                    target=background_reader, args=(self.reader, self.echo_writer, self._kill)
-                )
-                self._thread.start()
+            self._thread = Thread(
+                target=background_reader, args=(self.reader, self.echo_writer, self._kill)
+            )
+            self._thread.start()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

lib/spack/spack/builder.py

@@ -11,7 +11,7 @@
 import spack.multimethod
 import spack.package_base
 import spack.phase_callbacks
-import spack.repo
+import spack.repo_utils
 import spack.spec
 import spack.util.environment
 
@@ -59,7 +59,7 @@ def __call__(self, spec, prefix):
 def get_builder_class(pkg, name: str) -> Optional[Type["Builder"]]:
     """Return the builder class if a package module defines it."""
     cls = getattr(pkg.module, name, None)
-    if cls and cls.__module__.startswith(spack.repo.ROOT_PYTHON_NAMESPACE):
+    if cls and cls.__module__.startswith(spack.repo_utils.ROOT_PYTHON_NAMESPACE):
         return cls
     return None
 

lib/spack/spack/cmd/dependencies.py

@@ -9,9 +9,9 @@
 
 import spack.cmd
 import spack.environment as ev
-import spack.package_base
 import spack.store
 from spack.cmd.common import arguments
+from spack.solver.input_analysis import create_graph_analyzer
 
 description = "show dependencies of a package"
 section = "basic"
@@ -68,15 +68,17 @@ def dependencies(parser, args):
 
     else:
         spec = specs[0]
-        dependencies = spack.package_base.possible_dependencies(
+        dependencies, virtuals, _ = create_graph_analyzer().possible_dependencies(
             spec,
             transitive=args.transitive,
             expand_virtuals=args.expand_virtuals,
-            depflag=args.deptype,
+            allowed_deps=args.deptype,
         )
+        if not args.expand_virtuals:
+            dependencies.update(virtuals)
 
         if spec.name in dependencies:
-            del dependencies[spec.name]
+            dependencies.remove(spec.name)
 
         if dependencies:
             colify(sorted(dependencies))

lib/spack/spack/cmd/repo.py

@@ -8,6 +8,7 @@
 import llnl.util.tty as tty
 
 import spack.config
+import spack.error
 import spack.repo
 import spack.util.path
 from spack.cmd.common import arguments
@@ -129,7 +130,7 @@ def repo_remove(args):
                 spack.config.set("repos", repos, args.scope)
                 tty.msg("Removed repository %s with namespace '%s'." % (repo.root, repo.namespace))
                 return
-        except spack.repo.RepoError:
+        except spack.error.RepoError:
             continue
 
     tty.die("No repository with path or namespace: %s" % namespace_or_path)
@@ -142,7 +143,7 @@ def repo_list(args):
     for r in roots:
         try:
             repos.append(spack.repo.from_path(r))
-        except spack.repo.RepoError:
+        except spack.error.RepoError:
             continue
 
     if sys.stdout.isatty():

lib/spack/spack/cmd/style.py

@@ -14,7 +14,7 @@
 from llnl.util.filesystem import working_dir
 
 import spack.paths
-import spack.repo
+import spack.repo_utils
 import spack.util.git
 from spack.util.executable import Executable, which
 
@@ -369,7 +369,7 @@ def run_black(black_cmd, file_list, args):
 def _module_part(root: str, expr: str):
     parts = expr.split(".")
     # spack.pkg is for repositories, don't try to resolve it here.
-    if ".".join(parts[:2]) == spack.repo.ROOT_PYTHON_NAMESPACE:
+    if ".".join(parts[:2]) == spack.repo_utils.ROOT_PYTHON_NAMESPACE:
         return None
     while parts:
         f1 = os.path.join(root, "lib", "spack", *parts) + ".py"

lib/spack/spack/directives_meta.py

@@ -9,7 +9,7 @@
 import llnl.util.lang
 
 import spack.error
-import spack.repo
+import spack.repo_utils
 import spack.spec
 
 #: Names of possible directives. This list is mostly populated using the @directive decorator.
@@ -65,7 +65,7 @@ def __init__(cls: "DirectiveMeta", name: str, bases: tuple, attr_dict: dict):
         # The instance is being initialized: if it is a package we must ensure
         # that the directives are called to set it up.
 
-        if cls.__module__.startswith(spack.repo.ROOT_PYTHON_NAMESPACE):
+        if cls.__module__.startswith(spack.repo_utils.ROOT_PYTHON_NAMESPACE):
             # Ensure the presence of the dictionaries associated with the directives.
             # All dictionaries are defaultdicts that create lists for missing keys.
             for d in DirectiveMeta._directive_dict_names:

lib/spack/spack/error.py

@@ -202,3 +202,11 @@ class MirrorError(SpackError):
 
     def __init__(self, msg, long_msg=None):
         super().__init__(msg, long_msg)
+
+
+class RepoError(SpackError):
+    """Superclass for repository-related errors."""
+
+
+class UnknownEntityError(RepoError):
+    """Raised when we encounter a package spack doesn't have."""

lib/spack/spack/graph.py

@@ -42,10 +42,10 @@
 import llnl.util.tty.color
 
 import spack.deptypes as dt
-import spack.repo
 import spack.spec
 import spack.tengine
 import spack.traverse
+from spack.solver.input_analysis import create_graph_analyzer
 
 
 def find(seq, predicate):
@@ -537,10 +537,11 @@ def edge_entry(self, edge):
 
 def _static_edges(specs, depflag):
     for spec in specs:
-        pkg_cls = spack.repo.PATH.get_pkg_class(spec.name)
-        possible = pkg_cls.possible_dependencies(expand_virtuals=True, depflag=depflag)
+        *_, edges = create_graph_analyzer().possible_dependencies(
+            spec.name, expand_virtuals=True, allowed_deps=depflag
+        )
 
-        for parent_name, dependencies in possible.items():
+        for parent_name, dependencies in edges.items():
             for dependency_name in dependencies:
                 yield spack.spec.DependencySpec(
                     spack.spec.Spec(parent_name),

lib/spack/spack/installer.py

@@ -560,7 +560,7 @@ def dump_packages(spec: "spack.spec.Spec", path: str) -> None:
             try:
                 source_repo = spack.repo.from_path(source_repo_root)
                 source_pkg_dir = source_repo.dirname_for_package_name(node.name)
-            except spack.repo.RepoError as err:
+            except spack.error.RepoError as err:
                 tty.debug(f"Failed to create source repo for {node.name}: {str(err)}")
                 source_pkg_dir = None
                 tty.warn(f"Warning: Couldn't copy in provenance for {node.name}")
@@ -2436,11 +2436,7 @@ def _real_install(self) -> None:
                     # DEBUGGING TIP - to debug this section, insert an IPython
                     # embed here, and run the sections below without log capture
                     log_contextmanager = log_output(
-                        log_file,
-                        self.echo,
-                        True,
-                        env=self.unmodified_env,
-                        filter_fn=self.filter_fn,
+                        log_file, self.echo, True, filter_fn=self.filter_fn
                     )
 
                     with log_contextmanager as logger:

lib/spack/spack/package_base.py

@@ -22,7 +22,6 @@
 import textwrap
 import time
 import traceback
-import typing
 from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Type, TypeVar, Union
 
 from typing_extensions import Literal
@@ -37,14 +36,14 @@
 import spack.deptypes as dt
 import spack.directives_meta
 import spack.error
-import spack.fetch_strategy as fs
+import spack.fetch_strategy
 import spack.hooks
 import spack.mirrors.layout
 import spack.mirrors.mirror
 import spack.multimethod
 import spack.patch
 import spack.phase_callbacks
-import spack.repo
+import spack.repo_utils
 import spack.spec
 import spack.store
 import spack.url
@@ -822,104 +821,6 @@ def get_variant(self, name: str) -> spack.variant.Variant:
         except StopIteration:
             raise ValueError(f"No variant '{name}' on spec: {self.spec}")
 
-    @classmethod
-    def possible_dependencies(
-        cls,
-        transitive: bool = True,
-        expand_virtuals: bool = True,
-        depflag: dt.DepFlag = dt.ALL,
-        visited: Optional[dict] = None,
-        missing: Optional[dict] = None,
-        virtuals: Optional[set] = None,
-    ) -> Dict[str, Set[str]]:
-        """Return dict of possible dependencies of this package.
-
-        Args:
-            transitive (bool or None): return all transitive dependencies if
-                True, only direct dependencies if False (default True)..
-            expand_virtuals (bool or None): expand virtual dependencies into
-                all possible implementations (default True)
-            depflag: dependency types to consider
-            visited (dict or None): dict of names of dependencies visited so
-                far, mapped to their immediate dependencies' names.
-            missing (dict or None): dict to populate with packages and their
-                *missing* dependencies.
-            virtuals (set): if provided, populate with virtuals seen so far.
-
-        Returns:
-            (dict): dictionary mapping dependency names to *their*
-                immediate dependencies
-
-        Each item in the returned dictionary maps a (potentially
-        transitive) dependency of this package to its possible
-        *immediate* dependencies. If ``expand_virtuals`` is ``False``,
-        virtual package names wil be inserted as keys mapped to empty
-        sets of dependencies.  Virtuals, if not expanded, are treated as
-        though they have no immediate dependencies.
-
-        Missing dependencies by default are ignored, but if a
-        missing dict is provided, it will be populated with package names
-        mapped to any dependencies they have that are in no
-        repositories. This is only populated if transitive is True.
-
-        Note: the returned dict *includes* the package itself.
-
-        """
-        visited = {} if visited is None else visited
-        missing = {} if missing is None else missing
-
-        visited.setdefault(cls.name, set())
-
-        for name, conditions in cls.dependencies_by_name(when=True).items():
-            # check whether this dependency could be of the type asked for
-            depflag_union = 0
-            for deplist in conditions.values():
-                for dep in deplist:
-                    depflag_union |= dep.depflag
-            if not (depflag & depflag_union):
-                continue
-
-            # expand virtuals if enabled, otherwise just stop at virtuals
-            if spack.repo.PATH.is_virtual(name):
-                if virtuals is not None:
-                    virtuals.add(name)
-                if expand_virtuals:
-                    providers = spack.repo.PATH.providers_for(name)
-                    dep_names = [spec.name for spec in providers]
-                else:
-                    visited.setdefault(cls.name, set()).add(name)
-                    visited.setdefault(name, set())
-                    continue
-            else:
-                dep_names = [name]
-
-            # add the dependency names to the visited dict
-            visited.setdefault(cls.name, set()).update(set(dep_names))
-
-            # recursively traverse dependencies
-            for dep_name in dep_names:
-                if dep_name in visited:
-                    continue
-
-                visited.setdefault(dep_name, set())
-
-                # skip the rest if not transitive
-                if not transitive:
-                    continue
-
-                try:
-                    dep_cls = spack.repo.PATH.get_pkg_class(dep_name)
-                except spack.repo.UnknownPackageError:
-                    # log unknown packages
-                    missing.setdefault(cls.name, set()).add(dep_name)
-                    continue
-
-                dep_cls.possible_dependencies(
-                    transitive, expand_virtuals, depflag, visited, missing, virtuals
-                )
-
-        return visited
-
     @classproperty
     def package_dir(cls):
         """Directory where the package.py file lives."""
@@ -937,7 +838,7 @@ def module(cls):
     @classproperty
     def namespace(cls):
         """Spack namespace for the package, which identifies its repo."""
-        return spack.repo.namespace_from_fullname(cls.__module__)
+        return spack.repo_utils.namespace_from_fullname(cls.__module__)
 
     @classproperty
     def fullname(cls):
@@ -1197,7 +1098,7 @@ def _make_resource_stage(self, root_stage, resource):
         )
 
     def _download_search(self):
-        dynamic_fetcher = fs.from_list_url(self)
+        dynamic_fetcher = spack.fetch_strategy.from_list_url(self)
         return [dynamic_fetcher] if dynamic_fetcher else []
 
     def _make_root_stage(self, fetcher):
@@ -1366,7 +1267,7 @@ def fetcher(self):
         if not self.spec.versions.concrete:
             raise ValueError("Cannot retrieve fetcher for package without concrete version.")
         if not self._fetcher:
-            self._fetcher = fs.for_package_version(self)
+            self._fetcher = spack.fetch_strategy.for_package_version(self)
         return self._fetcher
 
     @fetcher.setter
@@ -1758,8 +1659,11 @@ def content_hash(self, content: Optional[bytes] = None) -> str:
         # TODO: resources
         if self.spec.versions.concrete:
             try:
-                source_id = fs.for_package_version(self).source_id()
-            except (fs.ExtrapolationError, fs.InvalidArgsError):
+                source_id = spack.fetch_strategy.for_package_version(self).source_id()
+            except (
+                spack.fetch_strategy.ExtrapolationError,
+                spack.fetch_strategy.InvalidArgsError,
+            ):
                 # ExtrapolationError happens if the package has no fetchers defined.
                 # InvalidArgsError happens when there are version directives with args,
                 #     but none of them identifies an actual fetcher.
@@ -2109,7 +2013,7 @@ def uninstall_by_spec(spec, force=False, deprecator=None):
         # Try to get the package for the spec
         try:
             pkg = spec.package
-        except spack.repo.UnknownEntityError:
+        except spack.error.UnknownEntityError:
             pkg = None
 
         # Pre-uninstall hook runs first.
@@ -2284,55 +2188,6 @@ def rpath_args(self):
 build_system_flags = PackageBase.build_system_flags
 
 
-def use_cray_compiler_names():
-    """Compiler names for builds that rely on cray compiler names."""
-    os.environ["CC"] = "cc"
-    os.environ["CXX"] = "CC"
-    os.environ["FC"] = "ftn"
-    os.environ["F77"] = "ftn"
-
-
-def possible_dependencies(
-    *pkg_or_spec: Union[str, spack.spec.Spec, typing.Type[PackageBase]],
-    transitive: bool = True,
-    expand_virtuals: bool = True,
-    depflag: dt.DepFlag = dt.ALL,
-    missing: Optional[dict] = None,
-    virtuals: Optional[set] = None,
-) -> Dict[str, Set[str]]:
-    """Get the possible dependencies of a number of packages.
-
-    See ``PackageBase.possible_dependencies`` for details.
-    """
-    packages = []
-    for pos in pkg_or_spec:
-        if isinstance(pos, PackageMeta) and issubclass(pos, PackageBase):
-            packages.append(pos)
-            continue
-
-        if not isinstance(pos, spack.spec.Spec):
-            pos = spack.spec.Spec(pos)
-
-        if spack.repo.PATH.is_virtual(pos.name):
-            packages.extend(p.package_class for p in spack.repo.PATH.providers_for(pos.name))
-            continue
-        else:
-            packages.append(pos.package_class)
-
-    visited: Dict[str, Set[str]] = {}
-    for pkg in packages:
-        pkg.possible_dependencies(
-            visited=visited,
-            transitive=transitive,
-            expand_virtuals=expand_virtuals,
-            depflag=depflag,
-            missing=missing,
-            virtuals=virtuals,
-        )
-
-    return visited
-
-
 def deprecated_version(pkg: PackageBase, version: Union[str, StandardVersion]) -> bool:
     """Return True iff the version is deprecated.
 

lib/spack/spack/repo.py

@@ -35,8 +35,10 @@
 import spack.caches
 import spack.config
 import spack.error
+import spack.package_base
 import spack.patch
 import spack.provider_index
+import spack.repo_utils
 import spack.spec
 import spack.tag
 import spack.tengine
@@ -46,39 +48,6 @@
 import spack.util.path
 import spack.util.spack_yaml as syaml
 
-#: Package modules are imported as spack.pkg.<repo-namespace>.<pkg-name>
-ROOT_PYTHON_NAMESPACE = "spack.pkg"
-
-
-def python_package_for_repo(namespace):
-    """Returns the full namespace of a repository, given its relative one
-
-    For instance:
-
-        python_package_for_repo('builtin') == 'spack.pkg.builtin'
-
-    Args:
-        namespace (str): repo namespace
-    """
-    return "{0}.{1}".format(ROOT_PYTHON_NAMESPACE, namespace)
-
-
-def namespace_from_fullname(fullname):
-    """Return the repository namespace only for the full module name.
-
-    For instance:
-
-        namespace_from_fullname('spack.pkg.builtin.hdf5') == 'builtin'
-
-    Args:
-        fullname (str): full name for the Python module
-    """
-    namespace, dot, module = fullname.rpartition(".")
-    prefix_and_dot = "{0}.".format(ROOT_PYTHON_NAMESPACE)
-    if namespace.startswith(prefix_and_dot):
-        namespace = namespace[len(prefix_and_dot) :]
-    return namespace
-
 
 class SpackNamespaceLoader:
     def create_module(self, spec):
@@ -124,7 +93,7 @@ def find_spec(self, fullname, python_path, target=None):
             raise RuntimeError('cannot reload module "{0}"'.format(fullname))
 
         # Preferred API from https://peps.python.org/pep-0451/
-        if not fullname.startswith(ROOT_PYTHON_NAMESPACE):
+        if not fullname.startswith(spack.repo_utils.ROOT_PYTHON_NAMESPACE):
             return None
 
         loader = self.compute_loader(fullname)
@@ -303,7 +272,6 @@ def is_package_file(filename):
     # Package files are named `package.py` and are not in lib/spack/spack
     # We have to remove the file extension because it can be .py and can be
     # .pyc depending on context, and can differ between the files
-    import spack.package_base  # break cycle
 
     filename_noext = os.path.splitext(filename)[0]
     packagebase_filename_noext = os.path.splitext(inspect.getfile(spack.package_base.PackageBase))[
@@ -663,7 +631,7 @@ def __init__(
                     repo = Repo(repo, cache=cache, overrides=overrides)
                 repo.finder(self)
                 self.put_last(repo)
-            except RepoError as e:
+            except spack.error.RepoError as e:
                 tty.warn(
                     f"Failed to initialize repository: '{repo}'.",
                     e.message,
@@ -705,7 +673,7 @@ def remove(self, repo):
 
     def get_repo(self, namespace: str) -> "Repo":
         """Get a repository by namespace."""
-        full_namespace = python_package_for_repo(namespace)
+        full_namespace = spack.repo_utils.python_package_for_repo(namespace)
         if full_namespace not in self.by_namespace:
             raise UnknownNamespaceError(namespace)
         return self.by_namespace[full_namespace]
@@ -816,7 +784,7 @@ def repo_for_pkg(self, spec: Union[str, "spack.spec.Spec"]) -> "Repo":
         # If the spec already has a namespace, then return the
         # corresponding repo if we know about it.
         if namespace:
-            fullspace = python_package_for_repo(namespace)
+            fullspace = spack.repo_utils.python_package_for_repo(namespace)
             if fullspace not in self.by_namespace:
                 raise UnknownNamespaceError(namespace, name=name)
             return self.by_namespace[fullspace]
@@ -966,7 +934,7 @@ def check(condition, msg):
         )
 
         # Set up 'full_namespace' to include the super-namespace
-        self.full_namespace = python_package_for_repo(self.namespace)
+        self.full_namespace = spack.repo_utils.python_package_for_repo(self.namespace)
 
         # Keep name components around for checking prefixes.
         self._names = self.full_namespace.split(".")
@@ -1241,7 +1209,7 @@ def get_pkg_class(self, pkg_name: str) -> Type["spack.package_base.PackageBase"]
             raise UnknownPackageError(fullname)
         except Exception as e:
             msg = f"cannot load package '{pkg_name}' from the '{self.namespace}' repository: {e}"
-            raise RepoError(msg) from e
+            raise spack.error.RepoError(msg) from e
 
         cls = getattr(module, class_name)
         if not isinstance(cls, type):
@@ -1501,27 +1469,19 @@ def recipe_filename(self, name):
         return os.path.join(self.root, "packages", name, "package.py")
 
 
-class RepoError(spack.error.SpackError):
-    """Superclass for repository-related errors."""
-
-
-class NoRepoConfiguredError(RepoError):
+class NoRepoConfiguredError(spack.error.RepoError):
     """Raised when there are no repositories configured."""
 
 
-class InvalidNamespaceError(RepoError):
+class InvalidNamespaceError(spack.error.RepoError):
     """Raised when an invalid namespace is encountered."""
 
 
-class BadRepoError(RepoError):
+class BadRepoError(spack.error.RepoError):
     """Raised when repo layout is invalid."""
 
 
-class UnknownEntityError(RepoError):
-    """Raised when we encounter a package spack doesn't have."""
-
-
-class UnknownPackageError(UnknownEntityError):
+class UnknownPackageError(spack.error.UnknownEntityError):
     """Raised when we encounter a package spack doesn't have."""
 
     def __init__(self, name, repo=None):
@@ -1558,7 +1518,7 @@ def __init__(self, name, repo=None):
         self.name = name
 
 
-class UnknownNamespaceError(UnknownEntityError):
+class UnknownNamespaceError(spack.error.UnknownEntityError):
     """Raised when we encounter an unknown namespace"""
 
     def __init__(self, namespace, name=None):
@@ -1568,7 +1528,7 @@ def __init__(self, namespace, name=None):
         super().__init__(msg, long_msg)
 
 
-class FailedConstructorError(RepoError):
+class FailedConstructorError(spack.error.RepoError):
     """Raised when a package's class constructor fails."""
 
     def __init__(self, name, exc_type, exc_obj, exc_tb):

lib/spack/spack/repo_utils.py

@@ -0,0 +1,36 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+#: Package modules are imported as spack.pkg.<repo-namespace>.<pkg-name>
+ROOT_PYTHON_NAMESPACE = "spack.pkg"
+
+
+def namespace_from_fullname(fullname):
+    """Return the repository namespace only for the full module name.
+
+    For instance:
+
+        namespace_from_fullname('spack.pkg.builtin.hdf5') == 'builtin'
+
+    Args:
+        fullname (str): full name for the Python module
+    """
+    namespace, dot, module = fullname.rpartition(".")
+    prefix_and_dot = "{0}.".format(ROOT_PYTHON_NAMESPACE)
+    if namespace.startswith(prefix_and_dot):
+        namespace = namespace[len(prefix_and_dot) :]
+    return namespace
+
+
+def python_package_for_repo(namespace):
+    """Returns the full namespace of a repository, given its relative one
+
+    For instance:
+
+        python_package_for_repo('builtin') == 'spack.pkg.builtin'
+
+    Args:
+        namespace (str): repo namespace
+    """
+    return "{0}.{1}".format(ROOT_PYTHON_NAMESPACE, namespace)

lib/spack/spack/schema/concretizer.py

@@ -87,6 +87,7 @@
                     "strategy": {"type": "string", "enum": ["none", "minimal", "full"]}
                 },
             },
+            "static_analysis": {"type": "boolean"},
             "timeout": {"type": "integer", "minimum": 0},
             "error_on_timeout": {"type": "boolean"},
             "os_compatible": {"type": "object", "additionalProperties": {"type": "array"}},

lib/spack/spack/solver/asp.py

@@ -62,7 +62,7 @@
     parse_files,
     parse_term,
 )
-from .counter import FullDuplicatesCounter, MinimalDuplicatesCounter, NoDuplicatesCounter
+from .input_analysis import create_counter, create_graph_analyzer
 from .requirements import RequirementKind, RequirementParser, RequirementRule
 from .version_order import concretization_version_order
 
@@ -271,15 +271,6 @@ def remove_node(spec: spack.spec.Spec, facts: List[AspFunction]) -> List[AspFunc
     return list(filter(lambda x: x.args[0] not in ("node", "virtual_node"), facts))
 
 
-def _create_counter(specs: List[spack.spec.Spec], tests: bool):
-    strategy = spack.config.CONFIG.get("concretizer:duplicates:strategy", "none")
-    if strategy == "full":
-        return FullDuplicatesCounter(specs, tests=tests)
-    if strategy == "minimal":
-        return MinimalDuplicatesCounter(specs, tests=tests)
-    return NoDuplicatesCounter(specs, tests=tests)
-
-
 def all_libcs() -> Set[spack.spec.Spec]:
     """Return a set of all libc specs targeted by any configured compiler. If none, fall back to
     libc determined from the current Python process if dynamically linked."""
@@ -1121,6 +1112,8 @@ class SpackSolverSetup:
     """Class to set up and run a Spack concretization solve."""
 
     def __init__(self, tests: bool = False):
+        self.possible_graph = create_graph_analyzer()
+
         # these are all initialized in setup()
         self.gen: "ProblemInstanceBuilder" = ProblemInstanceBuilder()
         self.requirement_parser = RequirementParser(spack.config.CONFIG)
@@ -2397,38 +2390,20 @@ def keyfun(os):
 
     def target_defaults(self, specs):
         """Add facts about targets and target compatibility."""
-        self.gen.h2("Default target")
-
-        platform = spack.platforms.host()
-        uarch = archspec.cpu.TARGETS.get(platform.default)
-
         self.gen.h2("Target compatibility")
 
-        # Construct the list of targets which are compatible with the host
-        candidate_targets = [uarch] + uarch.ancestors
-
-        # Get configuration options
-        granularity = spack.config.get("concretizer:targets:granularity")
-        host_compatible = spack.config.get("concretizer:targets:host_compatible")
-
-        # Add targets which are not compatible with the current host
-        if not host_compatible:
-            additional_targets_in_family = sorted(
-                [
-                    t
-                    for t in archspec.cpu.TARGETS.values()
-                    if (t.family.name == uarch.family.name and t not in candidate_targets)
-                ],
-                key=lambda x: len(x.ancestors),
-                reverse=True,
-            )
-            candidate_targets += additional_targets_in_family
-
-        # Check if we want only generic architecture
-        if granularity == "generic":
-            candidate_targets = [t for t in candidate_targets if t.vendor == "generic"]
-
         # Add targets explicitly requested from specs
+        candidate_targets = []
+        for x in self.possible_graph.candidate_targets():
+            if all(
+                self.possible_graph.unreachable(pkg_name=pkg_name, when_spec=f"target={x}")
+                for pkg_name in self.pkgs
+            ):
+                tty.debug(f"[{__name__}] excluding target={x}, cause no package can use it")
+                continue
+            candidate_targets.append(x)
+
+        host_compatible = spack.config.CONFIG.get("concretizer:targets:host_compatible")
         for spec in specs:
             if not spec.architecture or not spec.architecture.target:
                 continue
@@ -2444,6 +2419,8 @@ def target_defaults(self, specs):
                     if ancestor not in candidate_targets:
                         candidate_targets.append(ancestor)
 
+        platform = spack.platforms.host()
+        uarch = archspec.cpu.TARGETS.get(platform.default)
         best_targets = {uarch.family.name}
         for compiler_id, known_compiler in enumerate(self.possible_compilers):
             if not known_compiler.available:
@@ -2501,7 +2478,6 @@ def target_defaults(self, specs):
             self.gen.newline()
 
         self.default_targets = list(sorted(set(self.default_targets)))
-
         self.target_preferences()
 
     def virtual_providers(self):
@@ -2605,7 +2581,14 @@ def define_variant_values(self):
         # Tell the concretizer about possible values from specs seen in spec_clauses().
         # We might want to order these facts by pkg and name if we are debugging.
         for pkg_name, variant_def_id, value in self.variant_values_from_specs:
-            vid = self.variant_ids_by_def_id[variant_def_id]
+            try:
+                vid = self.variant_ids_by_def_id[variant_def_id]
+            except KeyError:
+                tty.debug(
+                    f"[{__name__}] cannot retrieve id of the {value} variant from {pkg_name}"
+                )
+                continue
+
             self.gen.fact(fn.pkg_fact(pkg_name, fn.variant_possible_value(vid, value)))
 
     def register_concrete_spec(self, spec, possible):
@@ -2676,7 +2659,7 @@ def setup(
         """
         check_packages_exist(specs)
 
-        node_counter = _create_counter(specs, tests=self.tests)
+        node_counter = create_counter(specs, tests=self.tests, possible_graph=self.possible_graph)
         self.possible_virtuals = node_counter.possible_virtuals()
         self.pkgs = node_counter.possible_dependencies()
         self.libcs = sorted(all_libcs())  # type: ignore[type-var]
@@ -3831,7 +3814,7 @@ def _is_reusable(spec: spack.spec.Spec, packages, local: bool) -> bool:
 
     try:
         provided = spack.repo.PATH.get(spec).provided_virtual_names()
-    except spack.repo.RepoError:
+    except spack.error.RepoError:
         provided = []
 
     for name in {spec.name, *provided}:

lib/spack/spack/solver/counter.py

@@ -1,179 +0,0 @@
-# Copyright Spack Project Developers. See COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import collections
-from typing import List, Set
-
-from llnl.util import lang
-
-import spack.deptypes as dt
-import spack.package_base
-import spack.repo
-import spack.spec
-
-PossibleDependencies = Set[str]
-
-
-class Counter:
-    """Computes the possible packages and the maximum number of duplicates
-    allowed for each of them.
-
-    Args:
-        specs: abstract specs to concretize
-        tests: if True, add test dependencies to the list of possible packages
-    """
-
-    def __init__(self, specs: List["spack.spec.Spec"], tests: bool) -> None:
-        runtime_pkgs = spack.repo.PATH.packages_with_tags("runtime")
-        runtime_virtuals = set()
-        for x in runtime_pkgs:
-            pkg_class = spack.repo.PATH.get_pkg_class(x)
-            runtime_virtuals.update(pkg_class.provided_virtual_names())
-
-        self.specs = specs + [spack.spec.Spec(x) for x in runtime_pkgs]
-
-        self.link_run_types: dt.DepFlag = dt.LINK | dt.RUN | dt.TEST
-        self.all_types: dt.DepFlag = dt.ALL
-        if not tests:
-            self.link_run_types = dt.LINK | dt.RUN
-            self.all_types = dt.LINK | dt.RUN | dt.BUILD
-
-        self._possible_dependencies: PossibleDependencies = set()
-        self._possible_virtuals: Set[str] = (
-            set(x.name for x in specs if x.virtual) | runtime_virtuals
-        )
-
-    def possible_dependencies(self) -> PossibleDependencies:
-        """Returns the list of possible dependencies"""
-        self.ensure_cache_values()
-        return self._possible_dependencies
-
-    def possible_virtuals(self) -> Set[str]:
-        """Returns the list of possible virtuals"""
-        self.ensure_cache_values()
-        return self._possible_virtuals
-
-    def ensure_cache_values(self) -> None:
-        """Ensure the cache values have been computed"""
-        if self._possible_dependencies:
-            return
-        self._compute_cache_values()
-
-    def possible_packages_facts(self, gen: "spack.solver.asp.PyclingoDriver", fn) -> None:
-        """Emit facts associated with the possible packages"""
-        raise NotImplementedError("must be implemented by derived classes")
-
-    def _compute_cache_values(self):
-        raise NotImplementedError("must be implemented by derived classes")
-
-
-class NoDuplicatesCounter(Counter):
-    def _compute_cache_values(self):
-        result = spack.package_base.possible_dependencies(
-            *self.specs, virtuals=self._possible_virtuals, depflag=self.all_types
-        )
-        self._possible_dependencies = set(result)
-
-    def possible_packages_facts(self, gen, fn):
-        gen.h2("Maximum number of nodes (packages)")
-        for package_name in sorted(self.possible_dependencies()):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-        gen.h2("Maximum number of nodes (virtual packages)")
-        for package_name in sorted(self.possible_virtuals()):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-        gen.h2("Possible package in link-run subDAG")
-        for name in sorted(self.possible_dependencies()):
-            gen.fact(fn.possible_in_link_run(name))
-        gen.newline()
-
-
-class MinimalDuplicatesCounter(NoDuplicatesCounter):
-    def __init__(self, specs, tests):
-        super().__init__(specs, tests)
-        self._link_run: PossibleDependencies = set()
-        self._direct_build: PossibleDependencies = set()
-        self._total_build: PossibleDependencies = set()
-        self._link_run_virtuals: Set[str] = set()
-
-    def _compute_cache_values(self):
-        self._link_run = set(
-            spack.package_base.possible_dependencies(
-                *self.specs, virtuals=self._possible_virtuals, depflag=self.link_run_types
-            )
-        )
-        self._link_run_virtuals.update(self._possible_virtuals)
-        for x in self._link_run:
-            build_dependencies = spack.repo.PATH.get_pkg_class(x).dependencies_of_type(dt.BUILD)
-            virtuals, reals = lang.stable_partition(
-                build_dependencies, spack.repo.PATH.is_virtual_safe
-            )
-
-            self._possible_virtuals.update(virtuals)
-            for virtual_dep in virtuals:
-                providers = spack.repo.PATH.providers_for(virtual_dep)
-                self._direct_build.update(str(x) for x in providers)
-
-            self._direct_build.update(reals)
-
-        self._total_build = set(
-            spack.package_base.possible_dependencies(
-                *self._direct_build, virtuals=self._possible_virtuals, depflag=self.all_types
-            )
-        )
-        self._possible_dependencies = set(self._link_run) | set(self._total_build)
-
-    def possible_packages_facts(self, gen, fn):
-        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
-        gen.h2("Packages with at most a single node")
-        for package_name in sorted(self.possible_dependencies() - build_tools):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-
-        gen.h2("Packages with at multiple possible nodes (build-tools)")
-        for package_name in sorted(self.possible_dependencies() & build_tools):
-            gen.fact(fn.max_dupes(package_name, 2))
-            gen.fact(fn.multiple_unification_sets(package_name))
-        gen.newline()
-
-        gen.h2("Maximum number of nodes (virtual packages)")
-        for package_name in sorted(self.possible_virtuals()):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-
-        gen.h2("Possible package in link-run subDAG")
-        for name in sorted(self._link_run):
-            gen.fact(fn.possible_in_link_run(name))
-        gen.newline()
-
-
-class FullDuplicatesCounter(MinimalDuplicatesCounter):
-    def possible_packages_facts(self, gen, fn):
-        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
-        counter = collections.Counter(
-            list(self._link_run) + list(self._total_build) + list(self._direct_build)
-        )
-        gen.h2("Maximum number of nodes")
-        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
-            count = min(count, 2)
-            gen.fact(fn.max_dupes(pkg, count))
-        gen.newline()
-
-        gen.h2("Build unification sets ")
-        for name in sorted(self.possible_dependencies() & build_tools):
-            gen.fact(fn.multiple_unification_sets(name))
-        gen.newline()
-
-        gen.h2("Possible package in link-run subDAG")
-        for name in sorted(self._link_run):
-            gen.fact(fn.possible_in_link_run(name))
-        gen.newline()
-
-        counter = collections.Counter(
-            list(self._link_run_virtuals) + list(self._possible_virtuals)
-        )
-        gen.h2("Maximum number of virtual nodes")
-        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
-            gen.fact(fn.max_dupes(pkg, count))
-        gen.newline()

lib/spack/spack/solver/input_analysis.py

@@ -0,0 +1,524 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+"""Classes to analyze the input of a solve, and provide information to set up the ASP problem"""
+import collections
+from typing import Dict, List, NamedTuple, Set, Tuple, Union
+
+import archspec.cpu
+
+from llnl.util import lang, tty
+
+import spack.binary_distribution
+import spack.config
+import spack.deptypes as dt
+import spack.platforms
+import spack.repo
+import spack.spec
+import spack.store
+from spack.error import SpackError
+
+RUNTIME_TAG = "runtime"
+
+
+class PossibleGraph(NamedTuple):
+    real_pkgs: Set[str]
+    virtuals: Set[str]
+    edges: Dict[str, Set[str]]
+
+
+class PossibleDependencyGraph:
+    """Returns information needed to set up an ASP problem"""
+
+    def unreachable(self, *, pkg_name: str, when_spec: spack.spec.Spec) -> bool:
+        """Returns true if the context can determine that the condition cannot ever
+        be met on pkg_name.
+        """
+        raise NotImplementedError
+
+    def candidate_targets(self) -> List[archspec.cpu.Microarchitecture]:
+        """Returns a list of targets that are candidate for concretization"""
+        raise NotImplementedError
+
+    def possible_dependencies(
+        self,
+        *specs: Union[spack.spec.Spec, str],
+        allowed_deps: dt.DepFlag,
+        transitive: bool = True,
+        strict_depflag: bool = False,
+        expand_virtuals: bool = True,
+    ) -> PossibleGraph:
+        """Returns the set of possible dependencies, and the set of possible virtuals.
+
+        Both sets always include runtime packages, which may be injected by compilers.
+
+        Args:
+            transitive: return transitive dependencies if True, only direct dependencies if False
+            allowed_deps: dependency types to consider
+            strict_depflag: if True, only the specific dep type is considered, if False any
+                deptype that intersects with allowed deptype is considered
+            expand_virtuals: expand virtual dependencies into all possible implementations
+        """
+        raise NotImplementedError
+
+
+class NoStaticAnalysis(PossibleDependencyGraph):
+    """Implementation that tries to minimize the setup time (i.e. defaults to give fast
+    answers), rather than trying to reduce the ASP problem size with more complex analysis.
+    """
+
+    def __init__(self, *, configuration: spack.config.Configuration, repo: spack.repo.RepoPath):
+        self.configuration = configuration
+        self.repo = repo
+        self.runtime_pkgs = set(self.repo.packages_with_tags(RUNTIME_TAG))
+        self.runtime_virtuals = set()
+        for x in self.runtime_pkgs:
+            pkg_class = self.repo.get_pkg_class(x)
+            self.runtime_virtuals.update(pkg_class.provided_virtual_names())
+
+        try:
+            self.libc_pkgs = [x.name for x in self.providers_for("libc")]
+        except spack.repo.UnknownPackageError:
+            self.libc_pkgs = []
+
+    def is_virtual(self, name: str) -> bool:
+        return self.repo.is_virtual(name)
+
+    @lang.memoized
+    def is_allowed_on_this_platform(self, *, pkg_name: str) -> bool:
+        """Returns true if a package is allowed on the current host"""
+        pkg_cls = self.repo.get_pkg_class(pkg_name)
+        platform_condition = (
+            f"platform={spack.platforms.host()} target={archspec.cpu.host().family}:"
+        )
+        for when_spec, conditions in pkg_cls.requirements.items():
+            if not when_spec.intersects(platform_condition):
+                continue
+            for requirements, _, _ in conditions:
+                if not any(x.intersects(platform_condition) for x in requirements):
+                    tty.debug(f"[{__name__}] {pkg_name} is not for this platform")
+                    return False
+        return True
+
+    def providers_for(self, virtual_str: str) -> List[spack.spec.Spec]:
+        """Returns a list of possible providers for the virtual string in input."""
+        return self.repo.providers_for(virtual_str)
+
+    def can_be_installed(self, *, pkg_name) -> bool:
+        """Returns True if a package can be installed, False otherwise."""
+        return True
+
+    def unreachable(self, *, pkg_name: str, when_spec: spack.spec.Spec) -> bool:
+        """Returns true if the context can determine that the condition cannot ever
+        be met on pkg_name.
+        """
+        return False
+
+    def candidate_targets(self) -> List[archspec.cpu.Microarchitecture]:
+        """Returns a list of targets that are candidate for concretization"""
+        platform = spack.platforms.host()
+        default_target = archspec.cpu.TARGETS[platform.default]
+
+        # Construct the list of targets which are compatible with the host
+        candidate_targets = [default_target] + default_target.ancestors
+        granularity = self.configuration.get("concretizer:targets:granularity")
+        host_compatible = self.configuration.get("concretizer:targets:host_compatible")
+
+        # Add targets which are not compatible with the current host
+        if not host_compatible:
+            additional_targets_in_family = sorted(
+                [
+                    t
+                    for t in archspec.cpu.TARGETS.values()
+                    if (t.family.name == default_target.family.name and t not in candidate_targets)
+                ],
+                key=lambda x: len(x.ancestors),
+                reverse=True,
+            )
+            candidate_targets += additional_targets_in_family
+
+        # Check if we want only generic architecture
+        if granularity == "generic":
+            candidate_targets = [t for t in candidate_targets if t.vendor == "generic"]
+
+        return candidate_targets
+
+    def possible_dependencies(
+        self,
+        *specs: Union[spack.spec.Spec, str],
+        allowed_deps: dt.DepFlag,
+        transitive: bool = True,
+        strict_depflag: bool = False,
+        expand_virtuals: bool = True,
+    ) -> PossibleGraph:
+        stack = [x for x in self._package_list(specs)]
+        virtuals: Set[str] = set()
+        edges: Dict[str, Set[str]] = {}
+
+        while stack:
+            pkg_name = stack.pop()
+
+            if pkg_name in edges:
+                continue
+
+            edges[pkg_name] = set()
+
+            # Since libc is not buildable, there is no need to extend the
+            # search space with libc dependencies.
+            if pkg_name in self.libc_pkgs:
+                continue
+
+            pkg_cls = self.repo.get_pkg_class(pkg_name=pkg_name)
+            for name, conditions in pkg_cls.dependencies_by_name(when=True).items():
+                if all(self.unreachable(pkg_name=pkg_name, when_spec=x) for x in conditions):
+                    tty.debug(
+                        f"[{__name__}] Not adding {name} as a dep of {pkg_name}, because "
+                        f"conditions cannot be met"
+                    )
+                    continue
+
+                if not self._has_deptypes(
+                    conditions, allowed_deps=allowed_deps, strict=strict_depflag
+                ):
+                    continue
+
+                if name in virtuals:
+                    continue
+
+                dep_names = set()
+                if self.is_virtual(name):
+                    virtuals.add(name)
+                    if expand_virtuals:
+                        providers = self.providers_for(name)
+                        dep_names = {spec.name for spec in providers}
+                else:
+                    dep_names = {name}
+
+                edges[pkg_name].update(dep_names)
+
+                if not transitive:
+                    continue
+
+                for dep_name in dep_names:
+                    if dep_name in edges:
+                        continue
+
+                    if not self._is_possible(pkg_name=dep_name):
+                        continue
+
+                    stack.append(dep_name)
+
+        real_packages = set(edges)
+        if not transitive:
+            # We exit early, so add children from the edges information
+            for root, children in edges.items():
+                real_packages.update(x for x in children if self._is_possible(pkg_name=x))
+
+        virtuals.update(self.runtime_virtuals)
+        real_packages = real_packages | self.runtime_pkgs
+        return PossibleGraph(real_pkgs=real_packages, virtuals=virtuals, edges=edges)
+
+    def _package_list(self, specs: Tuple[Union[spack.spec.Spec, str], ...]) -> List[str]:
+        stack = []
+        for current_spec in specs:
+            if isinstance(current_spec, str):
+                current_spec = spack.spec.Spec(current_spec)
+
+            if self.repo.is_virtual(current_spec.name):
+                stack.extend([p.name for p in self.providers_for(current_spec.name)])
+                continue
+
+            stack.append(current_spec.name)
+        return sorted(set(stack))
+
+    def _has_deptypes(self, dependencies, *, allowed_deps: dt.DepFlag, strict: bool) -> bool:
+        if strict is True:
+            return any(
+                dep.depflag == allowed_deps for deplist in dependencies.values() for dep in deplist
+            )
+        return any(
+            dep.depflag & allowed_deps for deplist in dependencies.values() for dep in deplist
+        )
+
+    def _is_possible(self, *, pkg_name):
+        try:
+            return self.is_allowed_on_this_platform(pkg_name=pkg_name) and self.can_be_installed(
+                pkg_name=pkg_name
+            )
+        except spack.repo.UnknownPackageError:
+            return False
+
+
+class StaticAnalysis(NoStaticAnalysis):
+    """Performs some static analysis of the configuration, store, etc. to provide more precise
+    answers on whether some packages can be installed, or used as a provider.
+
+    It increases the setup time, but might decrease the grounding and solve time considerably,
+    especially when requirements restrict the possible choices for providers.
+    """
+
+    def __init__(
+        self,
+        *,
+        configuration: spack.config.Configuration,
+        repo: spack.repo.RepoPath,
+        store: spack.store.Store,
+        binary_index: spack.binary_distribution.BinaryCacheIndex,
+    ):
+        super().__init__(configuration=configuration, repo=repo)
+        self.store = store
+        self.binary_index = binary_index
+
+    @lang.memoized
+    def providers_for(self, virtual_str: str) -> List[spack.spec.Spec]:
+        candidates = super().providers_for(virtual_str)
+        result = []
+        for spec in candidates:
+            if not self._is_provider_candidate(pkg_name=spec.name, virtual=virtual_str):
+                continue
+            result.append(spec)
+        return result
+
+    @lang.memoized
+    def buildcache_specs(self) -> List[spack.spec.Spec]:
+        self.binary_index.update()
+        return self.binary_index.get_all_built_specs()
+
+    @lang.memoized
+    def can_be_installed(self, *, pkg_name) -> bool:
+        if self.configuration.get(f"packages:{pkg_name}:buildable", True):
+            return True
+
+        if self.configuration.get(f"packages:{pkg_name}:externals", []):
+            return True
+
+        reuse = self.configuration.get("concretizer:reuse")
+        if reuse is not False and self.store.db.query(pkg_name):
+            return True
+
+        if reuse is not False and any(x.name == pkg_name for x in self.buildcache_specs()):
+            return True
+
+        tty.debug(f"[{__name__}] {pkg_name} cannot be installed")
+        return False
+
+    @lang.memoized
+    def _is_provider_candidate(self, *, pkg_name: str, virtual: str) -> bool:
+        if not self.is_allowed_on_this_platform(pkg_name=pkg_name):
+            return False
+
+        if not self.can_be_installed(pkg_name=pkg_name):
+            return False
+
+        virtual_spec = spack.spec.Spec(virtual)
+        if self.unreachable(pkg_name=virtual_spec.name, when_spec=pkg_name):
+            tty.debug(f"[{__name__}] {pkg_name} cannot be a provider for {virtual}")
+            return False
+
+        return True
+
+    @lang.memoized
+    def unreachable(self, *, pkg_name: str, when_spec: spack.spec.Spec) -> bool:
+        """Returns true if the context can determine that the condition cannot ever
+        be met on pkg_name.
+        """
+        candidates = self.configuration.get(f"packages:{pkg_name}:require", [])
+        if not candidates and pkg_name != "all":
+            return self.unreachable(pkg_name="all", when_spec=when_spec)
+
+        if not candidates:
+            return False
+
+        if isinstance(candidates, str):
+            candidates = [candidates]
+
+        union_requirement = spack.spec.Spec()
+        for c in candidates:
+            if not isinstance(c, str):
+                continue
+            try:
+                union_requirement.constrain(c)
+            except SpackError:
+                # Less optimized, but shouldn't fail
+                pass
+
+        if not union_requirement.intersects(when_spec):
+            return True
+
+        return False
+
+
+def create_graph_analyzer() -> PossibleDependencyGraph:
+    static_analysis = spack.config.CONFIG.get("concretizer:static_analysis", False)
+    if static_analysis:
+        return StaticAnalysis(
+            configuration=spack.config.CONFIG,
+            repo=spack.repo.PATH,
+            store=spack.store.STORE,
+            binary_index=spack.binary_distribution.BINARY_INDEX,
+        )
+    return NoStaticAnalysis(configuration=spack.config.CONFIG, repo=spack.repo.PATH)
+
+
+class Counter:
+    """Computes the possible packages and the maximum number of duplicates
+    allowed for each of them.
+
+    Args:
+        specs: abstract specs to concretize
+        tests: if True, add test dependencies to the list of possible packages
+    """
+
+    def __init__(
+        self, specs: List["spack.spec.Spec"], tests: bool, possible_graph: PossibleDependencyGraph
+    ) -> None:
+        self.possible_graph = possible_graph
+        self.specs = specs
+        self.link_run_types: dt.DepFlag = dt.LINK | dt.RUN | dt.TEST
+        self.all_types: dt.DepFlag = dt.ALL
+        if not tests:
+            self.link_run_types = dt.LINK | dt.RUN
+            self.all_types = dt.LINK | dt.RUN | dt.BUILD
+
+        self._possible_dependencies: Set[str] = set()
+        self._possible_virtuals: Set[str] = set(x.name for x in specs if x.virtual)
+
+    def possible_dependencies(self) -> Set[str]:
+        """Returns the list of possible dependencies"""
+        self.ensure_cache_values()
+        return self._possible_dependencies
+
+    def possible_virtuals(self) -> Set[str]:
+        """Returns the list of possible virtuals"""
+        self.ensure_cache_values()
+        return self._possible_virtuals
+
+    def ensure_cache_values(self) -> None:
+        """Ensure the cache values have been computed"""
+        if self._possible_dependencies:
+            return
+        self._compute_cache_values()
+
+    def possible_packages_facts(self, gen: "spack.solver.asp.ProblemInstanceBuilder", fn) -> None:
+        """Emit facts associated with the possible packages"""
+        raise NotImplementedError("must be implemented by derived classes")
+
+    def _compute_cache_values(self) -> None:
+        raise NotImplementedError("must be implemented by derived classes")
+
+
+class NoDuplicatesCounter(Counter):
+    def _compute_cache_values(self) -> None:
+        self._possible_dependencies, virtuals, _ = self.possible_graph.possible_dependencies(
+            *self.specs, allowed_deps=self.all_types
+        )
+        self._possible_virtuals.update(virtuals)
+
+    def possible_packages_facts(self, gen: "spack.solver.asp.ProblemInstanceBuilder", fn) -> None:
+        gen.h2("Maximum number of nodes (packages)")
+        for package_name in sorted(self.possible_dependencies()):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+        gen.h2("Maximum number of nodes (virtual packages)")
+        for package_name in sorted(self.possible_virtuals()):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+        gen.h2("Possible package in link-run subDAG")
+        for name in sorted(self.possible_dependencies()):
+            gen.fact(fn.possible_in_link_run(name))
+        gen.newline()
+
+
+class MinimalDuplicatesCounter(NoDuplicatesCounter):
+    def __init__(
+        self, specs: List["spack.spec.Spec"], tests: bool, possible_graph: PossibleDependencyGraph
+    ) -> None:
+        super().__init__(specs, tests, possible_graph)
+        self._link_run: Set[str] = set()
+        self._direct_build: Set[str] = set()
+        self._total_build: Set[str] = set()
+        self._link_run_virtuals: Set[str] = set()
+
+    def _compute_cache_values(self) -> None:
+        self._link_run, virtuals, _ = self.possible_graph.possible_dependencies(
+            *self.specs, allowed_deps=self.link_run_types
+        )
+        self._possible_virtuals.update(virtuals)
+        self._link_run_virtuals.update(virtuals)
+        for x in self._link_run:
+            reals, virtuals, _ = self.possible_graph.possible_dependencies(
+                x, allowed_deps=dt.BUILD, transitive=False, strict_depflag=True
+            )
+            self._possible_virtuals.update(virtuals)
+            self._direct_build.update(reals)
+
+        self._total_build, virtuals, _ = self.possible_graph.possible_dependencies(
+            *self._direct_build, allowed_deps=self.all_types
+        )
+        self._possible_virtuals.update(virtuals)
+        self._possible_dependencies = set(self._link_run) | set(self._total_build)
+
+    def possible_packages_facts(self, gen, fn):
+        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
+        gen.h2("Packages with at most a single node")
+        for package_name in sorted(self.possible_dependencies() - build_tools):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+
+        gen.h2("Packages with at multiple possible nodes (build-tools)")
+        for package_name in sorted(self.possible_dependencies() & build_tools):
+            gen.fact(fn.max_dupes(package_name, 2))
+            gen.fact(fn.multiple_unification_sets(package_name))
+        gen.newline()
+
+        gen.h2("Maximum number of nodes (virtual packages)")
+        for package_name in sorted(self.possible_virtuals()):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+
+        gen.h2("Possible package in link-run subDAG")
+        for name in sorted(self._link_run):
+            gen.fact(fn.possible_in_link_run(name))
+        gen.newline()
+
+
+class FullDuplicatesCounter(MinimalDuplicatesCounter):
+    def possible_packages_facts(self, gen, fn):
+        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
+        counter = collections.Counter(
+            list(self._link_run) + list(self._total_build) + list(self._direct_build)
+        )
+        gen.h2("Maximum number of nodes")
+        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
+            count = min(count, 2)
+            gen.fact(fn.max_dupes(pkg, count))
+        gen.newline()
+
+        gen.h2("Build unification sets ")
+        for name in sorted(self.possible_dependencies() & build_tools):
+            gen.fact(fn.multiple_unification_sets(name))
+        gen.newline()
+
+        gen.h2("Possible package in link-run subDAG")
+        for name in sorted(self._link_run):
+            gen.fact(fn.possible_in_link_run(name))
+        gen.newline()
+
+        counter = collections.Counter(
+            list(self._link_run_virtuals) + list(self._possible_virtuals)
+        )
+        gen.h2("Maximum number of virtual nodes")
+        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
+            gen.fact(fn.max_dupes(pkg, count))
+        gen.newline()
+
+
+def create_counter(
+    specs: List[spack.spec.Spec], tests: bool, possible_graph: PossibleDependencyGraph
+) -> Counter:
+    strategy = spack.config.CONFIG.get("concretizer:duplicates:strategy", "none")
+    if strategy == "full":
+        return FullDuplicatesCounter(specs, tests=tests, possible_graph=possible_graph)
+    if strategy == "minimal":
+        return MinimalDuplicatesCounter(specs, tests=tests, possible_graph=possible_graph)
+    return NoDuplicatesCounter(specs, tests=tests, possible_graph=possible_graph)

lib/spack/spack/spec.py

@@ -3342,7 +3342,7 @@ def intersects(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
                     # Here we might get an abstract spec
                     pkg_cls = spack.repo.PATH.get_pkg_class(non_virtual_spec.fullname)
                     pkg = pkg_cls(non_virtual_spec)
-                except spack.repo.UnknownEntityError:
+                except spack.error.UnknownEntityError:
                     # If we can't get package info on this spec, don't treat
                     # it as a provider of this vdep.
                     return False
@@ -3447,7 +3447,7 @@ def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
                     # Here we might get an abstract spec
                     pkg_cls = spack.repo.PATH.get_pkg_class(self.fullname)
                     pkg = pkg_cls(self)
-                except spack.repo.UnknownEntityError:
+                except spack.error.UnknownEntityError:
                     # If we can't get package info on this spec, don't treat
                     # it as a provider of this vdep.
                     return False

lib/spack/spack/test/cmd/dependencies.py

@@ -24,32 +24,24 @@
 mpi_deps = ["fake"]
 
 
-def test_direct_dependencies(mock_packages):
-    out = dependencies("mpileaks")
-    actual = set(re.split(r"\s+", out.strip()))
-    expected = set(["callpath"] + mpis)
-    assert expected == actual
-
-
-def test_transitive_dependencies(mock_packages):
-    out = dependencies("--transitive", "mpileaks")
-    actual = set(re.split(r"\s+", out.strip()))
-    expected = set(["callpath", "dyninst", "libdwarf", "libelf"] + mpis + mpi_deps)
-    assert expected == actual
-
-
-def test_transitive_dependencies_with_deptypes(mock_packages):
-    out = dependencies("--transitive", "--deptype=link,run", "dtbuild1")
-    deps = set(re.split(r"\s+", out.strip()))
-    assert set(["dtlink2", "dtrun2"]) == deps
-
-    out = dependencies("--transitive", "--deptype=build", "dtbuild1")
-    deps = set(re.split(r"\s+", out.strip()))
-    assert set(["dtbuild2", "dtlink2"]) == deps
-
-    out = dependencies("--transitive", "--deptype=link", "dtbuild1")
-    deps = set(re.split(r"\s+", out.strip()))
-    assert set(["dtlink2"]) == deps
+@pytest.mark.parametrize(
+    "cli_args,expected",
+    [
+        (["mpileaks"], set(["callpath"] + mpis)),
+        (
+            ["--transitive", "mpileaks"],
+            set(["callpath", "dyninst", "libdwarf", "libelf"] + mpis + mpi_deps),
+        ),
+        (["--transitive", "--deptype=link,run", "dtbuild1"], {"dtlink2", "dtrun2"}),
+        (["--transitive", "--deptype=build", "dtbuild1"], {"dtbuild2", "dtlink2"}),
+        (["--transitive", "--deptype=link", "dtbuild1"], {"dtlink2"}),
+    ],
+)
+def test_direct_dependencies(cli_args, expected, mock_runtimes):
+    out = dependencies(*cli_args)
+    result = set(re.split(r"\s+", out.strip()))
+    expected.update(mock_runtimes)
+    assert expected == result
 
 
 @pytest.mark.db

lib/spack/spack/test/concretization/requirements.py

@@ -1,7 +1,6 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import os
 import pathlib
 
 import pytest
@@ -200,11 +199,11 @@ def test_requirement_adds_version_satisfies(
 
 @pytest.mark.parametrize("require_checksum", (True, False))
 def test_requirement_adds_git_hash_version(
-    require_checksum, concretize_scope, test_repo, mock_git_version_info, monkeypatch, working_env
+    require_checksum, concretize_scope, test_repo, mock_git_version_info, monkeypatch
 ):
     # A full commit sha is a checksummed version, so this test should pass in both cases
     if require_checksum:
-        os.environ["SPACK_CONCRETIZER_REQUIRE_CHECKSUM"] = "yes"
+        monkeypatch.setenv("SPACK_CONCRETIZER_REQUIRE_CHECKSUM", "yes")
 
     repo_path, filename, commits = mock_git_version_info
     monkeypatch.setattr(

lib/spack/spack/test/conftest.py

@@ -2171,3 +2171,8 @@ def getcode(self):
 
     def info(self):
         return self.headers
+
+
+@pytest.fixture()
+def mock_runtimes(config, mock_packages):
+    return mock_packages.packages_with_tags("runtime")

lib/spack/spack/test/package_class.py

@@ -1,7 +1,6 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
 """Test class methods on Package objects.
 
 This doesn't include methods on package *instances* (like do_patch(),
@@ -16,6 +15,7 @@
 
 import llnl.util.filesystem as fs
 
+import spack.binary_distribution
 import spack.compilers
 import spack.concretize
 import spack.deptypes as dt
@@ -23,15 +23,11 @@
 import spack.install_test
 import spack.package
 import spack.package_base
-import spack.repo
 import spack.spec
+import spack.store
 from spack.build_systems.generic import Package
 from spack.error import InstallError
-
-
-@pytest.fixture(scope="module")
-def mpi_names(mock_repo_path):
-    return [spec.name for spec in mock_repo_path.providers_for("mpi")]
+from spack.solver.input_analysis import NoStaticAnalysis, StaticAnalysis
 
 
 @pytest.fixture()
@@ -53,78 +49,94 @@ def mpileaks_possible_deps(mock_packages, mpi_names):
     return possible
 
 
-def test_possible_dependencies(mock_packages, mpileaks_possible_deps):
-    pkg_cls = spack.repo.PATH.get_pkg_class("mpileaks")
-    expanded_possible_deps = pkg_cls.possible_dependencies(expand_virtuals=True)
-    assert mpileaks_possible_deps == expanded_possible_deps
-    assert {
-        "callpath": {"dyninst", "mpi"},
-        "dyninst": {"libdwarf", "libelf"},
-        "libdwarf": {"libelf"},
-        "libelf": set(),
-        "mpi": set(),
-        "mpileaks": {"callpath", "mpi"},
-    } == pkg_cls.possible_dependencies(expand_virtuals=False)
-
-
-def test_possible_direct_dependencies(mock_packages, mpileaks_possible_deps):
-    pkg_cls = spack.repo.PATH.get_pkg_class("mpileaks")
-    deps = pkg_cls.possible_dependencies(transitive=False, expand_virtuals=False)
-    assert {"callpath": set(), "mpi": set(), "mpileaks": {"callpath", "mpi"}} == deps
-
-
-def test_possible_dependencies_virtual(mock_packages, mpi_names):
-    expected = dict(
-        (name, set(dep for dep in spack.repo.PATH.get_pkg_class(name).dependencies_by_name()))
-        for name in mpi_names
-    )
-
-    # only one mock MPI has a dependency
-    expected["fake"] = set()
-
-    assert expected == spack.package_base.possible_dependencies("mpi", transitive=False)
-
-
-def test_possible_dependencies_missing(mock_packages):
-    pkg_cls = spack.repo.PATH.get_pkg_class("missing-dependency")
-    missing = {}
-    pkg_cls.possible_dependencies(transitive=True, missing=missing)
-    assert {"this-is-a-missing-dependency"} == missing["missing-dependency"]
-
-
-def test_possible_dependencies_with_deptypes(mock_packages):
-    dtbuild1 = spack.repo.PATH.get_pkg_class("dtbuild1")
-
-    assert {
-        "dtbuild1": {"dtrun2", "dtlink2"},
-        "dtlink2": set(),
-        "dtrun2": set(),
-    } == dtbuild1.possible_dependencies(depflag=dt.LINK | dt.RUN)
-
-    assert {
-        "dtbuild1": {"dtbuild2", "dtlink2"},
-        "dtbuild2": set(),
-        "dtlink2": set(),
-    } == dtbuild1.possible_dependencies(depflag=dt.BUILD)
-
-    assert {"dtbuild1": {"dtlink2"}, "dtlink2": set()} == dtbuild1.possible_dependencies(
-        depflag=dt.LINK
+@pytest.fixture(params=[NoStaticAnalysis, StaticAnalysis])
+def mock_inspector(config, mock_packages, request):
+    inspector_cls = request.param
+    if inspector_cls is NoStaticAnalysis:
+        return inspector_cls(configuration=config, repo=mock_packages)
+    return inspector_cls(
+        configuration=config,
+        repo=mock_packages,
+        store=spack.store.STORE,
+        binary_index=spack.binary_distribution.BINARY_INDEX,
     )
 
 
-def test_possible_dependencies_with_multiple_classes(mock_packages, mpileaks_possible_deps):
+@pytest.fixture
+def mpi_names(mock_inspector):
+    return [spec.name for spec in mock_inspector.providers_for("mpi")]
+
+
+@pytest.mark.parametrize(
+    "pkg_name,fn_kwargs,expected",
+    [
+        (
+            "mpileaks",
+            {"expand_virtuals": True, "allowed_deps": dt.ALL},
+            {
+                "fake",
+                "mpileaks",
+                "multi-provider-mpi",
+                "callpath",
+                "dyninst",
+                "mpich2",
+                "libdwarf",
+                "zmpi",
+                "low-priority-provider",
+                "intel-parallel-studio",
+                "mpich",
+                "libelf",
+            },
+        ),
+        (
+            "mpileaks",
+            {"expand_virtuals": False, "allowed_deps": dt.ALL},
+            {"callpath", "dyninst", "libdwarf", "libelf", "mpileaks"},
+        ),
+        (
+            "mpileaks",
+            {"expand_virtuals": False, "allowed_deps": dt.ALL, "transitive": False},
+            {"callpath", "mpileaks"},
+        ),
+        ("dtbuild1", {"allowed_deps": dt.LINK | dt.RUN}, {"dtbuild1", "dtrun2", "dtlink2"}),
+        ("dtbuild1", {"allowed_deps": dt.BUILD}, {"dtbuild1", "dtbuild2", "dtlink2"}),
+        ("dtbuild1", {"allowed_deps": dt.LINK}, {"dtbuild1", "dtlink2"}),
+    ],
+)
+def test_possible_dependencies(pkg_name, fn_kwargs, expected, mock_runtimes, mock_inspector):
+    """Tests possible nodes of mpileaks, under different scenarios."""
+    expected.update(mock_runtimes)
+    result, *_ = mock_inspector.possible_dependencies(pkg_name, **fn_kwargs)
+    assert expected == result
+
+
+def test_possible_dependencies_virtual(mock_inspector, mock_packages, mock_runtimes, mpi_names):
+    expected = set(mpi_names)
+    for name in mpi_names:
+        expected.update(dep for dep in mock_packages.get_pkg_class(name).dependencies_by_name())
+    expected.update(mock_runtimes)
+
+    real_pkgs, *_ = mock_inspector.possible_dependencies(
+        "mpi", transitive=False, allowed_deps=dt.ALL
+    )
+    assert expected == real_pkgs
+
+
+def test_possible_dependencies_missing(mock_inspector):
+    result, *_ = mock_inspector.possible_dependencies("missing-dependency", allowed_deps=dt.ALL)
+    assert "this-is-a-missing-dependency" not in result
+
+
+def test_possible_dependencies_with_multiple_classes(
+    mock_inspector, mock_packages, mpileaks_possible_deps
+):
     pkgs = ["dt-diamond", "mpileaks"]
-    expected = mpileaks_possible_deps.copy()
-    expected.update(
-        {
-            "dt-diamond": set(["dt-diamond-left", "dt-diamond-right"]),
-            "dt-diamond-left": set(["dt-diamond-bottom"]),
-            "dt-diamond-right": set(["dt-diamond-bottom"]),
-            "dt-diamond-bottom": set(),
-        }
-    )
+    expected = set(mpileaks_possible_deps)
+    expected.update({"dt-diamond", "dt-diamond-left", "dt-diamond-right", "dt-diamond-bottom"})
+    expected.update(mock_packages.packages_with_tags("runtime"))
 
-    assert expected == spack.package_base.possible_dependencies(*pkgs)
+    real_pkgs, *_ = mock_inspector.possible_dependencies(*pkgs, allowed_deps=dt.ALL)
+    assert set(expected) == real_pkgs
 
 
 def setup_install_test(source_paths, test_root):

lib/spack/spack/test/util/elf.py

@@ -201,3 +201,15 @@ def test_drop_redundant_rpath(tmpdir, binary_with_rpaths):
     new_rpaths = elf.get_rpaths(binary)
     assert set(existing_dirs).issubset(new_rpaths)
     assert set(non_existing_dirs).isdisjoint(new_rpaths)
+
+
+def test_elf_invalid_e_shnum(tmp_path):
+    # from llvm/test/Object/Inputs/invalid-e_shnum.elf
+    path = tmp_path / "invalid-e_shnum.elf"
+    with open(path, "wb") as file:
+        file.write(
+            b"\x7fELF\x02\x010000000000\x03\x00>\x0000000000000000000000"
+            b"\x00\x00\x00\x00\x00\x00\x00\x000000000000@\x000000"
+        )
+    with open(path, "rb") as file, pytest.raises(elf.ElfParsingError):
+        elf.parse_elf(file)

lib/spack/spack/util/elf.py

@@ -195,7 +195,10 @@ def parse_program_headers(f: BinaryIO, elf: ElfFile) -> None:
         elf: ELF file parser data
     """
     # Forward to the program header
-    f.seek(elf.elf_hdr.e_phoff)
+    try:
+        f.seek(elf.elf_hdr.e_phoff)
+    except OSError:
+        raise ElfParsingError("Could not seek to program header")
 
     # Here we have to make a mapping from virtual address to offset in the file.
     ph_fmt = elf.byte_order + ("LLQQQQQQ" if elf.is_64_bit else "LLLLLLLL")
@@ -245,7 +248,10 @@ def parse_pt_interp(f: BinaryIO, elf: ElfFile) -> None:
         f: file handle
         elf: ELF file parser data
     """
-    f.seek(elf.pt_interp_p_offset)
+    try:
+        f.seek(elf.pt_interp_p_offset)
+    except OSError:
+        raise ElfParsingError("Could not seek to PT_INTERP entry")
     data = read_exactly(f, elf.pt_interp_p_filesz, "Malformed PT_INTERP entry")
     elf.pt_interp_str = parse_c_string(data)
 
@@ -264,7 +270,10 @@ def find_strtab_size_at_offset(f: BinaryIO, elf: ElfFile, offset: int) -> int:
     """
     section_hdr_fmt = elf.byte_order + ("LLQQQQLLQQ" if elf.is_64_bit else "LLLLLLLLLL")
     section_hdr_size = calcsize(section_hdr_fmt)
-    f.seek(elf.elf_hdr.e_shoff)
+    try:
+        f.seek(elf.elf_hdr.e_shoff)
+    except OSError:
+        raise ElfParsingError("Could not seek to section header table")
     for _ in range(elf.elf_hdr.e_shnum):
         data = read_exactly(f, section_hdr_size, "Malformed section header")
         sh = SectionHeader(*unpack(section_hdr_fmt, data))
@@ -286,7 +295,10 @@ def retrieve_strtab(f: BinaryIO, elf: ElfFile, offset: int) -> bytes:
     Returns: file offset
     """
     size = find_strtab_size_at_offset(f, elf, offset)
-    f.seek(offset)
+    try:
+        f.seek(offset)
+    except OSError:
+        raise ElfParsingError("Could not seek to string table")
     return read_exactly(f, size, "Could not read string table")
 
 
@@ -319,7 +331,10 @@ def parse_pt_dynamic(f: BinaryIO, elf: ElfFile) -> None:
     count_runpath = 0
     count_strtab = 0
 
-    f.seek(elf.pt_dynamic_p_offset)
+    try:
+        f.seek(elf.pt_dynamic_p_offset)
+    except OSError:
+        raise ElfParsingError("Could not seek to PT_DYNAMIC entry")
 
     # In case of broken ELF files, don't read beyond the advertized size.
     for _ in range(elf.pt_dynamic_p_filesz // dynamic_array_size):
@@ -478,7 +493,10 @@ def get_interpreter(path: str) -> Optional[str]:
 def _delete_dynamic_array_entry(
     f: BinaryIO, elf: ElfFile, should_delete: Callable[[int, int], bool]
 ) -> None:
-    f.seek(elf.pt_dynamic_p_offset)
+    try:
+        f.seek(elf.pt_dynamic_p_offset)
+    except OSError:
+        raise ElfParsingError("Could not seek to PT_DYNAMIC entry")
     dynamic_array_fmt = elf.byte_order + ("qQ" if elf.is_64_bit else "lL")
     dynamic_array_size = calcsize(dynamic_array_fmt)
     new_offset = elf.pt_dynamic_p_offset  # points to the new dynamic array

lib/spack/spack/version/git_ref_lookup.py

@@ -10,6 +10,7 @@
 from llnl.util.filesystem import mkdirp, working_dir
 
 import spack.caches
+import spack.error
 import spack.fetch_strategy
 import spack.paths
 import spack.repo
@@ -78,7 +79,7 @@ def pkg(self):
             try:
                 pkg = spack.repo.PATH.get_pkg_class(self.pkg_name)
                 pkg.git
-            except (spack.repo.RepoError, AttributeError) as e:
+            except (spack.error.RepoError, AttributeError) as e:
                 raise VersionLookupError(f"Couldn't get the git repo for {self.pkg_name}") from e
             self._pkg = pkg
         return self._pkg

share/spack/gitlab/cloud_pipelines/stacks/developer-tools-x86_64_v3-linux-gnu/spack.yaml

@@ -2,10 +2,16 @@ spack:
   view: false
   packages:
     all:
-      require: target=x86_64_v3
+      require:
+      - target=x86_64_v3
+      - ~cuda
+      - ~rocm
+
   concretizer:
     unify: true
     reuse: false
+    static_analysis: true
+
   definitions:
   - default_specs:
       # editors

share/spack/gitlab/cloud_pipelines/stacks/e4s/spack.yaml

@@ -4,16 +4,32 @@ spack:
   concretizer:
     reuse: false
     unify: false
+    static_analysis: true
 
   packages:
     all:
-      require: '%gcc target=x86_64_v3'
-      providers:
-        blas: [openblas]
-        mpi: [mpich]
+      require:
+      - '%gcc target=x86_64_v3'
       variants: +mpi
+    mpi:
+      require:
+      - mpich
+    blas:
+      require:
+      - openblas
+    lapack:
+      require:
+      - openblas
     binutils:
       variants: +ld +gold +headers +libiberty ~nls
+    cmake:
+      require:
+      - "~qtgui"
+      - '%gcc target=x86_64_v3'
+    gmake:
+      require:
+      - "~guile"
+      - '%gcc target=x86_64_v3'
     hdf5:
       variants: +fortran +hl +shared
     libfabric:
@@ -27,19 +43,25 @@ spack:
         +ifpack +ifpack2 +intrepid +intrepid2 +isorropia +kokkos +ml +minitensor +muelu
         +nox +piro +phalanx +rol +rythmos +sacado +stk +shards +shylu +stokhos +stratimikos
         +teko +tempus +tpetra +trilinoscouplings +zoltan +zoltan2 +superlu-dist gotype=long_long
-    mpi:
-      require: mpich
     mpich:
-      require: '~wrapperrpath ~hwloc target=x86_64_v3'
+      require:
+      - '~wrapperrpath ~hwloc'
+      - '%gcc target=x86_64_v3'
     tbb:
-      require: intel-tbb
+      require:
+      - intel-tbb
     vtk-m:
-      require: "+examples target=x86_64_v3"
+      require:
+      - "+examples"
+      - '%gcc target=x86_64_v3'
     visit:
-      require: "~gui target=x86_64_v3"
+      require:
+      - "~gui target=x86_64_v3"
     paraview:
       # Don't build GUI support or GLX rendering for HPC/container deployments
-      require: "+examples ~qt ^[virtuals=gl] osmesa target=x86_64_v3"
+      require:
+      - "+examples ~qt ^[virtuals=gl] osmesa target=x86_64_v3"
+      - '%gcc target=x86_64_v3'
 
   specs:
   # CPU

share/spack/qa/run-unit-tests

@@ -36,7 +36,7 @@ bin/spack -h
 bin/spack help -a
 
 # Profile and print top 20 lines for a simple call to spack spec
-spack -p --lines 20 spec mpileaks%gcc ^dyninst@10.0.0 ^elfutils@0.170
+spack -p --lines 20 spec mpileaks%gcc
 $coverage_run $(which spack) bootstrap status --dev --optional
 
 # Check that we can import Spack packages directly as a first import

var/spack/repos/builtin/packages/amdsmi/package.py

@@ -19,6 +19,7 @@ class Amdsmi(CMakePackage):
     libraries = ["libamd_smi"]
 
     license("MIT")
+    version("6.3.2", sha256="1ed452eedfe51ac6e615d7bfe0bd7a0614f21113874ae3cbea7df72343cc2d13")
     version("6.3.1", sha256="a3a5a711052e813b9be9304d5e818351d3797f668ec2a455e61253a73429c355")
     version("6.3.0", sha256="7234c46648938239385cd5db57516ed53985b8c09d2f0828ae8f446386d8bd1e")
     version("6.2.4", sha256="5ebe8d0f176bf4a73b0e7000d9c47cb7f65ecca47011d3f9b08b93047dcf7ac5")

var/spack/repos/builtin/packages/aqlprofile/package.py

@@ -8,6 +8,20 @@
 from spack.package import *
 
 _versions = {
+    "6.3.2": {
+        "apt": (
+            "bef302bf344c9297f9fb64a4a93f360721a467185bc4fefbeecb307dd956c504",
+            "https://repo.radeon.com/rocm/apt/6.3.2/pool/main/h/hsa-amd-aqlprofile/hsa-amd-aqlprofile_1.0.0.60302-66~20.04_amd64.deb",
+        ),
+        "yum": (
+            "1e01de060073cb72a97fcddf0f3b637b48cf89a08b34f2447d010031abc0e099",
+            "https://repo.radeon.com/rocm/rhel8/6.3.2/main/hsa-amd-aqlprofile-1.0.0.60302-66.el8.x86_64.rpm",
+        ),
+        "zyp": (
+            "408fb29e09ba59a9e83e8f7d703ba53e1ef3b3acbae1103b2a82d4f87f321752",
+            "https://repo.radeon.com/rocm/zyp/6.3.2/main/hsa-amd-aqlprofile-1.0.0.60302-sles155.66.x86_64.rpm",
+        ),
+    },
     "6.3.1": {
         "apt": (
             "76b129345a1a7caa04859fd738e0ba5bfa6f7bc1ad11171f1a7b2d46e0c0b158",
@@ -275,6 +289,7 @@ class Aqlprofile(Package):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hsa-rocr-dev@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/ascent/package.py

@@ -148,6 +148,14 @@ class Ascent(CMakePackage, CudaPackage):
     # https://github.com/Alpine-DAV/ascent/pull/1123
     patch("ascent-find-raja-pr1123.patch", when="@0.9.0")
 
+    # patch for fix typo in coord_type
+    # https://github.com/Alpine-DAV/ascent/pull/1408
+    patch(
+        "https://github.com/Alpine-DAV/ascent/pull/1408.patch?full_index=1",
+        when="@0.9.3 %oneapi@2025:",
+        sha256="7de7f51e57f3d743c39ad80d8783a4eb482be1def51eb2d3f9259246c661f164",
+    )
+
     ##########################################################################
     # package dependencies
     ###########################################################################
@@ -468,6 +476,9 @@ def hostconfig(self):
         if cflags:
             cfg.write(cmake_cache_entry("CMAKE_C_FLAGS", cflags))
         cxxflags = cppflags + " ".join(spec.compiler_flags["cxxflags"])
+        if spec.satisfies("%oneapi@2025:"):
+            cxxflags += "-Wno-error=missing-template-arg-list-after-template-kw "
+            cxxflags += "-Wno-missing-template-arg-list-after-template-kw"
         if cxxflags:
             cfg.write(cmake_cache_entry("CMAKE_CXX_FLAGS", cxxflags))
         fflags = " ".join(spec.compiler_flags["fflags"])

var/spack/repos/builtin/packages/cbtf-krell/package.py

@@ -4,7 +4,6 @@
 
 import spack.store
 from spack.package import *
-from spack.pkg.builtin.boost import Boost
 
 
 class CbtfKrell(CMakePackage):
@@ -51,9 +50,17 @@ class CbtfKrell(CMakePackage):
         description="build only the FE tool using the runtime_dir to point to target build.",
     )
 
+    # Fix build errors with gcc >= 10
+    patch(
+        "https://github.com/OpenSpeedShop/cbtf-krell/commit/7d47761c6cd9110883bff9ca1e694af1475676f5.patch?full_index=1",
+        sha256="64ed80d18163ca04a67be4a13ac2d2553243fc24c6274d26981472e6e2050b8a",
+    )
+
     # Dependencies for cbtf-krell
     depends_on("cmake@3.0.2:", type="build")
 
+    depends_on("gotcha")
+
     # For rpcgen
     depends_on("rpcsvc-proto", type="build")
 
@@ -64,16 +71,11 @@ class CbtfKrell(CMakePackage):
     depends_on("binutils@2.32")
 
     # For boost
-    depends_on("boost@1.70.0:")
-
-    # TODO: replace this with an explicit list of components of Boost,
-    # for instance depends_on('boost +filesystem')
-    # See https://github.com/spack/spack/pull/22303 for reference
-    depends_on(Boost.with_default_variants)
+    depends_on("boost@1.70.0:+filesystem+graph+program_options+python+test+thread")
 
     # For Dyninst
-    depends_on("dyninst@10.1.0", when="@develop")
-    depends_on("dyninst@10.1.0", when="@1.9.3:9999")
+    depends_on("dyninst@10.1.0:", when="@develop")
+    depends_on("dyninst@10.1.0:", when="@1.9.3:9999")
 
     # For MRNet
     depends_on("mrnet@5.0.1-3:+lwthreads", when="@develop", type=("build", "link", "run"))

var/spack/repos/builtin/packages/clingo-bootstrap/package.py

@@ -92,9 +92,9 @@ def pgo_train(self):
 
         # Set PGO training flags.
         generate_mods = EnvironmentModifications()
-        generate_mods.append_flags("CFLAGS", "-fprofile-generate={}".format(reports))
-        generate_mods.append_flags("CXXFLAGS", "-fprofile-generate={}".format(reports))
-        generate_mods.append_flags("LDFLAGS", "-fprofile-generate={} --verbose".format(reports))
+        generate_mods.append_flags("CFLAGS", f"-fprofile-generate={reports}")
+        generate_mods.append_flags("CXXFLAGS", f"-fprofile-generate={reports}")
+        generate_mods.append_flags("LDFLAGS", f"-fprofile-generate={reports}")
 
         with working_dir(self.build_directory, create=True):
             cmake(*cmake_options, sources, extra_env=generate_mods)
@@ -118,14 +118,14 @@ def pgo_train(self):
         # Clean the build dir.
         rmtree(self.build_directory, ignore_errors=True)
 
-        if self.spec.satisfies("%clang") or self.spec.satisfies("apple-clang"):
+        if self.spec.satisfies("%clang") or self.spec.satisfies("%apple-clang"):
             # merge reports
             use_report = join_path(reports, "merged.prof")
             raw_files = glob.glob(join_path(reports, "*.profraw"))
-            llvm_profdata("merge", "--output={}".format(use_report), *raw_files)
-            use_flag = "-fprofile-instr-use={}".format(use_report)
+            llvm_profdata("merge", f"--output={use_report}", *raw_files)
+            use_flag = f"-fprofile-instr-use={use_report}"
         else:
-            use_flag = "-fprofile-use={}".format(reports)
+            use_flag = f"-fprofile-use={reports}"
 
         # Set PGO use flags for next cmake phase.
         use_mods = EnvironmentModifications()

var/spack/repos/builtin/packages/comgr/package.py

@@ -29,6 +29,7 @@ def url_for_version(self, version):
     license("NCSA")
 
     version("master", branch="amd-stg-open")
+    version("6.3.2", sha256="1f52e45660ea508d3fe717a9903fe27020cee96de95a3541434838e0193a4827")
     version("6.3.1", sha256="e9c2481cccacdea72c1f8d3970956c447cec47e18dfb9712cbbba76a2820552c")
     version("6.3.0", sha256="79580508b039ca6c50dfdfd7c4f6fbcf489fe1931037ca51324818851eea0c1c")
     version("6.2.4", sha256="7af782bf5835fcd0928047dbf558f5000e7f0207ca39cf04570969343e789528")
@@ -88,6 +89,7 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         # llvm libs are linked statically, so this *could* be a build dep
@@ -115,6 +117,7 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/composable-kernel/package.py

@@ -18,6 +18,7 @@ class ComposableKernel(CMakePackage):
     license("MIT")
 
     version("master", branch="develop")
+    version("6.3.2", sha256="875237fe493ff040f8f63b827cddf2ff30a8d3aa18864f87d0e35323c7d62a2d")
     version("6.3.1", sha256="3e8c8c832ca3f9ceb99ab90f654b93b7db876f08d90eda87a70bc629c854052a")
     version("6.3.0", sha256="274f87fc27ec2584c76b5bc7ebdbe172923166b6b93e66a24f98475b44be272d")
     version("6.2.4", sha256="5598aea4bce57dc95b60f2029831edfdade80b30a56e635412cc02b2a6729aa6")
@@ -60,6 +61,7 @@ class ComposableKernel(CMakePackage):
 
     for ver in [
         "master",
+        "6.3.2",
         "6.3.1",
         "6.3.0",
         "6.2.4",

var/spack/repos/builtin/packages/detray/package.py

@@ -19,6 +19,7 @@ class Detray(CMakePackage):
 
     license("MPL-2.0", checked_by="stephenswat")
 
+    version("0.88.0", sha256="bda15501c9c96af961e24ce243982f62051c535b9fe458fb28336a19b54eb47d")
     version("0.87.0", sha256="2d4a76432dd6ddbfc00b88b5d482072e471fefc264b60748bb1f9a123963576e")
     version("0.86.0", sha256="98350c94e8a2395b8712b7102fd449536857e8158b38a96cc913c79b70301170")
     version("0.85.0", sha256="a0121a27fd08243d4a6aab060e8ab379ad5129e96775b45f6a683835767fa8e7")

var/spack/repos/builtin/packages/duckdb/package.py

@@ -17,6 +17,7 @@ class Duckdb(MakefilePackage):
     maintainers("glentner", "teaguesterling")
 
     version("master", branch="master")
+    version("1.2.0", sha256="f22c97e18c071fa8e43b5e150c03c6ab4bcc510cca6e6b50cbe13af8535fa701")
     version("1.1.3", sha256="2aea0af898ad753fee82b776fea1bf78ccbc9648986e7f7a87372df5e74cdb98")
     version("1.1.2", sha256="a3319a64c390ed0454c869b2e4fc0af2413cd49f55cd0f1400aaed9069cdbc4c")
     version("1.1.1", sha256="a764cef80287ccfd8555884d8facbe962154e7c747043c0842cd07873b4d6752")
@@ -92,7 +93,6 @@ class Duckdb(MakefilePackage):
     # Extensions
     variant("autocomplete", default=True, description="Include autocomplete for CLI in build")
     variant("excel", default=True, description="Include Excel formatting extension in build")
-    variant("fts", default=True, description="Include FTS (full text search) support in build")
     variant("httpfs", default=True, description="Include HTTPFS (& S3) support in build")
     variant("inet", default=True, description="Include INET (ip address) support in build")
     variant("json", default=True, description="Include JSON support in build")
@@ -100,6 +100,14 @@ class Duckdb(MakefilePackage):
     variant("tpce", default=False, description="Include TPCE in build")
     variant("tpch", default=False, description="Include TPCH in build")
 
+    # FTS was moved to an out-of-tree extension after v1.1.3
+    variant(
+        "fts",
+        default=True,
+        description="Include FTS (full text search) support in build",
+        when="@:1.1",
+    )
+
     # APIs
     variant("python", default=True, description="Build with Python driver")
     extends("python", when="+python")

var/spack/repos/builtin/packages/extrae/package.py

@@ -73,10 +73,6 @@ class Extrae(AutotoolsPackage):
     depends_on("mpi")
     depends_on("libunwind")
 
-    # TODO: replace this with an explicit list of components of Boost,
-    # for instance depends_on('boost +filesystem')
-    # See https://github.com/spack/spack/pull/22303 for reference
-    depends_on(Boost.with_default_variants)
     depends_on("libdwarf")
     depends_on("elf", type="link")
     depends_on("libxml2")
@@ -92,6 +88,10 @@ class Extrae(AutotoolsPackage):
     variant("dyninst", default=False, description="Use dyninst for dynamic code installation")
     with when("+dyninst"):
         depends_on("dyninst@10.1.0:")
+        # TODO: replace this with an explicit list of components of Boost,
+        # for instance depends_on('boost +filesystem')
+        # See https://github.com/spack/spack/pull/22303 for reference
+        depends_on(Boost.with_default_variants)
         depends_on("elfutils", when="@4.1.2:")
         depends_on("intel-oneapi-tbb", when="@4.1.2:")
 
@@ -127,7 +127,6 @@ def configure_args(self):
         args = [
             "--with-mpi=%s" % mpiroot,
             "--with-unwind=%s" % spec["libunwind"].prefix,
-            "--with-boost=%s" % spec["boost"].prefix,
             "--with-dwarf=%s" % spec["libdwarf"].prefix,
             "--with-elf=%s" % spec["elf"].prefix,
             "--with-xml-prefix=%s" % spec["libxml2"].prefix,
@@ -141,7 +140,10 @@ def configure_args(self):
         )
 
         if spec.satisfies("+dyninst"):
-            args += ["--with-dyninst={spec['dyninst'].prefix}"]
+            args += [
+                f"--with-dyninst={spec['dyninst'].prefix}",
+                f"--with-boost={spec['boost'].prefix}",
+            ]
 
             if spec.satisfies("@4.1.2:"):
                 args += [

var/spack/repos/builtin/packages/fargparse/package.py

@@ -19,6 +19,7 @@ class Fargparse(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
+    version("1.9.0", sha256="c83c13fa90b6b45adf8d84fe00571174acfa118d2a0d1e8c467f74bbd7dec49d")
     version("1.8.0", sha256="37108bd3c65d892d8c24611ce4d8e5451767e4afe81445fde67eab652178dd01")
     version("1.7.0", sha256="9889e7eca9c020b742787fba2be0ba16edcc3fcf52929261ccb7d09996a35f89")
     version("1.6.0", sha256="055a0af44f50c302f8f20a8bcf3d26c5bbeacf5222cdbaa5b19da4cff56eb9c0")

var/spack/repos/builtin/packages/flux-sched/package.py

@@ -22,6 +22,7 @@ class FluxSched(CMakePackage, AutotoolsPackage):
     license("LGPL-3.0-only")
 
     version("master", branch="master")
+    version("0.42.1", sha256="ab56b257e4918ad7e26ef6a375d0ea500a4929bf6633937f0c11c06e21db56b9")
     version("0.41.0", sha256="c89baf72867031847748c157aa99f3b36755f2801df917aae66010d2112e10fe")
     version("0.40.0", sha256="1484befcf8628b0af7833bf550d0bb3864db32b70f2c1bb363c35e30ada1ecc5")
     version("0.39.0", sha256="7e87029f8ad17b9286096e4e2d44982b5d6634908aefde3282497bdd3f44f2f8")

var/spack/repos/builtin/packages/geomodel/package.py

@@ -17,6 +17,7 @@ class Geomodel(CMakePackage):
 
     license("Apache-2.0", checked_by="wdconinc")
 
+    version("6.9.0", sha256="ea34dad8a0cd392e06794b8a1b7407dd6ad617fefd19fb4cccdf36b154749793")
     version("6.8.0", sha256="4dfd5a932955ee2618a880bb210aed9ce7087cfadd31f23f92e5ff009c8384eb")
     version("6.7.0", sha256="bfa69062ba191d0844d7099b28c0d6c3c0f87e726dacfaa21dba7a6f593d34bf")
     version("6.6.0", sha256="3cefeaa409177d45d3fa63e069b6496ca062991b0d7d71275b1748487659e91b")

var/spack/repos/builtin/packages/gftl-shared/package.py

@@ -24,6 +24,7 @@ class GftlShared(CMakePackage):
 
     version("main", branch="main")
 
+    version("1.10.0", sha256="42158fe75fa6bee336516c7531b4c6c4e7252dee2fed541eec740209a07ceafe")
     version("1.9.0", sha256="a3291ce61b512fe88628cc074b02363c2ba3081e7b453371089121988482dd6f")
     version("1.8.0", sha256="3450161508c573ea053b2a23cdbf2a1d6fd6fdb78c162d31fc0019da0f8dd03c")
     version("1.7.0", sha256="8ba567133fcee6b93bc71f61b3bb2053b4b07c6d78f6ad98a04dfc40aa478de7")

var/spack/repos/builtin/packages/gftl/package.py

@@ -38,6 +38,7 @@ class Gftl(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
+    version("1.15.1", sha256="13b9e17b7ec5e9ba19d0ee3ad1957bfa2015055b654891c6bb0bbe68b7a040d7")
     version("1.14.0", sha256="bf8e3ba3f708ea327c7eb1a5bd1afdce41358c6df1a323aba0f73575c25d5fc8")
     version("1.13.0", sha256="d8ef4bca5fb67e63dcd69e5377a0cef8336b00178a97450e79010552000d0a52")
     version("1.12.0", sha256="b50e17cb2109372819b3ee676e6e61fd3a517dc4c1ea293937c8a83f03b0cbd6")

var/spack/repos/builtin/packages/go/package.py

@@ -38,6 +38,8 @@ class Go(Package):
 
     license("BSD-3-Clause")
 
+    version("1.23.6", sha256="039c5b04e65279daceee8a6f71e70bd05cf5b801782b6f77c6e19e2ed0511222")
+    version("1.23.5", sha256="a6f3f4bbd3e6bdd626f79b668f212fbb5649daf75084fb79b678a0ae4d97423b")
     version("1.23.4", sha256="ad345ac421e90814293a9699cca19dd5238251c3f687980bbcae28495b263531")
     version("1.23.3", sha256="8d6a77332487557c6afa2421131b50f83db4ae3c579c3bc72e670ee1f6968599")
     version("1.23.2", sha256="36930162a93df417d90bd22c6e14daff4705baac2b02418edda671cdfa9cd07f")

var/spack/repos/builtin/packages/hip-tensor/package.py

@@ -16,6 +16,7 @@ class HipTensor(CMakePackage, ROCmPackage):
     maintainers("srekolam", "afzpatel")
 
     version("master", branch="master")
+    version("6.3.2", sha256="094db6d759eb32e9d15c36fce7f5b5d46ba81416953a8d9435b2fb9c161d8c83")
     version("6.3.1", sha256="142401331526e6da3fa172cce283f1c053056cb59cf431264443da76cee2f168")
     version("6.3.0", sha256="9a4acef722e838ec702c6b111ebc1fff9d5686ae5c79a9f5a82e5fac2a5e406a")
     version("6.2.4", sha256="54c378b440ede7a07c93b5ed8d16989cc56283a56ea35e41f3666bb05b6bc984")
@@ -45,12 +46,13 @@ class HipTensor(CMakePackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"composable-kernel@{ver}", when=f"@{ver}")
         depends_on(f"rocm-cmake@{ver}", when=f"@{ver}")
 
-    for ver in ["6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"hipcc@{ver}", when=f"@{ver}")
 
     def setup_build_environment(self, env):

var/spack/repos/builtin/packages/hip/package.py

@@ -25,6 +25,7 @@ class Hip(CMakePackage):
     license("MIT")
 
     version("master", branch="master")
+    version("6.3.2", sha256="2832e21d75369f87beee767949177a93ac113710afae6b73da5548c0047962ec")
     version("6.3.1", sha256="ebde9fa80ad1f4ba3fbe04fd36d90548492ebe5828ac459995b5f9d384a29783")
     version("6.3.0", sha256="d8dba8cdf05463afb7879de2833983cafa6a006ba719815a35b96d9b92fc7fc4")
     version("6.2.4", sha256="76e4583ae3d31786270fd92abbb2e3dc5e665b22fdedb5ceff0093131d4dc0ca")
@@ -117,6 +118,7 @@ class Hip(CMakePackage):
             "6.2.4",
             "6.3.0",
             "6.3.1",
+            "6.3.2",
         ]:
             depends_on(f"hsa-rocr-dev@{ver}", when=f"@{ver}")
             depends_on(f"comgr@{ver}", when=f"@{ver}")
@@ -143,6 +145,7 @@ class Hip(CMakePackage):
             "6.2.4",
             "6.3.0",
             "6.3.1",
+            "6.3.2",
         ]:
             depends_on(f"hipify-clang@{ver}", when=f"@{ver}")
 
@@ -163,6 +166,7 @@ class Hip(CMakePackage):
             "6.2.4",
             "6.3.0",
             "6.3.1",
+            "6.3.2",
         ]:
             depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 
@@ -180,10 +184,11 @@ class Hip(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hipcc@{ver}", when=f"@{ver}")
 
-    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"rocprofiler-register@{ver}", when=f"@{ver}")
 
     # roc-obj-ls requirements
@@ -245,6 +250,7 @@ class Hip(CMakePackage):
         )
     # Add hip-clr sources thru the below
     for d_version, d_shasum in [
+        ("6.3.2", "ec13dc4ffe212beee22171cb2825d2b16cdce103c835adddb482b9238cf4f050"),
         ("6.3.1", "bfb8a4a59e7bd958e2cd4bf6f14c6cdea601d9827ebf6dc7af053a90e963770f"),
         ("6.3.0", "829e61a5c54d0c8325d02b0191c0c8254b5740e63b8bfdb05eec9e03d48f7d2c"),
         ("6.2.4", "0a3164af7f997a4111ade634152957378861b95ee72d7060eb01c86c87208c54"),
@@ -303,6 +309,7 @@ class Hip(CMakePackage):
         )
     # Add hipother sources thru the below
     for d_version, d_shasum in [
+        ("6.3.2", "1623d823de49471aae3ecb1fad0e9cdddf9301a4089f1fd44f78ac2ff0c20fb2"),
         ("6.3.1", "caa69147227bf72fa7b076867f84579456ef55af63efec29914265a80602df42"),
         ("6.3.0", "a28eb1e8fe239b41e744584d45d676925ca210968ecb21bfa60678cf8e86eeb7"),
         ("6.2.4", "b7ebcf8a2679e50d27c49ebec0dbea5a67573f8b8c3f4a29108c84b28b5bedee"),

var/spack/repos/builtin/packages/hipblas-common/package.py

@@ -15,5 +15,6 @@ class HipblasCommon(CMakePackage):
 
     license("MIT")
 
+    version("6.3.2", sha256="29aa1ac1a0f684a09fe2ea8a34ae8af3622c27708c7df403a7481e75174e1984")
     version("6.3.1", sha256="512e652483b5580713eca14db3fa633d0441cd7c02cdb0d26e631ea605b9231b")
     version("6.3.0", sha256="240bb1b0f2e6632447e34deae967df259af1eec085470e58a6d0aa040c8530b0")

var/spack/repos/builtin/packages/hipblas/package.py

@@ -24,6 +24,7 @@ class Hipblas(CMakePackage, CudaPackage, ROCmPackage):
 
     version("develop", branch="develop")
     version("master", branch="master")
+    version("6.3.2", sha256="6e86d4f8657e13665e37fdf3174c3a30f4c7dff2c4e2431d1be110cd7d463971")
     version("6.3.1", sha256="77a1845254d738c43a48bc52fa3e94499ed83535b5771408ff476122bc4b7b7c")
     version("6.3.0", sha256="72604c1896e42e65ea2b3e905159af6ec5eede6a353678009c47d0a24f462c92")
     version("6.2.4", sha256="3137ba35e0663d6cceed70086fc6397d9e74803e1711382be62809b91beb2f32")
@@ -92,6 +93,7 @@ class Hipblas(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-cmake@{ver}", when=f"+rocm @{ver}")
         depends_on(f"rocm-openmp-extras@{ver}", type="test", when=f"+rocm @{ver}")
@@ -119,6 +121,7 @@ class Hipblas(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
         "develop",
     ]:
@@ -127,7 +130,7 @@ class Hipblas(CMakePackage, CudaPackage, ROCmPackage):
     for tgt in ROCmPackage.amdgpu_targets:
         depends_on(f"rocblas amdgpu_target={tgt}", when=f"+rocm amdgpu_target={tgt}")
         depends_on(f"rocsolver amdgpu_target={tgt}", when=f"+rocm amdgpu_target={tgt}")
-    for ver in ["6.3.0", "6.3.1"]:
+    for ver in ["6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"hipblas-common@{ver}", when=f"@{ver}")
 
     @classmethod
@@ -155,7 +158,7 @@ def cmake_args(self):
         # FindHIP.cmake is still used for +cuda
         if self.spec.satisfies("+cuda"):
             args.append(self.define("CMAKE_MODULE_PATH", self.spec["hip"].prefix.lib.cmake.hip))
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
         if self.spec.satisfies("@5.3.0:"):
             args.append("-DCMAKE_INSTALL_LIBDIR=lib")

var/spack/repos/builtin/packages/hipblaslt/package.py

@@ -16,6 +16,7 @@ class Hipblaslt(CMakePackage):
     maintainers("srekolam", "afzpatel", "renjithravindrankannath")
 
     license("MIT")
+    version("6.3.2", sha256="cc4875b1a5cf1708a7576c42aff6b4cb790cb7337f5dc2df33119a4aadcef027")
     version("6.3.1", sha256="9a18a2e44264a21cfe58ed102fd3e34b336f23d6c191ca2da726e8e0883ed663")
     version("6.3.0", sha256="e570996037ea42eeca4c9b8b0b77a202d40be1a16068a6245595c551d80bdcad")
     version("6.2.4", sha256="b8a72cb1ed4988b0569817c6387fb2faee4782795a0d8f49b827b32b52572cfd")
@@ -51,6 +52,7 @@ class Hipblaslt(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hip@{ver}", when=f"@{ver}")
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
@@ -59,7 +61,7 @@ class Hipblaslt(CMakePackage):
     for ver in ["6.0.0", "6.0.2", "6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4"]:
         depends_on(f"hipblas@{ver}", when=f"@{ver}")
 
-    for ver in ["6.3.0", "6.3.1"]:
+    for ver in ["6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"hipblas-common@{ver}", when=f"@{ver}")
         depends_on(f"rocm-smi-lib@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/hipcc/package.py

@@ -23,6 +23,7 @@ def url_for_version(self, version):
     maintainers("srekolam", "renjithravindrankannath", "afzpatel")
 
     license("MIT")
+    version("6.3.2", sha256="1f52e45660ea508d3fe717a9903fe27020cee96de95a3541434838e0193a4827")
     version("6.3.1", sha256="e9c2481cccacdea72c1f8d3970956c447cec47e18dfb9712cbbba76a2820552c")
     version("6.3.0", sha256="79580508b039ca6c50dfdfd7c4f6fbcf489fe1931037ca51324818851eea0c1c")
     version("6.2.4", sha256="7af782bf5835fcd0928047dbf558f5000e7f0207ca39cf04570969343e789528")

var/spack/repos/builtin/packages/hipcub/package.py

@@ -17,6 +17,7 @@ class Hipcub(CMakePackage, CudaPackage, ROCmPackage):
     license("BSD-3-Clause")
 
     maintainers("srekolam", "renjithravindrankannath", "afzpatel")
+    version("6.3.2", sha256="4a1443c2ea12c3aa05fb65703eb309ccf8b893f9e6cbebec4ccf5502ba54b940")
     version("6.3.1", sha256="e5d100c7b8f95fe6243ad9f22170c136aa34db4e588136bec54ede7cb2e7f12f")
     version("6.3.0", sha256="a609cde18cefa90a1970049cc5630f2ec263f12961aa85993897580da2ca0456")
     version("6.2.4", sha256="06f3655b110d3d2e2ecf0aca052d3ba3f2ef012c069e5d2d82f2b75d50555f46")
@@ -84,6 +85,7 @@ class Hipcub(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocprim@{ver}", when=f"+rocm @{ver}")
         depends_on(f"rocm-cmake@{ver}:", type="build", when=f"@{ver}")
@@ -107,7 +109,7 @@ def cmake_args(self):
         # FindHIP.cmake is still used for +cuda
         if self.spec.satisfies("+cuda"):
             args.append(self.define("CMAKE_MODULE_PATH", self.spec["hip"].prefix.lib.cmake.hip))
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
 
         return args

var/spack/repos/builtin/packages/hipfft/package.py

@@ -24,6 +24,7 @@ class Hipfft(CMakePackage, CudaPackage, ROCmPackage):
     license("MIT")
 
     version("master", branch="master")
+    version("6.3.2", sha256="5d9e662c7d67f4c814cad70476b57651df5ae6b65f371ca6dbb5aa51d9eeb6f5")
     version("6.3.1", sha256="b709df2d0115748ed004d0cddce829cb0f9ec3761eb855e61f0097cab04e4806")
     version("6.3.0", sha256="08a0c800f531247281b4dbe8de9567a6fde4f432829a451a720d0b0a3c711059")
     version("6.2.4", sha256="308b81230498b01046f7fc3299a9e9c2c5456d80fd71a94f490ad97f51ed9de8")
@@ -91,6 +92,7 @@ class Hipfft(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"rocm-cmake@{ver}:", type="build", when=f"@{ver}")
@@ -117,7 +119,7 @@ def cmake_args(self):
         if self.spec["hip"].satisfies("@5.2:"):
             args.append(self.define("CMAKE_MODULE_PATH", self.spec["hip"].prefix.lib.cmake.hip))
 
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
 
         if self.spec.satisfies("@5.3.0:"):

var/spack/repos/builtin/packages/hipfort/package.py

@@ -16,6 +16,7 @@ class Hipfort(CMakePackage):
     license("MIT")
 
     maintainers("cgmb", "srekolam", "renjithravindrankannath", "afzpatel")
+    version("6.3.2", sha256="d2438971199637eb2e09519c1f2300cdd7a84b4d948034a7cd1ce3e441faf5de")
     version("6.3.1", sha256="8141bf3d05ab4f91c561815134707123e3d06486bf775224b9a3a4cc8ee8f56f")
     version("6.3.0", sha256="9e7f4420c75430cdb9046c0c4dbe656f22128b0672b2e261d50a6e92e47cc6d3")
     version("6.2.4", sha256="32daa4ee52c2d44790bff7a7ddde9d572e4785b2f54766a5e45d10228da0534b")
@@ -68,6 +69,7 @@ class Hipfort(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hip@{ver}", type="build", when=f"@{ver}")
 

var/spack/repos/builtin/packages/hipify-clang/package.py

@@ -19,6 +19,7 @@ class HipifyClang(CMakePackage):
     license("MIT")
 
     version("master", branch="master")
+    version("6.3.2", sha256="c0da5118be8207fab6d19803417c0b8d2db5bc766279038527cbd6fa92b25c67")
     version("6.3.1", sha256="5f9d9a65545f97b18c6a0d4394dca1bcdee10737a5635b79378ea505081f9315")
     version("6.3.0", sha256="9fced04f9e36350bdbabd730c446b55a898e2f4ba82078855bcf5dea3b5e8dc8")
     version("6.2.4", sha256="981af55ab4243f084b3e75007e827f7c94ac317fa84fe08d59c5872124a7d3c7")
@@ -76,6 +77,7 @@ class HipifyClang(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
@@ -97,6 +99,7 @@ class HipifyClang(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/hiprand/package.py

@@ -24,6 +24,7 @@ class Hiprand(CMakePackage, CudaPackage, ROCmPackage):
 
     version("develop", branch="develop")
     version("master", branch="master")
+    version("6.3.2", sha256="0a08ed7554c161b095c866cd5e6f0d63cdf063e5b3c1183afa6ac18bad94a575")
     version("6.3.1", sha256="ec43bf64eda348cf53c2767e553fd9561540dc50ae3ce95ca916404aa9a3eafb")
     version("6.3.0", sha256="7464c1e48f4e1a97a5e5978146641971d068886038810876b60acb5dfb6c4d39")
     version("6.2.4", sha256="b6010f5e0c63a139acd92197cc1c0d64a428f7a0ad661bce0cd1e553ad6fd6eb")
@@ -103,6 +104,7 @@ class Hiprand(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
         "develop",
     ]:
@@ -140,7 +142,7 @@ def cmake_args(self):
         else:
             args.append(self.define("BUILD_WITH_LIB", "ROCM"))
 
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
 
         if self.spec.satisfies("@5.3.0:"):

var/spack/repos/builtin/packages/hipsolver/package.py

@@ -29,6 +29,7 @@ class Hipsolver(CMakePackage, CudaPackage, ROCmPackage):
 
     version("develop", branch="develop")
     version("master", branch="master")
+    version("6.3.2", sha256="885c999da8e4aa0b4cb9584bc0fc0d6a8c8d56f5e7ee6d211c608003eff22aa7")
     version("6.3.1", sha256="793074ebaa4a3b16dc6e4d2a54ecbb259f1e0ec7fdcd7f885da622a1d1478b76")
     version("6.3.0", sha256="a0443f0b894cedd5af59af4fadcb3c38daa728ca32c13b9741fb19e2d828a089")
     version("6.2.4", sha256="4dc564498361cb1bac17dcfeaf0f2b9c85320797c75b05ee33160a133f5f4a15")
@@ -109,6 +110,7 @@ class Hipsolver(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
         "develop",
     ]:
@@ -162,7 +164,7 @@ def cmake_args(self):
                     self.define("CMAKE_MODULE_PATH", self.spec["hip"].prefix.lib.cmake.hip)
                 )
 
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
         if self.spec.satisfies("@5.3.0:"):
             args.append(self.define("CMAKE_INSTALL_LIBDIR", "lib"))

var/spack/repos/builtin/packages/hipsparse/package.py

@@ -21,6 +21,7 @@ class Hipsparse(CMakePackage, CudaPackage, ROCmPackage):
     libraries = ["libhipsparse"]
 
     license("MIT")
+    version("6.3.2", sha256="9fbc3468632fdc828d7bae386c2737eb371d78811f53da7348b417fb00d62808")
     version("6.3.1", sha256="d64bc48e0aa5ec2f48853272a9c554b37ec98cb0724135e45f21b1340df7bccb")
     version("6.3.0", sha256="550fd5a480490e631507e8c34b2b0cf9cbc2ad2a5bf84e8ea0a8fad96eecb25a")
     version("6.2.4", sha256="0ecc0ff1eeb99e9a9ac419e49e9be9ec4cd23a117d819710114ee2f35aefe88b")
@@ -91,6 +92,7 @@ class Hipsparse(CMakePackage, CudaPackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-cmake@{ver}:", type="build", when=f"@{ver}")
         depends_on(f"rocsparse@{ver}", when=f"+rocm @{ver}")
@@ -127,7 +129,7 @@ def cmake_args(self):
         # FindHIP.cmake is still used for +cuda
         if self.spec.satisfies("+cuda"):
             args.append(self.define("CMAKE_MODULE_PATH", self.spec["hip"].prefix.lib.cmake.hip))
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
 
         if self.spec.satisfies("@5.3.0:"):

var/spack/repos/builtin/packages/hipsparselt/package.py

@@ -21,6 +21,7 @@ class Hipsparselt(CMakePackage, ROCmPackage):
     maintainers("srekolam", "afzpatel", "renjithravindrankannath")
 
     license("MIT")
+    version("6.3.2", sha256="a0b30b478eff822dd7fa1c116ad99dcdf14ece1c33aae04ac71b594efd4d9866")
     version("6.3.1", sha256="403d4c0ef47f89510452a20be6cce72962f21761081fc19a7e0e27e7f0c4ccfd")
     version("6.3.0", sha256="f67ed4900101686596add37824d0628f1e71cf6a30d827a0519b3c3657f63ac3")
     version("6.2.4", sha256="7b007b346f89fac9214ad8541b3276105ce1cac14d6f95a8a504b5a5381c8184")
@@ -58,13 +59,14 @@ class Hipsparselt(CMakePackage, ROCmPackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hip@{ver}", when=f"@{ver}")
         depends_on(f"hipsparse@{ver}", when=f"@{ver}")
         depends_on(f"rocm-openmp-extras@{ver}", when=f"@{ver}", type="test")
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
 
-    for ver in ["6.3.0", "6.3.1"]:
+    for ver in ["6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"rocm-smi-lib@{ver}", when=f"@{ver}")
 
     depends_on("cmake@3.5:", type="build")

var/spack/repos/builtin/packages/hsa-rocr-dev/package.py

@@ -23,6 +23,7 @@ class HsaRocrDev(CMakePackage):
     libraries = ["libhsa-runtime64"]
 
     version("master", branch="master")
+    version("6.3.2", sha256="aaecaa7206b6fa1d5d7b8f7c1f7c5057a944327ba4779448980d7e7c7122b074")
     version("6.3.1", sha256="547ceeeda9a41cdffa21e57809dc5834f94938a0a2809c283aebcbcf01901df0")
     version("6.3.0", sha256="8fd6bcd6a5afd0ae5a59e33b786a525f575183d38c34049c2dab6b9270a1ca3b")
     version("6.2.4", sha256="b7aa0055855398d1228c39a6f4feb7d7be921af4f43d82855faf0b531394bb9b")
@@ -106,6 +107,7 @@ class HsaRocrDev(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
@@ -129,6 +131,7 @@ class HsaRocrDev(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/libgcrypt/o_flag_munging-1.10.patch

@@ -0,0 +1,39 @@
+From 7cea256ef1a6017e722bdfd5b7381fa90580d55a Mon Sep 17 00:00:00 2001
+From: "simit.ghane" <simit.ghane@lge.com>
+Date: Tue, 7 May 2024 14:09:03 +0530
+Subject: [PATCH] fix o_flag_munging
+
+---
+ cipher/Makefile.am | 2 +-
+ random/Makefile.am | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/cipher/Makefile.am b/cipher/Makefile.am
+index c3d642b2..04bf25e9 100644
+--- a/cipher/Makefile.am
++++ b/cipher/Makefile.am
+@@ -153,7 +153,7 @@ gost-s-box: gost-s-box.c
+ 
+ 
+ if ENABLE_O_FLAG_MUNGING
+-o_flag_munging = sed -e 's/-O\([2-9sgz][2-9sgz]*\)/-O1/' -e 's/-Ofast/-O1/g'
++o_flag_munging = sed -e 's/[[:blank:]]-O\([2-9sgz][2-9sgz]*\)/ -O1 /g' -e 's/[[:blank:]]-Ofast/ -O1 /g'
+ else
+ o_flag_munging = cat
+ endif
+diff --git a/random/Makefile.am b/random/Makefile.am
+index 0c935a05..a42e4306 100644
+--- a/random/Makefile.am
++++ b/random/Makefile.am
+@@ -56,7 +56,7 @@ jitterentropy-base.c jitterentropy.h jitterentropy-base-user.h
+ 
+ # The rndjent module needs to be compiled without optimization.  */
+ if ENABLE_O_FLAG_MUNGING
+-o_flag_munging = sed -e 's/-O\([1-9sgz][1-9sgz]*\)/-O0/g' -e 's/-Ofast/-O0/g'
++o_flag_munging = sed -e 's/[[:blank:]]-O\([1-9sgz][1-9sgz]*\)/ -O0 /g' -e 's/[[:blank:]]-Ofast/ -O0 /g'
+ else
+ o_flag_munging = cat
+ endif
+-- 
+2.43.0
+

var/spack/repos/builtin/packages/libgcrypt/o_flag_munging-1.11.patch

@@ -0,0 +1,50 @@
+From 9c11f1e12a6ddbd49b5fd38c94e6a004f8da6e29 Mon Sep 17 00:00:00 2001
+From: "simit.ghane" <simit.ghane@lge.com>
+Date: Tue, 11 Jun 2024 07:22:28 +0530
+Subject: [PATCH] random:cipher: handle substitution in sed command
+
+* cipher/Makefile.am (o_flag_munging): Add 'g' flag for first sed
+expression.
+* random/Makefile.am (o_flag_munging): Likewise.
+--
+
+It was there earlier and accidentally removed from
+Makefile.am of cipher and random
+
+Signed-off-by: simit.ghane <simit.ghane@lge.com>
+[jk: add changelog to commit message]
+Signed-off-by: Jussi Kivilinna <jussi.kivilinna@iki.fi>
+---
+ cipher/Makefile.am | 2 +-
+ random/Makefile.am | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/cipher/Makefile.am b/cipher/Makefile.am
+index ea9014cc..149c9f21 100644
+--- a/cipher/Makefile.am
++++ b/cipher/Makefile.am
+@@ -169,7 +169,7 @@ gost-s-box$(EXEEXT_FOR_BUILD): gost-s-box.c
+ 
+ 
+ if ENABLE_O_FLAG_MUNGING
+-o_flag_munging = sed -e 's/[[:blank:]]-O\([2-9sgz][2-9sgz]*\)/ -O1 /' -e 's/[[:blank:]]-Ofast/ -O1 /g'
++o_flag_munging = sed -e 's/[[:blank:]]-O\([2-9sgz][2-9sgz]*\)/ -O1 /g' -e 's/[[:blank:]]-Ofast/ -O1 /g'
+ else
+ o_flag_munging = cat
+ endif
+diff --git a/random/Makefile.am b/random/Makefile.am
+index c7100ef8..a42e4306 100644
+--- a/random/Makefile.am
++++ b/random/Makefile.am
+@@ -56,7 +56,7 @@ jitterentropy-base.c jitterentropy.h jitterentropy-base-user.h
+ 
+ # The rndjent module needs to be compiled without optimization.  */
+ if ENABLE_O_FLAG_MUNGING
+-o_flag_munging = sed -e 's/[[:blank:]]-O\([1-9sgz][1-9sgz]*\)/ -O0 /' -e 's/[[:blank:]]-Ofast/ -O0 /g'
++o_flag_munging = sed -e 's/[[:blank:]]-O\([1-9sgz][1-9sgz]*\)/ -O0 /g' -e 's/[[:blank:]]-Ofast/ -O0 /g'
+ else
+ o_flag_munging = cat
+ endif
+-- 
+2.43.0
+

var/spack/repos/builtin/packages/libgcrypt/package.py

@@ -17,26 +17,26 @@ class Libgcrypt(AutotoolsPackage):
 
     version("1.11.0", sha256="09120c9867ce7f2081d6aaa1775386b98c2f2f246135761aae47d81f58685b9c")
     version("1.10.3", sha256="8b0870897ac5ac67ded568dcfadf45969cfa8a6beb0fd60af2a9eadc2a3272aa")
-    version("1.10.2", sha256="3b9c02a004b68c256add99701de00b383accccf37177e0d6c58289664cce0c03")
-    version("1.10.1", sha256="ef14ae546b0084cd84259f61a55e07a38c3b53afc0f546bffcef2f01baffe9de")
-    version("1.10.0", sha256="6a00f5c05caa4c4acc120c46b63857da0d4ff61dc4b4b03933fa8d46013fae81")
 
-    # End of life: 2024-03-31
     with default_args(deprecated=True):
-        version("1.9.4", sha256="ea849c83a72454e3ed4267697e8ca03390aee972ab421e7df69dfe42b65caaf7")
-        version("1.9.3", sha256="97ebe4f94e2f7e35b752194ce15a0f3c66324e0ff6af26659bbfb5ff2ec328fd")
-        version("1.9.2", sha256="b2c10d091513b271e47177274607b1ffba3d95b188bbfa8797f948aec9053c5a")
-        version("1.9.1", sha256="c5a67a8b9b2bd370fb415ed1ee31c7172e5683076493cf4a3678a0fbdf0265d9")
+        version(
+            "1.10.2", sha256="3b9c02a004b68c256add99701de00b383accccf37177e0d6c58289664cce0c03"
+        )
+        version(
+            "1.10.1", sha256="ef14ae546b0084cd84259f61a55e07a38c3b53afc0f546bffcef2f01baffe9de"
+        )
+        version(
+            "1.10.0", sha256="6a00f5c05caa4c4acc120c46b63857da0d4ff61dc4b4b03933fa8d46013fae81"
+        )
+        # End of life: 2024-12-31 (LTS)
+        version("1.8.9", sha256="2bda4790aa5f0895d3407cf7bf6bd7727fd992f25a45a63d92fef10767fa3769")
+        version("1.8.7", sha256="03b70f028299561b7034b8966d7dd77ef16ed139c43440925fe8782561974748")
+        version("1.8.6", sha256="0cba2700617b99fc33864a0c16b1fa7fdf9781d9ed3509f5d767178e5fd7b975")
+        version("1.8.5", sha256="3b4a2a94cb637eff5bdebbcaf46f4d95c4f25206f459809339cdada0eb577ac3")
+        version("1.8.4", sha256="f638143a0672628fde0cad745e9b14deb85dffb175709cacc1f4fe24b93f2227")
+        version("1.8.1", sha256="7a2875f8b1ae0301732e878c0cca2c9664ff09ef71408f085c50e332656a78b3")
 
-    # End of life: 2024-12-31 (LTS)
-    version("1.8.9", sha256="2bda4790aa5f0895d3407cf7bf6bd7727fd992f25a45a63d92fef10767fa3769")
-    version("1.8.7", sha256="03b70f028299561b7034b8966d7dd77ef16ed139c43440925fe8782561974748")
-    version("1.8.6", sha256="0cba2700617b99fc33864a0c16b1fa7fdf9781d9ed3509f5d767178e5fd7b975")
-    version("1.8.5", sha256="3b4a2a94cb637eff5bdebbcaf46f4d95c4f25206f459809339cdada0eb577ac3")
-    version("1.8.4", sha256="f638143a0672628fde0cad745e9b14deb85dffb175709cacc1f4fe24b93f2227")
-    version("1.8.1", sha256="7a2875f8b1ae0301732e878c0cca2c9664ff09ef71408f085c50e332656a78b3")
-
-    depends_on("c", type="build")  # generated
+    depends_on("c", type="build")
 
     depends_on("libgpg-error@1.25:")
     depends_on("libgpg-error@1.27:", when="@1.9:")
@@ -58,6 +58,9 @@ def flag_handler(self, name, flags):
     # https://git.gnupg.org/cgi-bin/gitweb.cgi?p=libgcrypt.git;a=commit;h=b42116d6067a5233f72e5598032d4b396bb8eaac
     patch("conditional_avx512.patch", when="@1.11.0")
 
+    patch("o_flag_munging-1.10.patch", when="@1.10")
+    patch("o_flag_munging-1.11.patch", when="@1.11")
+
     def check(self):
         # Without this hack, `make check` fails on macOS when SIP is enabled
         # https://bugs.gnupg.org/gnupg/issue2056

var/spack/repos/builtin/packages/llvm-amdgpu/package.py

@@ -24,6 +24,7 @@ class LlvmAmdgpu(CMakePackage, CompilerPackage):
     license("Apache-2.0")
 
     version("master", branch="amd-stg-open")
+    version("6.3.2", sha256="1f52e45660ea508d3fe717a9903fe27020cee96de95a3541434838e0193a4827")
     version("6.3.1", sha256="e9c2481cccacdea72c1f8d3970956c447cec47e18dfb9712cbbba76a2820552c")
     version("6.3.0", sha256="79580508b039ca6c50dfdfd7c4f6fbcf489fe1931037ca51324818851eea0c1c")
     version("6.2.4", sha256="7af782bf5835fcd0928047dbf558f5000e7f0207ca39cf04570969343e789528")
@@ -160,6 +161,7 @@ class LlvmAmdgpu(CMakePackage, CompilerPackage):
         when="@master +rocm-device-libs",
     )
     for d_version, d_shasum in [
+        ("6.3.2", "aaecaa7206b6fa1d5d7b8f7c1f7c5057a944327ba4779448980d7e7c7122b074"),
         ("6.3.1", "547ceeeda9a41cdffa21e57809dc5834f94938a0a2809c283aebcbcf01901df0"),
         ("6.3.0", "8fd6bcd6a5afd0ae5a59e33b786a525f575183d38c34049c2dab6b9270a1ca3b"),
         ("6.2.4", "b7aa0055855398d1228c39a6f4feb7d7be921af4f43d82855faf0b531394bb9b"),

var/spack/repos/builtin/packages/llvm/detection_test.yaml

@@ -16,6 +16,58 @@ paths:
         c: ".*/bin/clang-3.9$"
         cxx: ".*/bin/clang[+][+]-3.9$"
 
+# flang-new detection: flang-new generates slightly-different output than clang
+- layout:
+  - executables:
+    - "bin/clang"
+    - "bin/clang++"
+    script: |
+      echo "clang version 19.1.6 (https://github.com/spack/spack.git 8d3a733b7798b6e33c371518b6dec298c3ebd8b1)"
+      echo "Target: x86_64-unknown-linux-gnu"
+      echo "Thread model: posix"
+      echo "InstalledDir: /path/to/spack/install/llvm/bin"
+  - executables:
+    - "bin/flang-new"
+    script: |
+      echo "flang-new version 19.1.6 (https://github.com/spack/spack.git 8d3a733b7798b6e33c371518b6dec298c3ebd8b1)"
+      echo "Target: x86_64-unknown-linux-gnu"
+      echo "Thread model: posix"
+      echo "InstalledDir: /path/to/spack/install/llvm/bin"
+  platforms: ["darwin", "linux"]
+  results:
+  - spec: 'llvm@19.1.6 +flang+clang~lld~lldb'
+    extra_attributes:
+      compilers:
+        c: ".*/bin/clang"
+        cxx: ".*/bin/clang[+][+]"
+        fortran: ".*/bin/flang-new"
+
+# flang: like previous test, but the fortran compiler is called "flang" vs. "flang-new"
+- layout:
+  - executables:
+    - "bin/clang"
+    - "bin/clang++"
+    script: |
+      echo "clang version 20.1.0-rc1 (https://github.com/llvm/llvm-project af7f483a9d801252247b6c72e3763c1f55c5a506)"
+      echo "Target: x86_64-unknown-linux-gnu"
+      echo "Thread model: posix"
+      echo "InstalledDir: /tmp/clang/LLVM-20.1.0-rc1-Linux-X64/bin"
+  - executables:
+    - "bin/flang"
+    script: |
+      echo "flang version 20.1.0-rc1 (https://github.com/llvm/llvm-project af7f483a9d801252247b6c72e3763c1f55c5a506)"
+      echo "Target: x86_64-unknown-linux-gnu"
+      echo "Thread model: posix"
+      echo "InstalledDir: /tmp/clang/LLVM-20.1.0-rc1-Linux-X64/bin"
+  platforms: ["darwin", "linux"]
+  results:
+  - spec: 'llvm@20.1.0 +flang+clang~lld~lldb'
+    extra_attributes:
+      compilers:
+        c: ".*/bin/clang"
+        cxx: ".*/bin/clang[+][+]"
+        fortran: ".*/bin/flang"
+
 # `~` and other weird characters in the version string
 - layout:
   - executables:

var/spack/repos/builtin/packages/llvm/package.py

@@ -753,19 +753,21 @@ def patch(self):
             string=True,
         )
 
+    clang_and_friends = "(?:clang|flang|flang-new)"
+
     compiler_version_regex = (
         # Normal clang compiler versions are left as-is
-        r"clang version ([^ )\n]+)-svn[~.\w\d-]*|"
+        rf"{clang_and_friends} version ([^ )\n]+)-svn[~.\w\d-]*|"
         # Don't include hyphenated patch numbers in the version
         # (see https://github.com/spack/spack/pull/14365 for details)
-        r"clang version ([^ )\n]+?)-[~.\w\d-]*|"
-        r"clang version ([^ )\n]+)|"
+        rf"{clang_and_friends} version ([^ )\n]+?)-[~.\w\d-]*|"
+        rf"{clang_and_friends} version ([^ )\n]+)|"
         # LLDB
         r"lldb version ([^ )\n]+)|"
         # LLD
         r"LLD ([^ )\n]+) \(compatible with GNU linkers\)"
     )
-    fortran_names = ["flang"]
+    fortran_names = ["flang", "flang-new"]
 
     @property
     def supported_languages(self):

var/spack/repos/builtin/packages/lua-sol2/package.py

@@ -31,6 +31,12 @@ class LuaSol2(CMakePackage):
     # Lua is not needed when building, since sol2 is headers-only
     depends_on("lua", type=("link", "run"))
 
+    patch(
+        "https://github.com/ThePhD/sol2/pull/1606.patch?full_index=1",
+        when="@3.3.0 %oneapi@2025:",
+        sha256="ed6c5924a0639fb1671e6d7dacbb88dce70aa006bcee2f380b6acd34da89664c",
+    )
+
     def cmake_args(self):
         args = [
             self.define("SOL2_ENABLE_INSTALL", True),

var/spack/repos/builtin/packages/mapl/package.py

@@ -38,6 +38,8 @@ class Mapl(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
+    version("2.54.1", sha256="2430ded45a98989e9100037f54cf22f5a5083e17196514b3667d3003413e49e1")
+    version("2.53.1", sha256="8371a75d4d81294eb9d99d66702f8cf62d4bd954cec3e247e1afae621b4e4726")
     version("2.53.0", sha256="68c24e6c0e3340645b1fb685972c96ef80746d5a289572c9883e520680708ebe")
     version("2.52.0", sha256="c30be3a6ed3fca40aea903e10ee51e2fb50b4ef2445fdc959d4871baf3c20585")
     version("2.51.2", sha256="f6df2be24d0c113af3d0424b674d970621660bf11e59a699373f014a14d0716e")

var/spack/repos/builtin/packages/migraphx/package.py

@@ -19,6 +19,7 @@ class Migraphx(CMakePackage):
     libraries = ["libmigraphx"]
 
     license("MIT")
+    version("6.3.2", sha256="4e6b9800919e99070c0289616657592c23ff66a55230409f38e5c7e099c0d89b")
     version("6.3.1", sha256="c60df20b3c890c469265ae6f273fb5d43cc13c8c514f76dd7b4d195d9e44ba85")
     version("6.3.0", sha256="21550e5cecf1b26c02e1c4633c7c4c6eb5e37be8758d7a2641f10cfdf4203636")
     version("6.2.4", sha256="849cca3c7c98dc437e42ac17013f86ef0a5fd202cb87b7822778bd9a8f93d293")
@@ -105,6 +106,7 @@ class Migraphx(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-cmake@{ver}:", type="build", when=f"@{ver}")
         depends_on(f"hip@{ver}", when=f"@{ver}")
@@ -122,6 +124,7 @@ class Migraphx(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocmlir@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/miopen-hip/package.py

@@ -20,6 +20,7 @@ class MiopenHip(CMakePackage):
     libraries = ["libMIOpen"]
 
     license("MIT")
+    version("6.3.2", sha256="7abda3b437e396a1611a6f63e73ab1656d45d5405194504136c0ccbb75b81fea")
     version("6.3.1", sha256="edb82a74086fb96f8d7ee9e50a180302f716332cd0dff96bf7244bdc6fab5895")
     version("6.3.0", sha256="171834978d6316a5ec7607d4b10c7c69e5bfe9064edae8bdb9b207e578b41c1d")
     version("6.2.4", sha256="8e4836e007e5e66fa487288887a098aaeeb95f3c63a19c2b91f6e848c023a040")
@@ -96,6 +97,7 @@ class MiopenHip(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-cmake@{ver}:", type="build", when=f"@{ver}")
         depends_on(f"hip@{ver}", when=f"@{ver}")
@@ -139,6 +141,7 @@ class MiopenHip(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on("nlohmann-json", type="link")
         depends_on(f"composable-kernel@{ver}", when=f"@{ver}")
@@ -156,13 +159,14 @@ class MiopenHip(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"roctracer-dev@{ver}", when=f"@{ver}")
     for ver in ["6.1.0", "6.1.1", "6.1.2"]:
         depends_on("googletest")
-    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"rocrand@{ver}", when=f"@{ver}")
-    for ver in ["6.3.0", "6.3.1"]:
+    for ver in ["6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"hipblas@{ver}", when=f"@{ver}")
         depends_on(f"hipblaslt@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/mivisionx/package.py

@@ -25,6 +25,7 @@ def url_for_version(self, version):
         return url.format(version)
 
     license("MIT")
+    version("6.3.2", sha256="2e7984e4ef2e6195aa9afa11030b8418aee885bec9befa220b9b53b5229b7fae")
     version("6.3.1", sha256="1f7bd1f6b61401bc642b50e96411344b092b09189534c5d6ba2f4c661d1af0ce")
     version("6.3.0", sha256="bc16881eae11140025b8fbd00bc741763548d41345dbe954c8d8659f4dccfe9e")
     version("6.2.4", sha256="7e65dc83f1b85e089c1218dff57211e64f3586bcb4415bda4798e4a434cba216")
@@ -172,6 +173,14 @@ def patch(self):
                 "model_compiler/python/nnir_to_clib.py",
                 string=True,
             )
+        if self.spec.satisfies("@6.2:"):
+            filter_file(
+                r"crypto",
+                "{0}".format(self.spec["openssl"].libs),
+                "utilities/runvx/CMakeLists.txt",
+                "utilities/runcl/CMakeLists.txt",
+                string=True,
+            )
 
     depends_on("cmake@3.5:", type="build")
     depends_on("ffmpeg@:4", type="build", when="@:5.3")
@@ -230,6 +239,7 @@ def patch(self):
             "6.2.4",
             "6.3.0",
             "6.3.1",
+            "6.3.2",
         ]:
             depends_on(f"miopen-hip@{ver}", when=f"@{ver}")
         for ver in [
@@ -252,6 +262,7 @@ def patch(self):
             "6.2.4",
             "6.3.0",
             "6.3.1",
+            "6.3.2",
         ]:
             depends_on(f"migraphx@{ver}", when=f"@{ver}")
             depends_on(f"hip@{ver}", when=f"@{ver}")
@@ -273,6 +284,7 @@ def patch(self):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
         depends_on("python@3.5:", type="build")
@@ -290,6 +302,7 @@ def patch(self):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rpp@{ver}", when=f"@{ver}")
 
@@ -299,9 +312,10 @@ def setup_run_environment(self, env):
             env.prepend_path("LD_LIBRARY_PATH", self.spec["hsa-rocr-dev"].prefix.lib)
 
     def setup_build_environment(self, env):
-        if self.spec.satisfies("+asan"):
+        if self.spec.satisfies("@6.1:"):
             env.set("CC", f"{self.spec['llvm-amdgpu'].prefix}/bin/clang")
             env.set("CXX", f"{self.spec['llvm-amdgpu'].prefix}/bin/clang++")
+        if self.spec.satisfies("+asan"):
             env.set("ASAN_OPTIONS", "detect_leaks=0")
             env.set("CFLAGS", "-fsanitize=address -shared-libasan")
             env.set("CXXFLAGS", "-fsanitize=address -shared-libasan")

var/spack/repos/builtin/packages/nim/package.py

@@ -15,7 +15,7 @@ class Nim(Package):
     """
 
     homepage = "https://nim-lang.org/"
-    url = "https://nim-lang.org/download/nim-2.2.0.tar.xz"
+    url = "https://nim-lang.org/download/nim-2.2.2.tar.xz"
     git = "https://github.com/nim-lang/Nim.git"
 
     license("MIT", checked_by="Buldram")
@@ -23,6 +23,7 @@ class Nim(Package):
     maintainers("Buldram")
 
     version("devel", branch="devel")
+    version("2.2.2", sha256="7fcc9b87ac9c0ba5a489fdc26e2d8480ce96a3ca622100d6267ef92135fd8a1f")
     version("2.2.0", sha256="ce9842849c9760e487ecdd1cdadf7c0f2844cafae605401c7c72ae257644893c")
     version("2.0.14", sha256="d420b955833294b7861e3fb65021dac26d1c19c528c4d6e139ccd379e2c15a43")
     version("2.0.12", sha256="c4887949c5eb8d7f9a9f56f0aeb2bf2140fabf0aee0f0580a319e2a09815733a")

var/spack/repos/builtin/packages/nwchem/oneapi2025.patch

@@ -0,0 +1,36 @@
+diff -ruN spack-src/src/config/makefile.h spack-src-patched/src/config/makefile.h
+--- spack-src/src/config/makefile.h	2024-08-28 02:30:22.000000000 +0000
++++ spack-src-patched/src/config/makefile.h	2025-02-07 16:03:07.315882016 +0000
+@@ -2364,15 +2364,14 @@
+ 		    _GOTAVX2 := $(shell cat /proc/cpuinfo | grep fma | tail -n 1 | awk ' /fma/  {print "Y"}')
+ 		    _GOTAVX512F := $(shell cat /proc/cpuinfo | grep avx512f | tail -n 1 | awk ' /avx512f/  {print "Y"}')
+                 endif
+-		_IFCE := $(shell ifort -V  2>&1 |head -1 |awk ' /64/ {print "Y";exit};')
+-		_IFCV7 := $(shell ifort -v  2>&1|grep "Version "|head -n 1|awk ' /7./  {print "Y";exit}')
+-		_IFCV11 := $(shell ifort -logo  2>&1|grep "Version "|head -n 1|sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 11) {print "Y";exit}}')
+-		_IFCV12 := $(shell ifort -logo  2>&1|grep "Version "|head -n 1|sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 12) {print "Y";exit}}')
+-		_IFCV14 := $(shell ifort -logo  2>&1|grep "Version "|head -n 1|sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 14) {print "Y";exit}}')
+-		_IFCV15ORNEWER := $(shell ifort -logo  2>&1|grep "Version "|head -n 1 | sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 15) {print "Y";exit}}')
+-	       _IFCV17 := $(shell ifort -logo  2>&1|grep "Version "|head -n 1 | sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 17) {print "Y";exit}}')
+-	       _IFCV18 := $(shell ifort -logo  2>&1|grep "Version "|head -n 1 | sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 18) {print "Y";exit}}')
+-
++                _IFCE := $(shell $(FC) -V  2>&1 |head -1 |awk ' /64/ {print "Y";exit};')
++		_IFCV7 := $(shell $(FC) -v  2>&1|grep "Version "|head -n 1|awk ' /7./  {print "Y";exit}')
++		_IFCV11 := $(shell $(FC) -logo  2>&1|grep "Version "|head -n 1|sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 11) {print "Y";exit}}')
++		_IFCV12 := $(shell $(FC) -logo  2>&1|grep "Version "|head -n 1|sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 12) {print "Y";exit}}')
++		_IFCV14 := $(shell $(FC) -logo  2>&1|grep "Version "|head -n 1|sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 14) {print "Y";exit}}')
++		_IFCV15ORNEWER := $(shell $(FC) -logo  2>&1|grep "Version "|head -n 1 | sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 15) {print "Y";exit}}')
++	        _IFCV17 := $(shell $(FC) -logo  2>&1|grep "Version "|head -n 1 | sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 17) {print "Y";exit}}')
++	        _IFCV18 := $(shell $(FC) -logo  2>&1|grep "Version "|head -n 1 | sed 's/.*Version \([0-9][0-9]\).*/\1/' | awk '{if ($$1 >= 18) {print "Y";exit}}')
+ #               Intel EM64T is required
+                 ifneq ($(_IFCE),Y)
+                     defineFCE:
+@@ -2406,7 +2405,7 @@
+ #               CPP=fpp -P
+ #
+                 ifeq ($(_IFCV15ORNEWER), Y)
+-		 IFORTVER := $(shell ifort -v 2>&1|cut -d " " -f 3)
++                 IFORTVER := $(shell $(FC) -v 2>&1|cut -d " " -f 3)
+ #                ifeq ($(IFORTVER),2021.7.0)
+ #                   $(info     )
+ #                   $(info     ifort 2021.7.0 not validated)

var/spack/repos/builtin/packages/nwchem/package.py

@@ -13,11 +13,14 @@ class Nwchem(Package):
 
     homepage = "https://nwchemgit.github.io"
     url = "https://github.com/nwchemgit/nwchem/releases/download/v7.2.0-release/nwchem-7.2.0-release.revision-d0d141fd-srconly.2023-03-10.tar.bz2"
+    git = "https://github.com/nwchemgit/nwchem.git"
 
     tags = ["ecp", "ecp-apps"]
 
     maintainers("jeffhammond")
 
+    version("master", branch="master")
+
     version(
         "7.2.3",
         sha256="8cb4ec065215bc0316d8e01f67f1674a572f7d0f565c52e4a327975c04ddb6eb",
@@ -69,6 +72,9 @@ class Nwchem(Package):
         "elpa", default=False, description="Enable optimised diagonalisation routines from ELPA"
     )
 
+    # https://github.com/nwchemgit/nwchem/pull/1034
+    patch("oneapi2025.patch", when="@7.2.3 %oneapi@2025:")
+
     # This patch is for the modification of the build system (e.g. compiler flags) and
     # Fortran syntax to enable the compilation with Fujitsu compilers. The modification
     # will be merged to the next release of NWChem (see https://github.com/nwchemgit/nwchem/issues/347

var/spack/repos/builtin/packages/openmpi/package.py

@@ -64,6 +64,9 @@ class Openmpi(AutotoolsPackage, CudaPackage):
     version(
         "5.0.0", sha256="9d845ca94bc1aeb445f83d98d238cd08f6ec7ad0f73b0f79ec1668dbfdacd613"
     )  # libmpi.so.40.40.0
+    version(
+        "4.1.8", sha256="466f68e3132a1dc02710cc2011fafced8336d98359fa2dae4dddcfd5719f12a9"
+    )  # libmpi.so.40.30.8
     version(
         "4.1.7", sha256="54a33cb7ad81ff0976f15a6cc8003c3922f0f3d8ceed14e1813ef3603f22cd34"
     )  # libmpi.so.40.30.7

var/spack/repos/builtin/packages/pflogger/package.py

@@ -21,6 +21,7 @@ class Pflogger(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
+    version("1.16.1", sha256="82ae8d008dda3984e12df3e92a61486a8f5c0b87182d54087f1d004ecc141fff")
     version("1.15.0", sha256="454f05731a3ba50c7ae3ef9463b642c53248ae84ccb3b93455ef2ae2b6858235")
     version("1.14.0", sha256="63422493136f66f61d5148b7b1d278b1e5ca76bd37c578e45e4ae0e967351823")
     version("1.13.2", sha256="934e573134f7f1a22b14eb582ea38dd68eb9dccb10526bfabe51229efe106352")

var/spack/repos/builtin/packages/pfunit/package.py

@@ -18,6 +18,7 @@ class Pfunit(CMakePackage):
 
     maintainers("mathomp4", "tclune")
 
+    version("4.11.1", sha256="db954ce44e857fe17cf4212f91223d2ab73248de0c3af405e2e1224f92ed8d42")
     version("4.10.0", sha256="ee5e899dfb786bac46e3629b272d120920bafdb7f6a677980fc345f6acda0f99")
     version("4.9.0", sha256="caea019f623d4e02dd3e8442cee88e6087b4c431a2628e9ec2de55b527b51ab6")
     version("4.8.0", sha256="b5c66ab949fd23bee5c3b4d93069254f7ea40decb8d21f622fd6aa45ee68ef10")

var/spack/repos/builtin/packages/ports-of-call/package.py

@@ -17,6 +17,9 @@ class PortsOfCall(CMakePackage):
     license("BSD-3-Clause")
 
     version("main", branch="main")
+    version("1.7.1", sha256="18b0b99370ef2adf3374248f653461606f826fe4076d0f19ac8c72d46035fdf5")
+    version("1.7.0", sha256="99045a7c4e3fbc73f01e930ce870cdc573a39910a28d85c54d65d2135f764bfc")
+    version("1.6.0", sha256="290da149d4ad79c15787956559aeeefa0a06403be2f08cd324562ef013306797")
     version("1.5.2", sha256="73d16fe9236a9475010dbb01bf751c15bef01eb2e15bf92c8d9be2c0a606329f")
     version("1.5.1", sha256="b1f0232cd6d2aac65385d77cc061ec5035283ea50d0f167e7003eae034effb78")
     version("1.4.1", sha256="82d2c75fcca8bd613273fd4126749df68ccc22fbe4134ba673b4275f9972b78d")
@@ -44,11 +47,32 @@ class PortsOfCall(CMakePackage):
         default="None",
         when="@:1.2.0",
     )
+    variant("test", default=False, description="Build tests")
+    variant(
+        "test_portability_strategy",
+        description="Portability strategy used by tests",
+        values=("Kokkos", "Cuda", "None"),
+        multi=False,
+        default="None",
+        when="@1.7.0: +test",
+    )
 
     depends_on("cmake@3.12:", type="build")
+    depends_on("catch2@3.0.1:", when="+test", type=("build", "test"))
+    depends_on("kokkos", when="+test test_portability_strategy=Kokkos", type=("build", "test"))
 
     def cmake_args(self):
-        args = []
+        args = [
+            self.define_from_variant("PORTS_OF_CALL_BUILD_TESTING", "test"),
+            self.define_from_variant(
+                "PORTS_OF_CALL_TEST_PORTABILITY_STRATEGY", "test_portability_strategy"
+            ),
+        ]
         if self.spec.satisfies("@:1.2.0"):
             args.append(self.define_from_variant("PORTABILITY_STRATEGY", "portability_strategy"))
+        if self.spec.satisfies("test_portability_strategy=Kokkos ^kokkos+rocm"):
+            args.append(self.define("CMAKE_CXX_COMPILER", self.spec["hip"].hipcc))
+            args.append(self.define("CMAKE_C_COMPILER", self.spec["hip"].hipcc))
+        if self.spec.satisfies("test_portability_strategy=Kokkos ^kokkos+cuda"):
+            args.append(self.define("CMAKE_CXX_COMPILER", self.spec["kokkos"].kokkos_cxx))
         return args

var/spack/repos/builtin/packages/py-einops/package.py

@@ -16,6 +16,7 @@ class PyEinops(PythonPackage):
     license("MIT")
     maintainers("adamjstewart")
 
+    version("0.8.1", sha256="de5d960a7a761225532e0f1959e5315ebeafc0cd43394732f103ca44b9837e84")
     version("0.8.0", sha256="63486517fed345712a8385c100cb279108d9d47e6ae59099b07657e983deae85")
     version("0.7.0", sha256="b2b04ad6081a3b227080c9bf5e3ace7160357ff03043cd66cc5b2319eb7031d1")
     version("0.6.1", sha256="f95f8d00f4ded90dbc4b19b6f98b177332614b0357dde66997f3ae5d474dc8c8")

var/spack/repos/builtin/packages/py-iterative-stats/package.py

@@ -10,25 +10,28 @@ class PyIterativeStats(PythonPackage):
 
     pypi = "iterative-stats/iterative_stats-0.1.0.tar.gz"
     git = "https://github.com/IterativeStatistics/BasicIterativeStatistics.git"
-    maintainers("robcaulk")
+    maintainers("robcaulk", "viperML", "abhishek1297")
 
     license("BSD-3-Clause")
 
     version("main", branch="main")
+    version("0.1.1", sha256="c2be6045e720aa7ff5c8dbbcd01d082d1b66f2c2a8613ad825528535e3ce0436")
     version("0.1.0", sha256="bb4f378a8fa117d1f24e9ea5ac0f1bd13c04b1ab3693a148ba936ffb237f2fba")
     version("0.0.4", sha256="7e838aa79de867b0e312be8cdf9319bb70824b624c684e968636cc8d4c9d5712")
 
-    # main dependencies
-    depends_on("python@3.8.0:3.10", type=("build", "run"))
-    depends_on("py-poetry-core@1.0.0:", type=("build"))
-    depends_on("py-pyyaml@6.0", type=("build", "run"))
-    depends_on("py-numpy@1.19:1", type=("build", "run"))
+    with default_args(type=("build", "run")):
+        depends_on("python@3.8:3.10", when="@:0.1.0")
+        depends_on("python@3.9:3.12", when="@0.1.1:")
+        depends_on("py-pyyaml@6.0:")
+        depends_on("py-numpy@1.19:1")
 
-    # dev dependencies
-    depends_on("py-pytest@6.2.1:6", type=("test"))
-    depends_on("py-autopep8@1.6.0", type=("test"))
-    depends_on("openturns@1.19+python+libxml2", type=("test"))
-    depends_on("py-scipy@1.8", type=("test"))
+    depends_on("py-poetry-core@1.0.0:", type=("build"))
+
+    with default_args(type=("test")):
+        depends_on("py-pytest@6.2.1:6")
+        depends_on("py-autopep8@1.6.0")
+        depends_on("openturns@1.19+python+libxml2")
+        depends_on("py-scipy@1.8:1")
 
     @run_after("install")
     @on_package_attributes(run_tests=True)

var/spack/repos/builtin/packages/py-maturin/package.py

@@ -17,6 +17,7 @@ class PyMaturin(PythonPackage):
 
     license("Apache-2.0")
 
+    version("1.8.2", sha256="e31abc70f6f93285d6e63d2f4459c079c94c259dd757370482d2d4ceb9ec1fa0")
     version("1.6.0", sha256="b955025c24c8babc808db49e0ff90db8b4b1320dcc16b14eb26132841737230d")
     version("1.5.1", sha256="3dd834ece80edb866af18cbd4635e0ecac40139c726428d5f1849ae154b26dca")
     version("1.4.0", sha256="ed12e1768094a7adeafc3a74ebdb8dc2201fa64c4e7e31f14cfc70378bf93790")
@@ -42,4 +43,5 @@ class PyMaturin(PythonPackage):
     # May be an accidental dependency, remove in the future
     # https://git.alpinelinux.org/aports/commit/?id=7ad298b467403b96a6b97d050170e367f147a75f
     # https://patchwork.yoctoproject.org/project/oe-core/patch/8803dc101b641c948805cab9e5784c38f43b0e51.1702791173.git.tim.orling@konsulko.com/
-    depends_on("bzip2", when="platform=darwin")
+    # This seems to still be an issue for others
+    depends_on("bzip2")

var/spack/repos/builtin/packages/python/package.py

@@ -57,15 +57,21 @@ class Python(Package):
 
     license("0BSD")
 
+    version("3.13.2", sha256="b8d79530e3b7c96a5cb2d40d431ddb512af4a563e863728d8713039aa50203f9")
     version("3.13.1", sha256="1513925a9f255ef0793dbf2f78bb4533c9f184bdd0ad19763fd7f47a400a7c55")
     version("3.13.0", sha256="12445c7b3db3126c41190bfdc1c8239c39c719404e844babbd015a1bc3fafcd4")
+    version("3.12.9", sha256="45313e4c5f0e8acdec9580161d565cf5fea578e3eabf25df7cc6355bf4afa1ee")
     version("3.12.8", sha256="5978435c479a376648cb02854df3b892ace9ed7d32b1fead652712bee9d03a45")
+    version("3.12.7", sha256="73ac8fe780227bf371add8373c3079f42a0dc62deff8d612cd15a618082ab623")
+    version("3.12.6", sha256="85a4c1be906d20e5c5a69f2466b00da769c221d6a684acfd3a514dbf5bf10a66")
     version("3.12.5", sha256="38dc4e2c261d49c661196066edbfb70fdb16be4a79cc8220c224dfeb5636d405")
     version("3.12.4", sha256="01b3c1c082196f3b33168d344a9c85fb07bfe0e7ecfe77fee4443420d1ce2ad9")
     version("3.12.3", sha256="a6b9459f45a6ebbbc1af44f5762623fa355a0c87208ed417628b379d762dddb0")
     version("3.12.2", sha256="a7c4f6a9dc423d8c328003254ab0c9338b83037bd787d680826a5bf84308116e")
     version("3.12.1", sha256="d01ec6a33bc10009b09c17da95cc2759af5a580a7316b3a446eb4190e13f97b2")
     version("3.12.0", sha256="51412956d24a1ef7c97f1cb5f70e185c13e3de1f50d131c0aac6338080687afb")
+    version("3.11.11", sha256="883bddee3c92fcb91cf9c09c5343196953cbb9ced826213545849693970868ed")
+    version("3.11.10", sha256="92f2faf242681bfa406d53a51e17d42c5373affe23a130cd9697e132ef574706")
     version("3.11.9", sha256="e7de3240a8bc2b1e1ba5c81bf943f06861ff494b69fda990ce2722a504c6153d")
     version("3.11.8", sha256="d3019a613b9e8761d260d9ebe3bd4df63976de30464e5c0189566e1ae3f61889")
     version("3.11.7", sha256="068c05f82262e57641bd93458dfa883128858f5f4997aad7a36fd25b13b29209")
@@ -76,6 +82,8 @@ class Python(Package):
     version("3.11.2", sha256="2411c74bda5bbcfcddaf4531f66d1adc73f247f529aee981b029513aefdbf849")
     version("3.11.1", sha256="baed518e26b337d4d8105679caf68c5c32630d702614fc174e98cb95c46bdfa4")
     version("3.11.0", sha256="64424e96e2457abbac899b90f9530985b51eef2905951febd935f0e73414caeb")
+    version("3.10.16", sha256="f2e22ed965a93cfeb642378ed6e6cdbc127682664b24123679f3d013fafe9cd0")
+    version("3.10.15", sha256="a27864e5ba2a4474f8f6c58ab92ff52767ac8b66f1646923355a53fe3ef15074")
     version("3.10.14", sha256="cefea32d3be89c02436711c95a45c7f8e880105514b78680c14fe76f5709a0f6")
     version("3.10.13", sha256="698ec55234c1363bd813b460ed53b0f108877c7a133d48bde9a50a1eb57b7e65")
     version("3.10.12", sha256="a43cd383f3999a6f4a7db2062b2fc9594fefa73e175b3aedafa295a51a7bb65c")
@@ -91,6 +99,8 @@ class Python(Package):
     version("3.10.2", sha256="3c0ede893011319f9b0a56b44953a3d52c7abf9657c23fb4bc9ced93b86e9c97")
     version("3.10.1", sha256="b76117670e7c5064344b9c138e141a377e686b9063f3a8a620ff674fa8ec90d3")
     version("3.10.0", sha256="c4e0cbad57c90690cb813fb4663ef670b4d0f587d8171e2c42bd4c9245bd2758")
+    version("3.9.21", sha256="667c3ba2ca98d39ead1162f6548c3475768582e2ff89e0821d25eb956ac09944")
+    version("3.9.20", sha256="1e71f006222666e0a39f5a47be8221415c22c4dd8f25334cc41aee260b3d379e")
     version("3.9.19", sha256="f5f9ec8088abca9e399c3b62fd8ef31dbd2e1472c0ccb35070d4d136821aaf71")
     version("3.9.18", sha256="504ce8cfd59addc04c22f590377c6be454ae7406cb1ebf6f5a350149225a9354")
     version("3.9.17", sha256="8ead58f669f7e19d777c3556b62fae29a81d7f06a7122ff9bc57f7dd82d7e014")
@@ -112,6 +122,9 @@ class Python(Package):
     version("3.9.1", sha256="29cb91ba038346da0bd9ab84a0a55a845d872c341a4da6879f462e94c741f117")
     version("3.9.0", sha256="df796b2dc8ef085edae2597a41c1c0a63625ebd92487adaef2fed22b567873e8")
     with default_args(deprecated=True):
+        version(
+            "3.8.20", sha256="9f2d5962c2583e67ef75924cd56d0c1af78bf45ec57035cf8a2cc09f74f4bf78"
+        )
         version(
             "3.8.19", sha256="c7fa55a36e5c7a19ec37d8f90f60a2197548908c9ac8b31e7c0dbffdd470eeac"
         )
@@ -159,8 +172,8 @@ class Python(Package):
             "3.6.15", sha256="54570b7e339e2cfd72b29c7e2fdb47c0b7b18b7412e61de5b463fc087c13b043"
         )
 
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
 
     extendable = True
 

var/spack/repos/builtin/packages/qmcpack/package.py

@@ -16,13 +16,14 @@ class Qmcpack(CMakePackage, CudaPackage):
     maintainers("ye-luo")
     tags = ["ecp", "ecp-apps"]
 
-    license("CC0-1.0")
+    license("NCSA", checked_by="prckent")
 
     # This download method is untrusted, and is not recommended by the
     # Spack manual. However, it is easier to maintain because github hashes
     # can occasionally change.
     # NOTE: 12/19/2017 QMCPACK 3.0.0 does not build properly with Spack.
     version("develop")
+    version("4.0.0", tag="v4.0.0", commit="0199944fb644b4798446fdfc0549c81666a4a943")
     version("3.17.1", tag="v3.17.1", commit="9d0d968139fc33f71dbf9159f526dd7b47f10a3b")
     version("3.17.0", tag="v3.17.0", commit="9049a90626d1fe3c431f55c56a7197f8a13d5fc6")
     version("3.16.0", tag="v3.16.0", commit="5b7544c40be105b0aafa1602601ccb0cf23ea547")

var/spack/repos/builtin/packages/quantum-espresso/package.py

@@ -24,6 +24,7 @@ class QuantumEspresso(CMakePackage, Package):
     license("GPL-2.0-only")
 
     version("develop", branch="develop")
+    version("7.4.1", sha256="6ef9c53dbf0add2a5bf5ad2a372c0bff935ad56c4472baa001003e4f932cab97")
     version("7.4", sha256="b15dcfe25f4fbf15ccd34c1194021e90996393478226e601d876f7dea481d104")
     version("7.3.1", sha256="2c58b8fadfe4177de5a8b69eba447db5e623420b070dea6fd26c1533b081d844")
     version("7.3", sha256="edc2a0f3315c69966df4f82ec86ab9f682187bc9430ef6d2bacad5f27f08972c")

var/spack/repos/builtin/packages/rccl/package.py

@@ -20,6 +20,12 @@ class Rccl(CMakePackage):
 
     maintainers("srekolam", "renjithravindrankannath", "afzpatel")
     libraries = ["librccl"]
+    version(
+        "6.3.2",
+        tag="rocm-6.3.2",
+        commit="9a0e6a114c8f7371fa3050b413a350d6945fb7db",
+        submodules=True,
+    )
     version(
         "6.3.1",
         tag="rocm-6.3.1",
@@ -93,6 +99,7 @@ class Rccl(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-cmake@{ver}:", type="build", when=f"@{ver}")
         depends_on(f"hip@{ver}", when=f"@{ver}")
@@ -116,6 +123,7 @@ class Rccl(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/rdc/package.py

@@ -26,6 +26,7 @@ def url_for_version(self, version):
         return url.format(version)
 
     license("MIT")
+    version("6.3.2", sha256="e0780b8ef46d7b9885eb06a0b9eb56924fdf090ade71a66360a0bee1d9d7295d")
     version("6.3.1", sha256="88a96f13c0010a7f9e63f7a5a5531ae1d57ef1a722bac232c8544cde6245e120")
     version("6.3.0", sha256="419afd9c8e50a872fb0a922e29c8578664ed88e0b79bf558db0a1e864aa8fecf")
     version("6.2.4", sha256="cdebbc0c1a49f067fb8ff17bd91cd92f6f83b2aee142e5b576e5eb1742983a7f")
@@ -80,6 +81,7 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-smi-lib@{ver}", type=("build", "link"), when=f"@{ver}")
         depends_on(f"hsa-rocr-dev@{ver}", when=f"@{ver}")
@@ -101,9 +103,10 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
-    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"amdsmi@{ver}", when=f"@{ver}")
 
     def patch(self):

var/spack/repos/builtin/packages/reframe/package.py

@@ -25,6 +25,11 @@ class Reframe(Package):
     license("BSD-3-Clause")
 
     version("develop", branch="develop")
+    version("4.7.3", sha256="74b8f56dc622d1c75fc1152d15d45e00edab9d2db1f6bc8fd7290125d69c74dd")
+    version("4.7.2", sha256="90e04eaaa21afd5c29a9c6218204c3df4503f624f21f2fe773f90e148d30c152")
+    version("4.7.1", sha256="ed693368d8b47327981a0db2b984c88d7dd703add1ffe736c95f9193ef727baf")
+    version("4.7.0", sha256="4a2604616cd492ab21b09f8234482239eff1a07e1ee61f4e4493fd973e7d5dc2")
+    version("4.6.4", sha256="6167ecfe6711fb9c412c0198cab549f4826eae502c9b592f18eb0192390e740e")
     version("4.6.3", sha256="0f335e588d21a26d76beb011bc86baf80ba633d875512ecd564d0aeb320fcf2c")
     version("4.6.2", sha256="d3343815ee3d2c330b91a1cdb924ba184119ed7d9fc88a4a754b939a4259df82")
     version("4.6.1", sha256="058b05c430af26d2958851af0da32bac0f4bff1af7d78ce6a132c32bbe40ec5c")
@@ -133,6 +138,8 @@ class Reframe(Package):
     depends_on("py-pyyaml", when="@3.4.1:", type="run")
     depends_on("py-requests", when="@3.4.1:", type="run")
     depends_on("py-semver", when="@3.4.2:", type="run")
+    depends_on("py-filelock", when="@4.7:", type="run")
+    depends_on("py-tabulate", when="@4.7:", type="run")
 
     # extension dependencies
     depends_on("py-pygelf", when="+gelf", type="run")
@@ -144,7 +151,7 @@ class Reframe(Package):
 
     # sanity check
     sanity_check_is_file = ["bin/reframe"]
-    sanity_check_is_dir = ["bin", "config", "docs", "reframe", "tutorials", "unittests"]
+    sanity_check_is_dir = ["bin", "docs", "reframe"]
 
     # check if we can run reframe
     @run_after("install")

var/spack/repos/builtin/packages/rivet/package.py

@@ -104,6 +104,12 @@ class Rivet(AutotoolsPackage):
 
     filter_compiler_wrappers("rivet-build", relative_root="bin")
 
+    # fix missing header in 3.1.10
+    patch(
+        "https://gitlab.com/hepcedar/rivet/-/merge_requests/800.diff",
+        sha256="9ff3429f20a4497d100627551c75a6b76dd8666d40fb5e21fdc83df4e539a6b5",
+        when="@3.1.10",
+    )
     # fix missing headers in 4.0.x
     patch(
         "https://gitlab.com/hepcedar/rivet/-/merge_requests/973.diff",

var/spack/repos/builtin/packages/rocal/package.py

@@ -15,6 +15,7 @@ class Rocal(CMakePackage):
     maintainers("afzpatel", "srekolam", "renjithravindrankannath")
 
     license("MIT")
+    version("6.3.2", sha256="ceae8a86770c1f5d8cb56f4c38d6b354e16bda6b877cf93417d6a3e4e33354c6")
     version("6.3.1", sha256="e332c9c2b2eb4081d7dd8a66a141f95fe8c7fccbbfdd0fea7572a62a28a62bbb")
     version("6.3.0", sha256="162a0c15e6e7e09c0e13a9d01a493ba3199b77919addf396cd5d273ebf44d759")
     version("6.2.4", sha256="630813669e75a8ee179b89f489101931a26f7a7ee486fcbe1b0e3cb1803c582c")
@@ -27,7 +28,7 @@ class Rocal(CMakePackage):
     depends_on("ffmpeg@4.4:")
     depends_on("abseil-cpp", when="@6.3:")
 
-    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"mivisionx@{ver}", when=f"@{ver}")
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
         depends_on(f"rpp@{ver}", when=f"@{ver}")

var/spack/repos/builtin/packages/rocalution/package.py

@@ -25,6 +25,7 @@ class Rocalution(CMakePackage):
     libraries = ["librocalution_hip"]
 
     license("MIT")
+    version("6.3.2", sha256="b13118a5c0af08a666d80af78d52bdfba12ed134f6745ab36d8de75ed3bc7584")
     version("6.3.1", sha256="94b78b34ac750c09831aa70a3d7f8cd220c540a75e4f91c391ba435de420c536")
     version("6.3.0", sha256="a7476e1ce79915cb8e01917de372ae6b15d7e51b1a25e15cde346dadf2391068")
     version("6.2.4", sha256="993c55e732d0ee390746890639486649f36ae806110cf7490b9bb5d49b0663c0")
@@ -86,6 +87,7 @@ class Rocalution(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hip@{ver}", when=f"@{ver}")
         depends_on(f"rocprim@{ver}", when=f"@{ver}")
@@ -145,7 +147,7 @@ def cmake_args(self):
         if self.spec.satisfies("^cmake@3.21.0:3.21.2"):
             args.append(self.define("__skip_rocmclang", "ON"))
 
-        if self.spec.satisfies("@5.2:"):
+        if self.spec.satisfies("@5.2:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
 
         if self.spec.satisfies("@5.3:"):

var/spack/repos/builtin/packages/rocblas/package.py

@@ -22,6 +22,7 @@ class Rocblas(CMakePackage):
 
     version("develop", branch="develop")
     version("master", branch="master")
+    version("6.3.2", sha256="455cad760d926c21101594197c4456f617e5873a8f17bb3e14bd762018545a9e")
     version("6.3.1", sha256="88d2de6ce6b23a157eea8be63408350848935e4dfc3e27e5f2add78834c6d6ba")
     version("6.3.0", sha256="051f53bb69a9aba55a0c66c32688bf6af80e29e4a6b56b380b3c427e7a6aff9d")
     version("6.2.4", sha256="8bacf74e3499c445f1bb0a8048df1ef3ce6f72388739b1823b5784fd1e8aa22a")
@@ -88,10 +89,11 @@ class Rocblas(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-openmp-extras@{ver}", type="test", when=f"@{ver}")
 
-    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"rocm-smi-lib@{ver}", type="test", when=f"@{ver}")
 
     depends_on("rocm-cmake@master", type="build", when="@master:")
@@ -117,13 +119,14 @@ class Rocblas(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hip@{ver}", when=f"@{ver}")
         depends_on(f"llvm-amdgpu@{ver}", type="build", when=f"@{ver}")
         depends_on(f"rocminfo@{ver}", type="build", when=f"@{ver}")
         depends_on(f"rocm-cmake@{ver}", type="build", when=f"@{ver}")
 
-    for ver in ["6.3.0", "6.3.1"]:
+    for ver in ["6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"hipblaslt@{ver}", when=f"@{ver}")
     depends_on("python@3.6:", type="build")
 
@@ -160,6 +163,7 @@ class Rocblas(CMakePackage):
         ("@6.2.4", "81ae9537671627fe541332c0a5d953bfd6af71d6"),
         ("@6.3.0", "aca95d1743c243dd0dd0c8b924608bc915ce1ae7"),
         ("@6.3.1", "aca95d1743c243dd0dd0c8b924608bc915ce1ae7"),
+        ("@6.3.2", "aca95d1743c243dd0dd0c8b924608bc915ce1ae7"),
     ]:
         resource(
             name="Tensile",
@@ -250,7 +254,7 @@ def cmake_args(self):
         if self.spec.satisfies("^cmake@3.21.0:3.21.2"):
             args.append(self.define("__skip_rocmclang", "ON"))
 
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
         if self.spec.satisfies("@5.3.0:"):
             args.append("-DCMAKE_INSTALL_LIBDIR=lib")

var/spack/repos/builtin/packages/rocdecode/package.py

@@ -17,6 +17,7 @@ class Rocdecode(CMakePackage):
     maintainers("afzpatel", "srekolam", "renjithravindrankannath")
 
     license("MIT")
+    version("6.3.2", sha256="39ff3c21c81a73910dcfe6a147edaddecc21575a3077f0f99971c8d2f6d0e7d5")
     version("6.3.1", sha256="94da1a61167abaf3f983ae5d62bffb22bb8ba3eb1c9d9fc7c68ed9a066aa4e52")
     version("6.3.0", sha256="931f49ff86fa34929b03cec8e7becde78d0c49c1c3a23a13203fecd2b392b242")
     version("6.2.4", sha256="37aaa1299cfc517ddaf60b0e8a5cf06d672f59e8acc0da3862b40b810d4931cb")
@@ -37,7 +38,7 @@ class Rocdecode(CMakePackage):
 
     depends_on("libva", type="build", when="@6.2:")
 
-    for ver in ["6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"hip@{ver}", when=f"@{ver}")
 
     def patch(self):

var/spack/repos/builtin/packages/rocfft/package.py

@@ -20,6 +20,7 @@ class Rocfft(CMakePackage):
 
     license("MIT")
     version("master", branch="master")
+    version("6.3.2", sha256="0511d04d2367dcac6b35bc6b449337ba37bb623b8382fb11178fc608b5435437")
     version("6.3.1", sha256="f8aa0e68d8e303725d0be8ae1d7c0113b6ca019a3b9f08572abf8a02db690662")
     version("6.3.0", sha256="afc716c95d1c80097f7a965e0c3cf1fe246c9fdf10a8fd9a303202156bd3811d")
     version("6.2.4", sha256="8ddc4e779a84b73c21b054ae37fec69e5c2f248589c7fb1b84a2197baf6ce995")
@@ -97,6 +98,7 @@ class Rocfft(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"hip@{ver}", when=f"@{ver}")
@@ -163,7 +165,7 @@ def cmake_args(self):
         if self.spec.satisfies("^cmake@3.21.0:3.21.2"):
             args.append(self.define("__skip_rocmclang", "ON"))
 
-        if self.spec.satisfies("@5.2.0:"):
+        if self.spec.satisfies("@5.2.0:6.3.1"):
             args.append(self.define("BUILD_FILE_REORG_BACKWARD_COMPATIBILITY", True))
 
         if self.spec.satisfies("@5.3.0:"):

var/spack/repos/builtin/packages/rocjpeg/package.py

@@ -18,12 +18,13 @@ class Rocjpeg(CMakePackage):
 
     license("MIT")
 
+    version("6.3.2", sha256="4e1ec9604152e818afa85360f1e0ef9e98bfb8a97ca0989980063e2ece015c16")
     version("6.3.1", sha256="f4913cbc63e11b9b418d33b0f9ba0fec0aa00b23285090acfd435e1ba1c21e42")
     version("6.3.0", sha256="2623b8f8bb61cb418d00c695e8ff0bc5979e1bb2d61d6c327a27d676c89e89cb")
 
     depends_on("cxx", type="build")
 
-    for ver in ["6.3.0", "6.3.1"]:
+    for ver in ["6.3.0", "6.3.1", "6.3.2"]:
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
         depends_on(f"hip@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/rocm-bandwidth-test/package.py

@@ -17,6 +17,7 @@ class RocmBandwidthTest(CMakePackage):
     maintainers("srekolam", "renjithravindrankannath", "afzpatel")
 
     version("master", branch="master")
+    version("6.3.2", sha256="3754831244d7c4f6314fc25b3e929adf9abe44c9cb60621dd8ae5d1aa930ae55")
     version("6.3.1", sha256="98002e4104929a62a308114ed82fba530880359a17f90ebd62a2ca49c2baac78")
     version("6.3.0", sha256="6d1e444b962e7a40fb9f20c87631865d3e04e8c9027fd21b439bee9b62d0070c")
     version("6.2.4", sha256="4d25c62d81f60eba8042f57ca0905adc853a214333ffc70238d91e2f53606a79")
@@ -86,6 +87,7 @@ class RocmBandwidthTest(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"hsa-rocr-dev@{ver}", when=f"@{ver}")
@@ -107,6 +109,7 @@ class RocmBandwidthTest(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/rocm-cmake/package.py

@@ -20,6 +20,7 @@ class RocmCmake(CMakePackage):
     license("MIT")
 
     version("master", branch="master")
+    version("6.3.2", sha256="f5104c2289da99a70d8c4c1befbca4f8efa7c89711eaac7b6b63592cd4bd99a8")
     version("6.3.1", sha256="6994a5bdeea55cd41ec01ab4142785ea02bbdcb83e70f6911095c7cea766ebe8")
     version("6.3.0", sha256="45a1b96f85ae28a7f62895ddc4d6648500b883af250f52f6417bafb31b3cc75d")
     version("6.2.4", sha256="76bfac6fba31a9c4ec196d9b9b2d5ec51b8b68840b3fba8686aa42323d76a425")
@@ -63,6 +64,7 @@ class RocmCmake(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/rocm-core/package.py

@@ -19,6 +19,7 @@ class RocmCore(CMakePackage):
     libraries = ["librocm-core"]
 
     license("MIT")
+    version("6.3.2", sha256="3243f661e5e995341e81127a6096ac80169b8481826ebadc02e24020f1ff985d")
     version("6.3.1", sha256="f8196f3aafe03bd93ae2947162f34098fd08ddbad4eb3deaf92acd434b480304")
     version("6.3.0", sha256="4fa981335426195028dd6b3a05228a2ebe8e601023a1e99130bba1b14bf60178")
     version("6.2.4", sha256="46dcfb5d20d242cd0ce6d02ba64d92bdd3ea59c103cf47b665c7d7a4ea7dc7f1")
@@ -44,7 +45,7 @@ class RocmCore(CMakePackage):
 
     depends_on("cxx", type="build")  # generated
 
-    for ver in ["6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1"]:
+    for ver in ["6.1.0", "6.1.1", "6.1.2", "6.2.0", "6.2.1", "6.2.4", "6.3.0", "6.3.1", "6.3.2"]:
         depends_on("llvm-amdgpu", when=f"@{ver}+asan")
 
     def setup_build_environment(self, env):

var/spack/repos/builtin/packages/rocm-dbgapi/package.py

@@ -24,6 +24,7 @@ class RocmDbgapi(CMakePackage):
     license("MIT")
 
     version("master", branch="amd-master")
+    version("6.3.2", sha256="0e7cea6ae2eb737ad378787d2ef5f6cbaf9dfb483bb5e61e716601a145677adf")
     version("6.3.1", sha256="1843423c91a22cf83bef5f14cb50f55ba333047e03e75296b9f9522facde5822")
     version("6.3.0", sha256="c46ca562fbbac8673c22ee5c92d62ddf6c7dfd7faceeb66d3876cde6beda8872")
     version("6.2.4", sha256="004e9ace3ead840e44f98fc033b621d5489a554965deecfdb7df768482068282")
@@ -78,6 +79,7 @@ class RocmDbgapi(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"hsa-rocr-dev@{ver}", type="build", when=f"@{ver}")
@@ -100,6 +102,7 @@ class RocmDbgapi(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/rocm-debug-agent/package.py

@@ -17,6 +17,7 @@ class RocmDebugAgent(CMakePackage):
 
     maintainers("srekolam", "renjithravindrankannath", "afzpatel")
     libraries = ["librocm-debug-agent"]
+    version("6.3.2", sha256="578aa08b10a456eebd2b548afd86339bd5a5df807611ffd20cc3006eaae74836")
     version("6.3.1", sha256="0e28a9febf3b95cc6bbf8eae91091bf22a8f49fe9558171251f8f9afe666f9d7")
     version("6.3.0", sha256="c8c3461395b2fc1e136d61eb5a36ba9f3f751eb00cb9d830f498de2e5d4299d5")
     version("6.2.4", sha256="a4f213a9e28a1e82543135c0b6d16c5a252186f83fc842f980631943f7e11398")
@@ -93,6 +94,7 @@ class RocmDebugAgent(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"hsa-rocr-dev@{ver}", when=f"@{ver}")
         depends_on(f"rocm-dbgapi@{ver}", when=f"@{ver}")
@@ -114,6 +116,7 @@ class RocmDebugAgent(CMakePackage):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

var/spack/repos/builtin/packages/rocm-device-libs/package.py

@@ -24,6 +24,7 @@ def url_for_version(self, version):
     maintainers("srekolam", "renjithravindrankannath", "haampie", "afzpatel")
 
     version("master", branch="amd-stg-open")
+    version("6.3.2", sha256="1f52e45660ea508d3fe717a9903fe27020cee96de95a3541434838e0193a4827")
     version("6.3.1", sha256="e9c2481cccacdea72c1f8d3970956c447cec47e18dfb9712cbbba76a2820552c")
     version("6.3.0", sha256="79580508b039ca6c50dfdfd7c4f6fbcf489fe1931037ca51324818851eea0c1c")
     version("6.2.4", sha256="7af782bf5835fcd0928047dbf558f5000e7f0207ca39cf04570969343e789528")
@@ -82,6 +83,7 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
         "master",
     ]:
         depends_on(f"llvm-amdgpu@{ver}", when=f"@{ver}")
@@ -103,6 +105,7 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
+        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")