| ... | @@ -3037,7 +3037,21 @@ fn updateConstInner( | ... | @@ -3037,7 +3037,21 @@ fn updateConstInner( |
| 3037 | }); | 3037 | }); |
| 3038 | }, | 3038 | }, |
| 3039 | | 3039 | |
| 3040 | else => return, | 3040 | .undef => |ty| { |
| | 3041 | try dwarf.abbrevCode(di_nw, .undefined_comptime_value); |
| | 3042 | try dwarf.refType(pt, di_nw, .fromInterned(ty)); |
| | 3043 | }, |
| | 3044 | .simple_value => |simple_value| switch (simple_value) { |
| | 3045 | .void => unreachable, // opv state |
| | 3046 | .true, .false => unreachable, // runtime bits |
| | 3047 | .@"unreachable" => unreachable, // not a value |
| | 3048 | .null => { |
| | 3049 | // TODO: proper representation for this |
| | 3050 | try dwarf.abbrevCode(di_nw, .undefined_comptime_value); |
| | 3051 | try dwarf.refType(pt, di_nw, .null); |
| | 3052 | }, |
| | 3053 | }, |
| | 3054 | .@"extern" => unreachable, |
| 3041 | .func => |func| { | 3055 | .func => |func| { |
| 3042 | const func_type = ip.indexToKey(func.ty).func_type; | 3056 | const func_type = ip.indexToKey(func.ty).func_type; |
| 3043 | const nav = ip.getNav(func.owner_nav); | 3057 | const nav = ip.getNav(func.owner_nav); |
| ... | @@ -3069,17 +3083,424 @@ fn updateConstInner( | ... | @@ -3069,17 +3083,424 @@ fn updateConstInner( |
| 3069 | if (func_type.is_var_args) try dwarf.abbrevCode(di_nw, .is_var_args); | 3083 | if (func_type.is_var_args) try dwarf.abbrevCode(di_nw, .is_var_args); |
| 3070 | if (!empty) try di_w.writeUleb128(@backingInt(AbbrevCode.null)); | 3084 | if (!empty) try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 3071 | }, | 3085 | }, |
| | 3086 | .int => |int| { |
| | 3087 | var big_int_space: Value.BigIntSpace = undefined; |
| | 3088 | try dwarf.abbrevCode(di_nw, .comptime_value); |
| | 3089 | try dwarf.refType(pt, di_nw, .fromInterned(int.ty)); |
| | 3090 | try dwarf.bigIntConstValue( |
| | 3091 | di_w, |
| | 3092 | .fromInterned(int.ty), |
| | 3093 | Value.fromInterned(val).toBigInt(&big_int_space, zcu), |
| | 3094 | ); |
| | 3095 | }, |
| | 3096 | .bitpack => |bitpack| { |
| | 3097 | var big_int_space: Value.BigIntSpace = undefined; |
| | 3098 | const backing_int_val: Value = .fromInterned(bitpack.backing_int_val); |
| | 3099 | try dwarf.abbrevCode(di_nw, .comptime_value); |
| | 3100 | try dwarf.refType(pt, di_nw, .fromInterned(bitpack.ty)); |
| | 3101 | try dwarf.bigIntConstValue( |
| | 3102 | di_w, |
| | 3103 | backing_int_val.typeOf(zcu), |
| | 3104 | backing_int_val.toBigInt(&big_int_space, zcu), |
| | 3105 | ); |
| | 3106 | }, |
| | 3107 | .err => |err| { |
| | 3108 | try dwarf.abbrevCode(di_nw, .comptime_value); |
| | 3109 | try dwarf.refType(pt, di_nw, .fromInterned(err.ty)); |
| | 3110 | try di_w.writeUleb128(DW.FORM.udata); |
| | 3111 | try di_w.writeUleb128(try pt.getErrorValue(err.name)); |
| | 3112 | }, |
| | 3113 | .error_union => |error_union| { |
| | 3114 | try dwarf.abbrevCode(di_nw, .aggregate_undefined_comptime_value); |
| | 3115 | try dwarf.refType(pt, di_nw, .fromInterned(error_union.ty)); |
| | 3116 | var err_buf: [4]u8 = undefined; |
| | 3117 | const err_bytes = err_buf[0..@divCeil(zcu.errorSetBits(), 8)]; |
| | 3118 | const err_val = switch (error_union.val) { |
| | 3119 | .err_name => |err_name| try pt.getErrorValue(err_name), |
| | 3120 | .payload => 0, |
| | 3121 | }; |
| | 3122 | switch (err_bytes.len) { |
| | 3123 | else => unreachable, |
| | 3124 | inline 0...4 => |len| std.mem.writeInt( |
| | 3125 | @Int(.unsigned, 8 * len), |
| | 3126 | err_bytes[0..len], |
| | 3127 | @intCast(err_val), |
| | 3128 | dwarf.endian, |
| | 3129 | ), |
| | 3130 | } |
| | 3131 | { |
| | 3132 | try dwarf.abbrevCode(di_nw, .comptime_value_field_runtime); |
| | 3133 | try dwarf.strp(&dwarf.debug_str, di_nw, "is_error"); |
| | 3134 | try di_w.writeUleb128(err_bytes.len); |
| | 3135 | try di_w.writeAll(err_bytes); |
| | 3136 | } |
| | 3137 | payload_field: switch (error_union.val) { |
| | 3138 | .err_name => {}, |
| | 3139 | .payload => |payload_val| { |
| | 3140 | const payload_ty: Type = .fromInterned(ip.typeOf(payload_val)); |
| | 3141 | const payload_class = payload_ty.classify(zcu); |
| | 3142 | try dwarf.abbrevCode(di_nw, if (payload_class.comptimeOnly()) |
| | 3143 | .comptime_value_field_comptime |
| | 3144 | else if (payload_class.hasRuntimeBits()) |
| | 3145 | .comptime_value_field_runtime |
| | 3146 | else |
| | 3147 | break :payload_field); |
| | 3148 | try dwarf.strp(&dwarf.debug_str, di_nw, "value"); |
| | 3149 | if (payload_class.comptimeOnly()) |
| | 3150 | try dwarf.refConst(pt, di_nw, .fromInterned(payload_val)) |
| | 3151 | else if (payload_class.hasRuntimeBits()) |
| | 3152 | try dwarf.blockConst(pt, di_nw, .fromInterned(payload_val)) |
| | 3153 | else |
| | 3154 | unreachable; |
| | 3155 | }, |
| | 3156 | } |
| | 3157 | { |
| | 3158 | try dwarf.abbrevCode(di_nw, .comptime_value_field_runtime); |
| | 3159 | try dwarf.strp(&dwarf.debug_str, di_nw, "error"); |
| | 3160 | try di_w.writeUleb128(err_bytes.len); |
| | 3161 | try di_w.writeAll(err_bytes); |
| | 3162 | } |
| | 3163 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| | 3164 | }, |
| | 3165 | .enum_literal => |enum_literal| { |
| | 3166 | try dwarf.abbrevCode(di_nw, .comptime_value); |
| | 3167 | try dwarf.refType(pt, di_nw, .enum_literal); |
| | 3168 | try di_w.writeUleb128(DW.FORM.strp); |
| | 3169 | try dwarf.strp(&dwarf.debug_str, di_nw, enum_literal.toSlice(ip)); |
| | 3170 | }, |
| | 3171 | .enum_tag => |enum_tag| { |
| | 3172 | var big_int_space: Value.BigIntSpace = undefined; |
| | 3173 | const int = ip.indexToKey(enum_tag.int).int; |
| | 3174 | try dwarf.abbrevCode(di_nw, .comptime_value); |
| | 3175 | try dwarf.refType(pt, di_nw, .fromInterned(enum_tag.ty)); |
| | 3176 | try dwarf.bigIntConstValue( |
| | 3177 | di_w, |
| | 3178 | .fromInterned(int.ty), |
| | 3179 | Value.fromInterned(val).toBigInt(&big_int_space, zcu), |
| | 3180 | ); |
| | 3181 | }, |
| | 3182 | .float => |float| { |
| | 3183 | try dwarf.abbrevCode(di_nw, .comptime_value); |
| | 3184 | try dwarf.refType(pt, di_nw, .fromInterned(float.ty)); |
| | 3185 | switch (float.storage) { |
| | 3186 | .f16 => |f16_val| { |
| | 3187 | try di_w.writeUleb128(DW.FORM.data2); |
| | 3188 | try di_w.writeInt(u16, @bitCast(f16_val), dwarf.endian); |
| | 3189 | }, |
| | 3190 | .f32 => |f32_val| { |
| | 3191 | try di_w.writeUleb128(DW.FORM.data4); |
| | 3192 | try di_w.writeInt(u32, @bitCast(f32_val), dwarf.endian); |
| | 3193 | }, |
| | 3194 | .f64 => |f64_val| { |
| | 3195 | try di_w.writeUleb128(DW.FORM.data8); |
| | 3196 | try di_w.writeInt(u64, @bitCast(f64_val), dwarf.endian); |
| | 3197 | }, |
| | 3198 | .f80 => |f80_val| { |
| | 3199 | try di_w.writeUleb128(DW.FORM.block); |
| | 3200 | try di_w.writeUleb128(@divExact(80, 8)); |
| | 3201 | try di_w.writeInt(u80, @bitCast(f80_val), dwarf.endian); |
| | 3202 | }, |
| | 3203 | .f128 => |f128_val| { |
| | 3204 | try di_w.writeUleb128(DW.FORM.data16); |
| | 3205 | try di_w.writeInt(u128, @bitCast(f128_val), dwarf.endian); |
| | 3206 | }, |
| | 3207 | } |
| | 3208 | }, |
| | 3209 | .ptr => |ptr| { |
| | 3210 | const Access = union(enum) { |
| | 3211 | index: u64, |
| | 3212 | field: InternPool.NullTerminatedString, |
| | 3213 | synthetic_field: []const u8, |
| | 3214 | tuple_index: u32, |
| | 3215 | }; |
| | 3216 | var zero_bit_accesses: std.ArrayList(Access) = .empty; |
| | 3217 | defer zero_bit_accesses.deinit(zcu.gpa); |
| | 3218 | location: { |
| | 3219 | var base_addr = ptr.base_addr; |
| | 3220 | var byte_offset = ptr.byte_offset; |
| | 3221 | const base_ni = while (true) { |
| | 3222 | const base_ptr, const access: Access = base_ptr_access: switch (base_addr) { |
| | 3223 | .nav => |ni| break (try dwarf.getGlobal(ni)).get(dwarf).debug_info_ni, |
| | 3224 | .comptime_alloc, .comptime_field => unreachable, |
| | 3225 | .uav => |uav| { |
| | 3226 | const uav_ty: Type = .fromInterned(ip.typeOf(uav.val)); |
| | 3227 | if (uav_ty.classify(zcu) == .one_possible_value) { |
| | 3228 | try dwarf.abbrevCode(di_nw, if (zero_bit_accesses.items.len > 0) |
| | 3229 | .aggregate_comptime_value |
| | 3230 | else |
| | 3231 | .comptime_value); |
| | 3232 | try dwarf.refType(pt, di_nw, .fromInterned(ptr.ty)); |
| | 3233 | try di_w.writeUleb128(DW.FORM.udata); |
| | 3234 | try di_w.writeUleb128(ip.indexToKey(uav.orig_ty) |
| | 3235 | .ptr_type.flags.alignment.toByteUnits() orelse |
| | 3236 | uav_ty.abiAlignment(zcu).toByteUnits().?); |
| | 3237 | break :location; |
| | 3238 | } else break Const.get(try dwarf.getConst(pt, .fromInterned( |
| | 3239 | uav.val, |
| | 3240 | )), dwarf).debug_info_ni; |
| | 3241 | }, |
| | 3242 | .int => { |
| | 3243 | try dwarf.abbrevCode(di_nw, if (zero_bit_accesses.items.len > 0) |
| | 3244 | .aggregate_comptime_value |
| | 3245 | else |
| | 3246 | .comptime_value); |
| | 3247 | try dwarf.refType(pt, di_nw, .fromInterned(ptr.ty)); |
| | 3248 | try di_w.writeUleb128(DW.FORM.udata); |
| | 3249 | try di_w.writeUleb128(byte_offset); |
| | 3250 | break :location; |
| | 3251 | }, |
| | 3252 | .eu_payload => |eu_ptr| { |
| | 3253 | const base_ptr = ip.indexToKey(eu_ptr).ptr; |
| | 3254 | byte_offset += codegen.errUnionPayloadOffset(.fromInterned(ip.indexToKey( |
| | 3255 | ip.indexToKey(base_ptr.ty).ptr_type.child, |
| | 3256 | ).error_union_type.payload_type), zcu); |
| | 3257 | break :base_ptr_access .{ base_ptr, .{ .synthetic_field = "value" } }; |
| | 3258 | }, |
| | 3259 | .opt_payload => |opt_ptr| .{ ip.indexToKey(opt_ptr).ptr, .{ |
| | 3260 | .synthetic_field = "?", |
| | 3261 | } }, |
| | 3262 | .field => |field| { |
| | 3263 | const base_ptr = ip.indexToKey(field.base).ptr; |
| | 3264 | const agg_ty: Type = |
| | 3265 | .fromInterned(ip.indexToKey(base_ptr.ty).ptr_type.child); |
| | 3266 | break :base_ptr_access .{ |
| | 3267 | base_ptr, |
| | 3268 | if (agg_ty.isSlice(zcu)) .{ .synthetic_field = switch (field.index) { |
| | 3269 | Value.slice_ptr_index => "ptr", |
| | 3270 | Value.slice_len_index => "len", |
| | 3271 | else => unreachable, |
| | 3272 | } } else if (agg_ty.structFieldName( |
| | 3273 | @intCast(field.index), |
| | 3274 | zcu, |
| | 3275 | ).unwrap()) |field_name| |
| | 3276 | .{ .field = field_name } |
| | 3277 | else |
| | 3278 | .{ .tuple_index = @intCast(field.index) }, |
| | 3279 | }; |
| | 3280 | }, |
| | 3281 | .arr_elem => |arr_elem| .{ |
| | 3282 | ip.indexToKey(arr_elem.base).ptr, |
| | 3283 | .{ .index = arr_elem.index }, |
| | 3284 | }, |
| | 3285 | }; |
| | 3286 | base_addr = base_ptr.base_addr; |
| | 3287 | byte_offset += base_ptr.byte_offset; |
| | 3288 | if (Type.fromInterned( |
| | 3289 | ip.indexToKey(base_ptr.ty).ptr_type.child, |
| | 3290 | ).hasRuntimeBits(zcu)) |
| | 3291 | assert(access != .index) |
| | 3292 | else |
| | 3293 | try zero_bit_accesses.append(zcu.gpa, access); |
| | 3294 | }; |
| | 3295 | try dwarf.abbrevCode(di_nw, if (zero_bit_accesses.items.len > 0) |
| | 3296 | .aggregate_location_comptime_value |
| | 3297 | else |
| | 3298 | .location_comptime_value); |
| | 3299 | try dwarf.refType(pt, di_nw, .fromInterned(ptr.ty)); |
| | 3300 | try dwarf.exprLoc(di_nw, .{ .implicit_pointer = .{ |
| | 3301 | .node = base_ni.unwrap().?, |
| | 3302 | .offset = byte_offset, |
| | 3303 | } }); |
| | 3304 | } |
| | 3305 | if (zero_bit_accesses.items.len > 0) { |
| | 3306 | for (zero_bit_accesses.items) |access| switch (access) { |
| | 3307 | .index => |index| { |
| | 3308 | try dwarf.abbrevCode(di_nw, .array_index); |
| | 3309 | try di_w.writeUleb128(index); |
| | 3310 | }, |
| | 3311 | .field => |field| { |
| | 3312 | try dwarf.abbrevCode(di_nw, .access); |
| | 3313 | try dwarf.strp(&dwarf.debug_str, di_nw, field.toSlice(ip)); |
| | 3314 | }, |
| | 3315 | .synthetic_field => |field| { |
| | 3316 | try dwarf.abbrevCode(di_nw, .access); |
| | 3317 | try dwarf.strp(&dwarf.debug_str, di_nw, field); |
| | 3318 | }, |
| | 3319 | .tuple_index => |index| { |
| | 3320 | try dwarf.abbrevCode(di_nw, .access); |
| | 3321 | var field_name_buf: [std.fmt.count("{d}", .{std.math.maxInt(u32)})]u8 = |
| | 3322 | undefined; |
| | 3323 | const field_name = std.mem.print(&field_name_buf, "{d}", .{index}) catch |
| | 3324 | unreachable; |
| | 3325 | try dwarf.strp(&dwarf.debug_str, di_nw, field_name); |
| | 3326 | }, |
| | 3327 | }; |
| | 3328 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| | 3329 | } |
| | 3330 | }, |
| | 3331 | .slice => |slice| { |
| | 3332 | try dwarf.abbrevCode(di_nw, .aggregate_undefined_comptime_value); |
| | 3333 | try dwarf.refType(pt, di_nw, .fromInterned(slice.ty)); |
| | 3334 | { |
| | 3335 | try dwarf.abbrevCode(di_nw, .comptime_value_field_comptime); |
| | 3336 | try dwarf.strp(&dwarf.debug_str, di_nw, "ptr"); |
| | 3337 | try dwarf.refConst(pt, di_nw, .fromInterned(slice.ptr)); |
| | 3338 | } |
| | 3339 | { |
| | 3340 | try dwarf.abbrevCode(di_nw, .comptime_value_field_runtime); |
| | 3341 | try dwarf.strp(&dwarf.debug_str, di_nw, "len"); |
| | 3342 | try dwarf.blockConst(pt, di_nw, .fromInterned(slice.len)); |
| | 3343 | } |
| | 3344 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| | 3345 | }, |
| | 3346 | .opt => |opt| { |
| | 3347 | const opt_child_ty: Type = .fromInterned(ip.indexToKey(opt.ty).opt_type); |
| | 3348 | try dwarf.abbrevCode(di_nw, .aggregate_undefined_comptime_value); |
| | 3349 | try dwarf.refType(pt, di_nw, .fromInterned(opt.ty)); |
| | 3350 | { |
| | 3351 | try dwarf.abbrevCode(di_nw, .comptime_value_field_runtime); |
| | 3352 | try dwarf.strp(&dwarf.debug_str, di_nw, "has_value"); |
| | 3353 | switch (optRepr(opt_child_ty, zcu)) { |
| | 3354 | .opv_null => try di_w.writeUleb128(0), |
| | 3355 | .unpacked => try dwarf.blockConst(pt, di_nw, .makeBool(opt.val != .none)), |
| | 3356 | .error_set, .pointer => try dwarf.blockConst(pt, di_nw, .fromInterned(val)), |
| | 3357 | } |
| | 3358 | } |
| | 3359 | if (opt.val != .none) child_field: { |
| | 3360 | const opt_child_class = opt_child_ty.classify(zcu); |
| | 3361 | try dwarf.abbrevCode(di_nw, if (opt_child_class.comptimeOnly()) |
| | 3362 | .comptime_value_field_comptime |
| | 3363 | else if (opt_child_class.hasRuntimeBits()) |
| | 3364 | .comptime_value_field_runtime |
| | 3365 | else |
| | 3366 | break :child_field); |
| | 3367 | try dwarf.strp(&dwarf.debug_str, di_nw, "?"); |
| | 3368 | if (opt_child_class.comptimeOnly()) |
| | 3369 | try dwarf.refConst(pt, di_nw, .fromInterned(opt.val)) |
| | 3370 | else if (opt_child_class.hasRuntimeBits()) |
| | 3371 | try dwarf.blockConst(pt, di_nw, .fromInterned(opt.val)) |
| | 3372 | else |
| | 3373 | unreachable; |
| | 3374 | } |
| | 3375 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| | 3376 | }, |
| | 3377 | .aggregate => |aggregate| { |
| | 3378 | try dwarf.abbrevCode(di_nw, .aggregate_undefined_comptime_value); |
| | 3379 | try dwarf.refType(pt, di_nw, .fromInterned(aggregate.ty)); |
| | 3380 | switch (ip.indexToKey(aggregate.ty)) { |
| | 3381 | .struct_type => { |
| | 3382 | const loaded_struct = ip.loadStructType(aggregate.ty); |
| | 3383 | assert(loaded_struct.layout == .auto); |
| | 3384 | for (0..loaded_struct.field_types.len) |field_index| { |
| | 3385 | if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue; |
| | 3386 | const field_ty: Type = |
| | 3387 | .fromInterned(loaded_struct.field_types.get(ip)[field_index]); |
| | 3388 | const field_class = field_ty.classify(zcu); |
| | 3389 | try dwarf.abbrevCode(di_nw, if (field_class.comptimeOnly()) |
| | 3390 | .comptime_value_field_comptime |
| | 3391 | else if (field_class.hasRuntimeBits()) |
| | 3392 | .comptime_value_field_runtime |
| | 3393 | else |
| | 3394 | continue); |
| | 3395 | try dwarf.strp( |
| | 3396 | &dwarf.debug_str, |
| | 3397 | di_nw, |
| | 3398 | loaded_struct.field_names.get(ip)[field_index].toSlice(ip), |
| | 3399 | ); |
| | 3400 | const field_value: Value = .fromInterned(switch (aggregate.storage) { |
| | 3401 | .bytes => unreachable, |
| | 3402 | .elems => |elems| elems[field_index], |
| | 3403 | .repeated_elem => |repeated_elem| repeated_elem, |
| | 3404 | }); |
| | 3405 | if (field_class.comptimeOnly()) |
| | 3406 | try dwarf.refConst(pt, di_nw, field_value) |
| | 3407 | else if (field_class.hasRuntimeBits()) |
| | 3408 | try dwarf.blockConst(pt, di_nw, field_value) |
| | 3409 | else |
| | 3410 | unreachable; |
| | 3411 | } |
| | 3412 | }, |
| | 3413 | .tuple_type => |tuple_type| for (0..tuple_type.types.len) |field_index| { |
| | 3414 | if (tuple_type.values.get(ip)[field_index] != .none) continue; |
| | 3415 | const field_ty: Type = .fromInterned(tuple_type.types.get(ip)[field_index]); |
| | 3416 | const field_class = field_ty.classify(zcu); |
| | 3417 | try dwarf.abbrevCode(di_nw, if (field_class.comptimeOnly()) |
| | 3418 | .comptime_value_field_comptime |
| | 3419 | else if (field_class.hasRuntimeBits()) |
| | 3420 | .comptime_value_field_runtime |
| | 3421 | else |
| | 3422 | continue); |
| | 3423 | { |
| | 3424 | var field_name_buf: [std.fmt.count("{d}", .{std.math.maxInt(u32)})]u8 = |
| | 3425 | undefined; |
| | 3426 | const field_name = std.mem.print(&field_name_buf, "{d}", .{field_index}) catch |
| | 3427 | unreachable; |
| | 3428 | try dwarf.strp(&dwarf.debug_str, di_nw, field_name); |
| | 3429 | } |
| | 3430 | const field_value: Value = .fromInterned(switch (aggregate.storage) { |
| | 3431 | .bytes => unreachable, |
| | 3432 | .elems => |elems| elems[field_index], |
| | 3433 | .repeated_elem => |repeated_elem| repeated_elem, |
| | 3434 | }); |
| | 3435 | if (field_class.comptimeOnly()) |
| | 3436 | try dwarf.refConst(pt, di_nw, field_value) |
| | 3437 | else if (field_class.hasRuntimeBits()) |
| | 3438 | try dwarf.blockConst(pt, di_nw, field_value) |
| | 3439 | else |
| | 3440 | unreachable; |
| | 3441 | }, |
| | 3442 | inline .array_type, .vector_type => |sequence_type| { |
| | 3443 | const child_ty: Type = .fromInterned(sequence_type.child); |
| | 3444 | const child_class = child_ty.classify(zcu); |
| | 3445 | for (switch (aggregate.storage) { |
| | 3446 | .bytes => unreachable, |
| | 3447 | .elems => |elems| elems, |
| | 3448 | .repeated_elem => |*repeated_elem| repeated_elem[0..1], |
| | 3449 | }) |elem| { |
| | 3450 | try dwarf.abbrevCode(di_nw, if (child_class.comptimeOnly()) |
| | 3451 | .comptime_value_elem_comptime |
| | 3452 | else if (child_class.hasRuntimeBits()) |
| | 3453 | .comptime_value_elem_runtime |
| | 3454 | else |
| | 3455 | break); |
| | 3456 | if (child_class.comptimeOnly()) |
| | 3457 | try dwarf.refConst(pt, di_nw, .fromInterned(elem)) |
| | 3458 | else if (child_class.hasRuntimeBits()) |
| | 3459 | try dwarf.blockConst(pt, di_nw, .fromInterned(elem)) |
| | 3460 | else |
| | 3461 | unreachable; |
| | 3462 | } |
| | 3463 | }, |
| | 3464 | else => unreachable, |
| | 3465 | } |
| | 3466 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| | 3467 | }, |
| | 3468 | .un => |un| { |
| | 3469 | try dwarf.abbrevCode(di_nw, .aggregate_undefined_comptime_value); |
| | 3470 | try dwarf.refType(pt, di_nw, .fromInterned(un.ty)); |
| | 3471 | { |
| | 3472 | const loaded_union = ip.loadUnionType(un.ty); |
| | 3473 | assert(loaded_union.layout == .auto); |
| | 3474 | const field_index = zcu.unionTagFieldIndex(loaded_union, Value.fromInterned(un.tag)).?; |
| | 3475 | const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]); |
| | 3476 | const field_class = field_ty.classify(zcu); |
| | 3477 | const field_name = |
| | 3478 | ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index]; |
| | 3479 | try dwarf.abbrevCode(di_nw, if (field_class.comptimeOnly()) |
| | 3480 | .comptime_value_field_comptime |
| | 3481 | else if (field_class.hasRuntimeBits()) |
| | 3482 | .comptime_value_field_runtime |
| | 3483 | else |
| | 3484 | .access); |
| | 3485 | try dwarf.strp(&dwarf.debug_str, di_nw, field_name.toSlice(ip)); |
| | 3486 | if (field_class.comptimeOnly()) |
| | 3487 | try dwarf.refConst(pt, di_nw, .fromInterned(un.val)) |
| | 3488 | else if (field_class.hasRuntimeBits()) |
| | 3489 | try dwarf.blockConst(pt, di_nw, .fromInterned(un.val)); |
| | 3490 | } |
| | 3491 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| | 3492 | }, |
| 3072 | | 3493 | |
| 3073 | .memoized_call => unreachable, // not a value | 3494 | .memoized_call => unreachable, // not a value |
| 3074 | } | 3495 | } |
| 3075 | try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); | 3496 | try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); |
| 3076 | } | 3497 | } |
| 3077 | | 3498 | |
| 3078 | fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum { unpacked, opv_null, error_set, pointer } { | 3499 | fn optRepr(opt_child_ty: Type, zcu: *const Zcu) enum { unpacked, opv_null, error_set, pointer } { |
| 3079 | if (opt_child_type.isNoReturn(zcu)) return .opv_null; | 3500 | if (opt_child_ty.isNoReturn(zcu)) return .opv_null; |
| 3080 | return switch (opt_child_type.toIntern()) { | 3501 | return switch (opt_child_ty.toIntern()) { |
| 3081 | .anyerror_type => .error_set, | 3502 | .anyerror_type => .error_set, |
| 3082 | else => switch (zcu.intern_pool.indexToKey(opt_child_type.toIntern())) { | 3503 | else => switch (zcu.intern_pool.indexToKey(opt_child_ty.toIntern())) { |
| 3083 | else => .unpacked, | 3504 | else => .unpacked, |
| 3084 | .error_set_type, .inferred_error_set_type => .error_set, | 3505 | .error_set_type, .inferred_error_set_type => .error_set, |
| 3085 | .ptr_type => |ptr_type| if (ptr_type.flags.is_allowzero) .unpacked else .pointer, | 3506 | .ptr_type => |ptr_type| if (ptr_type.flags.is_allowzero) .unpacked else .pointer, |
| ... | @@ -4096,10 +4517,10 @@ pub const AbbrevCode = enum { | ... | @@ -4096,10 +4517,10 @@ pub const AbbrevCode = enum { |
| 4096 | aggregate_undefined_comptime_value, | 4517 | aggregate_undefined_comptime_value, |
| 4097 | aggregate_comptime_value, | 4518 | aggregate_comptime_value, |
| 4098 | aggregate_location_comptime_value, | 4519 | aggregate_location_comptime_value, |
| 4099 | comptime_value_field_runtime_bits, | 4520 | comptime_value_field_runtime, |
| 4100 | comptime_value_field_comptime_state, | 4521 | comptime_value_field_comptime, |
| 4101 | comptime_value_elem_runtime_bits, | 4522 | comptime_value_elem_runtime, |
| 4102 | comptime_value_elem_comptime_state, | 4523 | comptime_value_elem_comptime, |
| 4103 | | 4524 | |
| 4104 | const decl_size = uleb128Size(@backingInt(AbbrevCode.decl_instance_extern_func)); | 4525 | const decl_size = uleb128Size(@backingInt(AbbrevCode.decl_instance_extern_func)); |
| 4105 | comptime { | 4526 | comptime { |
| ... | @@ -5384,27 +5805,27 @@ pub const AbbrevCode = enum { | ... | @@ -5384,27 +5805,27 @@ pub const AbbrevCode = enum { |
| 5384 | .{ .location, .exprloc }, | 5805 | .{ .location, .exprloc }, |
| 5385 | }, | 5806 | }, |
| 5386 | }, | 5807 | }, |
| 5387 | .comptime_value_field_runtime_bits = .{ | 5808 | .comptime_value_field_runtime = .{ |
| 5388 | .tag = .member, | 5809 | .tag = .member, |
| 5389 | .attrs = &.{ | 5810 | .attrs = &.{ |
| 5390 | .{ .name, .strp }, | 5811 | .{ .name, .strp }, |
| 5391 | .{ .const_value, .block }, | 5812 | .{ .const_value, .block }, |
| 5392 | }, | 5813 | }, |
| 5393 | }, | 5814 | }, |
| 5394 | .comptime_value_field_comptime_state = .{ | 5815 | .comptime_value_field_comptime = .{ |
| 5395 | .tag = .member, | 5816 | .tag = .member, |
| 5396 | .attrs = &.{ | 5817 | .attrs = &.{ |
| 5397 | .{ .name, .strp }, | 5818 | .{ .name, .strp }, |
| 5398 | .{ .ZIG_comptime_value, .ref_addr }, | 5819 | .{ .ZIG_comptime_value, .ref_addr }, |
| 5399 | }, | 5820 | }, |
| 5400 | }, | 5821 | }, |
| 5401 | .comptime_value_elem_runtime_bits = .{ | 5822 | .comptime_value_elem_runtime = .{ |
| 5402 | .tag = .member, | 5823 | .tag = .member, |
| 5403 | .attrs = &.{ | 5824 | .attrs = &.{ |
| 5404 | .{ .const_value, .block }, | 5825 | .{ .const_value, .block }, |
| 5405 | }, | 5826 | }, |
| 5406 | }, | 5827 | }, |
| 5407 | .comptime_value_elem_comptime_state = .{ | 5828 | .comptime_value_elem_comptime = .{ |
| 5408 | .tag = .member, | 5829 | .tag = .member, |
| 5409 | .attrs = &.{ | 5830 | .attrs = &.{ |
| 5410 | .{ .ZIG_comptime_value, .ref_addr }, | 5831 | .{ .ZIG_comptime_value, .ref_addr }, |
Jacob Young <jacobly@ziglang.org> 2026-09-05 23:57:23-04:00