@@ -73,148 +73,202 @@ pub unsafe fn vceqq_f64(a: float64x2_t, b: float64x2_t) -> uint64x2_t {
73
73
simd_eq ( a, b)
74
74
}
75
75
76
- /// Signed Compare bitwise equal to zero
76
+ /// Signed compare bitwise equal to zero
77
77
#[ inline]
78
78
#[ target_feature( enable = "neon" ) ]
79
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
79
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
80
80
pub unsafe fn vceqz_s8 ( a : int8x8_t ) -> uint8x8_t {
81
- simd_eq ( a, transmute ( i8x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ) )
81
+ let b: i8x8 = i8x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ;
82
+ simd_eq ( a, transmute ( b) )
82
83
}
83
84
84
- /// Signed Compare bitwise equal to zero
85
+ /// Signed compare bitwise equal to zero
85
86
#[ inline]
86
87
#[ target_feature( enable = "neon" ) ]
87
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
88
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
88
89
pub unsafe fn vceqzq_s8 ( a : int8x16_t ) -> uint8x16_t {
89
- simd_eq ( a, transmute ( i8x16:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ) )
90
+ let b: i8x16 = i8x16:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ;
91
+ simd_eq ( a, transmute ( b) )
90
92
}
91
93
92
- /// Signed Compare bitwise equal to zero
94
+ /// Signed compare bitwise equal to zero
93
95
#[ inline]
94
96
#[ target_feature( enable = "neon" ) ]
95
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
97
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
96
98
pub unsafe fn vceqz_s16 ( a : int16x4_t ) -> uint16x4_t {
97
- simd_eq ( a, transmute ( i16x4:: new ( 0 , 0 , 0 , 0 ) ) )
99
+ let b: i16x4 = i16x4:: new ( 0 , 0 , 0 , 0 ) ;
100
+ simd_eq ( a, transmute ( b) )
98
101
}
99
102
100
- /// Signed Compare bitwise equal to zero
103
+ /// Signed compare bitwise equal to zero
101
104
#[ inline]
102
105
#[ target_feature( enable = "neon" ) ]
103
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
106
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
104
107
pub unsafe fn vceqzq_s16 ( a : int16x8_t ) -> uint16x8_t {
105
- simd_eq ( a, transmute ( i16x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ) )
108
+ let b: i16x8 = i16x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ;
109
+ simd_eq ( a, transmute ( b) )
106
110
}
107
111
108
- /// Signed Compare bitwise equal to zero
112
+ /// Signed compare bitwise equal to zero
109
113
#[ inline]
110
114
#[ target_feature( enable = "neon" ) ]
111
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
115
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
112
116
pub unsafe fn vceqz_s32 ( a : int32x2_t ) -> uint32x2_t {
113
- simd_eq ( a, transmute ( i32x2:: new ( 0 , 0 ) ) )
117
+ let b: i32x2 = i32x2:: new ( 0 , 0 ) ;
118
+ simd_eq ( a, transmute ( b) )
114
119
}
115
120
116
- /// Signed Compare bitwise equal to zero
121
+ /// Signed compare bitwise equal to zero
117
122
#[ inline]
118
123
#[ target_feature( enable = "neon" ) ]
119
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
124
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
120
125
pub unsafe fn vceqzq_s32 ( a : int32x4_t ) -> uint32x4_t {
121
- simd_eq ( a, transmute ( i32x4:: new ( 0 , 0 , 0 , 0 ) ) )
126
+ let b: i32x4 = i32x4:: new ( 0 , 0 , 0 , 0 ) ;
127
+ simd_eq ( a, transmute ( b) )
122
128
}
123
129
124
- /// Signed Compare bitwise equal to zero
130
+ /// Signed compare bitwise equal to zero
125
131
#[ inline]
126
132
#[ target_feature( enable = "neon" ) ]
127
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
133
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
128
134
pub unsafe fn vceqz_s64 ( a : int64x1_t ) -> uint64x1_t {
129
- simd_eq ( a, transmute ( i64x1:: new ( 0 ) ) )
135
+ let b: i64x1 = i64x1:: new ( 0 ) ;
136
+ simd_eq ( a, transmute ( b) )
130
137
}
131
138
132
- /// Signed Compare bitwise equal to zero
139
+ /// Signed compare bitwise equal to zero
133
140
#[ inline]
134
141
#[ target_feature( enable = "neon" ) ]
135
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
142
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
136
143
pub unsafe fn vceqzq_s64 ( a : int64x2_t ) -> uint64x2_t {
137
- simd_eq ( a, transmute ( i64x2:: new ( 0 , 0 ) ) )
144
+ let b: i64x2 = i64x2:: new ( 0 , 0 ) ;
145
+ simd_eq ( a, transmute ( b) )
138
146
}
139
147
140
- /// Signed Compare bitwise equal to zero
148
+ /// Signed compare bitwise equal to zero
141
149
#[ inline]
142
150
#[ target_feature( enable = "neon" ) ]
143
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
151
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
144
152
pub unsafe fn vceqz_p64 ( a : poly64x1_t ) -> uint64x1_t {
145
- simd_eq ( a, transmute ( i64x1:: new ( 0 ) ) )
153
+ let b: i64x1 = i64x1:: new ( 0 ) ;
154
+ simd_eq ( a, transmute ( b) )
146
155
}
147
156
148
- /// Signed Compare bitwise equal to zero
157
+ /// Signed compare bitwise equal to zero
149
158
#[ inline]
150
159
#[ target_feature( enable = "neon" ) ]
151
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
160
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
152
161
pub unsafe fn vceqzq_p64 ( a : poly64x2_t ) -> uint64x2_t {
153
- simd_eq ( a, transmute ( i64x2:: new ( 0 , 0 ) ) )
162
+ let b: i64x2 = i64x2:: new ( 0 , 0 ) ;
163
+ simd_eq ( a, transmute ( b) )
154
164
}
155
165
156
- /// Unsigned Compare bitwise equal to zero
166
+ /// Unsigned compare bitwise equal to zero
157
167
#[ inline]
158
168
#[ target_feature( enable = "neon" ) ]
159
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
169
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
160
170
pub unsafe fn vceqz_u8 ( a : uint8x8_t ) -> uint8x8_t {
161
- simd_eq ( a, transmute ( u8x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ) )
171
+ let b: u8x8 = u8x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ;
172
+ simd_eq ( a, transmute ( b) )
162
173
}
163
174
164
- /// Unsigned Compare bitwise equal to zero
175
+ /// Unsigned compare bitwise equal to zero
165
176
#[ inline]
166
177
#[ target_feature( enable = "neon" ) ]
167
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
178
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
168
179
pub unsafe fn vceqzq_u8 ( a : uint8x16_t ) -> uint8x16_t {
169
- simd_eq ( a, transmute ( u8x16:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ) )
180
+ let b: u8x16 = u8x16:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ;
181
+ simd_eq ( a, transmute ( b) )
170
182
}
171
183
172
- /// Unsigned Compare bitwise equal to zero
184
+ /// Unsigned compare bitwise equal to zero
173
185
#[ inline]
174
186
#[ target_feature( enable = "neon" ) ]
175
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
187
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
176
188
pub unsafe fn vceqz_u16 ( a : uint16x4_t ) -> uint16x4_t {
177
- simd_eq ( a, transmute ( u16x4:: new ( 0 , 0 , 0 , 0 ) ) )
189
+ let b: u16x4 = u16x4:: new ( 0 , 0 , 0 , 0 ) ;
190
+ simd_eq ( a, transmute ( b) )
178
191
}
179
192
180
- /// Unsigned Compare bitwise equal to zero
193
+ /// Unsigned compare bitwise equal to zero
181
194
#[ inline]
182
195
#[ target_feature( enable = "neon" ) ]
183
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
196
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
184
197
pub unsafe fn vceqzq_u16 ( a : uint16x8_t ) -> uint16x8_t {
185
- simd_eq ( a, transmute ( u16x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ) )
198
+ let b: u16x8 = u16x8:: new ( 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ;
199
+ simd_eq ( a, transmute ( b) )
186
200
}
187
201
188
- /// Unsigned Compare bitwise equal to zero
202
+ /// Unsigned compare bitwise equal to zero
189
203
#[ inline]
190
204
#[ target_feature( enable = "neon" ) ]
191
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
205
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
192
206
pub unsafe fn vceqz_u32 ( a : uint32x2_t ) -> uint32x2_t {
193
- simd_eq ( a, transmute ( u32x2:: new ( 0 , 0 ) ) )
207
+ let b: u32x2 = u32x2:: new ( 0 , 0 ) ;
208
+ simd_eq ( a, transmute ( b) )
194
209
}
195
210
196
- /// Unsigned Compare bitwise equal to zero
211
+ /// Unsigned compare bitwise equal to zero
197
212
#[ inline]
198
213
#[ target_feature( enable = "neon" ) ]
199
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
214
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
200
215
pub unsafe fn vceqzq_u32 ( a : uint32x4_t ) -> uint32x4_t {
201
- simd_eq ( a, transmute ( u32x4:: new ( 0 , 0 , 0 , 0 ) ) )
216
+ let b: u32x4 = u32x4:: new ( 0 , 0 , 0 , 0 ) ;
217
+ simd_eq ( a, transmute ( b) )
202
218
}
203
219
204
- /// Unsigned Compare bitwise equal to zero
220
+ /// Unsigned compare bitwise equal to zero
205
221
#[ inline]
206
222
#[ target_feature( enable = "neon" ) ]
207
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
223
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
208
224
pub unsafe fn vceqz_u64 ( a : uint64x1_t ) -> uint64x1_t {
209
- simd_eq ( a, transmute ( u64x1:: new ( 0 ) ) )
225
+ let b: u64x1 = u64x1:: new ( 0 ) ;
226
+ simd_eq ( a, transmute ( b) )
210
227
}
211
228
212
- /// Unsigned Compare bitwise equal to zero
229
+ /// Unsigned compare bitwise equal to zero
213
230
#[ inline]
214
231
#[ target_feature( enable = "neon" ) ]
215
- #[ cfg_attr( test, assert_instr( vceqz ) ) ]
232
+ #[ cfg_attr( test, assert_instr( cmeq ) ) ]
216
233
pub unsafe fn vceqzq_u64 ( a : uint64x2_t ) -> uint64x2_t {
217
- simd_eq ( a, transmute ( u64x2:: new ( 0 , 0 ) ) )
234
+ let b: u64x2 = u64x2:: new ( 0 , 0 ) ;
235
+ simd_eq ( a, transmute ( b) )
236
+ }
237
+
238
+ /// Floating-point compare bitwise equal to zero
239
+ #[ inline]
240
+ #[ target_feature( enable = "neon" ) ]
241
+ #[ cfg_attr( test, assert_instr( fcmeq) ) ]
242
+ pub unsafe fn vceqz_f32 ( a : float32x2_t ) -> uint32x2_t {
243
+ let b: f32x2 = f32x2:: new ( 0.0 , 0.0 ) ;
244
+ simd_eq ( a, transmute ( b) )
245
+ }
246
+
247
+ /// Floating-point compare bitwise equal to zero
248
+ #[ inline]
249
+ #[ target_feature( enable = "neon" ) ]
250
+ #[ cfg_attr( test, assert_instr( fcmeq) ) ]
251
+ pub unsafe fn vceqzq_f32 ( a : float32x4_t ) -> uint32x4_t {
252
+ let b: f32x4 = f32x4:: new ( 0.0 , 0.0 , 0.0 , 0.0 ) ;
253
+ simd_eq ( a, transmute ( b) )
254
+ }
255
+
256
+ /// Floating-point compare bitwise equal to zero
257
+ #[ inline]
258
+ #[ target_feature( enable = "neon" ) ]
259
+ #[ cfg_attr( test, assert_instr( fcmeq) ) ]
260
+ pub unsafe fn vceqz_f64 ( a : float64x1_t ) -> uint64x1_t {
261
+ let b: f64 = 0.0 ;
262
+ simd_eq ( a, transmute ( b) )
263
+ }
264
+
265
+ /// Floating-point compare bitwise equal to zero
266
+ #[ inline]
267
+ #[ target_feature( enable = "neon" ) ]
268
+ #[ cfg_attr( test, assert_instr( fcmeq) ) ]
269
+ pub unsafe fn vceqzq_f64 ( a : float64x2_t ) -> uint64x2_t {
270
+ let b: f64x2 = f64x2:: new ( 0.0 , 0.0 ) ;
271
+ simd_eq ( a, transmute ( b) )
218
272
}
219
273
220
274
/// Compare signed greater than
@@ -752,6 +806,38 @@ mod test {
752
806
assert_eq ! ( r, e) ;
753
807
}
754
808
809
+ #[ simd_test( enable = "neon" ) ]
810
+ unsafe fn test_vceqz_f32 ( ) {
811
+ let a: f32x2 = f32x2:: new ( 0.0 , 1.2 ) ;
812
+ let e: u32x2 = u32x2:: new ( 0xFF_FF_FF_FF , 0 ) ;
813
+ let r: u32x2 = transmute ( vceqz_f32 ( transmute ( a) ) ) ;
814
+ assert_eq ! ( r, e) ;
815
+ }
816
+
817
+ #[ simd_test( enable = "neon" ) ]
818
+ unsafe fn test_vceqzq_f32 ( ) {
819
+ let a: f32x4 = f32x4:: new ( 0.0 , 1.2 , 3.4 , 5.6 ) ;
820
+ let e: u32x4 = u32x4:: new ( 0xFF_FF_FF_FF , 0 , 0 , 0 ) ;
821
+ let r: u32x4 = transmute ( vceqzq_f32 ( transmute ( a) ) ) ;
822
+ assert_eq ! ( r, e) ;
823
+ }
824
+
825
+ #[ simd_test( enable = "neon" ) ]
826
+ unsafe fn test_vceqz_f64 ( ) {
827
+ let a: f64 = 0.0 ;
828
+ let e: u64x1 = u64x1:: new ( 0xFF_FF_FF_FF_FF_FF_FF_FF ) ;
829
+ let r: u64x1 = transmute ( vceqz_f64 ( transmute ( a) ) ) ;
830
+ assert_eq ! ( r, e) ;
831
+ }
832
+
833
+ #[ simd_test( enable = "neon" ) ]
834
+ unsafe fn test_vceqzq_f64 ( ) {
835
+ let a: f64x2 = f64x2:: new ( 0.0 , 1.2 ) ;
836
+ let e: u64x2 = u64x2:: new ( 0xFF_FF_FF_FF_FF_FF_FF_FF , 0 ) ;
837
+ let r: u64x2 = transmute ( vceqzq_f64 ( transmute ( a) ) ) ;
838
+ assert_eq ! ( r, e) ;
839
+ }
840
+
755
841
#[ simd_test( enable = "neon" ) ]
756
842
unsafe fn test_vcgt_s64 ( ) {
757
843
let a: i64x1 = i64x1:: new ( 1 ) ;
0 commit comments