Skip to content

Commit 61cfd46

Browse files
bend-nbend-n
committed
apply fix
1 parent ad3fcff commit 61cfd46

File tree

2 files changed

+26
-27
lines changed

2 files changed

+26
-27
lines changed

Diff for: ‎crates/core_arch/src/lib.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,8 @@
3838
sha512_sm_x86,
3939
x86_amx_intrinsics,
4040
f16,
41-
keylocker_x86
41+
keylocker_x86,
42+
integer_sign_cast,
4243
)]
4344
#![cfg_attr(test, feature(test, abi_vectorcall, stdarch_internal))]
4445
#![deny(clippy::missing_inline_in_public_items)]

Diff for: ‎crates/core_arch/src/x86/avx512f.rs

+24-26
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,3 @@
1-
#![allow(unknown_lints)]
2-
#![allow(redundant_transmutation)]
31
use crate::{
42
arch::asm,
53
core_arch::{simd::*, x86::*},
@@ -28617,7 +28615,7 @@ pub unsafe fn _mm512_cmp_ps_mask<const IMM8: i32>(a: __m512, b: __m512) -> __mma
2861728615
let a = a.as_f32x16();
2861828616
let b = b.as_f32x16();
2861928617
let r = vcmpps(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
28620-
transmute(r)
28618+
r.cast_unsigned()
2862128619
}
2862228620

2862328621
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).
@@ -28637,7 +28635,7 @@ pub unsafe fn _mm512_mask_cmp_ps_mask<const IMM8: i32>(
2863728635
let a = a.as_f32x16();
2863828636
let b = b.as_f32x16();
2863928637
let r = vcmpps(a, b, IMM8, k1 as i16, _MM_FROUND_CUR_DIRECTION);
28640-
transmute(r)
28638+
r.cast_unsigned()
2864128639
}
2864228640

2864328641
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.
@@ -28654,7 +28652,7 @@ pub unsafe fn _mm256_cmp_ps_mask<const IMM8: i32>(a: __m256, b: __m256) -> __mma
2865428652
let a = a.as_f32x8();
2865528653
let b = b.as_f32x8();
2865628654
let r = vcmpps256(a, b, IMM8, neg_one);
28657-
transmute(r)
28655+
r.cast_unsigned()
2865828656
}
2865928657

2866028658
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).
@@ -28674,7 +28672,7 @@ pub unsafe fn _mm256_mask_cmp_ps_mask<const IMM8: i32>(
2867428672
let a = a.as_f32x8();
2867528673
let b = b.as_f32x8();
2867628674
let r = vcmpps256(a, b, IMM8, k1 as i8);
28677-
transmute(r)
28675+
r.cast_unsigned()
2867828676
}
2867928677

2868028678
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.
@@ -28691,7 +28689,7 @@ pub unsafe fn _mm_cmp_ps_mask<const IMM8: i32>(a: __m128, b: __m128) -> __mmask8
2869128689
let a = a.as_f32x4();
2869228690
let b = b.as_f32x4();
2869328691
let r = vcmpps128(a, b, IMM8, neg_one);
28694-
transmute(r)
28692+
r.cast_unsigned()
2869528693
}
2869628694

2869728695
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).
@@ -28711,7 +28709,7 @@ pub unsafe fn _mm_mask_cmp_ps_mask<const IMM8: i32>(
2871128709
let a = a.as_f32x4();
2871228710
let b = b.as_f32x4();
2871328711
let r = vcmpps128(a, b, IMM8, k1 as i8);
28714-
transmute(r)
28712+
r.cast_unsigned()
2871528713
}
2871628714

2871728715
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.\
@@ -28733,7 +28731,7 @@ pub unsafe fn _mm512_cmp_round_ps_mask<const IMM5: i32, const SAE: i32>(
2873328731
let a = a.as_f32x16();
2873428732
let b = b.as_f32x16();
2873528733
let r = vcmpps(a, b, IMM5, neg_one, SAE);
28736-
transmute(r)
28734+
r.cast_unsigned()
2873728735
}
2873828736

