pub mod emulation;
mod inputs;
mod opts;
mod response;
mod zopts;
use std::{
ffi::{OsStr, OsString},
path::PathBuf,
};
use inputs::{Inputs, has_syslibroot, parse_search_path, parse_sysroot};
use opts::{
Attached, Parsed, attached, is_noop_flag, parse_build_id, parse_hash_style,
parse_icf, parse_lib_marker, positional, raw_argument,
};
pub use response::expand_response_files;
use xold::{
buildid::BuildId,
dynamic::{HashStyle, Strip, ZOptions},
icf::IcfMode,
macho::{MachoTarget, PlatformVersion},
search::LibKind,
};
const DEFAULT_INTERP: &str = "/lib64/ld-linux-x86-64.so.2";
#[allow(clippy::struct_excessive_bools)]
pub struct Options {
pub inputs: Vec<PathBuf>,
pub lib_groups: Vec<(usize, usize)>,
pub from_l: Vec<bool>,
pub as_needed: Vec<bool>,
pub emulation: Option<String>,
pub threads: Option<usize>,
pub static_link: bool,
pub pie: Option<bool>,
pub export_dynamic: bool,
pub strip: Strip,
pub hash_style: HashStyle,
pub rpath: String,
pub build_id: BuildId,
pub undefined: Vec<String>,
pub version_script: Option<String>,
pub undefined_version: bool,
pub z: ZOptions,
pub no_undefined: bool,
pub search: Vec<PathBuf>,
pub sysroot: Option<PathBuf>,
pub entry_given: bool,
pub output: PathBuf,
pub entry: String,
pub shared: bool,
pub soname: Option<String>,
pub dynamic_exec: bool,
pub interpreter: String,
pub gc_sections: bool,
pub icf: IcfMode,
pub relax: bool,
pub relax_named: bool,
pub no_fork: bool,
pub macho_dynamic: bool,
pub macho_arch: Option<MachoTarget>,
pub macho_platform: Option<PlatformVersion>,
pub macho_dead_strip: bool,
}
pub enum Request {
Link(Box<Options>),
Print(String),
}
fn version_text() -> String {
format!("xold {}\n", env!("CARGO_PKG_VERSION"))
}
pub fn parse(args: &[OsString]) -> std::result::Result<Request, String> {
let sysroot = parse_sysroot(args)?;
let search = parse_search_path(args)?;
let mut inputs = Inputs {
search,
sysroot,
macho_libraries: has_syslibroot(args),
..Default::default()
};
if let Some(text) = asked_about_itself(args) {
return Ok(Request::Print(text));
}
let mut p = Parsed::default();
let mut i = 0;
while i < args.len() {
i = step(args, i, &mut p, &mut inputs)?;
}
if inputs.in_lib {
return Err("xold: --start-lib without --end-lib".into());
}
if inputs.paths.is_empty() {
return Err(USAGE.into());
}
Ok(Request::Link(Box::new(p.into_options(inputs))))
}
fn asked_about_itself(args: &[OsString]) -> Option<String> {
for arg in args {
let Some(text) = arg.to_str() else {
continue;
};
match text {
"--version" | "-V" => return Some(version_text()),
"--help" => {
return Some(format!("{}\n{USAGE}\n", version_text().trim()));
}
"-v" if args.len() == 1 => return Some(version_text()),
_ => {}
}
}
None
}
fn step(
args: &[OsString],
i: usize,
p: &mut Parsed,
inputs: &mut Inputs,
) -> std::result::Result<usize, String> {
let Some(arg) = args[i].to_str() else {
raw_argument(inputs, &args[i])?;
return Ok(i + 1);
};
if let Some((opt, value)) = attached(arg) {
apply_attached(p, opt, value)?;
return Ok(i + 1);
}
if let Some(next_i) = separated(args, i, arg, p, inputs)? {
return Ok(next_i);
}
plain(arg, p, inputs)?;
Ok(i + 1)
}
fn apply_attached(
p: &mut Parsed,
opt: Attached,
value: &str,
) -> std::result::Result<(), String> {
match opt {
Attached::Output => p.output = PathBuf::from(value),
Attached::Entry => {
p.entry = value.to_string();
p.entry_given = true;
}
Attached::Soname => p.soname = Some(value.to_string()),
Attached::Interp => {
p.interpreter = value.to_string();
p.sw.dynamic_exec = true;
}
Attached::Icf => p.icf = parse_icf(value)?,
Attached::HashStyle => p.hash_style = parse_hash_style(value)?,
Attached::Rpath => p.rpath.push(value.to_string()),
Attached::BuildId => p.build_id = parse_build_id(value)?,
Attached::Undefined => p.undefined.push(value.to_string()),
Attached::VersionScript => {
p.version_script = Some(value.to_string());
}
Attached::Emulation => p.emulation = Some(value.to_string()),
Attached::Threads => p.threads = Some(parse_threads(value)?),
Attached::OptLevel => parse_opt_level(value)?,
}
Ok(())
}
fn separated(
args: &[OsString],
i: usize,
arg: &str,
p: &mut Parsed,
inputs: &mut Inputs,
) -> std::result::Result<Option<usize>, String> {
let at = i + 1;
match arg {
"-o" => p.output = PathBuf::from(next_os(args, at, "-o")?),
"--entry" | "-e" => {
p.entry = next(args, at, "--entry")?.to_string();
p.entry_given = true;
}
"-soname" | "--soname" => {
p.soname = Some(next(args, at, "-soname")?.to_string());
}
"-dynamic-linker" | "--dynamic-linker" => {
p.interpreter = next(args, at, "-dynamic-linker")?.to_string();
p.sw.dynamic_exec = true;
}
"-m" => p.emulation = Some(next(args, at, "-m")?.to_string()),
"-u" | "--undefined" => {
p.undefined.push(next(args, at, "-u")?.to_string());
}
"-plugin" | "-plugin-opt" => {
let _ = next(args, at, arg)?;
}
"-lto_library" | "-mllvm" => {
let _ = next(args, at, arg)?;
}
"-arch" => {
p.macho_arch =
Some(opts::parse_macho_arch(next(args, at, "-arch")?)?);
}
"-platform_version" => {
let platform = next(args, at, "-platform_version")?;
let min_os = next(args, at + 1, "-platform_version")?;
let sdk = next(args, at + 2, "-platform_version")?;
p.macho_platform =
Some(opts::parse_platform_version(platform, min_os, sdk)?);
return Ok(Some(at + 3));
}
"--version-script" | "-version-script" => {
p.version_script = Some(next(args, at, "--version-script")?.into());
}
"-rpath" | "--rpath" | "-R" => {
p.rpath.push(next(args, at, "-rpath")?.to_string());
}
"-rpath-link" | "--rpath-link" => {
inputs.search.push(PathBuf::from(next_os(
args,
at,
"-rpath-link",
)?));
}
"--threads" => {
p.threads = Some(parse_threads(next(args, at, "--threads")?)?);
}
"-z" => p.zkeyword(next(args, at, "-z")?)?,
"-l" => inputs.library(next(args, at, "-l")?)?,
"--sysroot" | "-syslibroot" | "-L" => {}
_ => return Ok(None),
}
Ok(Some(at + 1))
}
fn plain(
arg: &str,
p: &mut Parsed,
inputs: &mut Inputs,
) -> std::result::Result<(), String> {
match arg {
s if p.sw.parse(s) => {}
s if positional(inputs, s)? => {}
"-static" => {
p.sw.static_link = true;
inputs.kind = LibKind::ArchiveOnly;
}
"-dynamic" => p.macho_dynamic = true,
"-dead_strip" => p.macho_dead_strip = true,
"--no-threads" => p.threads = Some(1),
s if s.starts_with("-z") && s.len() > 2 => p.zkeyword(&s[2..])?,
"--no-undefined" => p.no_undefined = true,
"-v" => println!("{}", version_text().trim()),
s if s.starts_with("-plugin-opt=") => {}
"--build-id" => p.build_id = BuildId::Fast,
"--no-undefined-version" => p.undefined_version = false,
"--undefined-version" => p.undefined_version = true,
"--no-build-id" => p.build_id = BuildId::None,
s if is_noop_flag(s) => {}
"--start-lib" | "--end-lib" => parse_lib_marker(inputs, arg)?,
s if s.starts_with("--sysroot=") => {}
s if s.starts_with("-L") && s.len() > 2 => {}
s if s.starts_with("-l") && s.len() > 2 => inputs.library(&s[2..])?,
s if s.starts_with('-') && s.len() > 1 => {
return Err(unknown_option(s));
}
s => inputs.file(OsStr::new(s)),
}
Ok(())
}
pub const USAGE: &str = "usage: xold [-shared | --dynamic-exec | -static] \
[-pie | -no-pie] [--strip-all | --strip-debug] \
[--hash-style=sysv|gnu|both] [-rpath dir]... \
[--build-id[=none|fast|md5|sha1|0xHEX]] [--version-script file] \
[-u symbol]... [--export-dynamic] \
[--gc-sections | --no-gc-sections] \
[--relax | --no-relax] \
[--icf=all|--icf=safe|--icf=none] [--eh-frame-hdr] [--no-fork] \
[-m emulation] [-O level] [--threads N | --no-threads] [-z keyword]... \
[-Bstatic | -Bdynamic] [--as-needed | --no-as-needed] \
[--push-state | --pop-state] [-o output] [--entry symbol] [-soname name] \
[-dynamic-linker path] [--sysroot dir] [-L dir]... [-l lib]... \
<object files...>";
pub fn unknown_option(arg: &str) -> String {
format!(
"xold: unknown option `{arg}`: this linker implements a fixed set of \
options and does not ignore the ones it lacks, since an ignored \
option changes the image it was meant to describe\n{USAGE}"
)
}
pub fn next_os<'a>(
args: &'a [OsString],
i: usize,
flag: &str,
) -> std::result::Result<&'a OsStr, String> {
args.get(i)
.map(OsString::as_os_str)
.ok_or_else(|| format!("xold: {flag} requires an argument"))
}
pub fn next<'a>(
args: &'a [OsString],
i: usize,
flag: &str,
) -> std::result::Result<&'a str, String> {
next_os(args, i, flag)?
.to_str()
.ok_or_else(|| format!("xold: {flag} argument is not valid UTF-8"))
}
fn parse_threads(value: &str) -> std::result::Result<usize, String> {
match value.parse::<usize>() {
Ok(n @ 1..) => Ok(n),
_ => Err(format!(
"xold: --threads value `{value}` is not a positive number"
)),
}
}
fn parse_opt_level(value: &str) -> std::result::Result<(), String> {
if value.bytes().all(|b| b.is_ascii_digit()) {
return Ok(());
}
Err(format!("xold: -O level `{value}` is not a number"))
}
pub fn unknown_icf(value: &str) -> String {
format!("xold: unknown --icf value `{value}` (expected all|safe|none)")
}