Skip to main content

offlineasm_backend/
backends.rs

1//! Lowers resolved trees to assembly text or RLoop Rust.
2
3use 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}