Compiler: force zero initialization of local variables

chqrlie · chqrlie · commit 3307c8b99755 · 2026-03-26T19:54:57.000+01:00
* make all local variables zero-initialized except if tagged as `@(noinit)`
* update tests
diff --git a/ast/ast_evaluator.c2 b/ast/ast_evaluator.c2
@@ -405,7 +405,7 @@ fn Value Evaluator.eval_call(Evaluator* caller, const CallExpr* c) {
 
     // Create a new stack frame and link it to the caller's
     // TODO: handle Stack frames as separate allocated objects or fragments of a stack area
-    Evaluator eval;
+    Evaluator eval /*@(noinit)*/;
 
     if (num_args > elemsof(eval.args)) {
         return Value.error("too many arguments in pure function evaluation");
diff --git a/ast/var_decl.c2 b/ast/var_decl.c2
@@ -57,6 +57,7 @@ type VarDeclBits struct {
     u32 addr_used : 1;
     AutoAttr auto_attr : 2;  // for parameters only
     FormatAttr format_attr : 2; // for parameters only
+    u32 attr_noinit : 1;
 }
 
 public type BitFieldLayout struct {
@@ -307,6 +308,14 @@ public fn bool VarDecl.hasInitCall(const VarDecl* d) {
     return d.base.varDeclBits.has_init_call;
 }
 
+public fn void VarDecl.setAttrNoInit(VarDecl* d) {
+    d.base.varDeclBits.attr_noinit = 1;
+}
+
+public fn bool VarDecl.hasAttrNoInit(const VarDecl* d) {
+    return d.base.varDeclBits.attr_noinit;
+}
+
 public fn void VarDecl.setAttrWeak(VarDecl* d) {
     d.base.varDeclBits.attr_weak = 1;
 }
diff --git a/ast_utils/attr.c2 b/ast_utils/attr.c2
@@ -44,6 +44,7 @@ public type AttrKind enum u8 {
     AutoFunc,       //               Var, function param only
     Embed,          //               Var, globals only
     Deprecated,     //        Func
+    NoInit,         //               Var
 }
 
 const char*[AttrKind] attrKind_names = {
@@ -71,6 +72,7 @@ const char*[AttrKind] attrKind_names = {
     "auto_func",
     "embed",
     "deprecated",
+    "noinit",
 }
 
 public type AttrValueKind enum u8 {
@@ -148,6 +150,7 @@ const AttrReq[AttrKind] Required_arg = {
     [AutoFunc]     = NoArg,
     [Embed]        = String,
     [Deprecated]   = String,
+    [NoInit]       = NoArg,
 }
 
 public type AttrReq enum u8 {
diff --git a/ast_utils/string_buffer.c2 b/ast_utils/string_buffer.c2
@@ -169,7 +169,7 @@ public fn void Buf.stripTrailingSpaces(Buf* buf) {
 }
 
 public fn void Buf.print(Buf* buf, const char* format @(printf_format), ...) {
-    char[4096] tmp;
+    char[4096] tmp /*@(noinit)*/;
     // NOTE: no growing
     va_list args;
     va_start(args, format);
@@ -180,7 +180,7 @@ public fn void Buf.print(Buf* buf, const char* format @(printf_format), ...) {
 }
 
 public fn void Buf.vprintf(Buf* buf, const char* format, va_list args) {
-    char[4096] tmp;
+    char[4096] tmp /*@(noinit)*/;
     // NOTE: no growing
     i32 len = vsnprintf(tmp, elemsof(tmp), format, args);
     assert(len < elemsof(tmp));
diff --git a/ast_utils/value_type.c2 b/ast_utils/value_type.c2
@@ -824,7 +824,7 @@ fn f64 fabs(f64 d) {
 // string and trying to avoid using exponential notation
 // TODO: should be in the C2 library as a type function f64.str()
 public fn char *ftoa(char *dest, usize size, f64 d) {
-    char[32] buf;
+    char[32] buf /*@(noinit)*/;
     usize pos = 0;
 
     if (size < 2) {
diff --git a/common/ast_builder.c2 b/common/ast_builder.c2
@@ -512,6 +512,9 @@ fn void Builder.actOnVarAttr(Builder* b, Decl* d, const Attr* a) {
     case Embed:
         b.storeAttr(d, a);
         break;
+    case NoInit:
+        vd.setAttrNoInit();
+        break;
     default:
         b.diags.error(a.loc, "attribute '%s' is not applicable to variables",
                       a.kind2name());
diff --git a/common/file/file_utils.c2 b/common/file/file_utils.c2
@@ -116,7 +116,7 @@ public fn const char* make_path3(char *buf, usize size, const char* dir, const c
 // returns 0 on success, errno on failure
 // create a directory path, OK if exists already
 public fn i32 create_path(const char* path) {
-    char[file_utils.Max_path] tmp;
+    char[file_utils.Max_path] tmp /*@(noinit)*/;
     char *p = tmp;
     if (!*path) return 0;
     *p++ = *path++;
diff --git a/generator/c/c_generator.c2 b/generator/c/c_generator.c2
@@ -1309,8 +1309,7 @@ public fn void generate(string_pool.Pool* astPool,
         return;
     }
 
-    Generator gen;
-    gen.init(astPool, target, kind, output_dir, dir, diags, sm, build_info, mainFunc);
+    Generator gen.init(astPool, target, kind, output_dir, dir, diags, sm, build_info, mainFunc);
     gen.auxPool = auxPool;
     gen.enable_asserts = enable_asserts;
     gen.fast_build = fast_build;
diff --git a/generator/c/c_generator_special.c2 b/generator/c/c_generator_special.c2
@@ -60,7 +60,7 @@ fn void Generator.createMakefile(Generator* gen,
     out.print("CC?=%s\n", cc);
 
     out.add("CFLAGS+=-Wall -Wextra -Wno-unused -Wno-switch\n");
-    out.add("CFLAGS+=-Wno-unused-parameter -Wno-missing-field-initializers -Wno-format-zero-length\n");
+    out.add("CFLAGS+=-Wno-unused-parameter -Wno-missing-field-initializers -Wno-missing-braces -Wno-format-zero-length\n");
     out.add("CFLAGS+=-pipe -std=c99 -funsigned-char\n");
     if (gen.fast_build)
         out.add("CFLAGS+=-O0 -g\n");
diff --git a/generator/c/c_generator_stmt.c2 b/generator/c/c_generator_stmt.c2
@@ -39,6 +39,10 @@ fn void Generator.emitVarDecl(Generator* gen, VarDecl* vd, string_buffer.Buf* ou
             out.add(" = ");
         }
         gen.emitExpr(out, ie);
+    } else {
+        if (!vd.hasAttrNoInit()) {
+            out.add(" = { 0 }");
+        }
     }
 }
 
diff --git a/parser/c2_parser.c2 b/parser/c2_parser.c2
@@ -447,6 +447,10 @@ fn bool findName(const u32* names, u32 count, u32 name) {
 // returns the number of attributes parsed and stored in Builder
 fn u32 Parser.parseOptionalAttributes(Parser* p) {
     if (p.tok.kind != At) return 0;
+    return p.parseAttributes();
+}
+
+fn u32 Parser.parseAttributes(Parser* p) {
     p.consumeToken();
 
     p.expectAndConsume(LParen);
diff --git a/parser/c2_parser_stmt.c2 b/parser/c2_parser_stmt.c2
@@ -21,6 +21,7 @@ import constants local;
 import token local;
 import src_loc local;
 import string_list;
+import string local;
 
 fn Stmt* Parser.parseStmt(Parser* p) {
     // TODO use Jump Table (combined one for multiple purposes?)
@@ -504,7 +505,7 @@ fn Stmt* Parser.parseWhileStmt(Parser* p) {
 }
 
 fn Stmt* Parser.parseDeclStmt(Parser* p, bool checkSemi, bool allowLocal, bool isCondition) {
-    VarDecl*[MaxMultiDecl] decls;
+    VarDecl*[MaxMultiDecl] decls /*@(noinit)*/;
     u32 num_decls = 0;
     bool has_local = false;
     if (p.tok.kind == KW_local) {
@@ -529,6 +530,7 @@ fn Stmt* Parser.parseDeclStmt(Parser* p, bool checkSemi, bool allowLocal, bool i
         p.consumeToken();
 
         // TODO same as parseVarDecl()
+        bool has_noinit = false;
         bool has_init_call = false;
         need_semi = true;
         Expr* initValue = nil;
@@ -543,7 +545,14 @@ fn Stmt* Parser.parseDeclStmt(Parser* p, bool checkSemi, bool allowLocal, bool i
             need_semi = checkSemi && initValue.needsSemi();
             break;
         case At:
-            p.error("local variables cannot have attributes");
+            // check for noinit attribute
+            p.consumeToken();
+            p.expectAndConsume(Kind.LParen);
+            p.expectIdentifier();
+            if (strcmp(p.pool.idx2str(p.tok.name_idx), "noinit"))
+                p.error("local variables cannot have attributes");
+            has_noinit = true;
+            p.expectAndConsume(Kind.RParen);
             break;
         case Dot:
             if (p.peekToken(1) == Identifier
@@ -571,7 +580,9 @@ fn Stmt* Parser.parseDeclStmt(Parser* p, bool checkSemi, bool allowLocal, bool i
         default:
             break;
         }
-        decls[num_decls++] = p.builder.actOnVarDecl(name, loc, &ref, assignLoc, initValue, has_local, has_init_call);
+        VarDecl* vd = p.builder.actOnVarDecl(name, loc, &ref, assignLoc, initValue, has_local, has_init_call);
+        if (has_noinit) vd.setAttrNoInit();
+        decls[num_decls++] = vd;
         if (p.tok.kind != Comma)
             break;
         p.consumeToken();
diff --git a/parser/c2_tokenizer.c2 b/parser/c2_tokenizer.c2
@@ -886,7 +886,7 @@ check_overflow:
 }
 
 fn void Tokenizer.lex_floating_point(Tokenizer* t, Token* result, const char* start) {
-    char[4096] buf;
+    char[128] buf /*@(noinit)*/;
     const char* p = start;
     usize pos = 0;
     u8 seen_dot = 0;
@@ -941,7 +941,7 @@ too_large:
 }
 
 fn void Tokenizer.lex_floating_point_hex(Tokenizer* t, Token* result, const char* start) {
-    char[4096] buf;
+    char[128] buf /*@(noinit)*/;
     const char* p = start;
     usize pos = 0;
     u8 seen_dot = 0;
diff --git a/test/auto_args/struct_function_before_self.c2t b/test/auto_args/struct_function_before_self.c2t
@@ -27,7 +27,7 @@ static void test_Foo_test(const char* file, u32 line, test_Foo* f, void* p)
 
 int main(void)
 {
-   test_Foo f;
+   test_Foo f = { 0 };
    test_Foo_test("file1.c2", 11, &f, NULL);
    return 0;
 }
diff --git a/test/auto_args/struct_function_ok.c2t b/test/auto_args/struct_function_ok.c2t
@@ -27,7 +27,7 @@ static void test_Foo_test(test_Foo* f, const char* file, u32 line, void* p)
 
 int main(void)
 {
-   test_Foo f;
+   test_Foo f = { 0 };
    test_Foo_test(&f, "file1.c2", 11, NULL);
    test_Foo_test(&f, "file1.c2", 12, NULL);
    return 0;
diff --git a/test/c_generator/asm/gen_asm.c2t b/test/c_generator/asm/gen_asm.c2t
@@ -48,16 +48,16 @@ static void test_basic_asm(void);
 
 static int test_add(int x, int y)
 {
-  int result;
+  int result = { 0 };
   __asm__ volatile ("add %[Rd], %[Rm], %[Rn]" : [Rd] "=r" (result) : [Rm] "r" (x), [Rn] "r" (y));
   return result;
 }
 
 static void test_clobbers(void)
 {
-  int from;
-  int to;
-  int count;
+  int from = { 0 };
+  int to = { 0 };
+  int count = { 0 };
   __asm__ volatile ("movc3 %0, %1, %2"
             :
             : "g" (from), "g" (to), "g" (count)
@@ -67,8 +67,8 @@ static void test_clobbers(void)
 static inline
 u64 test_rdtsc(void)
 {
-  u32 lo;
-  u32 hi;
+  u32 lo = { 0 };
+  u32 hi = { 0 };
   __asm__ volatile ("rdtsc" : "=a" (lo), "=d" (hi));
   u64 res = hi;
   res <<= 32;
diff --git a/test/c_generator/expr/prec_expr.c2t b/test/c_generator/expr/prec_expr.c2t
@@ -30,7 +30,7 @@ public fn i32 main(i32 argc, const char** argv) {
 
 int main(int argc, const char** argv)
 {
-    int a;
+    int a = { 0 };
 
     a = (1 << 2) + 3;
     a = ((1 ^ 2) | 3) & 4;
diff --git a/test/c_generator/functions/inline/inline_prefix.c2t b/test/c_generator/functions/inline/inline_prefix.c2t
@@ -47,7 +47,7 @@ type Point struct {
 static inline
 void test1_myfunc(const test2_Point* p)
 {
-  test2_Point points[3];
+  test2_Point points[3] = { 0 };
   points[1] = *p;
 }
 
diff --git a/test/c_generator/functions/inline/inline_stmts.c2t b/test/c_generator/functions/inline/inline_stmts.c2t
@@ -114,7 +114,7 @@ next:
 static inline
 int test1_test_fn(const char* format, ...)
 {
-  const char* p;
+  const char* p = { 0 };
   {
     const char* q = format;
     if (q) {
@@ -137,7 +137,7 @@ int test1_test_fn(const char* format, ...)
   if (format) p = format;
   else p = format;
   {
-    const char* q;
+    const char* q = { 0 };
     while ((q = format)) {
     }
   }
diff --git a/test/c_generator/functions/inline/lib_public_inline.c2t b/test/c_generator/functions/inline/lib_public_inline.c2t
@@ -41,7 +41,7 @@ typedef void (*test1_Handler)(int* _arg0);
 static inline
 int test1_test_fn(test1_Handler a, int** b)
 {
-  int c[4];
+  int c[4] = { 0 };
   a(*b);
   return 123;
 }
diff --git a/test/c_generator/functions/inline/nonpublic_inline.c2t b/test/c_generator/functions/inline/nonpublic_inline.c2t
@@ -42,6 +42,6 @@ void test1_test_fn(void)
 {
    test1_non_public();
    test1_num++;
-   test1_Priv p;
+   test1_Priv p = { 0 };
    test1_Handler h = test1_non_public;
 }
diff --git a/test/c_generator/functions/struct_functions/chained_struct_calls.c2t b/test/c_generator/functions/struct_functions/chained_struct_calls.c2t
@@ -73,7 +73,7 @@ static test_B* test_C_getB(test_C* c)
 
 static void test_test1(void)
 {
-  test_C c;
+  test_C c = { 0 };
   u32 n = test_A_run(test_B_getA(test_C_getB(&c)));
 }
 
diff --git a/test/c_generator/functions/struct_functions/local.c2t b/test/c_generator/functions/struct_functions/local.c2t
@@ -33,7 +33,7 @@ static void test_Type_init(test_Type* _arg0)
 
 int main(void)
 {
-  test_Type t;
+  test_Type t = { 0 };
   test_Type_init(&t);
   return 0;
 }
diff --git a/test/c_generator/functions/struct_functions/local_arg.c2t b/test/c_generator/functions/struct_functions/local_arg.c2t
@@ -33,7 +33,7 @@ static void test_Type_init(test_Type* _arg0, int _arg1)
 
 int main(void)
 {
-  test_Type t;
+  test_Type t = { 0 };
   test_Type_init(&t, 4);
   return 0;
 }
diff --git a/test/c_generator/functions/struct_functions/local_member.c2t b/test/c_generator/functions/struct_functions/local_member.c2t
@@ -31,7 +31,7 @@ static void test_Type_init(test_Type* _arg0)
 
 int main(void)
 {
-  test_Outer o;
+  test_Outer o = { 0 };
   test_Type_init(&o.t);
   return 0;
 }
diff --git a/test/c_generator/functions/struct_functions/local_normal_callback.c2t b/test/c_generator/functions/struct_functions/local_normal_callback.c2t
@@ -28,7 +28,7 @@ struct test_Type_ {
 
 int main(void)
 {
-  test_Type t;
+  test_Type t = { 0 };
   t.init(1);
   return 0;
 }
diff --git a/test/c_generator/functions/struct_functions/local_ptr.c2t b/test/c_generator/functions/struct_functions/local_ptr.c2t
@@ -33,7 +33,7 @@ static void test_Type_init(test_Type* _arg0)
 
 int main(void)
 {
-  test_Type* t;
+  test_Type* t = { 0 };
   test_Type_init(t);
   return 0;
 }
diff --git a/test/c_generator/stmts/local_array_decl.c2t b/test/c_generator/stmts/local_array_decl.c2t
@@ -26,6 +26,6 @@ static void test_func1(void);
 
 static void test_func1(void)
 {
-  int board2[20][20];
+  int board2[20][20] = { 0 };
 }
 
diff --git a/test/c_generator/stmts/while_stmt_expr.c2t b/test/c_generator/stmts/while_stmt_expr.c2t
@@ -30,7 +30,7 @@ int main(int argc, const char** argv)
     }
 
     {
-        int b;
+        int b = { 0 };
         while ((b = 0)) {
         }
     }
diff --git a/test/expr/assign_list.c2t b/test/expr/assign_list.c2t
@@ -44,7 +44,7 @@ static test_Point test_new_point(int x, int y)
 int main(void)
 {
     printf("p0={ %d, %d }\n", test_p0.x, test_p0.y);
-    test_Point p1;
+    test_Point p1 = { 0 };
     p1 = (test_Point){ 3, 4 };
     printf("p1={ %d, %d }\n", p1.x, p1.y);
     test_print_point("p2", (test_Point){ 5, 6 });
diff --git a/test/types/const/multi_const.c2t b/test/types/const/multi_const.c2t
diff --git a/tools/tester/expect_file.c2 b/tools/tester/expect_file.c2
diff --git a/tools/tester/line_db.c2 b/tools/tester/line_db.c2
diff --git a/tools/tester/test_db.c2 b/tools/tester/test_db.c2

Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ public type AttrKind enum u8 {`
`44`	`44`	`AutoFunc, // Var, function param only`
`45`	`45`	`Embed, // Var, globals only`
`46`	`46`	`Deprecated, // Func`
	`47`	`+ NoInit, // Var`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`const char*[AttrKind] attrKind_names = {`
`@@ -71,6 +72,7 @@ const char*[AttrKind] attrKind_names = {`
`71`	`72`	`"auto_func",`
`72`	`73`	`"embed",`
`73`	`74`	`"deprecated",`
	`75`	`+ "noinit",`
`74`	`76`	`}`
`75`	`77`
`76`	`78`	`public type AttrValueKind enum u8 {`
`@@ -148,6 +150,7 @@ const AttrReq[AttrKind] Required_arg = {`
`148`	`150`	`[AutoFunc] = NoArg,`
`149`	`151`	`[Embed] = String,`
`150`	`152`	`[Deprecated] = String,`
	`153`	`+ [NoInit] = NoArg,`
`151`	`154`	`}`
`152`	`155`
`153`	`156`	`public type AttrReq enum u8 {`
Original file line number	Diff line number	Diff line change
`@@ -1309,8 +1309,7 @@ public fn void generate(string_pool.Pool* astPool,`
`1309`	`1309`	`return;`
`1310`	`1310`	`}`
`1311`	`1311`
`1312`		`- Generator gen;`
`1313`		`- gen.init(astPool, target, kind, output_dir, dir, diags, sm, build_info, mainFunc);`
	`1312`	`+ Generator gen.init(astPool, target, kind, output_dir, dir, diags, sm, build_info, mainFunc);`
`1314`	`1313`	`gen.auxPool = auxPool;`
`1315`	`1314`	`gen.enable_asserts = enable_asserts;`
`1316`	`1315`	`gen.fast_build = fast_build;`
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,10 @@ fn void Generator.emitVarDecl(Generator* gen, VarDecl* vd, string_buffer.Buf* ou`
`39`	`39`	`out.add(" = ");`
`40`	`40`	`}`
`41`	`41`	`gen.emitExpr(out, ie);`
	`42`	`+ } else {`
	`43`	`+ if (!vd.hasAttrNoInit()) {`
	`44`	`+ out.add(" = { 0 }");`
	`45`	`+ }`
`42`	`46`	`}`
`43`	`47`	`}`
`44`	`48`