Skip to content

Commit de5bd5e

Browse files
bend-nbend-n
committed
fix
1 parent f32eeff commit de5bd5e

File tree

2 files changed

+26
-25
lines changed

2 files changed

+26
-25
lines changed

‎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)]

‎crates/core_arch/src/x86/avx512f.rs

+24-24
Original file line numberDiff line numberDiff line change
@@ -28615,7 +28615,7 @@ pub unsafe fn _mm512_cmp_ps_mask<const IMM8: i32>(a: __m512, b: __m512) -> __mma
2861528615
let a = a.as_f32x16();
2861628616
let b = b.as_f32x16();
2861728617
let r = vcmpps(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
28618-
transmute(r)
28618+
r.cast_unsigned()
2861928619
}
2862028620

2862128621
/// 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).
@@ -28635,7 +28635,7 @@ pub unsafe fn _mm512_mask_cmp_ps_mask<const IMM8: i32>(
2863528635
let a = a.as_f32x16();
2863628636
let b = b.as_f32x16();
2863728637
let r = vcmpps(a, b, IMM8, k1 as i16, _MM_FROUND_CUR_DIRECTION);
28638-
transmute(r)
28638+
r.cast_unsigned()
2863928639
}
2864028640

2864128641
/// 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.
@@ -28652,7 +28652,7 @@ pub unsafe fn _mm256_cmp_ps_mask<const IMM8: i32>(a: __m256, b: __m256) -> __mma
2865228652
let a = a.as_f32x8();
2865328653
let b = b.as_f32x8();
2865428654
let r = vcmpps256(a, b, IMM8, neg_one);
28655-
transmute(r)
28655+
r.cast_unsigned()
2865628656
}
2865728657

2865828658
/// 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).
@@ -28672,7 +28672,7 @@ pub unsafe fn _mm256_mask_cmp_ps_mask<const IMM8: i32>(
2867228672
let a = a.as_f32x8();
2867328673
let b = b.as_f32x8();
2867428674
let r = vcmpps256(a, b, IMM8, k1 as i8);
28675-
transmute(r)
28675+
r.cast_unsigned()
2867628676
}
2867728677

2867828678
/// 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.
@@ -28689,7 +28689,7 @@ pub unsafe fn _mm_cmp_ps_mask<const IMM8: i32>(a: __m128, b: __m128) -> __mmask8
2868928689
let a = a.as_f32x4();
2869028690
let b = b.as_f32x4();
2869128691
let r = vcmpps128(a, b, IMM8, neg_one);
28692-
transmute(r)
28692+
r.cast_unsigned()
2869328693
}
2869428694

2869528695
/// 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).
@@ -28709,7 +28709,7 @@ pub unsafe fn _mm_mask_cmp_ps_mask<const IMM8: i32>(
2870928709
let a = a.as_f32x4();
2871028710
let b = b.as_f32x4();
2871128711
let r = vcmpps128(a, b, IMM8, k1 as i8);
28712-
transmute(r)
28712+
r.cast_unsigned()
2871328713
}
2871428714

2871528715
/// 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.\
@@ -28731,7 +28731,7 @@ pub unsafe fn _mm512_cmp_round_ps_mask<const IMM5: i32, const SAE: i32>(
2873128731
let a = a.as_f32x16();
2873228732
let b = b.as_f32x16();
2873328733
let r = vcmpps(a, b, IMM5, neg_one, SAE);
28734-
transmute(r)
28734+
r.cast_unsigned()
2873528735
}
2873628736

2873728737
/// 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).\
@@ -28753,7 +28753,7 @@ pub unsafe fn _mm512_mask_cmp_round_ps_mask<const IMM5: i32, const SAE: i32>(
2875328753
let a = a.as_f32x16();
2875428754
let b = b.as_f32x16();
2875528755
let r = vcmpps(a, b, IMM5, m as i16, SAE);
28756-
transmute(r)
28756+
r.cast_unsigned()
2875728757
}
2875828758

2875928759
/// 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.
@@ -28946,7 +28946,7 @@ pub unsafe fn _mm512_cmp_pd_mask<const IMM8: i32>(a: __m512d, b: __m512d) -> __m
2894628946
let a = a.as_f64x8();
2894728947
let b = b.as_f64x8();
2894828948
let r = vcmppd(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
28949-
transmute(r)
28949+
r.cast_unsigned()
2895028950
}
2895128951

2895228952
/// 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).
@@ -28966,7 +28966,7 @@ pub unsafe fn _mm512_mask_cmp_pd_mask<const IMM8: i32>(
2896628966
let a = a.as_f64x8();
2896728967
let b = b.as_f64x8();
2896828968
let r = vcmppd(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
28969-
transmute(r)
28969+
r.cast_unsigned()
2897028970
}
2897128971

2897228972
/// 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.
@@ -28983,7 +28983,7 @@ pub unsafe fn _mm256_cmp_pd_mask<const IMM8: i32>(a: __m256d, b: __m256d) -> __m
2898328983
let a = a.as_f64x4();
2898428984
let b = b.as_f64x4();
2898528985
let r = vcmppd256(a, b, IMM8, neg_one);
28986-
transmute(r)
28986+
r.cast_unsigned()
2898728987
}
2898828988

2898928989
/// 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).
@@ -29003,7 +29003,7 @@ pub unsafe fn _mm256_mask_cmp_pd_mask<const IMM8: i32>(
2900329003
let a = a.as_f64x4();
2900429004
let b = b.as_f64x4();
2900529005
let r = vcmppd256(a, b, IMM8, k1 as i8);
29006-
transmute(r)
29006+
r.cast_unsigned()
2900729007
}
2900829008

