From efcaf6a72d19c6105b235e45dc79f70023d84ffc Mon Sep 17 00:00:00 2001
From: Pavel Verigo <paul.verigo@gmail.com>
Date: Mon, 6 Jul 2026 12:52:19 +0200
Subject: [PATCH] lib: use @divCeil

---
 lib/compiler/Maker/WebServer.zig |  2 +-
 lib/compiler_rt/limb64.zig       |  3 +--
 lib/compiler_rt/udivmodei4.zig   |  2 +-
 lib/fuzzer.zig                   |  2 +-
 lib/std/Random.zig               |  2 +-
 lib/std/Target.zig               |  2 +-
 lib/std/crypto/aes_gcm.zig       |  4 ++--
 lib/std/crypto/ascon.zig         |  2 +-
 lib/std/crypto/ff.zig            |  6 +++---
 lib/std/crypto/pbkdf2.zig        |  2 +-
 lib/std/crypto/sha2.zig          |  2 +-
 lib/std/crypto/sha3.zig          |  4 ++--
 lib/std/debug.zig                |  2 +-
 lib/std/enums.zig                |  2 +-
 lib/std/hash/auto_hash.zig       |  2 +-
 lib/std/math.zig                 | 17 +++--------------
 lib/std/math/big/int.zig         |  2 +-
 lib/std/mem.zig                  |  6 +++---
 lib/std/zig/AstGen.zig           |  2 +-
 lib/std/zig/Zir.zig              |  2 +-
 20 files changed, 28 insertions(+), 40 deletions(-)

diff --git a/lib/compiler/Maker/WebServer.zig b/lib/compiler/Maker/WebServer.zig
index f77c367f6103724c7990a05c0e3be94a38ecf736..54527c805c35cfc4bdfbeadf27acee68fce8d691 100644
--- a/lib/compiler/Maker/WebServer.zig
+++ b/lib/compiler/Maker/WebServer.zig
@@ -163,7 +163,7 @@ pub fn updateConfiguration(ws: *WebServer, maker: *Maker) !void {
         assert(idx == step_names_trailing.len);
     }
 
-    const step_status_bits = try gpa.alloc(u8, std.math.divCeil(usize, all_steps.len, 4) catch unreachable);
+    const step_status_bits = try gpa.alloc(u8, @divCeil(all_steps.len, 4));
     errdefer gpa.free(step_status_bits);
     @memset(step_status_bits, 0);
 
diff --git a/lib/compiler_rt/limb64.zig b/lib/compiler_rt/limb64.zig
index 56e4bfc817373e3ba1e90c3525f83ee6a99fd995..bfe4c441f0525b2e7f5e858e3fa98f81a2e9c865 100644
--- a/lib/compiler_rt/limb64.zig
+++ b/lib/compiler_rt/limb64.zig
@@ -3,7 +3,6 @@ const testing = std.testing;
 const assert = std.debug.assert;
 const maxInt = std.math.maxInt;
 const minInt = std.math.minInt;
-const divCeil = std.math.divCeil;
 
 const builtin = @import("builtin");
 const compiler_rt = @import("../compiler_rt.zig");
