1 | // SPDX-License-Identifier: GPL-2.0 |
2 | |
3 | //! The custom target specification file generator for `rustc`. |
4 | //! |
5 | //! To configure a target from scratch, a JSON-encoded file has to be passed |
6 | //! to `rustc` (introduced in [RFC 131]). These options and the file itself are |
7 | //! unstable. Eventually, `rustc` should provide a way to do this in a stable |
8 | //! manner. For instance, via command-line arguments. Therefore, this file |
9 | //! should avoid using keys which can be set via `-C` or `-Z` options. |
10 | //! |
11 | //! [RFC 131]: https://rust-lang.github.io/rfcs/0131-target-specification.html |
12 | |
13 | use std::{ |
14 | collections::HashMap, |
15 | fmt::{Display, Formatter, Result}, |
16 | io::BufRead, |
17 | }; |
18 | |
19 | enum Value { |
20 | Boolean(bool), |
21 | Number(i32), |
22 | String(String), |
23 | Object(Object), |
24 | } |
25 | |
26 | type Object = Vec<(String, Value)>; |
27 | |
28 | /// Minimal "almost JSON" generator (e.g. no `null`s, no arrays, no escaping), |
29 | /// enough for this purpose. |
30 | impl Display for Value { |
31 | fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { |
32 | match self { |
33 | Value::Boolean(boolean) => write!(formatter, "{}" , boolean), |
34 | Value::Number(number) => write!(formatter, "{}" , number), |
35 | Value::String(string) => write!(formatter, "\"{}\"" , string), |
36 | Value::Object(object) => { |
37 | formatter.write_str("{" )?; |
38 | if let [ref rest @ .., ref last] = object[..] { |
39 | for (key, value) in rest { |
40 | write!(formatter, "\"{}\": {}," , key, value)?; |
41 | } |
42 | write!(formatter, "\"{}\": {}" , last.0, last.1)?; |
43 | } |
44 | formatter.write_str("}" ) |
45 | } |
46 | } |
47 | } |
48 | } |
49 | |
50 | struct TargetSpec(Object); |
51 | |
52 | impl TargetSpec { |
53 | fn new() -> TargetSpec { |
54 | TargetSpec(Vec::new()) |
55 | } |
56 | } |
57 | |
58 | trait Push<T> { |
59 | fn push(&mut self, key: &str, value: T); |
60 | } |
61 | |
62 | impl Push<bool> for TargetSpec { |
63 | fn push(&mut self, key: &str, value: bool) { |
64 | self.0.push((key.to_string(), Value::Boolean(value))); |
65 | } |
66 | } |
67 | |
68 | impl Push<i32> for TargetSpec { |
69 | fn push(&mut self, key: &str, value: i32) { |
70 | self.0.push((key.to_string(), Value::Number(value))); |
71 | } |
72 | } |
73 | |
74 | impl Push<String> for TargetSpec { |
75 | fn push(&mut self, key: &str, value: String) { |
76 | self.0.push((key.to_string(), Value::String(value))); |
77 | } |
78 | } |
79 | |
80 | impl Push<&str> for TargetSpec { |
81 | fn push(&mut self, key: &str, value: &str) { |
82 | self.push(key, value.to_string()); |
83 | } |
84 | } |
85 | |
86 | impl Push<Object> for TargetSpec { |
87 | fn push(&mut self, key: &str, value: Object) { |
88 | self.0.push((key.to_string(), Value::Object(value))); |
89 | } |
90 | } |
91 | |
92 | impl Display for TargetSpec { |
93 | fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { |
94 | // We add some newlines for clarity. |
95 | formatter.write_str("{\n" )?; |
96 | if let [ref rest @ .., ref last] = self.0[..] { |
97 | for (key, value) in rest { |
98 | write!(formatter, " \"{}\": {},\n" , key, value)?; |
99 | } |
100 | write!(formatter, " \"{}\": {}\n" , last.0, last.1)?; |
101 | } |
102 | formatter.write_str("}" ) |
103 | } |
104 | } |
105 | |
106 | struct KernelConfig(HashMap<String, String>); |
107 | |
108 | impl KernelConfig { |
109 | /// Parses `include/config/auto.conf` from `stdin`. |
110 | fn from_stdin() -> KernelConfig { |
111 | let mut result = HashMap::new(); |
112 | |
113 | let stdin = std::io::stdin(); |
114 | let mut handle = stdin.lock(); |
115 | let mut line = String::new(); |
116 | |
117 | loop { |
118 | line.clear(); |
119 | |
120 | if handle.read_line(&mut line).unwrap() == 0 { |
121 | break; |
122 | } |
123 | |
124 | if line.starts_with('#') { |
125 | continue; |
126 | } |
127 | |
128 | let (key, value) = line.split_once('=').expect("Missing `=` in line." ); |
129 | result.insert(key.to_string(), value.trim_end_matches('\n').to_string()); |
130 | } |
131 | |
132 | KernelConfig(result) |
133 | } |
134 | |
135 | /// Does the option exist in the configuration (any value)? |
136 | /// |
137 | /// The argument must be passed without the `CONFIG_` prefix. |
138 | /// This avoids repetition and it also avoids `fixdep` making us |
139 | /// depend on it. |
140 | fn has(&self, option: &str) -> bool { |
141 | let option = "CONFIG_" .to_owned() + option; |
142 | self.0.contains_key(&option) |
143 | } |
144 | } |
145 | |
146 | fn main() { |
147 | let cfg = KernelConfig::from_stdin(); |
148 | let mut ts = TargetSpec::new(); |
149 | |
150 | // `llvm-target`s are taken from `scripts/Makefile.clang`. |
151 | if cfg.has("X86_64" ) { |
152 | ts.push("arch" , "x86_64" ); |
153 | ts.push( |
154 | "data-layout" , |
155 | "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" , |
156 | ); |
157 | let mut features = "-3dnow,-3dnowa,-mmx,+soft-float" .to_string(); |
158 | if cfg.has("RETPOLINE" ) { |
159 | features += ",+retpoline-external-thunk" ; |
160 | } |
161 | ts.push("features" , features); |
162 | ts.push("llvm-target" , "x86_64-linux-gnu" ); |
163 | ts.push("target-pointer-width" , "64" ); |
164 | } else { |
165 | panic!("Unsupported architecture" ); |
166 | } |
167 | |
168 | ts.push("emit-debug-gdb-scripts" , false); |
169 | ts.push("frame-pointer" , "may-omit" ); |
170 | ts.push( |
171 | "stack-probes" , |
172 | vec![("kind" .to_string(), Value::String("none" .to_string()))], |
173 | ); |
174 | |
175 | // Everything else is LE, whether `CPU_LITTLE_ENDIAN` is declared or not |
176 | // (e.g. x86). It is also `rustc`'s default. |
177 | if cfg.has("CPU_BIG_ENDIAN" ) { |
178 | ts.push("target-endian" , "big" ); |
179 | } |
180 | |
181 | println!("{}" , ts); |
182 | } |
183 | |