Skip to content

Comptime panic with destructing fields #23389

Closed as duplicate of#19730
Closed as duplicate of#19730
@RossComputerGuy

Description

@RossComputerGuy

Zig Version

0.15.0-dev.128+5b4759bd3

Steps to Reproduce and Observed Behavior

Compile this: https://github.com/ZenithOSProject/zenith/blob/a6431b220ab6cda682495d482d7891a7e4ee6e74/kernel/arch/x86/Gdt.zig#L34-L42

error: thread 95817 panic: integer overflow
Analyzing kernel/arch/x86/Gdt.zig
      %40 = ret_type() 
      %41 = dbg_stmt(2, 9)
      %42 = decl_ref("std") 
      %43 = dbg_stmt(2, 12)
      %44 = field_ptr(%42, "debug") 
      %45 = dbg_stmt(2, 25)
      %46 = field_call(nodiscard .auto, %44, "assert", [
        {
          %47 = dbg_stmt(2, 31)
          %48 = field_val(%37, "reserved") 
          %49 = cmp_eq(%48, @zero) 
          %50 = break_inline(%46, %49)
        },
      ]) 
      %51 = dbg_stmt(3, 9)
      %52 = ret_ptr() 
      %53 = opt_eu_base_ptr_init(%52) 
      %54 = struct_init_field_ptr(%53, "limit_low") 
      %55 = typeof(%54) 
      %56 = elem_type(%55) 
      %57 = dbg_stmt(4, 26)
      %58 = truncate(%56, %31) 
      %59 = store_node(%54, %58) 
      %60 = struct_init_field_ptr(%53, "base_low") 
      %61 = typeof(%60) 
      %62 = elem_type(%61) 
      %63 = dbg_stmt(5, 25)
      %64 = truncate(%62, %28) 
      %65 = store_node(%60, %64) 
      %66 = struct_init_field_ptr(%53, "access") 
      %67 = opt_eu_base_ptr_init(%66) 
      %68 = struct_init_field_ptr(%67, "accessed") 
      %69 = dbg_stmt(7, 35)
      %70 = field_val(%34, "accessed") 
    > %71 = store_node(%68, %70) 
      %72 = struct_init_field_ptr(%67, "read_write") 
      %73 = dbg_stmt(8, 37)
      %74 = field_val(%34, "read_write") 
      %75 = store_node(%72, %74) 
      %76 = struct_init_field_ptr(%67, "direction_conforming") 
      %77 = dbg_stmt(9, 47)
      %78 = field_val(%34, "direction_conforming") 
      %79 = store_node(%76, %78) 
      %80 = struct_init_field_ptr(%67, "executable") 
      %81 = dbg_stmt(10, 37)
      %82 = field_val(%34, "executable") 
      %83 = store_node(%80, %82) 
      %84 = struct_init_field_ptr(%67, "descriptor") 
      %85 = dbg_stmt(11, 37)
      %86 = field_val(%34, "descriptor") 
      %87 = store_node(%84, %86) 
      %88 = struct_init_field_ptr(%67, "privilege") 
      %89 = dbg_stmt(12, 36)
      %90 = field_val(%34, "privilege") 
      %91 = store_node(%88, %90) 
      %92 = struct_init_field_ptr(%67, "present") 
      %93 = dbg_stmt(13, 34)
      %94 = field_val(%34, "present") 
      %95 = store_node(%92, %94) 
      %96 = validate_ptr_struct_init({
        %68 = struct_init_field_ptr(%67, "accessed") 
        %72 = struct_init_field_ptr(%67, "read_write") 
        %76 = struct_init_field_ptr(%67, "direction_conforming") 
        %80 = struct_init_field_ptr(%67, "executable") 
        %84 = struct_init_field_ptr(%67, "descriptor") 
        %88 = struct_init_field_ptr(%67, "privilege") 
        %92 = struct_init_field_ptr(%67, "present") 
      }) 
      %97 = struct_init_field_ptr(%53, "limit_high") 
      %98 = typeof(%97) 
      %99 = elem_type(%98) 
      %100 = typeof_log2_int_type(%31) 
      %101 = int(16)
      %102 = as_shift_operand(%100, %101) 
      %103 = dbg_stmt(15, 43)
      %104 = shr(%31, %102) 
      %105 = dbg_stmt(15, 27)
      %106 = truncate(%99, %104) 
      %107 = store_node(%97, %106) 
      %108 = struct_init_field_ptr(%53, "flags") 
      %109 = opt_eu_base_ptr_init(%108) 
      %110 = struct_init_field_ptr(%109, "reserved") 
      %111 = dbg_stmt(17, 34)
      %112 = field_val(%37, "reserved") 
      %113 = store_node(%110, %112) 
      %114 = struct_init_field_ptr(%109, "is_64bit") 
      %115 = dbg_stmt(18, 34)
      %116 = field_val(%37, "is_64bit") 
      %117 = store_node(%114, %116) 
      %118 = struct_init_field_ptr(%109, "is_32bit") 
      %119 = dbg_stmt(19, 34)
      %120 = field_val(%37, "is_32bit") 
      %121 = store_node(%118, %120) 
      %122 = struct_init_field_ptr(%109, "granularity") 
      %123 = dbg_stmt(20, 37)
      %124 = field_val(%37, "granularity") 
      %125 = store_node(%122, %124) 
      %126 = validate_ptr_struct_init({
        %110 = struct_init_field_ptr(%109, "reserved") 
        %114 = struct_init_field_ptr(%109, "is_64bit") 
        %118 = struct_init_field_ptr(%109, "is_32bit") 
        %122 = struct_init_field_ptr(%109, "granularity") 
      }) 
      %127 = struct_init_field_ptr(%53, "base_high") 
      %128 = typeof(%127) 
      %129 = elem_type(%128) 
      %130 = typeof_log2_int_type(%28) 
      %131 = int(24)
      %132 = as_shift_operand(%130, %131) 
      %133 = dbg_stmt(22, 41)
      %134 = shr(%28, %132) 
      %135 = dbg_stmt(22, 26)
      %136 = truncate(%129, %134) 
      %137 = store_node(%127, %136) 
      %138 = validate_ptr_struct_init({
        %54 = struct_init_field_ptr(%53, "limit_low") 
        %60 = struct_init_field_ptr(%53, "base_low") 
        %66 = struct_init_field_ptr(%53, "access") 
        %97 = struct_init_field_ptr(%53, "limit_high") 
        %108 = struct_init_field_ptr(%53, "flags") 
        %127 = struct_init_field_ptr(%53, "base_high") 
      }) 
      %139 = restore_err_ret_index_unconditional(.none) 
      %140 = dbg_stmt(3, 9)
      %141 = ret_load(%52) 
    For full context, use the command
      zig ast-check -t kernel/arch/x86/Gdt.zig

  in kernel/arch/x86/Gdt.zig
    > %300 = field_call(.auto, %298, "init", [
        {%301},
        {%302},
        {%303, %304},
        {%305, %306},
      ]) 
  in kernel/arch/x86/Gdt.zig
    > %373 = decl_ref("entries") 

