cpet/openbsd-ports
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

suricata: unbreak build with rust 1.53.0

Browse Source 
backport https://github.com/Alexhuszagh/rust-lexical/pull/56

ok tb@ jasper@
This commit is contained in:
semarie 2021-06-19 12:39:34 +00:00
parent 5678e5e199
commit 82ff7200e5
4 changed files with 230 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
security/suricata/patches/patch-rust_vendor_lexical-core__cargo-checksum_json Normal file
View File

File diff suppressed because one or more lines are too long

15
security/suricata/patches/patch-rust_vendor_lexical-core_src_atof_algorithm_bhcomp_rs Normal file
View File

@ -0,0 +1,15 @@
$OpenBSD: patch-rust_vendor_lexical-core_src_atof_algorithm_bhcomp_rs,v 1.1 2021/06/19 12:39:34 semarie Exp $
Backport of https://github.com/Alexhuszagh/rust-lexical/pull/56 for rustc 1.53.0
Index: rust/vendor/lexical-core/src/atof/algorithm/bhcomp.rs
--- rust/vendor/lexical-core/src/atof/algorithm/bhcomp.rs.orig
+++ rust/vendor/lexical-core/src/atof/algorithm/bhcomp.rs
@@ -59,7 +59,7 @@ pub(super) fn parse_mantissa<'a, Data>(data: Data, rad
let small_powers = Bigint::small_powers(radix);
let count = data.mantissa_digits();
let bits = count / integral_binary_factor(radix).as_usize();
- let bytes = bits / Limb::BITS;
+ let bytes = bits / <Limb as Integer>::BITS;
// Main loop
let step = small_powers.len() - 2;

24
security/suricata/patches/patch-rust_vendor_lexical-core_src_atof_algorithm_bigcomp_rs Normal file
View File