2873928737
/// Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).\
@@ -28755,7 +28753,7 @@ pub unsafe fn _mm512_mask_cmp_round_ps_mask<const IMM5: i32, const SAE: i32>(
2875528753
let a = a.as_f32x16();
2875628754
let b = b.as_f32x16();
2875728755
let r = vcmpps(a, b, IMM5, m as i16, SAE);
28758-
transmute(r)
28756+
r.cast_unsigned()
2875928757
}
2876028758

2876128759
/// Compare packed single-precision (32-bit) floating-point elements in a and b to see if neither is NaN, and store the results in mask vector k.
@@ -28948,7 +28946,7 @@ pub unsafe fn _mm512_cmp_pd_mask<const IMM8: i32>(a: __m512d, b: __m512d) -> __m
2894828946
let a = a.as_f64x8();
2894928947
let b = b.as_f64x8();
2895028948
let r = vcmppd(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
28951-
transmute(r)
28949+
r.cast_unsigned()
2895228950
}
2895328951

2895428952
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).
@@ -28968,7 +28966,7 @@ pub unsafe fn _mm512_mask_cmp_pd_mask<const IMM8: i32>(
2896828966
let a = a.as_f64x8();
2896928967
let b = b.as_f64x8();
2897028968
let r = vcmppd(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
28971-
transmute(r)
28969+
r.cast_unsigned()
2897228970
}
2897328971

2897428972
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.
@@ -28985,7 +28983,7 @@ pub unsafe fn _mm256_cmp_pd_mask<const IMM8: i32>(a: __m256d, b: __m256d) -> __m
2898528983
let a = a.as_f64x4();
2898628984
let b = b.as_f64x4();
2898728985
let r = vcmppd256(a, b, IMM8, neg_one);
28988-
transmute(r)
28986+
r.cast_unsigned()
2898928987
}
2899028988

2899128989
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).
@@ -29005,7 +29003,7 @@ pub unsafe fn _mm256_mask_cmp_pd_mask<const IMM8: i32>(
2900529003
let a = a.as_f64x4();
2900629004
let b = b.as_f64x4();
2900729005
let r = vcmppd256(a, b, IMM8, k1 as i8);
29008-
transmute(r)
29006+
r.cast_unsigned()
2900929007
}
2901029008

2901129009
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.
@@ -29022,7 +29020,7 @@ pub unsafe fn _mm_cmp_pd_mask<const IMM8: i32>(a: __m128d, b: __m128d) -> __mmas
2902229020
let a = a.as_f64x2();
2902329021
let b = b.as_f64x2();
2902429022
let r = vcmppd128(a, b, IMM8, neg_one);
29025-
transmute(r)
29023+
r.cast_unsigned()
2902629024
}
2902729025

2902829026
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).
@@ -29042,7 +29040,7 @@ pub unsafe fn _mm_mask_cmp_pd_mask<const IMM8: i32>(
2904229040
let a = a.as_f64x2();
2904329041
let b = b.as_f64x2();
2904429042
let r = vcmppd128(a, b, IMM8, k1 as i8);
29045-
transmute(r)
29043+
r.cast_unsigned()
2904629044
}
2904729045

2904829046
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k.\
@@ -29064,7 +29062,7 @@ pub unsafe fn _mm512_cmp_round_pd_mask<const IMM5: i32, const SAE: i32>(
2906429062
let a = a.as_f64x8();
2906529063
let b = b.as_f64x8();
2906629064
let r = vcmppd(a, b, IMM5, neg_one, SAE);
29067-
transmute(r)
29065+
r.cast_unsigned()
2906829066
}
2906929067

2907029068
/// Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in mask vector k using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).\
@@ -29086,7 +29084,7 @@ pub unsafe fn _mm512_mask_cmp_round_pd_mask<const IMM5: i32, const SAE: i32>(
2908629084
let a = a.as_f64x8();
2908729085
let b = b.as_f64x8();
2908829086
let r = vcmppd(a, b, IMM5, k1 as i8, SAE);
29089-
transmute(r)
29087+
r.cast_unsigned()
2909029088
}
2909129089

