Commit 3cebaaad1ca16a9e0203ed8c1684d0ce72da9487 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-03-31 18:05:37-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-03-31 18:05:37-07:00
log	3cebaaad1ca16a9e0203ed8c1684d0ce72da9487
tree	a153e50f75fad0a1b6c683ad5c06e28e102ff848
parent	08eedc962d8e2582db8fb5b4a50114f2913519fd

astgen: improved handling of coercion

GenZir struct now has rl_ty_inst field which tracks the result location
type (if any) a block expects all of its results to be coerced to.

Remove a redundant coercion on const local initialization with a
specified type.

Switch expressions, during elision of store_to_block_ptr instructions,
now re-purpose them to be type coercion when the block has a type in the
result location.

4 files changed, 227 insertions(+), 105 deletions(-)

src
test
- stage2
  - cbe.zig

src/AstGen.zig+65-22

 @@ -1415,6 +1415,7 @@ fn varDecl(
                 const type_inst = try typeExpr(gz, &init_scope.base, var_decl.ast.type_node);
                 opt_type_inst = type_inst;
                 init_scope.rl_ptr = try init_scope.addUnNode(.alloc, type_inst, node);
+                init_scope.rl_ty_inst = type_inst;
             } else {
                 const alloc = try init_scope.addUnNode(.alloc_inferred, undefined, node);
                 resolve_inferred_alloc = alloc;
 @@ -1441,20 +1442,13 @@ fn varDecl(
                     parent_zir.appendAssumeCapacity(src_inst);
                 }
                 assert(parent_zir.items.len == expected_len);
-                const casted_init = if (opt_type_inst != .none)
-                    try gz.addPlNode(.as_node, var_decl.ast.type_node, zir.Inst.As{
-                        .dest_type = opt_type_inst,
-                        .operand = init_inst,
-                    })
-                else
-                    init_inst;
                 const sub_scope = try block_arena.create(Scope.LocalVal);
                 sub_scope.* = .{
                     .parent = scope,
                     .gen_zir = gz,
                     .name = ident_name,
-                    .inst = casted_init,
+                    .inst = init_inst,
                     .src = name_src,
                 };
                 return &sub_scope.base;
 @@ -3029,25 +3023,48 @@ fn switchExpr(
             // all prongs, except for prongs that ended with a noreturn instruction.
             // Elide all the `store_to_block_ptr` instructions.
+            // The break instructions need to have their operands coerced if the
+            // switch's result location is a `ty`. In this case we overwrite the
+            // `store_to_block_ptr` instruction with an `as` instruction and repurpose
+            // it as the break operand.
             var extra_index: usize = 0;
             extra_index += 2;
             extra_index += @boolToInt(multi_cases_len != 0);
-            if (special_prong != .none) {
+            if (special_prong != .none) special_prong: {
                 const body_len_index = extra_index;
                 const body_len = scalar_cases_payload.items[extra_index];
                 extra_index += 1;
+                if (body_len < 2) {
+                    extra_index += body_len;
+                    astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[0..extra_index]);
+                    break :special_prong;
+                }
                 extra_index += body_len - 2;
                 const store_inst = scalar_cases_payload.items[extra_index];
-                if (zir_tags[store_inst] == .store_to_block_ptr) {
+                if (zir_tags[store_inst] != .store_to_block_ptr) {
-                    assert(zir_datas[store_inst].bin.lhs == block_scope.rl_ptr);
+                    extra_index += 2;
-                    scalar_cases_payload.items[body_len_index] -= 1;
                     astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[0..extra_index]);
+                    break :special_prong;
+                }
+                assert(zir_datas[store_inst].bin.lhs == block_scope.rl_ptr);
+                if (block_scope.rl_ty_inst != .none) {
                     extra_index += 1;
-                    astgen.extra.appendAssumeCapacity(scalar_cases_payload.items[extra_index]);
+                    const break_inst = scalar_cases_payload.items[extra_index];
                     extra_index += 1;
+                    astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[0..extra_index]);
+                    zir_tags[store_inst] = .as;
+                    zir_datas[store_inst].bin = .{
+                        .lhs = block_scope.rl_ty_inst,
+                        .rhs = zir_datas[break_inst].@"break".operand,
+                    };
+                    zir_datas[break_inst].@"break".operand = astgen.indexToRef(store_inst);
                 } else {
-                    extra_index += 2;
+                    scalar_cases_payload.items[body_len_index] -= 1;
                     astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[0..extra_index]);
+                    extra_index += 1;
+                    astgen.extra.appendAssumeCapacity(scalar_cases_payload.items[extra_index]);
+                    extra_index += 1;
                 }
             } else {
                 astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[0..extra_index]);
 @@ -3066,16 +3083,29 @@ fn switchExpr(
                 }
                 extra_index += body_len - 2;
                 const store_inst = scalar_cases_payload.items[extra_index];
