git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_CEC_MEC_17xx_51xx_Keil_GCC/CMSIS/cmsis_gcc.h

   1 /**************************************************************************//**\r
   2  * @file     cmsis_gcc.h\r
   3  * @brief    CMSIS Cortex-M Core Function/Instruction Header File\r
   4  * @version  V5.00\r
   5  * @date     02. March 2016\r
   6  ******************************************************************************/\r
   7 /*\r
   8  * Copyright (c) 2009-2016 ARM Limited. All rights reserved.\r
   9  *\r
  10  * SPDX-License-Identifier: Apache-2.0\r
  11  *\r
  12  * Licensed under the Apache License, Version 2.0 (the License); you may\r
  13  * not use this file except in compliance with the License.\r
  14  * You may obtain a copy of the License at\r
  15  *\r
  16  * http://www.apache.org/licenses/LICENSE-2.0\r
  17  *\r
  18  * Unless required by applicable law or agreed to in writing, software\r
  19  * distributed under the License is distributed on an AS IS BASIS, WITHOUT\r
  20  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  21  * See the License for the specific language governing permissions and\r
  22  * limitations under the License.\r
  23  */\r
  24 \r
  25 #ifndef __CMSIS_GCC_H\r
  26 #define __CMSIS_GCC_H\r
  27 \r
  28 /* ignore some GCC warnings */\r
  29 #if defined ( __GNUC__ )\r
  30 #pragma GCC diagnostic push\r
  31 #pragma GCC diagnostic ignored "-Wsign-conversion"\r
  32 #pragma GCC diagnostic ignored "-Wconversion"\r
  33 #pragma GCC diagnostic ignored "-Wunused-parameter"\r
  34 #endif\r
  35 \r
  36 \r
  37 /* ###########################  Core Function Access  ########################### */\r
  38 /** \ingroup  CMSIS_Core_FunctionInterface\r
  39     \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions\r
  40   @{\r
  41  */\r
  42 \r
  43 /**\r
  44   \brief   Enable IRQ Interrupts\r
  45   \details Enables IRQ interrupts by clearing the I-bit in the CPSR.\r
  46            Can only be executed in Privileged modes.\r
  47  */\r
  48 __attribute__((always_inline)) __STATIC_INLINE void __enable_irq(void)\r
  49 {\r
  50   __ASM volatile ("cpsie i" : : : "memory");\r
  51 }\r
  52 \r
  53 \r
  54 /**\r
  55   \brief   Disable IRQ Interrupts\r
  56   \details Disables IRQ interrupts by setting the I-bit in the CPSR.\r
  57            Can only be executed in Privileged modes.\r
  58  */\r
  59 __attribute__((always_inline)) __STATIC_INLINE void __disable_irq(void)\r
  60 {\r
  61   __ASM volatile ("cpsid i" : : : "memory");\r
  62 }\r
  63 \r
  64 \r
  65 /**\r
  66   \brief   Get Control Register\r
  67   \details Returns the content of the Control Register.\r
  68   \return               Control Register value\r
  69  */\r
  70 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_CONTROL(void)\r
  71 {\r
  72   uint32_t result;\r
  73 \r
  74   __ASM volatile ("MRS %0, control" : "=r" (result) );\r
  75   return(result);\r
  76 }\r
  77 \r
  78 \r
  79 /**\r
  80   \brief   Set Control Register\r
  81   \details Writes the given value to the Control Register.\r
  82   \param [in]    control  Control Register value to set\r
  83  */\r
  84 __attribute__((always_inline)) __STATIC_INLINE void __set_CONTROL(uint32_t control)\r
  85 {\r
  86   __ASM volatile ("MSR control, %0" : : "r" (control) : "memory");\r
  87 }\r
  88 \r
  89 \r
  90 /**\r
  91   \brief   Get IPSR Register\r
  92   \details Returns the content of the IPSR Register.\r
  93   \return               IPSR Register value\r
  94  */\r
  95 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_IPSR(void)\r
  96 {\r
  97   uint32_t result;\r
  98 \r
  99   __ASM volatile ("MRS %0, ipsr" : "=r" (result) );\r
 100   return(result);\r
 101 }\r
 102 \r
 103 \r
 104 /**\r
 105   \brief   Get APSR Register\r
 106   \details Returns the content of the APSR Register.\r
 107   \return               APSR Register value\r
 108  */\r
 109 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_APSR(void)\r
 110 {\r
 111   uint32_t result;\r
 112 \r
 113   __ASM volatile ("MRS %0, apsr" : "=r" (result) );\r
 114   return(result);\r
 115 }\r
 116 \r
 117 \r
 118 /**\r
 119   \brief   Get xPSR Register\r
 120   \details Returns the content of the xPSR Register.\r
 121   \return               xPSR Register value\r
 122  */\r
 123 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_xPSR(void)\r
 124 {\r
 125   uint32_t result;\r
 126 \r
 127   __ASM volatile ("MRS %0, xpsr" : "=r" (result) );\r
 128   return(result);\r
 129 }\r
 130 \r
 131 \r
 132 /**\r
 133   \brief   Get Process Stack Pointer\r
 134   \details Returns the current value of the Process Stack Pointer (PSP).\r
 135   \return               PSP Register value\r
 136  */\r
 137 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_PSP(void)\r
 138 {\r
 139   register uint32_t result;\r
 140 \r
 141   __ASM volatile ("MRS %0, psp"  : "=r" (result) );\r
 142   return(result);\r
 143 }\r
 144 \r
 145 \r
 146 /**\r
 147   \brief   Set Process Stack Pointer\r
 148   \details Assigns the given value to the Process Stack Pointer (PSP).\r
 149   \param [in]    topOfProcStack  Process Stack Pointer value to set\r
 150  */\r
 151 __attribute__((always_inline)) __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)\r
 152 {\r
 153   __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : "sp");\r
 154 }\r
 155 \r
 156 \r
 157 /**\r
 158   \brief   Get Main Stack Pointer\r
 159   \details Returns the current value of the Main Stack Pointer (MSP).\r
 160   \return               MSP Register value\r
 161  */\r
 162 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_MSP(void)\r
 163 {\r
 164   register uint32_t result;\r
 165 \r
 166   __ASM volatile ("MRS %0, msp" : "=r" (result) );\r
 167   return(result);\r
 168 }\r
 169 \r
 170 \r
 171 /**\r
 172   \brief   Set Main Stack Pointer\r
 173   \details Assigns the given value to the Main Stack Pointer (MSP).\r
 174   \param [in]    topOfMainStack  Main Stack Pointer value to set\r
 175  */\r
 176 __attribute__((always_inline)) __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)\r
 177 {\r
 178   __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : "sp");\r
 179 }\r
 180 \r
 181 \r
 182 /**\r
 183   \brief   Get Priority Mask\r
 184   \details Returns the current state of the priority mask bit from the Priority Mask Register.\r
 185   \return               Priority Mask value\r
 186  */\r
 187 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_PRIMASK(void)\r
 188 {\r
 189   uint32_t result;\r
 190 \r
 191   __ASM volatile ("MRS %0, primask" : "=r" (result) );\r
 192   return(result);\r
 193 }\r
 194 \r
 195 \r
 196 /**\r
 197   \brief   Set Priority Mask\r
 198   \details Assigns the given value to the Priority Mask Register.\r
 199   \param [in]    priMask  Priority Mask\r
 200  */\r
 201 __attribute__((always_inline)) __STATIC_INLINE void __set_PRIMASK(uint32_t priMask)\r
 202 {\r
 203   __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");\r
 204 }\r
 205 \r
 206 \r
 207 #if ((defined (__CORTEX_M ) && (__CORTEX_M  >=   3U)) || \\r
 208      (defined (__CORTEX_SC) && (__CORTEX_SC >= 300U))     )\r
 209 \r
 210 /**\r
 211   \brief   Enable FIQ\r
 212   \details Enables FIQ interrupts by clearing the F-bit in the CPSR.\r
 213            Can only be executed in Privileged modes.\r
 214  */\r
 215 __attribute__((always_inline)) __STATIC_INLINE void __enable_fault_irq(void)\r
 216 {\r
 217   __ASM volatile ("cpsie f" : : : "memory");\r
 218 }\r
 219 \r
 220 \r
 221 /**\r
 222   \brief   Disable FIQ\r
 223   \details Disables FIQ interrupts by setting the F-bit in the CPSR.\r
 224            Can only be executed in Privileged modes.\r
 225  */\r
 226 __attribute__((always_inline)) __STATIC_INLINE void __disable_fault_irq(void)\r
 227 {\r
 228   __ASM volatile ("cpsid f" : : : "memory");\r
 229 }\r
 230 \r
 231 \r
 232 /**\r
 233   \brief   Get Base Priority\r
 234   \details Returns the current value of the Base Priority register.\r
 235   \return               Base Priority register value\r
 236  */\r
 237 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_BASEPRI(void)\r
 238 {\r
 239   uint32_t result;\r
 240 \r
 241   __ASM volatile ("MRS %0, basepri" : "=r" (result) );\r
 242   return(result);\r
 243 }\r
 244 \r
 245 \r
 246 /**\r
 247   \brief   Set Base Priority\r
 248   \details Assigns the given value to the Base Priority register.\r
 249   \param [in]    basePri  Base Priority value to set\r
 250  */\r
 251 __attribute__((always_inline)) __STATIC_INLINE void __set_BASEPRI(uint32_t value)\r
 252 {\r
 253   __ASM volatile ("MSR basepri, %0" : : "r" (value) : "memory");\r
 254 }\r
 255 \r
 256 \r
 257 /**\r
 258   \brief   Set Base Priority with condition\r
 259   \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,\r
 260            or the new value increases the BASEPRI priority level.\r
 261   \param [in]    basePri  Base Priority value to set\r
 262  */\r
 263 __attribute__((always_inline)) __STATIC_INLINE void __set_BASEPRI_MAX(uint32_t value)\r
 264 {\r
 265   __ASM volatile ("MSR basepri_max, %0" : : "r" (value) : "memory");\r
 266 }\r
 267 \r
 268 \r
 269 /**\r
 270   \brief   Get Fault Mask\r
 271   \details Returns the current value of the Fault Mask register.\r
 272   \return               Fault Mask register value\r
 273  */\r
 274 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_FAULTMASK(void)\r
 275 {\r
 276   uint32_t result;\r
 277 \r
 278   __ASM volatile ("MRS %0, faultmask" : "=r" (result) );\r
 279   return(result);\r
 280 }\r
 281 \r
 282 \r
 283 /**\r
 284   \brief   Set Fault Mask\r
 285   \details Assigns the given value to the Fault Mask register.\r
 286   \param [in]    faultMask  Fault Mask value to set\r
 287  */\r
 288 __attribute__((always_inline)) __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)\r
 289 {\r
 290   __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory");\r
 291 }\r
 292 \r
 293 #endif /* ((defined (__CORTEX_M ) && (__CORTEX_M  >=   3U)) || \\r
 294            (defined (__CORTEX_SC) && (__CORTEX_SC >= 300U))     ) */\r
 295 \r
 296 \r
 297 #if (defined (__CORTEX_M) && (__CORTEX_M >= 4U))\r
 298 \r
 299 /**\r
 300   \brief   Get FPSCR\r
 301   \details Returns the current value of the Floating Point Status/Control register.\r
 302   \return               Floating Point Status/Control register value\r
 303  */\r
 304 __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_FPSCR(void)\r
 305 {\r
 306 #if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \\r
 307      (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )\r
 308   uint32_t result;\r
 309 \r
 310   __ASM volatile ("");                                 /* Empty asm statement works as a scheduling barrier */\r
 311   __ASM volatile ("VMRS %0, fpscr" : "=r" (result) );\r
 312   __ASM volatile ("");\r
 313   return(result);\r
 314 #else\r
 315    return(0U);\r
 316 #endif\r
 317 }\r
 318 \r
 319 \r
 320 /**\r
 321   \brief   Set FPSCR\r
 322   \details Assigns the given value to the Floating Point Status/Control register.\r
 323   \param [in]    fpscr  Floating Point Status/Control value to set\r
 324  */\r
 325 __attribute__((always_inline)) __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)\r
 326 {\r
 327 #if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \\r
 328      (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )\r
 329   __ASM volatile ("");                                           /* Empty asm statement works as a scheduling barrier */\r
 330   __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc");\r
 331   __ASM volatile ("");\r
 332 #endif\r
 333 }\r
 334 \r
 335 #endif /* (defined (__CORTEX_M) && (__CORTEX_M >= 4U)) */\r
 336 \r
 337 \r
 338 \r
 339 /*@} end of CMSIS_Core_RegAccFunctions */\r
 340 \r
 341 \r
 342 /* ##########################  Core Instruction Access  ######################### */\r
 343 /** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface\r
 344   Access to dedicated instructions\r
 345   @{\r
 346 */\r
 347 \r
 348 /* Define macros for porting to both thumb1 and thumb2.\r
 349  * For thumb1, use low register (r0-r7), specified by constraint "l"\r
 350  * Otherwise, use general registers, specified by constraint "r" */\r
 351 #if defined (__thumb__) && !defined (__thumb2__)\r
 352 #define __CMSIS_GCC_OUT_REG(r) "=l" (r)\r
 353 #define __CMSIS_GCC_USE_REG(r) "l" (r)\r
 354 #else\r
 355 #define __CMSIS_GCC_OUT_REG(r) "=r" (r)\r
 356 #define __CMSIS_GCC_USE_REG(r) "r" (r)\r
 357 #endif\r
 358 \r
 359 /**\r
 360   \brief   No Operation\r
 361   \details No Operation does nothing. This instruction can be used for code alignment purposes.\r
 362  */\r
 363 __attribute__((always_inline)) __STATIC_INLINE void __NOP(void)\r
 364 {\r
 365   __ASM volatile ("nop");\r
 366 }\r
 367 \r
 368 \r
 369 /**\r
 370   \brief   Wait For Interrupt\r
 371   \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.\r
 372  */\r
 373 __attribute__((always_inline)) __STATIC_INLINE void __WFI(void)\r
 374 {\r
 375   __ASM volatile ("wfi");\r
 376 }\r
 377 \r
 378 \r
 379 /**\r
 380   \brief   Wait For Event\r
 381   \details Wait For Event is a hint instruction that permits the processor to enter\r
 382            a low-power state until one of a number of events occurs.\r
 383  */\r
 384 __attribute__((always_inline)) __STATIC_INLINE void __WFE(void)\r
 385 {\r
 386   __ASM volatile ("wfe");\r
 387 }\r
 388 \r
 389 \r
 390 /**\r
 391   \brief   Send Event\r
 392   \details Send Event is a hint instruction. It causes an event to be signaled to the CPU.\r
 393  */\r
 394 __attribute__((always_inline)) __STATIC_INLINE void __SEV(void)\r
 395 {\r
 396   __ASM volatile ("sev");\r
 397 }\r
 398 \r
 399 \r
 400 /**\r
 401   \brief   Instruction Synchronization Barrier\r
 402   \details Instruction Synchronization Barrier flushes the pipeline in the processor,\r
 403            so that all instructions following the ISB are fetched from cache or memory,\r
 404            after the instruction has been completed.\r
 405  */\r
 406 __attribute__((always_inline)) __STATIC_INLINE void __ISB(void)\r
 407 {\r
 408   __ASM volatile ("isb 0xF":::"memory");\r
 409 }\r
 410 \r
 411 \r
 412 /**\r
 413   \brief   Data Synchronization Barrier\r
 414   \details Acts as a special kind of Data Memory Barrier.\r
 415            It completes when all explicit memory accesses before this instruction complete.\r
 416  */\r
 417 __attribute__((always_inline)) __STATIC_INLINE void __DSB(void)\r
 418 {\r
 419   __ASM volatile ("dsb 0xF":::"memory");\r
 420 }\r
 421 \r
 422 \r
 423 /**\r
 424   \brief   Data Memory Barrier\r
 425   \details Ensures the apparent order of the explicit memory operations before\r
 426            and after the instruction, without ensuring their completion.\r
 427  */\r
 428 __attribute__((always_inline)) __STATIC_INLINE void __DMB(void)\r
 429 {\r
 430   __ASM volatile ("dmb 0xF":::"memory");\r
 431 }\r
 432 \r
 433 \r
 434 /**\r
 435   \brief   Reverse byte order (32 bit)\r
 436   \details Reverses the byte order in integer value.\r
 437   \param [in]    value  Value to reverse\r
 438   \return               Reversed value\r
 439  */\r
 440 __attribute__((always_inline)) __STATIC_INLINE uint32_t __REV(uint32_t value)\r
 441 {\r
 442 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)\r
 443   return __builtin_bswap32(value);\r
 444 #else\r
 445   uint32_t result;\r
 446 \r
 447   __ASM volatile ("rev %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );\r
 448   return(result);\r
 449 #endif\r
 450 }\r
 451 \r
 452 \r
 453 /**\r
 454   \brief   Reverse byte order (16 bit)\r
 455   \details Reverses the byte order in two unsigned short values.\r
 456   \param [in]    value  Value to reverse\r
 457   \return               Reversed value\r
 458  */\r
 459 __attribute__((always_inline)) __STATIC_INLINE uint32_t __REV16(uint32_t value)\r
 460 {\r
 461   uint32_t result;\r
 462 \r
 463   __ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );\r
 464   return(result);\r
 465 }\r
 466 \r
 467 \r
 468 /**\r
 469   \brief   Reverse byte order in signed short value\r
 470   \details Reverses the byte order in a signed short value with sign extension to integer.\r
 471   \param [in]    value  Value to reverse\r
 472   \return               Reversed value\r
 473  */\r
 474 __attribute__((always_inline)) __STATIC_INLINE int32_t __REVSH(int32_t value)\r
 475 {\r
 476 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)\r
 477   return (short)__builtin_bswap16(value);\r
 478 #else\r
 479   int32_t result;\r
 480 \r
 481   __ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );\r
 482   return(result);\r
 483 #endif\r
 484 }\r
 485 \r
 486 \r
 487 /**\r
 488   \brief   Rotate Right in unsigned value (32 bit)\r
 489   \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.\r
 490   \param [in]    op1  Value to rotate\r
 491   \param [in]    op2  Number of Bits to rotate\r
 492   \return               Rotated value\r
 493  */\r
 494 __attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint32_t op2)\r
 495 {\r
 496   return (op1 >> op2) | (op1 << (32U - op2));\r
 497 }\r
 498 \r
 499 \r
 500 /**\r
 501   \brief   Breakpoint\r
 502   \details Causes the processor to enter Debug state.\r
 503            Debug tools can use this to investigate system state when the instruction at a particular address is reached.\r
 504   \param [in]    value  is ignored by the processor.\r
 505                  If required, a debugger can use it to store additional information about the breakpoint.\r
 506  */\r
 507 #define __BKPT(value)                       __ASM volatile ("bkpt "#value)\r
 508 \r
 509 \r
 510 /**\r
 511   \brief   Reverse bit order of value\r
 512   \details Reverses the bit order of the given value.\r
 513   \param [in]    value  Value to reverse\r
 514   \return               Reversed value\r
 515  */\r
 516 __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)\r
 517 {\r
 518   uint32_t result;\r
 519 \r
 520 #if ((defined (__CORTEX_M ) && (__CORTEX_M  >=   3U)) || \\r
 521      (defined (__CORTEX_SC) && (__CORTEX_SC >= 300U))     )\r
 522    __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );\r
 523 #else\r
 524   int32_t s = 4 /*sizeof(v)*/ * 8 - 1; /* extra shift needed at end */\r
 525 \r
 526   result = value;                      /* r will be reversed bits of v; first get LSB of v */\r
 527   for (value >>= 1U; value; value >>= 1U)\r
 528   {\r
 529     result <<= 1U;\r
 530     result |= value & 1U;\r
 531     s--;\r
 532   }\r
 533   result <<= s;                        /* shift when v's highest bits are zero */\r
 534 #endif\r
 535   return(result);\r
 536 }\r
 537 \r
 538 \r
 539 /**\r
 540   \brief   Count leading zeros\r
 541   \details Counts the number of leading zeros of a data value.\r
 542   \param [in]  value  Value to count the leading zeros\r
 543   \return             number of leading zeros in value\r
 544  */\r
 545 #define __CLZ             __builtin_clz\r
 546 \r
 547 \r
 548 #if ((defined (__CORTEX_M ) && (__CORTEX_M  >=   3U)) || \\r
 549      (defined (__CORTEX_SC) && (__CORTEX_SC >= 300U))     )\r
 550 \r
 551 /**\r
 552   \brief   LDR Exclusive (8 bit)\r
 553   \details Executes a exclusive LDR instruction for 8 bit value.\r
 554   \param [in]    ptr  Pointer to data\r
 555   \return             value of type uint8_t at (*ptr)\r
 556  */\r
 557 __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDREXB(volatile uint8_t *addr)\r
 558 {\r
 559     uint32_t result;\r
 560 \r
 561 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)\r
 562    __ASM volatile ("ldrexb %0, %1" : "=r" (result) : "Q" (*addr) );\r
 563 #else\r
 564     /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not\r
 565        accepted by assembler. So has to use following less efficient pattern.\r
 566     */\r
 567    __ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) : "memory" );\r
 568 #endif\r
 569    return ((uint8_t) result);    /* Add explicit type cast here */\r
 570 }\r
 571 \r
 572 \r
 573 /**\r
 574   \brief   LDR Exclusive (16 bit)\r
 575   \details Executes a exclusive LDR instruction for 16 bit values.\r
 576   \param [in]    ptr  Pointer to data\r
 577   \return        value of type uint16_t at (*ptr)\r
 578  */\r
 579 __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDREXH(volatile uint16_t *addr)\r
 580 {\r
 581     uint32_t result;\r
 582 \r
 583 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)\r
 584    __ASM volatile ("ldrexh %0, %1" : "=r" (result) : "Q" (*addr) );\r
 585 #else\r
 586     /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not\r
 587        accepted by assembler. So has to use following less efficient pattern.\r
 588     */\r
 589    __ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) : "memory" );\r
 590 #endif\r
 591    return ((uint16_t) result);    /* Add explicit type cast here */\r
 592 }\r
 593 \r
 594 \r
 595 /**\r
 596   \brief   LDR Exclusive (32 bit)\r
 597   \details Executes a exclusive LDR instruction for 32 bit values.\r
 598   \param [in]    ptr  Pointer to data\r
 599   \return        value of type uint32_t at (*ptr)\r
 600  */\r
 601 __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDREXW(volatile uint32_t *addr)\r
 602 {\r
 603     uint32_t result;\r
 604 \r
 605    __ASM volatile ("ldrex %0, %1" : "=r" (result) : "Q" (*addr) );\r
 606    return(result);\r
 607 }\r
 608 \r
 609 \r
 610 /**\r
 611   \brief   STR Exclusive (8 bit)\r
 612   \details Executes a exclusive STR instruction for 8 bit values.\r
 613   \param [in]  value  Value to store\r
 614   \param [in]    ptr  Pointer to location\r
 615   \return          0  Function succeeded\r
 616   \return          1  Function failed\r
 617  */\r
 618 __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr)\r
 619 {\r
 620    uint32_t result;\r
 621 \r
 622    __ASM volatile ("strexb %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) );\r
 623    return(result);\r
 624 }\r
 625 \r
 626 \r
 627 /**\r
 628   \brief   STR Exclusive (16 bit)\r
 629   \details Executes a exclusive STR instruction for 16 bit values.\r
 630   \param [in]  value  Value to store\r
 631   \param [in]    ptr  Pointer to location\r
 632   \return          0  Function succeeded\r
 633   \return          1  Function failed\r
 634  */\r
 635 __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr)\r
 636 {\r
 637    uint32_t result;\r
 638 \r
 639    __ASM volatile ("strexh %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) );\r
 640    return(result);\r
 641 }\r
 642 \r
 643 \r
 644 /**\r
 645   \brief   STR Exclusive (32 bit)\r
 646   \details Executes a exclusive STR instruction for 32 bit values.\r
 647   \param [in]  value  Value to store\r
 648   \param [in]    ptr  Pointer to location\r
 649   \return          0  Function succeeded\r
 650   \return          1  Function failed\r
 651  */\r
 652 __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr)\r
 653 {\r
 654    uint32_t result;\r
 655 \r
 656    __ASM volatile ("strex %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) );\r
 657    return(result);\r
 658 }\r
 659 \r
 660 \r
 661 /**\r
 662   \brief   Remove the exclusive lock\r
 663   \details Removes the exclusive lock which is created by LDREX.\r
 664  */\r
 665 __attribute__((always_inline)) __STATIC_INLINE void __CLREX(void)\r
 666 {\r
 667   __ASM volatile ("clrex" ::: "memory");\r
 668 }\r
 669 \r
 670 \r
 671 /**\r
 672   \brief   Signed Saturate\r
 673   \details Saturates a signed value.\r
 674   \param [in]  value  Value to be saturated\r
 675   \param [in]    sat  Bit position to saturate to (1..32)\r
 676   \return             Saturated value\r
 677  */\r
 678 #define __SSAT(ARG1,ARG2) \\r
 679 ({                          \\r
 680   int32_t __RES, __ARG1 = (ARG1); \\r
 681   __ASM ("ssat %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \\r
 682   __RES; \\r
 683  })\r
 684 \r
 685 \r
 686 /**\r
 687   \brief   Unsigned Saturate\r
 688   \details Saturates an unsigned value.\r
 689   \param [in]  value  Value to be saturated\r
 690   \param [in]    sat  Bit position to saturate to (0..31)\r
 691   \return             Saturated value\r
 692  */\r
 693 #define __USAT(ARG1,ARG2) \\r
 694 ({                          \\r
 695   uint32_t __RES, __ARG1 = (ARG1); \\r
 696   __ASM ("usat %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \\r
 697   __RES; \\r
 698  })\r
 699 \r
 700 \r
 701 /**\r
 702   \brief   Rotate Right with Extend (32 bit)\r
 703   \details Moves each bit of a bitstring right by one bit.\r
 704            The carry input is shifted in at the left end of the bitstring.\r
 705   \param [in]    value  Value to rotate\r
 706   \return               Rotated value\r
 707  */\r
 708 __attribute__((always_inline)) __STATIC_INLINE uint32_t __RRX(uint32_t value)\r
 709 {\r
 710   uint32_t result;\r
 711 \r
 712   __ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );\r
 713   return(result);\r
 714 }\r
 715 \r
 716 \r
 717 /**\r
 718   \brief   LDRT Unprivileged (8 bit)\r
 719   \details Executes a Unprivileged LDRT instruction for 8 bit value.\r
 720   \param [in]    ptr  Pointer to data\r
 721   \return             value of type uint8_t at (*ptr)\r
 722  */\r
 723 __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDRBT(volatile uint8_t *ptr)\r
 724 {\r
 725     uint32_t result;\r
 726 \r
 727 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)\r
 728    __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );\r
 729 #else\r
 730     /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not\r
 731        accepted by assembler. So has to use following less efficient pattern.\r
 732     */\r
 733    __ASM volatile ("ldrbt %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" );\r
 734 #endif\r
 735    return ((uint8_t) result);    /* Add explicit type cast here */\r
 736 }\r
 737 \r
 738 \r
 739 /**\r
 740   \brief   LDRT Unprivileged (16 bit)\r
 741   \details Executes a Unprivileged LDRT instruction for 16 bit values.\r
 742   \param [in]    ptr  Pointer to data\r
 743   \return        value of type uint16_t at (*ptr)\r
 744  */\r
 745 __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDRHT(volatile uint16_t *ptr)\r
 746 {\r
 747     uint32_t result;\r
 748 \r
 749 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)\r
 750    __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );\r
 751 #else\r
 752     /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not\r
 753        accepted by assembler. So has to use following less efficient pattern.\r
 754     */\r
 755    __ASM volatile ("ldrht %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" );\r
 756 #endif\r
 757    return ((uint16_t) result);    /* Add explicit type cast here */\r
 758 }\r
 759 \r
 760 \r
 761 /**\r
 762   \brief   LDRT Unprivileged (32 bit)\r
 763   \details Executes a Unprivileged LDRT instruction for 32 bit values.\r
 764   \param [in]    ptr  Pointer to data\r
 765   \return        value of type uint32_t at (*ptr)\r
 766  */\r
 767 __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDRT(volatile uint32_t *ptr)\r
 768 {\r
 769     uint32_t result;\r
 770 \r
 771    __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );\r
 772    return(result);\r
 773 }\r
 774 \r
 775 \r
 776 /**\r
 777   \brief   STRT Unprivileged (8 bit)\r
 778   \details Executes a Unprivileged STRT instruction for 8 bit values.\r
 779   \param [in]  value  Value to store\r
 780   \param [in]    ptr  Pointer to location\r
 781  */\r
 782 __attribute__((always_inline)) __STATIC_INLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)\r
 783 {\r
 784    __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );\r
 785 }\r
 786 \r
 787 \r
 788 /**\r
 789   \brief   STRT Unprivileged (16 bit)\r
 790   \details Executes a Unprivileged STRT instruction for 16 bit values.\r
 791   \param [in]  value  Value to store\r
 792   \param [in]    ptr  Pointer to location\r
 793  */\r
 794 __attribute__((always_inline)) __STATIC_INLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)\r
 795 {\r
 796    __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );\r
 797 }\r
 798 \r
 799 \r
 800 /**\r
 801   \brief   STRT Unprivileged (32 bit)\r
 802   \details Executes a Unprivileged STRT instruction for 32 bit values.\r
 803   \param [in]  value  Value to store\r
 804   \param [in]    ptr  Pointer to location\r
 805  */\r
 806 __attribute__((always_inline)) __STATIC_INLINE void __STRT(uint32_t value, volatile uint32_t *ptr)\r
 807 {\r
 808    __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );\r
 809 }\r
 810 \r
 811 #endif /* ((defined (__CORTEX_M ) && (__CORTEX_M >=    3U)) || \\r
 812            (defined (__CORTEX_SC) && (__CORTEX_SC >= 300U))     ) */\r
 813 \r
 814 /*@}*/ /* end of group CMSIS_Core_InstructionInterface */\r
 815 \r
 816 \r
 817 /* ###################  Compiler specific Intrinsics  ########################### */\r
 818 /** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics\r
 819   Access to dedicated SIMD instructions\r
 820   @{\r
 821 */\r
 822 \r
 823 #if (defined (__CORTEX_M) && (__CORTEX_M >= 4U))\r
 824 \r
 825 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)\r
 826 {\r
 827   uint32_t result;\r
 828 \r
 829   __ASM volatile ("sadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 830   return(result);\r
 831 }\r
 832 \r
 833 __attribute__((always_inline)) __STATIC_INLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)\r
 834 {\r
 835   uint32_t result;\r
 836 \r
 837   __ASM volatile ("qadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 838   return(result);\r
 839 }\r
 840 \r
 841 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)\r
 842 {\r
 843   uint32_t result;\r
 844 \r
 845   __ASM volatile ("shadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 846   return(result);\r
 847 }\r
 848 \r
 849 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)\r
 850 {\r
 851   uint32_t result;\r
 852 \r
 853   __ASM volatile ("uadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 854   return(result);\r
 855 }\r
 856 \r
 857 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)\r
 858 {\r
 859   uint32_t result;\r
 860 \r
 861   __ASM volatile ("uqadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 862   return(result);\r
 863 }\r
 864 \r
 865 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)\r
 866 {\r
 867   uint32_t result;\r
 868 \r
 869   __ASM volatile ("uhadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 870   return(result);\r
 871 }\r
 872 \r
 873 \r
 874 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)\r
 875 {\r
 876   uint32_t result;\r
 877 \r
 878   __ASM volatile ("ssub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 879   return(result);\r
 880 }\r
 881 \r
 882 __attribute__((always_inline)) __STATIC_INLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)\r
 883 {\r
 884   uint32_t result;\r
 885 \r
 886   __ASM volatile ("qsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 887   return(result);\r
 888 }\r
 889 \r
 890 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)\r
 891 {\r
 892   uint32_t result;\r
 893 \r
 894   __ASM volatile ("shsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 895   return(result);\r
 896 }\r
 897 \r
 898 __attribute__((always_inline)) __STATIC_INLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)\r
 899 {\r
 900   uint32_t result;\r
 901 \r
 902   __ASM volatile ("usub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 903   return(result);\r
 904 }\r
 905 \r
 906 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)\r
 907 {\r
 908   uint32_t result;\r
 909 \r
 910   __ASM volatile ("uqsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 911   return(result);\r
 912 }\r
 913 \r
 914 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)\r
 915 {\r
 916   uint32_t result;\r
 917 \r
 918   __ASM volatile ("uhsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 919   return(result);\r
 920 }\r
 921 \r
 922 \r
 923 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)\r
 924 {\r
 925   uint32_t result;\r
 926 \r
 927   __ASM volatile ("sadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 928   return(result);\r
 929 }\r
 930 \r
 931 __attribute__((always_inline)) __STATIC_INLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)\r
 932 {\r
 933   uint32_t result;\r
 934 \r
 935   __ASM volatile ("qadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 936   return(result);\r
 937 }\r
 938 \r
 939 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)\r
 940 {\r
 941   uint32_t result;\r
 942 \r
 943   __ASM volatile ("shadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 944   return(result);\r
 945 }\r
 946 \r
 947 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)\r
 948 {\r
 949   uint32_t result;\r
 950 \r
 951   __ASM volatile ("uadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 952   return(result);\r
 953 }\r
 954 \r
 955 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)\r
 956 {\r
 957   uint32_t result;\r
 958 \r
 959   __ASM volatile ("uqadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 960   return(result);\r
 961 }\r
 962 \r
 963 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)\r
 964 {\r
 965   uint32_t result;\r
 966 \r
 967   __ASM volatile ("uhadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 968   return(result);\r
 969 }\r
 970 \r
 971 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)\r
 972 {\r
 973   uint32_t result;\r
 974 \r
 975   __ASM volatile ("ssub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 976   return(result);\r
 977 }\r
 978 \r
 979 __attribute__((always_inline)) __STATIC_INLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)\r
 980 {\r
 981   uint32_t result;\r
 982 \r
 983   __ASM volatile ("qsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 984   return(result);\r
 985 }\r
 986 \r
 987 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)\r
 988 {\r
 989   uint32_t result;\r
 990 \r
 991   __ASM volatile ("shsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
 992   return(result);\r
 993 }\r
 994 \r
 995 __attribute__((always_inline)) __STATIC_INLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)\r
 996 {\r
 997   uint32_t result;\r
 998 \r
 999   __ASM volatile ("usub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1000   return(result);\r
1001 }\r
1002 \r
1003 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)\r
1004 {\r
1005   uint32_t result;\r
1006 \r
1007   __ASM volatile ("uqsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1008   return(result);\r
1009 }\r
1010 \r
1011 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)\r
1012 {\r
1013   uint32_t result;\r
1014 \r
1015   __ASM volatile ("uhsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1016   return(result);\r
1017 }\r
1018 \r
1019 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SASX(uint32_t op1, uint32_t op2)\r
1020 {\r
1021   uint32_t result;\r
1022 \r
1023   __ASM volatile ("sasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1024   return(result);\r
1025 }\r
1026 \r
1027 __attribute__((always_inline)) __STATIC_INLINE uint32_t __QASX(uint32_t op1, uint32_t op2)\r
1028 {\r
1029   uint32_t result;\r
1030 \r
1031   __ASM volatile ("qasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1032   return(result);\r
1033 }\r
1034 \r
1035 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)\r
1036 {\r
1037   uint32_t result;\r
1038 \r
1039   __ASM volatile ("shasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1040   return(result);\r
1041 }\r
1042 \r
1043 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UASX(uint32_t op1, uint32_t op2)\r
1044 {\r
1045   uint32_t result;\r
1046 \r
1047   __ASM volatile ("uasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1048   return(result);\r
1049 }\r
1050 \r
1051 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)\r
1052 {\r
1053   uint32_t result;\r
1054 \r
1055   __ASM volatile ("uqasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1056   return(result);\r
1057 }\r
1058 \r
1059 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)\r
1060 {\r
1061   uint32_t result;\r
1062 \r
1063   __ASM volatile ("uhasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1064   return(result);\r
1065 }\r
1066 \r
1067 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)\r
1068 {\r
1069   uint32_t result;\r
1070 \r
1071   __ASM volatile ("ssax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1072   return(result);\r
1073 }\r
1074 \r
1075 __attribute__((always_inline)) __STATIC_INLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)\r
1076 {\r
1077   uint32_t result;\r
1078 \r
1079   __ASM volatile ("qsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1080   return(result);\r
1081 }\r
1082 \r
1083 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)\r
1084 {\r
1085   uint32_t result;\r
1086 \r
1087   __ASM volatile ("shsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1088   return(result);\r
1089 }\r
1090 \r
1091 __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAX(uint32_t op1, uint32_t op2)\r
1092 {\r
1093   uint32_t result;\r
1094 \r
1095   __ASM volatile ("usax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1096   return(result);\r
1097 }\r
1098 \r
1099 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)\r
1100 {\r
1101   uint32_t result;\r
1102 \r
1103   __ASM volatile ("uqsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1104   return(result);\r
1105 }\r
1106 \r
1107 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)\r
1108 {\r
1109   uint32_t result;\r
1110 \r
1111   __ASM volatile ("uhsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1112   return(result);\r
1113 }\r
1114 \r
1115 __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)\r
1116 {\r
1117   uint32_t result;\r
1118 \r
1119   __ASM volatile ("usad8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1120   return(result);\r
1121 }\r
1122 \r
1123 __attribute__((always_inline)) __STATIC_INLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)\r
1124 {\r
1125   uint32_t result;\r
1126 \r
1127   __ASM volatile ("usada8 %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );\r
1128   return(result);\r
1129 }\r
1130 \r
1131 #define __SSAT16(ARG1,ARG2) \\r
1132 ({                          \\r
1133   int32_t __RES, __ARG1 = (ARG1); \\r
1134   __ASM ("ssat16 %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \\r
1135   __RES; \\r
1136  })\r
1137 \r
1138 #define __USAT16(ARG1,ARG2) \\r
1139 ({                          \\r
1140   uint32_t __RES, __ARG1 = (ARG1); \\r
1141   __ASM ("usat16 %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \\r
1142   __RES; \\r
1143  })\r
1144 \r
1145 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UXTB16(uint32_t op1)\r
1146 {\r
1147   uint32_t result;\r
1148 \r
1149   __ASM volatile ("uxtb16 %0, %1" : "=r" (result) : "r" (op1));\r
1150   return(result);\r
1151 }\r
1152 \r
1153 __attribute__((always_inline)) __STATIC_INLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)\r
1154 {\r
1155   uint32_t result;\r
1156 \r
1157   __ASM volatile ("uxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1158   return(result);\r
1159 }\r
1160 \r
1161 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SXTB16(uint32_t op1)\r
1162 {\r
1163   uint32_t result;\r
1164 \r
1165   __ASM volatile ("sxtb16 %0, %1" : "=r" (result) : "r" (op1));\r
1166   return(result);\r
1167 }\r
1168 \r
1169 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)\r
1170 {\r
1171   uint32_t result;\r
1172 \r
1173   __ASM volatile ("sxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1174   return(result);\r
1175 }\r
1176 \r
1177 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUAD  (uint32_t op1, uint32_t op2)\r
1178 {\r
1179   uint32_t result;\r
1180 \r
1181   __ASM volatile ("smuad %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1182   return(result);\r
1183 }\r
1184 \r
1185 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)\r
1186 {\r
1187   uint32_t result;\r
1188 \r
1189   __ASM volatile ("smuadx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1190   return(result);\r
1191 }\r
1192 \r
1193 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)\r
1194 {\r
1195   uint32_t result;\r
1196 \r
1197   __ASM volatile ("smlad %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );\r
1198   return(result);\r
1199 }\r
1200 \r
1201 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)\r
1202 {\r
1203   uint32_t result;\r
1204 \r
1205   __ASM volatile ("smladx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );\r
1206   return(result);\r
1207 }\r
1208 \r
1209 __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)\r
1210 {\r
1211   union llreg_u{\r
1212     uint32_t w32[2];\r
1213     uint64_t w64;\r
1214   } llr;\r
1215   llr.w64 = acc;\r
1216 \r
1217 #ifndef __ARMEB__   /* Little endian */\r
1218   __ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );\r
1219 #else               /* Big endian */\r
1220   __ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );\r
1221 #endif\r
1222 \r
1223   return(llr.w64);\r
1224 }\r
1225 \r
1226 __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)\r
1227 {\r
1228   union llreg_u{\r
1229     uint32_t w32[2];\r
1230     uint64_t w64;\r
1231   } llr;\r
1232   llr.w64 = acc;\r
1233 \r
1234 #ifndef __ARMEB__   /* Little endian */\r
1235   __ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );\r
1236 #else               /* Big endian */\r
1237   __ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );\r
1238 #endif\r
1239 \r
1240   return(llr.w64);\r
1241 }\r
1242 \r
1243 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUSD  (uint32_t op1, uint32_t op2)\r
1244 {\r
1245   uint32_t result;\r
1246 \r
1247   __ASM volatile ("smusd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1248   return(result);\r
1249 }\r
1250 \r
1251 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)\r
1252 {\r
1253   uint32_t result;\r
1254 \r
1255   __ASM volatile ("smusdx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1256   return(result);\r
1257 }\r
1258 \r
1259 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)\r
1260 {\r
1261   uint32_t result;\r
1262 \r
1263   __ASM volatile ("smlsd %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );\r
1264   return(result);\r
1265 }\r
1266 \r
1267 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)\r
1268 {\r
1269   uint32_t result;\r
1270 \r
1271   __ASM volatile ("smlsdx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );\r
1272   return(result);\r
1273 }\r
1274 \r
1275 __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)\r
1276 {\r
1277   union llreg_u{\r
1278     uint32_t w32[2];\r
1279     uint64_t w64;\r
1280   } llr;\r
1281   llr.w64 = acc;\r
1282 \r
1283 #ifndef __ARMEB__   /* Little endian */\r
1284   __ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );\r
1285 #else               /* Big endian */\r
1286   __ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );\r
1287 #endif\r
1288 \r
1289   return(llr.w64);\r
1290 }\r
1291 \r
1292 __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)\r
1293 {\r
1294   union llreg_u{\r
1295     uint32_t w32[2];\r
1296     uint64_t w64;\r
1297   } llr;\r
1298   llr.w64 = acc;\r
1299 \r
1300 #ifndef __ARMEB__   /* Little endian */\r
1301   __ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );\r
1302 #else               /* Big endian */\r
1303   __ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );\r
1304 #endif\r
1305 \r
1306   return(llr.w64);\r
1307 }\r
1308 \r
1309 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SEL  (uint32_t op1, uint32_t op2)\r
1310 {\r
1311   uint32_t result;\r
1312 \r
1313   __ASM volatile ("sel %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1314   return(result);\r
1315 }\r
1316 \r
1317 __attribute__((always_inline)) __STATIC_INLINE  int32_t __QADD( int32_t op1,  int32_t op2)\r
1318 {\r
1319   int32_t result;\r
1320 \r
1321   __ASM volatile ("qadd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1322   return(result);\r
1323 }\r
1324 \r
1325 __attribute__((always_inline)) __STATIC_INLINE  int32_t __QSUB( int32_t op1,  int32_t op2)\r
1326 {\r
1327   int32_t result;\r
1328 \r
1329   __ASM volatile ("qsub %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );\r
1330   return(result);\r
1331 }\r
1332 \r
1333 #define __PKHBT(ARG1,ARG2,ARG3) \\r
1334 ({                          \\r
1335   uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \\r
1336   __ASM ("pkhbt %0, %1, %2, lsl %3" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2), "I" (ARG3)  ); \\r
1337   __RES; \\r
1338  })\r
1339 \r
1340 #define __PKHTB(ARG1,ARG2,ARG3) \\r
1341 ({                          \\r
1342   uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \\r
1343   if (ARG3 == 0) \\r
1344     __ASM ("pkhtb %0, %1, %2" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2)  ); \\r
1345   else \\r
1346     __ASM ("pkhtb %0, %1, %2, asr %3" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2), "I" (ARG3)  ); \\r
1347   __RES; \\r
1348  })\r
1349 \r
1350 __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)\r
1351 {\r
1352  int32_t result;\r
1353 \r
1354  __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r"  (op1), "r" (op2), "r" (op3) );\r
1355  return(result);\r
1356 }\r
1357 \r
1358 #endif /* (defined (__CORTEX_M) && (__CORTEX_M >= 4U)) */\r
1359 /*@} end of group CMSIS_SIMD_intrinsics */\r
1360 \r
1361 \r
1362 #if defined ( __GNUC__ )\r
1363 #pragma GCC diagnostic pop\r
1364 #endif\r
1365 \r
1366 #endif /* __CMSIS_GCC_H */\r