// SPDX-License-Identifier: GPL-2.0 //! The custom target specification file generator for `rustc`.//!//! To configure a target from scratch, a JSON-encoded file has to be passed//! to `rustc` (introduced in [RFC 131]). These options and the file itself are//! unstable. Eventually, `rustc` should provide a way to do this in a stable//! manner. For instance, via command-line arguments. Therefore, this file//! should avoid using keys which can be set via `-C` or `-Z` options.//!//! [RFC 131]: https://rust-lang.github.io/rfcs/0131-target-specification.html use std::{ collections::HashMap, fmt::{Display, Formatter, Result}, io::BufRead,}; enum Value { Boolean(bool), Number(i32), String(String), Object(Object),} type Object = Vec<(String, Value)>; /// Minimal "almost JSON" generator (e.g. no `null`s, no arrays, no escaping),/// enough for this purpose.impl Display for Value { fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { match self { Value::Boolean(boolean) => write!(formatter, "{}", boolean), Value::Number(number) => write!(formatter, "{}", number), Value::String(string) => write!(formatter, "\"{}\"", string), Value::Object(object) => { formatter.write_str("{")?; if let [ref rest @ .., ref last] = object[..] { for (key, value) in rest { write!(formatter, "\"{}\": {},", key, value)?; } write!(formatter, "\"{}\": {}", last.0, last.1)?; } formatter.write_str("}") } } }} struct TargetSpec(Object); impl TargetSpec { fn new() -> TargetSpec { TargetSpec(Vec::new()) }} trait Push<T> { fn push(&mut self, key: &str, value: T);} impl Push<bool> for TargetSpec { fn push(&mut self, key: &str, value: bool) { self.0.push((key.to_string(), Value::Boolean(value))); }} impl Push<i32> for TargetSpec { fn push(&mut self, key: &str, value: i32) { self.0.push((key.to_string(), Value::Number(value))); }} impl Push<String> for TargetSpec { fn push(&mut self, key: &str, value: String) { self.0.push((key.to_string(), Value::String(value))); }} impl Push<&str> for TargetSpec { fn push(&mut self, key: &str, value: &str) { self.push(key, value.to_string()); }} impl Push<Object> for TargetSpec { fn push(&mut self, key: &str, value: Object) { self.0.push((key.to_string(), Value::Object(value))); }} impl Display for TargetSpec { fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { // We add some newlines for clarity. formatter.write_str("{\n")?; if let [ref rest @ .., ref last] = self.0[..] { for (key, value) in rest { write!(formatter, " \"{}\": {},\n", key, value)?; } write!(formatter, " \"{}\": {}\n", last.0, last.1)?; } formatter.write_str("}") }} struct KernelConfig(HashMap<String, String>); impl KernelConfig { /// Parses `include/config/auto.conf` from `stdin`. fn from_stdin() -> KernelConfig { let mut result = HashMap::new(); let stdin = std::io::stdin(); let mut handle = stdin.lock(); let mut line = String::new(); loop { line.clear(); if handle.read_line(&mut line).unwrap() == 0 { break; } if line.starts_with('#') { continue; } let (key, value) = line.split_once('=').expect("Missing `=` in line."); result.insert(key.to_string(), value.trim_end_matches('\n').to_string()); } KernelConfig(result) } /// Does the option exist in the configuration (any value)? /// /// The argument must be passed without the `CONFIG_` prefix. /// This avoids repetition and it also avoids `fixdep` making us /// depend on it. fn has(&self, option: &str) -> bool { let option = "CONFIG_".to_owned() + option; self.0.contains_key(&option) }} fn main() { let cfg = KernelConfig::from_stdin(); let mut ts = TargetSpec::new(); // `llvm-target`s are taken from `scripts/Makefile.clang`. if cfg.has("ARM64") { panic!("arm64 uses the builtin rustc aarch64-unknown-none target"); } else if cfg.has("RISCV") { if cfg.has("64BIT") { panic!("64-bit RISC-V uses the builtin rustc riscv64-unknown-none-elf target"); } else { panic!("32-bit RISC-V is an unsupported architecture"); } } else if cfg.has("X86_64") { ts.push("arch", "x86_64"); ts.push( "data-layout", "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", ); let mut features = "-mmx,+soft-float".to_string(); if cfg.has("MITIGATION_RETPOLINE") { features += ",+retpoline-external-thunk"; } ts.push("features", features); ts.push("llvm-target", "x86_64-linux-gnu"); ts.push("target-pointer-width", "64"); } else if cfg.has("X86_32") { // This only works on UML, as i386 otherwise needs regparm support in rustc if !cfg.has("UML") { panic!("32-bit x86 only works under UML"); } ts.push("arch", "x86"); ts.push( "data-layout", "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128", ); let mut features = "-mmx,+soft-float".to_string(); if cfg.has("MITIGATION_RETPOLINE") { features += ",+retpoline-external-thunk"; } ts.push("features", features); ts.push("llvm-target", "i386-unknown-linux-gnu"); ts.push("target-pointer-width", "32"); } else if cfg.has("LOONGARCH") { panic!("loongarch uses the builtin rustc loongarch64-unknown-none-softfloat target"); } else { panic!("Unsupported architecture"); } ts.push("emit-debug-gdb-scripts", false); ts.push("frame-pointer", "may-omit"); ts.push( "stack-probes", vec![("kind".to_string(), Value::String("none".to_string()))], ); // Everything else is LE, whether `CPU_LITTLE_ENDIAN` is declared or not // (e.g. x86). It is also `rustc`'s default. if cfg.has("CPU_BIG_ENDIAN") { ts.push("target-endian", "big"); } println!("{}", ts);}
// SPDX-License-Identifier: GPL-2.0
//! The custom target specification file generator for `rustc`.
//!
//! To configure a target from scratch, a JSON-encoded file has to be passed
//! to `rustc` (introduced in [RFC 131]). These options and the file itself are
//! unstable. Eventually, `rustc` should provide a way to do this in a stable
//! manner. For instance, via command-line arguments. Therefore, this file
//! should avoid using keys which can be set via `-C` or `-Z` options.
//!
//! [RFC 131]: https://rust-lang.github.io/rfcs/0131-target-specification.html
use std::{
collections::HashMap,
fmt::{Display, Formatter, Result},
io::BufRead,
};
enum Value {
Boolean(bool),
Number(i32),
String(String),
Object(Object),
}
type Object = Vec<(String, Value)>;
/// Minimal "almost JSON" generator (e.g. no `null`s, no arrays, no escaping),
/// enough for this purpose.
impl Display for Value {
fn fmt(&self, formatter: &mut Formatter<'_>) -> Result {
match self {
Value::Boolean(boolean) => write!(formatter, "{}", boolean),
Value::Number(number) => write!(formatter, "{}", number),
Value::String(string) => write!(formatter, "\"{}\"", string),
Value::Object(object) => {
formatter.write_str("{")?;
if let [ref rest @ .., ref last] = object[..] {
for (key, value) in rest {
write!(formatter, "\"{}\": {},", key, value)?;
}
write!(formatter, "\"{}\": {}", last.0, last.1)?;
}
formatter.write_str("}")
}
}
}
}
struct TargetSpec(Object);
impl TargetSpec {
fn new() -> TargetSpec {
TargetSpec(Vec::new())
}
}
trait Push<T> {
fn push(&mut self, key: &str, value: T);
}
impl Push<bool> for TargetSpec {
fn push(&mut self, key: &str, value: bool) {
self.0.push((key.to_string(), Value::Boolean(value)));
}
}
impl Push<i32> for TargetSpec {
fn push(&mut self, key: &str, value: i32) {
self.0.push((key.to_string(), Value::Number(value)));
}
}
impl Push<String> for TargetSpec {
fn push(&mut self, key: &str, value: String) {
self.0.push((key.to_string(), Value::String(value)));
}
}
impl Push<&str> for TargetSpec {
fn push(&mut self, key: &str, value: &str) {
self.push(key, value.to_string());
}
}
impl Push<Object> for TargetSpec {
fn push(&mut self, key: &str, value: Object) {
self.0.push((key.to_string(), Value::Object(value)));
}
}
impl Display for TargetSpec {
fn fmt(&self, formatter: &mut Formatter<'_>) -> Result {
// We add some newlines for clarity.
formatter.write_str("{\n")?;
if let [ref rest @ .., ref last] = self.0[..] {
for (key, value) in rest {
write!(formatter, " \"{}\": {},\n", key, value)?;
}
write!(formatter, " \"{}\": {}\n", last.0, last.1)?;
}
formatter.write_str("}")
}
}
struct KernelConfig(HashMap<String, String>);
impl KernelConfig {
/// Parses `include/config/auto.conf` from `stdin`.
fn from_stdin() -> KernelConfig {
let mut result = HashMap::new();
let stdin = std::io::stdin();
let mut handle = stdin.lock();
let mut line = String::new();
loop {
line.clear();
if handle.read_line(&mut line).unwrap() == 0 {
break;
}
if line.starts_with('#') {
continue;
}
let (key, value) = line.split_once('=').expect("Missing `=` in line.");
result.insert(key.to_string(), value.trim_end_matches('\n').to_string());
}
KernelConfig(result)
}
/// Does the option exist in the configuration (any value)?
///
/// The argument must be passed without the `CONFIG_` prefix.
/// This avoids repetition and it also avoids `fixdep` making us
/// depend on it.
fn has(&self, option: &str) -> bool {
let option = "CONFIG_".to_owned() + option;
self.0.contains_key(&option)
}
}
fn main() {
let cfg = KernelConfig::from_stdin();
let mut ts = TargetSpec::new();
// `llvm-target`s are taken from `scripts/Makefile.clang`.
if cfg.has("ARM64") {
panic!("arm64 uses the builtin rustc aarch64-unknown-none target");
} else if cfg.has("RISCV") {
if cfg.has("64BIT") {
panic!("64-bit RISC-V uses the builtin rustc riscv64-unknown-none-elf target");
} else {
panic!("32-bit RISC-V is an unsupported architecture");
}
} else if cfg.has("X86_64") {
ts.push("arch", "x86_64");
ts.push(
"data-layout",
"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
);
let mut features = "-mmx,+soft-float".to_string();
if cfg.has("MITIGATION_RETPOLINE") {
features += ",+retpoline-external-thunk";
}
ts.push("features", features);
ts.push("llvm-target", "x86_64-linux-gnu");
ts.push("target-pointer-width", "64");
} else if cfg.has("X86_32") {
// This only works on UML, as i386 otherwise needs regparm support in rustc
if !cfg.has("UML") {
panic!("32-bit x86 only works under UML");
}
ts.push("arch", "x86");
ts.push(
"data-layout",
"e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128",
);
let mut features = "-mmx,+soft-float".to_string();
if cfg.has("MITIGATION_RETPOLINE") {
features += ",+retpoline-external-thunk";
}
ts.push("features", features);
ts.push("llvm-target", "i386-unknown-linux-gnu");
ts.push("target-pointer-width", "32");
} else if cfg.has("LOONGARCH") {
panic!("loongarch uses the builtin rustc loongarch64-unknown-none-softfloat target");
} else {
panic!("Unsupported architecture");
}
ts.push("emit-debug-gdb-scripts", false);
ts.push("frame-pointer", "may-omit");
ts.push(
"stack-probes",
vec![("kind".to_string(), Value::String("none".to_string()))],
);
// Everything else is LE, whether `CPU_LITTLE_ENDIAN` is declared or not
// (e.g. x86). It is also `rustc`'s default.
if cfg.has("CPU_BIG_ENDIAN") {
ts.push("target-endian", "big");
}
println!("{}", ts);
}