Commit 2f05b1482a6f62658cc70c252d48a24a40404aa8 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-05-05 14:57:23-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-06-10 20:42:28-07:00
log	2f05b1482a6f62658cc70c252d48a24a40404aa8
tree	17384a9a13b9cb993918ded8c83b8d7a123e6b47
parent	ac07ddadeb36019c262b4f28a4fa3884f6f50b32

Sema: update core comptime detection logic to be InternPool aware

 * Add some assertions to make sure instructions are not none. I tested
   all these with master branch as well and made sure the behavior tests
   still passed with the assertions intact (along with a handful of
   callsite updates).
 * Fix Sema.resolveMaybeUndefValAllowVariablesMaybeRuntime not noticing
   that interned values are comptime-known. This was causing all kinds
   of chaos.
 * Fix print_air writeType calling tag() without checking for ip_index

6 files changed, 47 insertions(+), 28 deletions(-)

src
- Air.zig
- Liveness.zig
- Liveness
  - Verify.zig
- Sema.zig
- Zir.zig
- print_air.zig

src/Air.zig+11-5

 @@ -925,7 +925,7 @@ pub const Inst = struct {
         /// This Ref does not correspond to any AIR instruction or constant
         /// value and may instead be used as a sentinel to indicate null.
-        none = std.math.maxInt(u32),
+        none = @enumToInt(InternPool.Index.none),
         _,
     };
 @@ -1461,11 +1461,12 @@ pub fn deinit(air: *Air, gpa: std.mem.Allocator) void {
 pub const ref_start_index: u32 = InternPool.static_len;
-pub fn indexToRef(inst: Air.Inst.Index) Air.Inst.Ref {
+pub fn indexToRef(inst: Inst.Index) Inst.Ref {
-    return @intToEnum(Air.Inst.Ref, ref_start_index + inst);
+    return @intToEnum(Inst.Ref, ref_start_index + inst);
 }
-pub fn refToIndex(inst: Air.Inst.Ref) ?Air.Inst.Index {
+pub fn refToIndex(inst: Inst.Ref) ?Inst.Index {
+    assert(inst != .none);
     const ref_int = @enumToInt(inst);
     if (ref_int >= ref_start_index) {
         return ref_int - ref_start_index;
 @@ -1474,8 +1475,13 @@ pub fn refToIndex(inst: Air.Inst.Ref) ?Air.Inst.Index {
     }
 }
+pub fn refToIndexAllowNone(inst: Inst.Ref) ?Inst.Index {
+    if (inst == .none) return null;
+    return refToIndex(inst);
+}
 /// Returns `null` if runtime-known.
-pub fn value(air: Air, inst: Air.Inst.Ref, mod: *const Module) ?Value {
+pub fn value(air: Air, inst: Inst.Ref, mod: *const Module) ?Value {
     const ref_int = @enumToInt(inst);
     if (ref_int < ref_start_index) {
         const ip_index = @intToEnum(InternPool.Index, ref_int);

src/Liveness.zig+2-2

...	@@ -1268,7 +1268,7 @@ fn analyzeOperands(	...	@@ -1268,7 +1268,7 @@ fn analyzeOperands(
1268	_ = data.live_set.remove(inst);	1268	_ = data.live_set.remove(inst);
1269		1269
1270	for (operands) \|op_ref\| {	1270	for (operands) \|op_ref\| {
1271	const operand = Air.refToIndex(op_ref) orelse continue;	1271	const operand = Air.refToIndexAllowNone(op_ref) orelse continue;
1272		1272
1273	// Don't compute any liveness for constants	1273	// Don't compute any liveness for constants
1274	switch (inst_tags[operand]) {	1274	switch (inst_tags[operand]) {
...	@@ -1304,7 +1304,7 @@ fn analyzeOperands(	...	@@ -1304,7 +1304,7 @@ fn analyzeOperands(
1304	while (i > 0) {	1304	while (i > 0) {
1305	i -= 1;	1305	i -= 1;
1306	const op_ref = operands[i];	1306	const op_ref = operands[i];
1307	const operand = Air.refToIndex(op_ref) orelse continue;	1307	const operand = Air.refToIndexAllowNone(op_ref) orelse continue;
1308		1308
1309	// Don't compute any liveness for constants	1309	// Don't compute any liveness for constants
1310	switch (inst_tags[operand]) {	1310	switch (inst_tags[operand]) {

src/Liveness/Verify.zig+1-1

...	@@ -555,7 +555,7 @@ fn verifyDeath(self: *Verify, inst: Air.Inst.Index, operand: Air.Inst.Index) Err	...	@@ -555,7 +555,7 @@ fn verifyDeath(self: *Verify, inst: Air.Inst.Index, operand: Air.Inst.Index) Err
555	}	555	}
556		556
557	fn verifyOperand(self: *Verify, inst: Air.Inst.Index, op_ref: Air.Inst.Ref, dies: bool) Error!void {	557	fn verifyOperand(self: *Verify, inst: Air.Inst.Index, op_ref: Air.Inst.Ref, dies: bool) Error!void {
558	const operand = Air.refToIndex(op_ref) orelse return;	558	const operand = Air.refToIndexAllowNone(op_ref) orelse return;
559	switch (self.air.instructions.items(.tag)[operand]) {	559	switch (self.air.instructions.items(.tag)[operand]) {
560	.constant, .const_ty, .interned => {},	560	.constant, .const_ty, .interned => {},
561	else => {	561	else => {

src/Sema.zig+19-14

 @@ -968,7 +968,7 @@ fn analyzeBodyInner(
             .int_big                      => try sema.zirIntBig(block, inst),
             .float                        => try sema.zirFloat(block, inst),
             .float128                     => try sema.zirFloat128(block, inst),
-            .int_type                     => try sema.zirIntType(block, inst),
+            .int_type                     => try sema.zirIntType(inst),
             .is_non_err                   => try sema.zirIsNonErr(block, inst),
             .is_non_err_ptr               => try sema.zirIsNonErrPtr(block, inst),
             .ret_is_non_err               => try sema.zirRetIsNonErr(block, inst),
 @@ -1694,7 +1694,7 @@ fn analyzeBodyInner(
                 const extra = sema.code.extraData(Zir.Inst.DeferErrCode, inst_data.payload_index).data;
                 const defer_body = sema.code.extra[extra.index..][0..extra.len];
                 const err_code = try sema.resolveInst(inst_data.err_code);
-                sema.inst_map.putAssumeCapacity(extra.remapped_err_code, err_code);
+                map.putAssumeCapacity(extra.remapped_err_code, err_code);
                 const break_inst = sema.analyzeBodyInner(block, defer_body) catch |err| switch (err) {
                     error.ComptimeBreak => sema.comptime_break_inst,
                     else => |e| return e,
 @@ -1730,7 +1730,16 @@ fn analyzeBodyInner(
     return result;
 }
+pub fn resolveInstAllowNone(sema: *Sema, zir_ref: Zir.Inst.Ref) !Air.Inst.Ref {
+    if (zir_ref == .none) {
+        return .none;
+    } else {
+        return resolveInst(sema, zir_ref);
+    }
+}
 pub fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) !Air.Inst.Ref {
+    assert(zir_ref != .none);
     const i = @enumToInt(zir_ref);
     // First section of indexes correspond to a set number of constant values.
     // We intentionally map the same indexes to the same values between ZIR and AIR.
 @@ -1969,6 +1978,7 @@ fn resolveMaybeUndefValAllowVariablesMaybeRuntime(
     inst: Air.Inst.Ref,
     make_runtime: *bool,
 ) CompileError!?Value {
+    assert(inst != .none);
     // First section of indexes correspond to a set number of constant values.
     const int = @enumToInt(inst);
     if (int < InternPool.static_len) {
 @@ -1985,17 +1995,17 @@ fn resolveMaybeUndefValAllowVariablesMaybeRuntime(
         }
         return opv;
     }
+    const air_datas = sema.air_instructions.items(.data);
     switch (air_tags[i]) {
         .constant => {
-            const ty_pl = sema.air_instructions.items(.data)[i].ty_pl;
+            const ty_pl = air_datas[i].ty_pl;
             const val = sema.air_values.items[ty_pl.payload];
             if (val.tag() == .runtime_value) make_runtime.* = true;
             if (val.isPtrToThreadLocal(sema.mod)) make_runtime.* = true;
             return val;
         },
-        .const_ty => {
+        .const_ty => return try air_datas[i].ty.toValue(sema.arena),
-            return try sema.air_instructions.items(.data)[i].ty.toValue(sema.arena);
+        .interned => return air_datas[i].interned.toValue(),
-        },
         else => return null,
     }
 }
 @@ -7913,15 +7923,10 @@ fn emitDbgInline(
     });
 }
-fn zirIntType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirIntType(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    _ = block;
-    const tracy = trace(@src());
-    defer tracy.end();
     const mod = sema.mod;
     const int_type = sema.code.instructions.items(.data)[inst].int_type;
     const ty = try mod.intType(int_type.signedness, int_type.bit_count);
     return sema.addType(ty);
 }
 @@ -17509,7 +17514,7 @@ fn zirRestoreErrRetIndex(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index)
     const tracy = trace(@src());
     defer tracy.end();
-    const saved_index = if (Zir.refToIndex(inst_data.block)) |zir_block| b: {
+    const saved_index = if (Zir.refToIndexAllowNone(inst_data.block)) |zir_block| b: {
         var block = start_block;
         while (true) {
             if (block.label) |label| {
 @@ -17535,7 +17540,7 @@ fn zirRestoreErrRetIndex(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index)
     assert(saved_index != .none); // The .error_return_trace_index field was dropped somewhere
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = try sema.resolveInstAllowNone(inst_data.operand);
     return sema.popErrorReturnTrace(start_block, src, operand, saved_index);
 }

src/Zir.zig+8-2

 @@ -2132,7 +2132,7 @@ pub const Inst = struct {
         /// This Ref does not correspond to any ZIR instruction or constant
         /// value and may instead be used as a sentinel to indicate null.
-        none = std.math.maxInt(u32),
+        none = @enumToInt(InternPool.Index.none),
         _,
     };
 @@ -3814,13 +3814,14 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
     };
 }
-const ref_start_index: u32 = InternPool.static_len;
+pub const ref_start_index: u32 = InternPool.static_len;
 pub fn indexToRef(inst: Inst.Index) Inst.Ref {
     return @intToEnum(Inst.Ref, ref_start_index + inst);
 }
 pub fn refToIndex(inst: Inst.Ref) ?Inst.Index {
+    assert(inst != .none);
     const ref_int = @enumToInt(inst);
     if (ref_int >= ref_start_index) {
         return ref_int - ref_start_index;
 @@ -3828,3 +3829,8 @@ pub fn refToIndex(inst: Inst.Ref) ?Inst.Index {
         return null;
     }
 }
+pub fn refToIndexAllowNone(inst: Inst.Ref) ?Inst.Index {
+    if (inst == .none) return null;
+    return refToIndex(inst);
+}

src/print_air.zig+6-4

 @@ -366,10 +366,12 @@ const Writer = struct {
     }
     fn writeType(w: *Writer, s: anytype, ty: Type) !void {
-        const t = ty.tag();
+        switch (ty.ip_index) {
-        switch (t) {
+            .none => switch (ty.tag()) {
-            .inferred_alloc_const => try s.writeAll("(inferred_alloc_const)"),
+                .inferred_alloc_const => try s.writeAll("(inferred_alloc_const)"),
-            .inferred_alloc_mut => try s.writeAll("(inferred_alloc_mut)"),
+                .inferred_alloc_mut => try s.writeAll("(inferred_alloc_mut)"),
+                else => try ty.print(s, w.module),
+            },
             else => try ty.print(s, w.module),
         }
     }