authorgravatar for samy2014@free.frsamy007 <samy2014@free.fr> 2025-04-13 21:07:11+02:00
committergravatar for samy2014@free.frsamy007 <samy2014@free.fr> 2025-04-13 21:07:11+02:00
logb635b372498f553dfea16d846fec7c9332c3a61b
tree62d51076ea5e72963327968462b3bf6e49f2aca9
parent4e700fdf8ed01e7fc856e631ceffd6006e6f48df

std.math.big.int: remove setRuntimeSafety

1 files changed, 0 insertions(+), 22 deletions(-)

lib/std/math/big/int.zig-22
......@@ -17,7 +17,6 @@ const Endian = std.builtin.Endian;
1717const Signedness = std.builtin.Signedness;
1818const native_endian = builtin.cpu.arch.endian();
1919
20const debug_safety = false;
2120
2221/// Returns the number of limbs needed to store `scalar`, which must be a
2322/// primitive integer value.
......@@ -92,8 +91,6 @@ pub fn calcTwosCompLimbCount(bit_count: usize) usize {
9291
9392/// a + b * c + *carry, sets carry to the overflow bits
9493pub fn addMulLimbWithCarry(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {
95 @setRuntimeSafety(debug_safety);
96
9794 // ov1[0] = a + *carry
9895 const ov1 = @addWithOverflow(a, carry.*);
9996
......@@ -3277,7 +3274,6 @@ const AccOp = enum {
32773274///
32783275/// The result is computed modulo `r.len`. When `r.len >= a.len + b.len`, no overflow occurs.
32793276fn llmulacc(comptime op: AccOp, opt_allocator: ?Allocator, r: []Limb, a: []const Limb, b: []const Limb) void {
3280 @setRuntimeSafety(debug_safety);
32813277 assert(r.len >= a.len);
32823278 assert(r.len >= b.len);
32833279
......@@ -3316,7 +3312,6 @@ fn llmulaccKaratsuba(
33163312 a: []const Limb,
33173313 b: []const Limb,
33183314) error{OutOfMemory}!void {
3319 @setRuntimeSafety(debug_safety);
33203315 assert(r.len >= a.len);
33213316 assert(a.len >= b.len);
33223317
......@@ -3479,7 +3474,6 @@ fn llmulaccKaratsuba(
34793474/// r = r (op) a.
34803475/// The result is computed modulo `r.len`.
34813476fn llaccum(comptime op: AccOp, r: []Limb, a: []const Limb) void {
3482 @setRuntimeSafety(debug_safety);
34833477 if (op == .sub) {
34843478 _ = llsubcarry(r, r, a);
34853479 return;
......@@ -3508,7 +3502,6 @@ fn llaccum(comptime op: AccOp, r: []Limb, a: []const Limb) void {
35083502
35093503/// Returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively for limbs.
35103504pub fn llcmp(a: []const Limb, b: []const Limb) i8 {
3511 @setRuntimeSafety(debug_safety);
35123505 const a_len = llnormalize(a);
35133506 const b_len = llnormalize(b);
35143507 if (a_len < b_len) {
......@@ -3537,7 +3530,6 @@ pub fn llcmp(a: []const Limb, b: []const Limb) i8 {
35373530/// r = r (op) y * xi
35383531/// The result is computed modulo `r.len`. When `r.len >= a.len + b.len`, no overflow occurs.
35393532fn llmulaccLong(comptime op: AccOp, r: []Limb, a: []const Limb, b: []const Limb) void {
3540 @setRuntimeSafety(debug_safety);
35413533 assert(r.len >= a.len);
35423534 assert(a.len >= b.len);
35433535
......@@ -3551,7 +3543,6 @@ fn llmulaccLong(comptime op: AccOp, r: []Limb, a: []const Limb, b: []const Limb)
35513543/// The result is computed modulo `r.len`.
35523544/// Returns whether the operation overflowed.
35533545fn llmulLimb(comptime op: AccOp, acc: []Limb, y: []const Limb, xi: Limb) bool {
3554 @setRuntimeSafety(debug_safety);
35553546 if (xi == 0) {
35563547 return false;
35573548 }
......@@ -3598,7 +3589,6 @@ fn llmulLimb(comptime op: AccOp, acc: []Limb, y: []const Limb, xi: Limb) bool {
35983589
35993590/// returns the min length the limb could be.
36003591fn llnormalize(a: []const Limb) usize {
3601 @setRuntimeSafety(debug_safety);
36023592 var j = a.len;
36033593 while (j > 0) : (j -= 1) {
36043594 if (a[j - 1] != 0) {
......@@ -3612,7 +3602,6 @@ fn llnormalize(a: []const Limb) usize {
36123602
36133603/// Knuth 4.3.1, Algorithm S.
36143604fn llsubcarry(r: []Limb, a: []const Limb, b: []const Limb) Limb {
3615 @setRuntimeSafety(debug_safety);
36163605 assert(a.len != 0 and b.len != 0);
36173606 assert(a.len >= b.len);
36183607 assert(r.len >= a.len);
......@@ -3638,14 +3627,12 @@ fn llsubcarry(r: []Limb, a: []const Limb, b: []const Limb) Limb {
36383627}
36393628
36403629fn llsub(r: []Limb, a: []const Limb, b: []const Limb) void {
3641 @setRuntimeSafety(debug_safety);
36423630 assert(a.len > b.len or (a.len == b.len and a[a.len - 1] >= b[b.len - 1]));
36433631 assert(llsubcarry(r, a, b) == 0);
36443632}
36453633
36463634/// Knuth 4.3.1, Algorithm A.
36473635fn lladdcarry(r: []Limb, a: []const Limb, b: []const Limb) Limb {
3648 @setRuntimeSafety(debug_safety);
36493636 assert(a.len != 0 and b.len != 0);
36503637 assert(a.len >= b.len);
36513638 assert(r.len >= a.len);
......@@ -3671,14 +3658,12 @@ fn lladdcarry(r: []Limb, a: []const Limb, b: []const Limb) Limb {
36713658}
36723659
36733660fn lladd(r: []Limb, a: []const Limb, b: []const Limb) void {
3674 @setRuntimeSafety(debug_safety);
36753661 assert(r.len >= a.len + 1);
36763662 r[a.len] = lladdcarry(r, a, b);
36773663}
36783664
36793665/// Knuth 4.3.1, Exercise 16.
36803666fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
3681 @setRuntimeSafety(debug_safety);
36823667 assert(a.len > 1 or a[0] >= b);
36833668 assert(quo.len >= a.len);
36843669
......@@ -3704,7 +3689,6 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
37043689}
37053690
37063691fn lldiv0p5(quo: []Limb, rem: *Limb, a: []const Limb, b: HalfLimb) void {
3707 @setRuntimeSafety(debug_safety);
37083692 assert(a.len > 1 or a[0] >= b);
37093693 assert(quo.len >= a.len);
37103694
......@@ -3788,7 +3772,6 @@ fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
37883772
37893773// r = ~r
37903774fn llnot(r: []Limb) void {
3791 @setRuntimeSafety(debug_safety);
37923775
37933776 for (r) |*elem| {
37943777 elem.* = ~elem.*;
......@@ -3802,7 +3785,6 @@ fn llnot(r: []Limb) void {
38023785// When b is positive, r requires at least `a.len` limbs of storage.
38033786// When b is negative, r requires at least `b.len` limbs of storage.
38043787fn llsignedor(r: []Limb, a: []const Limb, a_positive: bool, b: []const Limb, b_positive: bool) bool {
3805 @setRuntimeSafety(debug_safety);
38063788 assert(r.len >= a.len);
38073789 assert(a.len >= b.len);
38083790
......@@ -3933,7 +3915,6 @@ fn llsignedor(r: []Limb, a: []const Limb, a_positive: bool, b: []const Limb, b_p
39333915// 2. when b is negative but a is positive, r requires at least `a.len` limbs of storage,
39343916// 3. when both a and b are negative, r requires at least `a.len + 1` limbs of storage.
39353917fn llsignedand(r: []Limb, a: []const Limb, a_positive: bool, b: []const Limb, b_positive: bool) bool {
3936 @setRuntimeSafety(debug_safety);
39373918 assert(a.len != 0 and b.len != 0);
39383919 assert(a.len >= b.len);
39393920 assert(r.len >= if (b_positive) b.len else if (a_positive) a.len else a.len + 1);
......@@ -4043,7 +4024,6 @@ fn llsignedand(r: []Limb, a: []const Limb, a_positive: bool, b: []const Limb, b_
40434024// If the sign of a and b is equal, then r requires at least `@max(a.len, b.len)` limbs are required.
40444025// Otherwise, r requires at least `@max(a.len, b.len) + 1` limbs.
40454026fn llsignedxor(r: []Limb, a: []const Limb, a_positive: bool, b: []const Limb, b_positive: bool) bool {
4046 @setRuntimeSafety(debug_safety);
40474027 assert(a.len != 0 and b.len != 0);
40484028 assert(r.len >= a.len);
40494029 assert(a.len >= b.len);
......@@ -4102,8 +4082,6 @@ fn llsignedxor(r: []Limb, a: []const Limb, a_positive: bool, b: []const Limb, b_
41024082
41034083/// r MUST NOT alias x.
41044084fn llsquareBasecase(r: []Limb, x: []const Limb) void {
4105 @setRuntimeSafety(debug_safety);
4106
41074085 const x_norm = x;
41084086 assert(r.len >= 2 * x_norm.len + 1);
41094087