@@ -26,7 +25,7 @@ inline fn limbSet(limbs: []u64, i: usize, value: u64) void {
 }
 
 fn usedLimbCount(bits: u16) u16 {
-    return divCeil(u16, bits, 64) catch unreachable;
+    return @divCeil(bits, 64);
 }
 
 fn limbCount(bits: u16) u16 {
diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig
index 5aa8421bdb920c33c7d0f3a10c32ee9db6c21da0..41ba32cdbef1532de8b77e0f91db4bbf4b39f29a 100644
--- a/lib/compiler_rt/udivmodei4.zig
+++ b/lib/compiler_rt/udivmodei4.zig
@@ -8,7 +8,7 @@ const shl = std.math.shl;
 const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
-const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535
+const max_limbs = @divCeil(65535, 32); // max supported type is u65535
 
 comptime {
     symbol(&__udivei4, "__udivei4");
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index acb23b66c58777bc2a6738081e23fcb52ee3c1d9..d4353db874490765967e47e90aaa923c871f2011 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -52,7 +52,7 @@ var fuzzer: Fuzzer = undefined;
 var current_test_name: ?[]const u8 = null;
 
 fn bitsetUsizes(elems: usize) usize {
-    return math.divCeil(usize, elems, @bitSizeOf(usize)) catch unreachable;
+    return @divCeil(elems, @bitSizeOf(usize));
 }
 
 const Executable = struct {
diff --git a/lib/std/Random.zig b/lib/std/Random.zig
index 7593e9680f9f714d9853275c115acfdbe95d13fb..4ab514844eb2e4ecf485f33beb2085853732a4ff 100644
--- a/lib/std/Random.zig
+++ b/lib/std/Random.zig
@@ -126,7 +126,7 @@ pub fn enumValueWithIndex(r: Random, comptime EnumType: type, comptime Index: ty
 pub fn int(r: Random, comptime T: type) T {
     const bits = @typeInfo(T).int.bits;
     const UnsignedT = @Int(.unsigned, bits);
-    const ceil_bytes = comptime std.math.divCeil(u16, bits, 8) catch unreachable;
+    const ceil_bytes = @divCeil(bits, 8);
     const ByteAlignedT = @Int(.unsigned, ceil_bytes * 8);
 
     var rand_bytes: [ceil_bytes]u8 = undefined;
diff --git a/lib/std/Target.zig b/lib/std/Target.zig
index a75d23ca4d7530da5aaeda2c3f9c5a2056914391..c7a9be7b6dca168c8ab8429c21be6f4caf5e9e47 100644
--- a/lib/std/Target.zig
+++ b/lib/std/Target.zig
@@ -1252,7 +1252,7 @@ pub const Cpu = struct {
             ints: [usize_count]usize,
 
             pub const needed_bit_count = 347;
-            pub const byte_count = (needed_bit_count + 7) / 8;
+            pub const byte_count = @divCeil(needed_bit_count, 8);
             pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize);
             pub const Index = std.math.Log2Int(@Int(.unsigned, usize_count * @bitSizeOf(usize)));
             pub const ShiftInt = std.math.Log2Int(usize);
diff --git a/lib/std/crypto/aes_gcm.zig b/lib/std/crypto/aes_gcm.zig
index 2bc56b8c8ee05c91ef432894030a2c36a84292f9..d4e3e3168571ea55438b295c5be787a7f8e54e0b 100644
--- a/lib/std/crypto/aes_gcm.zig
+++ b/lib/std/crypto/aes_gcm.zig
@@ -39,7 +39,7 @@ fn AesGcm(comptime Aes: anytype) type {
             mem.writeInt(u32, j[nonce_length..][0..4], 1, .big);
             aes.encrypt(&t, &j);
 
-            const block_count = (math.divCeil(usize, ad.len, Ghash.block_length) catch unreachable) + (math.divCeil(usize, c.len, Ghash.block_length) catch unreachable) + 1;
+            const block_count = @divCeil(ad.len, Ghash.block_length) + @divCeil(c.len, Ghash.block_length) + 1;
             var mac = Ghash.initForBlockCount(&h, block_count);
             mac.update(ad);
             mac.pad();
@@ -81,7 +81,7 @@ fn AesGcm(comptime Aes: anytype) type {
             mem.writeInt(u32, j[nonce_length..][0..4], 1, .big);
             aes.encrypt(&t, &j);
 
-            const block_count = (math.divCeil(usize, ad.len, Ghash.block_length) catch unreachable) + (math.divCeil(usize, c.len, Ghash.block_length) catch unreachable) + 1;
+            const block_count = @divCeil(ad.len, Ghash.block_length) + @divCeil(c.len, Ghash.block_length) + 1;
             var mac = Ghash.initForBlockCount(&h, block_count);
             mac.update(ad);
             mac.pad();
diff --git a/lib/std/crypto/ascon.zig b/lib/std/crypto/ascon.zig
index 3142bc0a8972c394be1e927361f8ad162780b040..9d2ac52e83dc500062c93aa4af56cd9b50f11f03 100644
--- a/lib/std/crypto/ascon.zig
+++ b/lib/std/crypto/ascon.zig
@@ -198,7 +198,7 @@ pub fn State(comptime endian: std.builtin.Endian) type {
         ///
         /// Note: Clears complete words that contain the specified byte range
         pub fn clear(self: *Self, from: usize, to: usize) void {
-            @memset(self.st[from / 8 .. (to + 7) / 8], 0);
+            @memset(self.st[from / 8 .. @divCeil(to, 8)], 0);
         }
 
         /// Clear the entire state, disabling compiler optimizations.
diff --git a/lib/std/crypto/ff.zig b/lib/std/crypto/ff.zig
index 796a11e435eed7e956311232b523bf49bf301eb0..bf9584dfa3ad033652130705937972171370669c 100644
--- a/lib/std/crypto/ff.zig
+++ b/lib/std/crypto/ff.zig
@@ -61,14 +61,14 @@ pub fn Uint(comptime max_bits: comptime_int) type {
 
     return struct {
         const Self = @This();
-        const max_limbs_count = math.divCeil(usize, max_bits, t_bits) catch unreachable;
+        const max_limbs_count = @divCeil(max_bits, t_bits);
 
         limbs_buffer: [max_limbs_count]Limb,
         /// The number of active limbs.
         limbs_len: usize,
 
         /// Number of bytes required to serialize an integer.
-        pub const encoded_bytes = math.divCeil(usize, max_bits, 8) catch unreachable;
+        pub const encoded_bytes = @divCeil(max_bits, 8);
 
         /// Constant slice of active limbs.
         fn limbsConst(self: *const Self) []const Limb {
@@ -847,7 +847,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
             }
             var e_normalized = Fe{ .v = e.v.normalize() };
             var buf_: [Fe.encoded_bytes]u8 = undefined;
-            var buf = buf_[0 .. math.divCeil(usize, e_normalized.v.limbs_len * t_bits, 8) catch unreachable];
+            var buf = buf_[0..@divCeil(e_normalized.v.limbs_len * t_bits, 8)];
             e_normalized.toBytes(buf, .little) catch unreachable;
             const leading = @clz(e_normalized.v.limbsConst()[e_normalized.v.limbs_len - carry_bits]);
             buf = buf[0 .. buf.len - leading / 8];
diff --git a/lib/std/crypto/pbkdf2.zig b/lib/std/crypto/pbkdf2.zig
index 88b6cf690dc40107e615ac253bebf5bfa2b25bb4..5e7f45087f3c8fd703700cf4fba2fa7667c30787 100644
--- a/lib/std/crypto/pbkdf2.zig
+++ b/lib/std/crypto/pbkdf2.zig
@@ -74,7 +74,7 @@ pub fn pbkdf2(dk: []u8, password: []const u8, salt: []const u8, rounds: u32, com
     //      block
     //
 
-    const blocks_count = @as(u32, @intCast(std.math.divCeil(usize, dk_len, h_len) catch unreachable));
+    const blocks_count: u32 = @intCast(@divCeil(dk_len, h_len));
     var r = dk_len % h_len;
     if (r == 0) {
         r = h_len;
diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index 78e0bbd7858ff55dbfb62a9cb4bcdb3c58f1b2e8..3c5773af50fc827bc34cd10af4d90185d86f27d7 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -474,7 +474,7 @@ fn Sha2x64(comptime iv: Iv64, digest_bits: comptime_int) type {
     return struct {
         const Self = @This();
         pub const block_length = 128;
-        pub const digest_length = std.math.divCeil(comptime_int, digest_bits, 8) catch unreachable;
+        pub const digest_length = @divCeil(digest_bits, 8);
         pub const Options = struct {};
 
         s: Iv64,
diff --git a/lib/std/crypto/sha3.zig b/lib/std/crypto/sha3.zig
index d5e62904703c71ae685fb4b22b2062fe697179ce..6fe661981ab71fa49906f5998400aa5e1250d48c 100644
--- a/lib/std/crypto/sha3.zig
+++ b/lib/std/crypto/sha3.zig
@@ -58,7 +58,7 @@ pub fn Keccak(comptime f: u11, comptime output_bits: u11, comptime default_delim
         st: State,
 
         /// The output length, in bytes.
-        pub const digest_length = std.math.divCeil(comptime_int, output_bits, 8) catch unreachable;
+        pub const digest_length: comptime_int = @divCeil(output_bits, 8);
         /// The block length, or rate, in bytes.
         pub const block_length = State.rate;
         /// The delimiter can be overwritten in the options.
@@ -464,7 +464,7 @@ pub const NistLengthEncoding = enum {
     /// Encode a length according to NIST SP 800-185.
     pub fn encode(comptime encoding: NistLengthEncoding, len: usize) Length {
         const len_bits = @bitSizeOf(@TypeOf(len)) - @clz(len) + 3;
-        const len_bytes = std.math.divCeil(usize, len_bits, 8) catch unreachable;
+        const len_bytes = @divCeil(len_bits, 8);
 
         var res = Length{ .len = len_bytes + 1 };
         if (encoding == .right) {
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index a8475fdd456a1e604ada80e7f90157e05375cc88..c5d65db7d8261a3be9b5bcdc774b78da68ce8309 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -349,7 +349,7 @@ pub fn dumpHexFallible(t: Io.Terminal, bytes: []const u8) !void {
     var chunks = mem.window(u8, bytes, 16, 16);
     while (chunks.next()) |window| {
         // 1. Print the address.
-        const address = (@intFromPtr(bytes.ptr) + 0x10 * (std.math.divCeil(usize, chunks.index orelse bytes.len, 16) catch unreachable)) - 0x10;
+        const address = (@intFromPtr(bytes.ptr) + 0x10 * @divCeil(chunks.index orelse bytes.len, 16) - 0x10);
         try t.setColor(.dim);
         // We print the address in lowercase and the bytes in uppercase hexadecimal to distinguish them more.
         // Also, make sure all lines are aligned by padding the address.
diff --git a/lib/std/enums.zig b/lib/std/enums.zig
index 10b85ddeeb570510f3b6c93ada06f9bfdcdaa07f..47e0e4d0bb9266e5cd3d6a5ce5409b276e28527a 100644
--- a/lib/std/enums.zig
+++ b/lib/std/enums.zig
@@ -1391,7 +1391,7 @@ test "EnumIndexer non-exhaustive" {
         const max_index: comptime_int = std.math.maxInt(RangedType);
         const number_zero_tag_index: usize = switch (@typeInfo(BackingInt).int.signedness) {
             .unsigned => 0,
-            .signed => std.math.divCeil(comptime_int, max_index, 2) catch unreachable,
+            .signed => @divCeil(max_index, 2),
         };
 
         try testing.expectEqual(E, Indexer.Key);
diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index 2562c5157355aa312b3fdd5a89e652a131035d61..31f565ea93f9440316e11f2656a3d38e0f14475d 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -99,7 +99,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
                 } else {
                     // Take only the part containing the key value, the remaining
                     // bytes are undefined and must not be hashed!
-                    const byte_size = comptime std.math.divCeil(comptime_int, @bitSizeOf(Key), 8) catch unreachable;
+                    const byte_size = @divCeil(@bitSizeOf(Key), 8);
                     @call(.always_inline, Hasher.update, .{ hasher, std.mem.asBytes(&key)[0..byte_size] });
                 }
             },
diff --git a/lib/std/math.zig b/lib/std/math.zig
index ec4f47edc1f0ff887ed728ffb636d363e66dfaad..90ff8a4abdede9f325b77ca143996840f14a3060 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -922,21 +922,10 @@ fn testDivFloor() !void {
 pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T {
     @setRuntimeSafety(false);
     if (denominator == 0) return error.DivisionByZero;
-    const info = @typeInfo(T);
-    switch (info) {
-        .comptime_float, .float => return @ceil(numerator / denominator),
-        .comptime_int, .int => {
-            if (numerator < 0 and denominator < 0) {
-                if (info == .int and numerator == minInt(T) and denominator == -1)
-                    return error.Overflow;
-                return @divFloor(numerator + 1, denominator) + 1;
-            }
-            if (numerator > 0 and denominator > 0)
-                return @divFloor(numerator - 1, denominator) + 1;
-            return @divTrunc(numerator, denominator);
-        },
-        else => @compileError("divCeil unsupported on " ++ @typeName(T)),
+    if (@typeInfo(T) == .int and numerator == minInt(T) and denominator == -1) {
+        return error.Overflow;
     }
+    return @divCeil(numerator, denominator);
 }
 
 test divCeil {
diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index 24d4f36afd80b8db8873492e92e8ceea4d80040b..8765f5de2d1944101a6a5a5fec9acaac473b6c06 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -122,7 +122,7 @@ pub fn calcNonZeroTwosCompLimbCount(bit_count: usize) usize {
 /// Special cases `bit_count == 0` to return 1. Zero-bit integers can only store the value zero
 /// and this big integer implementation stores zero using one limb.
 pub fn calcTwosCompLimbCount(bit_count: usize) usize {
-    return @max(std.math.divCeil(usize, bit_count, @bitSizeOf(Limb)) catch unreachable, 1);
+    return @max(@divCeil(bit_count, @bitSizeOf(Limb)), 1);
 }
 
 /// a + b * c + *carry, sets carry to the overflow bits
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 2e0f3cb0ccee44adabf55ff740bd247ad762a5a6..d2c98e4c58e11a803db66a3da86d46dfb7e40bee 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1937,7 +1937,7 @@ fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T
     const bit_count = @as(usize, @bitSizeOf(T));
     const bit_shift = @as(u3, @intCast(bit_offset % 8));
 
-    const load_size = (bit_count + 7) / 8;
+    const load_size = @divCeil(bit_count, 8);
     const load_tail_bits = @as(u3, @intCast((load_size * 8) - bit_count));
     const LoadInt = @Int(.unsigned, load_size * 8);
 
@@ -1964,9 +1964,9 @@ fn readPackedIntBig(comptime T: type, bytes: []const u8, bit_offset: usize) T {
 
     const bit_count = @as(usize, @bitSizeOf(T));
     const bit_shift = @as(u3, @intCast(bit_offset % 8));
-    const byte_count = (@as(usize, bit_shift) + bit_count + 7) / 8;
+    const byte_count = @divCeil(@as(usize, bit_shift) + bit_count, 8);
 
-    const load_size = (bit_count + 7) / 8;
+    const load_size = @divCeil(bit_count, 8);
     const load_tail_bits = @as(u3, @intCast((load_size * 8) - bit_count));
     const LoadInt = @Int(.unsigned, load_size * 8);
 
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 037a9f766c1a66513173cdd7d0154500362856bd..46aa2fea1231792ad4c8ec64c6f167c9340a0fdd 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -4896,7 +4896,7 @@ fn structDeclInner(
     const field_default_body_lens = try scratch.addOptionalSlice(scan_result.any_field_values, scan_result.fields_len);
     const field_comptime_bits = try scratch.addOptionalSlice(
         scan_result.any_comptime_fields,
-        std.math.divCeil(u32, scan_result.fields_len, 32) catch unreachable,
+        @divCeil(scan_result.fields_len, 32),
     );
     if (field_comptime_bits) |bits| @memset(bits.get(astgen), 0);
 
diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig
index c5fc15d64fb50e09f5b5b809ec1cd6eba314bc70..6e14e5ee9096b1e6ef9f190d6cb5dfd7e23de5a0 100644
--- a/lib/std/zig/Zir.zig
+++ b/lib/std/zig/Zir.zig
@@ -5279,7 +5279,7 @@ pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDe
         break :lens @ptrCast(lens);
     } else null;
     const field_comptime_bits: ?[]const u32 = if (small.any_comptime_fields) bits: {
-        const bits_len = std.math.divCeil(u32, fields_len, 32) catch unreachable;
+        const bits_len = @divCeil(fields_len, 32);
         const bits = zir.extra[extra_index..][0..bits_len];
         extra_index += bits_len;
         break :bits bits;
-- 
2.54.0