mlonmcu 0.3.0.dev0__3-none-any.whl

mlonmcu/setup/tasks/utvmcg.py

@@ -0,0 +1,96 @@
+#
+# 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 .tvm import _validate_tvm
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_utvmcg(context: MlonMcuContext, params=None):
+    if not _validate_tvm(context, params=params):
+        return False
+    return context.environment.has_backend("tvmcg")
+
+
+@Tasks.provides(["utvmcg.src_dir"])
+@Tasks.validate(_validate_utvmcg)
+@Tasks.register(category=TaskType.BACKEND)
+def clone_utvm_staticrt_codegen(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Clone the uTVM code generator."""
+    utvmcgName = utils.makeDirName("utvmcg")
+    utvmcgSrcDir = context.environment.paths["deps"].path / "src" / utvmcgName
+    if rebuild or not utils.is_populated(utvmcgSrcDir):
+        utvmcgRepo = context.environment.repos["utvm_staticrt_codegen"]
+        utils.clone(utvmcgRepo.url, utvmcgSrcDir, branch=utvmcgRepo.ref)
+    context.cache["utvmcg.src_dir"] = utvmcgSrcDir
+
+
+@Tasks.needs(["utvmcg.src_dir", "tvm.src_dir"])
+@Tasks.provides(["utvmcg.build_dir", "utvmcg.exe"])
+@Tasks.param("dbg", False)
+@Tasks.validate(_validate_utvmcg)
+@Tasks.register(category=TaskType.BACKEND)
+def build_utvm_staticrt_codegen(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Build the uTVM code generator."""
+    if not params:
+        params = {}
+    flags = utils.makeFlags((params["dbg"], "dbg"))
+    utvmcgName = utils.makeDirName("utvmcg", flags=flags)
+    utvmcgSrcDir = context.cache["utvmcg.src_dir"]
+    utvmcgBuildDir = context.environment.paths["deps"].path / "build" / utvmcgName
+    utvmcgInstallDir = context.environment.paths["deps"].path / "install" / utvmcgName
+    utvmcgExe = utvmcgInstallDir / "compiler"
+    if rebuild or not utils.is_populated(utvmcgSrcDir) or not utvmcgExe.is_file():
+        utvmcgArgs = []
+        utvmcgArgs.append("-DTVM_DIR=" + str(context.cache["tvm.src_dir"]))
+        crtConfigPath = context.cache["tvm.src_dir"] / "apps" / "bundle_deploy" / "crt_config"
+        if context:
+            user_vars = context.environment.vars
+            if "tvm.crt_config_dir" in user_vars:
+                crtConfigPath = Path(user_vars["tvm.crt_config_dir"])
+        utvmcgArgs.append("-DTVM_CRT_CONFIG_DIR=" + str(crtConfigPath))
+        utils.mkdirs(utvmcgBuildDir)
+        utils.cmake(
+            utvmcgSrcDir,
+            *utvmcgArgs,
+            cwd=utvmcgBuildDir,
+            debug=params["dbg"],
+            live=verbose,
+        )
+        utils.make(cwd=utvmcgBuildDir, threads=threads, live=verbose)
+        utils.mkdirs(utvmcgInstallDir)
+        utils.move(utvmcgBuildDir / "utvm_staticrt_codegen", utvmcgExe)
+    context.cache["utvmcg.build_dir", flags] = utvmcgBuildDir
+    context.cache["utvmcg.exe", flags] = utvmcgExe

mlonmcu/setup/tasks/zephyr.py

@@ -0,0 +1,119 @@
+#
+# 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
+import venv
+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_zephyr(context: MlonMcuContext, params=None):
+    return context.environment.has_platform("zephyr")
+
+
+# @Tasks.needs([])
+@Tasks.provides(["zephyr.install_dir", "zephyr.sdk_dir", "zephyr.venv_dir"])
+@Tasks.validate(_validate_zephyr)
+@Tasks.register(category=TaskType.PLATFORM)
+def install_zephyr(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install support for the Zephyr Platform."""
+    zephyrName = utils.makeDirName("zephyr")
+    zephyrInstallDir = context.environment.paths["deps"].path / "install" / zephyrName
+    zephyrInstallDir.mkdir(exist_ok=True)
+    zephyrSdkDir = zephyrInstallDir / "sdk"
+    zephyrVenvDir = zephyrInstallDir / "venv"
+    zephyrModulesDir = zephyrInstallDir / "modules"
+    user_vars = context.environment.vars
+    if "zephyr.install_dir" in user_vars:  # TODO: also check command line flags?
+        assert "zephyr.sdk_dir" in user_vars
+        assert "zephyr.venv_dir" in user_vars
+        return False
+    # boards = ["espressif"]
+    # if "zephyr.boards" in user_vars:
+    #     boards = user_vars["zephyr.boards"]
+    # if not isinstance(boards, str):
+    #     assert isinstance(boards, list)
+    #     boards = ",".join(boards)
+    if (
+        not utils.is_populated(zephyrInstallDir)
+        or not utils.is_populated(zephyrSdkDir)
+        or not utils.is_populated(zephyrVenvDir)
+        or not utils.is_populated(zephyrModulesDir)
+        or rebuild
+    ):
+        zephyrVenvScript = zephyrVenvDir / "bin" / "activate"
+        if not utils.is_populated(zephyrVenvDir):
+            venv.create(zephyrVenvDir)
+        utils.exec_getout(f". {zephyrVenvScript} && pip install west", shell=True, print_output=False, live=verbose)
+        zephyrRepo = context.environment.repos["zephyr"]
+        zephyrUrl = zephyrRepo.url
+        if not utils.is_populated(zephyrInstallDir / "zephyr"):
+            zephyrVersion = zephyrRepo.ref
+            utils.exec_getout(
+                f". {zephyrVenvScript} && west init -m {zephyrUrl} --mr {zephyrVersion} {zephyrInstallDir}",
+                shell=True,
+                print_output=False,
+                live=verbose,
+            )
+        extra = zephyrInstallDir / "zephyr" / "scripts" / "requirements.txt"
+        utils.exec_getout(
+            f". {zephyrVenvScript} && pip install -r {extra}", shell=True, print_output=False, live=verbose
+        )
+        env = os.environ.copy()
+        env["ZEPHYR_BASE"] = str(zephyrInstallDir / "zephyr")
+        utils.exec_getout(f". {zephyrVenvScript} && west update", shell=True, print_output=False, live=verbose, env=env)
+        if "zephyr.sdk_version" in user_vars:
+            sdkVersion = user_vars["zephyr.sdk_version"]
+        else:
+            sdkVersion = "0.15.0-rc1"
+        sdkDist = "linux-x86_64"
+        sdkUrl = f"https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v{sdkVersion}/"
+        sdkArchive = f"zephyr-sdk-{sdkVersion}_{sdkDist}.tar.gz"
+        if not utils.is_populated(zephyrSdkDir):
+            utils.download_and_extract(sdkUrl, sdkArchive, zephyrSdkDir, progress=verbose)
+        sdkScript = zephyrSdkDir / "setup.sh"
+        # TODO: allow to limit installed toolchains
+        utils.exec_getout(sdkScript, "-t", "all", "-h", print_output=False, live=verbose)
+        # Apply patch to fix esp32c3 support
+        patchFile = Path(
+            pkg_resources.resource_filename(
+                "mlonmcu", os.path.join("..", "resources", "patches", "zephyr", "fix_esp32c3_march.patch")
+            )
+        )
+        if patchFile.is_file():
+            xtensaDir = zephyrInstallDir / "modules" / "hal" / "xtensa"
+            utils.patch(patchFile, cwd=xtensaDir)
+    context.cache["zephyr.install_dir"] = zephyrInstallDir
+    context.cache["zephyr.sdk_dir"] = zephyrSdkDir
+    context.cache["zephyr.venv_dir"] = zephyrVenvDir

mlonmcu/setup/utils.py

@@ -0,0 +1,374 @@
+#
+# 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.
+#
+import os
+import signal
+import sys
+import multiprocessing
+import subprocess
+
+# import logging
+import tarfile
+import zipfile
+import shutil
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Union
+from git import Repo
+from tqdm import tqdm
+
+from mlonmcu import logging
+
+logger = logging.get_logger()
+
+
+def makeFlags(*args):
+    """Resolve tuple-like arguments to a list of string.
+
+    Parameters
+    ----------
+    args
+        List of tuples of the form: [(True, "foo"), (False, "bar")]
+
+    Returns
+    -------
+    dirname : str
+        The generated directory name
+
+    Examples
+    --------
+    >>> makeFlags((True, "foo"), (False, "bar"))
+    ["foo"]
+    """
+    return [name for check, name in args if check]
+
+
+def makeDirName(base: str, *args, flags: list = None) -> str:
+    """Creates a directory name based on configuration values.
+
+    Using snake_case style.
+
+    Parameters
+    ----------
+    base : str
+        Prefix of the filename to be generated.
+    args
+        List of tuples of the form: [(True, "foo"), (False, "bar")]
+    flags : list
+        Optional list of additional flags to be added.
+
+    Returns
+    -------
+    dirname : str
+        The generated directory name
+
+    Examples
+    --------
+    >>> makeDirName("base", (True, "foo"), (False, "bar"), flags=["flag"])
+    "base_foo_flag"
+    """
+    names = [base] + makeFlags(*args)
+    if flags:
+        names = names + flags
+    return "_".join(names)
+
+
+def exec(*args, **kwargs):
+    """Execute a process with the given args and using the given kwards as Popen arguments.
+
+    Parameters
+    ----------
+    args
+        The command to be executed.
+    """
+    logger.debug("- Executing: " + str(args))
+    subprocess.run([i for i in args], **kwargs, check=True)
+
+
+def exec_getout(*args, live: bool = False, print_output: bool = True, handle_exit=None, prefix="", **kwargs) -> str:
+    """Execute a process with the given args and using the given kwards as Popen arguments and return the output.
+
+    Parameters
+    ----------
+    args
+        The command to be executed.
+    live : bool
+        If the stdout should be updated in real time.
+    print_output : bool
+        Print the output at the end on non-live mode.
+
+    Returns
+    -------
+    output
+        The text printed to the command line.
+    """
+    logger.debug("- Executing: " + str(args))
+    outStr = ""
+    if live:
+        process = subprocess.Popen([i for i in args], **kwargs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        try:
+            for line in process.stdout:
+                new_line = prefix + line.decode(errors="replace")
+                outStr = outStr + new_line
+                print(new_line.replace("\n", ""))
+            exit_code = None
+            while exit_code is None:
+                exit_code = process.poll()
+            if handle_exit is not None:
+                exit_code = handle_exit(exit_code)
+            assert exit_code == 0, "The process returned an non-zero exit code {}! (CMD: `{}`)".format(
+                exit_code, " ".join(list(map(str, args)))
+            )
+        except KeyboardInterrupt:
+            logger.debug("Interrupted subprocess. Sending SIGINT signal...")
+            pid = process.pid
+            os.kill(pid, signal.SIGINT)
+
+    else:
+        try:
+            p = subprocess.Popen([i for i in args], **kwargs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+            outStr = p.communicate()[0].decode(errors="replace")
+            exit_code = p.poll()
+            # outStr = p.stdout.decode(errors="replace")
+            if print_output:
+                logger.debug(prefix + outStr)
+            if handle_exit is not None:
+                exit_code = handle_exit(exit_code)
+            if exit_code != 0:
+                logger.error(outStr)
+            assert exit_code == 0, "The process returned an non-zero exit code {}! (CMD: `{}`)".format(
+                exit_code, " ".join(list(map(str, args)))
+            )
+        except KeyboardInterrupt:
+            logger.debug("Interrupted subprocess. Sending SIGINT signal...")
+            pid = p.pid
+            os.kill(pid, signal.SIGINT)
+        except subprocess.CalledProcessError as e:
+            outStr = e.output.decode(errors="replace")
+            logger.error(outStr)
+            raise e
+
+    return outStr
+
+
+def python(*args, **kwargs):
+    """Run a python script with the current interpreter."""
+    return exec_getout(sys.executable, *args, **kwargs)
+
+
+# Makes sure all directories at the given path are created.
+def mkdirs(path: Union[str, bytes, os.PathLike]):
+    """Wrapper for os.makedirs which handels the special case where the path already exits."""
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+
+# Clones a git repository at given url into given dir and switches to the given branch.
+def clone(
+    url: str,
+    dest: Union[str, bytes, os.PathLike],
+    branch: str = "",
+    recursive: bool = False,
+    refresh: bool = False,
+):
+    """Helper function for cloning a repository.
+
+    Parameters
+    ----------
+    url : str
+        Clone URL of the repository.
+    dest : Path
+        Destination directory path.
+    branch : str
+        Optional branch name or commit reference/tag.
+    recursive : bool
+        If the clone should be done recursively.
+    refesh : bool
+        Enables switching the url/branch if the repo already exists
+    """
+    mkdirs(dest)
+
+    if is_populated(dest):
+        if refresh:
+            repo = Repo(dest)
+            # TODO: backup old remote?
+            repo.remotes.origin.set_url(url)
+            repo.remotes.origin.fetch()
+            repo.git.checkout(branch)
+            repo.git.pull("origin", branch)  # This should also work for specific commits
+    else:
+        if branch:
+            repo = Repo.clone_from(url, dest, recursive=recursive, no_checkout=True)
+            repo.git.checkout(branch)
+            if recursive:
+                repo.git.submodule("update", "--init", "--recursive")
+        else:
+            Repo.clone_from(url, dest, recursive=recursive)
+
+
+def apply(
+    repo_dir: Path,
+    patch_file: Path,
+):
+    """Helper function for applying a patch to a repository.
+
+    Parameters
+    ----------
+    repo_dir : Path
+        Clone directory of repository.
+    patch_file : Path
+        Path to patch file.
+    """
+
+    repo = Repo(repo_dir)
+    repo.git.clean("-xdf")  # Undo all changes
+    repo.git.apply(patch_file)
+
+
+def make(*args, threads=multiprocessing.cpu_count(), use_ninja=False, cwd=None, verbose=False, **kwargs):
+    if cwd is None:
+        raise RuntimeError("Please always pass a cwd to make()")
+    if isinstance(cwd, Path):
+        cwd = str(cwd.resolve())
+    # TODO: make sure that ninja is installed?
+    extraArgs = []
+    tool = "ninja" if use_ninja else "make"
+    extraArgs.append("-j" + str(threads))
+    cmd = [tool] + extraArgs + list(args)
+    return exec_getout(*cmd, cwd=cwd, print_output=False, **kwargs)
+
+
+def cmake(src, *args, debug=False, use_ninja=False, cwd=None, **kwargs):
+    if cwd is None:
+        raise RuntimeError("Please always pass a cwd to cmake()")
+    if isinstance(cwd, Path):
+        cwd = str(cwd.resolve())
+    buildType = "Debug" if debug else "Release"
+    extraArgs = []
+    extraArgs.append("-DCMAKE_BUILD_TYPE=" + buildType)
+    if use_ninja:
+        extraArgs.append("-GNinja")
+    cmd = ["cmake", str(src)] + extraArgs + list(args)
+    return exec_getout(*cmd, cwd=cwd, print_output=False, **kwargs)
+
+
+# def move(a, b):  # TODO: make every utility compatible with Paths!
+#     # This can not handle cross file-system renames!
+#     if not isinstance(a, Path):
+#         a = Path(a)
+#     if not isinstance(b, Path):
+#         b = Path(b)
+#     a.replace(b)
+
+
+def download(url, dest, progress=False):
+    def hook(t):
+        """Wraps tqdm instance."""
+        last_b = [0]
+
+        def update_to(b=1, bsize=1, tsize=None):
+            """
+            b  : int, optional
+                Number of blocks transferred so far [default: 1].
+            bsize  : int, optional
+                Size of each block (in tqdm units) [default: 1].
+            tsize  : int, optional
+                Total size (in tqdm units). If [default: None] remains unchanged.
+            """
+            if tsize is not None:
+                t.total = tsize
+            t.update((b - last_b[0]) * bsize)
+            last_b[0] = b
+
+        return update_to
+
+    if progress:
+        with tqdm(unit="B", unit_scale=True, unit_divisor=1024, miniters=1, desc="Downloading File") as t:
+            urllib.request.urlretrieve(url, dest, reporthook=hook(t))
+    else:
+        urllib.request.urlretrieve(url, dest)
+
+
+def extract(archive, dest, progress=False):
+    ext = Path(archive).suffix[1:]
+
+    def handle(f):
+        if progress:
+            members = f.getmembers()
+            for m in tqdm(iterable=members, total=len(members), desc="Extracting..."):
+                f.extract(m, dest)
+        else:
+            f.extractall(dest)
+
+    if ext == "zip":
+        with zipfile.ZipFile(archive) as zip_file:
+            handle(zip_file)
+    elif ext in ["tar", "gz", "xz", "tgz", "bz2"]:
+        with tarfile.open(archive) as tar_file:
+            handle(tar_file)
+    else:
+        raise RuntimeError("Unable to detect the archive type")
+
+
+def remove(path):
+    os.remove(path)
+
+
+def move(src, dest):
+    shutil.move(src, dest)
+
+
+def copy(src, dest):
+    shutil.copy(src, dest)
+
+
+def is_populated(path):
+    if not isinstance(path, Path):
+        path = Path(path)
+    return path.is_dir() and os.listdir(path.resolve())
+
+
+def download_and_extract(url, archive, dest, progress=False):
+    if isinstance(dest, str):
+        dest = Path(dest)
+    assert isinstance(dest, Path)
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_archive = os.path.join(tmp_dir, archive)
+        base_name = Path(archive).stem
+        if ".tar" in base_name:
+            base_name = Path(base_name).stem
+        if url[-1] != "/":
+            url += "/"
+        download(url + archive, tmp_archive, progress=progress)
+        extract(tmp_archive, tmp_dir, progress=progress)
+        remove(os.path.join(tmp_dir, tmp_archive))
+        mkdirs(dest.parent)
+        if (Path(tmp_dir) / base_name).is_dir():  # Archive contains a subdirectory with the same name
+            move(os.path.join(tmp_dir, base_name), dest)
+        else:
+            contents = list(Path(tmp_dir).glob("*"))
+            if len(contents) == 1:
+                tmp_dir_new = Path(tmp_dir) / contents[0]
+                if tmp_dir_new.is_dir():  # Archive contains a single subdirectory with a different name
+                    tmp_dir = tmp_dir_new
+            move(tmp_dir, dest)
+
+
+def patch(path, cwd=None):
+    raise NotImplementedError

mlonmcu/target/__init__.py

@@ -0,0 +1,37 @@
+#
+# 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.
+#
+"""MLonMCU target submodule"""
+
+from .target import Target
+from ._target import register_target, get_targets
+from .riscv import EtissPulpinoTarget, SpikeTarget, OVPSimTarget, RiscvQemuTarget
+from .arm import Corstone300Target
+from .host_x86 import HostX86Target
+
+__all__ = [
+    "register_target",
+    "get_targets",
+    "Target",
+    "EtissPulpinoTarget",
+    "SpikeTarget",
+    "OVPSimTarget",
+    "RiscvQemuTarget",
+    "Corstone300Target",
+    "HostX86Target",
+]

mlonmcu/target/_target.py

@@ -0,0 +1,41 @@
+# 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.
+#
+from .riscv import EtissPulpinoTarget, SpikeTarget, OVPSimTarget, RiscvQemuTarget, GvsocPulpTarget
+from .arm import Corstone300Target
+from .host_x86 import HostX86Target
+
+TARGET_REGISTRY = {}
+
+
+def register_target(target_name, t, override=False):
+    global TARGET_REGISTRY
+
+    if target_name in TARGET_REGISTRY and not override:
+        raise RuntimeError(f"Target {target_name} is already registered")
+    TARGET_REGISTRY[target_name] = t
+
+
+def get_targets():
+    return TARGET_REGISTRY
+
+
+register_target("etiss_pulpino", EtissPulpinoTarget)
+register_target("host_x86", HostX86Target)
+register_target("corstone300", Corstone300Target)
+register_target("spike", SpikeTarget)
+register_target("ovpsim", OVPSimTarget)
+register_target("riscv_qemu", RiscvQemuTarget)
+register_target("gvsoc_pulp", GvsocPulpTarget)

mlonmcu/target/arm/__init__.py

@@ -0,0 +1,3 @@
+from .corstone300 import Corstone300Target
+
+__all__ = ["Corstone300Target"]