builtin headers

Author: jgarzik

cc/builtin_headers.rs

@@ -0,0 +1,58 @@
+//
+// Copyright (c) 2025-2026 Jeff Garzik
+//
+// This file is part of the posixutils-rs project covered under
+// the MIT License.  For the full license text, please see the LICENSE
+// file in the root directory of this project.
+// SPDX-License-Identifier: MIT
+//
+// Builtin headers for pcc
+//
+// These headers are embedded directly in the compiler binary and are
+// searched before system headers. They provide compiler-specific
+// implementations of standard headers like <stdarg.h> and <stddef.h>.
+//
+
+/// Builtin stdarg.h - variadic function support
+pub const STDARG_H: &str = include_str!("include/stdarg.h");
+
+/// Builtin stddef.h - standard type definitions
+pub const STDDEF_H: &str = include_str!("include/stddef.h");
+
+/// Look up a builtin header by name
+///
+/// Returns the header content if found, None otherwise.
+/// The name should be the basename without path (e.g., "stdarg.h").
+pub fn get_builtin_header(name: &str) -> Option<&'static str> {
+    match name {
+        "stdarg.h" => Some(STDARG_H),
+        "stddef.h" => Some(STDDEF_H),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_stdarg_exists() {
+        let header = get_builtin_header("stdarg.h");
+        assert!(header.is_some());
+        assert!(header.unwrap().contains("va_list"));
+        assert!(header.unwrap().contains("va_start"));
+    }
+
+    #[test]
+    fn test_stddef_exists() {
+        let header = get_builtin_header("stddef.h");
+        assert!(header.is_some());
+        assert!(header.unwrap().contains("size_t"));
+        assert!(header.unwrap().contains("NULL"));
+    }
+
+    #[test]
+    fn test_unknown_header() {
+        assert!(get_builtin_header("unknown.h").is_none());
+    }
+}

cc/cflow.rs

@@ -459,6 +459,8 @@ fn process_file(
         defines,
         undefines,
         include_paths,
+        false, // no_std_inc
+        false, // no_builtin_inc
     );
 
     // Create symbol table and type table

cc/ctags.rs

@@ -131,9 +131,11 @@ fn process_file(path: &str, streams: &mut StreamTable) -> io::Result<Vec<TagEntr
         &target,
         &mut strings,
         path,
-        &[], // No extra defines
-        &[], // No undefines
-        &[], // No include paths
+        &[],   // No extra defines
+        &[],   // No undefines
+        &[],   // No include paths
+        false, // no_std_inc
+        false, // no_builtin_inc
     );
 
     // Create symbol table and type table

cc/cxref.rs

@@ -384,6 +384,8 @@ fn process_file(
         defines,
         undefines,
         include_paths,
+        false, // no_std_inc
+        false, // no_builtin_inc
     );
 
     // Create symbol table and type table

cc/include/stdarg.h

@@ -0,0 +1,24 @@
+/*
+ * pcc builtin stdarg.h
+ *
+ * This file is part of the posixutils-rs project covered under
+ * the MIT License. For the full license text, please see the LICENSE
+ * file in the root directory of this project.
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef _STDARG_H
+#define _STDARG_H
+
+typedef __builtin_va_list va_list;
+
+#define va_start(ap, param) __builtin_va_start(ap, param)
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+#define va_copy(dest, src) __builtin_va_copy(dest, src)
+
+/* GCC compatibility */
+typedef __builtin_va_list __gnuc_va_list;
+#define __va_copy(dest, src) __builtin_va_copy(dest, src)
+
+#endif /* _STDARG_H */

cc/include/stddef.h

@@ -0,0 +1,26 @@
+/*
+ * pcc builtin stddef.h
+ *
+ * This file is part of the posixutils-rs project covered under
+ * the MIT License. For the full license text, please see the LICENSE
+ * file in the root directory of this project.
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef _STDDEF_H
+#define _STDDEF_H
+
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef __SIZE_TYPE__ size_t;
+typedef __WCHAR_TYPE__ wchar_t;
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#define offsetof(type, member) __builtin_offsetof(type, member)
+
+/* max_align_t - type with strictest alignment requirement */
+typedef long double max_align_t;
+
+#endif /* _STDDEF_H */

cc/lib.rs

@@ -13,6 +13,7 @@
 //
 
 pub mod arch;
+pub mod builtin_headers;
 pub mod diag;
 pub mod ir;
 pub mod opt;

cc/main.rs

@@ -10,6 +10,7 @@
 //
 
 mod arch;
+mod builtin_headers;
 mod diag;
 mod ir;
 mod opt;
