authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-09-26 15:22:57-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-09-26 16:06:05-07:00
log1b491e640d7c6a3cd71c4b146ca104ff0b136edd
tree3f3dc9f356304aeb82274488f3db24fc9786fd14
parentc9c080a187ae1839a5531d3d95c1080f38721229

fixes and make sema report errors when std.builtin wrong

instead of panicking

4 files changed, 95 insertions(+), 65 deletions(-)

lib/std/builtin.zig+1-1
......@@ -777,7 +777,7 @@ else
777777/// root source file.
778778pub const Panic: type = if (@hasDecl(root, "Panic"))
779779 root.Panic
780else if (std.builtin.zig_backend == .stage2_riscv64)
780else if (builtin.zig_backend == .stage2_riscv64)
781781 std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519
782782else
783783 std.debug.FormattedPanic;
src/Sema.zig+81-40
......@@ -2141,7 +2141,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
21412141 const addrs_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(addr_arr_ty));
21422142
21432143 // var st: StackTrace = undefined;
2144 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
2144 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
21452145 try stack_trace_ty.resolveFields(pt);
21462146 const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty));
21472147
......@@ -6945,7 +6945,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
69456945
69466946 if (!block.ownerModule().error_tracing) return .none;
69476947
6948 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
6948 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
69496949 try stack_trace_ty.resolveFields(pt);
69506950 const field_name = try zcu.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
69516951 const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) {
......@@ -6987,7 +6987,7 @@ fn popErrorReturnTrace(
69876987 // AstGen determined this result does not go to an error-handling expr (try/catch/return etc.), or
69886988 // the result is comptime-known to be a non-error. Either way, pop unconditionally.
69896989
6990 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
6990 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
69916991 try stack_trace_ty.resolveFields(pt);
69926992 const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
69936993 const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
......@@ -7013,7 +7013,7 @@ fn popErrorReturnTrace(
70137013 defer then_block.instructions.deinit(gpa);
70147014
70157015 // If non-error, then pop the error return trace by restoring the index.
7016 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
7016 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
70177017 try stack_trace_ty.resolveFields(pt);
70187018 const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
70197019 const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
......@@ -7156,7 +7156,7 @@ fn zirCall(
71567156 // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only
71577157 // need to clean-up our own trace if we were passed to a non-error-handling expression.
71587158 if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) {
7159 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
7159 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
71607160 try stack_trace_ty.resolveFields(pt);
71617161 const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "index", .no_embedded_nulls);
71627162 const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src);
......@@ -10211,7 +10211,7 @@ fn finishFunc(
1021110211 if (!final_is_generic and sema.wantErrorReturnTracing(return_type)) {
1021210212 // Make sure that StackTrace's fields are resolved so that the backend can
1021310213 // lower this fn type.
10214 const unresolved_stack_trace_ty = try pt.getBuiltinType("StackTrace");
10214 const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
1021510215 try unresolved_stack_trace_ty.resolveFields(pt);
1021610216 }
1021710217
......@@ -14209,7 +14209,7 @@ fn maybeErrorUnwrap(
1420914209 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
1421014210 const msg_inst = try sema.resolveInst(inst_data.operand);
1421114211
14212 const panic_fn = try pt.getBuiltinInnerType("Panic", "call");
14212 const panic_fn = try getBuiltinInnerAsInst(sema, block, operand_src, "Panic", "call");
1421314213 const err_return_trace = try sema.getErrorReturnTrace(block);
1421414214 const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value };
1421514215 try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check");
......@@ -18246,7 +18246,7 @@ fn zirBuiltinSrc(
1824618246 } });
1824718247 };
1824818248
18249 const src_loc_ty = try pt.getBuiltinType("SourceLocation");
18249 const src_loc_ty = try sema.getBuiltinType("SourceLocation");
1825018250 const fields = .{
1825118251 // module: [:0]const u8,
1825218252 module_name_val,
......@@ -18273,7 +18273,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1827318273 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
1827418274 const src = block.nodeOffset(inst_data.src_node);
1827518275 const ty = try sema.resolveType(block, src, inst_data.operand);
18276 const type_info_ty = try pt.getBuiltinType("Type");
18276 const type_info_ty = try sema.getBuiltinType("Type");
1827718277 const type_info_tag_ty = type_info_ty.unionTagType(zcu).?;
1827818278
1827918279 if (ty.typeDeclInst(zcu)) |type_decl_inst| {
......@@ -18364,7 +18364,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1836418364 func_ty_info.return_type,
1836518365 } });
1836618366
18367 const callconv_ty = try pt.getBuiltinType("CallingConvention");
18367 const callconv_ty = try sema.getBuiltinType("CallingConvention");
1836818368
1836918369 const field_values = .{
1837018370 // calling_convention: CallingConvention,
......@@ -18389,7 +18389,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1838918389 },
1839018390 .int => {
1839118391 const int_info_ty = try getInnerType(sema, block, src, type_info_ty, "Int");
18392 const signedness_ty = try pt.getBuiltinType("Signedness");
18392 const signedness_ty = try sema.getBuiltinType("Signedness");
1839318393 const info = ty.intInfo(zcu);
1839418394 const field_values = .{
1839518395 // signedness: Signedness,
......@@ -18429,7 +18429,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1842918429 else
1843018430 try Type.fromInterned(info.child).lazyAbiAlignment(pt);
1843118431
18432 const addrspace_ty = try pt.getBuiltinType("AddressSpace");
18432 const addrspace_ty = try sema.getBuiltinType("AddressSpace");
1843318433 const pointer_ty = try getInnerType(sema, block, src, type_info_ty, "Pointer");
1843418434 const ptr_size_ty = try getInnerType(sema, block, src, pointer_ty, "Size");
1843518435
......@@ -20047,11 +20047,11 @@ fn retWithErrTracing(
2004720047 else => true,
2004820048 };
2004920049 const gpa = sema.gpa;
20050 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
20050 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
2005120051 try stack_trace_ty.resolveFields(pt);
2005220052 const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
2005320053 const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
20054 const return_err_fn = try pt.getBuiltin("returnError");
20054 const return_err_fn = try sema.getBuiltin("returnError");
2005520055 const args: [1]Air.Inst.Ref = .{err_return_trace};
2005620056
2005720057 if (!need_check) {
......@@ -21455,7 +21455,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
2145521455 const pt = sema.pt;
2145621456 const zcu = pt.zcu;
2145721457 const ip = &zcu.intern_pool;
21458 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
21458 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
2145921459 try stack_trace_ty.resolveFields(pt);
2146021460 const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
2146121461 const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern());
......@@ -21744,7 +21744,7 @@ fn zirReify(
2174421744 },
2174521745 },
2174621746 };
21747 const type_info_ty = try pt.getBuiltinType("Type");
21747 const type_info_ty = try sema.getBuiltinType("Type");
2174821748 const uncasted_operand = try sema.resolveInst(extra.operand);
2174921749 const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src);
2175021750 const val = try sema.resolveConstDefinedValue(block, operand_src, type_info, .{
......@@ -22946,7 +22946,7 @@ fn reifyStruct(
2294622946
2294722947fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref {
2294822948 const pt = sema.pt;
22949 const va_list_ty = try pt.getBuiltinType("VaList");
22949 const va_list_ty = try sema.getBuiltinType("VaList");
2295022950 const va_list_ptr = try pt.singleMutPtrType(va_list_ty);
2295122951
2295222952 const inst = try sema.resolveInst(zir_ref);
......@@ -22985,7 +22985,7 @@ fn zirCVaCopy(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData)
2298522985 const va_list_src = block.builtinCallArgSrc(extra.node, 0);
2298622986
2298722987 const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.operand);
22988 const va_list_ty = try sema.pt.getBuiltinType("VaList");
22988 const va_list_ty = try sema.getBuiltinType("VaList");
2298922989
2299022990 try sema.requireRuntimeBlock(block, src, null);
2299122991 return block.addTyOp(.c_va_copy, va_list_ty, va_list_ref);
......@@ -23005,7 +23005,7 @@ fn zirCVaEnd(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
2300523005fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
2300623006 const src = block.nodeOffset(@bitCast(extended.operand));
2300723007
23008 const va_list_ty = try sema.pt.getBuiltinType("VaList");
23008 const va_list_ty = try sema.getBuiltinType("VaList");
2300923009 try sema.requireRuntimeBlock(block, src, null);
2301023010 return block.addInst(.{
2301123011 .tag = .c_va_start,
......@@ -24617,7 +24617,7 @@ fn resolveExportOptions(
2461724617 const zcu = pt.zcu;
2461824618 const gpa = sema.gpa;
2461924619 const ip = &zcu.intern_pool;
24620 const export_options_ty = try pt.getBuiltinType("ExportOptions");
24620 const export_options_ty = try sema.getBuiltinType("ExportOptions");
2462124621 const air_ref = try sema.resolveInst(zir_ref);
2462224622 const options = try sema.coerce(block, export_options_ty, air_ref, src);
2462324623
......@@ -24681,7 +24681,7 @@ fn resolveBuiltinEnum(
2468124681 reason: NeededComptimeReason,
2468224682) CompileError!@field(std.builtin, name) {
2468324683 const pt = sema.pt;
24684 const ty = try pt.getBuiltinType(name);
24684 const ty = try sema.getBuiltinType(name);
2468524685 const air_ref = try sema.resolveInst(zir_ref);
2468624686 const coerced = try sema.coerce(block, ty, air_ref, src);
2468724687 const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
......@@ -25450,7 +25450,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
2545025450 const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data;
2545125451 const func = try sema.resolveInst(extra.callee);
2545225452
25453 const modifier_ty = try pt.getBuiltinType("CallModifier");
25453 const modifier_ty = try sema.getBuiltinType("CallModifier");
2545425454 const air_ref = try sema.resolveInst(extra.modifier);
2545525455 const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);
2545625456 const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{
......@@ -26576,7 +26576,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2657626576 const body = sema.code.bodySlice(extra_index, body_len);
2657726577 extra_index += body.len;
2657826578
26579 const addrspace_ty = try pt.getBuiltinType("AddressSpace");
26579 const addrspace_ty = try sema.getBuiltinType("AddressSpace");
2658026580 const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty, .{
2658126581 .needed_comptime_reason = "addrspace must be comptime-known",
2658226582 });
......@@ -26587,7 +26587,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2658726587 } else if (extra.data.bits.has_addrspace_ref) blk: {
2658826588 const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
2658926589 extra_index += 1;
26590 const addrspace_ty = try pt.getBuiltinType("AddressSpace");
26590 const addrspace_ty = try sema.getBuiltinType("AddressSpace");
2659126591 const uncoerced_addrspace = sema.resolveInst(addrspace_ref) catch |err| switch (err) {
2659226592 error.GenericPoison => break :blk null,
2659326593 else => |e| return e,
......@@ -26641,7 +26641,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2664126641 const body = sema.code.bodySlice(extra_index, body_len);
2664226642 extra_index += body.len;
2664326643
26644 const cc_ty = try pt.getBuiltinType("CallingConvention");
26644 const cc_ty = try sema.getBuiltinType("CallingConvention");
2664526645 const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty, .{
2664626646 .needed_comptime_reason = "calling convention must be comptime-known",
2664726647 });
......@@ -26652,7 +26652,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2665226652 } else if (extra.data.bits.has_cc_ref) blk: {
2665326653 const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
2665426654 extra_index += 1;
26655 const cc_ty = try pt.getBuiltinType("CallingConvention");
26655 const cc_ty = try sema.getBuiltinType("CallingConvention");
2665626656 const uncoerced_cc = sema.resolveInst(cc_ref) catch |err| switch (err) {
2665726657 error.GenericPoison => break :blk null,
2665826658 else => |e| return e,
......@@ -26869,7 +26869,7 @@ fn resolvePrefetchOptions(
2686926869 const zcu = pt.zcu;
2687026870 const gpa = sema.gpa;
2687126871 const ip = &zcu.intern_pool;
26872 const options_ty = try pt.getBuiltinType("PrefetchOptions");
26872 const options_ty = try sema.getBuiltinType("PrefetchOptions");
2687326873 const options = try sema.coerce(block, options_ty, try sema.resolveInst(zir_ref), src);
2687426874
2687526875 const rw_src = block.src(.{ .init_field_rw = src.offset.node_offset_builtin_call_arg.builtin_call_node });
......@@ -26942,7 +26942,7 @@ fn resolveExternOptions(
2694226942 const gpa = sema.gpa;
2694326943 const ip = &zcu.intern_pool;
2694426944 const options_inst = try sema.resolveInst(zir_ref);
26945 const extern_options_ty = try pt.getBuiltinType("ExternOptions");
26945 const extern_options_ty = try sema.getBuiltinType("ExternOptions");
2694626946 const options = try sema.coerce(block, extern_options_ty, options_inst, src);
2694726947
2694826948 const name_src = block.src(.{ .init_field_name = src.offset.node_offset_builtin_call_arg.builtin_call_node });
......@@ -27129,7 +27129,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
2712927129
2713027130 // Values are handled here.
2713127131 .calling_convention_c => {
27132 const callconv_ty = try pt.getBuiltinType("CallingConvention");
27132 const callconv_ty = try sema.getBuiltinType("CallingConvention");
2713327133 comptime assert(@intFromEnum(std.builtin.CallingConvention.C) == 1);
2713427134 const val = try pt.intern(.{ .enum_tag = .{
2713527135 .ty = callconv_ty.toIntern(),
......@@ -27138,7 +27138,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
2713827138 return Air.internedToRef(val);
2713927139 },
2714027140 .calling_convention_inline => {
27141 const callconv_ty = try pt.getBuiltinType("CallingConvention");
27141 const callconv_ty = try sema.getBuiltinType("CallingConvention");
2714227142 comptime assert(@intFromEnum(std.builtin.CallingConvention.Inline) == 4);
2714327143 const val = try pt.intern(.{ .enum_tag = .{
2714427144 .ty = callconv_ty.toIntern(),
......@@ -27147,7 +27147,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
2714727147 return Air.internedToRef(val);
2714827148 },
2714927149 };
27150 const ty = try pt.getBuiltinType(type_name);
27150 const ty = try sema.getBuiltinType(type_name);
2715127151 return Air.internedToRef(ty.toIntern());
2715227152}
2715327153
......@@ -27186,7 +27186,7 @@ fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
2718627186 const uncoerced_hint = try sema.resolveInst(extra.operand);
2718727187 const operand_src = block.builtinCallArgSrc(extra.node, 0);
2718827188
27189 const hint_ty = try pt.getBuiltinType("BranchHint");
27189 const hint_ty = try sema.getBuiltinType("BranchHint");
2719027190 const coerced_hint = try sema.coerce(block, hint_ty, uncoerced_hint, operand_src);
2719127191 const hint_val = try sema.resolveConstDefinedValue(block, operand_src, coerced_hint, .{
2719227192 .needed_comptime_reason = "operand to '@branchHint' must be comptime-known",
......@@ -27650,7 +27650,7 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void {
2765027650 }
2765127651
2765227652 if (zcu.null_stack_trace == .none) {
27653 const stack_trace_ty = try pt.getBuiltinType("StackTrace");
27653 const stack_trace_ty = try sema.getBuiltinType("StackTrace");
2765427654 try stack_trace_ty.resolveFields(pt);
2765527655 const target = zcu.getTarget();
2765627656 const ptr_stack_trace_ty = try pt.ptrTypeSema(.{
......@@ -27678,7 +27678,7 @@ fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.Pan
2767827678
2767927679 try sema.prepareSimplePanic(block, src);
2768027680
27681 const panic_messages_ty = try pt.getBuiltinType("panic_messages");
27681 const panic_messages_ty = try sema.getBuiltinType("panic_messages");
2768227682 const msg_nav_index = (sema.namespaceLookup(
2768327683 block,
2768427684 LazySrcLoc.unneeded,
......@@ -27846,7 +27846,7 @@ fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air.
2784627846 if (!zcu.backendSupportsFeature(.panic_fn)) {
2784727847 _ = try block.addNoOp(.trap);
2784827848 } else {
27849 const panic_fn = try pt.getBuiltinInnerType("Panic", "unwrapError");
27849 const panic_fn = try getBuiltinInnerAsInst(sema, block, src, "Panic", "unwrapError");
2785027850 const err_return_trace = try sema.getErrorReturnTrace(block);
2785127851 const args: [2]Air.Inst.Ref = .{ err_return_trace, err };
2785227852 try sema.callBuiltin(block, src, panic_fn, .auto, &args, .@"safety check");
......@@ -27950,7 +27950,7 @@ fn addSafetyCheckCall(
2795027950 if (!zcu.backendSupportsFeature(.panic_fn)) {
2795127951 _ = try fail_block.addNoOp(.trap);
2795227952 } else {
27953 const panic_fn = try pt.getBuiltinInnerType("Panic", func_name);
27953 const panic_fn = try getBuiltinInnerAsInst(sema, &fail_block, src, "Panic", func_name);
2795427954 try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check");
2795527955 }
2795627956
......@@ -35604,7 +35604,7 @@ pub fn resolveFnTypes(sema: *Sema, fn_ty: Type) CompileError!void {
3560435604 Type.fromInterned(fn_ty_info.return_type).isError(zcu))
3560535605 {
3560635606 // Ensure the type exists so that backends can assume that.
35607 _ = try pt.getBuiltinType("StackTrace");
35607 _ = try sema.getBuiltinType("StackTrace");
3560835608 }
3560935609
3561035610 for (0..fn_ty_info.param_types.len) |i| {
......@@ -37650,7 +37650,7 @@ pub fn analyzeAsAddressSpace(
3765037650) !std.builtin.AddressSpace {
3765137651 const pt = sema.pt;
3765237652 const zcu = pt.zcu;
37653 const addrspace_ty = try pt.getBuiltinType("AddressSpace");
37653 const addrspace_ty = try sema.getBuiltinType("AddressSpace");
3765437654 const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
3765537655 const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{
3765637656 .needed_comptime_reason = "address space must be comptime-known",
......@@ -38908,6 +38908,19 @@ const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadR
3890838908const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr;
3890938909const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult;
3891038910
38911/// Convenience function that looks 2 levels deep into `std.builtin`.
38912fn getBuiltinInnerAsInst(
38913 sema: *Sema,
38914 block: *Block,
38915 src: LazySrcLoc,
38916 outer_name: []const u8,
38917 inner_name: []const u8,
38918) !Air.Inst.Ref {
38919 const outer_ty = try sema.getBuiltinType(outer_name);
38920 const inner_val = try getInnerValue(sema, block, src, outer_ty, inner_name);
38921 return Air.internedToRef(inner_val.toIntern());
38922}
38923
3891138924/// Convenience function that looks 2 levels deep into `std.builtin`.
3891238925fn getBuiltinInnerType(
3891338926 sema: *Sema,
......@@ -38916,7 +38929,7 @@ fn getBuiltinInnerType(
3891638929 outer_name: []const u8,
3891738930 inner_name: []const u8,
3891838931) !Type {
38919 const outer_ty = try sema.pt.getBuiltinType(outer_name);
38932 const outer_ty = try sema.getBuiltinType(outer_name);
3892038933 return getInnerType(sema, block, src, outer_ty, inner_name);
3892138934}
3892238935
......@@ -38927,6 +38940,17 @@ fn getInnerType(
3892738940 outer_ty: Type,
3892838941 inner_name: []const u8,
3892938942) !Type {
38943 const inner_val = try getInnerValue(sema, block, src, outer_ty, inner_name);
38944 return inner_val.toType();
38945}
38946
38947fn getInnerValue(
38948 sema: *Sema,
38949 block: *Block,
38950 src: LazySrcLoc,
38951 outer_ty: Type,
38952 inner_name: []const u8,
38953) !Value {
3893038954 const pt = sema.pt;
3893138955 const zcu = pt.zcu;
3893238956 const ip = &zcu.intern_pool;
......@@ -38938,5 +38962,22 @@ fn getInnerType(
3893838962 try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls),
3893938963 ) orelse return sema.fail(block, src, "std.builtin missing {s}", .{inner_name});
3894038964 try sema.ensureNavResolved(src, nav);
38941 return Type.fromInterned(ip.getNav(nav).status.resolved.val);
38965 return Value.fromInterned(ip.getNav(nav).status.resolved.val);
38966}
38967
38968fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref {
38969 const pt = sema.pt;
38970 const zcu = pt.zcu;
38971 const ip = &zcu.intern_pool;
38972 const nav = try pt.getBuiltinNav(name);
38973 try pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?);
38974 return Air.internedToRef(ip.getNav(nav).status.resolved.val);
38975}
38976
38977fn getBuiltinType(sema: *Sema, name: []const u8) SemaError!Type {
38978 const pt = sema.pt;
38979 const ty_inst = try sema.getBuiltin(name);
38980 const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt"));
38981 try ty.resolveFully(pt);
38982 return ty;
3894238983}
src/Zcu/PerThread.zig-15
......@@ -3075,14 +3075,6 @@ pub fn structPackedFieldBitOffset(
30753075 unreachable; // index out of bounds
30763076}
30773077
3078pub fn getBuiltin(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Air.Inst.Ref {
3079 const zcu = pt.zcu;
3080 const ip = &zcu.intern_pool;
3081 const nav = try pt.getBuiltinNav(name);
3082 pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?) catch @panic("std.builtin is corrupt");
3083 return Air.internedToRef(ip.getNav(nav).status.resolved.val);
3084}
3085
30863078pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!InternPool.Nav.Index {
30873079 const zcu = pt.zcu;
30883080 const gpa = zcu.gpa;
......@@ -3100,13 +3092,6 @@ pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Intern
31003092 return builtin_namespace.pub_decls.getKeyAdapted(name_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse @panic("lib/std/builtin.zig is corrupt");
31013093}
31023094
3103pub fn getBuiltinType(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Type {
3104 const ty_inst = try pt.getBuiltin(name);
3105 const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt"));
3106 ty.resolveFully(pt) catch @panic("std.builtin is corrupt");
3107 return ty;
3108}
3109
31103095pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.Error!Type {
31113096 const zcu = pt.zcu;
31123097 const ip = &zcu.intern_pool;
src/codegen/llvm.zig+13-9
......@@ -5675,20 +5675,23 @@ pub const FuncGen = struct {
56755675 }
56765676 }
56775677
5678 const PanicCauseTag = @typeInfo(std.builtin.PanicCause).@"union".tag_type.?;
5679
5680 fn buildSimplePanic(fg: *FuncGen, panic_cause: InternPool.Index) !void {
5678 fn buildSimplePanic(fg: *FuncGen, panic_id: Zcu.PanicId) !void {
56815679 const o = fg.ng.object;
56825680 const zcu = o.pt.zcu;
56835681 const ip = &zcu.intern_pool;
5684 const cause_ptr = try o.lowerValue(panic_cause);
5682 const msg_nav_index = zcu.panic_messages[@intFromEnum(panic_id)].unwrap().?;
5683 const msg_nav = ip.getNav(msg_nav_index);
5684 const msg_len = Type.fromInterned(msg_nav.typeOf(ip)).childType(zcu).arrayLen(zcu);
5685 const msg_ptr = try o.lowerValue(msg_nav.status.resolved.val);
56855686 const null_opt_addr_global = try fg.resolveNullOptUsize();
56865687 const target = zcu.getTarget();
5688 const llvm_usize = try o.lowerType(Type.usize);
56875689 // example:
56885690 // call fastcc void @test2.panic(
5689 // ptr @foo, ; panic_cause
5690 // ptr null, ; stack trace
5691 // ptr @2, ; addr (null ?usize)
5691 // ptr @builtin.panic_messages.integer_overflow__anon_987, ; msg.ptr
5692 // i64 16, ; msg.len
5693 // ptr null, ; stack trace
5694 // ptr @2, ; addr (null ?usize)
56925695 // )
56935696 const panic_func = zcu.funcInfo(zcu.panic_func_index);
56945697 const panic_nav = ip.getNav(panic_func.owner_nav);
......@@ -5702,7 +5705,8 @@ pub const FuncGen = struct {
57025705 panic_global.typeOf(&o.builder),
57035706 panic_global.toValue(&o.builder),
57045707 &.{
5705 cause_ptr.toValue(),
5708 msg_ptr.toValue(),
5709 try o.builder.intValue(llvm_usize, msg_len),
57065710 try o.builder.nullValue(.ptr),
57075711 null_opt_addr_global.toValue(),
57085712 },
......@@ -8331,7 +8335,7 @@ pub const FuncGen = struct {
83318335 _ = try fg.wip.brCond(overflow_bit, fail_block, ok_block, .none);
83328336
83338337 fg.wip.cursor = .{ .block = fail_block };
8334 try fg.buildSimplePanic(zcu.panic_cause_integer_overflow);
8338 try fg.buildSimplePanic(.integer_overflow);
83358339
83368340 fg.wip.cursor = .{ .block = ok_block };
83378341 return fg.wip.extractValue(results, &.{0}, "");