mirror of
https://github.com/RT-Thread/rt-thread.git
synced 2026-10-02 14:23:19 +08:00
yan hu
30af7388a4
Improve the Rust build integration across core, applications, components, and module examples. Fix build failure propagation, target and feature handling, linker flags, example configuration semantics, and add STM32 CI attach coverage.
374 lines
14 KiB
Python
374 lines
14 KiB
Python
import os
|
||
import subprocess
|
||
|
||
|
||
def _parse_cflags(cflags: str):
|
||
info = {
|
||
"march": None,
|
||
"mabi": None,
|
||
"rv_bits": None, # 32 or 64
|
||
"has_f": False,
|
||
"has_d": False,
|
||
}
|
||
|
||
if not cflags:
|
||
return info
|
||
|
||
parts = cflags.split()
|
||
for flag in parts:
|
||
if flag.startswith("-march="):
|
||
info["march"] = flag.split("=", 1)[1]
|
||
if "rv32" in info["march"]:
|
||
info["rv_bits"] = 32
|
||
elif "rv64" in info["march"]:
|
||
info["rv_bits"] = 64
|
||
# crude feature detection
|
||
m = info["march"]
|
||
if m:
|
||
info["has_f"] = ("f" in m)
|
||
info["has_d"] = ("d" in m)
|
||
elif flag.startswith("-mabi="):
|
||
info["mabi"] = flag.split("=", 1)[1]
|
||
if info["mabi"] in ("ilp32d", "ilp32f", "lp64d", "lp64f"):
|
||
# floating-point ABI implies FPU availability
|
||
info["has_f"] = True
|
||
info["has_d"] = info["mabi"].endswith("d")
|
||
|
||
return info
|
||
|
||
|
||
def detect_rust_target(has, rtconfig):
|
||
"""
|
||
Decide the Rust target triple based on RT-Thread Kconfig and rtconfig.*.
|
||
`has` is a callable: has("SYMBOL") -> bool
|
||
"""
|
||
# ARM Cortex-M
|
||
if has("ARCH_ARM"):
|
||
# FPU hints from flags/macros
|
||
cflags = getattr(rtconfig, "CFLAGS", "")
|
||
hard_float = "-mfloat-abi=hard" in cflags or has("ARCH_ARM_FPU") or has("ARCH_FPU_VFP")
|
||
|
||
if has("ARCH_ARM_CORTEX_M0") or has("ARCH_ARM_CORTEX_M0PLUS"):
|
||
return "thumbv6m-none-eabi"
|
||
if has("ARCH_ARM_CORTEX_M3"):
|
||
return "thumbv7m-none-eabi"
|
||
if has("ARCH_ARM_CORTEX_M4") or has("ARCH_ARM_CORTEX_M7"):
|
||
return "thumbv7em-none-eabihf" if hard_float else "thumbv7em-none-eabi"
|
||
if has("ARCH_ARM_CORTEX_M23"):
|
||
return "thumbv8m.base-none-eabi"
|
||
if has("ARCH_ARM_CORTEX_M33"):
|
||
# v8m.main
|
||
return "thumbv8m.main-none-eabi"
|
||
if has("ARCH_ARM_CORTEX_A"):
|
||
return "armv7a-none-eabi"
|
||
|
||
# AArch64
|
||
if has("ARCH_AARCH64") or has("ARCH_ARMV8") or has("ARCH_ARM64"):
|
||
if has("ARCH_CPU_FLOAT_ABI_SOFT"):
|
||
return "aarch64-unknown-none-softfloat"
|
||
return "aarch64-unknown-none"
|
||
|
||
# RISC-V
|
||
if has("ARCH_RISCV32") or has("ARCH_RISCV64"):
|
||
cflags = getattr(rtconfig, "CFLAGS", "")
|
||
info = _parse_cflags(cflags)
|
||
|
||
# fallback to Kconfig hint if march not present
|
||
rv_bits = info["rv_bits"] or (32 if has("ARCH_RISCV32") else 64)
|
||
|
||
# ABI must carry f/d to actually use hard-float calling convention
|
||
abi = info["mabi"] or ""
|
||
abi_has_fp = abi.endswith("f") or abi.endswith("d")
|
||
|
||
if rv_bits == 32:
|
||
# Only pick *f* target when ABI uses hard-float; otherwise use soft-float even if core has F/D
|
||
return "riscv32imafc-unknown-none-elf" if abi_has_fp else "riscv32imac-unknown-none-elf"
|
||
else:
|
||
# rv64: prefer gc (includes fd) only when ABI uses hard-float
|
||
return "riscv64gc-unknown-none-elf" if abi_has_fp else "riscv64imac-unknown-none-elf"
|
||
|
||
# Fallback by ARCH string or CFLAGS
|
||
arch = getattr(rtconfig, "ARCH", None)
|
||
if arch:
|
||
arch_l = arch.lower()
|
||
if "aarch64" in arch_l:
|
||
return "aarch64-unknown-none"
|
||
if "arm" == arch_l or "armv7" in arch_l:
|
||
return "armv7a-none-eabi"
|
||
if "riscv32" in arch_l:
|
||
return "riscv32imac-unknown-none-elf"
|
||
if "riscv64" in arch_l:
|
||
return "riscv64imac-unknown-none-elf"
|
||
if "risc-v" in arch_l:
|
||
info = _parse_cflags(getattr(rtconfig, "CFLAGS", ""))
|
||
abi = info["mabi"] or ""
|
||
abi_has_fp = abi.endswith("f") or abi.endswith("d")
|
||
if info["rv_bits"] == 32:
|
||
return "riscv32imafc-unknown-none-elf" if abi_has_fp else "riscv32imac-unknown-none-elf"
|
||
if info["rv_bits"] == 64:
|
||
return "riscv64gc-unknown-none-elf" if abi_has_fp else "riscv64imac-unknown-none-elf"
|
||
# Many BSPs use "risc-v" token; assume 64-bit for virt64 when CFLAGS do not specify width
|
||
return "riscv64imac-unknown-none-elf"
|
||
|
||
# Parse CFLAGS for hints
|
||
cflags = getattr(rtconfig, "CFLAGS", "")
|
||
if "-mcpu=cortex-m3" in cflags:
|
||
return "thumbv7m-none-eabi"
|
||
if "-mcpu=cortex-m4" in cflags or "-mcpu=cortex-m7" in cflags:
|
||
if "-mfpu=" in cflags and "-mfloat-abi=hard" in cflags:
|
||
return "thumbv7em-none-eabihf"
|
||
return "thumbv7em-none-eabi"
|
||
if "-march=rv32" in cflags:
|
||
info = _parse_cflags(cflags)
|
||
abi = info["mabi"] or ""
|
||
abi_has_fp = abi.endswith("f") or abi.endswith("d")
|
||
return "riscv32imafc-unknown-none-elf" if abi_has_fp else "riscv32imac-unknown-none-elf"
|
||
if "-march=rv64" in cflags:
|
||
info = _parse_cflags(cflags)
|
||
abi = info["mabi"] or ""
|
||
abi_has_fp = abi.endswith("f") or abi.endswith("d")
|
||
if abi_has_fp:
|
||
return "riscv64gc-unknown-none-elf"
|
||
return "riscv64imac-unknown-none-elf"
|
||
|
||
return None
|
||
|
||
|
||
def uses_short_wchar_abi(rtconfig, target: str):
|
||
if not isinstance(target, str) or not target:
|
||
return False
|
||
if not (target.startswith("thumb") or target.startswith("arm")):
|
||
return False
|
||
|
||
cflags = getattr(rtconfig, "CFLAGS", "")
|
||
return "-fshort-wchar" in cflags.split()
|
||
|
||
|
||
def make_cargo_build_std_args(rtconfig, target: str):
|
||
if uses_short_wchar_abi(rtconfig, target):
|
||
return ["-Z", "build-std=core,alloc"]
|
||
return []
|
||
|
||
|
||
def make_rustflags(rtconfig, target: str):
|
||
if not isinstance(target, str) or not target:
|
||
arch = getattr(rtconfig, "ARCH", None)
|
||
cflags = getattr(rtconfig, "CFLAGS", "")
|
||
raise ValueError(
|
||
"Unsupported Rust target: unable to detect a Rust target "
|
||
f"for ARCH={arch!r}, CFLAGS={cflags!r}"
|
||
)
|
||
|
||
rustflags = [
|
||
"-C", "opt-level=z",
|
||
"-C", "panic=abort",
|
||
"-C", "relocation-model=static",
|
||
]
|
||
|
||
if "riscv" in target:
|
||
rustflags += [
|
||
"-C", "code-model=medium",
|
||
"-C", "link-dead-code",
|
||
]
|
||
# propagate march/mabi for consistency (use link-arg for staticlib builds – harmless)
|
||
cflags = getattr(rtconfig, "CFLAGS", "")
|
||
for flag in cflags.split():
|
||
if flag.startswith("-march=") or flag.startswith("-mabi="):
|
||
rustflags += ["-C", f"link-arg={flag}"]
|
||
|
||
if "thumb" in target or "aarch64" in target:
|
||
rustflags += ["-C", "link-arg=-nostartfiles"]
|
||
|
||
if uses_short_wchar_abi(rtconfig, target):
|
||
rustflags += ["-Zllvm_module_flag=wchar_size:u32:2:error"]
|
||
|
||
return " ".join(rustflags)
|
||
|
||
|
||
def collect_features(has):
|
||
cargo_toml_path = os.path.abspath(
|
||
os.path.join(os.path.dirname(__file__), "..", "core", "Cargo.toml")
|
||
)
|
||
if not os.path.isfile(cargo_toml_path):
|
||
raise RuntimeError(f"Rust core Cargo.toml not found: {cargo_toml_path}")
|
||
|
||
try:
|
||
import toml
|
||
except ImportError as e:
|
||
raise RuntimeError("Missing toml module required to parse Rust core Cargo.toml") from e
|
||
|
||
try:
|
||
with open(cargo_toml_path, "r") as f:
|
||
cargo_data = toml.load(f)
|
||
except OSError as e:
|
||
raise RuntimeError(f"Failed to read Rust core Cargo.toml {cargo_toml_path}: {e}") from e
|
||
except Exception as e:
|
||
raise RuntimeError(f"Failed to parse Rust core Cargo.toml {cargo_toml_path}: {e}") from e
|
||
|
||
declared_features = cargo_data.get("features")
|
||
if not isinstance(declared_features, dict):
|
||
raise RuntimeError("Invalid Rust core Cargo.toml: [features] must be a table")
|
||
|
||
package = cargo_data.get("package")
|
||
metadata = package.get("metadata") if isinstance(package, dict) else None
|
||
rt_thread = metadata.get("rt-thread") if isinstance(metadata, dict) else None
|
||
feature_mappings = rt_thread.get("features") if isinstance(rt_thread, dict) else None
|
||
if not isinstance(feature_mappings, dict):
|
||
raise RuntimeError(
|
||
"Invalid Rust core feature metadata: package.metadata.rt-thread.features must be a table"
|
||
)
|
||
|
||
for feature in feature_mappings:
|
||
if feature not in declared_features:
|
||
raise RuntimeError(
|
||
f"Rust core feature metadata references undeclared Cargo feature: {feature}"
|
||
)
|
||
|
||
feats = []
|
||
for feature in declared_features:
|
||
if feature == "default" or feature not in feature_mappings:
|
||
continue
|
||
|
||
mapping = feature_mappings[feature]
|
||
if not isinstance(mapping, dict):
|
||
raise RuntimeError(f"Invalid Rust core feature metadata for '{feature}': expected a table")
|
||
if set(mapping) != {"all"}:
|
||
raise RuntimeError(
|
||
f"Invalid Rust core feature metadata for '{feature}': only 'all' is supported"
|
||
)
|
||
|
||
symbols = mapping["all"]
|
||
if not isinstance(symbols, list):
|
||
raise RuntimeError(f"Invalid Rust core feature metadata for '{feature}': 'all' must be a list")
|
||
if not symbols:
|
||
raise RuntimeError(f"Invalid Rust core feature metadata for '{feature}': 'all' must not be empty")
|
||
if any(not isinstance(symbol, str) or not symbol for symbol in symbols):
|
||
raise RuntimeError(
|
||
f"Invalid Rust core feature metadata for '{feature}': 'all' must contain only non-empty strings"
|
||
)
|
||
|
||
if all(has(symbol) for symbol in symbols):
|
||
feats.append(feature)
|
||
return feats
|
||
|
||
|
||
def verify_rust_toolchain():
|
||
try:
|
||
r1 = subprocess.run(["rustc", "--version"], capture_output=True, text=True)
|
||
r2 = subprocess.run(["cargo", "--version"], capture_output=True, text=True)
|
||
return r1.returncode == 0 and r2.returncode == 0
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def parse_installed_rust_targets(output):
|
||
return {line.strip() for line in output.splitlines() if line.strip()}
|
||
|
||
|
||
def get_staticlib_artifact_name(rust_dir):
|
||
cargo_toml_path = os.path.join(rust_dir, "Cargo.toml")
|
||
lib_name = "rt_rust"
|
||
|
||
try:
|
||
import toml
|
||
with open(cargo_toml_path, "r") as f:
|
||
cargo_data = toml.load(f)
|
||
|
||
package_name = cargo_data.get("package", {}).get("name")
|
||
lib_name = cargo_data.get("lib", {}).get("name") or package_name or lib_name
|
||
except Exception as e:
|
||
print(f"Warning: Failed to parse Rust static library metadata from {cargo_toml_path}: {e}")
|
||
|
||
if not isinstance(lib_name, str) or not lib_name:
|
||
lib_name = "rt_rust"
|
||
|
||
lib_name = lib_name.replace("-", "_")
|
||
return f"lib{lib_name}.a"
|
||
|
||
|
||
def get_staticlib_link_name(rust_dir):
|
||
cargo_toml_path = os.path.join(rust_dir, "Cargo.toml")
|
||
lib_name = "rt_rust"
|
||
|
||
try:
|
||
import toml
|
||
with open(cargo_toml_path, "r") as f:
|
||
cargo_data = toml.load(f)
|
||
|
||
package_name = cargo_data.get("package", {}).get("name")
|
||
lib_name = cargo_data.get("lib", {}).get("name") or package_name or lib_name
|
||
except Exception as e:
|
||
print(f"Warning: Failed to parse Rust static library metadata from {cargo_toml_path}: {e}")
|
||
|
||
if not isinstance(lib_name, str) or not lib_name:
|
||
lib_name = "rt_rust"
|
||
|
||
return lib_name.replace("-", "_")
|
||
|
||
|
||
def ensure_rust_target_installed(target: str):
|
||
if not isinstance(target, str) or not target:
|
||
print("Invalid Rust target: expected a non-empty string")
|
||
return False
|
||
|
||
try:
|
||
result = subprocess.run(["rustup", "target", "list", "--installed"], capture_output=True, text=True)
|
||
installed_targets = parse_installed_rust_targets(result.stdout)
|
||
if result.returncode == 0 and target in installed_targets:
|
||
return True
|
||
print(f"Rust target '{target}' is not installed.")
|
||
print(f"Please install it with: rustup target add {target}")
|
||
except Exception:
|
||
print("Warning: Failed to check rustup target list (rustup missing?)")
|
||
return False
|
||
|
||
|
||
def cargo_build_staticlib(rust_dir: str, target: str, features, debug: bool, rustflags: str = None, build_root: str = None, cargo_extra_args=None):
|
||
if build_root is None:
|
||
build_root = os.path.join((os.path.abspath(os.path.join(rust_dir, os.pardir, os.pardir))), "build", "rust")
|
||
else:
|
||
build_root = os.path.abspath(os.fspath(build_root))
|
||
target_dir = os.path.join(build_root, "target")
|
||
os.makedirs(build_root, exist_ok=True)
|
||
|
||
env = os.environ.copy()
|
||
if rustflags:
|
||
prev = env.get("RUSTFLAGS", "").strip()
|
||
env["RUSTFLAGS"] = (prev + " " + rustflags).strip() if prev else rustflags
|
||
env["CARGO_TARGET_DIR"] = target_dir
|
||
|
||
cmd = ["cargo", "build", "--target", target, "--manifest-path", os.path.join(rust_dir, "Cargo.toml")]
|
||
if not debug:
|
||
cmd.insert(2, "--release")
|
||
if cargo_extra_args:
|
||
cmd[2:2] = cargo_extra_args
|
||
if features:
|
||
cmd += ["--no-default-features", "--features", ",".join(features)]
|
||
|
||
print("Building Rust component (cargo)…")
|
||
try:
|
||
res = subprocess.run(cmd, cwd=rust_dir, env=env, capture_output=True, text=True)
|
||
except FileNotFoundError:
|
||
print("Error: cargo executable not found. Please install Rust/Cargo and ensure it is in PATH.")
|
||
return None
|
||
if res.returncode != 0:
|
||
print("Warning: Rust build failed")
|
||
if res.stderr:
|
||
print(res.stderr)
|
||
return None
|
||
|
||
mode = "debug" if debug else "release"
|
||
artifact_name = get_staticlib_artifact_name(rust_dir)
|
||
lib_path = os.path.join(target_dir, target, mode, artifact_name)
|
||
if os.path.isfile(lib_path) and os.path.getsize(lib_path) > 0:
|
||
print("Rust component built successfully")
|
||
return lib_path
|
||
print(f"Warning: Rust static library artifact not found, is not a file, or is empty: {lib_path}")
|
||
return None
|
||
|
||
|
||
def clean_rust_build(bsp_root: str, artifact_type: str = "rust"):
|
||
"""Return the build directory path for SCons Clean operation"""
|
||
build_dir = os.path.join(bsp_root, "build", artifact_type)
|
||
return build_dir
|