2900929009
/// 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.
@@ -29020,7 +29020,7 @@ pub unsafe fn _mm_cmp_pd_mask<const IMM8: i32>(a: __m128d, b: __m128d) -> __mmas
2902029020
let a = a.as_f64x2();
2902129021
let b = b.as_f64x2();
2902229022
let r = vcmppd128(a, b, IMM8, neg_one);
29023-
transmute(r)
29023+
r.cast_unsigned()
2902429024
}
2902529025

2902629026
/// 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).
@@ -29040,7 +29040,7 @@ pub unsafe fn _mm_mask_cmp_pd_mask<const IMM8: i32>(
2904029040
let a = a.as_f64x2();
2904129041
let b = b.as_f64x2();
2904229042
let r = vcmppd128(a, b, IMM8, k1 as i8);
29043-
transmute(r)
29043+
r.cast_unsigned()
2904429044
}
2904529045

2904629046
/// 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.\
@@ -29062,7 +29062,7 @@ pub unsafe fn _mm512_cmp_round_pd_mask<const IMM5: i32, const SAE: i32>(
2906229062
let a = a.as_f64x8();
2906329063
let b = b.as_f64x8();
2906429064
let r = vcmppd(a, b, IMM5, neg_one, SAE);
29065-
transmute(r)
29065+
r.cast_unsigned()
2906629066
}
2906729067

2906829068
/// 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).\
@@ -29084,7 +29084,7 @@ pub unsafe fn _mm512_mask_cmp_round_pd_mask<const IMM5: i32, const SAE: i32>(
2908429084
let a = a.as_f64x8();
2908529085
let b = b.as_f64x8();
2908629086
let r = vcmppd(a, b, IMM5, k1 as i8, SAE);
29087-
transmute(r)
29087+
r.cast_unsigned()
2908829088
}
2908929089

2909029090
/// 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.
@@ -29143,7 +29143,7 @@ pub unsafe fn _mm_cmp_ss_mask<const IMM8: i32>(a: __m128, b: __m128) -> __mmask8
2914329143
static_assert_uimm_bits!(IMM8, 5);
2914429144
let neg_one = -1;
2914529145
let r = vcmpss(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
29146-
transmute(r)
29146+
r.cast_unsigned()
2914729147
}
2914829148

2914929149
/// 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).
@@ -29161,7 +29161,7 @@ pub unsafe fn _mm_mask_cmp_ss_mask<const IMM8: i32>(
2916129161
) -> __mmask8 {
2916229162
static_assert_uimm_bits!(IMM8, 5);
2916329163
let r = vcmpss(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
29164-
transmute(r)
29164+
r.cast_unsigned()
2916529165
}
2916629166

2916729167
/// 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.\
@@ -29181,7 +29181,7 @@ pub unsafe fn _mm_cmp_round_ss_mask<const IMM5: i32, const SAE: i32>(
2918129181
static_assert_mantissas_sae!(SAE);
2918229182
let neg_one = -1;
2918329183
let r = vcmpss(a, b, IMM5, neg_one, SAE);
29184-
transmute(r)
29184+
r.cast_unsigned()
2918529185
}
2918629186

2918729187
/// 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).\
@@ -29201,7 +29201,7 @@ pub unsafe fn _mm_mask_cmp_round_ss_mask<const IMM5: i32, const SAE: i32>(
2920129201
static_assert_uimm_bits!(IMM5, 5);
2920229202
static_assert_mantissas_sae!(SAE);
2920329203
let r = vcmpss(a, b, IMM5, k1 as i8, SAE);
29204-
transmute(r)
29204+
r.cast_unsigned()
2920529205
}
2920629206

2920729207
/// 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.
@@ -29216,7 +29216,7 @@ pub unsafe fn _mm_cmp_sd_mask<const IMM8: i32>(a: __m128d, b: __m128d) -> __mmas
2921629216
static_assert_uimm_bits!(IMM8, 5);
2921729217
let neg_one = -1;
2921829218
let r = vcmpsd(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
29219-
transmute(r)
29219+
r.cast_unsigned()
2922029220
}
2922129221

2922229222
/// 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).
@@ -29234,7 +29234,7 @@ pub unsafe fn _mm_mask_cmp_sd_mask<const IMM8: i32>(
2923429234
) -> __mmask8 {
2923529235
static_assert_uimm_bits!(IMM8, 5);
2923629236
let r = vcmpsd(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
29237-
transmute(r)
29237+
r.cast_unsigned()
2923829238
}
2923929239

2924029240
/// 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.\
@@ -29254,7 +29254,7 @@ pub unsafe fn _mm_cmp_round_sd_mask<const IMM5: i32, const SAE: i32>(
2925429254
static_assert_mantissas_sae!(SAE);
2925529255
let neg_one = -1;
2925629256
let r = vcmpsd(a, b, IMM5, neg_one, SAE);
29257-
transmute(r)
29257+
r.cast_unsigned()
2925829258
}
2925929259

2926029260
/// 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).\
@@ -29274,7 +29274,7 @@ pub unsafe fn _mm_mask_cmp_round_sd_mask<const IMM5: i32, const SAE: i32>(
2927429274
static_assert_uimm_bits!(IMM5, 5);
2927529275
static_assert_mantissas_sae!(SAE);
2927629276
let r = vcmpsd(a, b, IMM5, k1 as i8, SAE);
29277-
transmute(r)
29277+
r.cast_unsigned()
2927829278
}
2927929279

2928029280
/// 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)