-                if (zir_tags[store_inst] == .store_to_block_ptr) {
+                if (zir_tags[store_inst] != .store_to_block_ptr) {
+                    extra_index += 2;
+                    astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[start_index..extra_index]);
+                    continue;
+                }
+                if (block_scope.rl_ty_inst != .none) {
+                    extra_index += 1;
+                    const break_inst = scalar_cases_payload.items[extra_index];
+                    extra_index += 1;
+                    astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[start_index..extra_index]);
+                    zir_tags[store_inst] = .as;
+                    zir_datas[store_inst].bin = .{
+                        .lhs = block_scope.rl_ty_inst,
+                        .rhs = zir_datas[break_inst].@"break".operand,
+                    };
+                    zir_datas[break_inst].@"break".operand = astgen.indexToRef(store_inst);
+                } else {
                     assert(zir_datas[store_inst].bin.lhs == block_scope.rl_ptr);
                     scalar_cases_payload.items[body_len_index] -= 1;
                     astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[start_index..extra_index]);
                     extra_index += 1;
                     astgen.extra.appendAssumeCapacity(scalar_cases_payload.items[extra_index]);
                     extra_index += 1;
-                } else {
-                    extra_index += 2;
-                    astgen.extra.appendSliceAssumeCapacity(scalar_cases_payload.items[start_index..extra_index]);
                 }
             }
             extra_index = 0;
 @@ -3098,16 +3128,29 @@ fn switchExpr(
                 }
                 extra_index += body_len - 2;
                 const store_inst = multi_cases_payload.items[extra_index];
-                if (zir_tags[store_inst] == .store_to_block_ptr) {
+                if (zir_tags[store_inst] != .store_to_block_ptr) {
+                    extra_index += 2;
+                    astgen.extra.appendSliceAssumeCapacity(multi_cases_payload.items[start_index..extra_index]);
+                    continue;
+                }
+                if (block_scope.rl_ty_inst != .none) {
+                    extra_index += 1;
+                    const break_inst = multi_cases_payload.items[extra_index];
+                    extra_index += 1;
+                    astgen.extra.appendSliceAssumeCapacity(multi_cases_payload.items[start_index..extra_index]);
+                    zir_tags[store_inst] = .as;
+                    zir_datas[store_inst].bin = .{
+                        .lhs = block_scope.rl_ty_inst,
+                        .rhs = zir_datas[break_inst].@"break".operand,
+                    };
+                    zir_datas[break_inst].@"break".operand = astgen.indexToRef(store_inst);
+                } else {
                     assert(zir_datas[store_inst].bin.lhs == block_scope.rl_ptr);
                     multi_cases_payload.items[body_len_index] -= 1;
                     astgen.extra.appendSliceAssumeCapacity(multi_cases_payload.items[start_index..extra_index]);
                     extra_index += 1;
                     astgen.extra.appendAssumeCapacity(multi_cases_payload.items[extra_index]);
                     extra_index += 1;
-                } else {
-                    extra_index += 2;
-                    astgen.extra.appendSliceAssumeCapacity(multi_cases_payload.items[start_index..extra_index]);
                 }
             }

src/Module.zig+8-1

src/Sema.zig+88-82

 @@ -4104,102 +4104,108 @@ fn coerce(
     }
     assert(inst.ty.zigTypeTag() != .Undefined);
