mlonmcu 0.3.0.dev0__3-none-any.whl

mlonmcu/setup/tasks/mlif.py

@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import multiprocessing
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_mlif(context: MlonMcuContext, params=None):
+    return context.environment.has_platform("mlif")
+
+
+@Tasks.provides(["mlif.src_dir"])
+@Tasks.validate(_validate_mlif)
+@Tasks.register(category=TaskType.PLATFORM)
+def clone_mlif(context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()):
+    """Clone the MLonMCU SW repository."""
+    mlifName = utils.makeDirName("mlif")
+    mlifSrcDir = context.environment.paths["deps"].path / "src" / mlifName
+    if rebuild or not utils.is_populated(mlifSrcDir):
+        mlifRepo = context.environment.repos["mlif"]
+        utils.clone(mlifRepo.url, mlifSrcDir, branch=mlifRepo.ref, refresh=rebuild)
+    context.cache["mlif.src_dir"] = mlifSrcDir

mlonmcu/setup/tasks/muriscvnn.py

@@ -0,0 +1,166 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import multiprocessing
+from pathlib import Path
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_muriscvnn(context: MlonMcuContext, params=None):
+    if not context.environment.supports_feature("muriscvnn"):
+        return False
+    user_vars = context.environment.vars
+    if "muriscvnn.src_dir" not in user_vars:
+        assert "muriscvnn" in context.environment.repos, "Undefined repository: 'muriscvnn'"
+    if params:
+        toolchain = params.get("toolchain", "gcc")
+        if not context.environment.has_toolchain(toolchain):
+            return False
+        target_arch = params.get("target_arch", "riscv")
+        if target_arch == "riscv":
+            if params.get("vext", False):
+                if not context.environment.supports_feature("vext"):
+                    return False
+            if params.get("pext", False):
+                if toolchain == "llvm":
+                    # Unsupported
+                    return False
+                if not context.environment.supports_feature("pext"):
+                    return False
+            if params.get("vext", False) and params.get("pext", False):
+                # Either pext or vext!
+                return False
+        elif target_arch == "x86":
+            if toolchain != "gcc":
+                return False
+            if params.get("vext", False) or params.get("pext", False):
+                return False
+            # TODO: validate chosen toolchain?
+    return True
+
+
+@Tasks.provides(["muriscvnn.src_dir", "muriscvnn.inc_dir"])
+@Tasks.validate(_validate_muriscvnn)
+@Tasks.register(category=TaskType.OPT)
+def clone_muriscvnn(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Clone the muRISCV-NN project."""
+    muriscvnnName = utils.makeDirName("muriscvnn")
+    user_vars = context.environment.vars
+    # if "muriscvnn.lib" in user_vars:  # TODO: also check command line flags?
+    #     return False
+    if "muriscvnn.src_dir" in user_vars:
+        muriscvnnSrcDir = user_vars["muriscvnn.src_dir"]
+        muriscvnnIncludeDir = Path(muriscvnnSrcDir) / "Include"
+        rebuild = False
+    else:
+        muriscvnnSrcDir = context.environment.paths["deps"].path / "src" / muriscvnnName
+        muriscvnnIncludeDir = muriscvnnSrcDir / "Include"
+    if rebuild or not utils.is_populated(muriscvnnSrcDir):
+        muriscvnnRepo = context.environment.repos["muriscvnn"]
+        utils.clone(muriscvnnRepo.url, muriscvnnSrcDir, branch=muriscvnnRepo.ref)
+    context.cache["muriscvnn.src_dir"] = muriscvnnSrcDir
+    context.cache["muriscvnn.inc_dir"] = muriscvnnIncludeDir
+
+
+@Tasks.needs(["muriscvnn.src_dir", "riscv_gcc.install_dir", "riscv_gcc.name"])
+# @Tasks.optional(["riscv_gcc.install_dir", "riscv_gcc.name", "arm_gcc.install_dir"])
+@Tasks.provides(["muriscvnn.build_dir", "muriscvnn.lib"])
+# @Tasks.param("dbg", [False, True])
+@Tasks.param("dbg", [False])  # disable due to bug with vext gcc
+@Tasks.param("vext", [False, True])
+@Tasks.param("pext", [False, True])
+@Tasks.param("toolchain", ["gcc"])
+@Tasks.param("target_arch", ["x86", "riscv"])
+@Tasks.validate(_validate_muriscvnn)
+@Tasks.register(category=TaskType.OPT)
+def build_muriscvnn(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Build muRISCV-NN."""
+    if not params:
+        params = {}
+    flags = utils.makeFlags(
+        (params["dbg"], "dbg"),
+        (params["vext"], "vext"),
+        (params["pext"], "pext"),
+        (True, params["toolchain"]),
+        (True, params["target_arch"]),
+    )
+    flags_ = utils.makeFlags((params["vext"], "vext"), (params["pext"], "pext"))
+    muriscvnnName = utils.makeDirName("muriscvnn", flags=flags)
+    muriscvnnSrcDir = context.cache["muriscvnn.src_dir"]
+    muriscvnnBuildDir = context.environment.paths["deps"].path / "build" / muriscvnnName
+    muriscvnnInstallDir = context.environment.paths["deps"].path / "install" / muriscvnnName
+    muriscvnnLib = muriscvnnInstallDir / "libmuriscvnn.a"
+    user_vars = context.environment.vars
+    if "muriscvnn.lib" in user_vars:  # TODO: also check command line flags?
+        return False
+    if rebuild or not (utils.is_populated(muriscvnnBuildDir) and muriscvnnLib.is_file()):
+        utils.mkdirs(muriscvnnBuildDir)
+        muriscvnnArgs = []
+        target_arch = params.get("target_arch", "riscv")
+        if target_arch == "riscv":
+            gccName = context.cache["riscv_gcc.name", flags_]
+            toolchain = params.get("toolchain", "gcc")
+            assert (
+                gccName == "riscv32-unknown-elf" or toolchain != "llvm"
+            ), "muRISCV-NN requires a non-multilib toolchain!"
+            if "riscv_gcc.install_dir" in user_vars:
+                riscv_gcc = user_vars["riscv_gcc.install_dir"]
+            else:
+                riscv_gcc = context.cache["riscv_gcc.install_dir", flags_]
+            muriscvnnArgs.append("-DRISCV_GCC_PREFIX=" + str(riscv_gcc))
+            muriscvnnArgs.append("-DTOOLCHAIN=" + params["toolchain"].upper())
+            vext = params.get("vext", False)
+            pext = params.get("pext", False)
+            muriscvnnArgs.append("-DUSE_VEXT=" + ("ON" if vext else "OFF"))
+            muriscvnnArgs.append("-DUSE_PEXT=" + ("ON" if pext else "OFF"))
+            muriscvnnArgs.append(f"-DRISCV_GCC_BASENAME={gccName}")
+        elif target_arch == "x86":
+            toolchain = params.get("toolchain", "gcc")
+            muriscvnnArgs.append("-DTOOLCHAIN=x86")
+            muriscvnnArgs.append("-DUSE_VEXT=OFF")
+            muriscvnnArgs.append("-DUSE_PEXT=OFF")
+        else:
+            raise RuntimeError(f"Unsupported target_arch for muriscvnn: {target_arch}")
+        utils.cmake(
+            muriscvnnSrcDir,
+            *muriscvnnArgs,
+            cwd=muriscvnnBuildDir,
+            debug=params["dbg"],
+            live=verbose,
+        )
+        utils.make(cwd=muriscvnnBuildDir, threads=threads, live=verbose)
+        utils.mkdirs(muriscvnnInstallDir)
+        utils.move(muriscvnnBuildDir / "Source" / "libmuriscvnn.a", muriscvnnLib)
+    context.cache["muriscvnn.build_dir", flags] = muriscvnnBuildDir
+    context.cache["muriscvnn.lib", flags] = muriscvnnLib

mlonmcu/setup/tasks/pulp.py

@@ -0,0 +1,192 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import os
+import pkg_resources
+from pathlib import Path
+import multiprocessing
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+Tasks = get_task_factory()
+
+#############
+# pulp-gcc  #
+#############
+
+
+def _validate_pulp(context: MlonMcuContext, params=None):
+    return context.environment.has_target("gvsoc_pulp") or context.environment.has_target("gvsoc_pulpissimo")
+
+
+def _validate_pulp_gcc(context: MlonMcuContext, params=None):
+    return context.environment.has_toolchain("gcc") and _validate_pulp(context, params)
+
+
+@Tasks.provides(["pulp_gcc.install_dir", "pulp_gcc.name"])
+@Tasks.validate(_validate_pulp_gcc)
+@Tasks.register(category=TaskType.TOOLCHAIN)
+def install_pulp_gcc(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install the PULP (RISCV) GCC toolchain."""
+    if not params:
+        params = {}
+    user_vars = context.environment.vars
+    from_source = user_vars.get("pulp_gcc.from_source", False)
+    flags = utils.makeFlags()
+    pulpGccName = utils.makeDirName("pulp_gcc", flags=flags)
+    pulpGccInstallDir = context.environment.paths["deps"].path / "install" / pulpGccName
+    if "pulp_gcc.install_dir" in user_vars:  # TODO: also check command line flags?
+        # This would overwrite the cache.ini entry which is NOT wanted! -> return false but populate gcc_name?
+        pulpGccInstallDir = user_vars["pulp_gcc.install_dir"]
+    else:
+        if rebuild or not utils.is_populated(pulpGccInstallDir):
+            if from_source:
+                pulpGccSrcDir = context.environment.paths["deps"].path / "src" / pulpGccName
+                pulpGccBuildDir = context.environment.paths["deps"].path / "build" / pulpGccName
+                utils.mkdirs(pulpGccBuildDir)
+                if rebuild or not utils.is_populated(pulpGccSrcDir):
+                    pulpGccRepo = context.environment.repos["pulp_gcc"]
+                    utils.clone(pulpGccRepo.url, pulpGccSrcDir, branch=pulpGccRepo.ref, refresh=rebuild, recursive=True)
+                env = os.environ.copy()
+                env["PATH"] = str(pulpGccInstallDir) + ":" + env["PATH"]
+                if rebuild or not utils.is_populated(pulpGccBuildDir):
+                    pulpGccArgs = []
+                    pulpGccArgs.append("--prefix=" + str(pulpGccInstallDir))
+                    pulpGccArgs.append("--with-arch=rv32imc")
+                    pulpGccArgs.append("--with-cmodel=medlow")
+                    pulpGccArgs.append("--enable-multilib")
+                    utils.exec_getout(
+                        str(pulpGccSrcDir / "configure"),
+                        *pulpGccArgs,
+                        cwd=pulpGccBuildDir,
+                        env=env,
+                        live=verbose,
+                    )
+                utils.make(
+                    cwd=pulpGccBuildDir,
+                    env=env,
+                    live=verbose,
+                    threads=threads,
+                )
+            else:
+                pulpGccUrl = user_vars.get("pulp_gcc.dl_url", None)
+                assert pulpGccUrl, "pulp_gcc.dl_url undefined and environment and pulp_gcc.from_source=0"
+                pulpGccBaseUrl, pulpGccArchive = pulpGccUrl.rsplit("/", 1)
+                utils.download_and_extract(pulpGccBaseUrl, pulpGccArchive, pulpGccInstallDir)
+    if "pulp_gcc.name" in user_vars:
+        pulpGccName = user_vars["pulp_gcc.name"]
+    else:
+        pulpGccName = "riscv32-unknown-elf"
+    context.cache["pulp_gcc.install_dir", flags] = pulpGccInstallDir
+    context.cache["pulp_gcc.name", flags] = pulpGccName
+    # context.cache["pulp_gcc.build_dir", flags] = pulpGccBuildDir
+
+
+@Tasks.provides(["pulp_freertos.src_dir", "pulp_freertos.support_dir", "pulp_freertos.config_dir"])
+@Tasks.validate(_validate_pulp)
+@Tasks.register(category=TaskType.TARGET)
+def clone_pulp_freertos(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Clone the pulp-freertos repository."""
+    pulpRtosName = utils.makeDirName("pulp_freertos")
+    pulpRtosSrcDir = context.environment.paths["deps"].path / "src" / pulpRtosName
+    pulpRtosSupportDir = pulpRtosSrcDir / "support"
+    pulpConfigsDir = pulpRtosSupportDir / "pulp-configs" / "configs"
+    if (
+        rebuild
+        or not utils.is_populated(pulpRtosSrcDir)
+        or not utils.is_populated(pulpRtosSupportDir)
+        or not utils.is_populated(pulpConfigsDir)
+    ):
+        pulpRtosRepo = context.environment.repos["pulp_freertos"]
+        utils.clone(pulpRtosRepo.url, pulpRtosSrcDir, branch=pulpRtosRepo.ref, refresh=rebuild, recursive=True)
+        user_vars = context.environment.vars
+        experimental_install = user_vars.get("pulp_freertos.experimental_install", False)
+        if experimental_install:
+            patchFile = Path(
+                pkg_resources.resource_filename(
+                    "mlonmcu", os.path.join("..", "resources", "patches", "pulp_freertos_support.patch")
+                )
+            )
+            if patchFile.is_file():
+                utils.patch(patchFile, cwd=pulpRtosSrcDir)
+    context.cache["pulp_freertos.src_dir"] = pulpRtosSrcDir
+    context.cache["pulp_freertos.support_dir"] = pulpRtosSupportDir
+    context.cache["pulp_freertos.config_dir"] = pulpConfigsDir
+
+
+@Tasks.needs(["pulp_freertos.src_dir", "pulp_freertos.support_dir", "pulp_freertos.config_dir"])
+@Tasks.provides(["pulp_freertos.install_dir", "pulp_freertos.pythonpath", "gvsoc.exe"])
+@Tasks.validate(_validate_pulp)
+@Tasks.register(category=TaskType.TARGET)
+def install_gvsoc(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Setup the pulp-freertos build."""
+    pulpRtosName = utils.makeDirName("pulp_freertos")
+    user_vars = context.environment.vars
+    experimental_install = user_vars.get("pulp_freertos.experimental_install", False)
+    pulpRtosSupportDir = context.cache["pulp_freertos.support_dir"]
+    gvsocExe = pulpRtosSupportDir / "egvsoc.sh"
+    pulpConfigDir = context.cache["pulp_freertos.config_dir"]
+    if experimental_install:
+        pulpRtosInstallDir = context.environment.paths["deps"].path / "install" / pulpRtosName
+    else:
+        pulpRtosInstallDir = pulpRtosSupportDir / "install"
+    pulpPythonPath = pulpRtosInstallDir / "python"
+    if rebuild or not utils.is_populated(pulpRtosInstallDir) or not utils.is_populated(pulpPythonPath):
+        utils.mkdirs(pulpRtosInstallDir)
+        env = os.environ.copy()
+        env.update(
+            {
+                "PULP_CURRENT_CONFIG": "pulpissimo@config_file=chips/pulpissimo/pulpissimo.json",
+                "PULP_CONFIGS_PATH": pulpConfigDir,
+                "PYTHONPATH": pulpRtosInstallDir / "python",
+                "INSTALL_DIR": pulpRtosInstallDir,
+                "ARCHI_DIR": pulpRtosSupportDir / "archi" / "include",
+                "SUPPORT_ROOT": pulpRtosSupportDir,
+            }
+        )
+        if experimental_install:
+            env.update(
+                {
+                    "SUPPORT_INSTALL_DIR": pulpRtosInstallDir,
+                }
+            )
+        makeArgs = ["-f", pulpRtosSupportDir / "support.mk", "gvsoc"]
+        utils.make(
+            *makeArgs,
+            cwd=pulpRtosInstallDir,
+            env=env,
+            live=verbose,
+            threads=1,  # Script returns 2 exit code if parallel
+        )
+    context.cache["pulp_freertos.install_dir"] = pulpRtosInstallDir
+    context.cache["pulp_freertos.pythonpath"] = pulpPythonPath
+    context.cache["gvsoc.exe"] = gvsocExe

mlonmcu/setup/tasks/riscv_gcc.py

@@ -0,0 +1,146 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import multiprocessing
+from pathlib import Path
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import _validate_gcc, get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_riscv_gcc(context: MlonMcuContext, params=None):
+    if not _validate_gcc(context, params=params):
+        return False
+    if not (
+        context.environment.has_target("etiss_pulpino")
+        or context.environment.has_target("spike")
+        or context.environment.has_target("ovpsim")
+    ):
+        return False
+    if params:
+        vext = params.get("vext", False)
+        pext = params.get("pext", False)
+        user_vars = context.environment.vars
+        multilib = user_vars.get("riscv_gcc.multilib", False)
+        if vext and pext:
+            return multilib
+        elif vext:
+            if not context.environment.has_feature("vext"):
+                return False
+        elif pext:
+            if not context.environment.has_feature("pext"):
+                return False
+    return True
+
+
+@Tasks.provides(["riscv_gcc.install_dir", "riscv_gcc.name", "riscv_gcc.variant"])
+@Tasks.param("vext", [False, True])
+@Tasks.param("pext", [False, True])
+@Tasks.validate(_validate_riscv_gcc)
+@Tasks.register(category=TaskType.TOOLCHAIN)
+def install_riscv_gcc(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install the RISCV GCC toolchain."""
+    if not params:
+        params = {}
+    user_vars = context.environment.vars
+    vext = params["vext"]
+    pext = params["pext"]
+    multilib = user_vars.get("riscv_gcc.multilib", False)
+    variant = user_vars.get("riscv_gcc.variant", "unknown")
+    flags = utils.makeFlags((params["vext"], "vext"), (params["pext"], "pext"))
+    # TODO: if the used gcc supports both pext and vext we do not need to download it 3 times!
+    if multilib:
+        riscvName = utils.makeDirName("riscv_gcc", flags=[])
+    else:
+        riscvName = utils.makeDirName("riscv_gcc", flags=flags)
+    riscvInstallDir = context.environment.paths["deps"].path / "install" / riscvName
+    if (not vext) and (not pext) and "riscv_gcc.install_dir_default" in user_vars:
+        riscvInstallDir = user_vars["riscv_gcc.install_dir_default"]
+    if vext and "riscv_gcc.install_dir_vext" in user_vars:
+        assert not multilib, "Multilib toolchain does only support riscv_gcc.install_dir"
+        riscvInstallDir = user_vars["riscv_gcc.install_dir_vext"]
+    elif pext and "riscv_gcc.install_dir_pext" in user_vars:
+        assert not multilib, "Multilib toolchain does only support riscv_gcc.install_dir"
+        riscvInstallDir = user_vars["riscv_gcc.install_dir_pext"]
+    elif "riscv_gcc.install_dir" in user_vars:  # TODO: also check command line flags?
+        # This would overwrite the cache.ini entry which is NOT wanted! -> return false but populate gcc_name?
+        riscvInstallDir = user_vars["riscv_gcc.install_dir"]
+    else:
+
+        def _helper(url):
+            fullUrlSplit = url.split("/")
+            riscvUrl = "/".join(fullUrlSplit[:-1])
+            riscvFileName, riscvFileExtension = fullUrlSplit[-1].split(".", 1)
+            return riscvUrl, riscvFileName, riscvFileExtension
+
+        if vext and "riscv_gcc.dl_url_vext" in user_vars:
+            assert not multilib, "Multilib toolchain does only support riscv_gcc.dl_url"
+            riscvUrl, riscvFileName, riscvFileExtension = _helper(user_vars["riscv_gcc.dl_url_vext"])
+        elif pext and "riscv_gcc.dl_url_pext" in user_vars:
+            assert not multilib, "Multilib toolchain does only support riscv_gcc.dl_url"
+            riscvUrl, riscvFileName, riscvFileExtension = _helper(user_vars["riscv_gcc.dl_url_pext"])
+        elif "riscv_gcc.dl_url" in user_vars:
+            riscvUrl, riscvFileName, riscvFileExtension = _helper(user_vars["riscv_gcc.dl_url"])
+        else:
+            riscvVersion = (
+                user_vars["riscv.version"]
+                if "riscv.version" in user_vars
+                else ("8.3.0-2020.04.0" if not vext else "10.2.0-2020.12.8")
+            )
+            riscvDist = (
+                user_vars["riscv.distribution"] if "riscv.distribution" in user_vars else "x86_64-linux-ubuntu14"
+            )
+            if vext:
+                subdir = "v" + ".".join(riscvVersion.split("-")[1].split(".")[:-1])
+                riscvUrl = "https://static.dev.sifive.com/dev-tools/freedom-tools/" + subdir + "/"
+                riscvFileName = f"riscv64-unknown-elf-toolchain-{riscvVersion}-{riscvDist}"
+            else:
+                riscvUrl = "https://static.dev.sifive.com/dev-tools/"
+                riscvFileName = f"riscv64-unknown-elf-gcc-{riscvVersion}-{riscvDist}"
+            riscvFileExtension = "tar.gz"
+        riscvArchive = riscvFileName + "." + riscvFileExtension
+        # if rebuild or not utils.is_populated(riscvInstallDir):
+        # rebuild should only be triggered if the version/url changes but we can not detect that at the moment
+        if not utils.is_populated(riscvInstallDir):
+            utils.download_and_extract(riscvUrl, riscvArchive, riscvInstallDir, progress=verbose)
+    assert utils.is_populated(riscvInstallDir)
+    if "riscv_gcc.name" in user_vars:
+        gccName = user_vars["riscv_gcc.name"]
+    else:
+        gccNames = ["riscv64-unknown-elf", "riscv32-unknown-elf"]
+        gccName = None
+        for name in gccNames:
+            if (Path(riscvInstallDir) / name).is_dir():
+                gccName = name
+                break
+    assert gccName is not None, "Toolchain name could not be determined automatically"
+    context.cache["riscv_gcc.install_dir", flags] = riscvInstallDir
+    context.cache["riscv_gcc.name", flags] = gccName
+    context.cache["riscv_gcc.variant", flags] = variant