authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2022-04-23 11:13:31+03:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-05-16 17:42:51-07:00
logab4ec35b8bb3a19361afa315f77cce5f6054b109
tree9aa1100a74f3beba5b1ca35d4f9c3dc52e360a11
parente369752430a1b3a50e57e11b9f0682d026c62feb

stage2: add runtime safety for unwrapping error

4 files changed, 139 insertions(+), 22 deletions(-)

lib/compiler_rt.zig+11-13
......@@ -198,19 +198,17 @@ comptime {
198198 const __trunctfxf2 = @import("compiler_rt/trunc_f80.zig").__trunctfxf2;
199199 @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = linkage });
200200
201 if (builtin.zig_backend == .stage1) { // TODO
202 switch (arch) {
203 .i386,
204 .x86_64,
205 => {
206 const zig_probe_stack = @import("compiler_rt/stack_probe.zig").zig_probe_stack;
207 @export(zig_probe_stack, .{
208 .name = "__zig_probe_stack",
209 .linkage = linkage,
210 });
211 },
212 else => {},
213 }
201 switch (arch) {
202 .i386,
203 .x86_64,
204 => {
205 const zig_probe_stack = @import("compiler_rt/stack_probe.zig").zig_probe_stack;
206 @export(zig_probe_stack, .{
207 .name = "__zig_probe_stack",
208 .linkage = linkage,
209 });
210 },
211 else => {},
214212 }
215213
216214 const __unordsf2 = @import("compiler_rt/compareXf2.zig").__unordsf2;
lib/std/builtin.zig+4
......@@ -846,6 +846,10 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn
846846 }
847847}
848848
849pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn {
850 std.debug.panicExtra(st, "attempt to unwrap error: {s}", .{@errorName(err)});
851}
852
849853pub noinline fn returnError(maybe_st: ?*StackTrace) void {
850854 @setCold(true);
851855 const st = maybe_st orelse return;
src/AstGen.zig+27
......@@ -856,6 +856,33 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
856856 catch_token + 2
857857 else
858858 null;
859
860 var rhs = node_datas[node].rhs;
861 while (true) switch (node_tags[rhs]) {
862 .grouped_expression => rhs = node_datas[rhs].lhs,
863 .unreachable_literal => {
864 if (payload_token != null and mem.eql(u8, tree.tokenSlice(payload_token.?), "_")) {
865 return astgen.failTok(payload_token.?, "discard of error capture; omit it instead", .{});
866 } else if (payload_token != null) {
867 return astgen.failTok(payload_token.?, "unused capture", .{});
868 }
869 const lhs = node_datas[node].lhs;
870
871 const operand = try reachableExpr(gz, scope, switch (rl) {
872 .ref => .ref,
873 else => .none,
874 }, lhs, lhs);
875 const result = try gz.addUnNode(switch (rl) {
876 .ref => .err_union_payload_safe_ptr,
877 else => .err_union_payload_safe,
878 }, operand, node);
879 switch (rl) {
880 .none, .coerced_ty, .discard, .ref => return result,
881 else => return rvalue(gz, rl, result, lhs),
882 }
883 },
884 else => break,
885 };
859886 switch (rl) {
860887 .ref => return orelseCatchExpr(
861888 gz,
src/Sema.zig+97-9
......@@ -6248,8 +6248,7 @@ fn zirErrUnionPayload(
62486248 }
62496249 try sema.requireRuntimeBlock(block, src);
62506250 if (safety_check and block.wantSafety()) {
6251 const is_non_err = try block.addUnOp(.is_err, operand);
6252 try sema.addSafetyCheck(block, is_non_err, .unwrap_errunion);
6251 try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err);
62536252 }
62546253 const result_ty = operand_ty.errorUnionPayload();
62556254 return block.addTyOp(.unwrap_errunion_payload, result_ty, operand);
......@@ -6330,8 +6329,7 @@ fn analyzeErrUnionPayloadPtr(
63306329
63316330 try sema.requireRuntimeBlock(block, src);
63326331 if (safety_check and block.wantSafety()) {
6333 const is_non_err = try block.addUnOp(.is_err, operand);
6334 try sema.addSafetyCheck(block, is_non_err, .unwrap_errunion);
6332 try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr);
63356333 }
63366334 const air_tag: Air.Inst.Tag = if (initializing)
63376335 .errunion_payload_ptr_set
......@@ -13400,6 +13398,10 @@ fn zirErrorReturnTrace(
1340013398 extended: Zir.Inst.Extended.InstData,
1340113399) CompileError!Air.Inst.Ref {
1340213400 const src: LazySrcLoc = .{ .node_offset = @bitCast(i32, extended.operand) };
13401 return sema.getErrorReturnTrace(block, src);
13402}
13403
13404fn getErrorReturnTrace(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError!Air.Inst.Ref {
1340313405 const unresolved_stack_trace_ty = try sema.getBuiltinType(block, src, "StackTrace");
1340413406 const stack_trace_ty = try sema.resolveTypeFields(block, src, unresolved_stack_trace_ty);
1340513407 const opt_ptr_stack_trace_ty = try Type.Tag.optional_single_mut_pointer.create(sema.arena, stack_trace_ty);
......@@ -16852,7 +16854,6 @@ fn explainWhyTypeIsComptime(
1685216854pub const PanicId = enum {
1685316855 unreach,
1685416856 unwrap_null,
16855 unwrap_errunion,
1685616857 cast_to_null,
1685716858 incorrect_alignment,
1685816859 invalid_error_code,
......@@ -16962,12 +16963,100 @@ fn panicWithMsg(
1696216963 try Type.optional(arena, ptr_stack_trace_ty),
1696316964 Value.@"null",
1696416965 );
16965 const args = try arena.create([2]Air.Inst.Ref);
16966 args.* = .{ msg_inst, null_stack_trace };
16967 _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, args);
16966 const args: [2]Air.Inst.Ref = .{ msg_inst, null_stack_trace };
16967 _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, &args);
1696816968 return always_noreturn;
1696916969}
1697016970
16971fn panicUnwrapError(
16972 sema: *Sema,
16973 parent_block: *Block,
16974 src: LazySrcLoc,
16975 operand: Air.Inst.Ref,
16976 unwrap_err_tag: Air.Inst.Tag,
16977 is_non_err_tag: Air.Inst.Tag,
16978) !void {
16979 const ok = try parent_block.addUnOp(is_non_err_tag, operand);
16980 const gpa = sema.gpa;
16981
16982 var fail_block: Block = .{
16983 .parent = parent_block,
16984 .sema = sema,
16985 .src_decl = parent_block.src_decl,
16986 .namespace = parent_block.namespace,
16987 .wip_capture_scope = parent_block.wip_capture_scope,
16988 .instructions = .{},
16989 .inlining = parent_block.inlining,
16990 .is_comptime = parent_block.is_comptime,
16991 };
16992
16993 defer fail_block.instructions.deinit(gpa);
16994
16995 {
16996 const this_feature_is_implemented_in_the_backend =
16997 sema.mod.comp.bin_file.options.object_format == .c or
16998 sema.mod.comp.bin_file.options.use_llvm;
16999
17000 if (!this_feature_is_implemented_in_the_backend) {
17001 // TODO implement this feature in all the backends and then delete this branch
17002 _ = try fail_block.addNoOp(.breakpoint);
17003 _ = try fail_block.addNoOp(.unreach);
17004 } else {
17005 const panic_fn = try sema.getBuiltin(&fail_block, src, "panicUnwrapError");
17006 const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand);
17007 const err_return_trace = try sema.getErrorReturnTrace(&fail_block, src);
17008 const args: [2]Air.Inst.Ref = .{ err_return_trace, err };
17009 _ = try sema.analyzeCall(&fail_block, panic_fn, src, src, .auto, false, &args);
17010 }
17011 }
17012
17013 try parent_block.instructions.ensureUnusedCapacity(gpa, 1);
17014
17015 try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
17016 1 + // The main block only needs space for the cond_br.
17017 @typeInfo(Air.CondBr).Struct.fields.len +
17018 1 + // The ok branch of the cond_br only needs space for the br.
17019 fail_block.instructions.items.len);
17020
17021 try sema.air_instructions.ensureUnusedCapacity(gpa, 3);
17022 const block_inst = @intCast(Air.Inst.Index, sema.air_instructions.len);
17023 const cond_br_inst = block_inst + 1;
17024 const br_inst = cond_br_inst + 1;
17025 sema.air_instructions.appendAssumeCapacity(.{
17026 .tag = .block,
17027 .data = .{ .ty_pl = .{
17028 .ty = .void_type,
17029 .payload = sema.addExtraAssumeCapacity(Air.Block{
17030 .body_len = 1,
17031 }),
17032 } },
17033 });
17034 sema.air_extra.appendAssumeCapacity(cond_br_inst);
17035
17036 sema.air_instructions.appendAssumeCapacity(.{
17037 .tag = .cond_br,
17038 .data = .{ .pl_op = .{
17039 .operand = ok,
17040 .payload = sema.addExtraAssumeCapacity(Air.CondBr{
17041 .then_body_len = 1,
17042 .else_body_len = @intCast(u32, fail_block.instructions.items.len),
17043 }),
17044 } },
17045 });
17046 sema.air_extra.appendAssumeCapacity(br_inst);
17047 sema.air_extra.appendSliceAssumeCapacity(fail_block.instructions.items);
17048
17049 sema.air_instructions.appendAssumeCapacity(.{
17050 .tag = .br,
17051 .data = .{ .br = .{
17052 .block_inst = block_inst,
17053 .operand = .void_value,
17054 } },
17055 });
17056
17057 parent_block.instructions.appendAssumeCapacity(block_inst);
17058}
17059
1697117060fn safetyPanic(
1697217061 sema: *Sema,
1697317062 block: *Block,
......@@ -16977,7 +17066,6 @@ fn safetyPanic(
1697717066 const msg = switch (panic_id) {
1697817067 .unreach => "reached unreachable code",
1697917068 .unwrap_null => "attempt to use null value",
16980 .unwrap_errunion => "unreachable error occurred",
1698117069 .cast_to_null => "cast causes pointer to be null",
1698217070 .incorrect_alignment => "incorrect alignment",
1698317071 .invalid_error_code => "invalid error code",