2909229090
/// Compare packed double-precision (64-bit) floating-point elements in a and b to see if neither is NaN, and store the results in mask vector k.
@@ -29145,7 +29143,7 @@ pub unsafe fn _mm_cmp_ss_mask<const IMM8: i32>(a: __m128, b: __m128) -> __mmask8
2914529143
static_assert_uimm_bits!(IMM8, 5);
2914629144
let neg_one = -1;
2914729145
let r = vcmpss(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
29148-
transmute(r)
29146+
r.cast_unsigned()
2914929147
}
2915029148

2915129149
/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not set).
@@ -29163,7 +29161,7 @@ pub unsafe fn _mm_mask_cmp_ss_mask<const IMM8: i32>(
2916329161
) -> __mmask8 {
2916429162
static_assert_uimm_bits!(IMM8, 5);
2916529163
let r = vcmpss(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
29166-
transmute(r)
29164+
r.cast_unsigned()
2916729165
}
2916829166

2916929167
/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k.\
@@ -29183,7 +29181,7 @@ pub unsafe fn _mm_cmp_round_ss_mask<const IMM5: i32, const SAE: i32>(
2918329181
static_assert_mantissas_sae!(SAE);
2918429182
let neg_one = -1;
2918529183
let r = vcmpss(a, b, IMM5, neg_one, SAE);
29186-
transmute(r)
29184+
r.cast_unsigned()
2918729185
}
2918829186

2918929187
/// Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not seti).\
@@ -29203,7 +29201,7 @@ pub unsafe fn _mm_mask_cmp_round_ss_mask<const IMM5: i32, const SAE: i32>(
2920329201
static_assert_uimm_bits!(IMM5, 5);
2920429202
static_assert_mantissas_sae!(SAE);
2920529203
let r = vcmpss(a, b, IMM5, k1 as i8, SAE);
29206-
transmute(r)
29204+
r.cast_unsigned()
2920729205
}
2920829206

2920929207
/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k.
@@ -29218,7 +29216,7 @@ pub unsafe fn _mm_cmp_sd_mask<const IMM8: i32>(a: __m128d, b: __m128d) -> __mmas
2921829216
static_assert_uimm_bits!(IMM8, 5);
2921929217
let neg_one = -1;
2922029218
let r = vcmpsd(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
29221-
transmute(r)
29219+
r.cast_unsigned()
2922229220
}
2922329221

2922429222
/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not set).
@@ -29236,7 +29234,7 @@ pub unsafe fn _mm_mask_cmp_sd_mask<const IMM8: i32>(
2923629234
) -> __mmask8 {
2923729235
static_assert_uimm_bits!(IMM8, 5);
2923829236
let r = vcmpsd(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
29239-
transmute(r)
29237+
r.cast_unsigned()
2924029238
}
2924129239

2924229240
/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k.\
@@ -29256,7 +29254,7 @@ pub unsafe fn _mm_cmp_round_sd_mask<const IMM5: i32, const SAE: i32>(
2925629254
static_assert_mantissas_sae!(SAE);
2925729255
let neg_one = -1;
2925829256
let r = vcmpsd(a, b, IMM5, neg_one, SAE);
29259-
transmute(r)
29257+
r.cast_unsigned()
2926029258
}
2926129259

2926229260
/// Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, and store the result in mask vector k using zeromask k1 (the element is zeroed out when mask bit 0 is not set).\
@@ -29276,7 +29274,7 @@ pub unsafe fn _mm_mask_cmp_round_sd_mask<const IMM5: i32, const SAE: i32>(
2927629274
static_assert_uimm_bits!(IMM5, 5);
2927729275
static_assert_mantissas_sae!(SAE);
2927829276
let r = vcmpsd(a, b, IMM5, k1 as i8, SAE);
29279-
transmute(r)
29277+
r.cast_unsigned()
2928029278
}
2928129279

2928229280
/// Compare packed unsigned 32-bit integers in a and b for less-than, and store the results in mask vector k.

0 commit comments

Comments
 (0)