zephyr: zmake: implement multiple toolchain support/probing

Our GitLab builder uses different toolchains than the supported ones
we use for development.  At present, this means that the GitLab CI
needs to call -t for each build with the desired toolchain, preventing
us from using the more general commands "zmake coverage" or "zmake
testall".

Extend the idea of toolchain in our config files to be "supported
toolchains" instead (i.e., multiple toolchains can be supported
instead of one.  We do this by refactoring our toolchain support code
to consist of two related methods:

- "probe" returns True if the toolchain is detected on the system, or
  False otherwise
- "get_toolchain_config" returns the BuildConfig associated with the
  toolchain for the system, mirroring the functionality previously
  implemented in lambda functions.

Also dropped support for arm-none-eabi, as I believe this was only
used early on during scarlet development, and am not aware of any
current users.

BUG=b:178731498
BRANCH=none
TEST=./run_tests.sh
TEST=zmake testall

Signed-off-by: Jack Rosenthal <jrosenth@chromium.org>
Change-Id: I9b2ad508ae6703f0c3b56518fc32606c0ff1777c
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/3134668
Commit-Queue: Jeremy Bettis <jbettis@chromium.org>
Reviewed-by: Jeremy Bettis <jbettis@chromium.org>

4 files changed, 152 insertions, 24 deletions

diff --git a/zephyr/zmake/tests/test_project.py b/zephyr/zmake/tests/test_project.py
index dd57a5c9c9..2442ceedf6 100644
--- a/zephyr/zmake/tests/test_project.py
+++ b/zephyr/zmake/tests/test_project.py
@@ -70,8 +70,8 @@ def test_find_dts_overlays(modules):
             with TemporaryProject(
                 {
                     "board": board,
-                    "toolchain": "foo",
                     "output-type": "elf",
+                    "supported-toolchains": ["llvm"],
                     "supported-zephyr-versions": ["v2.6"],
                 }
             ) as project:
