Merge pull request #496 from rustcoreutils/updates

[cc] ir and parser fixes

Author: jgarzik

cc/ir/linearize.rs

@@ -1346,6 +1346,37 @@ impl<'a> Linearizer<'a> {
                         self.emit_aggregate_zero(sym_id, typ);
                     }
                     self.linearize_init_list(sym_id, typ, elements);
+                } else if let ExprKind::StringLit(s) = &init.kind {
+                    // String literal initialization of char array
+                    // Copy the string bytes to the local array
+                    if self.types.kind(typ) == TypeKind::Array {
+                        let elem_type = self.types.base_type(typ).unwrap_or(self.types.char_id);
+                        let elem_size = self.types.size_bits(elem_type);
+
+                        // Copy each byte from string literal to local array
+                        for (i, byte) in s.bytes().enumerate() {
+                            let byte_val = self.emit_const(byte as i64, elem_type);
+                            self.emit(Instruction::store(
+                                byte_val, sym_id, i as i64, elem_type, elem_size,
+                            ));
+                        }
+                        // Store null terminator
+                        let null_val = self.emit_const(0, elem_type);
+                        self.emit(Instruction::store(
+                            null_val,
+                            sym_id,
+                            s.len() as i64,
+                            elem_type,
+                            elem_size,
+                        ));
+                    } else {
+                        // Pointer initialized with string literal - store the address
+                        let val = self.linearize_expr(init);
+                        let init_type = self.expr_type(init);
+                        let converted = self.emit_convert(val, init_type, typ);
+                        let size = self.types.size_bits(typ);
+                        self.emit(Instruction::store(converted, sym_id, 0, typ, size));
+                    }
                 } else if self.types.is_complex(typ) {
                     // Complex type initialization - linearize_expr returns an address
                     // to a temp containing the complex value. Copy from temp to local.
@@ -3407,6 +3438,12 @@ impl<'a> Linearizer<'a> {
                 let elem_type = self.types.base_type(arg_type).unwrap_or(self.types.int_id);
                 arg_types_vec.push(self.types.pointer_to(elem_type));
                 self.linearize_expr(a)
+            } else if arg_kind == TypeKind::VaList {
+                // va_list decay to pointer (C99 7.15.1)
+                // va_list is defined as __va_list_tag[1] (an array), so it decays to
+                // a pointer when passed to a function taking va_list parameter
+                arg_types_vec.push(self.types.pointer_to(arg_type));
+                self.linearize_lvalue(a)
             } else if arg_kind == TypeKind::Function {
                 // Function decay to pointer (C99 6.3.2.1)
                 // Function names passed as arguments decay to function pointers

cc/ir/test_linearize.rs

@@ -11,8 +11,12 @@
 //
 
 use super::*;
-use crate::parse::ast::{AssignOp, ExprKind, ExternalDecl, FunctionDef, Parameter, UnaryOp};
+use crate::parse::ast::{
+    AssignOp, BlockItem, Declaration, ExprKind, ExternalDecl, FunctionDef, InitDeclarator,
+    Parameter, UnaryOp,
+};
 use crate::strings::StringTable;
+use crate::types::Type;
 
 /// Create a default position for test code
 fn test_pos() -> Position {
@@ -2422,3 +2426,110 @@ fn test_ternary_with_post_increment_uses_phi() {
         ir
     );
 }
+
+// ============================================================================
+// String literal initialization tests
+// ============================================================================
+
+#[test]
+fn test_string_literal_char_array_init() {
+    // Test that `char arr[6] = "hello";` generates store instructions for each byte
+    // plus null terminator (6 stores total: 'h', 'e', 'l', 'l', 'o', '\0')
+    let mut strings = StringTable::new();
+    let mut types = TypeTable::new(64);
+    let test_id = strings.intern("test");
+    let arr_id = strings.intern("arr");
+
+    // Create char[6] type
+    let char_arr_type = types.intern(Type::array(types.char_id, 6));
+
+    // Function: int test() { char arr[6] = "hello"; return 0; }
+    let func = FunctionDef {
+        return_type: types.int_id,
+        name: test_id,
+        params: vec![],
+        body: Stmt::Block(vec![
+            BlockItem::Declaration(Declaration {
+                declarators: vec![InitDeclarator {
+                    name: arr_id,
+                    typ: char_arr_type,
+                    init: Some(Expr::typed(
+                        ExprKind::StringLit("hello".to_string()),
+                        types.char_ptr_id,
+                        test_pos(),
+                    )),
+                    vla_sizes: vec![],
+                }],
+            }),
+            BlockItem::Statement(Stmt::Return(Some(Expr::int(0, &types)))),
+        ]),
+        pos: test_pos(),
+    };
+    let tu = TranslationUnit {
+        items: vec![ExternalDecl::FunctionDef(func)],
+    };
+
+    let module = test_linearize(&tu, &types, &strings);
+    let ir = format!("{}", module);
+
+    // Should have 6 store instructions (5 chars + null terminator)
+    let store_count = ir.matches("store").count();
+    assert!(
+        store_count >= 6,
+        "Expected at least 6 store instructions for 'hello' + null, got {}: {}",
+        store_count,
+        ir
+    );
+}
+
+#[test]
+fn test_string_literal_char_pointer_init() {
+    // Test that `char *p = "hello";` generates a single store of the string address
+    let mut strings = StringTable::new();
+    let types = TypeTable::new(64);
+    let test_id = strings.intern("test");
+    let p_id = strings.intern("p");
+
+    // Function: int test() { char *p = "hello"; return 0; }
+    let func = FunctionDef {
+        return_type: types.int_id,
+        name: test_id,
+        params: vec![],
+        body: Stmt::Block(vec![
+            BlockItem::Declaration(Declaration {
+                declarators: vec![InitDeclarator {
+                    name: p_id,
+                    typ: types.char_ptr_id,
+                    init: Some(Expr::typed(
+                        ExprKind::StringLit("hello".to_string()),
+                        types.char_ptr_id,
+                        test_pos(),
+                    )),
+                    vla_sizes: vec![],
+                }],
+            }),
+            BlockItem::Statement(Stmt::Return(Some(Expr::int(0, &types)))),
+        ]),
+        pos: test_pos(),
+    };
+    let tu = TranslationUnit {
+        items: vec![ExternalDecl::FunctionDef(func)],
+    };
+
+    let module = test_linearize(&tu, &types, &strings);
+    let ir = format!("{}", module);
+
+    // Should have a store instruction for the pointer (storing the string address)
+    assert!(
+        ir.contains("store"),
+        "Pointer init should have a store instruction: {}",
+        ir
+    );
+
+    // The module should contain the string literal (strings are stored in module)
+    assert!(
+        !module.strings.is_empty(),
+        "Module should contain string literal: {}",
+        ir
+    );
+}