@@ -85,6 +86,14 @@ struct Args {
     #[arg(short = 'I', action = clap::ArgAction::Append, value_name = "dir")]
     include_paths: Vec<String>,
 
+    /// Disable all standard include paths (system and builtin)
+    #[arg(long = "nostdinc", help = gettext("Disable standard system include paths"))]
+    no_std_inc: bool,
+
+    /// Disable builtin include paths only (keep system paths)
+    #[arg(long = "nobuiltininc", help = gettext("Disable builtin #include directories"))]
+    no_builtin_inc: bool,
+
     /// Compile and assemble, but do not link
     #[arg(short = 'c', help = gettext("Compile and assemble, but do not link"))]
     compile_only: bool,
@@ -124,6 +133,14 @@ struct Args {
     /// Pedantic mode (compatibility, currently no-op)
     #[arg(long = "pedantic", hide = true)]
     pedantic: bool,
+
+    /// Add library search path (passed to linker)
+    #[arg(short = 'L', action = clap::ArgAction::Append, value_name = "dir")]
+    lib_paths: Vec<String>,
+
+    /// Link library (passed to linker)
+    #[arg(short = 'l', action = clap::ArgAction::Append, value_name = "library")]
+    libraries: Vec<String>,
 }
 
 fn process_file(
@@ -194,6 +211,8 @@ fn process_file(
         &args.defines,
         &args.undefines,
         &args.include_paths,
+        args.no_std_inc,
+        args.no_builtin_inc,
     );
 
     if args.preprocess_only {
@@ -348,9 +367,17 @@ fn process_file(
     }
 
     // Link
-    let status = Command::new("cc")
-        .args(["-o", &exe_file, &temp_obj])
-        .status()?;
+    let mut link_cmd = Command::new("cc");
+    link_cmd.args(["-o", &exe_file, &temp_obj]);
+    // Add library search paths
+    for lib_path in &args.lib_paths {
+        link_cmd.arg(format!("-L{}", lib_path));
+    }
+    // Add libraries
+    for lib in &args.libraries {
+        link_cmd.arg(format!("-l{}", lib));
+    }
+    let status = link_cmd.status()?;
 
     let _ = std::fs::remove_file(&temp_obj);
 
@@ -365,19 +392,59 @@ fn process_file(
     Ok(())
 }
 
+/// Check if a string is a valid optimization level for -O
+fn is_valid_opt_level(s: &str) -> bool {
+    matches!(s, "0" | "1" | "2" | "3" | "s" | "z" | "fast" | "g")
+}
+
 /// Preprocess command-line arguments for gcc compatibility.
-/// Converts -Wall → -W all, -Wextra → -W extra, etc.
+/// - Converts -Wall → -W all, -Wextra → -W extra, etc.
+/// - Handles -O flag: standalone -O followed by non-level becomes -O1
 fn preprocess_args() -> Vec<String> {
-    std::env::args()
-        .flat_map(|arg| {
-            if arg.starts_with("-W") && arg.len() > 2 {
-                // -Wall → -W all, -Wextra → -W extra, etc.
-                vec!["-W".to_string(), arg[2..].to_string()]
-            } else {
-                vec![arg]
+    let raw_args: Vec<String> = std::env::args().collect();
+    let mut result = Vec::with_capacity(raw_args.len());
+    let mut i = 0;
+
+    while i < raw_args.len() {
+        let arg = &raw_args[i];
+
+        if arg == "-O" {
+            // Standalone -O: check if next arg is a valid optimization level
+            if i + 1 < raw_args.len() && is_valid_opt_level(&raw_args[i + 1]) {
+                // Next arg is a level like "1", "2", etc. - merge them
+                result.push(format!("-O{}", raw_args[i + 1]));
+                i += 2;
+                continue;
             }
-        })
-        .collect()
+            // Next arg is not a valid level (or no next arg) - use default -O1
+            result.push("-O1".to_string());
+            i += 1;
+        } else if arg.starts_with("-O") && arg.len() > 2 {
+            // -O0, -O1, -O2, -O3, -Os, -Oz, -Ofast, -Og - pass through
+            result.push(arg.clone());
+            i += 1;
+        } else if arg.starts_with("-W") && arg.len() > 2 {
+            // -Wall → -W all, -Wextra → -W extra, etc.
+            result.push("-W".to_string());
+            result.push(arg[2..].to_string());
+            i += 1;
+        } else if arg.starts_with("-L") && arg.len() > 2 {
+            // -L. → -L .
+            result.push("-L".to_string());
+            result.push(arg[2..].to_string());
+            i += 1;
+        } else if arg.starts_with("-l") && arg.len() > 2 {
+            // -lz → -l z
+            result.push("-l".to_string());
+            result.push(arg[2..].to_string());
+            i += 1;
+        } else {
+            result.push(arg.clone());
+            i += 1;
+        }
+    }
+
+    result
 }
 
 /// Check if a file is a C source file (by extension)
@@ -437,6 +504,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         for obj in &object_files {
             link_cmd.arg(*obj);
         }
+        // Add library search paths
+        for lib_path in &args.lib_paths {
+            link_cmd.arg(format!("-L{}", lib_path));
+        }
+        // Add libraries
+        for lib in &args.libraries {
+            link_cmd.arg(format!("-l{}", lib));
+        }
         let status = link_cmd.status()?;
         if !status.success() {
             eprintln!("pcc: linker failed");