Compiler: move c2_assert to c2

chqrlie · chqrlie · commit ac7bab28e9a5 · 2025-06-27T14:03:29.000+02:00
* compute the assert string and function call at parse time
* add libc2 module in libs/libc/c2_internals.c2i
* add `auto_func` function parameter attribute
* reject invalid combinations of `auto_xxx` attributes
diff --git a/analyser/module_analyser_function.c2 b/analyser/module_analyser_function.c2
@@ -99,6 +99,9 @@ fn void Analyser.analyseFunction(Analyser* ma, FunctionDecl* fd) {
             if (v.hasAttrAutoLine() && !ref.isU32()) {  // check for 'u32'
                 ma.error(ref.getLoc(), "attribute 'auto_line' requires a parameter of type 'u32'");
             }
+            if (v.hasAttrAutoFunc() && !ref.isConstCharPtr()) { // check for 'const char *'
+                ma.error(ref.getLoc(), "attribute 'auto_func' requires a parameter of type 'const char*'");
+            }
         }
 
         if (v.hasPrintfFormat()) {
diff --git a/analyser/module_analyser_stmt.c2 b/analyser/module_analyser_stmt.c2
@@ -374,6 +374,11 @@ fn void Analyser.analyseAssertStmt(Analyser* ma, Stmt* s) {
 
     Expr* inner = a.getInner();
     ma.checker.check(builtins[BuiltinKind.Bool], qt, a.getInner2(), inner.getLoc());
+
+    if (a.getCall()) {
+        qt = ma.analyseExpr(a.getCall2(), true, RHS);
+        if (qt.isInvalid()) return;
+    }
 }
 
 fn void Analyser.analyseReturnStmt(Analyser* ma, Stmt* s) {
diff --git a/ast/assert_stmt.c2 b/ast/assert_stmt.c2
@@ -22,33 +22,43 @@ import string_buffer;
 public type AssertStmt struct @(opaque) {
     Stmt base;
     Expr* inner;
+    Expr* call;
 }
 
 public fn AssertStmt* AssertStmt.create(ast_context.Context* c,
-                                          SrcLoc loc,
-                                          Expr* inner)
+                                        SrcLoc loc,
+                                        Expr* inner,
+                                        Expr* call)
 {
     AssertStmt* s = c.alloc(sizeof(AssertStmt));
     s.base.init(StmtKind.Assert, loc);
     s.inner = inner;
+    s.call = call;
 #if AstStatistics
     Stats.addStmt(StmtKind.Assert, sizeof(AssertStmt));
 #endif
     return s;
 }
 
 fn Stmt* AssertStmt.instantiate(AssertStmt* s, Instantiator* inst) {
-    AssertStmt* s2 = AssertStmt.create(inst.c, s.base.loc, s.inner.instantiate(inst));
+    AssertStmt* s2 = AssertStmt.create(inst.c, s.base.loc,
+                                       s.inner.instantiate(inst),
+                                       s.call ? s.call.instantiate(inst) : nil);
     return (Stmt*)s2;
 }
 
 public fn Expr* AssertStmt.getInner(const AssertStmt* s) { return s.inner; }
 
 public fn Expr** AssertStmt.getInner2(AssertStmt* s) { return &s.inner; }
 
+public fn Expr* AssertStmt.getCall(const AssertStmt* s) { return s.call; }
+
+public fn Expr** AssertStmt.getCall2(AssertStmt* s) { return &s.call; }
+
 fn void AssertStmt.print(const AssertStmt* s, string_buffer.Buf* out, u32 indent) {
     s.base.printKind(out, indent);
     out.newline();
     s.inner.print(out, indent + 1);
+    if (s.call) s.call.print(out, indent + 1);
 }
 
diff --git a/ast/qualtype.c2 b/ast/qualtype.c2
@@ -97,6 +97,7 @@ public fn u32 QualType.getBitFieldWidth(const QualType* qt) {
         return bi.getBitfieldSize();
     }
     if (t.isEnumType()) {
+        // TODO return bits needed for max value to allow use in bitfields
         EnumType* et = (EnumType*)t;
         QualType impl = et.getImplType();
         return impl.getBitFieldWidth();
diff --git a/ast/utils.c2 b/ast/utils.c2
@@ -39,7 +39,7 @@ static_assert(80, sizeof(FunctionDecl));
 static_assert(8, sizeof(Stmt));
 static_assert(12, sizeof(GotoStmt));
 static_assert(24, sizeof(LabelStmt));
-static_assert(16, sizeof(AssertStmt));
+static_assert(24, sizeof(AssertStmt));
 static_assert(8, sizeof(DeclStmt));
 static_assert(16, sizeof(SwitchStmt));
 static_assert(24, sizeof(AsmStmt));
diff --git a/ast/var_decl.c2 b/ast/var_decl.c2
@@ -35,6 +35,13 @@ const char*[] varDeclNames = {
 
 static_assert(elemsof(VarDeclKind), elemsof(varDeclNames));
 
+type AutoAttr enum u32 {
+    None,
+    File,
+    Line,
+    Func,
+}
+
 type VarDeclBits struct {
     u32 : NumDeclBits;
     u32 kind : 3;
@@ -43,8 +50,7 @@ type VarDeclBits struct {
     u32 has_init_call : 1; // local variables only
     u32 attr_weak : 1; // globals only
     u32 addr_used : 1;
-    u32 auto_file : 1;  // for parameters only
-    u32 auto_line : 1;  // for parameters only
+    u32 auto_attr : 2;  // AutoAttr, for parameters only
     u32 printf_format : 1; // for parameters only
 }
 
@@ -246,23 +252,31 @@ public fn bool VarDecl.hasAttrWeak(const VarDecl* d) {
 }
 
 public fn void VarDecl.setAttrAutoFile(VarDecl* d) {
-    d.base.varDeclBits.auto_file = 1;
+    d.base.varDeclBits.auto_attr = AutoAttr.File;
 }
 
 public fn bool VarDecl.hasAttrAutoFile(const VarDecl* d) {
-    return d.base.varDeclBits.auto_file;
+    return d.base.varDeclBits.auto_attr == AutoAttr.File;
 }
 
 public fn void VarDecl.setAttrAutoLine(VarDecl* d) {
-    d.base.varDeclBits.auto_line = 1;
+    d.base.varDeclBits.auto_attr = AutoAttr.Line;
 }
 
 public fn bool VarDecl.hasAttrAutoLine(const VarDecl* d) {
-    return d.base.varDeclBits.auto_line;
+    return d.base.varDeclBits.auto_attr == AutoAttr.Line;
+}
+
+public fn void VarDecl.setAttrAutoFunc(VarDecl* d) {
+    d.base.varDeclBits.auto_attr = AutoAttr.Func;
+}
+
+public fn bool VarDecl.hasAttrAutoFunc(const VarDecl* d) {
+    return d.base.varDeclBits.auto_attr == AutoAttr.Func;
 }
 
 public fn bool VarDecl.hasAutoAttr(const VarDecl* d) {
-    return d.base.varDeclBits.auto_file || d.base.varDeclBits.auto_line;
+    return d.base.varDeclBits.auto_attr != AutoAttr.None;
 }
 
 public fn void VarDecl.setPrintfFormat(VarDecl* d) {
@@ -288,8 +302,12 @@ fn void VarDecl.print(const VarDecl* d, string_buffer.Buf* out, u32 indent) {
     if (d.hasLocalQualifier()) out.add(" (local)");
     if (d.base.varDeclBits.attr_weak) out.add(" weak");
     if (d.base.varDeclBits.addr_used) out.add(" addr_used");
-    if (d.base.varDeclBits.auto_file) out.add(" auto_file");
-    if (d.base.varDeclBits.auto_line) out.add(" auto_line");
+    switch ((AutoAttr)d.base.varDeclBits.auto_attr) {
+    case None: break;
+    case File: out.add(" auto_file"); break;
+    case Line: out.add(" auto_line"); break;
+    case Func: out.add(" auto_func"); break;
+    }
     if (d.base.varDeclBits.printf_format) out.add(" printf_format");
     if (d.base.varDeclBits.has_init_call) out.add(" init_call");
     d.base.printBits(out);
diff --git a/ast_utils/attr.c2 b/ast_utils/attr.c2
@@ -40,6 +40,7 @@ public type AttrKind enum u8 {
     Pure,           //        Func
     AutoFile,       //               Var, function param only
     AutoLine,       //               Var, function param only
+    AutoFunc,       //               Var, function param only
 }
 
 const char*[] attrKind_names = {
@@ -63,6 +64,7 @@ const char*[] attrKind_names = {
     "pure",
     "auto_file",
     "auto_line",
+    "auto_func",
 }
 
 static_assert(elemsof(AttrKind), elemsof(attrKind_names));
@@ -140,6 +142,7 @@ const AttrReq[] Required_arg = {
     [AttrKind.Pure]         = AttrReq.NoArg,
     [AttrKind.AutoFile]     = AttrReq.NoArg,
     [AttrKind.AutoLine]     = AttrReq.NoArg,
+    [AttrKind.AutoFunc]     = AttrReq.NoArg,
 }
 static_assert(elemsof(AttrKind), elemsof(Required_arg));
 
diff --git a/compiler/compiler.c2 b/compiler/compiler.c2
@@ -300,7 +300,8 @@ fn void Compiler.build(Compiler* c,
                                 c.astPool,
                                 c.builder,
                                 &c.kwinfo,
-                                target.getFeatures());
+                                target.getFeatures(),
+                                c.target.hasAsserts());
 
     ast.initialize(c.context, c.astPool, c.targetInfo.intWidth / 8, color.useColor());
 
diff --git a/generator/ast_visitor.c2 b/generator/ast_visitor.c2
@@ -213,6 +213,8 @@ fn void Visitor.handleStmt(Visitor* v, Stmt* s) {
     case Assert:
         AssertStmt* a = cast<AssertStmt*>(s);
         v.handleExpr(a.getInner());
+        Expr* call = a.getCall();
+        if (call) v.handleExpr(call);
         break;
     }
 }
diff --git a/generator/c/c2i_generator_decl.c2 b/generator/c/c2i_generator_decl.c2
@@ -69,6 +69,7 @@ fn void Generator.emitVarDecl(Generator* gen, const Decl* d, u32 indent) {
     if (v.hasAutoAttr()) {
         if (v.hasAttrAutoFile()) out.add(" @(auto_file)");
         if (v.hasAttrAutoLine()) out.add(" @(auto_line)");
+        if (v.hasAttrAutoFunc()) out.add(" @(auto_func)");
     }
     // Note: dont add ';' because it could also be a function argument
 }
diff --git a/generator/c/c2i_generator_stmt.c2 b/generator/c/c2i_generator_stmt.c2
@@ -207,23 +207,10 @@ fn void Generator.emitStmt(Generator* gen, ast.Stmt* s, u32 indent, bool newline
         //gen.emitAsmStmt(cast<AsmStmt*>(s), indent);
         break;
     case Assert:
-#if 0
-        // TODO: generate actual assert statement?
         AssertStmt* a = cast<AssertStmt*>(s);
-        source_mgr.Location loc = gen.sm.getLocation(a.getLoc());
-        const char* funcname = gen.cur_function.asDecl().getFullName();
-
-        out.add("(");
-        Expr* inner = a.getInner();
-        gen.emitExpr(out, inner);
-        out.print(") || c2_assert(\"%s\", %d, \"%s\", \"", loc.filename, loc.line, funcname);
-        // encode expression as a string
-        string_buffer.Buf* str = string_buffer.create(128, false, 0);
-        inner.printLiteral(str);
-        out.encodeBytes(str.data(), str.size(), '"');
-        str.free();
-        out.add("\");\n");
-#endif
+        out.add("assert(");
+        gen.emitExpr(a.getInner());
+        out.add(");\n");
         break;
     }
 }
diff --git a/generator/c/c_generator.c2 b/generator/c/c_generator.c2
@@ -1354,17 +1354,6 @@ const char[] C_types =
     #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
     ```;
 
-const char[] C2_assert =
-    ```c
-    int dprintf(int fd, const char *format, ...);
-    void abort(void);
-    static int c2_assert(const char* filename, int line, const char* funcname, const char* condstr) {
-        dprintf(2, "%s:%d: function %s: Assertion failed: %s\n", filename, line, funcname, condstr);
-        abort();
-        return 0;
-    }
-    ```;
-
 const char[] C2_strswitch =
     ```c
     static int c2_strswitch(const char* s1, const char* s2) {
@@ -1405,10 +1394,6 @@ fn void Generator.emit_external_header(Generator* gen, bool enable_asserts, cons
 #endif
     out.add("#define to_container(type, member, ptr) ((type*)((char*)(ptr) - offsetof(type, member)))\n\n");
 
-    if (enable_asserts) {
-        out.add(C2_assert);
-    }
-
     // for switch(str):
     // String format: strings are prefixed by a length byte and concatenated as a single character array.
     // This minimizes memory use, cache misses and avoids extra symbols.
diff --git a/generator/c/c_generator_call.c2 b/generator/c/c_generator_call.c2
@@ -137,6 +137,9 @@ fn void Generator.emitCall(Generator* gen, string_buffer.Buf* out, Expr* e) {
                 if (vd.hasAttrAutoLine()) {
                     out.print("%d", loc.line);
                 }
+                if (vd.hasAttrAutoFunc()) {
+                    out.print("\"%s\"", gen.cur_function.asDecl().getFullName());
+                }
                 needs_comma = true;
                 func_index++;
                 continue;
diff --git a/generator/c/c_generator_stmt.c2 b/generator/c/c_generator_stmt.c2
@@ -16,7 +16,6 @@
 module c_generator;
 
 import ast local;
-import source_mgr;
 import string_buffer;
 
 fn void Generator.emitVarDecl(Generator* gen, VarDecl* vd, string_buffer.Buf* out, bool emit_init, bool first) {
@@ -242,19 +241,14 @@ fn void Generator.emitStmt(Generator* gen, Stmt* s, u32 indent, bool newline) {
         if (!gen.enable_asserts) break;
 
         AssertStmt* a = cast<AssertStmt*>(s);
-        source_mgr.Location loc = gen.sm.locate(s.getLoc());
-        const char* funcname = gen.cur_function.asDecl().getFullName();
-
-        out.add("(");
-        Expr* inner = a.getInner();
-        gen.emitExpr(out, inner);
-        out.print(") || c2_assert(\"%s\", %d, \"%s\", \"", loc.filename, loc.line, funcname);
-        // encode expression as a string
-        string_buffer.Buf* str = string_buffer.create(128, false, 0);
-        inner.printLiteral(str);
-        out.encodeBytes(str.data(), str.size(), '"');
-        str.free();
-        out.add("\");\n");
+        Expr* call = a.getCall();
+        if (call) {
+            out.add("(");
+            gen.emitExpr(out, a.getInner());
+            out.add(") || ");
+            gen.emitExpr(out, call);
+            out.add(";\n");
+        }
         break;
     }
 }
diff --git a/libs/libc/c2_internals.c2i b/libs/libc/c2_internals.c2i
@@ -0,0 +1,15 @@
+module c2_internals;
+
+import stdio local;
+import stdlib local;
+
+public fn i32 c2_assert(const char* filename @(auto_file),
+                        u32 line @(auto_line),
+                        const char* funcname @(auto_func),
+                        const char* condstr)
+{
+    //const char* funcname = "function";
+    dprintf(2, "%s:%d: function %s: Assertion failed: %s\n", filename, line, funcname, condstr);
+    abort();
+    return 0;
+}
diff --git a/libs/libc/manifest.yaml b/libs/libc/manifest.yaml
@@ -40,4 +40,4 @@ modules:
     - sys_utsname
     - uio
     - unistd
-
+    - c2_internals
diff --git a/parser/ast_builder.c2 b/parser/ast_builder.c2
@@ -519,30 +519,41 @@ fn void Builder.actOnVarAttr(Builder* b, Decl* d, const Attr* a) {
     }
 }
 
-public fn void Builder.actOnParamAttr(Builder* b,
+public fn bool Builder.actOnParamAttr(Builder* b,
                                       VarDecl* d,
                                       u32 name,
                                       SrcLoc loc)
 {
     AttrKind kind = attr.find(name);
     switch (kind) {
     case Unknown:
+        // TODO should be a warning
         b.diags.error(loc, "unknown attribute '%s'", ast.idx2name(name));
-        break;
+        return false;
     case PrintfFormat:
         d.setPrintfFormat();
-        break;
+        return true;
     case AutoFile:
+        if (d.hasAutoAttr()) goto invalid;
         d.setAttrAutoFile();
-        break;
+        return true;
     case AutoLine:
+        if (d.hasAutoAttr()) goto invalid;
         d.setAttrAutoLine();
-        break;
+        return true;
+    case AutoFunc:
+        if (d.hasAutoAttr()) goto invalid;
+        d.setAttrAutoFunc();
+        return true;
+    invalid:
+        b.diags.error(loc, "invalid combination of attributes");
+        return false;
     default:
         b.diags.error(loc, "attribute '%s' cannot be applied to function parameters",
-            ast.idx2name(name));
-        break;
+                      ast.idx2name(name));
+        return false;
     }
+    return false;
 }
 
 public fn void Builder.actOnAttr(Builder* b, attr.Attr* a) {
@@ -858,8 +869,8 @@ public fn SwitchCase* Builder.actOnCase(Builder* b,
                              conds, num_conds, stmts, num_stmts);
 }
 
-public fn Stmt* Builder.actOnAssertStmt(Builder* b, SrcLoc loc, Expr* inner) {
-    return (Stmt*)AssertStmt.create(b.context, loc, inner);
+public fn Stmt* Builder.actOnAssertStmt(Builder* b, SrcLoc loc, Expr* inner, Expr* call) {
+    return (Stmt*)AssertStmt.create(b.context, loc, inner, call);
 }
 
 public fn Stmt* Builder.actOnBreakStmt(Builder* b, SrcLoc loc) {
diff --git a/parser/c2_parser.c2 b/parser/c2_parser.c2
diff --git a/parser/c2_parser_stmt.c2 b/parser/c2_parser_stmt.c2
diff --git a/test/auto_args/auto_arg_bad_type.c2 b/test/auto_args/auto_arg_bad_type.c2
diff --git a/test/auto_args/auto_arg_both.c2 b/test/auto_args/auto_arg_both.c2
diff --git a/tools/c2cat.c2 b/tools/c2cat.c2

Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,9 @@ fn void Analyser.analyseFunction(Analyser* ma, FunctionDecl* fd) {`
`99`	`99`	`if (v.hasAttrAutoLine() && !ref.isU32()) { // check for 'u32'`
`100`	`100`	`ma.error(ref.getLoc(), "attribute 'auto_line' requires a parameter of type 'u32'");`
`101`	`101`	`}`
	`102`	`+ if (v.hasAttrAutoFunc() && !ref.isConstCharPtr()) { // check for 'const char *'`
	`103`	`+ ma.error(ref.getLoc(), "attribute 'auto_func' requires a parameter of type 'const char*'");`
	`104`	`+ }`
`102`	`105`	`}`
`103`	`106`
`104`	`107`	`if (v.hasPrintfFormat()) {`
Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,7 @@ public fn u32 QualType.getBitFieldWidth(const QualType* qt) {`
`97`	`97`	`return bi.getBitfieldSize();`
`98`	`98`	`}`
`99`	`99`	`if (t.isEnumType()) {`
	`100`	`+ // TODO return bits needed for max value to allow use in bitfields`
`100`	`101`	`EnumType* et = (EnumType*)t;`
`101`	`102`	`QualType impl = et.getImplType();`
`102`	`103`	`return impl.getBitFieldWidth();`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ public type AttrKind enum u8 {`
`40`	`40`	`Pure, // Func`
`41`	`41`	`AutoFile, // Var, function param only`
`42`	`42`	`AutoLine, // Var, function param only`
	`43`	`+ AutoFunc, // Var, function param only`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`const char*[] attrKind_names = {`
`@@ -63,6 +64,7 @@ const char*[] attrKind_names = {`
`63`	`64`	`"pure",`
`64`	`65`	`"auto_file",`
`65`	`66`	`"auto_line",`
	`67`	`+ "auto_func",`
`66`	`68`	`}`
`67`	`69`
`68`	`70`	`static_assert(elemsof(AttrKind), elemsof(attrKind_names));`
`@@ -140,6 +142,7 @@ const AttrReq[] Required_arg = {`
`140`	`142`	`[AttrKind.Pure] = AttrReq.NoArg,`
`141`	`143`	`[AttrKind.AutoFile] = AttrReq.NoArg,`
`142`	`144`	`[AttrKind.AutoLine] = AttrReq.NoArg,`
	`145`	`+ [AttrKind.AutoFunc] = AttrReq.NoArg,`
`143`	`146`	`}`
`144`	`147`	`static_assert(elemsof(AttrKind), elemsof(Required_arg));`
`145`	`148`
Original file line number	Diff line number	Diff line change
`@@ -213,6 +213,8 @@ fn void Visitor.handleStmt(Visitor* v, Stmt* s) {`
`213`	`213`	`case Assert:`
`214`	`214`	`AssertStmt* a = cast<AssertStmt*>(s);`
`215`	`215`	`v.handleExpr(a.getInner());`
	`216`	`+ Expr* call = a.getCall();`
	`217`	`+ if (call) v.handleExpr(call);`
`216`	`218`	`break;`
`217`	`219`	`}`
`218`	`220`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,7 @@ fn void Generator.emitVarDecl(Generator* gen, const Decl* d, u32 indent) {`
`69`	`69`	`if (v.hasAutoAttr()) {`
`70`	`70`	`if (v.hasAttrAutoFile()) out.add(" @(auto_file)");`
`71`	`71`	`if (v.hasAttrAutoLine()) out.add(" @(auto_line)");`
	`72`	`+ if (v.hasAttrAutoFunc()) out.add(" @(auto_func)");`
`72`	`73`	`}`
`73`	`74`	`// Note: dont add ';' because it could also be a function argument`
`74`	`75`	`}`