@ -0,0 +1,24 @@
$OpenBSD: patch-rust_vendor_lexical-core_src_atof_algorithm_bigcomp_rs,v 1.1 2021/06/19 12:39:34 semarie Exp $
Backport of https://github.com/Alexhuszagh/rust-lexical/pull/56 for rustc 1.53.0
Index: rust/vendor/lexical-core/src/atof/algorithm/bigcomp.rs
--- rust/vendor/lexical-core/src/atof/algorithm/bigcomp.rs.orig
+++ rust/vendor/lexical-core/src/atof/algorithm/bigcomp.rs
@@ -154,7 +154,7 @@ pub(super) fn make_ratio<F: Float>(radix: u32, sci_exp
// Scale the denominator so it has the number of bits
// in the radix as the number of leading zeros.
let wlz = integral_binary_factor(radix).as_usize();
- let nlz = den.leading_zeros().wrapping_sub(wlz) & (u32::BITS - 1);
+ let nlz = den.leading_zeros().wrapping_sub(wlz) & (<u32 as Integer>::BITS - 1);
small::ishl_bits(den.data_mut(), nlz);
den.exp -= nlz.as_i32();
@@ -172,7 +172,7 @@ pub(super) fn make_ratio<F: Float>(radix: u32, sci_exp
// denominator will be normalized.
// We need to add one to the quotient,since we're calculating the
// ceiling of the divmod.
- let (q, r) = shift.ceil_divmod(Limb::BITS);
+ let (q, r) = shift.ceil_divmod(<Limb as Integer>::BITS);
// Since we're using a power from the denominator to the
// numerator, we to invert r, not add u32::BITS.
let r = -r;

181
security/suricata/patches/patch-rust_vendor_lexical-core_src_atof_algorithm_math_rs Normal file
View File

@ -0,0 +1,181 @@
$OpenBSD: patch-rust_vendor_lexical-core_src_atof_algorithm_math_rs,v 1.1 2021/06/19 12:39:34 semarie Exp $
Backport of https://github.com/Alexhuszagh/rust-lexical/pull/56 for rustc 1.53.0
Index: rust/vendor/lexical-core/src/atof/algorithm/math.rs
--- rust/vendor/lexical-core/src/atof/algorithm/math.rs.orig
+++ rust/vendor/lexical-core/src/atof/algorithm/math.rs
@@ -956,7 +956,7 @@ pub fn mul(x: Limb, y: Limb, carry: Limb)
// the following is always true:
// `Wide::max_value() - (Narrow::max_value() * Narrow::max_value()) >= Narrow::max_value()`
let z: Wide = as_wide(x) * as_wide(y) + as_wide(carry);
- (as_limb(z), as_limb(z >> Limb::BITS))
+ (as_limb(z), as_limb(z >> <Limb as Integer>::BITS))
}}
/// Multiply two small integers (with carry) (and return if overflow happens).
@@ -979,7 +979,7 @@ pub fn div(x: Limb, y: Limb, rem: Limb)
-> (Limb, Limb)
{
// Cannot overflow, as long as wide is 2x as wide.
- let x = as_wide(x) | (as_wide(rem) << Limb::BITS);
+ let x = as_wide(x) | (as_wide(rem) << <Limb as Integer>::BITS);
let y = as_wide(y);
(as_limb(x / y), as_limb(x % y))
}}
@@ -1046,7 +1046,7 @@ perftools_inline!{
pub fn trailing_zeros(x: &[Limb]) -> usize {
// Get the index of the last non-zero value
let index = trailing_zero_limbs(x);
- let mut count = index.saturating_mul(Limb::BITS);
+ let mut count = index.saturating_mul(<Limb as Integer>::BITS);
if let Some(value) = x.get(index) {
count = count.saturating_add(value.trailing_zeros().as_usize());
}
@@ -1061,7 +1061,7 @@ pub fn bit_length(x: &[Limb]) -> usize {
// Avoid overflowing, calculate via total number of bits
// minus leading zero bits.
let nlz = leading_zeros(x);
- Limb::BITS.checked_mul(x.len())
+ <Limb as Integer>::BITS.checked_mul(x.len())
.map(|v| v - nlz)
.unwrap_or(usize::max_value())
}}
@@ -1087,7 +1087,7 @@ pub fn ishr_bits<T>(x: &mut T, n: usize)
where T: CloneableVecLike<Limb>
{
// Need to shift by the number of `bits % Limb::BITS`.
- let bits = Limb::BITS;
+ let bits = <Limb as Integer>::BITS;
debug_assert!(n < bits && n != 0);
// Internally, for each item, we shift left by n, and add the previous
@@ -1134,7 +1134,7 @@ pub fn ishr<T>(x: &mut T, n: usize)
-> bool
where T: CloneableVecLike<Limb>
{
- let bits = Limb::BITS;
+ let bits = <Limb as Integer>::BITS;
// Need to pad with zeros for the number of `bits / Limb::BITS`,
// and shift-left with carry for `bits % Limb::BITS`.
let rem = n % bits;
@@ -1193,7 +1193,7 @@ pub fn ishl_bits<T>(x: &mut T, n: usize)
where T: CloneableVecLike<Limb>
{
// Need to shift by the number of `bits % Limb::BITS)`.
- let bits = Limb::BITS;
+ let bits = <Limb as Integer>::BITS;
debug_assert!(n < bits);
if n.is_zero() {
return;
@@ -1253,7 +1253,7 @@ perftools_inline!{
pub fn ishl<T>(x: &mut T, n: usize)
where T: CloneableVecLike<Limb>
{
- let bits = Limb::BITS;
+ let bits = <Limb as Integer>::BITS;
// Need to pad with zeros for the number of `bits / Limb::BITS`,
// and shift-left with carry for `bits % Limb::BITS`.
let rem = n % bits;
@@ -1912,7 +1912,7 @@ pub fn mul<T>(x: &[Limb], y: &[Limb])
// DIVISION
/// Constants for algorithm D.
-const ALGORITHM_D_B: Wide = 1 << Limb::BITS;
+const ALGORITHM_D_B: Wide = 1 << <Limb as Integer>::BITS;
const ALGORITHM_D_M: Wide = ALGORITHM_D_B - 1;
/// Calculate qhat (an estimate for the quotient).
@@ -1932,7 +1932,7 @@ fn calculate_qhat(x: &[Limb], y: &[Limb], j: usize)
// rhat = (x[j+n]*B + x[j+n-1]) - qhat*y[n-1];
let x_jn = as_wide(x[j+n]);
let x_jn1 = as_wide(x[j+n-1]);
- let num = (x_jn << Limb::BITS) + x_jn1;
+ let num = (x_jn << <Limb as Integer>::BITS) + x_jn1;
let den = as_wide(y[n-1]);
let mut qhat = num / den;
let mut rhat = num - qhat * den;
@@ -1949,7 +1949,7 @@ fn calculate_qhat(x: &[Limb], y: &[Limb], j: usize)
let y_n2 = as_wide(y[n-2]);
let y_n1 = as_wide(y[n-1]);
// This only happens when the leading bit of qhat is set.
- while qhat >= ALGORITHM_D_B || qhat * y_n2 > (rhat << Limb::BITS) + x_jn2 {
+ while qhat >= ALGORITHM_D_B || qhat * y_n2 > (rhat << <Limb as Integer>::BITS) + x_jn2 {
qhat -= 1;
rhat += y_n1;
if rhat >= ALGORITHM_D_B {
@@ -1989,7 +1989,7 @@ fn multiply_and_subtract<T>(x: &mut T, y: &T, qhat: Wi
let p = qhat * y_i;
t = x_ij.wrapping_sub(k).wrapping_sub(as_signed_wide(p & ALGORITHM_D_M));
x[i+j] = as_limb(t);
- k = as_signed_wide(p >> Limb::BITS) - (t >> Limb::BITS);
+ k = as_signed_wide(p >> <Limb as Integer>::BITS) - (t >> <Limb as Integer>::BITS);
}
t = as_signed_wide(x[j+n]) - k;
x[j+n] = as_limb(t);
@@ -2045,7 +2045,7 @@ fn add_back<T>(x: &mut T, y: &T, mut t: SignedWide, j:
for i in 0..n {
t = as_signed_wide(as_wide(x[i+j]) + as_wide(y[i])) + k;
x[i+j] = as_limb(t);
- k = t >> Limb::BITS;
+ k = t >> <Limb as Integer>::BITS;
}
let x_jn = as_signed_wide(x[j+n]) + k;
x[j+n] = as_limb(x_jn);
@@ -2068,7 +2068,7 @@ fn calculate_remainder<T>(x: &[Limb], y: &[Limb], s: u
let n = y.len();
let mut r = T::default();
r.reserve_exact(n);
- let rs = Limb::BITS - s;
+ let rs = <Limb as Integer>::BITS - s;
for i in 0..n-1 {
let xi = as_wide(x[i]) >> s;
let xi1 = as_wide(x[i+1]) << rs;
@@ -2205,9 +2205,9 @@ pub fn quorem<T>(x: &mut T, y: &T)
let mut carry: Wide = 0;
for j in 0..m {
let p = as_wide(y[j]) * as_wide(q) + carry;
- carry = p >> Limb::BITS;
+ carry = p >> <Limb as Integer>::BITS;
let t = as_wide(x[j]).wrapping_sub(p & mask).wrapping_sub(borrow);
- borrow = (t >> Limb::BITS) & 1;
+ borrow = (t >> <Limb as Integer>::BITS) & 1;
x[j] = as_limb(t);
}
small::normalize(x);
@@ -2220,9 +2220,9 @@ pub fn quorem<T>(x: &mut T, y: &T)
let mut carry: Wide = 0;
for j in 0..m {
let p = as_wide(y[j]) + carry;
- carry = p >> Limb::BITS;
+ carry = p >> <Limb as Integer>::BITS;
let t = as_wide(x[j]).wrapping_sub(p & mask).wrapping_sub(borrow);
- borrow = (t >> Limb::BITS) & 1;
+ borrow = (t >> <Limb as Integer>::BITS) & 1;
x[j] = as_limb(t);
}
small::normalize(x);
@@ -3137,18 +3137,18 @@ mod tests {
fn leading_zeros_test() {
assert_eq!(Bigint::new().leading_zeros(), 0);
- assert_eq!(Bigint::from_u16(0xFF).leading_zeros(), Limb::BITS-8);
- assert_eq!(Bigint::from_u32(0xFF).leading_zeros(), Limb::BITS-8);
+ assert_eq!(Bigint::from_u16(0xFF).leading_zeros(), <Limb as Integer>::BITS-8);
+ assert_eq!(Bigint::from_u32(0xFF).leading_zeros(), <Limb as Integer>::BITS-8);
assert_eq!(Bigint::from_u64(0xFF00000000).leading_zeros(), 24);
assert_eq!(Bigint::from_u128(0xFF000000000000000000000000).leading_zeros(), 24);
- assert_eq!(Bigint::from_u16(0xF).leading_zeros(), Limb::BITS-4);
- assert_eq!(Bigint::from_u32(0xF).leading_zeros(), Limb::BITS-4);
+ assert_eq!(Bigint::from_u16(0xF).leading_zeros(), <Limb as Integer>::BITS-4);
+ assert_eq!(Bigint::from_u32(0xF).leading_zeros(), <Limb as Integer>::BITS-4);
assert_eq!(Bigint::from_u64(0xF00000000).leading_zeros(), 28);
assert_eq!(Bigint::from_u128(0xF000000000000000000000000).leading_zeros(), 28);
- assert_eq!(Bigint::from_u16(0xF0).leading_zeros(), Limb::BITS-8);
- assert_eq!(Bigint::from_u32(0xF0).leading_zeros(), Limb::BITS-8);
+ assert_eq!(Bigint::from_u16(0xF0).leading_zeros(), <Limb as Integer>::BITS-8);
+ assert_eq!(Bigint::from_u32(0xF0).leading_zeros(), <Limb as Integer>::BITS-8);
assert_eq!(Bigint::from_u64(0xF000000000).leading_zeros(), 24);
assert_eq!(Bigint::from_u128(0xF0000000000000000000000000).leading_zeros(), 24);
}