translate-c: annotate volatile-qualified non-pointer typedefs

Author: theofabilous

src/translate_c.zig

@@ -265,6 +265,16 @@ fn declVisitorNamesOnly(c: *Context, decl: *const clang.Decl) Error!void {
                 c.weak_global_names.putAssumeCapacity(decl_name, {});
                 c.weak_global_names.putAssumeCapacity(prefixed_name, {});
             },
+            .Typedef => {
+                const typedef_decl = @as(*const clang.TypedefNameDecl, @ptrCast(decl));
+                const child_qt = typedef_decl.getUnderlyingType();
+                if (child_qt.isVolatileQualified()) {
+                    const prefixed_name = try std.fmt.allocPrint(c.arena, "volatile_{s}", .{decl_name});
+                    try c.weak_global_names.put(c.gpa, prefixed_name, {});
+                } else {
+                    try c.global_names.put(c.gpa, decl_name, {});
+                }
+            },
             else => {
                 try c.global_names.put(c.gpa, decl_name, {});
             },
@@ -697,10 +707,14 @@ fn transTypeDef(c: *Context, scope: *Scope, typedef_decl: *const clang.TypedefNa
     if (builtin_typedef_map.get(name)) |builtin| {
         return c.decl_table.putNoClobber(c.gpa, @intFromPtr(typedef_decl.getCanonicalDecl()), builtin);
     }
+    const child_qt = typedef_decl.getUnderlyingType();
+    if (child_qt.isVolatileQualified()) {
+        name = try std.fmt.allocPrint(c.arena, "volatile_{s}", .{name});
+        if (toplevel) name = try mangleWeakGlobalName(c, name);
+    }
     if (!toplevel) name = try bs.makeMangledName(c, name);
     try c.decl_table.putNoClobber(c.gpa, @intFromPtr(typedef_decl.getCanonicalDecl()), name);
 
-    const child_qt = typedef_decl.getUnderlyingType();
     const typedef_loc = typedef_decl.getLocation();
     const init_node = transQualType(c, scope, child_qt, typedef_loc) catch |err| switch (err) {
         error.UnsupportedType => {

test/cases/translate_c/volatile_typedef.c

@@ -15,6 +15,14 @@ extern hw_t hw_arr[4];
 extern const mmio_int reg;
 extern mmio_int *regs;
 
+// Check name mangling
+typedef volatile unsigned int mmio_uint;
+typedef unsigned int volatile_mmio_uint;
+static unsigned int check_typenames(void) {
+    const mmio_uint x = 0u;
+    return (volatile_mmio_uint)x;
+}
+
 static int hw_reg(void) {
     return hw->reg;
 }
@@ -54,42 +62,49 @@ static int ptr_arith(void) {
 // translate-c
 // c_frontend=clang
 //
-// pub const mmio_int = c_int;
-// pub const mmio_int_ptr = [*c]volatile mmio_int;
+// pub const volatile_mmio_int = c_int;
+// pub const mmio_int_ptr = [*c]volatile volatile_mmio_int;
 // pub const hw_t = extern struct {
-//     reg: mmio_int = @import("std").mem.zeroes(mmio_int),
-//     regs: [4]mmio_int = @import("std").mem.zeroes([4]mmio_int),
-//     regm: [2][2]mmio_int = @import("std").mem.zeroes([2][2]mmio_int),
+//     reg: volatile_mmio_int = @import("std").mem.zeroes(volatile_mmio_int),
+//     regs: [4]volatile_mmio_int = @import("std").mem.zeroes([4]volatile_mmio_int),
+//     regm: [2][2]volatile_mmio_int = @import("std").mem.zeroes([2][2]volatile_mmio_int),
 //     ptr: mmio_int_ptr = @import("std").mem.zeroes(mmio_int_ptr),
 // };
 // pub extern var hw: [*c]hw_t;
 // pub extern var hw_arr: [4]hw_t;
-// pub extern const reg: mmio_int;
-// pub extern var regs: [*c]volatile mmio_int;
+// pub extern const reg: volatile_mmio_int;
+// pub extern var regs: [*c]volatile volatile_mmio_int;
+// pub const volatile_mmio_uint_1 = c_uint;
+// pub const volatile_mmio_uint = c_uint;
+// pub fn check_typenames() callconv(.c) c_uint {
+//     const x: volatile_mmio_uint_1 = 0;
+//     _ = &x;
+//     return @as(volatile_mmio_uint, @bitCast(x));
+// }
 // pub fn hw_reg() callconv(.c) c_int {
-//     return @as([*c]volatile mmio_int, @ptrCast(&hw.*.reg)).*;
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(&hw.*.reg)).*;
 // }
-// pub fn hw_reg_ptr() callconv(.c) @TypeOf(@as([*c]volatile mmio_int, @ptrCast(&@as([*c]volatile mmio_int, @ptrCast(&hw.*.reg)).*))) {
-//     return @as([*c]volatile mmio_int, @ptrCast(&@as([*c]volatile mmio_int, @ptrCast(&hw.*.reg)).*));
+// pub fn hw_reg_ptr() callconv(.c) @TypeOf(@as([*c]volatile volatile_mmio_int, @ptrCast(&@as([*c]volatile volatile_mmio_int, @ptrCast(&hw.*.reg)).*))) {
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(&@as([*c]volatile volatile_mmio_int, @ptrCast(&hw.*.reg)).*));
 // }
 // pub fn hw_ptr() callconv(.c) mmio_int_ptr {
 //     return hw.*.ptr;
 // }
-// pub fn reg_ptr() callconv(.c) @TypeOf(@as([*c]const volatile mmio_int, @ptrCast(&reg))) {
-//     return @as([*c]const volatile mmio_int, @ptrCast(&reg));
+// pub fn reg_ptr() callconv(.c) @TypeOf(@as([*c]const volatile volatile_mmio_int, @ptrCast(&reg))) {
+//     return @as([*c]const volatile volatile_mmio_int, @ptrCast(&reg));
 // }
 // pub fn hw_regs_0() callconv(.c) c_int {
-//     return @as([*c]volatile mmio_int, @ptrCast(&hw.*.regs[@as(c_uint, 0)])).*;
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(&hw.*.regs[@as(c_uint, 0)])).*;
 // }
 // pub fn hw_0_regs_0() callconv(.c) c_int {
-//     return @as([*c]volatile mmio_int, @ptrCast(&hw_arr[@as(c_uint, 0)].regs[@as(c_uint, 0)])).*;
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(&hw_arr[@as(c_uint, 0)].regs[@as(c_uint, 0)])).*;
 // }
 // pub fn hw_regm_00() callconv(.c) c_int {
-//     return @as([*c]volatile mmio_int, @ptrCast(&hw.*.regm[@as(c_uint, 0)][@as(c_uint, 0)])).*;
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(&hw.*.regm[@as(c_uint, 0)][@as(c_uint, 0)])).*;
 // }
 // pub fn hw_regm_0_deref() callconv(.c) c_int {
-//     return @as([*c]volatile mmio_int, @ptrCast(@as([*c]volatile mmio_int, @ptrCast(@alignCast(&hw.*.regm[@as(c_uint, 0)]))))).*;
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(@as([*c]volatile volatile_mmio_int, @ptrCast(@alignCast(&hw.*.regm[@as(c_uint, 0)]))))).*;
 // }
 // pub fn ptr_arith() callconv(.c) c_int {
-//     return @as([*c]volatile mmio_int, @ptrCast(regs + @as(c_uint, 1))).*;
+//     return @as([*c]volatile volatile_mmio_int, @ptrCast(regs + @as(c_uint, 1))).*;
 // }