-    // null to ?T
-    if (dest_type.zigTypeTag() == .Optional and inst.ty.zigTypeTag() == .Null) {
-        return sema.mod.constInst(sema.arena, inst_src, .{ .ty = dest_type, .val = Value.initTag(.null_value) });
-    }
-    // T to ?T
-    if (dest_type.zigTypeTag() == .Optional) {
-        var buf: Type.Payload.ElemType = undefined;
-        const child_type = dest_type.optionalChild(&buf);
-        if (child_type.eql(inst.ty)) {
-            return sema.wrapOptional(block, dest_type, inst);
-        } else if (try sema.coerceNum(block, child_type, inst)) |some| {
-            return sema.wrapOptional(block, dest_type, some);
-        }
-    }
     // T to E!T or E to E!T
     if (dest_type.tag() == .error_union) {
         return try sema.wrapErrorUnion(block, dest_type, inst);
     }
-    // Coercions where the source is a single pointer to an array.
-    src_array_ptr: {
-        if (!inst.ty.isSinglePointer()) break :src_array_ptr;
-        const array_type = inst.ty.elemType();
-        if (array_type.zigTypeTag() != .Array) break :src_array_ptr;
-        const array_elem_type = array_type.elemType();
-        if (inst.ty.isConstPtr() and !dest_type.isConstPtr()) break :src_array_ptr;
-        if (inst.ty.isVolatilePtr() and !dest_type.isVolatilePtr()) break :src_array_ptr;
-        const dst_elem_type = dest_type.elemType();
-        switch (coerceInMemoryAllowed(dst_elem_type, array_elem_type)) {
-            .ok => {},
-            .no_match => break :src_array_ptr,
-        }
-        switch (dest_type.ptrSize()) {
-            .Slice => {
-                // *[N]T to []T
-                return sema.coerceArrayPtrToSlice(block, dest_type, inst);
-            },
-            .C => {
-                // *[N]T to [*c]T
-                return sema.coerceArrayPtrToMany(block, dest_type, inst);
-            },
-            .Many => {
-                // *[N]T to [*]T
-                // *[N:s]T to [*:s]T
-                const src_sentinel = array_type.sentinel();
-                const dst_sentinel = dest_type.sentinel();
-                if (src_sentinel == null and dst_sentinel == null)
-                    return sema.coerceArrayPtrToMany(block, dest_type, inst);
-                if (src_sentinel) |src_s| {
-                    if (dst_sentinel) |dst_s| {
-                        if (src_s.eql(dst_s)) {
-                            return sema.coerceArrayPtrToMany(block, dest_type, inst);
-                        }
-                    }
-                }
-            },
-            .One => {},
-        }
-    }
     // comptime known number to other number
     if (try sema.coerceNum(block, dest_type, inst)) |some|
         return some;
     const target = sema.mod.getTarget();
