begriffs open source - cmsis/blob - CMSIS/Core/Test/simd.c

   1 // REQUIRES: dsp
   2 // RUN: %cc% %ccflags% %ccout% %s.o %s; llvm-objdump --mcpu=%mcpu% -d %s.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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 }