@@ -104,8 +104,8 @@ def test_prune_modules(modules):
     with TemporaryProject(
         {
             "board": "native_posix",
-            "toolchain": "coreboot-sdk",
             "output-type": "elf",
+            "supported-toolchains": ["coreboot-sdk"],
             "supported-zephyr-versions": ["v2.6"],
             "modules": modules,
         }
@@ -125,8 +125,8 @@ def test_prune_modules_unavailable():
     with TemporaryProject(
         {
             "board": "native_posix",
-            "toolchain": "coreboot-sdk",
             "output-type": "elf",
+            "supported-toolchains": ["coreboot-sdk"],
             "supported-zephyr-versions": ["v2.6"],
             "modules": ["hal_stm32", "cmsis"],
         }
@@ -144,7 +144,8 @@ def test_find_projects_empty(tmp_path):
 YAML_FILE = """
 supported-zephyr-versions:
   - v2.6
-toolchain: coreboot-sdk
+supported-toolchains:
+  - coreboot-sdk
 output-type: npcx
 """
 
diff --git a/zephyr/zmake/tests/test_toolchains.py b/zephyr/zmake/tests/test_toolchains.py
index 266013b0e0..515f54a112 100644
--- a/zephyr/zmake/tests/test_toolchains.py
+++ b/zephyr/zmake/tests/test_toolchains.py
@@ -2,34 +2,154 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import os
 import pathlib
 
-import mock
+import pytest
 
+import zmake.project as project
 import zmake.toolchains as toolchains
 
 
-def test_coreboot_sdk():
-    config = toolchains.get_toolchain("coreboot-sdk", {"ec": pathlib.Path("/")})
-    assert config.cmake_defs["ZEPHYR_TOOLCHAIN_VARIANT"] == "coreboot-sdk"
-    assert config.cmake_defs["TOOLCHAIN_ROOT"] == "/zephyr"
+@pytest.fixture
+def mockfs(monkeypatch, tmp_path):
+    """Setup a fake fs root for pathlib objects at tmp_path/mockfs."""
+    mockfs_dir = pathlib.PosixPath(tmp_path / "mockfs")
+    mockfs_dir.mkdir()
 
+    class FakePath(pathlib.Path):
+        def __new__(cls, *args, **kwargs):
+            parts = pathlib.PosixPath(*args).relative_to("/").parts
+            # Make sure we don't double up our mocked directory.
+            mock_dir_parts = mockfs_dir.relative_to("/").parts
+            if parts[: len(mock_dir_parts)] == mock_dir_parts:
+                return pathlib.PosixPath(*args)
+            return pathlib.PosixPath("/", *mock_dir_parts, *parts)
 
-def test_llvm():
-    config = toolchains.get_toolchain("llvm", {"ec": pathlib.Path("/")})
-    assert config.cmake_defs["ZEPHYR_TOOLCHAIN_VARIANT"] == "llvm"
-    assert config.cmake_defs["TOOLCHAIN_ROOT"] == "/zephyr"
+    monkeypatch.setattr(pathlib, "Path", FakePath)
+    return mockfs_dir
 
 
-@mock.patch("zmake.toolchains.find_zephyr_sdk", return_value="/opt/zephyr-sdk")
-def test_zephyr(find_zephyr_sdk):
-    config = toolchains.get_toolchain("zephyr", {})
-    assert config.cmake_defs["ZEPHYR_TOOLCHAIN_VARIANT"] == "zephyr"
-    assert config.cmake_defs["ZEPHYR_SDK_INSTALL_DIR"] == "/opt/zephyr-sdk"
-    assert config.environ_defs["ZEPHYR_SDK_INSTALL_DIR"] == "/opt/zephyr-sdk"
+@pytest.fixture
+def coreboot_sdk_exists(mockfs):
+    coreboot_sdk_dir = mockfs / "opt" / "coreboot-sdk"
+    coreboot_sdk_dir.mkdir(parents=True)
 
 
-def test_arm_none_eabi():
-    config = toolchains.get_toolchain("arm-none-eabi", {})
-    assert config.cmake_defs["ZEPHYR_TOOLCHAIN_VARIANT"] == "cross-compile"
-    assert config.cmake_defs["CROSS_COMPILE"] == "/usr/bin/arm-none-eabi-"
+@pytest.fixture
+def llvm_exists(mockfs):
+    llvm_file = mockfs / "usr" / "bin" / "x86_64-pc-linux-gnu-clang"
+    llvm_file.parent.mkdir(parents=True)
+    llvm_file.write_text("")
+
+
+@pytest.fixture
+def host_toolchain_exists(mockfs, monkeypatch):
+    monkeypatch.setattr(os, "environ", {})
+
+    gcc_file = mockfs / "usr" / "bin" / "gcc"
+    gcc_file.parent.mkdir(parents=True)
+    gcc_file.write_text("")
+
+
+@pytest.fixture
+def zephyr_exists(mockfs):
+    zephyr_sdk_version_file = mockfs / "opt" / "zephyr-sdk" / "sdk_version"
+    zephyr_sdk_version_file.parent.mkdir(parents=True)
+    zephyr_sdk_version_file.write_text("")
+
+
+@pytest.fixture
+def fake_project(tmp_path):
+    return project.Project(
+        tmp_path,
+        config_dict={
+            "board": "foo",
+            "supported-zephyr-versions": ["v2.6"],
+            "supported-toolchains": [
+                "coreboot-sdk",
+                "host",
+                "llvm",
+                "zephyr",
+            ],
+            "output-type": "raw",
+        },
+    )
+
+
+module_paths = {
+    "ec": pathlib.Path("/mnt/host/source/src/platform/ec"),
+}
+
+
+def test_coreboot_sdk(fake_project, coreboot_sdk_exists):
+    tc = fake_project.get_toolchain(module_paths)
+    assert isinstance(tc, toolchains.CorebootSdkToolchain)
+
+    config = tc.get_build_config()
+    assert config.cmake_defs == {
+        "ZEPHYR_TOOLCHAIN_VARIANT": "coreboot-sdk",
+        "TOOLCHAIN_ROOT": "/mnt/host/source/src/platform/ec/zephyr",
+    }
+
+
+def test_llvm(fake_project, llvm_exists):
+    tc = fake_project.get_toolchain(module_paths)
+    assert isinstance(tc, toolchains.LlvmToolchain)
+
+    config = tc.get_build_config()
+    assert config.cmake_defs == {
+        "ZEPHYR_TOOLCHAIN_VARIANT": "llvm",
+        "TOOLCHAIN_ROOT": "/mnt/host/source/src/platform/ec/zephyr",
+    }
+
+
+def test_zephyr(fake_project, zephyr_exists):
+    tc = fake_project.get_toolchain(module_paths)
+    assert isinstance(tc, toolchains.ZephyrToolchain)
+
+    config = tc.get_build_config()
+    assert config.cmake_defs == {
+        "ZEPHYR_TOOLCHAIN_VARIANT": "zephyr",
+        "ZEPHYR_SDK_INSTALL_DIR": str(pathlib.Path("/opt/zephyr-sdk")),
+    }
+    assert config.environ_defs == {
+        "ZEPHYR_SDK_INSTALL_DIR": str(pathlib.Path("/opt/zephyr-sdk")),
+    }
+
+
+def test_zephyr_from_env(mockfs, monkeypatch, fake_project):
+    zephyr_sdk_path = mockfs / "zsdk"
+    zephyr_sdk_path.mkdir()
+
+    environ = {"ZEPHYR_SDK_INSTALL_DIR": str(zephyr_sdk_path)}
+    monkeypatch.setattr(os, "environ", environ)
+
+    tc = fake_project.get_toolchain(module_paths)
+    assert isinstance(tc, toolchains.ZephyrToolchain)
+
+    config = tc.get_build_config()
+    assert config.cmake_defs == {
+        "ZEPHYR_TOOLCHAIN_VARIANT": "zephyr",
+        "ZEPHYR_SDK_INSTALL_DIR": str(zephyr_sdk_path),
+    }
+    assert config.environ_defs == {
+        "ZEPHYR_SDK_INSTALL_DIR": str(zephyr_sdk_path),
+    }
+
+
+def test_host_toolchain(fake_project, host_toolchain_exists):
+    tc = fake_project.get_toolchain(module_paths)
+    assert isinstance(tc, toolchains.HostToolchain)
+
+    config = tc.get_build_config()
+    assert config.cmake_defs == {
+        "ZEPHYR_TOOLCHAIN_VARIANT": "host",
+    }
+
+
+def test_toolchain_override(mockfs, fake_project):
+    tc = fake_project.get_toolchain(module_paths, override="foo")
+    config = tc.get_build_config()
+    assert isinstance(tc, toolchains.GenericToolchain)
+    assert config.cmake_defs == {"ZEPHYR_TOOLCHAIN_VARIANT": "foo"}
diff --git a/zephyr/zmake/tests/test_version.py b/zephyr/zmake/tests/test_version.py
index 8fb4a09435..44997f94da 100644
--- a/zephyr/zmake/tests/test_version.py
+++ b/zephyr/zmake/tests/test_version.py
@@ -54,8 +54,8 @@ def _setup_example_repos(tmp_path):
         project_path,
         config_dict={
             "board": "foo",
-            "toolchain": "bar",
             "output-type": "raw",
+            "supported-toolchains": ["coreboot-sdk"],
             "supported-zephyr-versions": ["v2.6"],
         },
     )
diff --git a/zephyr/zmake/tests/test_zmake.py b/zephyr/zmake/tests/test_zmake.py
index f7978764f8..641f9f3db9 100644
--- a/zephyr/zmake/tests/test_zmake.py
+++ b/zephyr/zmake/tests/test_zmake.py
@@ -19,6 +19,7 @@ import zmake.build_config
 import zmake.jobserver
 import zmake.multiproc as multiproc
 import zmake.project
+import zmake.toolchains
 import zmake.zmake as zm
 
 OUR_PATH = os.path.dirname(os.path.realpath(__file__))
@@ -49,6 +50,12 @@ class FakeProject:
     def find_dts_overlays(self, module_paths):
         return zmake.build_config.BuildConfig()
 
+    def get_toolchain(self, module_paths, override=None):
+        return zmake.toolchains.GenericToolchain(
+            override or "foo",
+            modules=module_paths,
+        )
+
 
 class FakeJobserver(zmake.jobserver.GNUMakeJobServer):
     """A fake jobserver which just runs 'cat' on the provided files"""