core/stdarch/crates/core_arch/src/arm/
dsp.rs1#[cfg(test)]
24use stdarch_test::assert_instr;
25
26extern "unadjusted" {
27 #[link_name = "llvm.arm.smulbb"]
28 fn arm_smulbb(a: i32, b: i32) -> i32;
29
30 #[link_name = "llvm.arm.smulbt"]
31 fn arm_smulbt(a: i32, b: i32) -> i32;
32
33 #[link_name = "llvm.arm.smultb"]
34 fn arm_smultb(a: i32, b: i32) -> i32;
35
36 #[link_name = "llvm.arm.smultt"]
37 fn arm_smultt(a: i32, b: i32) -> i32;
38
39 #[link_name = "llvm.arm.smulwb"]
40 fn arm_smulwb(a: i32, b: i32) -> i32;
41
42 #[link_name = "llvm.arm.smulwt"]
43 fn arm_smulwt(a: i32, b: i32) -> i32;
44
45 #[link_name = "llvm.arm.qadd"]
46 fn arm_qadd(a: i32, b: i32) -> i32;
47
48 #[link_name = "llvm.arm.qsub"]
49 fn arm_qsub(a: i32, b: i32) -> i32;
50
51 #[link_name = "llvm.arm.smlabb"]
52 fn arm_smlabb(a: i32, b: i32, c: i32) -> i32;
53
54 #[link_name = "llvm.arm.smlabt"]
55 fn arm_smlabt(a: i32, b: i32, c: i32) -> i32;
56
57 #[link_name = "llvm.arm.smlatb"]
58 fn arm_smlatb(a: i32, b: i32, c: i32) -> i32;
59
60 #[link_name = "llvm.arm.smlatt"]
61 fn arm_smlatt(a: i32, b: i32, c: i32) -> i32;
62
63 #[link_name = "llvm.arm.smlawb"]
64 fn arm_smlawb(a: i32, b: i32, c: i32) -> i32;
65
66 #[link_name = "llvm.arm.smlawt"]
67 fn arm_smlawt(a: i32, b: i32, c: i32) -> i32;
68}
69
70#[inline]
75#[cfg_attr(test, assert_instr(smulbb))]
76#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
77pub unsafe fn __smulbb(a: i32, b: i32) -> i32 {
78 arm_smulbb(a, b)
79}
80
81#[inline]
86#[cfg_attr(test, assert_instr(smultb))]
87#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
88pub unsafe fn __smultb(a: i32, b: i32) -> i32 {
89 arm_smultb(a, b)
90}
91
92#[inline]
97#[cfg_attr(test, assert_instr(smulbt))]
98#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
99pub unsafe fn __smulbt(a: i32, b: i32) -> i32 {
100 arm_smulbt(a, b)
101}
102
103#[inline]
108#[cfg_attr(test, assert_instr(smultt))]
109#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
110pub unsafe fn __smultt(a: i32, b: i32) -> i32 {
111 arm_smultt(a, b)
112}
113
114#[inline]
120#[cfg_attr(test, assert_instr(smulwb))]
121#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
122pub unsafe fn __smulwb(a: i32, b: i32) -> i32 {
123 arm_smulwb(a, b)
124}
125
126#[inline]
132#[cfg_attr(test, assert_instr(smulwt))]
133#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
134pub unsafe fn __smulwt(a: i32, b: i32) -> i32 {
135 arm_smulwt(a, b)
136}
137
138#[inline]
143#[cfg_attr(test, assert_instr(qadd))]
144#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
145pub unsafe fn __qadd(a: i32, b: i32) -> i32 {
146 arm_qadd(a, b)
147}
148
149#[inline]
154#[cfg_attr(test, assert_instr(qsub))]
155#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
156pub unsafe fn __qsub(a: i32, b: i32) -> i32 {
157 arm_qsub(a, b)
158}
159
160#[inline]
165#[cfg_attr(test, assert_instr(qadd))]
166#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
167pub unsafe fn __qdbl(a: i32) -> i32 {
168 arm_qadd(a, a)
169}
170
171#[inline]
177#[cfg_attr(test, assert_instr(smlabb))]
178#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
179pub unsafe fn __smlabb(a: i32, b: i32, c: i32) -> i32 {
180 arm_smlabb(a, b, c)
181}
182
183#[inline]
189#[cfg_attr(test, assert_instr(smlabt))]
190#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
191pub unsafe fn __smlabt(a: i32, b: i32, c: i32) -> i32 {
192 arm_smlabt(a, b, c)
193}
194
195#[inline]
201#[cfg_attr(test, assert_instr(smlatb))]
202#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
203pub unsafe fn __smlatb(a: i32, b: i32, c: i32) -> i32 {
204 arm_smlatb(a, b, c)
205}
206
207#[inline]
213#[cfg_attr(test, assert_instr(smlatt))]
214#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
215pub unsafe fn __smlatt(a: i32, b: i32, c: i32) -> i32 {
216 arm_smlatt(a, b, c)
217}
218
219#[inline]
225#[cfg_attr(test, assert_instr(smlawb))]
226#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
227pub unsafe fn __smlawb(a: i32, b: i32, c: i32) -> i32 {
228 arm_smlawb(a, b, c)
229}
230
231#[inline]
237#[cfg_attr(test, assert_instr(smlawt))]
238#[unstable(feature = "stdarch_arm_dsp", issue = "117237")]
239pub unsafe fn __smlawt(a: i32, b: i32, c: i32) -> i32 {
240 arm_smlawt(a, b, c)
241}
242
243#[cfg(test)]
244mod tests {
245 use crate::core_arch::{
246 arm::*,
247 simd::{i16x2, i8x4, u8x4},
248 };
249 use std::mem::transmute;
250 use stdarch_test::simd_test;
251
252 #[test]
253 fn smulbb() {
254 unsafe {
255 let a = i16x2::new(10, 20);
256 let b = i16x2::new(30, 40);
257 assert_eq!(super::__smulbb(transmute(a), transmute(b)), 10 * 30);
258 }
259 }
260
261 #[test]
262 fn smulbt() {
263 unsafe {
264 let a = i16x2::new(10, 20);
265 let b = i16x2::new(30, 40);
266 assert_eq!(super::__smulbt(transmute(a), transmute(b)), 10 * 40);
267 }
268 }
269
270 #[test]
271 fn smultb() {
272 unsafe {
273 let a = i16x2::new(10, 20);
274 let b = i16x2::new(30, 40);
275 assert_eq!(super::__smultb(transmute(a), transmute(b)), 20 * 30);
276 }
277 }
278
279 #[test]
280 fn smultt() {
281 unsafe {
282 let a = i16x2::new(10, 20);
283 let b = i16x2::new(30, 40);
284 assert_eq!(super::__smultt(transmute(a), transmute(b)), 20 * 40);
285 }
286 }
287
288 #[test]
289 fn smulwb() {
290 unsafe {
291 let a = i16x2::new(10, 20);
292 let b = 30;
293 assert_eq!(super::__smulwb(transmute(a), b), 20 * b);
294 }
295 }
296
297 #[test]
298 fn smulwt() {
299 unsafe {
300 let a = i16x2::new(10, 20);
301 let b = 30;
302 assert_eq!(super::__smulwt(transmute(a), b), (10 * b) >> 16);
303 }
304 }
305
306 #[test]
307 fn qadd() {
308 unsafe {
309 assert_eq!(super::__qadd(-10, 60), 50);
310 assert_eq!(super::__qadd(i32::MAX, 10), i32::MAX);
311 assert_eq!(super::__qadd(i32::MIN, -10), i32::MIN);
312 }
313 }
314
315 #[test]
316 fn qsub() {
317 unsafe {
318 assert_eq!(super::__qsub(10, 60), -50);
319 assert_eq!(super::__qsub(i32::MAX, -10), i32::MAX);
320 assert_eq!(super::__qsub(i32::MIN, 10), i32::MIN);
321 }
322 }
323
324 fn qdbl() {
325 unsafe {
326 assert_eq!(super::__qdbl(10), 20);
327 assert_eq!(super::__qdbl(i32::MAX), i32::MAX);
328 }
329 }
330
331 fn smlabb() {
332 unsafe {
333 let a = i16x2::new(10, 20);
334 let b = i16x2::new(30, 40);
335 let c = 50;
336 let r = (10 * 30) + c;
337 assert_eq!(super::__smlabb(transmute(a), transmute(b), c), r);
338 }
339 }
340
341 fn smlabt() {
342 unsafe {
343 let a = i16x2::new(10, 20);
344 let b = i16x2::new(30, 40);
345 let c = 50;
346 let r = (10 * 40) + c;
347 assert_eq!(super::__smlabt(transmute(a), transmute(b), c), r);
348 }
349 }
350
351 fn smlatb() {
352 unsafe {
353 let a = i16x2::new(10, 20);
354 let b = i16x2::new(30, 40);
355 let c = 50;
356 let r = (20 * 30) + c;
357 assert_eq!(super::__smlabt(transmute(a), transmute(b), c), r);
358 }
359 }
360
361 fn smlatt() {
362 unsafe {
363 let a = i16x2::new(10, 20);
364 let b = i16x2::new(30, 40);
365 let c = 50;
366 let r = (20 * 40) + c;
367 assert_eq!(super::__smlatt(transmute(a), transmute(b), c), r);
368 }
369 }
370
371 fn smlawb() {
372 unsafe {
373 let a: i32 = 10;
374 let b = i16x2::new(30, 40);
375 let c: i32 = 50;
376 let r: i32 = ((a * 30) + (c << 16)) >> 16;
377 assert_eq!(super::__smlawb(a, transmute(b), c), r);
378 }
379 }
380
381 fn smlawt() {
382 unsafe {
383 let a: i32 = 10;
384 let b = i16x2::new(30, 40);
385 let c: i32 = 50;
386 let r: i32 = ((a * 40) + (c << 16)) >> 16;
387 assert_eq!(super::__smlawt(a, transmute(b), c), r);
388 }
389 }
390}