ATDF nested register groups (#650)

Author: mattnite

build.zig

@@ -208,6 +208,16 @@ var port_cache: PortCache = .{};
 /// ```
 pub fn MicroBuild(port_select: PortSelect) type {
     return struct {
+        builder: *Build,
+        dep: *Build.Dependency,
+        core_dep: *Build.Dependency,
+        drivers_dep: *Build.Dependency,
+
+        /// Contains all the ports you selected.
+        ports: SelectedPorts,
+
+        const Self = @This();
+
         const SelectedPorts = blk: {
             var fields: []const std.builtin.Type.StructField = &.{};
 
@@ -234,16 +244,6 @@ pub fn MicroBuild(port_select: PortSelect) type {
             });
         };
 
-        const Self = @This();
-
-        builder: *Build,
-        dep: *Build.Dependency,
-        core_dep: *Build.Dependency,
-        drivers_dep: *Build.Dependency,
-
-        /// Contains all the ports you selected.
-        ports: SelectedPorts,
-
         const InitReturnType = blk: {
             @setEvalBranchQuota(2000);
 

tools/regz/src/Database.zig

@@ -663,6 +663,20 @@ pub fn get_peripheral_by_name(db: *Database, name: []const u8) !?PeripheralID {
     return db.get_id_by_name(PeripheralID, name);
 }
 
+/// Get the struct ID for a struct decl with `name` in parent struct
+pub fn get_struct_decl_id_by_name(db: *Database, parent: StructID, name: []const u8) !StructID {
+    const query =
+        \\SELECT struct_id
+        \\FROM struct_decls
+        \\WHERE parent_id = ? AND name = ?
+    ;
+
+    return db.one(StructID, query, .{
+        .parent_id = parent,
+        .name = name,
+    });
+}
+
 pub fn get_struct_decl_by_name(db: *Database, allocator: Allocator, parent: StructID, name: []const u8) !StructDecl {
     const query = std.fmt.comptimePrint(
         \\SELECT {s}
@@ -945,12 +959,16 @@ pub fn get_nested_struct_fields_with_calculated_size(
     const nested_struct_fields = try db.get_nested_struct_fields(allocator, struct_id);
     defer allocator.free(nested_struct_fields);
 
+    log.debug("nested_struct_fields.len={} struct_id={}", .{ nested_struct_fields.len, struct_id });
+
     var size_cache: std.AutoArrayHashMap(StructID, u64) = .init(allocator);
     defer size_cache.deinit();
 
     for (nested_struct_fields) |*nsf| {
-        if (nsf.size_bytes != null)
+        if (nsf.size_bytes != null) {
+            try ret.append(nsf.*);
             continue;
+        }
 
         var depth: u8 = 0;
         const size_bytes = try db.recursively_calculate_struct_size(&depth, &size_cache, allocator, nsf.struct_id);

tools/regz/src/atdf.zig

@@ -273,12 +273,13 @@ fn infer_enum_size(allocator: Allocator, module_node: xml.Node, value_group_node
     var field_sizes = std.ArrayList(u64).init(allocator);
     defer field_sizes.deinit();
 
-    var register_it = module_node.iterate(&.{}, &.{"register"});
+    var register_it = module_node.iterate(&.{"register-group"}, &.{"register"});
     while (register_it.next()) |register_node| {
         var bitfield_it = register_node.iterate(&.{}, &.{"bitfield"});
         while (bitfield_it.next()) |bitfield_node| {
             if (bitfield_node.get_attribute("values")) |values| {
                 if (std.mem.eql(u8, values, value_group_name)) {
+                    log.debug("found values={s}", .{values});
                     const mask_str = bitfield_node.get_attribute("mask") orelse continue;
                     const mask = try std.fmt.parseInt(u64, mask_str, 0);
                     try field_sizes.append(@popCount(mask));
@@ -288,6 +289,8 @@ fn infer_enum_size(allocator: Allocator, module_node: xml.Node, value_group_node
         }
     }
 
+    log.debug("found field usage count of: {}", .{field_sizes.items.len});
+
     // if all the field sizes are the same, and the max value can fit in there,
     // then set the size of the enum. If there are no usages of an enum, then
     // assign it the smallest value possible
@@ -305,8 +308,10 @@ fn infer_enum_size(allocator: Allocator, module_node: xml.Node, value_group_node
                 return error.InconsistentEnumSizes;
         }
 
-        if (max_value > 0 and (std.math.log2_int(u64, max_value) + 1) > ret.?)
-            return error.EnumMaxValueTooBig;
+        if (max_value > 0 and (std.math.log2_int(u64, max_value) + 1) > ret.?) {
+            log.warn("Uses of this enum are smaller than the calculated size", .{});
+            return std.math.log2_int(u64, max_value);
+        }
 
         break :blk @intCast(ret.?);
     };
@@ -369,7 +374,7 @@ fn load_module_type(ctx: *Context, node: xml.Node) !void {
     // registers. This operation needs to be done in
     // `loadModuleInstance()` as well
     if (get_inlined_register_group(node, name)) |register_group_node| {
-        try load_register_group_children(ctx, register_group_node, struct_id);
+        try load_register_group_children(ctx, register_group_node, peripheral, struct_id);
     } else {
         var register_group_it = node.iterate(&.{}, &.{"register-group"});
         while (register_group_it.next()) |register_group_node|
@@ -407,6 +412,7 @@ fn load_module_interrupt_group_entry(
 fn load_register_group_children(
     ctx: *Context,
     node: xml.Node,
+    peripheral: PeripheralID,
     parent: StructID,
 ) !void {
     var mode_it = node.iterate(&.{}, &.{"mode"});
@@ -416,9 +422,59 @@ fn load_register_group_children(
             return err;
         };
 
-    var register_it = node.iterate(&.{}, &.{ "register", "register-group" });
+    var register_it = node.iterate(&.{}, &.{"register"});
     while (register_it.next()) |register_node|
         try load_register(ctx, register_node, parent);
+
+    var register_group_it = node.iterate(&.{}, &.{"register-group"});
+    while (register_group_it.next()) |register_group_node|
+        try load_nested_register_group(ctx, register_group_node, peripheral, parent);
+}
+
+fn load_nested_register_group(
+    ctx: *Context,
+    node: xml.Node,
+    peripheral: PeripheralID,
+    parent: StructID,
+) !void {
+    const db = ctx.db;
+    log.debug("load_nested_register_group: peripheral={} parent={}", .{ peripheral, parent });
+
+    validate_attrs(node, &.{
+        "name",
+        "name-in-module",
+        "offset",
+        "size",
+        "count",
+        "caption",
+    });
+
+    const name = node.get_attribute("name") orelse return error.MissingRegisterName;
+    const name_in_module = node.get_attribute("name-in-module") orelse return error.MissingNameInModule;
+
+    const peripheral_struct_id = try db.get_peripheral_struct(peripheral);
+    log.debug("  peripheral_struct_id={}", .{peripheral_struct_id});
+    const struct_id = try db.get_struct_decl_id_by_name(peripheral_struct_id, name_in_module);
+    log.debug("  struct_id={}", .{struct_id});
+
+    try db.add_nested_struct_field(parent, .{
+        .name = name,
+        .struct_id = struct_id,
+        .offset_bytes = if (node.get_attribute("offset")) |offset_str|
+            try std.fmt.parseInt(u64, offset_str, 0)
+        else
+            return error.MissingRegisterOffset,
+        .description = node.get_attribute("caption"),
+
+        .size_bytes = if (node.get_attribute("size")) |size_str|
+            try std.fmt.parseInt(u64, size_str, 0)
+        else
+            null,
+        .count = if (node.get_attribute("count")) |count_str|
+            try std.fmt.parseInt(u64, count_str, 0)
+        else
+            null,
+    });
 }
 
 fn infer_register_group_offset(ctx: *Context, node: xml.Node, struct_id: StructID) !void {
@@ -439,34 +495,16 @@ fn infer_register_group_offset(ctx: *Context, node: xml.Node, struct_id: StructI
 
 // loads a register group which is under a peripheral or under another
 // register-group
-//
-// TODO: implement nested register groups
 fn load_register_group(ctx: *Context, node: xml.Node, parent: PeripheralID) !void {
     const db = ctx.db;
 
-    //switch (parent) {
-    //    .peripheral =>
-
     validate_attrs(node, &.{
         "name",
         "caption",
         "aligned",
         "section",
         "size",
     });
-    //    .register_group => validate_attrs(node, &.{
-    //        "name",
-    //        "modes",
-    //        "size",
-    //        "name-in-module",
-    //        "caption",
-    //        "count",
-    //        "start-index",
-    //        "offset",
-    //    }),
-    //}
-
-    // TODO: for now just making register groups into structs.
 
     const parent_struct_id = try db.get_peripheral_struct(parent);
     const struct_id = try db.create_nested_struct(parent_struct_id, .{
@@ -479,7 +517,7 @@ fn load_register_group(ctx: *Context, node: xml.Node, parent: PeripheralID) !voi
     });
 
     try infer_register_group_offset(ctx, node, struct_id);
-    try load_register_group_children(ctx, node, struct_id);
+    try load_register_group_children(ctx, node, parent, struct_id);
     // TODO: infer register group size?
     // Do register groups ever operate as just namespaces?
 
@@ -786,6 +824,8 @@ fn load_enum(
         .size_bits = size_bits,
     });
 
+    log.debug("{}: name={s} inferred_size={}", .{ enum_id, name, size_bits });
+
     var value_it = node.iterate(&.{}, &.{"value"});
     while (value_it.next()) |value_node|
         load_enum_field(ctx, value_node, enum_id) catch {};
@@ -862,6 +902,7 @@ fn load_module_instance(
 
     const struct_id = try ctx.db.get_peripheral_struct(peripheral_id);
 
+    //
     // register-group never has an offset in a module, so we can safely assume
     // that they're used as variants of a peripheral, and never used like
     // clusters in SVD.

tools/regz/src/gen.zig

@@ -1035,12 +1035,16 @@ fn write_nested_struct_field(db: *Database, arena: Allocator, nsf: *const Nested
     try write_doc_comment(arena, offset_str, writer);
 
     try writer.print("{}: ", .{std.zig.fmtId(nsf.name)});
+    var array_prefix_buf: [80]u8 = undefined;
+    const array_prefix: []const u8 = if (nsf.count) |count|
+        try std.fmt.bufPrint(&array_prefix_buf, "[{}]", .{count})
+    else
+        "";
+    try writer.print("{s}", .{array_prefix});
 
     // TODO: if it's a struct decl then refer to it by name
     if (try db.get_struct_decl_by_struct_id(arena, nsf.struct_id)) |struct_decl| {
-        if (struct_decl.parent_id != nsf.parent_id)
-            return error.TodoDifferentParentStructDecl;
-
+        // TODO full reference?
         try writer.print("{},\n", .{std.zig.fmtId(struct_decl.name)});
     } else {
         try write_struct(db, arena, null, nsf.struct_id, writer);
@@ -1056,6 +1060,7 @@ fn write_registers_and_nested_structs_base(
     nested_struct_fields: []NestedStructField,
     out_writer: anytype,
 ) !void {
+    log.debug("registers.len={} nested_struct_fields.len={}", .{ registers.len, nested_struct_fields.len });
     var it: StructFieldIterator = .init(registers, nested_struct_fields);
 
     var buffer = std.ArrayList(u8).init(arena);
@@ -1186,6 +1191,7 @@ fn write_fields(
     var offset: u64 = 0;
 
     for (expanded_fields.items) |field| {
+        log.debug("next field: offset={} field.offset_bits={}", .{ offset, field.offset_bits });
         if (offset > field.offset_bits) {
             // It's possible there are fields that overlap so
             // we're going to filter out some fields so there's no overlap.
@@ -1217,7 +1223,12 @@ fn write_fields(
 
         if (field.enum_id) |enum_id| {
             const e = try db.get_enum(arena, enum_id);
-            if (e.name) |enum_name| {
+            if (e.size_bits != field.size_bits) {
+                log.warn("{}: fails to match the size of {s}, with sizes of {} and {} respectively. Not assigning type.", .{
+                    enum_id, field.name, e.size_bits, field.size_bits,
+                });
+                try writer.print("{}: u{},\n", .{ std.zig.fmtId(field.name), field.size_bits });
+            } else if (e.name) |enum_name| {
                 if (e.struct_id == null or try db.enum_has_name_collision(enum_id)) {
                     try writer.print(
                         \\{}: enum(u{}) {{
@@ -1254,12 +1265,18 @@ fn write_fields(
             try writer.print("{}: u{},\n", .{ std.zig.fmtId(field.name), field.size_bits });
         }
 
+        log.debug("adding size bits to offset: offset={} field.size_bits={}", .{ offset, field.size_bits });
         offset += field.size_bits;
     }
 
+    log.debug("before padding: offset={} register_size_bits={}", .{ offset, register_size_bits });
     assert(offset <= register_size_bits);
-    if (offset < register_size_bits)
+    if (offset < register_size_bits) {
+        log.debug("writing padding", .{});
         try writer.print("padding: u{} = 0,\n", .{register_size_bits - offset});
+    } else {
+        log.debug("No padding", .{});
+    }
 
     try out_writer.writeAll(buffer.items);
 }