Commit f4666678886c2a7a993ad30b63de4ff25594085a | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-11-29 13:40:57-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-11-29 23:30:38-07:00
log	f4666678886c2a7a993ad30b63de4ff25594085a
tree	45cbb5b3ebbe23a46e27b04aa5898a6c00ec4a61
parent	ceb0a632cfd6a4eada6bd27bf6a3754e95dcac86

stage2: fix crash on comptime lazy `@ctz` and `@clz`

3 files changed, 43 insertions(+), 24 deletions(-)

lib
- std
  - math
    big
    int.zig
src
- Sema.zig
- value.zig

lib/std/math/big/int.zig+28

...	@@ -2376,6 +2376,34 @@ pub const Const = struct {	...	@@ -2376,6 +2376,34 @@ pub const Const = struct {
2376	pub fn eq(a: Const, b: Const) bool {	2376	pub fn eq(a: Const, b: Const) bool {
2377	return order(a, b) == .eq;	2377	return order(a, b) == .eq;
2378	}	2378	}
		2379
		2380	pub fn clz(a: Const, bits: Limb) Limb {
		2381	// Limbs are stored in little-endian order but we need
		2382	// to iterate big-endian.
		2383	var total_limb_lz: Limb = 0;
		2384	var i: usize = a.limbs.len;
		2385	const bits_per_limb = @sizeOf(Limb) * 8;
		2386	while (i != 0) {
		2387	i -= 1;
		2388	const limb = a.limbs[i];
		2389	const this_limb_lz = @clz(limb);
		2390	total_limb_lz += this_limb_lz;
		2391	if (this_limb_lz != bits_per_limb) break;
		2392	}
		2393	const total_limb_bits = a.limbs.len * bits_per_limb;
		2394	return total_limb_lz + bits - total_limb_bits;
		2395	}
		2396
		2397	pub fn ctz(a: Const) Limb {
		2398	// Limbs are stored in little-endian order.
		2399	var result: Limb = 0;
		2400	for (a.limbs) \|limb\| {
		2401	const limb_tz = @ctz(limb);
		2402	result += limb_tz;
		2403	if (limb_tz != @sizeOf(Limb) * 8) break;
		2404	}
		2405	return result;
		2406	}
2379	};	2407	};
2380		2408
2381	/// An arbitrary-precision big integer along with an allocator which manages the memory.	2409	/// An arbitrary-precision big integer along with an allocator which manages the memory.

src/Sema.zig+1

...	@@ -19299,6 +19299,7 @@ fn zirBitCount(	...	@@ -19299,6 +19299,7 @@ fn zirBitCount(
19299	.Int => {	19299	.Int => {
19300	if (try sema.resolveMaybeUndefVal(operand)) \|val\| {	19300	if (try sema.resolveMaybeUndefVal(operand)) \|val\| {
19301	if (val.isUndef()) return sema.addConstUndef(result_scalar_ty);	19301	if (val.isUndef()) return sema.addConstUndef(result_scalar_ty);
		19302	try sema.resolveLazyValue(val);
19302	return sema.addIntUnsigned(result_scalar_ty, comptimeOp(val, operand_ty, target));	19303	return sema.addIntUnsigned(result_scalar_ty, comptimeOp(val, operand_ty, target));
19303	} else {	19304	} else {
19304	try sema.requireRuntimeBlock(block, src, operand_src);	19305	try sema.requireRuntimeBlock(block, src, operand_src);

src/value.zig+14-24

 @@ -1677,22 +1677,8 @@ pub const Value = extern union {
                 @panic("TODO implement i64 Value clz");
             },
             .int_big_positive => {
-                // TODO: move this code into std lib big ints
                 const bigint = val.castTag(.int_big_positive).?.asBigInt();
-                // Limbs are stored in little-endian order but we need
+                return bigint.clz(ty_bits);
-                // to iterate big-endian.
-                var total_limb_lz: u64 = 0;
-                var i: usize = bigint.limbs.len;
-                const bits_per_limb = @sizeOf(std.math.big.Limb) * 8;
-                while (i != 0) {
-                    i -= 1;
-                    const limb = bigint.limbs[i];
-                    const this_limb_lz = @clz(limb);
-                    total_limb_lz += this_limb_lz;
-                    if (this_limb_lz != bits_per_limb) break;
-                }
-                const total_limb_bits = bigint.limbs.len * bits_per_limb;
-                return total_limb_lz + ty_bits - total_limb_bits;
             },
             .int_big_negative => {
                 @panic("TODO implement int_big_negative Value clz");
 @@ -1703,6 +1689,12 @@ pub const Value = extern union {
                 return ty_bits;
             },
+            .lazy_align, .lazy_size => {
+                var bigint_buf: BigIntSpace = undefined;
+                const bigint = val.toBigIntAdvanced(&bigint_buf, target, null) catch unreachable;
+                return bigint.clz(ty_bits);
+            },
             else => unreachable,
         }
     }
 @@ -1721,16 +1713,8 @@ pub const Value = extern union {
                 @panic("TODO implement i64 Value ctz");
             },
             .int_big_positive => {
-                // TODO: move this code into std lib big ints
                 const bigint = val.castTag(.int_big_positive).?.asBigInt();
-                // Limbs are stored in little-endian order.
+                return bigint.ctz();
-                var result: u64 = 0;
-                for (bigint.limbs) |limb| {
-                    const limb_tz = @ctz(limb);
-                    result += limb_tz;
-                    if (limb_tz != @sizeOf(std.math.big.Limb) * 8) break;
-                }
-                return result;
             },
             .int_big_negative => {
                 @panic("TODO implement int_big_negative Value ctz");
 @@ -1741,6 +1725,12 @@ pub const Value = extern union {
                 return ty_bits;
             },
+            .lazy_align, .lazy_size => {
+                var bigint_buf: BigIntSpace = undefined;
+                const bigint = val.toBigIntAdvanced(&bigint_buf, target, null) catch unreachable;
+                return bigint.ctz();
+            },
             else => unreachable,
         }
     }