rld/src/linker.rs

use std::{
    fmt::Display,
    io::ErrorKind,
    path::{Path, PathBuf},
};

use crate::{
    common::{DataIndex, Loadable, Output, Relocatable},
    error::Error,
};

pub struct Linker<R, O>
where
    R: Relocatable,
    O: Output<R>,
{
    relocatables: Vec<R>,
    loadable: Loadable,
    output: O,
}

impl<R, O> Linker<R, O>
where
    R: Relocatable,
    O: Output<R>,
{
    pub fn new(output: O) -> Self {
        Self {
            relocatables: Vec::new(),
            loadable: Loadable::default(),
            output,
        }
    }

    pub fn add_relocatable(&mut self, origin: PathBuf) -> Result<(), Error> {
        self.relocatables.push(R::new(
            origin,
            DataIndex::for_object(self.relocatables.len()),
        )?);

        Ok(())
    }

    pub fn link(mut self) -> Result<PathBuf, Error> {
        for r in self.relocatables.iter() {
            for s in r.sections() {
                self.loadable.process_section(s?)?;
            }
        }

        self.loadable.start_offset = Some(4096); // TODO: get from .start symbol location
        self.output.finalize(&self.relocatables, &self.loadable)
    }

    pub fn object_path(origin: &Path) -> Result<PathBuf, Error> {
        let mut dest = std::fs::canonicalize(origin)?;
        if !dest.pop() {
            let err = std::io::Error::new(ErrorKind::Other, "Destination path invalid");
            Err(Error::IOError(Box::new(err)))
        } else {
            dest.push("rld.out");
            Ok(dest)
        }
    }
}

impl<R, O> Display for Linker<R, O>
where
    R: Relocatable,
    O: Output<R>,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "===Relocatables===")?;

        for r in self.relocatables.iter() {
            write!(f, "{}", r)?;
        }

        Ok(())
    }
}