1 // REQUIRES: dsp
2 // RUN: %cc% %ccflags% %ccout% %T/%basename_t.o %s; llvm-objdump --mcpu=%mcpu% -d %T/%basename_t.o | FileCheck --allow-unused-prefixes --check-prefixes %prefixes% %s
3
4 #include "cmsis_compiler.h"
5
6 volatile static int32_t s32_1 = 0x47;
7 volatile static int32_t s32_2 = 0x11;
8 volatile static int32_t s32_3 = 0x15;
9 volatile static uint8_t u8 = 5u;
10
11 /* ADD8 */
12
sadd8()13 void sadd8() {
14 // CHECK-LABEL: <sadd8>:
15 // CHECK: sadd8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
16 volatile uint32_t result = __SADD8(s32_1, s32_2);
17 // CHECK: {{(bx lr)|(pop {.*pc})}}
18 }
19
qadd8()20 void qadd8() {
21 // CHECK-LABEL: <qadd8>:
22 // CHECK: qadd8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
23 volatile uint32_t result = __QADD8(s32_1, s32_2);
24 // CHECK: {{(bx lr)|(pop {.*pc})}}
25 }
26
shadd8()27 void shadd8() {
28 // CHECK-LABEL: <shadd8>:
29 // CHECK: shadd8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
30 volatile uint32_t result = __SHADD8(s32_1, s32_2);
31 // CHECK: {{(bx lr)|(pop {.*pc})}}
32 }
33
uadd8()34 void uadd8() {
35 // CHECK-LABEL: <uadd8>:
36 // CHECK: uadd8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
37 volatile uint32_t result = __UADD8(s32_1, s32_2);
38 // CHECK: {{(bx lr)|(pop {.*pc})}}
39 }
40
uqadd8()41 void uqadd8() {
42 // CHECK-LABEL: <uqadd8>:
43 // CHECK: uqadd8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
44 volatile uint32_t result = __UQADD8(s32_1, s32_2);
45 // CHECK: {{(bx lr)|(pop {.*pc})}}
46 }
47
uhadd8()48 void uhadd8() {
49 // CHECK-LABEL: <uhadd8>:
50 // CHECK: uhadd8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
51 volatile uint32_t result = __UHADD8(s32_1, s32_2);
52 // CHECK: {{(bx lr)|(pop {.*pc})}}
53 }
54
55 /* SUB8 */
56
ssub8()57 void ssub8() {
58 // CHECK-LABEL: <ssub8>:
59 // CHECK: ssub8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
60 volatile uint32_t result = __SSUB8(s32_1, s32_2);
61 // CHECK: {{(bx lr)|(pop {.*pc})}}
62 }
63
qsub8()64 void qsub8() {
65 // CHECK-LABEL: <qsub8>:
66 // CHECK: qsub8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
67 volatile uint32_t result = __QSUB8(s32_1, s32_2);
68 // CHECK: {{(bx lr)|(pop {.*pc})}}
69 }
70
shsub8()71 void shsub8() {
72 // CHECK-LABEL: <shsub8>:
73 // CHECK: shsub8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
74 volatile uint32_t result = __SHSUB8(s32_1, s32_2);
75 // CHECK: {{(bx lr)|(pop {.*pc})}}
76 }
77
usub8()78 void usub8() {
79 // CHECK-LABEL: <usub8>:
80 // CHECK: usub8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
81 volatile uint32_t result = __USUB8(s32_1, s32_2);
82 // CHECK: {{(bx lr)|(pop {.*pc})}}
83 }
84
uqsub8()85 void uqsub8() {
86 // CHECK-LABEL: <uqsub8>:
87 // CHECK: uqsub8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
88 volatile uint32_t result = __UQSUB8(s32_1, s32_2);
89 // CHECK: {{(bx lr)|(pop {.*pc})}}
90 }
91
uhsub8()92 void uhsub8() {
93 // CHECK-LABEL: <uhsub8>:
94 // CHECK: uhsub8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
95 volatile uint32_t result = __UHSUB8(s32_1, s32_2);
96 // CHECK: {{(bx lr)|(pop {.*pc})}}
97 }
98
99 /* ADD16 */
100
sadd16()101 void sadd16() {
102 // CHECK-LABEL: <sadd16>:
103 // CHECK: sadd16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
104 volatile uint32_t result = __SADD16(s32_1, s32_2);
105 // CHECK: {{(bx lr)|(pop {.*pc})}}
106 }
107
qadd16()108 void qadd16() {
109 // CHECK-LABEL: <qadd16>:
110 // CHECK: qadd16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
111 volatile uint32_t result = __QADD16(s32_1, s32_2);
112 // CHECK: {{(bx lr)|(pop {.*pc})}}
113 }
114
shadd16()115 void shadd16() {
116 // CHECK-LABEL: <shadd16>:
117 // CHECK: shadd16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
118 volatile uint32_t result = __SHADD16(s32_1, s32_2);
119 // CHECK: {{(bx lr)|(pop {.*pc})}}
120 }
121
uadd16()122 void uadd16() {
123 // CHECK-LABEL: <uadd16>:
124 // CHECK: uadd16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
125 volatile uint32_t result = __UADD16(s32_1, s32_2);
126 // CHECK: {{(bx lr)|(pop {.*pc})}}
127 }
128
uqadd16()129 void uqadd16() {
130 // CHECK-LABEL: <uqadd16>:
131 // CHECK: uqadd16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
132 volatile uint32_t result = __UQADD16(s32_1, s32_2);
133 // CHECK: {{(bx lr)|(pop {.*pc})}}
134 }
135
uhadd16()136 void uhadd16() {
137 // CHECK-LABEL: <uhadd16>:
138 // CHECK: uhadd16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
139 volatile uint32_t result = __UHADD16(s32_1, s32_2);
140 // CHECK: {{(bx lr)|(pop {.*pc})}}
141 }
142
143 /* SUB16 */
144
ssub16()145 void ssub16() {
146 // CHECK-LABEL: <ssub16>:
147 // CHECK: ssub16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
148 volatile uint32_t result = __SSUB16(s32_1, s32_2);
149 // CHECK: {{(bx lr)|(pop {.*pc})}}
150 }
151
qsub16()152 void qsub16() {
153 // CHECK-LABEL: <qsub16>:
154 // CHECK: qsub16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
155 volatile uint32_t result = __QSUB16(s32_1, s32_2);
156 // CHECK: {{(bx lr)|(pop {.*pc})}}
157 }
158
shsub16()159 void shsub16() {
160 // CHECK-LABEL: <shsub16>:
161 // CHECK: shsub16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
162 volatile uint32_t result = __SHSUB16(s32_1, s32_2);
163 // CHECK: {{(bx lr)|(pop {.*pc})}}
164 }
165
usub16()166 void usub16() {
167 // CHECK-LABEL: <usub16>:
168 // CHECK: usub16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
169 volatile uint32_t result = __USUB16(s32_1, s32_2);
170 // CHECK: {{(bx lr)|(pop {.*pc})}}
171 }
172
uqsub16()173 void uqsub16() {
174 // CHECK-LABEL: <uqsub16>:
175 // CHECK: uqsub16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
176 volatile uint32_t result = __UQSUB16(s32_1, s32_2);
177 // CHECK: {{(bx lr)|(pop {.*pc})}}
178 }
179
uhsub16()180 void uhsub16() {
181 // CHECK-LABEL: <uhsub16>:
182 // CHECK: uhsub16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
183 volatile uint32_t result = __UHSUB16(s32_1, s32_2);
184 // CHECK: {{(bx lr)|(pop {.*pc})}}
185 }
186
187 /* ASX */
188
sasx()189 void sasx() {
190 // CHECK-LABEL: <sasx>:
191 // CHECK: sasx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
192 volatile uint32_t result = __SASX(s32_1, s32_2);
193 // CHECK: {{(bx lr)|(pop {.*pc})}}
194 }
195
qasx()196 void qasx() {
197 // CHECK-LABEL: <qasx>:
198 // CHECK: qasx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
199 volatile uint32_t result = __QASX(s32_1, s32_2);
200 // CHECK: {{(bx lr)|(pop {.*pc})}}
201 }
202
shasx()203 void shasx() {
204 // CHECK-LABEL: <shasx>:
205 // CHECK: shasx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
206 volatile uint32_t result = __SHASX(s32_1, s32_2);
207 // CHECK: {{(bx lr)|(pop {.*pc})}}
208 }
209
uasx()210 void uasx() {
211 // CHECK-LABEL: <uasx>:
212 // CHECK: uasx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
213 volatile uint32_t result = __UASX(s32_1, s32_2);
214 // CHECK: {{(bx lr)|(pop {.*pc})}}
215 }
216
uqasx()217 void uqasx() {
218 // CHECK-LABEL: <uqasx>:
219 // CHECK: uqasx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
220 volatile uint32_t result = __UQASX(s32_1, s32_2);
221 // CHECK: {{(bx lr)|(pop {.*pc})}}
222 }
223
uhasx()224 void uhasx() {
225 // CHECK-LABEL: <uhasx>:
226 // CHECK: uhasx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
227 volatile uint32_t result = __UHASX(s32_1, s32_2);
228 // CHECK: {{(bx lr)|(pop {.*pc})}}
229 }
230
231 /* SAX */
232
ssax()233 void ssax() {
234 // CHECK-LABEL: <ssax>:
235 // CHECK: ssax {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
236 volatile uint32_t result = __SSAX(s32_1, s32_2);
237 // CHECK: {{(bx lr)|(pop {.*pc})}}
238 }
239
qsax()240 void qsax() {
241 // CHECK-LABEL: <qsax>:
242 // CHECK: qsax {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
243 volatile uint32_t result = __QSAX(s32_1, s32_2);
244 // CHECK: {{(bx lr)|(pop {.*pc})}}
245 }
246
shsax()247 void shsax() {
248 // CHECK-LABEL: <shsax>:
249 // CHECK: shsax {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
250 volatile uint32_t result = __SHSAX(s32_1, s32_2);
251 // CHECK: {{(bx lr)|(pop {.*pc})}}
252 }
253
usax()254 void usax() {
255 // CHECK-LABEL: <usax>:
256 // CHECK: usax {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
257 volatile uint32_t result = __USAX(s32_1, s32_2);
258 // CHECK: {{(bx lr)|(pop {.*pc})}}
259 }
260
uqsax()261 void uqsax() {
262 // CHECK-LABEL: <uqsax>:
263 // CHECK: uqsax {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
264 volatile uint32_t result = __UQSAX(s32_1, s32_2);
265 // CHECK: {{(bx lr)|(pop {.*pc})}}
266 }
267
uhsax()268 void uhsax() {
269 // CHECK-LABEL: <uhsax>:
270 // CHECK: uhsax {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
271 volatile uint32_t result = __UHSAX(s32_1, s32_2);
272 // CHECK: {{(bx lr)|(pop {.*pc})}}
273 }
274
275 /* SAT */
276
usad8()277 void usad8() {
278 // CHECK-LABEL: <usad8>:
279 // CHECK: usad8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
280 volatile uint32_t result = __USAD8(s32_1, s32_2);
281 // CHECK: {{(bx lr)|(pop {.*pc})}}
282 }
283
usada8()284 void usada8() {
285 // CHECK-LABEL: <usada8>:
286 // CHECK: usada8 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
287 volatile uint32_t result = __USADA8(s32_1, s32_2, s32_3);
288 // CHECK: {{(bx lr)|(pop {.*pc})}}
289 }
290
ssat16()291 void ssat16() {
292 // CHECK-LABEL: <ssat16>:
293 // CHECK: ssat16 {{r[0-9]+}}, #0x5, {{r[0-9]+}}
294 volatile uint32_t result = __SSAT16(s32_1, 0x05);
295 // CHECK: {{(bx lr)|(pop {.*pc})}}
296 }
297
usat16()298 void usat16() {
299 // CHECK-LABEL: <usat16>:
300 // CHECK: usat16 {{r[0-9]+}}, #0x5, {{r[0-9]+}}
301 volatile uint32_t result = __USAT16(s32_1, 0x05);
302 // CHECK: {{(bx lr)|(pop {.*pc})}}
303 }
304
uxtb16()305 void uxtb16() {
306 // CHECK-LABEL: <uxtb16>:
307 // CHECK: uxtb16 {{r[0-9]+}}, {{r[0-9]+}}
308 volatile uint32_t result = __UXTB16(s32_1);
309 // CHECK: {{(bx lr)|(pop {.*pc})}}
310 }
311
uxtab16()312 void uxtab16() {
313 // CHECK-LABEL: <uxtab16>:
314 // CHECK: uxtab16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
315 volatile uint32_t result = __UXTAB16(s32_1, s32_2);
316 // CHECK: {{(bx lr)|(pop {.*pc})}}
317 }
318
sxtb16()319 void sxtb16() {
320 // CHECK-LABEL: <sxtb16>:
321 // CHECK: sxtb16 {{r[0-9]+}}, {{r[0-9]+}}
322 volatile uint32_t result = __SXTB16(s32_1);
323 // CHECK: {{(bx lr)|(pop {.*pc})}}
324 }
325
sxtab16()326 void sxtab16() {
327 // CHECK-LABEL: <sxtab16>:
328 // CHECK: sxtab16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
329 volatile uint32_t result = __SXTAB16(s32_1, s32_2);
330 // CHECK: {{(bx lr)|(pop {.*pc})}}
331 }
332
333 /* MUL */
334
smuad()335 void smuad() {
336 // CHECK-LABEL: <smuad>:
337 // CHECK: smuad {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
338 volatile uint32_t result = __SMUAD(s32_1, s32_2);
339 // CHECK: {{(bx lr)|(pop {.*pc})}}
340 }
341
smuadx()342 void smuadx() {
343 // CHECK-LABEL: <smuadx>:
344 // CHECK: smuadx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
345 volatile uint32_t result = __SMUADX(s32_1, s32_2);
346 // CHECK: {{(bx lr)|(pop {.*pc})}}
347 }
348
smlad()349 void smlad() {
350 // CHECK-LABEL: <smlad>:
351 // CHECK: smlad {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
352 volatile uint32_t result = __SMLAD(s32_1, s32_2, s32_3);
353 // CHECK: {{(bx lr)|(pop {.*pc})}}
354 }
355
smladx()356 void smladx() {
357 // CHECK-LABEL: <smladx>:
358 // CHECK: smladx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
359 volatile uint32_t result = __SMLADX(s32_1, s32_2, s32_3);
360 // CHECK: {{(bx lr)|(pop {.*pc})}}
361 }
362
smlald()363 void smlald() {
364 // CHECK-LABEL: <smlald>:
365 // CHECK: smlald {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
366 volatile uint32_t result = __SMLALD(s32_1, s32_2, s32_3);
367 // CHECK: {{(bx lr)|(pop {.*pc})}}
368 }
369
smlaldx()370 void smlaldx() {
371 // CHECK-LABEL: <smlaldx>:
372 // CHECK: smlaldx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
373 volatile uint32_t result = __SMLALDX(s32_1, s32_2, s32_3);
374 // CHECK: {{(bx lr)|(pop {.*pc})}}
375 }
376
smusd()377 void smusd() {
378 // CHECK-LABEL: <smusd>:
379 // CHECK: smusd {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
380 volatile uint32_t result = __SMUSD(s32_1, s32_2);
381 // CHECK: {{(bx lr)|(pop {.*pc})}}
382 }
383
smusdx()384 void smusdx() {
385 // CHECK-LABEL: <smusdx>:
386 // CHECK: smusdx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
387 volatile uint32_t result = __SMUSDX(s32_1, s32_2);
388 // CHECK: {{(bx lr)|(pop {.*pc})}}
389 }
390
smlsd()391 void smlsd() {
392 // CHECK-LABEL: <smlsd>:
393 // CHECK: smlsd {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
394 volatile uint32_t result = __SMLSD(s32_1, s32_2, s32_3);
395 // CHECK: {{(bx lr)|(pop {.*pc})}}
396 }
397
smlsdx()398 void smlsdx() {
399 // CHECK-LABEL: <smlsdx>:
400 // CHECK: smlsdx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
401 volatile uint32_t result = __SMLSDX(s32_1, s32_2, s32_3);
402 // CHECK: {{(bx lr)|(pop {.*pc})}}
403 }
404
smlsld()405 void smlsld() {
406 // CHECK-LABEL: <smlsld>:
407 // CHECK: smlsld {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
408 volatile uint32_t result = __SMLSLD(s32_1, s32_2, s32_3);
409 // CHECK: {{(bx lr)|(pop {.*pc})}}
410 }
411
smlsldx()412 void smlsldx() {
413 // CHECK-LABEL: <smlsldx>:
414 // CHECK: smlsldx {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
415 volatile uint32_t result = __SMLSLDX(s32_1, s32_2, s32_3);
416 // CHECK: {{(bx lr)|(pop {.*pc})}}
417 }
418
sel()419 void sel() {
420 // CHECK-LABEL: <sel>:
421 // CHECK: sel {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
422 volatile uint32_t result = __SEL(s32_1, s32_2);
423 // CHECK: {{(bx lr)|(pop {.*pc})}}
424 }
425
qadd()426 void qadd() {
427 // CHECK-LABEL: <qadd>:
428 // CHECK: qadd {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
429 volatile uint32_t result = __QADD(s32_1, s32_2);
430 // CHECK: {{(bx lr)|(pop {.*pc})}}
431 }
432
qsub()433 void qsub() {
434 // CHECK-LABEL: <qsub>:
435 // CHECK: qsub {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
436 volatile uint32_t result = __QSUB(s32_1, s32_2);
437 // CHECK: {{(bx lr)|(pop {.*pc})}}
438 }
439
pkhbt0()440 void pkhbt0() {
441 // CHECK-LABEL: <pkhbt0>:
442 // CHECK: {{pkhtb|pkhbt}} {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
443 // CHECK-NOT: , lsl
444 // CHECK-NOT: , asr
445 volatile uint32_t result = __PKHBT(s32_1, s32_2, 0);
446 // CHECK: {{(bx lr)|(pop {.*pc})}}
447 }
448
pkhbt()449 void pkhbt() {
450 // CHECK-LABEL: <pkhbt>:
451 // CHECK: pkhbt {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, lsl #11
452 volatile uint32_t result = __PKHBT(s32_1, s32_2, 11);
453 // CHECK: {{(bx lr)|(pop {.*pc})}}
454 }
455
pkhtb0()456 void pkhtb0() {
457 // CHECK-LABEL: <pkhtb0>:
458 // CHECK: {{pkhtb|pkhbt}} {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
459 // CHECK-NOT: , lsl
460 // CHECK-NOT: , asr
461 volatile uint32_t result = __PKHTB(s32_1, s32_2, 0);
462 // CHECK: {{(bx lr)|(pop {.*pc})}}
463 }
464
pkhtb()465 void pkhtb() {
466 // CHECK-LABEL: <pkhtb>:
467 // CHECK: pkhtb {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, asr #11
468 volatile uint32_t result = __PKHTB(s32_1, s32_2, 11);
469 // CHECK: {{(bx lr)|(pop {.*pc})}}
470 }
471
sxtb16_ror()472 void sxtb16_ror() {
473 // CHECK-LABEL: <sxtb16_ror>:
474 // CHECK: sxtb16 {{r[0-9]+}}, {{r[0-9]+}}, ror #8
475 volatile uint32_t result = __SXTB16_RORn(s32_1, 8);
476
477 // CHECK: sxtb16 {{r[0-9]+}}, {{r[0-9]+}}, ror #16
478 result = __SXTB16_RORn(s32_1, 16);
479
480 // CHECK: sxtb16 {{r[0-9]+}}, {{r[0-9]+}}, ror #24
481 result = __SXTB16_RORn(s32_1, 24);
482
483 // CHECK-THUMB: ror.w [[REG:r[0-9]+]], {{r[0-9]+}}, {{#5|#0x5}}
484 // CHECK-ARM: ror [[REG:r[0-9]+]], {{r[0-9]+}}, {{#5|#0x5}}
485 // CHECK: sxtb16 {{r[0-9]+}}, [[REG]]
486 // CHECK-NOT: , ror
487 result = __SXTB16_RORn(s32_1, 5);
488
489 // CHECK-THUMB: ror{{.w|ne|s}} {{r[0-9]+}}, {{r[0-9]+}}
490 // CHECK-ARM: ror{{(ne)?}} {{r[0-9]+}}, {{r[0-9]+}}
491 // CHECK: sxtb16 {{r[0-9]+}}, {{r[0-9]+}}
492 // CHECK-NOT: , ror
493 result = __SXTB16_RORn(s32_1, u8);
494
495 // CHECK: {{(bx lr)|(pop {.*pc})}}
496 }
497
sxtab16_ror()498 void sxtab16_ror() {
499 // CHECK-LABEL: <sxtab16_ror>:
500
501 // CHECK: sxtab16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, ror #8
502 volatile uint32_t result = __SXTAB16_RORn(s32_1, s32_2, 8);
503
504 // CHECK: sxtab16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, ror #16
505 result = __SXTAB16_RORn(s32_1, s32_2, 16);
506
507 // CHECK: sxtab16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, ror #24
508 result = __SXTAB16_RORn(s32_1, s32_2, 24);
509
510 // CHECK-THUMB: ror.w [[REG:r[0-9]+]], {{r[0-9]+}}, {{#5|#0x5}}
511 // CHECK-ARM: ror [[REG:r[0-9]+]], {{r[0-9]+}}, {{#5|#0x5}}
512 // CHECK: sxtab16 {{r[0-9]+}}, {{r[0-9]+}}, [[REG]]
513 // CHECK-NOT: , ror
514 result = __SXTAB16_RORn(s32_1, s32_2, 5);
515
516 // CHECK-THUMB: ror{{.w|ne|s}} {{r[0-9]+}}, {{r[0-9]+}}
517 // CHECK-ARM: ror{{(ne)?}} {{r[0-9]+}}, {{r[0-9]+}}
518 // CHECK: sxtab16 {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
519 // CHECK-NOT: , ror
520 result = __SXTAB16_RORn(s32_1, s32_2, u8);
521
522 // CHECK: {{(bx lr)|(pop {.*pc})}}
523 }
524
smmla()525 void smmla() {
526 // CHECK-LABEL: <smmla>:
527 // CHECK: smmla {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}, {{r[0-9]+}}
528 volatile int32_t result = __SMMLA(s32_1, s32_2, s32_3);
529 // CHECK: {{(bx lr)|(pop {.*pc})}}
530 }
531
