| # Copyright 2026 The Pigweed Authors |
| # |
| # 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 |
| # |
| # https://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 sys |
| import argparse |
| import tempfile |
| import re |
| import subprocess |
| from pathlib import Path |
| |
| import kconfig_utils |
| |
| try: |
| import yaml |
| try: |
| from yaml import CSafeLoader as SafeLoader |
| except ImportError: |
| from yaml import SafeLoader |
| except ImportError: |
| yaml = None |
| |
| def parse_args(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--zephyr-base", required=True) |
| parser.add_argument("--modules", nargs="+", default=[]) |
| parser.add_argument("--board-dirs", nargs="+", default=[]) |
| parser.add_argument("--oot-dts-roots", nargs="+", default=[]) |
| parser.add_argument("--output", required=True) |
| return parser.parse_args() |
| |
| def find_soc_source_directories(zephyr_base, modules=None): |
| soc_roots = [Path(zephyr_base)] + ([Path(m) for m in modules] if modules else []) |
| result = [] |
| for root in soc_roots: |
| soc_path = root / 'soc' |
| if soc_path.is_dir(): |
| for dirpath, _, filenames in os.walk(soc_path, followlinks=True): |
| if 'soc.yml' in filenames: |
| result.append(dirpath) |
| return result |
| |
| def find_board_source_directories(board_roots): |
| result = [] |
| for root in board_roots: |
| root_path = Path(root) |
| if not root_path.exists(): |
| continue |
| for dirpath, _, filenames in os.walk(root, followlinks=True): |
| if 'board.yml' in filenames: |
| result.append(dirpath) |
| # HWM v1 uses Kconfig.board or board.Kconfig |
| for kconfig_file in root_path.rglob('Kconfig.board'): |
| result.append(str(kconfig_file.parent)) |
| for kconfig_file in root_path.rglob('board.Kconfig'): |
| result.append(str(kconfig_file.parent)) |
| return list(set(result)) |
| |
| def get_soc_to_clusters(soc_dirs): |
| """Parses soc.yml files to map SoC names to their clusters.""" |
| soc_to_clusters = {} |
| if yaml is None: |
| return soc_to_clusters |
| |
| for sdir in soc_dirs: |
| soc_yml_path = os.path.join(sdir, "soc.yml") |
| if os.path.exists(soc_yml_path): |
| try: |
| with open(soc_yml_path, "r") as f: |
| content = yaml.load(f, Loader=SafeLoader) |
| |
| def find_socs(node): |
| if isinstance(node, dict): |
| if "socs" in node: |
| for soc in node["socs"]: |
| sn = soc.get("name") |
| if sn: |
| if sn not in soc_to_clusters: |
| soc_to_clusters[sn] = [] |
| if "cpuclusters" in soc: |
| for cluster in soc["cpuclusters"]: |
| cn = cluster.get("name") |
| if cn and cn not in soc_to_clusters[sn]: |
| soc_to_clusters[sn].append(cn) |
| for v in node.values(): |
| find_socs(v) |
| elif isinstance(node, list): |
| for item in node: |
| find_socs(item) |
| |
| find_socs(content) |
| except Exception as e: |
| raise Exception("DEBUG: Failed to parse %s: %s" % (soc_yml_path, e)) |
| return soc_to_clusters |
| |
| def discover_board_variants(board_dirs, soc_to_clusters, symbols): |
| """Discovers board and SoC variants from board.yml files using YAML parsing.""" |
| if yaml is None: |
| return |
| |
| for bdir in board_dirs: |
| for bfile in ["board.yml", "board.yaml"]: |
| bpath = os.path.join(bdir, bfile) |
| if os.path.exists(bpath): |
| try: |
| with open(bpath, "r") as f: |
| content = yaml.load(f, Loader=SafeLoader) |
| |
| if not content: |
| continue |
| |
| # Handle both 'board' (singular) and 'boards' (plural) formats |
| boards = [] |
| if isinstance(content.get("board"), dict): |
| boards.append(content["board"]) |
| if isinstance(content.get("boards"), list): |
| boards.extend(content["boards"]) |
| |
| for board in boards: |
| b_name = board.get("name", "").upper() |
| if not b_name: |
| continue |
| |
| socs = board.get("socs", []) |
| if not isinstance(socs, list): |
| continue |
| |
| for soc in socs: |
| sn_raw = soc.get("name") |
| if not sn_raw: |
| continue |
| |
| sn_upper = sn_raw.upper() |
| base_name = "CONFIG_BOARD_" + kconfig_utils.sanitize_name_for_target(b_name) + "_" + kconfig_utils.sanitize_name_for_target(sn_upper) |
| if base_name not in symbols: |
| symbols[base_name] = "bool" |
| |
| # Add board/soc variants from board.yml |
| variants = soc.get("variants", []) |
| if isinstance(variants, list): |
| for var in variants: |
| vn_raw = var.get("name") |
| if vn_raw: |
| vn_upper = vn_raw.upper() |
| var_name = base_name + "_" + kconfig_utils.sanitize_name_for_target(vn_upper) |
| if var_name not in symbols: |
| symbols[var_name] = "bool" |
| |
| # Add cluster variants |
| if sn_raw in soc_to_clusters: |
| for cn in soc_to_clusters[sn_raw]: |
| full_name = base_name + "_" + kconfig_utils.sanitize_name_for_target(cn.upper()) |
| if full_name not in symbols: |
| symbols[full_name] = "bool" |
| except Exception as e: |
| raise Exception("DEBUG: Failed to parse %s: %s" % (bpath, e)) |
| |
| def setup_kconfig_environment(zephyr_base, tmp_dir, modules=None): |
| """Sets up environment variables required for Kconfig parsing.""" |
| os.environ["ZEPHYR_BASE"] = zephyr_base |
| os.environ["srctree"] = zephyr_base |
| os.environ["KCONFIG_BINARY_DIR"] = tmp_dir |
| os.environ["CMAKE_BINARY_DIR"] = tmp_dir |
| os.environ["HWM_SCHEME"] = "v2" |
| os.environ["KCONFIG_FUNCTIONS"] = "kconfigfunctions" |
| os.environ["TOOLCHAIN_HAS_PICOLIBC"] = "y" |
| os.environ["TOOLCHAIN_HAS_NEWLIB"] = "y" |
| os.environ["ZEPHYR_TOOLCHAIN_VARIANT"] = "zephyr" |
| |
| kconfig_env_file = os.path.join(tmp_dir, "kconfig_module_dirs.env") |
| os.makedirs(tmp_dir, exist_ok=True) |
| with open(kconfig_env_file, "w") as f: |
| if modules: |
| for m in modules: |
| if os.path.isdir(m): |
| module_name = os.path.basename(m.rstrip('/')).split('+')[-1].replace('-', '_').upper() |
| m_abs = os.path.abspath(m) |
| f.write(f"ZEPHYR_{module_name}_MODULE_DIR={m_abs}\n") |
| os.environ[f"ZEPHYR_{module_name}_MODULE_DIR"] = m_abs |
| os.environ["KCONFIG_ENV_FILE"] = kconfig_env_file |
| |
| def generate_kconfig_scaffolding(tmp_dir, zephyr_base, soc_dirs, board_dirs, modules, oot_dts_roots=[]): |
| """Generates the necessary Kconfig tree scaffolding for super-schema parsing.""" |
| os.makedirs(tmp_dir, exist_ok=True) |
| |
| # Generate aggregation files |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "soc", "Kconfig.defconfig"), soc_dirs, "SoC defconfigs") |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "soc", "Kconfig"), soc_dirs, "SoC Kconfigs") |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "soc", "Kconfig.soc"), soc_dirs, "SoC Kconfigs") |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "soc", "Kconfig.sysbuild"), soc_dirs, "SoC sysbuild Kconfigs") |
| |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "boards", "Kconfig.defconfig"), board_dirs, "Board defconfigs") |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "boards", "Kconfig"), board_dirs, "Board Kconfigs", True) |
| kconfig_utils.generate_aggregation_file(os.path.join(tmp_dir, "boards", "Kconfig.sysbuild"), board_dirs, "Board sysbuild Kconfigs") |
| |
| # Mock arch Kconfig (Kconfig.zephyr sources it but we'll loop over archs) |
| os.makedirs(os.path.join(tmp_dir, "arch"), exist_ok=True) |
| with open(os.path.join(tmp_dir, "arch", "Kconfig"), "w") as f: |
| f.write("# Placeholder\n") |
| |
| kconfig_modules = os.path.join(tmp_dir, "Kconfig.modules") |
| kconfig_utils.generate_kconfig_modules(zephyr_base, modules, kconfig_modules) |
| |
| dts_roots = [Path(zephyr_base)] + [Path(m) for m in modules] + [Path(r) for r in oot_dts_roots] |
| kconfig_utils.generate_kconfig_dts(zephyr_base, os.path.join(tmp_dir, "Kconfig.dts"), dts_roots) |
| |
| # Mock currently unsupported parts of the Kconfig tree |
| for f_name in ["Kconfig.sysbuild.modules", "Kconfig.shield", "Kconfig.shield.defconfig"]: |
| with open(os.path.join(tmp_dir, f_name), "w") as f: |
| f.write("# Dummy\n") |
| |
| def parse_kconfig_authoritative(zephyr_base, tmp_dir, archs, symbols, warnings_list): |
| """Uses kconfiglib to perform an authoritative parse for each architecture.""" |
| # kconfiglib is in Zephyr's scripts/kconfig directory, which is added to path by setup_kconfiglib in main. |
| import kconfiglib |
| for arch in archs: |
| try: |
| os.environ["ARCH"] = arch |
| os.environ["BOARD"] = "generic" |
| os.environ["BOARD_QUALIFIERS"] = "" |
| os.environ["SOC_NAME"] = "none" |
| os.environ["KCONFIG_BOARD_DIR"] = tmp_dir |
| |
| # Update arch/Kconfig mock to source the real arch Kconfig |
| with open(os.path.join(tmp_dir, "arch", "Kconfig"), "w") as f: |
| arch_kconfig = os.path.join(zephyr_base, "arch", arch, "Kconfig") |
| if os.path.exists(arch_kconfig): |
| f.write('source "%s"\n' % arch_kconfig) |
| |
| toolchain_arch = "host" if arch == "posix" else "gnuarmemb" if arch == "arm" else "zephyr" |
| toolchain_kconfig_dir = os.path.join(zephyr_base, "cmake", "toolchain", toolchain_arch) |
| if not os.path.exists(toolchain_kconfig_dir): |
| toolchain_kconfig_dir = os.path.join(zephyr_base, "cmake", "toolchain", "zephyr") |
| os.environ["TOOLCHAIN_KCONFIG_DIR"] = toolchain_kconfig_dir |
| |
| kconf_path = os.path.join(zephyr_base, "Kconfig") |
| kconf = kconfiglib.Kconfig(kconf_path) |
| if kconf.warnings: |
| for warning in kconf.warnings: |
| print("\n" + warning, file=sys.stderr) |
| warnings_list.append(warning) |
| print("\nWarnings detected during Kconfig parsing, proceeding anyway.", file=sys.stderr) |
| |
| for name, sym in kconf.syms.items(): |
| if sym.type == kconfiglib.UNKNOWN: continue |
| full_name = "CONFIG_" + kconfig_utils.sanitize_name_for_target(name) |
| stype = "bool" |
| if sym.type in [kconfiglib.INT, kconfiglib.HEX]: stype = "int" |
| elif sym.type == kconfiglib.STRING: stype = "string" |
| |
| if full_name not in symbols or (stype != "bool" and symbols[full_name] == "bool"): |
| symbols[full_name] = stype |
| except Exception as e: |
| print("DEBUG: Exception parsing arch %s: %s" % (arch, e), file=sys.stderr) |
| pass |
| |
| def scan_files_for_dynamic_symbols(zephyr_base, board_dirs, modules, symbols): |
| """Scans files for symbols that might not be visible in the static Kconfig tree.""" |
| search_dirs = [zephyr_base] + list(board_dirs) + list(modules) |
| for d in search_dirs: |
| if not os.path.isdir(d): continue |
| for root, _, files in os.walk(d, followlinks=True): |
| for fname in files: |
| if fname == "Kconfig" or fname.startswith("Kconfig."): |
| try: |
| with open(os.path.join(root, fname), "r", errors="ignore") as f: |
| content = f.read() |
| # config/choice |
| for match in re.finditer(r"^\s*(?:menu)?(?:config|choice)\s+([a-zA-Z0-9_.-]+)", content, re.MULTILINE): |
| name = match.group(1) |
| if name == "MODULES": continue |
| full_name = "CONFIG_" + kconfig_utils.sanitize_name_for_target(name) |
| |
| # Look ahead for type |
| start = match.end() |
| next_match = re.search(r"^\s*(?:menu)?(?:config|choice)\s+", content[start:], re.MULTILINE) |
| end = start + next_match.start() if next_match else len(content) |
| block = content[start:end] |
| |
| stype = None |
| if re.search(r"^\s*int\b", block, re.MULTILINE): stype = "int" |
| elif re.search(r"^\s*hex\b", block, re.MULTILINE): stype = "int" |
| elif re.search(r"^\s*string\b", block, re.MULTILINE): stype = "string" |
| elif re.search(r"^\s*bool\b", block, re.MULTILINE): stype = "bool" |
| |
| if stype: |
| if full_name not in symbols: |
| symbols[full_name] = stype |
| else: |
| existing_type = symbols[full_name] |
| if existing_type != stype: |
| raise Exception(f"Conflict: Symbol {full_name} defined with types '{existing_type}' and '{stype}'") |
| else: |
| if full_name not in symbols: |
| symbols[full_name] = "bool" |
| |
| # Logging Template expansion |
| if 'subsys/logging/Kconfig.template.log_config' in content: |
| mod_match = re.search(r"module\s*=\s*([a-zA-Z0-9_]+)", content) |
| if mod_match: |
| mod_name = mod_match.group(1) |
| for suffix in ["_LOG_LEVEL_OFF", "_LOG_LEVEL_ERR", "_LOG_LEVEL_WRN", "_LOG_LEVEL_INF", "_LOG_LEVEL_DBG", "_LOG_LEVEL_DEFAULT", "_LOG_LEVEL"]: |
| full_name = "CONFIG_" + mod_name + suffix |
| if full_name not in symbols: |
| symbols[full_name] = "bool" if suffix != "_LOG_LEVEL" else "int" |
| except: |
| pass |
| |
| def write_bazel_build_file(output_file, symbols): |
| """Writes the discovered symbols into a BUILD.bazel file as Bazel flags.""" |
| with open(output_file, "w") as f: |
| f.write('load("@bazel_skylib//rules:common_settings.bzl", "bool_flag", "int_flag", "string_flag")\n') |
| f.write('load("@rules_cc//cc:defs.bzl", "cc_library")\n') |
| f.write('load("@zephyr//:cc.bzl", "zephyr_cc_library")\n\n') |
| f.write('package(default_visibility = ["//visibility:public"])\n\n') |
| f.write('exports_files(["local_modules.bzl"])\n\n') |
| f.write('zephyr_cc_library(\n') |
| f.write(' name = "kconfig_warnings",\n') |
| f.write(' srcs = ["kconfig_warnings.c"],\n') |
| f.write(')\n\n') |
| |
| for name in sorted(symbols.keys()): |
| stype = symbols[name] |
| if stype == "bool": |
| f.write('bool_flag(name = "%s", build_setting_default = False)\n' % name) |
| f.write('config_setting(name = "%s=true", flag_values = {":%s": "true"})\n' % (name, name)) |
| f.write('config_setting(name = "%s=false", flag_values = {":%s": "false"})\n' % (name, name)) |
| elif stype == "int": |
| f.write('int_flag(name = "%s", build_setting_default = 0)\n' % name) |
| f.write('config_setting(name = "%s=0", flag_values = {":%s": "0"})\n' % (name, name)) |
| else: |
| f.write('string_flag(name = "%s", build_setting_default = "")\n' % name) |
| |
| def main(): |
| args = parse_args() |
| kconfig_utils.setup_kconfiglib(args.zephyr_base) |
| |
| zephyr_base = os.path.abspath(args.zephyr_base) |
| tmp_dir = os.path.abspath("kconfig_bin") |
| symbols = {} |
| |
| # 1. Discover all hardware |
| soc_dirs = find_soc_source_directories(zephyr_base, args.modules) |
| board_roots = [os.path.join(zephyr_base, 'boards')] + args.board_dirs |
| board_dirs = find_board_source_directories(board_roots) |
| |
| soc_to_clusters = get_soc_to_clusters(soc_dirs) |
| discover_board_variants(board_dirs, soc_to_clusters, symbols) |
| |
| arch_root = os.path.join(zephyr_base, "arch") |
| archs = [d for d in os.listdir(arch_root) if os.path.isdir(os.path.join(arch_root, d))] |
| |
| # 2. Setup environment and scaffolding |
| setup_kconfig_environment(zephyr_base, tmp_dir, args.modules) |
| generate_kconfig_scaffolding(tmp_dir, zephyr_base, soc_dirs, board_dirs, args.modules, args.oot_dts_roots) |
| |
| # 3. Authoritative Parse using kconfiglib |
| all_warnings = [] |
| parse_kconfig_authoritative(zephyr_base, tmp_dir, archs, symbols, all_warnings) |
| |
| # Generate kconfig_warnings.c |
| output_dir = os.path.dirname(os.path.abspath(args.output)) |
| with open(os.path.join(output_dir, "kconfig_warnings.c"), "w") as f: |
| f.write("/* AUTO-GENERATED by kconfig_gen_symbols.py, do not edit! */\n\n") |
| if all_warnings: |
| for warning in all_warnings: |
| msg = warning.replace('"', '\\"').replace('\n', ' ') |
| f.write(f'#warning "Kconfig warning: {msg}"\n') |
| else: |
| f.write("/* No Kconfig warnings */\n") |
| |
| # 4. Fallback: Scan files for dynamic symbols |
| scan_files_for_dynamic_symbols(zephyr_base, args.board_dirs, args.modules, symbols) |
| |
| # 5. Generate BUILD.bazel |
| write_bazel_build_file(args.output, symbols) |
| |
| |
| if __name__ == "__main__": |
| main() |