/home/rad/lab/zig/src/Sema/bitcast.zig:157:59: 0x78c7d0e in bitCastSpliceInner (zig)
        .{ val_ty.abiSize(zcu) * 8 - host_bits, host_bits - val_ty.bitSize(zcu) }
                                                          ^
/home/rad/lab/zig/src/Sema/bitcast.zig:54:30: 0x74f044c in bitCastSplice (zig)
    return bitCastSpliceInner(sema, val, splice_val, byte_offset, host_bits, bit_offset) catch |err| switch (err) {
                             ^
/home/rad/lab/zig/src/Sema/comptime_ptr_access.zig:185:46: 0x74ef184 in storeComptimePtr (zig)
    const new_val = try sema.bitCastSpliceVal(
                                             ^
/home/rad/lab/zig/src/Sema.zig:31007:38: 0x74f0923 in storePtrVal (zig)
    switch (try sema.storeComptimePtr(block, src, coerced_ptr_val, coerced_operand_val)) {
                                     ^
/home/rad/lab/zig/src/Sema.zig:30809:32: 0x7010886 in storePtr2 (zig)
        return sema.storePtrVal(block, src, ptr_val, operand_val, elem_ty);
                               ^
/home/rad/lab/zig/src/Sema.zig:5789:26: 0x7108ccc in zirStoreNode (zig)
    return sema.storePtr2(block, src, ptr, ptr_src, operand, operand_src, air_tag);
                         ^
/home/rad/lab/zig/src/Sema.zig:1487:38: 0x6bfe71a in analyzeBodyInner (zig)
                try sema.zirStoreNode(block, inst);
                                     ^
/home/rad/lab/zig/src/Sema.zig:1007:26: 0x700bf81 in analyzeFnBody (zig)
    sema.analyzeBodyInner(block, body) catch |err| switch (err) {
                         ^
/home/rad/lab/zig/src/Sema.zig:8253:27: 0x71379eb in analyzeCall (zig)
        sema.analyzeFnBody(&child_block, fn_zir_info.body) catch |err| switch (err) {
                          ^
/home/rad/lab/zig/src/Sema.zig:7229:43: 0x706db3c in zirCall__anon_484637 (zig)
    const call_inst = try sema.analyzeCall(block, func, func_ty, callee_src, call_src, modifier, ensure_result_used, args_info, call_dbg_node, .call);
                                          ^
/home/rad/lab/zig/src/Sema.zig:1146:62: 0x6bfbae3 in analyzeBodyInner (zig)
            .field_call                   => try sema.zirCall(block, inst, .field),
                                                             ^
/home/rad/lab/zig/src/Sema.zig:1025:30: 0x67f9e2e in analyzeInlineBody (zig)
    if (sema.analyzeBodyInner(block, body)) |_| {
                             ^
/home/rad/lab/zig/src/Sema.zig:1058:39: 0x6427c2e in resolveInlineBody (zig)
    return (try sema.analyzeInlineBody(block, body, break_target)) orelse .unreachable_value;
                                      ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:1076:58: 0x622856a in analyzeNavVal (zig)
            const result_ref = try sema.resolveInlineBody(&block, value_body, inst_resolved.inst);
                                                         ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:940:80: 0x60c1c93 in ensureNavValUpToDate (zig)
    const invalidate_value: bool, const new_failed: bool = if (pt.analyzeNavVal(nav_id)) |result| res: {
                                                                               ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:1428:36: 0x67d9a81 in analyzeNavType (zig)
        try pt.ensureNavValUpToDate(nav_id);
                                   ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:1312:80: 0x6417e13 in ensureNavTypeUpToDate (zig)
    const invalidate_type: bool, const new_failed: bool = if (pt.analyzeNavType(nav_id)) |result| res: {
                                                                               ^
/home/rad/lab/zig/src/Sema.zig:31756:44: 0x642487c in ensureNavResolved (zig)
            return pt.ensureNavTypeUpToDate(nav_index);
                                           ^
/home/rad/lab/zig/src/Sema.zig:31786:31: 0x713a53a in analyzeNavRefInner (zig)
    try sema.ensureNavResolved(src, orig_nav_index, if (is_ref) .type else .fully);
                              ^
/home/rad/lab/zig/src/Sema.zig:31775:35: 0x6c2e86f in analyzeNavRef (zig)
    return sema.analyzeNavRefInner(src, nav_index, true);
                                  ^
/home/rad/lab/zig/src/Sema.zig:6865:30: 0x706feb4 in zirDeclRef (zig)
    return sema.analyzeNavRef(src, nav_index);
                             ^
/home/rad/lab/zig/src/Sema.zig:1153:65: 0x6bfbd0b in analyzeBodyInner (zig)
            .decl_ref                     => try sema.zirDeclRef(block, inst),
                                                                ^
/home/rad/lab/zig/src/Sema.zig:1007:26: 0x700bf81 in analyzeFnBody (zig)
    sema.analyzeBodyInner(block, body) catch |err| switch (err) {
                         ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:2705:23: 0x6babc03 in analyzeFnBodyInner (zig)
    sema.analyzeFnBody(&inner_block, fn_info.body) catch |err| switch (err) {
                      ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:1622:40: 0x67d79f7 in analyzeFuncBody (zig)
    var air = try pt.analyzeFnBodyInner(func_index);
                                       ^
/home/rad/lab/zig/src/Zcu/PerThread.zig:1542:66: 0x6416f96 in ensureFuncBodyUpToDate (zig)
    const ies_outdated, const new_failed = if (pt.analyzeFuncBody(func_index)) |result|
                                                                 ^
/home/rad/lab/zig/src/Compilation.zig:4055:38: 0x6223276 in processOneJob (zig)
            pt.ensureFuncBodyUpToDate(func) catch |err| switch (err) {
                                     ^
/home/rad/lab/zig/src/Compilation.zig:3990:30: 0x60c141c in performAllTheWorkInner (zig)
            try processOneJob(@intFromEnum(Zcu.PerThread.Id.main), comp, job);
                             ^
/home/rad/lab/zig/src/Compilation.zig:3730:36: 0x5f6aefc in performAllTheWork (zig)
    try comp.performAllTheWorkInner(main_progress_node);
                                   ^
/home/rad/lab/zig/src/Compilation.zig:2333:31: 0x5f61bfe in update (zig)
    try comp.performAllTheWork(main_progress_node);
                              ^
/home/rad/lab/zig/src/main.zig:4230:32: 0x5fdf23d in serve (zig)
                try comp.update(main_progress_node);
                               ^
/home/rad/lab/zig/src/main.zig:3670:22: 0x6003dc8 in buildOutputType (zig)
            try serve(
                     ^
/home/rad/lab/zig/src/main.zig:271:31: 0x5ee0ae3 in mainArgs (zig)
        return buildOutputType(gpa, arena, args, .{ .build = .Exe });
                              ^
/home/rad/lab/zig/src/main.zig:212:20: 0x5ededf3 in main (zig)
    return mainArgs(gpa, arena, args);
                   ^
/home/rad/lab/zig/build/stage4/lib/zig/std/start.zig:656:37: 0x5edea31 in main (zig)
            const result = root.main() catch |err| {
                                    ^
???:?:?: 0x7ffff7a2b12d in ??? (libc.so.6)
Unwind information for `libc.so.6:0x7ffff7a2b12d` was not available, trace may be incomplete


error: the following command terminated unexpectedly:
/home/rad/lab/zig/build/stage5/bin/zig build-exe -ODebug -mcmodel kernel -target x86-freestanding -mcpu baseline --dep options -Mroot=/home/rad/lab/zenith/kernel/main.zig -Moptions=/home/rad/lab/zenith/.zig-cache/c/de4f3e63dc73cbf4c977b47934d73880/options.zig --no-gc-sections --cache-dir /home/rad/lab/zenith/.zig-cache --global-cache-dir /home/rad/.cache/zig --name zenith -static --script /home/rad/lab/zenith/kernel/arch/x86/platforms/pc-multiboot/linker.ld --zig-lib-dir /home/rad/lab/zig/lib/ --listen=-

Changing the highlighted lines in the source from referencing specific fields to .access = access, fixes the issue.

Expected Behavior

It should compile fine

Metadata

Metadata

Assignees

No one assigned

    Labels

    bugObserved behavior contradicts documented or intended behavior

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions