authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-02-13 02:36:13+00:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-02-16 11:26:34+00:00
log10784c7fc8d419fff943994f1aa5a454d4e43391
treef58674fe9b481693abbba790f95491e950681ef8
parent434537213e406191959818f573b24ca45c1b0e45
signaturelock-open Commit is signed but in an unrecognized format.

AstGen: migrate `ty` result locations to `coerced_ty`

In most cases where AstGen is coercing to a fixed type (such as `u29`, `type`, `std.builtin.CallingConvention) we do not necessarily require an explicit coercion instruction. Instead, Sema knows the type that is required, and can perform the coercion after the fact. This means we can use the `coerced_ty` result location kind, saving unnecessary coercion instructions and therefore ZIR bytes. This required a few enhancements to Sema to introduce missing coercions.

2 files changed, 114 insertions(+), 87 deletions(-)

src/AstGen.zig+56-61
......@@ -360,16 +360,11 @@ const ResultInfo = struct {
360360 };
361361};
362362
363/// TODO: modify Sema to remove in favour of `coerced_align_ri`
364const align_ri: ResultInfo = .{ .rl = .{ .ty = .u29_type } };
365363const coerced_align_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .u29_type } };
366/// TODO: modify Sema to remove in favour of `coerced_addrspace_ri`
367const addrspace_ri: ResultInfo = .{ .rl = .{ .ty = .address_space_type } };
368364const coerced_addrspace_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .address_space_type } };
369365const coerced_linksection_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .slice_const_u8_type } };
370const bool_ri: ResultInfo = .{ .rl = .{ .ty = .bool_type } };
371const type_ri: ResultInfo = .{ .rl = .{ .ty = .type_type } };
372366const coerced_type_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .type_type } };
367const coerced_bool_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .bool_type } };
373368
374369fn typeExpr(gz: *GenZir, scope: *Scope, type_node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
375370 return comptimeExpr(gz, scope, coerced_type_ri, type_node);
......@@ -786,7 +781,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
786781 .bool_and => return boolBinOp(gz, scope, ri, node, .bool_br_and),
787782 .bool_or => return boolBinOp(gz, scope, ri, node, .bool_br_or),
788783
789 .bool_not => return simpleUnOp(gz, scope, ri, node, bool_ri, node_datas[node].lhs, .bool_not),
784 .bool_not => return simpleUnOp(gz, scope, ri, node, coerced_bool_ri, node_datas[node].lhs, .bool_not),
790785 .bit_not => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, node_datas[node].lhs, .bit_not),
791786
792787 .negation => return negation(gz, scope, ri, node),
......@@ -1372,7 +1367,7 @@ fn fnProtoExpr(
13721367 };
13731368
13741369 const align_ref: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
1375 break :inst try expr(&block_scope, scope, align_ri, fn_proto.ast.align_expr);
1370 break :inst try expr(&block_scope, scope, coerced_align_ri, fn_proto.ast.align_expr);
13761371 };
13771372
13781373 if (fn_proto.ast.addrspace_expr != 0) {
......@@ -1387,7 +1382,7 @@ fn fnProtoExpr(
13871382 try expr(
13881383 &block_scope,
13891384 scope,
1390 .{ .rl = .{ .ty = .calling_convention_type } },
1385 .{ .rl = .{ .coerced_ty = .calling_convention_type } },
13911386 fn_proto.ast.callconv_expr,
13921387 )
13931388 else
......@@ -3136,7 +3131,7 @@ fn varDecl(
31363131 }
31373132
31383133 const align_inst: Zir.Inst.Ref = if (var_decl.ast.align_node != 0)
3139 try expr(gz, scope, align_ri, var_decl.ast.align_node)
3134 try expr(gz, scope, coerced_align_ri, var_decl.ast.align_node)
31403135 else
31413136 .none;
31423137
......@@ -3505,7 +3500,7 @@ fn assignDestructureMaybeDecls(
35053500 const this_lhs_comptime = is_comptime or (is_const and rhs_is_comptime);
35063501
35073502 const align_inst: Zir.Inst.Ref = if (full.ast.align_node != 0)
3508 try expr(gz, scope, align_ri, full.ast.align_node)
3503 try expr(gz, scope, coerced_align_ri, full.ast.align_node)
35093504 else
35103505 .none;
35113506
......@@ -3783,7 +3778,7 @@ fn ptrType(
37833778 gz.astgen.source_line = source_line;
37843779 gz.astgen.source_column = source_column;
37853780
3786 addrspace_ref = try expr(gz, scope, addrspace_ri, ptr_info.ast.addrspace_node);
3781 addrspace_ref = try expr(gz, scope, coerced_addrspace_ri, ptr_info.ast.addrspace_node);
37873782 trailing_count += 1;
37883783 }
37893784 if (ptr_info.ast.align_node != 0) {
......@@ -4176,7 +4171,7 @@ fn fnDecl(
41764171 var addrspace_gz = decl_gz.makeSubBlock(params_scope);
41774172 defer addrspace_gz.unstack();
41784173 const addrspace_ref: Zir.Inst.Ref = if (fn_proto.ast.addrspace_expr == 0) .none else inst: {
4179 const inst = try expr(&decl_gz, params_scope, addrspace_ri, fn_proto.ast.addrspace_expr);
4174 const inst = try expr(&decl_gz, params_scope, coerced_addrspace_ri, fn_proto.ast.addrspace_expr);
41804175 if (addrspace_gz.instructionsSlice().len == 0) {
41814176 // In this case we will send a len=0 body which can be encoded more efficiently.
41824177 break :inst inst;
......@@ -4431,7 +4426,7 @@ fn globalVarDecl(
44314426 try expr(
44324427 &block_scope,
44334428 &block_scope.base,
4434 .{ .rl = .{ .ty = .type_type } },
4429 coerced_type_ri,
44354430 var_decl.ast.type_node,
44364431 )
44374432 else
......@@ -5254,7 +5249,7 @@ fn unionDeclInner(
52545249 return astgen.failNode(member_node, "union field missing type", .{});
52555250 }
52565251 if (have_align) {
5257 const align_inst = try expr(&block_scope, &block_scope.base, .{ .rl = .{ .ty = .u32_type } }, member.ast.align_expr);
5252 const align_inst = try expr(&block_scope, &block_scope.base, coerced_align_ri, member.ast.align_expr);
52585253 wip_members.appendToField(@intFromEnum(align_inst));
52595254 any_aligned_fields = true;
52605255 }
......@@ -5522,7 +5517,7 @@ fn containerDecl(
55225517 namespace.base.tag = .enum_namespace;
55235518
55245519 const arg_inst: Zir.Inst.Ref = if (container_decl.ast.arg != 0)
5525 try comptimeExpr(&block_scope, &namespace.base, .{ .rl = .{ .ty = .type_type } }, container_decl.ast.arg)
5520 try comptimeExpr(&block_scope, &namespace.base, coerced_type_ri, container_decl.ast.arg)
55265521 else
55275522 .none;
55285523
......@@ -6079,7 +6074,7 @@ fn arrayAccess(
60796074
60806075 const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);
60816076
6082 const rhs = try expr(gz, scope, .{ .rl = .{ .ty = .usize_type } }, node_datas[node].rhs);
6077 const rhs = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, node_datas[node].rhs);
60836078 try emitDbgStmt(gz, cursor);
60846079
60856080 return gz.addPlNode(.elem_ptr_node, node, Zir.Inst.Bin{ .lhs = lhs, .rhs = rhs });
......@@ -6089,7 +6084,7 @@ fn arrayAccess(
60896084
60906085 const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);
60916086
6092 const rhs = try expr(gz, scope, .{ .rl = .{ .ty = .usize_type } }, node_datas[node].rhs);
6087 const rhs = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, node_datas[node].rhs);
60936088 try emitDbgStmt(gz, cursor);
60946089
60956090 return rvalue(gz, ri, try gz.addPlNode(.elem_val_node, node, Zir.Inst.Bin{ .lhs = lhs, .rhs = rhs }), node);
......@@ -6157,12 +6152,12 @@ fn boolBinOp(
61576152 const tree = astgen.tree;
61586153 const node_datas = tree.nodes.items(.data);
61596154
6160 const lhs = try expr(gz, scope, bool_ri, node_datas[node].lhs);
6155 const lhs = try expr(gz, scope, coerced_bool_ri, node_datas[node].lhs);
61616156 const bool_br = (try gz.addPlNodePayloadIndex(zir_tag, node, undefined)).toIndex().?;
61626157
61636158 var rhs_scope = gz.makeSubBlock(scope);
61646159 defer rhs_scope.unstack();
6165 const rhs = try expr(&rhs_scope, &rhs_scope.base, bool_ri, node_datas[node].rhs);
6160 const rhs = try expr(&rhs_scope, &rhs_scope.base, coerced_bool_ri, node_datas[node].rhs);
61666161 if (!gz.refIsNoReturn(rhs)) {
61676162 _ = try rhs_scope.addBreakWithSrcNode(.break_inline, bool_br, rhs, node_datas[node].rhs);
61686163 }
......@@ -6230,7 +6225,7 @@ fn ifExpr(
62306225 .bool_bit = try block_scope.addUnNode(tag, optional, if_full.ast.cond_expr),
62316226 };
62326227 } else {
6233 const cond = try expr(&block_scope, &block_scope.base, bool_ri, if_full.ast.cond_expr);
6228 const cond = try expr(&block_scope, &block_scope.base, coerced_bool_ri, if_full.ast.cond_expr);
62346229 break :c .{
62356230 .inst = cond,
62366231 .bool_bit = cond,
......@@ -6476,7 +6471,7 @@ fn whileExpr(
64766471 .bool_bit = try cond_scope.addUnNode(tag, optional, while_full.ast.cond_expr),
64776472 };
64786473 } else {
6479 const cond = try expr(&cond_scope, &cond_scope.base, bool_ri, while_full.ast.cond_expr);
6474 const cond = try expr(&cond_scope, &cond_scope.base, coerced_bool_ri, while_full.ast.cond_expr);
64806475 break :c .{
64816476 .inst = cond,
64826477 .bool_bit = cond,
......@@ -8052,7 +8047,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
80528047 .rl = .{ .ptr = .{ .inst = try gz.addNode(.ret_ptr, node) } },
80538048 .ctx = .@"return",
80548049 } else .{
8055 .rl = .{ .ty = astgen.fn_ret_ty },
8050 .rl = .{ .coerced_ty = astgen.fn_ret_ty },
80568051 .ctx = .@"return",
80578052 };
80588053 const prev_anon_name_strategy = gz.anon_name_strategy;
......@@ -8688,7 +8683,7 @@ fn unionInit(
86888683 params: []const Ast.Node.Index,
86898684) InnerError!Zir.Inst.Ref {
86908685 const union_type = try typeExpr(gz, scope, params[0]);
8691 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[1]);
8686 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[1]);
86928687 const field_type = try gz.addPlNode(.field_type_ref, node, Zir.Inst.FieldTypeRef{
86938688 .container_type = union_type,
86948689 .field_name = field_name,
......@@ -9001,12 +8996,12 @@ fn builtinCall(
90018996 if (ri.rl == .ref or ri.rl == .ref_coerced_ty) {
90028997 return gz.addPlNode(.field_ptr_named, node, Zir.Inst.FieldNamed{
90038998 .lhs = try expr(gz, scope, .{ .rl = .ref }, params[0]),
9004 .field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[1]),
8999 .field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[1]),
90059000 });
90069001 }
90079002 const result = try gz.addPlNode(.field_val_named, node, Zir.Inst.FieldNamed{
90089003 .lhs = try expr(gz, scope, .{ .rl = .none }, params[0]),
9009 .field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[1]),
9004 .field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[1]),
90109005 });
90119006 return rvalue(gz, ri, result, node);
90129007 },
......@@ -9133,7 +9128,7 @@ fn builtinCall(
91339128 return rvalue(gz, ri, .void_value, node);
91349129 },
91359130 .set_align_stack => {
9136 const order = try expr(gz, scope, align_ri, params[0]);
9131 const order = try expr(gz, scope, coerced_align_ri, params[0]);
91379132 _ = try gz.addExtendedPayload(.set_align_stack, Zir.Inst.UnNode{
91389133 .node = gz.nodeIndexToRelative(node),
91399134 .operand = order,
......@@ -9175,32 +9170,32 @@ fn builtinCall(
91759170 .bit_size_of => return simpleUnOpType(gz, scope, ri, node, params[0], .bit_size_of),
91769171 .align_of => return simpleUnOpType(gz, scope, ri, node, params[0], .align_of),
91779172
9178 .int_from_ptr => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .int_from_ptr),
9179 .compile_error => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[0], .compile_error),
9180 .set_eval_branch_quota => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0], .set_eval_branch_quota),
9181 .int_from_enum => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .int_from_enum),
9182 .int_from_bool => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .int_from_bool),
9183 .embed_file => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[0], .embed_file),
9184 .error_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .anyerror_type } }, params[0], .error_name),
9185 .set_runtime_safety => return simpleUnOp(gz, scope, ri, node, bool_ri, params[0], .set_runtime_safety),
9186 .sqrt => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .sqrt),
9187 .sin => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .sin),
9188 .cos => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .cos),
9189 .tan => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .tan),
9190 .exp => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .exp),
9191 .exp2 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .exp2),
9192 .log => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log),
9193 .log2 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log2),
9194 .log10 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log10),
9195 .abs => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .abs),
9196 .floor => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .floor),
9197 .ceil => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .ceil),
9198 .trunc => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .trunc),
9199 .round => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .round),
9200 .tag_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .tag_name),
9201 .type_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .type_name),
9202 .Frame => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .frame_type),
9203 .frame_size => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .frame_size),
9173 .int_from_ptr => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .int_from_ptr),
9174 .compile_error => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[0], .compile_error),
9175 .set_eval_branch_quota => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0], .set_eval_branch_quota),
9176 .int_from_enum => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .int_from_enum),
9177 .int_from_bool => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .int_from_bool),
9178 .embed_file => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[0], .embed_file),
9179 .error_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .anyerror_type } }, params[0], .error_name),
9180 .set_runtime_safety => return simpleUnOp(gz, scope, ri, node, coerced_bool_ri, params[0], .set_runtime_safety),
9181 .sqrt => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .sqrt),
9182 .sin => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .sin),
9183 .cos => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .cos),
9184 .tan => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .tan),
9185 .exp => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .exp),
9186 .exp2 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .exp2),
9187 .log => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log),
9188 .log2 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log2),
9189 .log10 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log10),
9190 .abs => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .abs),
9191 .floor => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .floor),
9192 .ceil => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .ceil),
9193 .trunc => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .trunc),
9194 .round => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .round),
9195 .tag_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .tag_name),
9196 .type_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .type_name),
9197 .Frame => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .frame_type),
9198 .frame_size => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .frame_size),
92049199
92059200 .int_from_float => return typeCast(gz, scope, ri, node, params[0], .int_from_float, builtin_name),
92069201 .float_from_int => return typeCast(gz, scope, ri, node, params[0], .float_from_int, builtin_name),
......@@ -9238,7 +9233,7 @@ fn builtinCall(
92389233 },
92399234 .panic => {
92409235 try emitDbgNode(gz, node);
9241 return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[0], .panic);
9236 return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[0], .panic);
92429237 },
92439238 .trap => {
92449239 try emitDbgNode(gz, node);
......@@ -9327,7 +9322,7 @@ fn builtinCall(
93279322 },
93289323 .c_define => {
93299324 if (!gz.c_import) return gz.astgen.failNode(node, "C define valid only inside C import block", .{});
9330 const name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[0]);
9325 const name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[0]);
93319326 const value = try comptimeExpr(gz, scope, .{ .rl = .none }, params[1]);
93329327 const result = try gz.addExtendedPayload(.c_define, Zir.Inst.BinNode{
93339328 .node = gz.nodeIndexToRelative(node),
......@@ -9348,7 +9343,7 @@ fn builtinCall(
93489343 return rvalue(gz, ri, result, node);
93499344 },
93509345 .reduce => {
9351 const op = try expr(gz, scope, .{ .rl = .{ .ty = .reduce_op_type } }, params[0]);
9346 const op = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .reduce_op_type } }, params[0]);
93529347 const scalar = try expr(gz, scope, .{ .rl = .none }, params[1]);
93539348 const result = try gz.addPlNode(.reduce, node, Zir.Inst.Bin{
93549349 .lhs = op,
......@@ -9424,7 +9419,7 @@ fn builtinCall(
94249419 },
94259420 .field_parent_ptr => {
94269421 const parent_type = try typeExpr(gz, scope, params[0]);
9427 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[1]);
9422 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[1]);
94289423 const result = try gz.addPlNode(.field_parent_ptr, node, Zir.Inst.FieldParentPtr{
94299424 .parent_type = parent_type,
94309425 .field_name = field_name,
......@@ -9561,7 +9556,7 @@ fn hasDeclOrField(
95619556 tag: Zir.Inst.Tag,
95629557) InnerError!Zir.Inst.Ref {
95639558 const container_type = try typeExpr(gz, scope, lhs_node);
9564 const name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, rhs_node);
9559 const name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, rhs_node);
95659560 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
95669561 .lhs = container_type,
95679562 .rhs = name,
......@@ -9711,7 +9706,7 @@ fn simpleCBuiltin(
97119706) InnerError!Zir.Inst.Ref {
97129707 const name: []const u8 = if (tag == .c_undef) "C undef" else "C include";
97139708 if (!gz.c_import) return gz.astgen.failNode(node, "{s} valid only inside C import block", .{name});
9714 const operand = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, operand_node);
9709 const operand = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, operand_node);
97159710 _ = try gz.addExtendedPayload(tag, Zir.Inst.UnNode{
97169711 .node = gz.nodeIndexToRelative(node),
97179712 .operand = operand,
......@@ -9729,7 +9724,7 @@ fn offsetOf(
97299724 tag: Zir.Inst.Tag,
97309725) InnerError!Zir.Inst.Ref {
97319726 const type_inst = try typeExpr(gz, scope, lhs_node);
9732 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, rhs_node);
9727 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, rhs_node);
97339728 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
97349729 .lhs = type_inst,
97359730 .rhs = field_name,
......@@ -13148,7 +13143,7 @@ const GenZir = struct {
1314813143 fn addRet(gz: *GenZir, ri: ResultInfo, operand: Zir.Inst.Ref, node: Ast.Node.Index) !void {
1314913144 switch (ri.rl) {
1315013145 .ptr => |ptr_res| _ = try gz.addUnNode(.ret_load, ptr_res.inst, node),
13151 .ty => _ = try gz.addUnNode(.ret_node, operand, node),
13146 .coerced_ty => _ = try gz.addUnNode(.ret_node, operand, node),
1315213147 else => unreachable,
1315313148 }
1315413149 }
src/Sema.zig+58-26
......@@ -10487,7 +10487,8 @@ fn zirElemValNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
1048710487 const elem_index_src: LazySrcLoc = .{ .node_offset_array_access_index = inst_data.src_node };
1048810488 const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
1048910489 const array = try sema.resolveInst(extra.lhs);
10490 const elem_index = try sema.resolveInst(extra.rhs);
10490 const uncoerced_elem_index = try sema.resolveInst(extra.rhs);
10491 const elem_index = try sema.coerce(block, Type.usize, uncoerced_elem_index, elem_index_src);
1049110492 return sema.elemVal(block, src, array, elem_index, elem_index_src, true);
1049210493}
1049310494
......@@ -10539,7 +10540,8 @@ fn zirElemPtrNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
1053910540 const elem_index_src: LazySrcLoc = .{ .node_offset_array_access_index = inst_data.src_node };
1054010541 const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
1054110542 const array_ptr = try sema.resolveInst(extra.lhs);
10542 const elem_index = try sema.resolveInst(extra.rhs);
10543 const uncoerced_elem_index = try sema.resolveInst(extra.rhs);
10544 const elem_index = try sema.coerce(block, Type.usize, uncoerced_elem_index, elem_index_src);
1054310545 return sema.elemPtr(block, src, array_ptr, elem_index, elem_index_src, false, true);
1054410546}
1054510547
......@@ -18722,11 +18724,13 @@ fn zirBoolBr(
1872218724 const inst_data = datas[@intFromEnum(inst)].pl_node;
1872318725 const extra = sema.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index);
1872418726
18725 const lhs = try sema.resolveInst(extra.data.lhs);
18727 const uncoerced_lhs = try sema.resolveInst(extra.data.lhs);
1872618728 const body = sema.code.bodySlice(extra.end, extra.data.body_len);
1872718729 const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
1872818730 const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
1872918731
18732 const lhs = try sema.coerce(parent_block, Type.bool, uncoerced_lhs, lhs_src);
18733
1873018734 if (try sema.resolveDefinedValue(parent_block, lhs_src, lhs)) |lhs_val| {
1873118735 if (is_bool_or and lhs_val.toBool()) {
1873218736 return .bool_true;
......@@ -18736,7 +18740,11 @@ fn zirBoolBr(
1873618740 // comptime-known left-hand side. No need for a block here; the result
1873718741 // is simply the rhs expression. Here we rely on there only being 1
1873818742 // break instruction (`break_inline`).
18739 return sema.resolveBody(parent_block, body, inst);
18743 const rhs_result = try sema.resolveBody(parent_block, body, inst);
18744 if (sema.typeOf(rhs_result).isNoReturn(mod)) {
18745 return rhs_result;
18746 }
18747 return sema.coerce(parent_block, Type.bool, rhs_result, rhs_src);
1874018748 }
1874118749
1874218750 const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
......@@ -18767,13 +18775,16 @@ fn zirBoolBr(
1876718775 _ = try lhs_block.addBr(block_inst, lhs_result);
1876818776
1876918777 const rhs_result = try sema.resolveBody(rhs_block, body, inst);
18770 if (!sema.typeOf(rhs_result).isNoReturn(mod)) {
18771 _ = try rhs_block.addBr(block_inst, rhs_result);
18772 }
18778 const rhs_noret = sema.typeOf(rhs_result).isNoReturn(mod);
18779 const coerced_rhs_result = if (!rhs_noret) rhs: {
18780 const coerced_result = try sema.coerce(rhs_block, Type.bool, rhs_result, rhs_src);
18781 _ = try rhs_block.addBr(block_inst, coerced_result);
18782 break :rhs coerced_result;
18783 } else rhs_result;
1877318784
1877418785 const result = sema.finishCondBr(parent_block, &child_block, &then_block, &else_block, lhs, block_inst);
18775 if (!sema.typeOf(rhs_result).isNoReturn(mod)) {
18776 if (try sema.resolveDefinedValue(rhs_block, rhs_src, rhs_result)) |rhs_val| {
18786 if (!rhs_noret) {
18787 if (try sema.resolveDefinedValue(rhs_block, rhs_src, coerced_rhs_result)) |rhs_val| {
1877718788 if (is_bool_or and rhs_val.toBool()) {
1877818789 return .bool_true;
1877918790 } else if (!is_bool_or and !rhs_val.toBool()) {
......@@ -20750,8 +20761,9 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
2075020761
2075120762fn zirErrorName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
2075220763 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
20753 const operand = try sema.resolveInst(inst_data.operand);
2075420764 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
20765 const uncoerced_operand = try sema.resolveInst(inst_data.operand);
20766 const operand = try sema.coerce(block, Type.anyerror, uncoerced_operand, operand_src);
2075520767
2075620768 if (try sema.resolveDefinedValue(block, operand_src, operand)) |val| {
2075720769 const err_name = sema.mod.intern_pool.indexToKey(val.toIntern()).err.name;
......@@ -25375,15 +25387,21 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2537525387 } else if (extra.data.bits.has_align_ref) blk: {
2537625388 const align_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
2537725389 extra_index += 1;
25378 const align_tv = sema.resolveInstConst(block, align_src, align_ref, .{
25390 const uncoerced_align = sema.resolveInst(align_ref) catch |err| switch (err) {
25391 error.GenericPoison => break :blk null,
25392 else => |e| return e,
25393 };
25394 const coerced_align = sema.coerce(block, Type.u29, uncoerced_align, align_src) catch |err| switch (err) {
25395 error.GenericPoison => break :blk null,
25396 else => |e| return e,
25397 };
25398 const align_val = sema.resolveConstDefinedValue(block, align_src, coerced_align, .{
2537925399 .needed_comptime_reason = "alignment must be comptime-known",
2538025400 }) catch |err| switch (err) {
25381 error.GenericPoison => {
25382 break :blk null;
25383 },
25401 error.GenericPoison => break :blk null,
2538425402 else => |e| return e,
2538525403 };
25386 const alignment = try sema.validateAlignAllowZero(block, align_src, try align_tv.val.toUnsignedIntAdvanced(sema));
25404 const alignment = try sema.validateAlignAllowZero(block, align_src, try align_val.toUnsignedIntAdvanced(sema));
2538725405 const default = target_util.defaultFunctionAlignment(target);
2538825406 break :blk if (alignment == default) .none else alignment;
2538925407 } else .none;
......@@ -25394,7 +25412,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2539425412 const body = sema.code.bodySlice(extra_index, body_len);
2539525413 extra_index += body.len;
2539625414
25397 const addrspace_ty = try sema.getBuiltinType("AddressSpace");
25415 const addrspace_ty = Type.fromInterned(.address_space_type);
2539825416 const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty, .{
2539925417 .needed_comptime_reason = "addrspace must be comptime-known",
2540025418 });
......@@ -25405,15 +25423,22 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2540525423 } else if (extra.data.bits.has_addrspace_ref) blk: {
2540625424 const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
2540725425 extra_index += 1;
25408 const addrspace_tv = sema.resolveInstConst(block, addrspace_src, addrspace_ref, .{
25426 const addrspace_ty = Type.fromInterned(.address_space_type);
25427 const uncoerced_addrspace = sema.resolveInst(addrspace_ref) catch |err| switch (err) {
25428 error.GenericPoison => break :blk null,
25429 else => |e| return e,
25430 };
25431 const coerced_addrspace = sema.coerce(block, addrspace_ty, uncoerced_addrspace, addrspace_src) catch |err| switch (err) {
25432 error.GenericPoison => break :blk null,
25433 else => |e| return e,
25434 };
25435 const addrspace_val = sema.resolveConstDefinedValue(block, addrspace_src, coerced_addrspace, .{
2540925436 .needed_comptime_reason = "addrspace must be comptime-known",
2541025437 }) catch |err| switch (err) {
25411 error.GenericPoison => {
25412 break :blk null;
25413 },
25438 error.GenericPoison => break :blk null,
2541425439 else => |e| return e,
2541525440 };
25416 break :blk mod.toEnum(std.builtin.AddressSpace, addrspace_tv.val);
25441 break :blk mod.toEnum(std.builtin.AddressSpace, addrspace_val);
2541725442 } else target_util.defaultAddressSpace(target, .function);
2541825443
2541925444 const section: Section = if (extra.data.bits.has_section_body) blk: {
......@@ -25461,15 +25486,22 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2546125486 } else if (extra.data.bits.has_cc_ref) blk: {
2546225487 const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
2546325488 extra_index += 1;
25464 const cc_tv = sema.resolveInstConst(block, cc_src, cc_ref, .{
25489 const cc_ty = Type.fromInterned(.calling_convention_type);
25490 const uncoerced_cc = sema.resolveInst(cc_ref) catch |err| switch (err) {
25491 error.GenericPoison => break :blk null,
25492 else => |e| return e,
25493 };
25494 const coerced_cc = sema.coerce(block, cc_ty, uncoerced_cc, cc_src) catch |err| switch (err) {
25495 error.GenericPoison => break :blk null,
25496 else => |e| return e,
25497 };
25498 const cc_val = sema.resolveConstDefinedValue(block, cc_src, coerced_cc, .{
2546525499 .needed_comptime_reason = "calling convention must be comptime-known",
2546625500 }) catch |err| switch (err) {
25467 error.GenericPoison => {
25468 break :blk null;
25469 },
25501 error.GenericPoison => break :blk null,
2547025502 else => |e| return e,
2547125503 };
25472 break :blk mod.toEnum(std.builtin.CallingConvention, cc_tv.val);
25504 break :blk mod.toEnum(std.builtin.CallingConvention, cc_val);
2547325505 } else if (sema.owner_decl.is_exported and has_body)
2547425506 .C
2547525507 else