-    // integer widening
+    switch (dest_type.zigTypeTag()) {
-    if (inst.ty.zigTypeTag() == .Int and dest_type.zigTypeTag() == .Int) {
+        .Optional => {
-        assert(inst.value() == null); // handled above
+            // null to ?T
+            if (inst.ty.zigTypeTag() == .Null) {
+                return sema.mod.constInst(sema.arena, inst_src, .{ .ty = dest_type, .val = Value.initTag(.null_value) });
+            }
-        const src_info = inst.ty.intInfo(target);
+            // T to ?T
-        const dst_info = dest_type.intInfo(target);
+            var buf: Type.Payload.ElemType = undefined;
-        if ((src_info.signedness == dst_info.signedness and dst_info.bits >= src_info.bits) or
+            const child_type = dest_type.optionalChild(&buf);
-            // small enough unsigned ints can get casted to large enough signed ints
+            if (child_type.eql(inst.ty)) {
-            (src_info.signedness == .signed and dst_info.signedness == .unsigned and dst_info.bits > src_info.bits))
+                return sema.wrapOptional(block, dest_type, inst);
-        {
+            } else if (try sema.coerceNum(block, child_type, inst)) |some| {
-            try sema.requireRuntimeBlock(block, inst_src);
+                return sema.wrapOptional(block, dest_type, some);
-            return block.addUnOp(inst_src, dest_type, .intcast, inst);
+            }
-        }
+        },
-    }
+        .Pointer => {
+            // Coercions where the source is a single pointer to an array.
+            src_array_ptr: {
+                if (!inst.ty.isSinglePointer()) break :src_array_ptr;
+                const array_type = inst.ty.elemType();
+                if (array_type.zigTypeTag() != .Array) break :src_array_ptr;
+                const array_elem_type = array_type.elemType();
+                if (inst.ty.isConstPtr() and !dest_type.isConstPtr()) break :src_array_ptr;
+                if (inst.ty.isVolatilePtr() and !dest_type.isVolatilePtr()) break :src_array_ptr;
+                const dst_elem_type = dest_type.elemType();
+                switch (coerceInMemoryAllowed(dst_elem_type, array_elem_type)) {
+                    .ok => {},
+                    .no_match => break :src_array_ptr,
+                }
-    // float widening
+                switch (dest_type.ptrSize()) {
-    if (inst.ty.zigTypeTag() == .Float and dest_type.zigTypeTag() == .Float) {
+                    .Slice => {
-        assert(inst.value() == null); // handled above
+                        // *[N]T to []T
+                        return sema.coerceArrayPtrToSlice(block, dest_type, inst);
+                    },
+                    .C => {
+                        // *[N]T to [*c]T
+                        return sema.coerceArrayPtrToMany(block, dest_type, inst);
+                    },
+                    .Many => {
+                        // *[N]T to [*]T
+                        // *[N:s]T to [*:s]T
+                        const src_sentinel = array_type.sentinel();
+                        const dst_sentinel = dest_type.sentinel();
+                        if (src_sentinel == null and dst_sentinel == null)
+                            return sema.coerceArrayPtrToMany(block, dest_type, inst);
-        const src_bits = inst.ty.floatBits(target);
+                        if (src_sentinel) |src_s| {
-        const dst_bits = dest_type.floatBits(target);
+                            if (dst_sentinel) |dst_s| {
-        if (dst_bits >= src_bits) {
+                                if (src_s.eql(dst_s)) {
-            try sema.requireRuntimeBlock(block, inst_src);
+                                    return sema.coerceArrayPtrToMany(block, dest_type, inst);
-            return block.addUnOp(inst_src, dest_type, .floatcast, inst);
+                                }
-        }
+                            }
+                        }
+                    },
+                    .One => {},
+                }
+            }
+        },
+        .Int => {
+            // integer widening
+            if (inst.ty.zigTypeTag() == .Int) {
+                assert(inst.value() == null); // handled above
+                const dst_info = dest_type.intInfo(target);
+                const src_info = inst.ty.intInfo(target);
+                if ((src_info.signedness == dst_info.signedness and dst_info.bits >= src_info.bits) or
+                    // small enough unsigned ints can get casted to large enough signed ints
+                    (src_info.signedness == .signed and dst_info.signedness == .unsigned and dst_info.bits > src_info.bits))
+                {
+                    try sema.requireRuntimeBlock(block, inst_src);
+                    return block.addUnOp(inst_src, dest_type, .intcast, inst);
+                }
+            }
+        },
+        .Float => {
+            // float widening
+            if (inst.ty.zigTypeTag() == .Float) {
+                assert(inst.value() == null); // handled above
+                const src_bits = inst.ty.floatBits(target);
+                const dst_bits = dest_type.floatBits(target);
+                if (dst_bits >= src_bits) {
+                    try sema.requireRuntimeBlock(block, inst_src);
+                    return block.addUnOp(inst_src, dest_type, .floatcast, inst);
+                }
+            }
+        },
+        else => {},
     }
     return sema.mod.fail(&block.base, inst_src, "expected {}, found {}", .{ dest_type, inst.ty });

test/stage2/cbe.zig+66

...	@@ -279,6 +279,72 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -279,6 +279,72 @@ pub fn addCases(ctx: *TestContext) !void {
279	\\ return a - 4;	279	\\ return a - 4;
280	\\}	280	\\}
281	, "");	281	, "");
		282
		283	// Switch expression missing else case.
		284	case.addError(
		285	\\export fn main() c_int {
		286	\\ var cond: c_int = 0;
		287	\\ const a: c_int = switch (cond) {
		288	\\ 1 => 1,
		289	\\ 2 => 2,
		290	\\ 3 => 3,
		291	\\ 4 => 4,
		292	\\ };
		293	\\ return a - 4;
		294	\\}
		295	, &.{":3:22: error: switch must handle all possibilities"});
		296
		297	// Switch expression, has an unreachable prong.
		298	case.addCompareOutput(
		299	\\export fn main() c_int {
		300	\\ var cond: c_int = 0;
		301	\\ const a: c_int = switch (cond) {
		302	\\ 1 => 1,
		303	\\ 2 => 2,
		304	\\ 99...300, 12 => 3,
		305	\\ 0 => 4,
		306	\\ 13 => unreachable,
		307	\\ else => 5,
		308	\\ };
		309	\\ return a - 4;
		310	\\}
		311	, "");
		312
		313	// Switch expression, has an unreachable prong and prongs write
		314	// to result locations.
		315	case.addCompareOutput(
		316	\\export fn main() c_int {
		317	\\ var cond: c_int = 0;
		318	\\ var a: c_int = switch (cond) {
		319	\\ 1 => 1,
		320	\\ 2 => 2,
		321	\\ 99...300, 12 => 3,
		322	\\ 0 => 4,
		323	\\ 13 => unreachable,
		324	\\ else => 5,
		325	\\ };
		326	\\ return a - 4;
		327	\\}
		328	, "");
		329
		330	// Switch expression has duplicate case value.
		331	case.addError(
		332	\\export fn main() c_int {
		333	\\ var cond: c_int = 0;
		334	\\ const a: c_int = switch (cond) {
		335	\\ 1 => 1,
		336	\\ 2 => 2,
		337	\\ 96, 11...13, 97 => 3,
		338	\\ 0 => 4,
		339	\\ 90, 12 => 100,
		340	\\ else => 5,
		341	\\ };
		342	\\ return a - 4;
		343	\\}
		344	, &.{
		345	":8:13: error: duplicate switch value",
		346	":6:15: note: previous value here",
		347	});
