authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-12-29 23:34:46+00:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-12-31 09:55:03+00:00
log7e82398cfe94f99ea82270894f125d8547d5f1ad
treec37b2418157c45adb1111207f3dae1522ed3a0a7
parentd6120cf6a9a1d946f6754aa7de49c31b1fc8398e
signaturelock-open Commit is signed but in an unrecognized format.

Sema: remove some incorrect calls to `requireRuntimeBlock`

Most calls to `requireRuntimeBlock` in Sema are not correct. This function doesn't deal with all of them, but it does deal with ones which have, in combination with the past few commits, introduced real-world regressions. Related: #22353

1 files changed, 21 insertions(+), 55 deletions(-)

src/Sema.zig+21-55
......@@ -14626,7 +14626,7 @@ fn zirShl(
1462614626 }),
1462714627 } },
1462814628 });
14629 const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty);
14629 const ov_bit = try sema.tupleFieldValByIndex(block, op_ov, 1, op_ov_tuple_ty);
1463014630 const any_ov_bit = if (lhs_ty.zigTypeTag(zcu) == .vector)
1463114631 try block.addInst(.{
1463214632 .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,
......@@ -14641,7 +14641,7 @@ fn zirShl(
1464114641 const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
1464214642
1464314643 try sema.addSafetyCheck(block, src, no_ov, .shl_overflow);
14644 return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty);
14644 return sema.tupleFieldValByIndex(block, op_ov, 0, op_ov_tuple_ty);
1464514645 }
1464614646 }
1464714647 return block.addBinOp(air_tag, lhs, new_rhs);
......@@ -14969,20 +14969,12 @@ fn analyzeTupleCat(
1496914969 const element_refs = try sema.arena.alloc(Air.Inst.Ref, final_len);
1497014970 var i: u32 = 0;
1497114971 while (i < lhs_len) : (i += 1) {
14972 const operand_src = block.src(.{ .array_cat_lhs = .{
14973 .array_cat_offset = src_node,
14974 .elem_index = i,
14975 } });
14976 element_refs[i] = try sema.tupleFieldValByIndex(block, operand_src, lhs, i, lhs_ty);
14972 element_refs[i] = try sema.tupleFieldValByIndex(block, lhs, i, lhs_ty);
1497714973 }
1497814974 i = 0;
1497914975 while (i < rhs_len) : (i += 1) {
14980 const operand_src = block.src(.{ .array_cat_rhs = .{
14981 .array_cat_offset = src_node,
14982 .elem_index = i,
14983 } });
1498414976 element_refs[i + lhs_len] =
14985 try sema.tupleFieldValByIndex(block, operand_src, rhs, i, rhs_ty);
14977 try sema.tupleFieldValByIndex(block, rhs, i, rhs_ty);
1498614978 }
1498714979
1498814980 return block.addAggregateInit(Type.fromInterned(tuple_ty), element_refs);
......@@ -15400,11 +15392,7 @@ fn analyzeTupleMul(
1540015392 const element_refs = try sema.arena.alloc(Air.Inst.Ref, final_len);
1540115393 var i: u32 = 0;
1540215394 while (i < tuple_len) : (i += 1) {
15403 const operand_src = block.src(.{ .array_cat_lhs = .{
15404 .array_cat_offset = src_node,
15405 .elem_index = i,
15406 } });
15407 element_refs[i] = try sema.tupleFieldValByIndex(block, operand_src, operand, @intCast(i), operand_ty);
15395 element_refs[i] = try sema.tupleFieldValByIndex(block, operand, @intCast(i), operand_ty);
1540815396 }
1540915397 i = 1;
1541015398 while (i < factor) : (i += 1) {
......@@ -17502,7 +17490,7 @@ fn analyzeArithmetic(
1750217490 }),
1750317491 } },
1750417492 });
17505 const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty);
17493 const ov_bit = try sema.tupleFieldValByIndex(block, op_ov, 1, op_ov_tuple_ty);
1750617494 const any_ov_bit = if (resolved_type.zigTypeTag(zcu) == .vector)
1750717495 try block.addInst(.{
1750817496 .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,
......@@ -17517,7 +17505,7 @@ fn analyzeArithmetic(
1751717505 const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
1751817506
1751917507 try sema.addSafetyCheck(block, src, no_ov, .integer_overflow);
17520 return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty);
17508 return sema.tupleFieldValByIndex(block, op_ov, 0, op_ov_tuple_ty);
1752117509 }
1752217510 }
1752317511 }
......@@ -25725,7 +25713,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
2572525713
2572625714 const resolved_args: []Air.Inst.Ref = try sema.arena.alloc(Air.Inst.Ref, args_ty.structFieldCount(zcu));
2572725715 for (resolved_args, 0..) |*resolved, i| {
25728 resolved.* = try sema.tupleFieldValByIndex(block, args_src, args, @intCast(i), args_ty);
25716 resolved.* = try sema.tupleFieldValByIndex(block, args, @intCast(i), args_ty);
2572925717 }
2573025718
2573125719 const callee_ty = sema.typeOf(func);
......@@ -28113,7 +28101,7 @@ fn fieldVal(
2811328101 const field_ptr = try sema.structFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
2811428102 return sema.analyzeLoad(block, src, field_ptr, object_src);
2811528103 } else {
28116 return sema.structFieldVal(block, src, object, field_name, field_name_src, inner_ty);
28104 return sema.structFieldVal(block, object, field_name, field_name_src, inner_ty);
2811728105 },
2811828106 .@"union" => if (is_pointer_to) {
2811928107 // Avoid loading the entire union by fetching a pointer and loading that
......@@ -28733,14 +28721,12 @@ fn structFieldPtrByIndex(
2873328721 return Air.internedToRef(val);
2873428722 }
2873528723
28736 try sema.requireRuntimeBlock(block, src, null);
2873728724 return block.addStructFieldPtr(struct_ptr, field_index, ptr_field_ty);
2873828725}
2873928726
2874028727fn structFieldVal(
2874128728 sema: *Sema,
2874228729 block: *Block,
28743 src: LazySrcLoc,
2874428730 struct_byval: Air.Inst.Ref,
2874528731 field_name: InternPool.NullTerminatedString,
2874628732 field_name_src: LazySrcLoc,
......@@ -28776,12 +28762,11 @@ fn structFieldVal(
2877628762 return Air.internedToRef((try struct_val.fieldValue(pt, field_index)).toIntern());
2877728763 }
2877828764
28779 try sema.requireRuntimeBlock(block, src, null);
2878028765 try field_ty.resolveLayout(pt);
2878128766 return block.addStructFieldVal(struct_byval, field_index, field_ty);
2878228767 },
2878328768 .tuple_type => {
28784 return sema.tupleFieldVal(block, src, struct_byval, field_name, field_name_src, struct_ty);
28769 return sema.tupleFieldVal(block, struct_byval, field_name, field_name_src, struct_ty);
2878528770 },
2878628771 else => unreachable,
2878728772 }
......@@ -28790,7 +28775,6 @@ fn structFieldVal(
2879028775fn tupleFieldVal(
2879128776 sema: *Sema,
2879228777 block: *Block,
28793 src: LazySrcLoc,
2879428778 tuple_byval: Air.Inst.Ref,
2879528779 field_name: InternPool.NullTerminatedString,
2879628780 field_name_src: LazySrcLoc,
......@@ -28802,7 +28786,7 @@ fn tupleFieldVal(
2880228786 return pt.intRef(Type.usize, tuple_ty.structFieldCount(zcu));
2880328787 }
2880428788 const field_index = try sema.tupleFieldIndex(block, tuple_ty, field_name, field_name_src);
28805 return sema.tupleFieldValByIndex(block, src, tuple_byval, field_index, tuple_ty);
28789 return sema.tupleFieldValByIndex(block, tuple_byval, field_index, tuple_ty);
2880628790}
2880728791
2880828792/// Asserts that `field_name` is not "len".
......@@ -28831,7 +28815,6 @@ fn tupleFieldIndex(
2883128815fn tupleFieldValByIndex(
2883228816 sema: *Sema,
2883328817 block: *Block,
28834 src: LazySrcLoc,
2883528818 tuple_byval: Air.Inst.Ref,
2883628819 field_index: u32,
2883728820 tuple_ty: Type,
......@@ -28861,7 +28844,6 @@ fn tupleFieldValByIndex(
2886128844 };
2886228845 }
2886328846
28864 try sema.requireRuntimeBlock(block, src, null);
2886528847 try field_ty.resolveLayout(pt);
2886628848 return block.addStructFieldVal(tuple_byval, field_index, field_ty);
2886728849}
......@@ -28959,7 +28941,6 @@ fn unionFieldPtr(
2895928941 return Air.internedToRef(field_ptr_val.toIntern());
2896028942 }
2896128943
28962 try sema.requireRuntimeBlock(block, src, null);
2896328944 if (!initializing and union_obj.flagsUnordered(ip).layout == .auto and block.wantSafety() and
2896428945 union_ty.unionTagTypeSafety(zcu) != null and union_obj.field_types.len > 1)
2896528946 {
......@@ -29036,7 +29017,6 @@ fn unionFieldVal(
2903629017 }
2903729018 }
2903829019
29039 try sema.requireRuntimeBlock(block, src, null);
2904029020 if (union_obj.flagsUnordered(ip).layout == .auto and block.wantSafety() and
2904129021 union_ty.unionTagTypeSafety(zcu) != null and union_obj.field_types.len > 1)
2904229022 {
......@@ -29115,16 +29095,15 @@ fn elemPtrOneLayerOnly(
2911529095 .Many, .C => {
2911629096 const maybe_ptr_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
2911729097 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
29118 const runtime_src = rs: {
29119 const ptr_val = maybe_ptr_val orelse break :rs indexable_src;
29120 const index_val = maybe_index_val orelse break :rs elem_index_src;
29098 ct: {
29099 const ptr_val = maybe_ptr_val orelse break :ct;
29100 const index_val = maybe_index_val orelse break :ct;
2912129101 const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
2912229102 const elem_ptr = try ptr_val.ptrElem(index, pt);
2912329103 return Air.internedToRef(elem_ptr.toIntern());
29124 };
29104 }
2912529105 const result_ty = try indexable_ty.elemPtrType(null, pt);
2912629106
29127 try sema.requireRuntimeBlock(block, src, runtime_src);
2912829107 return block.addPtrElemPtr(indexable, elem_index, result_ty);
2912929108 },
2913029109 .One => {
......@@ -29172,22 +29151,19 @@ fn elemVal(
2917229151 const maybe_indexable_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
2917329152 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
2917429153
29175 const runtime_src = rs: {
29176 const indexable_val = maybe_indexable_val orelse break :rs indexable_src;
29177 const index_val = maybe_index_val orelse break :rs elem_index_src;
29154 ct: {
29155 const indexable_val = maybe_indexable_val orelse break :ct;
29156 const index_val = maybe_index_val orelse break :ct;
2917829157 const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
2917929158 const elem_ty = indexable_ty.elemType2(zcu);
2918029159 const many_ptr_ty = try pt.manyConstPtrType(elem_ty);
2918129160 const many_ptr_val = try pt.getCoerced(indexable_val, many_ptr_ty);
2918229161 const elem_ptr_ty = try pt.singleConstPtrType(elem_ty);
2918329162 const elem_ptr_val = try many_ptr_val.ptrElem(index, pt);
29184 if (try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty)) |elem_val| {
29185 return Air.internedToRef((try pt.getCoerced(elem_val, elem_ty)).toIntern());
29186 }
29187 break :rs indexable_src;
29188 };
29163 const elem_val = try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty) orelse break :ct;
29164 return Air.internedToRef((try pt.getCoerced(elem_val, elem_ty)).toIntern());
29165 }
2918929166
29190 try sema.requireRuntimeBlock(block, src, runtime_src);
2919129167 return block.addBinOp(.ptr_elem_val, indexable, elem_index);
2919229168 },
2919329169 .One => {
......@@ -29300,7 +29276,6 @@ fn tupleFieldPtr(
2930029276 try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_ptr_src);
2930129277 }
2930229278
29303 try sema.requireRuntimeBlock(block, tuple_ptr_src, null);
2930429279 return block.addStructFieldPtr(tuple_ptr, field_index, ptr_field_ty);
2930529280}
2930629281
......@@ -29343,7 +29318,6 @@ fn tupleField(
2934329318
2934429319 try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_src);
2934529320
29346 try sema.requireRuntimeBlock(block, tuple_src, null);
2934729321 try field_ty.resolveLayout(pt);
2934829322 return block.addStructFieldVal(tuple, field_index, field_ty);
2934929323}
......@@ -29399,7 +29373,6 @@ fn elemValArray(
2939929373
2940029374 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, array_ty, array_src);
2940129375
29402 const runtime_src = if (maybe_undef_array_val != null) elem_index_src else array_src;
2940329376 if (oob_safety and block.wantSafety()) {
2940429377 // Runtime check is only needed if unable to comptime check.
2940529378 if (maybe_index_val == null) {
......@@ -29412,7 +29385,6 @@ fn elemValArray(
2941229385 if (try sema.typeHasOnePossibleValue(elem_ty)) |elem_val|
2941329386 return Air.internedToRef(elem_val.toIntern());
2941429387
29415 try sema.requireRuntimeBlock(block, src, runtime_src);
2941629388 return block.addBinOp(.array_elem_val, array, elem_index);
2941729389}
2941829390
......@@ -29466,9 +29438,6 @@ fn elemPtrArray(
2946629438 try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.elemType2(zcu), array_ty, array_ptr_src);
2946729439 }
2946829440
29469 const runtime_src = if (maybe_undef_array_ptr_val != null) elem_index_src else array_ptr_src;
29470 try sema.requireRuntimeBlock(block, src, runtime_src);
29471
2947229441 // Runtime check is only needed if unable to comptime check.
2947329442 if (oob_safety and block.wantSafety() and offset == null) {
2947429443 const len_inst = try pt.intRef(Type.usize, array_len);
......@@ -29525,7 +29494,6 @@ fn elemValSlice(
2952529494
2952629495 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, slice_ty, slice_src);
2952729496
29528 try sema.requireRuntimeBlock(block, src, runtime_src);
2952929497 if (oob_safety and block.wantSafety()) {
2953029498 const len_inst = if (maybe_slice_val) |slice_val|
2953129499 try pt.intRef(Type.usize, try slice_val.sliceLen(pt))
......@@ -29582,8 +29550,6 @@ fn elemPtrSlice(
2958229550
2958329551 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ptr_ty, slice_ty, slice_src);
2958429552
29585 const runtime_src = if (maybe_undef_slice_val != null) elem_index_src else slice_src;
29586 try sema.requireRuntimeBlock(block, src, runtime_src);
2958729553 if (oob_safety and block.wantSafety()) {
2958829554 const len_inst = len: {
2958929555 if (maybe_undef_slice_val) |slice_val|