diff --git a/README.md b/README.md index b97aff6..a17d421 100644 --- a/README.md +++ b/README.md @@ -40,6 +40,9 @@ macro expansion and preprocessing/dependency arguments. Each backend keeps its generator entry point and core node dispatch in `src/generator//generator.rs`; `generator/aggregate.rs`, `globals.rs`, `atomic.rs` and `inline_asm.rs` contain the corresponding target-specific operations. +The C build driver starts in `src/bin/dynamite-cc/main.rs`, with argument handling +in `arguments.rs`. Its LLVM tools module keeps lowering and backend selection +in `llvm_tools.rs`, with native linking in `llvm_tools/gnu.rs` and `darwin.rs`. The image workflow runs only when `dockerfiles/dev.Dockerfile`, `.dockerignore`, or `.github/workflows/publish.yaml` changes, or when started manually. Image diff --git a/src/ast.rs b/src/ast.rs index 105361d..766fc22 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -28,6 +28,61 @@ mod validation; mod varargs; mod vla; +pub struct AstBuilderImpl<'a> { + error_logger: &'a dyn error::ErrorLogger, + tokens: &'a Vec, + cur: usize, + offset_size: usize, + loop_stack: Vec, + labels: HashMap, + defined_labels: HashSet, + switch_stack: Vec>, + switch_types: Vec, + return_type: Option, + current_function: Option, + mutable_static: Option, + return_pointer: Option, + variadic_parameters: Option>, + variadic_last: Option, + pending_bounds: Vec, + parameter_depth: usize, + declaration_attributes_state: Option, + dynamic_objects: Vec, + vla_active: Vec, + jump_depths: Vec, + continue_depths: HashMap, + switch_vla_depths: Vec, + next_enum_id: usize, + next_deferred_local: usize, + struct_definitions: Vec>>, + scope_stack: Vec>, + pub functions: HashMap, + pub global_variables: HashMap, + pub string_literals: Vec, + pub symbol_names: HashMap, +} + +pub struct ProgramAst<'a> { + pub functions: &'a HashMap, + pub global_variables: &'a HashMap, + pub string_literals: &'a Vec, + pub symbol_names: &'a HashMap, +} + +pub enum Identifier { + TypeDef(Type), + Constant(i64, Type), + EnumTag { + ty: Type, + fixed: bool, + defined: bool, + }, + StaticObject(Type, String), + Local(Type, usize, bool, usize), + Dynamic(Type, usize, bool), + Static(Type), +} + #[derive(Clone, Copy, PartialEq)] enum Nullability { Nullable, @@ -121,61 +176,6 @@ struct DeclarationAttributes { hidden: bool, } -pub struct AstBuilderImpl<'a> { - error_logger: &'a dyn error::ErrorLogger, - tokens: &'a Vec, - cur: usize, - offset_size: usize, - loop_stack: Vec, - labels: HashMap, - defined_labels: HashSet, - switch_stack: Vec>, - switch_types: Vec, - return_type: Option, - current_function: Option, - mutable_static: Option, - return_pointer: Option, - variadic_parameters: Option>, - variadic_last: Option, - pending_bounds: Vec, - parameter_depth: usize, - declaration_attributes_state: Option, - dynamic_objects: Vec, - vla_active: Vec, - jump_depths: Vec, - continue_depths: HashMap, - switch_vla_depths: Vec, - next_enum_id: usize, - next_deferred_local: usize, - struct_definitions: Vec>>, - scope_stack: Vec>, - pub functions: HashMap, - pub global_variables: HashMap, - pub string_literals: Vec, - pub symbol_names: HashMap, -} - -pub struct ProgramAst<'a> { - pub functions: &'a HashMap, - pub global_variables: &'a HashMap, - pub string_literals: &'a Vec, - pub symbol_names: &'a HashMap, -} - -pub enum Identifier { - TypeDef(Type), - Constant(i64, Type), - EnumTag { - ty: Type, - fixed: bool, - defined: bool, - }, - StaticObject(Type, String), - Local(Type, usize, bool, usize), - Dynamic(Type, usize, bool), - Static(Type), -} - pub(crate) const METADATA_ATTRIBUTES: &[&str] = &[ "availability", "deprecated", diff --git a/src/bin/dynamite-cc.rs b/src/bin/dynamite-cc/arguments.rs similarity index 52% rename from src/bin/dynamite-cc.rs rename to src/bin/dynamite-cc/arguments.rs index 916b996..d14e737 100644 --- a/src/bin/dynamite-cc.rs +++ b/src/bin/dynamite-cc/arguments.rs @@ -1,52 +1,11 @@ -//! Native C build driver with external Clang or LLVM tools. +//! Parse compiler arguments and preserve source/linker argument ordering. -#[path = "dynamite-cc/llvm_tools.rs"] -mod llvm_tools; - -use dynamite_compiler::timing::Timer; +use super::{Arguments, Input, LinkArgument, Mode}; use std::{ - borrow::Cow, collections::HashSet, - fs, path::{Path, PathBuf}, - process::Command, - sync::atomic::{AtomicUsize, Ordering}, }; -#[derive(Clone, Copy, PartialEq)] -enum Mode { - Link, - Object, - Assembly, -} - -struct Input { - name: String, - source: bool, -} - -enum LinkArgument { - Option(String), - Input(usize), -} - -struct Arguments { - inputs: Vec, - backend: Vec, - linker: Vec, - preprocessing: Vec, - forwarded: Vec, - output: Option, - mode: Mode, - jobs: usize, - dependencies: Option, - dependency_file: Option, - dependency_targets: Vec, - phony_dependencies: bool, - preprocess_only: bool, - emit_llvm: bool, -} - fn argument_value(args: &[String], index: &mut usize) -> Result { *index += 1; args.get(*index) @@ -55,7 +14,7 @@ fn argument_value(args: &[String], index: &mut usize) -> Result } impl Arguments { - fn parse(args: &[String]) -> Result { + pub(super) fn parse(args: &[String]) -> Result { let mut result = Self { inputs: vec![], backend: vec![], @@ -324,7 +283,7 @@ impl Arguments { Ok(result) } - fn link_arguments(&self, outputs: &[PathBuf]) -> Vec { + pub(super) fn link_arguments(&self, outputs: &[PathBuf]) -> Vec { let mut objects = outputs.iter(); let mut arguments = vec![]; for argument in &self.linker { @@ -346,7 +305,7 @@ impl Arguments { arguments } - fn output_for(&self, input: &Input) -> PathBuf { + pub(super) fn output_for(&self, input: &Input) -> PathBuf { if let Some(output) = &self.output { return output.into(); } @@ -359,322 +318,3 @@ impl Arguments { PathBuf::from(Path::new(&input.name).file_name().unwrap()).with_extension(suffix) } } - -struct TemporaryDirectory(PathBuf); -impl TemporaryDirectory { - fn new() -> Result { - let stamp = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .map_err(|e| e.to_string())? - .as_nanos(); - for attempt in 0..100 { - let path = std::env::temp_dir().join(format!( - "dynamite-cc-{}-{stamp}-{attempt}", - std::process::id() - )); - match fs::create_dir(&path) { - Ok(()) => return Ok(Self(path)), - Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue, - Err(e) => return Err(e.to_string()), - } - } - Err("failed to create compilation directory".into()) - } -} -impl Drop for TemporaryDirectory { - fn drop(&mut self) { - let _ = fs::remove_dir_all(&self.0); - } -} - -fn status(command: &mut Command) -> Result { - command - .status() - .map(|status| status.code().unwrap_or(1)) - .map_err(|error| format!("failed to run Clang: {error}")) -} - -fn compile( - input: &Input, - index: usize, - args: &Arguments, - clang: &str, - temporary: &Path, -) -> Result { - let output = if args.mode == Mode::Link { - temporary.join(format!("{index}.o")) - } else { - args.output_for(input) - }; - let mut preprocessing = args.preprocessing.clone(); - if let Some(system) = args.dependencies { - let dependency_output = if args.mode == Mode::Link { - Cow::Owned(PathBuf::from(args.output.as_deref().unwrap_or("a.out"))) - } else { - Cow::Borrowed(&output) - }; - let default_dependency_file = if args.mode == Mode::Link - && args.inputs.iter().filter(|input| input.source).count() > 1 - { - PathBuf::from(format!("{}-{index}.d", dependency_output.display())) - } else { - dependency_output.with_extension("d") - }; - preprocessing.extend([ - if system { "-MD" } else { "-MMD" }.into(), - "-MF".into(), - args.dependency_file - .as_ref() - .map(PathBuf::from) - .unwrap_or(default_dependency_file) - .to_string_lossy() - .into_owned(), - ]); - if args.dependency_targets.is_empty() { - preprocessing.extend([ - "-MQ".into(), - dependency_output.to_string_lossy().into_owned(), - ]); - } else { - preprocessing.extend(args.dependency_targets.clone()); - } - if args.phony_dependencies { - preprocessing.push("-MP".into()); - } - } - let timer = Timer::new("frontend_total"); - let one_shot = - args.mode != Mode::Link && args.inputs.iter().filter(|input| input.source).count() == 1; - let generate = if one_shot { - dynamite_compiler::generate_file_once - } else { - dynamite_compiler::generate_file - }; - let ir = generate(Path::new(&input.name), "llvm", false, &preprocessing)?; - drop(timer); - let ir_path = temporary.join(format!("{index}.ll")); - { - let _timer = Timer::new("write_ir"); - fs::write(&ir_path, &ir).map_err(|e| format!("failed to write LLVM IR: {e}"))?; - } - if llvm_tools::selected()? { - let _timer = Timer::new("lower"); - llvm_tools::lower( - &args.backend, - &ir_path, - &output, - args.mode == Mode::Assembly, - )?; - return Ok(output); - } - let mut command = Command::new(clang); - let mut backend_index = 0; - while backend_index < args.backend.len() { - let arg = &args.backend[backend_index]; - if matches!(arg.as_str(), "-L" | "-l" | "-framework" | "-Xlinker") { - backend_index += 2; - continue; - } - if !(arg.starts_with("-Wl,") - || arg.starts_with("-L") - || arg.starts_with("-l") - || arg.starts_with("-fuse-ld=") - || matches!( - arg.as_str(), - "-shared" | "-dynamiclib" | "-static" | "-pie" | "-no-pie" | "-rdynamic" | "-s" - )) - { - command.arg(arg); - } - backend_index += 1; - } - command - .arg(if args.mode == Mode::Assembly { - "-S" - } else { - "-c" - }) - .arg(&ir_path) - .arg("-o") - .arg(&output) - .arg("-Wno-override-module"); - let _timer = Timer::new("lower"); - let code = status(&mut command)?; - if code != 0 { - return Err(format!("LLVM lowering failed for {}", input.name)); - } - Ok(output) -} - -/// Run the C build driver. C inputs always pass through the Dynamite frontend. -/// `--jobs N` bounds independent translation units; the default is one worker. -fn run(arguments: &[String]) -> Result { - if arguments.iter().any(|arg| arg == "--help" || arg == "-h") { - println!( - "Usage: dynamite-cc [--jobs N] [Clang options] FILE...\nCompile C through Dynamite. DYNAMITE_BACKEND=llvm selects external llc/opt and a native linker on Linux x86_64 GNU or macOS; the default backend is Clang. Supports -c, -S, -o, -I/-D/-U, and dependency files. Default: one worker." - ); - return Ok(0); - } - let args = Arguments::parse(arguments)?; - let llvm = llvm_tools::selected()?; - let clang = std::env::var("DYNAMITE_CLANG").unwrap_or_else(|_| "clang".into()); - if args.preprocess_only { - let native_backend_option = |arg: &String| { - arg.starts_with("-O") - || arg.starts_with("-W") - || arg.starts_with("-g") - || matches!(arg.as_str(), "-pthread" | "-pedantic") - }; - let mut backend_index = 0; - let mut unsupported = None; - while backend_index < args.backend.len() { - let option = &args.backend[backend_index]; - if cfg!(target_os = "macos") - && matches!(option.as_str(), "-F" | "-iframework" | "-isysroot") - { - backend_index += 2; - } else if native_backend_option(option) - || cfg!(target_os = "macos") - && (option.starts_with("-F") - || option.starts_with("-iframework") - || option.starts_with("-isysroot")) - { - backend_index += 1; - } else { - unsupported = Some(option); - break; - } - } - let native_dependencies = args - .forwarded - .iter() - .any(|arg| matches!(arg.as_str(), "-M" | "-MM")); - if args.inputs.is_empty() { - return Err("native preprocessing requires a source file".into()); - } - let _timer = Timer::new(if native_dependencies { - "dependency_scan" - } else { - "preprocess_only" - }); - if let Some(option) = unsupported { - return Err(format!("unsupported native preprocessing option: {option}")); - } - let mut preprocessing = args.preprocessing.clone(); - for flag in ["-M", "-MM", "-P", "-MP"] { - if args.forwarded.iter().any(|arg| arg == flag) { - preprocessing.push(flag.into()); - } - } - if let Some(file) = &args.dependency_file { - preprocessing.extend(["-MF".into(), file.clone()]); - } - preprocessing.extend(args.dependency_targets.clone()); - let paths = args - .inputs - .iter() - .map(|input| PathBuf::from(&input.name)) - .collect::>(); - let output = - dynamite_compiler::preprocessor::preprocess_files_native(&paths, &preprocessing)?; - if let Some(path) = &args.output { - fs::write(path, output).map_err(|e| e.to_string())?; - } else { - use std::io::Write; - std::io::stdout() - .write_all(output.as_bytes()) - .map_err(|e| e.to_string())?; - } - return Ok(0); - } - let sources = args - .inputs - .iter() - .filter(|input| input.source) - .collect::>(); - if sources.is_empty() { - if llvm { - if arguments == ["--version"] { - println!( - "dynamite-cc {} (LLVM tools backend)", - env!("CARGO_PKG_VERSION") - ); - return Ok(0); - } - if arguments == ["-dumpmachine"] { - println!("{}", llvm_tools::target_triple()?); - return Ok(0); - } - let _timer = Timer::new("link_or_other"); - llvm_tools::link(&args.link_arguments(&[]))?; - return Ok(0); - } - if arguments.iter().any(|arg| arg == "--version") { - println!("dynamite-cc {} (clang backend)", env!("CARGO_PKG_VERSION")); - } - let _timer = Timer::new("link_or_other"); - return status(Command::new(&clang).args(&args.forwarded)); - } - let temporary = TemporaryDirectory::new()?; - let workers = args.jobs.min(sources.len()); - let compile_one = |index: usize| { - std::panic::catch_unwind(|| compile(sources[index], index, &args, &clang, &temporary.0)) - .unwrap_or_else(|_| Err(format!("compilation failed for {}", sources[index].name))) - }; - let outputs = if workers == 1 { - (0..sources.len()) - .map(compile_one) - .collect::, _>>()? - } else { - let next = AtomicUsize::new(0); - let results = std::thread::scope(|scope| { - let handles = (0..workers) - .map(|_| { - scope.spawn(|| { - let mut completed = vec![]; - loop { - let index = next.fetch_add(1, Ordering::Relaxed); - if index >= sources.len() { - break; - } - completed.push((index, compile_one(index))); - } - completed - }) - }) - .collect::>(); - handles - .into_iter() - .flat_map(|h| h.join().unwrap()) - .collect::>() - }); - let mut results = results; - results.sort_by_key(|(index, _)| *index); - results - .into_iter() - .map(|(_, output)| output) - .collect::, _>>()? - }; - if args.mode != Mode::Link { - return Ok(0); - } - let arguments = args.link_arguments(&outputs); - let _timer = Timer::new("link"); - if llvm { - llvm_tools::link(&arguments)?; - Ok(0) - } else { - status(Command::new(&clang).args(&arguments)) - } -} - -fn main() { - let arguments = std::env::args().skip(1).collect::>(); - match run(&arguments) { - Ok(code) => std::process::exit(code), - Err(message) => { - eprintln!("dynamite-cc: {message}"); - std::process::exit(1); - } - } -} diff --git a/src/bin/dynamite-cc/llvm_tools.rs b/src/bin/dynamite-cc/llvm_tools.rs index 074b02b..2298974 100644 --- a/src/bin/dynamite-cc/llvm_tools.rs +++ b/src/bin/dynamite-cc/llvm_tools.rs @@ -1,5 +1,10 @@ //! External LLVM tools for supported native GNU and Darwin toolchains. -use std::{fs, path::PathBuf, process::Command}; +mod darwin; +mod gnu; + +use darwin::link_macos; +use gnu::link_gnu; +use std::process::Command; use dynamite_compiler::timing::Timer; @@ -198,289 +203,9 @@ pub(super) fn lower( execute(&mut llc) } -fn gcc_runtime() -> Result { - if let Some(path) = std::env::var_os("DYNAMITE_GCC_RUNTIME") { - let path = PathBuf::from(path); - if path.join("crtbeginS.o").is_file() && path.join("crtendS.o").is_file() { - return Ok(path); - } - return Err("DYNAMITE_GCC_RUNTIME must contain crtbeginS.o and crtendS.o".into()); - } - let mut versions = fs::read_dir("/usr/lib/gcc/x86_64-linux-gnu") - .map_err(|error| { - format!("cannot find GNU runtime files; set DYNAMITE_GCC_RUNTIME: {error}") - })? - .filter_map(Result::ok) - .filter_map(|entry| { - let version = entry - .file_name() - .to_string_lossy() - .split('.') - .map(str::parse::) - .collect::, _>>() - .ok()?; - let path = entry.path(); - (path.join("crtbeginS.o").is_file() && path.join("crtendS.o").is_file()) - .then_some((version, path)) - }) - .collect::>(); - versions.sort_by(|a, b| b.0.cmp(&a.0)); - versions - .into_iter() - .next() - .map(|(_, path)| path) - .ok_or_else(|| "cannot find GNU runtime files; set DYNAMITE_GCC_RUNTIME".into()) -} - pub(super) fn link(arguments: &[String]) -> Result<(), String> { if cfg!(target_os = "macos") { return link_macos(arguments); } link_gnu(arguments) } - -fn link_gnu(arguments: &[String]) -> Result<(), String> { - let runtime = gcc_runtime()?; - let system = PathBuf::from("/usr/lib/x86_64-linux-gnu"); - let shared = arguments.iter().any(|arg| arg == "-shared"); - let pie = !shared - && arguments - .iter() - .rev() - .find(|arg| matches!(arg.as_str(), "-pie" | "-no-pie")) - .is_none_or(|arg| arg != "-no-pie"); - let mut command = tool("DYNAMITE_LLD", "ld.lld"); - command.arg("--eh-frame-hdr"); - if shared { - command.arg("-shared"); - } else { - if pie { - command.arg("-pie"); - } - command.args(["-dynamic-linker", "/lib64/ld-linux-x86-64.so.2"]); - command.arg(system.join(if pie { "Scrt1.o" } else { "crt1.o" })); - } - command - .arg(system.join("crti.o")) - .arg(runtime.join(if shared || pie { - "crtbeginS.o" - } else { - "crtbegin.o" - })); - let mut index = 0; - while index < arguments.len() { - let argument = &arguments[index]; - match argument.as_str() { - "-o" | "-L" | "-l" | "-Xlinker" => { - if argument != "-Xlinker" { - command.arg(argument); - } - index += 1; - command.arg( - arguments - .get(index) - .ok_or_else(|| format!("{argument} requires an argument"))?, - ); - } - "-pthread" => { - command.arg("-lpthread"); - } - "-rdynamic" => { - command.arg("--export-dynamic"); - } - "-shared" | "-pie" | "-no-pie" => {} - _ if argument.starts_with("-Wl,") => { - command.args(argument[4..].split(',')); - } - _ if argument.starts_with("-O") - || (argument.starts_with("-W") && !argument.starts_with("-Wa,")) - || matches!( - argument.as_str(), - "-g" | "-g0" - | "-ggdb" - | "-fPIC" - | "-fpic" - | "-fPIE" - | "-fpie" - | "-fomit-frame-pointer" - | "-fno-omit-frame-pointer" - ) => {} - _ if argument.starts_with("-L") || argument.starts_with("-l") || argument == "-s" => { - command.arg(argument); - } - _ if argument.starts_with('-') => { - return Err(format!("unsupported LLVM tools linker option: {argument}")); - } - _ => { - if !matches!( - std::path::Path::new(argument) - .extension() - .and_then(|part| part.to_str()), - Some("o" | "a" | "so") - ) && !argument.contains(".so.") - { - return Err(format!("unsupported LLVM tools linker input: {argument}")); - } - command.arg(argument); - } - } - index += 1; - } - command - .arg(format!("-L{}", runtime.display())) - .arg("-L/usr/lib/x86_64-linux-gnu") - .arg("-L/lib/x86_64-linux-gnu") - .args(["-lc", "-lgcc", "--as-needed", "-lgcc_s", "--no-as-needed"]) - .arg(runtime.join(if shared || pie { - "crtendS.o" - } else { - "crtend.o" - })) - .arg(system.join("crtn.o")); - execute(&mut command) -} - -fn link_macos(arguments: &[String]) -> Result<(), String> { - let mut sdk = None; - for (index, argument) in arguments.iter().enumerate() { - if argument == "-isysroot" { - sdk = Some(PathBuf::from( - arguments - .get(index + 1) - .ok_or("-isysroot requires an argument")?, - )); - } else if let Some(root) = argument.strip_prefix("-isysroot") { - sdk = Some(PathBuf::from(root)); - } - } - let sdk = sdk - .map(Ok) - .unwrap_or_else(dynamite_compiler::toolchain::macos_sdk_root)?; - let version = Command::new("/usr/bin/xcrun") - .arg("--sdk") - .arg(&sdk) - .arg("--show-sdk-version") - .output() - .map_err(|e| format!("cannot read macOS SDK version: {e}"))?; - if !version.status.success() { - return Err("cannot read macOS SDK version".into()); - } - let version = String::from_utf8(version.stdout).map_err(|e| e.to_string())?; - dynamite_compiler::toolchain::macos_version_number(version.trim())?; - let minimum = dynamite_compiler::toolchain::macos_deployment_target()?; - let mut command = tool("DYNAMITE_LD", "/usr/bin/ld"); - command - .args([ - "-arch", - if cfg!(target_arch = "aarch64") { - "arm64" - } else { - "x86_64" - }, - ]) - .arg("-syslibroot") - .arg(&sdk) - .args(["-platform_version", "macos", &minimum, version.trim()]); - let dylib = arguments - .iter() - .any(|a| matches!(a.as_str(), "-shared" | "-dynamiclib")); - let bundle = arguments.iter().any(|a| a == "-bundle"); - if dylib && bundle { - return Err("cannot combine a dynamic library and a bundle".into()); - } - if dylib { - command.arg("-dylib"); - } - if bundle { - command.arg("-bundle"); - } - let mut index = 0; - while index < arguments.len() { - let argument = &arguments[index]; - match argument.as_str() { - "-o" - | "-L" - | "-l" - | "-framework" - | "-F" - | "-iframework" - | "-Xlinker" - | "-undefined" - | "-install_name" - | "-rpath" - | "-compatibility_version" - | "-current_version" - | "-isysroot" => { - let value = arguments - .get(index + 1) - .ok_or_else(|| format!("{argument} requires an argument"))?; - if argument != "-isysroot" { - if argument != "-Xlinker" { - command.arg(if argument == "-iframework" { - "-F" - } else { - argument - }); - } - command.arg(value); - } - index += 1; - } - "-shared" | "-dynamiclib" | "-bundle" | "-dynamic" | "-pthread" => {} - "-rdynamic" => { - command.arg("-export_dynamic"); - } - "-no-pie" => { - command.arg("-no_pie"); - } - "-pie" | "-s" => { - command.arg(argument); - } - _ if argument.starts_with("-Wl,") => { - command.args(argument[4..].split(',')); - } - _ if argument.starts_with("-iframework") => { - command.arg("-F").arg(&argument[11..]); - } - _ if argument.starts_with("-isysroot") - || argument.starts_with("-O") - || (argument.starts_with("-W") && !argument.starts_with("-Wa,")) - || matches!( - argument.as_str(), - "-g" | "-g0" - | "-ggdb" - | "-fPIC" - | "-fpic" - | "-fPIE" - | "-fpie" - | "-fomit-frame-pointer" - | "-fno-omit-frame-pointer" - | "-fno-common" - | "-fno-strict-aliasing" - ) => {} - _ if argument.starts_with("-F") - || argument.starts_with("-L") - || argument.starts_with("-l") => - { - command.arg(argument); - } - _ if argument.starts_with('-') => { - return Err(format!("unsupported LLVM tools linker option: {argument}")); - } - _ => { - if !matches!( - std::path::Path::new(argument) - .extension() - .and_then(|s| s.to_str()), - Some("o" | "a" | "dylib" | "tbd") - ) { - return Err(format!("unsupported LLVM tools linker input: {argument}")); - } - command.arg(argument); - } - } - index += 1; - } - command.arg("-lSystem"); - execute(&mut command) -} diff --git a/src/bin/dynamite-cc/llvm_tools/darwin.rs b/src/bin/dynamite-cc/llvm_tools/darwin.rs new file mode 100644 index 0000000..7823c7d --- /dev/null +++ b/src/bin/dynamite-cc/llvm_tools/darwin.rs @@ -0,0 +1,149 @@ +//! Native Darwin SDK and linker arguments. + +use super::{execute, tool}; +use std::{path::PathBuf, process::Command}; + +pub(super) fn link_macos(arguments: &[String]) -> Result<(), String> { + let mut sdk = None; + for (index, argument) in arguments.iter().enumerate() { + if argument == "-isysroot" { + sdk = Some(PathBuf::from( + arguments + .get(index + 1) + .ok_or("-isysroot requires an argument")?, + )); + } else if let Some(root) = argument.strip_prefix("-isysroot") { + sdk = Some(PathBuf::from(root)); + } + } + let sdk = sdk + .map(Ok) + .unwrap_or_else(dynamite_compiler::toolchain::macos_sdk_root)?; + let version = Command::new("/usr/bin/xcrun") + .arg("--sdk") + .arg(&sdk) + .arg("--show-sdk-version") + .output() + .map_err(|e| format!("cannot read macOS SDK version: {e}"))?; + if !version.status.success() { + return Err("cannot read macOS SDK version".into()); + } + let version = String::from_utf8(version.stdout).map_err(|e| e.to_string())?; + dynamite_compiler::toolchain::macos_version_number(version.trim())?; + let minimum = dynamite_compiler::toolchain::macos_deployment_target()?; + let mut command = tool("DYNAMITE_LD", "/usr/bin/ld"); + command + .args([ + "-arch", + if cfg!(target_arch = "aarch64") { + "arm64" + } else { + "x86_64" + }, + ]) + .arg("-syslibroot") + .arg(&sdk) + .args(["-platform_version", "macos", &minimum, version.trim()]); + let dylib = arguments + .iter() + .any(|a| matches!(a.as_str(), "-shared" | "-dynamiclib")); + let bundle = arguments.iter().any(|a| a == "-bundle"); + if dylib && bundle { + return Err("cannot combine a dynamic library and a bundle".into()); + } + if dylib { + command.arg("-dylib"); + } + if bundle { + command.arg("-bundle"); + } + let mut index = 0; + while index < arguments.len() { + let argument = &arguments[index]; + match argument.as_str() { + "-o" + | "-L" + | "-l" + | "-framework" + | "-F" + | "-iframework" + | "-Xlinker" + | "-undefined" + | "-install_name" + | "-rpath" + | "-compatibility_version" + | "-current_version" + | "-isysroot" => { + let value = arguments + .get(index + 1) + .ok_or_else(|| format!("{argument} requires an argument"))?; + if argument != "-isysroot" { + if argument != "-Xlinker" { + command.arg(if argument == "-iframework" { + "-F" + } else { + argument + }); + } + command.arg(value); + } + index += 1; + } + "-shared" | "-dynamiclib" | "-bundle" | "-dynamic" | "-pthread" => {} + "-rdynamic" => { + command.arg("-export_dynamic"); + } + "-no-pie" => { + command.arg("-no_pie"); + } + "-pie" | "-s" => { + command.arg(argument); + } + _ if argument.starts_with("-Wl,") => { + command.args(argument[4..].split(',')); + } + _ if argument.starts_with("-iframework") => { + command.arg("-F").arg(&argument[11..]); + } + _ if argument.starts_with("-isysroot") + || argument.starts_with("-O") + || (argument.starts_with("-W") && !argument.starts_with("-Wa,")) + || matches!( + argument.as_str(), + "-g" | "-g0" + | "-ggdb" + | "-fPIC" + | "-fpic" + | "-fPIE" + | "-fpie" + | "-fomit-frame-pointer" + | "-fno-omit-frame-pointer" + | "-fno-common" + | "-fno-strict-aliasing" + ) => {} + _ if argument.starts_with("-F") + || argument.starts_with("-L") + || argument.starts_with("-l") => + { + command.arg(argument); + } + _ if argument.starts_with('-') => { + return Err(format!("unsupported LLVM tools linker option: {argument}")); + } + _ => { + if !matches!( + std::path::Path::new(argument) + .extension() + .and_then(|s| s.to_str()), + Some("o" | "a" | "dylib" | "tbd") + ) { + return Err(format!("unsupported LLVM tools linker input: {argument}")); + } + command.arg(argument); + } + } + index += 1; + } + command.arg("-lSystem"); + execute(&mut command) +} diff --git a/src/bin/dynamite-cc/llvm_tools/gnu.rs b/src/bin/dynamite-cc/llvm_tools/gnu.rs new file mode 100644 index 0000000..250cd92 --- /dev/null +++ b/src/bin/dynamite-cc/llvm_tools/gnu.rs @@ -0,0 +1,139 @@ +//! GNU runtime discovery and native ELF linking. + +use super::{execute, tool}; +use std::{fs, path::PathBuf}; + +fn gcc_runtime() -> Result { + if let Some(path) = std::env::var_os("DYNAMITE_GCC_RUNTIME") { + let path = PathBuf::from(path); + if path.join("crtbeginS.o").is_file() && path.join("crtendS.o").is_file() { + return Ok(path); + } + return Err("DYNAMITE_GCC_RUNTIME must contain crtbeginS.o and crtendS.o".into()); + } + let mut versions = fs::read_dir("/usr/lib/gcc/x86_64-linux-gnu") + .map_err(|error| { + format!("cannot find GNU runtime files; set DYNAMITE_GCC_RUNTIME: {error}") + })? + .filter_map(Result::ok) + .filter_map(|entry| { + let version = entry + .file_name() + .to_string_lossy() + .split('.') + .map(str::parse::) + .collect::, _>>() + .ok()?; + let path = entry.path(); + (path.join("crtbeginS.o").is_file() && path.join("crtendS.o").is_file()) + .then_some((version, path)) + }) + .collect::>(); + versions.sort_by(|a, b| b.0.cmp(&a.0)); + versions + .into_iter() + .next() + .map(|(_, path)| path) + .ok_or_else(|| "cannot find GNU runtime files; set DYNAMITE_GCC_RUNTIME".into()) +} + +pub(super) fn link_gnu(arguments: &[String]) -> Result<(), String> { + let runtime = gcc_runtime()?; + let system = PathBuf::from("/usr/lib/x86_64-linux-gnu"); + let shared = arguments.iter().any(|arg| arg == "-shared"); + let pie = !shared + && arguments + .iter() + .rev() + .find(|arg| matches!(arg.as_str(), "-pie" | "-no-pie")) + .is_none_or(|arg| arg != "-no-pie"); + let mut command = tool("DYNAMITE_LLD", "ld.lld"); + command.arg("--eh-frame-hdr"); + if shared { + command.arg("-shared"); + } else { + if pie { + command.arg("-pie"); + } + command.args(["-dynamic-linker", "/lib64/ld-linux-x86-64.so.2"]); + command.arg(system.join(if pie { "Scrt1.o" } else { "crt1.o" })); + } + command + .arg(system.join("crti.o")) + .arg(runtime.join(if shared || pie { + "crtbeginS.o" + } else { + "crtbegin.o" + })); + let mut index = 0; + while index < arguments.len() { + let argument = &arguments[index]; + match argument.as_str() { + "-o" | "-L" | "-l" | "-Xlinker" => { + if argument != "-Xlinker" { + command.arg(argument); + } + index += 1; + command.arg( + arguments + .get(index) + .ok_or_else(|| format!("{argument} requires an argument"))?, + ); + } + "-pthread" => { + command.arg("-lpthread"); + } + "-rdynamic" => { + command.arg("--export-dynamic"); + } + "-shared" | "-pie" | "-no-pie" => {} + _ if argument.starts_with("-Wl,") => { + command.args(argument[4..].split(',')); + } + _ if argument.starts_with("-O") + || (argument.starts_with("-W") && !argument.starts_with("-Wa,")) + || matches!( + argument.as_str(), + "-g" | "-g0" + | "-ggdb" + | "-fPIC" + | "-fpic" + | "-fPIE" + | "-fpie" + | "-fomit-frame-pointer" + | "-fno-omit-frame-pointer" + ) => {} + _ if argument.starts_with("-L") || argument.starts_with("-l") || argument == "-s" => { + command.arg(argument); + } + _ if argument.starts_with('-') => { + return Err(format!("unsupported LLVM tools linker option: {argument}")); + } + _ => { + if !matches!( + std::path::Path::new(argument) + .extension() + .and_then(|part| part.to_str()), + Some("o" | "a" | "so") + ) && !argument.contains(".so.") + { + return Err(format!("unsupported LLVM tools linker input: {argument}")); + } + command.arg(argument); + } + } + index += 1; + } + command + .arg(format!("-L{}", runtime.display())) + .arg("-L/usr/lib/x86_64-linux-gnu") + .arg("-L/lib/x86_64-linux-gnu") + .args(["-lc", "-lgcc", "--as-needed", "-lgcc_s", "--no-as-needed"]) + .arg(runtime.join(if shared || pie { + "crtendS.o" + } else { + "crtend.o" + })) + .arg(system.join("crtn.o")); + execute(&mut command) +} diff --git a/src/bin/dynamite-cc/main.rs b/src/bin/dynamite-cc/main.rs new file mode 100644 index 0000000..dd71b73 --- /dev/null +++ b/src/bin/dynamite-cc/main.rs @@ -0,0 +1,366 @@ +//! Native C build driver with external Clang or LLVM tools. + +mod arguments; +mod llvm_tools; + +use dynamite_compiler::timing::Timer; +use std::{ + borrow::Cow, + fs, + path::{Path, PathBuf}, + process::Command, + sync::atomic::{AtomicUsize, Ordering}, +}; + +#[derive(Clone, Copy, PartialEq)] +enum Mode { + Link, + Object, + Assembly, +} + +struct Input { + name: String, + source: bool, +} + +enum LinkArgument { + Option(String), + Input(usize), +} + +struct Arguments { + inputs: Vec, + backend: Vec, + linker: Vec, + preprocessing: Vec, + forwarded: Vec, + output: Option, + mode: Mode, + jobs: usize, + dependencies: Option, + dependency_file: Option, + dependency_targets: Vec, + phony_dependencies: bool, + preprocess_only: bool, + emit_llvm: bool, +} + +struct TemporaryDirectory(PathBuf); +impl TemporaryDirectory { + fn new() -> Result { + let stamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_err(|e| e.to_string())? + .as_nanos(); + for attempt in 0..100 { + let path = std::env::temp_dir().join(format!( + "dynamite-cc-{}-{stamp}-{attempt}", + std::process::id() + )); + match fs::create_dir(&path) { + Ok(()) => return Ok(Self(path)), + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue, + Err(e) => return Err(e.to_string()), + } + } + Err("failed to create compilation directory".into()) + } +} +impl Drop for TemporaryDirectory { + fn drop(&mut self) { + let _ = fs::remove_dir_all(&self.0); + } +} + +fn status(command: &mut Command) -> Result { + command + .status() + .map(|status| status.code().unwrap_or(1)) + .map_err(|error| format!("failed to run Clang: {error}")) +} + +fn compile( + input: &Input, + index: usize, + args: &Arguments, + clang: &str, + temporary: &Path, +) -> Result { + let output = if args.mode == Mode::Link { + temporary.join(format!("{index}.o")) + } else { + args.output_for(input) + }; + let mut preprocessing = args.preprocessing.clone(); + if let Some(system) = args.dependencies { + let dependency_output = if args.mode == Mode::Link { + Cow::Owned(PathBuf::from(args.output.as_deref().unwrap_or("a.out"))) + } else { + Cow::Borrowed(&output) + }; + let default_dependency_file = if args.mode == Mode::Link + && args.inputs.iter().filter(|input| input.source).count() > 1 + { + PathBuf::from(format!("{}-{index}.d", dependency_output.display())) + } else { + dependency_output.with_extension("d") + }; + preprocessing.extend([ + if system { "-MD" } else { "-MMD" }.into(), + "-MF".into(), + args.dependency_file + .as_ref() + .map(PathBuf::from) + .unwrap_or(default_dependency_file) + .to_string_lossy() + .into_owned(), + ]); + if args.dependency_targets.is_empty() { + preprocessing.extend([ + "-MQ".into(), + dependency_output.to_string_lossy().into_owned(), + ]); + } else { + preprocessing.extend(args.dependency_targets.clone()); + } + if args.phony_dependencies { + preprocessing.push("-MP".into()); + } + } + let timer = Timer::new("frontend_total"); + let one_shot = + args.mode != Mode::Link && args.inputs.iter().filter(|input| input.source).count() == 1; + let generate = if one_shot { + dynamite_compiler::generate_file_once + } else { + dynamite_compiler::generate_file + }; + let ir = generate(Path::new(&input.name), "llvm", false, &preprocessing)?; + drop(timer); + let ir_path = temporary.join(format!("{index}.ll")); + { + let _timer = Timer::new("write_ir"); + fs::write(&ir_path, &ir).map_err(|e| format!("failed to write LLVM IR: {e}"))?; + } + if llvm_tools::selected()? { + let _timer = Timer::new("lower"); + llvm_tools::lower( + &args.backend, + &ir_path, + &output, + args.mode == Mode::Assembly, + )?; + return Ok(output); + } + let mut command = Command::new(clang); + let mut backend_index = 0; + while backend_index < args.backend.len() { + let arg = &args.backend[backend_index]; + if matches!(arg.as_str(), "-L" | "-l" | "-framework" | "-Xlinker") { + backend_index += 2; + continue; + } + if !(arg.starts_with("-Wl,") + || arg.starts_with("-L") + || arg.starts_with("-l") + || arg.starts_with("-fuse-ld=") + || matches!( + arg.as_str(), + "-shared" | "-dynamiclib" | "-static" | "-pie" | "-no-pie" | "-rdynamic" | "-s" + )) + { + command.arg(arg); + } + backend_index += 1; + } + command + .arg(if args.mode == Mode::Assembly { + "-S" + } else { + "-c" + }) + .arg(&ir_path) + .arg("-o") + .arg(&output) + .arg("-Wno-override-module"); + let _timer = Timer::new("lower"); + let code = status(&mut command)?; + if code != 0 { + return Err(format!("LLVM lowering failed for {}", input.name)); + } + Ok(output) +} + +/// Run the C build driver. C inputs always pass through the Dynamite frontend. +/// `--jobs N` bounds independent translation units; the default is one worker. +fn run(arguments: &[String]) -> Result { + if arguments.iter().any(|arg| arg == "--help" || arg == "-h") { + println!( + "Usage: dynamite-cc [--jobs N] [Clang options] FILE...\nCompile C through Dynamite. DYNAMITE_BACKEND=llvm selects external llc/opt and a native linker on Linux x86_64 GNU or macOS; the default backend is Clang. Supports -c, -S, -o, -I/-D/-U, and dependency files. Default: one worker." + ); + return Ok(0); + } + let args = Arguments::parse(arguments)?; + let llvm = llvm_tools::selected()?; + let clang = std::env::var("DYNAMITE_CLANG").unwrap_or_else(|_| "clang".into()); + if args.preprocess_only { + let native_backend_option = |arg: &String| { + arg.starts_with("-O") + || arg.starts_with("-W") + || arg.starts_with("-g") + || matches!(arg.as_str(), "-pthread" | "-pedantic") + }; + let mut backend_index = 0; + let mut unsupported = None; + while backend_index < args.backend.len() { + let option = &args.backend[backend_index]; + if cfg!(target_os = "macos") + && matches!(option.as_str(), "-F" | "-iframework" | "-isysroot") + { + backend_index += 2; + } else if native_backend_option(option) + || cfg!(target_os = "macos") + && (option.starts_with("-F") + || option.starts_with("-iframework") + || option.starts_with("-isysroot")) + { + backend_index += 1; + } else { + unsupported = Some(option); + break; + } + } + let native_dependencies = args + .forwarded + .iter() + .any(|arg| matches!(arg.as_str(), "-M" | "-MM")); + if args.inputs.is_empty() { + return Err("native preprocessing requires a source file".into()); + } + let _timer = Timer::new(if native_dependencies { + "dependency_scan" + } else { + "preprocess_only" + }); + if let Some(option) = unsupported { + return Err(format!("unsupported native preprocessing option: {option}")); + } + let mut preprocessing = args.preprocessing.clone(); + for flag in ["-M", "-MM", "-P", "-MP"] { + if args.forwarded.iter().any(|arg| arg == flag) { + preprocessing.push(flag.into()); + } + } + if let Some(file) = &args.dependency_file { + preprocessing.extend(["-MF".into(), file.clone()]); + } + preprocessing.extend(args.dependency_targets.clone()); + let paths = args + .inputs + .iter() + .map(|input| PathBuf::from(&input.name)) + .collect::>(); + let output = + dynamite_compiler::preprocessor::preprocess_files_native(&paths, &preprocessing)?; + if let Some(path) = &args.output { + fs::write(path, output).map_err(|e| e.to_string())?; + } else { + use std::io::Write; + std::io::stdout() + .write_all(output.as_bytes()) + .map_err(|e| e.to_string())?; + } + return Ok(0); + } + let sources = args + .inputs + .iter() + .filter(|input| input.source) + .collect::>(); + if sources.is_empty() { + if llvm { + if arguments == ["--version"] { + println!( + "dynamite-cc {} (LLVM tools backend)", + env!("CARGO_PKG_VERSION") + ); + return Ok(0); + } + if arguments == ["-dumpmachine"] { + println!("{}", llvm_tools::target_triple()?); + return Ok(0); + } + let _timer = Timer::new("link_or_other"); + llvm_tools::link(&args.link_arguments(&[]))?; + return Ok(0); + } + if arguments.iter().any(|arg| arg == "--version") { + println!("dynamite-cc {} (clang backend)", env!("CARGO_PKG_VERSION")); + } + let _timer = Timer::new("link_or_other"); + return status(Command::new(&clang).args(&args.forwarded)); + } + let temporary = TemporaryDirectory::new()?; + let workers = args.jobs.min(sources.len()); + let compile_one = |index: usize| { + std::panic::catch_unwind(|| compile(sources[index], index, &args, &clang, &temporary.0)) + .unwrap_or_else(|_| Err(format!("compilation failed for {}", sources[index].name))) + }; + let outputs = if workers == 1 { + (0..sources.len()) + .map(compile_one) + .collect::, _>>()? + } else { + let next = AtomicUsize::new(0); + let results = std::thread::scope(|scope| { + let handles = (0..workers) + .map(|_| { + scope.spawn(|| { + let mut completed = vec![]; + loop { + let index = next.fetch_add(1, Ordering::Relaxed); + if index >= sources.len() { + break; + } + completed.push((index, compile_one(index))); + } + completed + }) + }) + .collect::>(); + handles + .into_iter() + .flat_map(|h| h.join().unwrap()) + .collect::>() + }); + let mut results = results; + results.sort_by_key(|(index, _)| *index); + results + .into_iter() + .map(|(_, output)| output) + .collect::, _>>()? + }; + if args.mode != Mode::Link { + return Ok(0); + } + let arguments = args.link_arguments(&outputs); + let _timer = Timer::new("link"); + if llvm { + llvm_tools::link(&arguments)?; + Ok(0) + } else { + status(Command::new(&clang).args(&arguments)) + } +} + +fn main() { + let arguments = std::env::args().skip(1).collect::>(); + match run(&arguments) { + Ok(code) => std::process::exit(code), + Err(message) => { + eprintln!("dynamite-cc: {message}"); + std::process::exit(1); + } + } +} diff --git a/src/generator/mod.rs b/src/generator/mod.rs index 7d88502..2724dde 100644 --- a/src/generator/mod.rs +++ b/src/generator/mod.rs @@ -1,3 +1,5 @@ +use crate::{ast::ProgramAst, error::ErrorLogger}; + pub mod aarch64; pub mod abi; pub mod llvm; @@ -14,6 +16,13 @@ pub enum Arch { X86_64, } +#[derive(Clone, Copy)] +pub enum ScalarLocation { + General(usize), + Floating(usize), + Stack(usize, usize), +} + /// Register width requested by the supported GNU target operand modifiers. pub(crate) fn asm_register_width( arch: Arch, @@ -30,8 +39,6 @@ pub(crate) fn asm_register_width( } } -use crate::{ast::ProgramAst, error::ErrorLogger}; - /// References reachable from emitted definitions and global initializers. /// Unreferenced static inline bodies must not create linker dependencies. pub(crate) fn referenced_symbols<'a>( @@ -132,13 +139,6 @@ pub fn new<'a>( } } -#[derive(Clone, Copy)] -pub enum ScalarLocation { - General(usize), - Floating(usize), - Stack(usize, usize), -} - pub fn scalar_arguments( types: &[crate::ctype::Type], general_limit: usize, diff --git a/src/lib.rs b/src/lib.rs index a59960e..6f07f9a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,6 +11,7 @@ pub mod preprocessor; pub mod timing; pub mod token; pub mod tokenizer; +pub mod toolchain; pub mod trie; use ast::{AstBuilder, ProgramAst}; @@ -156,5 +157,3 @@ fn gen_asm(ast: ProgramAst, error_printer: &dyn error::ErrorLogger) -> String { fn gen_llvm_ir(ast: ProgramAst, error_printer: &dyn error::ErrorLogger) -> String { generator::llvm::generator::IrGenerator::new(error_printer).generate(ast) } - -pub mod toolchain; diff --git a/src/node.rs b/src/node.rs index 621c626..5ae1281 100644 --- a/src/node.rs +++ b/src/node.rs @@ -23,45 +23,6 @@ pub enum AtomicOperation { CompareExchange(bool), } -/// Decode GNU numbered register operands, leaving target-specific modifiers to the backend. -pub(crate) fn render_inline_assembly( - template: &str, - mut operand: impl FnMut(usize, Option) -> Option, -) -> Option { - let mut rendered = String::new(); - let mut chars = template.chars().peekable(); - while let Some(ch) = chars.next() { - if ch != '%' { - rendered.push(ch); - continue; - } - if chars.peek() == Some(&'%') { - chars.next(); - rendered.push('%'); - continue; - } - let modifier = chars - .peek() - .copied() - .filter(char::is_ascii_alphabetic) - .inspect(|_| { - chars.next(); - }); - let mut index = None; - while let Some(ch) = chars.peek().copied().filter(char::is_ascii_digit) { - chars.next(); - index = Some( - index - .unwrap_or(0usize) - .checked_mul(10)? - .checked_add(ch.to_digit(10)? as usize)?, - ); - } - rendered.push_str(&operand(index?, modifier)?); - } - Some(rendered) -} - #[derive(Debug, PartialEq, Clone)] pub enum NodeType { InlineAsm(bool, bool), @@ -671,6 +632,45 @@ impl std::fmt::Debug for Node { } } +/// Decode GNU numbered register operands, leaving target-specific modifiers to the backend. +pub(crate) fn render_inline_assembly( + template: &str, + mut operand: impl FnMut(usize, Option) -> Option, +) -> Option { + let mut rendered = String::new(); + let mut chars = template.chars().peekable(); + while let Some(ch) = chars.next() { + if ch != '%' { + rendered.push(ch); + continue; + } + if chars.peek() == Some(&'%') { + chars.next(); + rendered.push('%'); + continue; + } + let modifier = chars + .peek() + .copied() + .filter(char::is_ascii_alphabetic) + .inspect(|_| { + chars.next(); + }); + let mut index = None; + while let Some(ch) = chars.peek().copied().filter(char::is_ascii_digit) { + chars.next(); + index = Some( + index + .unwrap_or(0usize) + .checked_mul(10)? + .checked_add(ch.to_digit(10)? as usize)?, + ); + } + rendered.push_str(&operand(index?, modifier)?); + } + Some(rendered) +} + #[cfg(test)] mod tests { use super::*;