282	}	348	}
283	//{	349	//{
284	// var case = ctx.exeFromCompiledC("optionals", .{});	350	// var case = ctx.exeFromCompiledC("optionals", .{});

...	@@ -942,6 +942,8 @@ pub const Scope = struct {	...	@@ -942,6 +942,8 @@ pub const Scope = struct {
942	break_result_loc: AstGen.ResultLoc = undefined,	942	break_result_loc: AstGen.ResultLoc = undefined,
943	/// When a block has a pointer result location, here it is.	943	/// When a block has a pointer result location, here it is.
944	rl_ptr: zir.Inst.Ref = .none,	944	rl_ptr: zir.Inst.Ref = .none,
		945	/// When a block has a type result location, here it is.
		946	rl_ty_inst: zir.Inst.Ref = .none,
945	/// Keeps track of how many branches of a block did not actually	947	/// Keeps track of how many branches of a block did not actually
946	/// consume the result location. astgen uses this to figure out	948	/// consume the result location. astgen uses this to figure out
947	/// whether to rely on break instructions or writing to the result	949	/// whether to rely on break instructions or writing to the result
...	@@ -1001,7 +1003,11 @@ pub const Scope = struct {	...	@@ -1001,7 +1003,11 @@ pub const Scope = struct {
1001	// we emit ZIR for the block break instructions to have the result values,	1003	// we emit ZIR for the block break instructions to have the result values,
1002	// and then rvalue() on that to pass the value to the result location.	1004	// and then rvalue() on that to pass the value to the result location.
1003	switch (parent_rl) {	1005	switch (parent_rl) {
1004	.discard, .none, .ty, .ptr, .ref => {	1006	.ty => \|ty_inst\| {
		1007	gz.rl_ty_inst = ty_inst;
		1008	gz.break_result_loc = parent_rl;
		1009	},
		1010	.discard, .none, .ptr, .ref => {
1005	gz.break_result_loc = parent_rl;	1011	gz.break_result_loc = parent_rl;
1006	},	1012	},
1007		1013
...	@@ -1016,6 +1022,7 @@ pub const Scope = struct {	...	@@ -1016,6 +1022,7 @@ pub const Scope = struct {
1016	},	1022	},
1017		1023
1018	.block_ptr => \|parent_block_scope\| {	1024	.block_ptr => \|parent_block_scope\| {
		1025	gz.rl_ty_inst = parent_block_scope.rl_ty_inst;
1019	gz.rl_ptr = parent_block_scope.rl_ptr;	1026	gz.rl_ptr = parent_block_scope.rl_ptr;
1020	gz.break_result_loc = .{ .block_ptr = gz };	1027	gz.break_result_loc = .{ .block_ptr = gz };
1021	},	1028	},