1use crate::ast::Node;
4use crate::driver::AsmEmitter;
5use crate::settings::SettingsMap;
6use offlineasm_ir::{ExternId, Label, Reach};
7use std::collections::HashSet;
8
9pub mod backend_rloop;
10pub mod frontend;
11pub mod text;
12pub mod text_arm64;
13pub mod text_riscv64;
14pub mod text_x86;
15
16pub const BACKENDS: &[&str] = &["X86_64", "ARM64", "ARM64E", "RISCV64", "RLOOP"];
17
18pub const WORKING_BACKENDS: &[&str] = &["X86_64", "ARM64", "ARM64E", "RISCV64", "RLOOP"];
19
20pub type LabelFlags<'a> = &'a dyn Fn(&str) -> (bool, bool, bool, bool, Option<String>);
21
22#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
23pub enum Backend {
24 X86_64,
25 Arm64,
26 Arm64e,
27 Riscv64,
28 RLoop,
29}
30
31impl Backend {
32 pub fn name(&self) -> &'static str {
33 match self {
34 Backend::X86_64 => "X86_64",
35 Backend::Arm64 => "ARM64",
36 Backend::Arm64e => "ARM64E",
37 Backend::Riscv64 => "RISCV64",
38 Backend::RLoop => "RLOOP",
39 }
40 }
41
42 pub fn parse(name: &str) -> Result<Self, String> {
43 match canonicalize_backend_name(name).as_str() {
44 "X86_64" => Ok(Backend::X86_64),
45 "ARM64" => Ok(Backend::Arm64),
46 "ARM64E" => Ok(Backend::Arm64e),
47 "RISCV64" => Ok(Backend::Riscv64),
48 "RLOOP" => Ok(Backend::RLoop),
49 other => Err(format!("unknown backend {}", other)),
50 }
51 }
52}
53
54pub fn canonicalize_backend_name(name: &str) -> String {
55 let upper = name.to_uppercase();
56 if upper == "ARM64_32" {
57 return "ARM64".to_string();
58 }
59 upper
60}
61
62pub fn canonicalize_backend_names(names: &[String]) -> Vec<String> {
63 let mut out: Vec<String> = names.iter().map(|n| canonicalize_backend_name(n)).collect();
64 out.dedup();
65 out
66}
67
68#[derive(Clone, Debug)]
69pub struct BackendSet {
70 valid: HashSet<String>,
71}
72
73impl Default for BackendSet {
74 fn default() -> Self {
75 Self {
76 valid: BACKENDS.iter().map(|s| s.to_string()).collect(),
77 }
78 }
79}
80
81impl BackendSet {
82 pub fn new() -> Self {
83 Self::default()
84 }
85
86 pub fn include_only(&mut self, list: &[String]) {
87 let mut next = HashSet::new();
88 for backend in list {
89 if self.valid.contains(backend) {
90 next.insert(backend.clone());
91 }
92 }
93 self.valid = next;
94 }
95
96 pub fn is_valid(&self, backend: &str) -> bool {
97 self.valid.contains(backend)
98 }
99
100 pub fn valid_backends(&self) -> Vec<String> {
101 let mut v: Vec<String> = self.valid.iter().cloned().collect();
102 v.sort();
103 v
104 }
105}
106
107pub fn is_backend(name: &str) -> bool {
108 BACKENDS.contains(&name)
109}
110
111pub fn is_valid_backend(name: &str) -> bool {
112 BackendSet::new().is_valid(name)
113}
114
115#[derive(Debug, Clone)]
116pub struct LoweringError {
117 pub message: String,
118 pub origin: String,
119}
120
121impl std::fmt::Display for LoweringError {
122 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
123 write!(f, "{} (due to {})", self.message, self.origin)
124 }
125}
126
127impl std::error::Error for LoweringError {}
128
129pub struct LowerCtx<'a> {
130 pub backend: Backend,
131 pub emitter: &'a mut AsmEmitter,
132 pub referenced_extern: Vec<String>,
133 pub globals: std::collections::HashMap<String, (bool, bool)>,
134 pub is_win: bool,
135 pub macho: bool,
136 pub local_strings: std::collections::HashMap<String, String>,
137 pub known_labels: std::collections::HashSet<String>,
138 settings: SettingsMap,
139 synth_counter: usize,
140 pub ir_labels: Vec<String>,
141 ir_label_ids: std::collections::HashMap<String, u32>,
142 pub ir_syms: Vec<String>,
143 ir_sym_ids: std::collections::HashMap<String, u32>,
144 pub ir_fresh: std::collections::HashMap<u32, String>,
145 pub declared_externs: std::collections::HashMap<String, Reach>,
146 pub ir_externs: Vec<String>,
147 ir_extern_ids: std::collections::HashMap<String, u32>,
148 pub extern_slots: std::collections::HashMap<u32, String>,
149}
150
151impl<'a> LowerCtx<'a> {
152 pub fn new(backend: Backend, emitter: &'a mut AsmEmitter) -> Self {
153 Self {
154 backend,
155 emitter,
156 referenced_extern: Vec::new(),
157 globals: std::collections::HashMap::new(),
158 is_win: false,
159 macho: false,
160 local_strings: std::collections::HashMap::new(),
161 known_labels: std::collections::HashSet::new(),
162 settings: SettingsMap::new(),
163 synth_counter: 0,
164 ir_labels: Vec::new(),
165 ir_label_ids: std::collections::HashMap::new(),
166 ir_syms: Vec::new(),
167 ir_sym_ids: std::collections::HashMap::new(),
168 ir_fresh: std::collections::HashMap::new(),
169 declared_externs: std::collections::HashMap::new(),
170 ir_externs: Vec::new(),
171 ir_extern_ids: std::collections::HashMap::new(),
172 extern_slots: std::collections::HashMap::new(),
173 }
174 }
175
176 pub fn intern_extern(&mut self, text: String) -> ExternId {
177 if let Some(&id) = self.ir_extern_ids.get(&text) {
178 return ExternId(id);
179 }
180 let id = self.ir_externs.len() as u32;
181 self.ir_externs.push(text.clone());
182 self.ir_extern_ids.insert(text, id);
183 ExternId(id)
184 }
185
186 pub fn coff(&self) -> bool {
187 !self.macho && (self.setting("WINDOWS") || self.is_win)
188 }
189
190 pub fn intern_label(&mut self, text: String) -> Label {
191 if let Some(&id) = self.ir_label_ids.get(&text) {
192 return Label(id);
193 }
194 let id = self.ir_labels.len() as u32;
195 self.ir_labels.push(text.clone());
196 self.ir_label_ids.insert(text, id);
197 Label(id)
198 }
199
200 pub fn intern_sym(&mut self, text: String) -> u32 {
201 if let Some(&id) = self.ir_sym_ids.get(&text) {
202 return id;
203 }
204 let id = self.ir_syms.len() as u32;
205 self.ir_syms.push(text.clone());
206 self.ir_sym_ids.insert(text, id);
207 id
208 }
209
210 pub fn set_settings(&mut self, settings: SettingsMap) {
211 self.settings = settings;
212 }
213
214 pub fn setting(&self, name: &str) -> bool {
215 self.settings.get(name) == Some(&true)
216 }
217
218 pub fn global_symbol(&self, name: &str) -> String {
219 if self.macho {
220 format!("_{}", name)
221 } else {
222 name.to_string()
223 }
224 }
225
226 pub fn local_symbol(&self, name: &str) -> String {
227 if self.macho {
228 format!("L{}", name)
229 } else {
230 name.to_string()
231 }
232 }
233
234 pub fn mark_used(&mut self, name: &str, is_extern: bool) {
235 if is_extern && !self.referenced_extern.contains(&name.to_string()) {
236 self.referenced_extern.push(name.to_string());
237 }
238 }
239
240 pub fn local_label_string(name: &str, origin: &crate::code_origin::CodeOrigin) -> String {
241 let stripped = name.get(1..).unwrap_or("");
242 format!(
243 "__offlineasm_{}_{}",
244 stripped,
245 origin.label_string_extension()
246 )
247 }
248
249 pub fn local_string(&self, name: &str) -> Result<String, String> {
250 self.local_strings
251 .get(name)
252 .cloned()
253 .ok_or_else(|| format!("unknown local label {}", name))
254 }
255
256 pub fn unique_local(
257 &mut self,
258 comment: &str,
259 origin: &crate::code_origin::CodeOrigin,
260 ) -> (Node, Node) {
261 let mut candidate = format!("_{}", comment);
262 if self.known_labels.contains(&candidate) {
263 loop {
264 candidate = format!("_{}_{}", self.synth_counter, comment);
265 self.synth_counter += 1;
266 if !self.known_labels.contains(&candidate) {
267 break;
268 }
269 }
270 }
271 self.known_labels.insert(candidate.clone());
272 let string = Self::local_label_string(&candidate, origin);
273 self.local_strings.insert(candidate.clone(), string);
274 (
275 Node::LocalLabel {
276 origin: origin.clone(),
277 name: candidate.clone(),
278 },
279 Node::LocalLabelReference {
280 origin: origin.clone(),
281 label: candidate,
282 },
283 )
284 }
285
286 pub fn lower_synth(
287 &mut self,
288 nodes: &[Node],
289 label_flags: LabelFlags<'_>,
290 ) -> Result<(), String> {
291 for node in nodes {
292 lower_node_inner(node, self, label_flags)?;
293 }
294 Ok(())
295 }
296}
297
298pub fn lower_node(
299 node: &Node,
300 ctx: &mut LowerCtx,
301 label_flags: LabelFlags<'_>,
302) -> Result<(), LoweringError> {
303 let origin = node.origin_string();
304 lower_node_inner(node, ctx, label_flags).map_err(|message| LoweringError { message, origin })
305}
306
307fn lower_node_inner(
308 node: &Node,
309 ctx: &mut LowerCtx,
310 label_flags: LabelFlags<'_>,
311) -> Result<(), String> {
312 match node {
313 Node::Label { name, .. } => {
314 let raw = name.strip_prefix('_').unwrap_or(name);
315 let (global, export, aligned, is_extern, align_to) = label_flags(name);
316 let symbol = if global || is_extern {
317 ctx.global_symbol(raw)
318 } else {
319 ctx.local_symbol(raw)
320 };
321 ctx.emitter
322 .puts_label(&symbol, global, export, aligned, align_to);
323 Ok(())
324 }
325 Node::LocalLabel { name, origin } => {
326 let label_string = ctx
327 .local_strings
328 .get(name)
329 .cloned()
330 .unwrap_or_else(|| LowerCtx::local_label_string(name, origin));
331 let symbol = ctx.local_symbol(&label_string);
332 ctx.emitter.puts_local_label(&symbol);
333 Ok(())
334 }
335 Node::Skip { .. } => Ok(()),
336 Node::Sequence { list, .. } => {
337 if ctx.backend == Backend::RLoop {
338 return backend_rloop::lower_sequence(list, ctx, label_flags);
339 }
340 for item in list {
341 lower_node_inner(item, ctx, label_flags)?;
342 }
343 Ok(())
344 }
345 Node::Instruction { .. } => match ctx.backend {
346 Backend::RLoop => backend_rloop::lower_instruction(node, ctx, label_flags),
347 Backend::X86_64 => {
348 frontend::lower_instruction(node, ctx, label_flags, text::TextTarget::X86_64, false)
349 }
350 Backend::Arm64 => frontend::lower_instruction(
351 node,
352 ctx,
353 label_flags,
354 text::TextTarget::Aarch64,
355 false,
356 ),
357 Backend::Arm64e => {
358 frontend::lower_instruction(node, ctx, label_flags, text::TextTarget::Aarch64, true)
359 }
360 Backend::Riscv64 => frontend::lower_instruction(
361 node,
362 ctx,
363 label_flags,
364 text::TextTarget::Riscv64,
365 false,
366 ),
367 },
368 other => Err(format!("cannot lower {} (validate first)", other.dump())),
369 }
370}
371
372pub fn local_ref_name(node: &Node, ctx: &LowerCtx) -> Result<String, String> {
373 match node {
374 Node::LocalLabelReference { label, .. } => Ok(ctx.local_symbol(&ctx.local_string(label)?)),
375 other => Err(format!("not a local label reference: {}", other.dump())),
376 }
377}
378
379pub fn extern_or_global_ref(stripped: &str) -> String {
380 stripped.to_string()
381}
382
383pub fn local_ref(stripped: &str) -> String {
384 stripped.to_string()
385}