Merge pull request #464 from rustcoreutils/updates

Updates

Author: jgarzik

cc/arch/codegen.rs

@@ -44,27 +44,17 @@ pub const PCC_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub fn generate_header_comments(target: &Target) -> Vec<String> {
     let mut comments = Vec::new();
 
-    // Compiler identification
-    comments.push(format!("Generated by pcc {}", PCC_VERSION));
-
     // Target triple (normalized format)
     let os_triple = match target.os {
         crate::target::Os::Linux => "unknown-linux-gnu",
         crate::target::Os::MacOS => "apple-darwin",
         crate::target::Os::FreeBSD => "unknown-freebsd",
     };
-    comments.push(format!("Target: {}-{}", target.arch, os_triple));
 
-    // ABI info
+    // Compiler identification with target
     comments.push(format!(
-        "ABI: LP64, pointer={}bit, long={}bit, char={}",
-        target.pointer_width,
-        target.long_width,
-        if target.char_signed {
-            "signed"
-        } else {
-            "unsigned"
-        }
+        "Generated by pcc {} ({}-{})",
+        PCC_VERSION, target.arch, os_triple
     ));
 
     comments

cc/diag.rs

@@ -18,10 +18,10 @@ use std::sync::atomic::{AtomicU32, Ordering};
 // Source Position
 // ============================================================================
 
-/// Source position tracking (mirrors sparse's struct position)
+/// Source position tracking for tokens and diagnostics.
 ///
-/// This is a compact structure that gets attached to every token.
-/// Following sparse's design where position fields are bit-packed.
+/// A compact structure attached to every token, tracking file, line,
+/// column, and preprocessor state (whitespace, newline flags).
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct Position {
     /// Stream/file index (which file this is in)
@@ -92,7 +92,7 @@ impl fmt::Display for Position {
 // Stream (Input Source)
 // ============================================================================
 
-/// Input stream information (following sparse's struct stream)
+/// Input stream information for tracking source files and includes.
 #[derive(Debug, Clone)]
 pub struct Stream {
     /// Filename

cc/doc/TODO.md

@@ -413,7 +413,7 @@ _Noreturn void exit(int status);
 
 ### Overview
 
-The compiler uses a sparse-style SSA IR, which is well-suited for classical optimizations. Passes are run iteratively until a fixed point is reached.
+The compiler uses an SSA-form IR, which is well-suited for classical optimizations. Passes are run iteratively until a fixed point is reached.
 
 ### Pass 1: SCCP - Sparse Conditional Constant Propagation
 

cc/ir/dominate.rs

@@ -8,7 +8,7 @@
 //
 // Dominator tree computation for pcc C99 compiler
 //
-// Based on sparse's flowgraph.c and dominate.c:
+// Algorithms used:
 // - Dominator tree: "A simple, fast dominance algorithm" by Cooper, Harvey, Kennedy
 // - IDF computation: "A Linear Time Algorithm for Placing phi-nodes" by Sreedhar and Gao
 //
@@ -39,7 +39,7 @@ fn compute_postorder(func: &mut Function) -> Vec<BasicBlockId> {
         visited.insert(bb_id);
 
         if let Some(bb) = func.get_block(bb_id) {
-            // Visit children in reverse order (like sparse)
+            // Visit children in reverse order for consistent numbering
             for &child in bb.children.iter().rev() {
                 dfs(func, child, visited, postorder);
             }

cc/ir/linearize.rs

@@ -7,7 +7,7 @@
 // SPDX-License-Identifier: MIT
 //
 // Linearizer for pcc C99 compiler
-// Converts AST to SSA-style IR following sparse's design
+// Converts AST to SSA-form IR with basic blocks and typed pseudo-registers
 //
 
 use super::ssa::ssa_convert;
@@ -2143,7 +2143,7 @@ impl<'a> Linearizer<'a> {
 
     /// Get the type of an expression.
     /// PANICS if expression has no type - type evaluation pass must run first.
-    /// Following sparse's design: the IR should ALWAYS receive fully typed input.
+    /// The IR requires fully typed input from the type evaluation pass.
     fn expr_type(&self, expr: &Expr) -> TypeId {
         expr.typ.expect(
             "BUG: expression has no type. Type evaluation pass must run before linearization.",

cc/ir/mod.rs

@@ -7,7 +7,7 @@
 // SPDX-License-Identifier: MIT
 //
 // Intermediate Representation (IR) for pcc C99 compiler
-// Based on sparse's linearize.c SSA-style IR
+// SSA-form IR with basic blocks and typed pseudo-registers
 //
 // The IR uses Single Static Assignment (SSA) form where each variable
 // is assigned exactly once. This simplifies dataflow analysis and
@@ -45,10 +45,10 @@ impl InsnRef {
 }
 
 // ============================================================================
-// Opcodes - Following sparse's opcode.def
+// Opcodes
 // ============================================================================
 
-/// IR opcodes following sparse's design
+/// IR opcodes for the intermediate representation
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Opcode {
     // Function entry

cc/ir/ssa.rs

@@ -8,8 +8,7 @@
 //
 // SSA Conversion for pcc C99 compiler
 //
-// Based on sparse's ssa.c:
-// - Converts memory-based local variables to SSA form
+// Converts memory-based local variables to SSA form:
 // - Inserts phi nodes at dominance frontiers
 // - Renames variables to complete SSA construction
 //

cc/main.rs

@@ -421,6 +421,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let source_files: Vec<&String> = args.files.iter().filter(|f| is_source_file(f)).collect();
     let object_files: Vec<&String> = args.files.iter().filter(|f| is_object_file(f)).collect();
 
+    // Warn about unrecognized file types
+    for file in &args.files {
+        if !is_source_file(file) && !is_object_file(file) {
+            eprintln!("pcc: warning: unrecognized file type: {}", file);
+        }
+    }
+
     // If we only have object files and an output is specified, just link them
     if source_files.is_empty() && !object_files.is_empty() && args.output.is_some() {
         let exe_file = args.output.clone().unwrap();

cc/parse/ast.rs

@@ -7,7 +7,7 @@
 // SPDX-License-Identifier: MIT
 //
 // Abstract Syntax Tree for pcc C99 compiler
-// Based on sparse's AST representation
+// Type-annotated AST for C99 with expressions, statements, and declarations
 //
 
 use crate::diag::Position;
@@ -108,15 +108,15 @@ pub enum AssignOp {
 // Expressions
 // ============================================================================
 
-/// An expression with type annotation (like sparse's expr->ctype)
+/// An expression with type annotation
 ///
-/// Following sparse's design, every expression carries its computed type.
-/// The type is filled in during type evaluation (after parsing, before linearization).
+/// Every expression carries its computed type, filled in during type evaluation
+/// (after parsing, before linearization).
 #[derive(Debug, Clone)]
 pub struct Expr {
     /// The expression kind/variant
     pub kind: ExprKind,
-    /// The computed type of this expression (like sparse's expr->ctype)
+    /// The computed type of this expression
     /// None before type evaluation, Some after (interned TypeId)
     pub typ: Option<TypeId>,
     /// Source position for debug info

cc/parse/parser.rs

@@ -7,7 +7,7 @@
 // SPDX-License-Identifier: MIT
 //
 // Parser for pcc C99 compiler
-// Based on sparse's expression.c recursive descent design
+// Recursive descent parser with Pratt-style precedence climbing
 //
 
 use super::ast::{
@@ -181,15 +181,15 @@ impl fmt::Display for AttributeList {
 
 /// C expression parser using recursive descent with precedence climbing
 ///
-/// Following sparse's design, the parser binds symbols to the symbol table
-/// during parsing. This means that by the time parsing is complete, all
-/// declared symbols are in the table with their types.
+/// The parser binds symbols to the symbol table during parsing. This means
+/// that by the time parsing is complete, all declared symbols are in the
+/// table with their types.
 pub struct Parser<'a> {
     /// Token stream
     tokens: &'a [Token],
     /// Identifier table for looking up names
     idents: &'a IdentTable,
-    /// Symbol table for binding declarations (like sparse's bind_symbol)
+    /// Symbol table for binding declarations
     symbols: &'a mut SymbolTable,
     /// Type table for interning types
     types: &'a mut TypeTable,
@@ -1576,26 +1576,20 @@ impl<'a> Parser<'a> {
                                     // Now expect parameter list
                     if self.is_special(b'(') {
                         self.advance(); // consume '('
-                                        // Parse parameter types (simplified - just skip them for now)
-                                        // Full implementation would build proper function type
-                        let mut param_depth = 1;
-                        while param_depth > 0 && !self.is_eof() {
-                            if self.is_special(b'(') {
-                                param_depth += 1;
-                            } else if self.is_special(b')') {
-                                param_depth -= 1;
-                            }
-                            if param_depth > 0 {
-                                self.advance();
+                                        // Parse parameter types properly
+                        if let Ok((params, variadic)) = self.parse_parameter_list() {
+                            if !self.is_special(b')') {
+                                return None;
                             }
+                            self.advance(); // consume final ')'
+                                            // Create function pointer type with actual parameter types
+                            let param_type_ids: Vec<TypeId> =
+                                params.iter().map(|p| p.typ).collect();
+                            let fn_type = Type::function(result_id, param_type_ids, variadic);
+                            let fn_type_id = self.types.intern(fn_type);
+                            result_id = self.types.intern(Type::pointer(fn_type_id));
+                            return Some(result_id);
                         }
-                        self.advance(); // consume final ')'
-                                        // Create function pointer type: pointer to function returning result_id
-                                        // For now, create a generic function pointer (void -> result_id)
-                        let fn_type = Type::function(result_id, vec![], false);
-                        let fn_type_id = self.types.intern(fn_type);
-                        result_id = self.types.intern(Type::pointer(fn_type_id));
-                        return Some(result_id);
                     }
                 }
             }
@@ -2921,9 +2915,9 @@ impl Parser<'_> {
 
     /// Parse a compound statement (block) with its own scope
     ///
-    /// Like sparse, blocks create their own scope for local declarations.
-    /// This enters a new scope, parses the block, binds any declarations,
-    /// then leaves the scope.
+    /// Blocks create their own scope for local declarations. This enters a
+    /// new scope, parses the block, binds any declarations, then leaves
+    /// the scope.
     fn parse_block_stmt(&mut self) -> ParseResult<Stmt> {
         self.expect_special(b'{')?;
 
@@ -3066,8 +3060,8 @@ impl Parser<'_> {
 
     /// Parse a declaration and bind variables to symbol table
     ///
-    /// Following sparse's design, this binds each declared variable to the
-    /// symbol table immediately during parsing. Like sparse's bind_symbol().
+    /// Binds each declared variable to the symbol table immediately during
+    /// parsing, so the symbol is available for subsequent references.
     fn parse_declaration_and_bind(&mut self) -> ParseResult<Declaration> {
         // Parse type specifiers
         let base_type = self.parse_type_specifier()?;
@@ -3117,7 +3111,7 @@ impl Parser<'_> {
                     }
                 }
 
-                // Bind to symbol table (like sparse's bind_symbol)
+                // Bind to symbol table
                 // Note: StringId is Copy, check for empty by comparing to empty string
                 let name_str = self.str(name);
                 if !name_str.is_empty() {
@@ -3945,9 +3939,9 @@ impl Parser<'_> {
 
     /// Parse a function definition
     ///
-    /// Following sparse's design, this binds the function to the symbol table
-    /// at global scope, then enters a new scope for the function body and
-    /// binds all parameters in that scope.
+    /// Binds the function to the symbol table at global scope, then enters
+    /// a new scope for the function body and binds all parameters in that
+    /// scope.
     #[cfg(test)]
     fn parse_function_def(&mut self) -> ParseResult<FunctionDef> {
         let func_pos = self.current_pos();
@@ -4010,7 +4004,6 @@ impl Parser<'_> {
         let func_type_id = self.types.intern(func_type);
 
         // Bind function to symbol table at current (global) scope
-        // Like sparse's bind_symbol() in parse.c
         let func_sym = Symbol::function(name, func_type_id, self.symbols.depth());
         let _ = self.symbols.declare(func_sym); // Ignore redefinition errors for now