begriffs open source - cmsis/blob - CMSIS/Core/Include/cmsis_armcc.h

   1 /**************************************************************************//**
   2  * @file     cmsis_armcc.h
   3  * @brief    CMSIS compiler ARMCC (ARM compiler V5) header file
   4  * @version  V5.0.2
   5  * @date     13. February 2017
   6  ******************************************************************************/
   7 /*
   8  * Copyright (c) 2009-2017 ARM Limited. All rights reserved.
   9  *
  10  * SPDX-License-Identifier: Apache-2.0
  11  *
  12  * Licensed under the Apache License, Version 2.0 (the License); you may
  13  * not use this file except in compliance with the License.
  14  * You may obtain a copy of the License at
  15  *
  16  * www.apache.org/licenses/LICENSE-2.0
  17  *
  18  * Unless required by applicable law or agreed to in writing, software
  19  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  20  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21  * See the License for the specific language governing permissions and
  22  * limitations under the License.
  23  */
  24
  25 #ifndef __CMSIS_ARMCC_H
  26 #define __CMSIS_ARMCC_H
  27
  28
  29 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 400677)
  30   #error "Please use ARM Compiler Toolchain V4.0.677 or later!"
  31 #endif
  32
  33 /* CMSIS compiler control architecture macros */
  34 #if ((defined (__TARGET_ARCH_6_M  ) && (__TARGET_ARCH_6_M   == 1)) || \
  35      (defined (__TARGET_ARCH_6S_M ) && (__TARGET_ARCH_6S_M  == 1))   )
  36   #define __ARM_ARCH_6M__           1
  37 #endif
  38
  39 #if (defined (__TARGET_ARCH_7_M ) && (__TARGET_ARCH_7_M  == 1))
  40   #define __ARM_ARCH_7M__           1
  41 #endif
  42
  43 #if (defined (__TARGET_ARCH_7E_M) && (__TARGET_ARCH_7E_M == 1))
  44   #define __ARM_ARCH_7EM__          1
  45 #endif
  46
  47   /* __ARM_ARCH_8M_BASE__  not applicable */
  48   /* __ARM_ARCH_8M_MAIN__  not applicable */
  49
  50
  51 /* CMSIS compiler specific defines */
  52 #ifndef   __ASM
  53   #define __ASM                                  __asm
  54 #endif
  55 #ifndef   __INLINE
  56   #define __INLINE                               __inline
  57 #endif
  58 #ifndef   __STATIC_INLINE
  59   #define __STATIC_INLINE                        static __inline
  60 #endif
  61 #ifndef   __NO_RETURN
  62   #define __NO_RETURN                            __declspec(noreturn)
  63 #endif
  64 #ifndef   __USED
  65   #define __USED                                 __attribute__((used))
  66 #endif
  67 #ifndef   __WEAK
  68   #define __WEAK                                 __attribute__((weak))
  69 #endif
  70 #ifndef   __PACKED
  71   #define __PACKED                               __attribute__((packed))
  72 #endif
  73 #ifndef   __PACKED_STRUCT
  74   #define __PACKED_STRUCT                        __packed struct
  75 #endif
  76 #ifndef   __PACKED_UNION
  77   #define __PACKED_UNION                         __packed union
  78 #endif
  79 #ifndef   __UNALIGNED_UINT32        /* deprecated */
  80   #define __UNALIGNED_UINT32(x)                  (*((__packed uint32_t *)(x)))
  81 #endif
  82 #ifndef   __UNALIGNED_UINT16_WRITE
  83   #define __UNALIGNED_UINT16_WRITE(addr, val)    ((*((__packed uint16_t *)(addr))) = (val))
  84 #endif
  85 #ifndef   __UNALIGNED_UINT16_READ
  86   #define __UNALIGNED_UINT16_READ(addr)          (*((const __packed uint16_t *)(addr)))
  87 #endif
  88 #ifndef   __UNALIGNED_UINT32_WRITE
  89   #define __UNALIGNED_UINT32_WRITE(addr, val)    ((*((__packed uint32_t *)(addr))) = (val))
  90 #endif
  91 #ifndef   __UNALIGNED_UINT32_READ
  92   #define __UNALIGNED_UINT32_READ(addr)          (*((const __packed uint32_t *)(addr)))
  93 #endif
  94 #ifndef   __ALIGNED
  95   #define __ALIGNED(x)                           __attribute__((aligned(x)))
  96 #endif
  97 #ifndef   __RESTRICT
  98   #define __RESTRICT                             __restrict
  99 #endif
 100
 101 /* ###########################  Core Function Access  ########################### */
 102 /** \ingroup  CMSIS_Core_FunctionInterface
 103     \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
 104   @{
 105  */
 106
 107 /**
 108   \brief   Enable IRQ Interrupts
 109   \details Enables IRQ interrupts by clearing the I-bit in the CPSR.
 110            Can only be executed in Privileged modes.
 111  */
 112 /* intrinsic void __enable_irq();     */
 113
 114
 115 /**
 116   \brief   Disable IRQ Interrupts
 117   \details Disables IRQ interrupts by setting the I-bit in the CPSR.
 118            Can only be executed in Privileged modes.
 119  */
 120 /* intrinsic void __disable_irq();    */
 121
 122 /**
 123   \brief   Get Control Register
 124   \details Returns the content of the Control Register.
 125   \return               Control Register value
 126  */
 127 __STATIC_INLINE uint32_t __get_CONTROL(void)
 128 {
 129   register uint32_t __regControl         __ASM("control");
 130   return(__regControl);
 131 }
 132
 133
 134 /**
 135   \brief   Set Control Register
 136   \details Writes the given value to the Control Register.
 137   \param [in]    control  Control Register value to set
 138  */
 139 __STATIC_INLINE void __set_CONTROL(uint32_t control)
 140 {
 141   register uint32_t __regControl         __ASM("control");
 142   __regControl = control;
 143 }
 144
 145
 146 /**
 147   \brief   Get IPSR Register
 148   \details Returns the content of the IPSR Register.
 149   \return               IPSR Register value
 150  */
 151 __STATIC_INLINE uint32_t __get_IPSR(void)
 152 {
 153   register uint32_t __regIPSR          __ASM("ipsr");
 154   return(__regIPSR);
 155 }
 156
 157
 158 /**
 159   \brief   Get APSR Register
 160   \details Returns the content of the APSR Register.
 161   \return               APSR Register value
 162  */
 163 __STATIC_INLINE uint32_t __get_APSR(void)
 164 {
 165   register uint32_t __regAPSR          __ASM("apsr");
 166   return(__regAPSR);
 167 }
 168
 169
 170 /**
 171   \brief   Get xPSR Register
 172   \details Returns the content of the xPSR Register.
 173   \return               xPSR Register value
 174  */
 175 __STATIC_INLINE uint32_t __get_xPSR(void)
 176 {
 177   register uint32_t __regXPSR          __ASM("xpsr");
 178   return(__regXPSR);
 179 }
 180
 181
 182 /**
 183   \brief   Get Process Stack Pointer
 184   \details Returns the current value of the Process Stack Pointer (PSP).
 185   \return               PSP Register value
 186  */
 187 __STATIC_INLINE uint32_t __get_PSP(void)
 188 {
 189   register uint32_t __regProcessStackPointer  __ASM("psp");
 190   return(__regProcessStackPointer);
 191 }
 192
 193
 194 /**
 195   \brief   Set Process Stack Pointer
 196   \details Assigns the given value to the Process Stack Pointer (PSP).
 197   \param [in]    topOfProcStack  Process Stack Pointer value to set
 198  */
 199 __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
 200 {
 201   register uint32_t __regProcessStackPointer  __ASM("psp");
 202   __regProcessStackPointer = topOfProcStack;
 203 }
 204
 205
 206 /**
 207   \brief   Get Main Stack Pointer
 208   \details Returns the current value of the Main Stack Pointer (MSP).
 209   \return               MSP Register value
 210  */
 211 __STATIC_INLINE uint32_t __get_MSP(void)
 212 {
 213   register uint32_t __regMainStackPointer     __ASM("msp");
 214   return(__regMainStackPointer);
 215 }
 216
 217
 218 /**
 219   \brief   Set Main Stack Pointer
 220   \details Assigns the given value to the Main Stack Pointer (MSP).
 221   \param [in]    topOfMainStack  Main Stack Pointer value to set
 222  */
 223 __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
 224 {
 225   register uint32_t __regMainStackPointer     __ASM("msp");
 226   __regMainStackPointer = topOfMainStack;
 227 }
 228
 229
 230 /**
 231   \brief   Get Priority Mask
 232   \details Returns the current state of the priority mask bit from the Priority Mask Register.
 233   \return               Priority Mask value
 234  */
 235 __STATIC_INLINE uint32_t __get_PRIMASK(void)
 236 {
 237   register uint32_t __regPriMask         __ASM("primask");
 238   return(__regPriMask);
 239 }
 240
 241
 242 /**
 243   \brief   Set Priority Mask
 244   \details Assigns the given value to the Priority Mask Register.
 245   \param [in]    priMask  Priority Mask
 246  */
 247 __STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
 248 {
 249   register uint32_t __regPriMask         __ASM("primask");
 250   __regPriMask = (priMask);
 251 }
 252
 253
 254 #if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
 255      (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 256
 257 /**
 258   \brief   Enable FIQ
 259   \details Enables FIQ interrupts by clearing the F-bit in the CPSR.
 260            Can only be executed in Privileged modes.
 261  */
 262 #define __enable_fault_irq                __enable_fiq
 263
 264
 265 /**
 266   \brief   Disable FIQ
 267   \details Disables FIQ interrupts by setting the F-bit in the CPSR.
 268            Can only be executed in Privileged modes.
 269  */
 270 #define __disable_fault_irq               __disable_fiq
 271
 272
 273 /**
 274   \brief   Get Base Priority
 275   \details Returns the current value of the Base Priority register.
 276   \return               Base Priority register value
 277  */
 278 __STATIC_INLINE uint32_t  __get_BASEPRI(void)
 279 {
 280   register uint32_t __regBasePri         __ASM("basepri");
 281   return(__regBasePri);
 282 }
 283
 284
 285 /**
 286   \brief   Set Base Priority
 287   \details Assigns the given value to the Base Priority register.
 288   \param [in]    basePri  Base Priority value to set
 289  */
 290 __STATIC_INLINE void __set_BASEPRI(uint32_t basePri)
 291 {
 292   register uint32_t __regBasePri         __ASM("basepri");
 293   __regBasePri = (basePri & 0xFFU);
 294 }
 295
 296
 297 /**
 298   \brief   Set Base Priority with condition
 299   \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
 300            or the new value increases the BASEPRI priority level.
 301   \param [in]    basePri  Base Priority value to set
 302  */
 303 __STATIC_INLINE void __set_BASEPRI_MAX(uint32_t basePri)
 304 {
 305   register uint32_t __regBasePriMax      __ASM("basepri_max");
 306   __regBasePriMax = (basePri & 0xFFU);
 307 }
 308
 309
 310 /**
 311   \brief   Get Fault Mask
 312   \details Returns the current value of the Fault Mask register.
 313   \return               Fault Mask register value
 314  */
 315 __STATIC_INLINE uint32_t __get_FAULTMASK(void)
 316 {
 317   register uint32_t __regFaultMask       __ASM("faultmask");
 318   return(__regFaultMask);
 319 }
 320
 321
 322 /**
 323   \brief   Set Fault Mask
 324   \details Assigns the given value to the Fault Mask register.
 325   \param [in]    faultMask  Fault Mask value to set
 326  */
 327 __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
 328 {
 329   register uint32_t __regFaultMask       __ASM("faultmask");
 330   __regFaultMask = (faultMask & (uint32_t)1U);
 331 }
 332
 333 #endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
 334            (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 335
 336
 337 #if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 338
 339 /**
 340   \brief   Get FPSCR
 341   \details Returns the current value of the Floating Point Status/Control register.
 342   \return               Floating Point Status/Control register value
 343  */
 344 __STATIC_INLINE uint32_t __get_FPSCR(void)
 345 {
 346 #if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
 347      (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
 348   register uint32_t __regfpscr         __ASM("fpscr");
 349   return(__regfpscr);
 350 #else
 351    return(0U);
 352 #endif
 353 }
 354
 355
 356 /**
 357   \brief   Set FPSCR
 358   \details Assigns the given value to the Floating Point Status/Control register.
 359   \param [in]    fpscr  Floating Point Status/Control value to set
 360  */
 361 __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
 362 {
 363 #if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
 364      (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
 365   register uint32_t __regfpscr         __ASM("fpscr");
 366   __regfpscr = (fpscr);
 367 #else
 368   (void)fpscr;
 369 #endif
 370 }
 371
 372 #endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 373
 374
 375
 376 /*@} end of CMSIS_Core_RegAccFunctions */
 377
 378
 379 /* ##########################  Core Instruction Access  ######################### */
 380 /** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
 381   Access to dedicated instructions
 382   @{
 383 */
 384
 385 /**
 386   \brief   No Operation
 387   \details No Operation does nothing. This instruction can be used for code alignment purposes.
 388  */
 389 #define __NOP                             __nop
 390
 391
 392 /**
 393   \brief   Wait For Interrupt
 394   \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
 395  */
 396 #define __WFI                             __wfi
 397
 398
 399 /**
 400   \brief   Wait For Event
 401   \details Wait For Event is a hint instruction that permits the processor to enter
 402            a low-power state until one of a number of events occurs.
 403  */
 404 #define __WFE                             __wfe
 405
 406
 407 /**
 408   \brief   Send Event
 409   \details Send Event is a hint instruction. It causes an event to be signaled to the CPU.
 410  */
 411 #define __SEV                             __sev
 412
 413
 414 /**
 415   \brief   Instruction Synchronization Barrier
 416   \details Instruction Synchronization Barrier flushes the pipeline in the processor,
 417            so that all instructions following the ISB are fetched from cache or memory,
 418            after the instruction has been completed.
 419  */
 420 #define __ISB() do {\
 421                    __schedule_barrier();\
 422                    __isb(0xF);\
 423                    __schedule_barrier();\
 424                 } while (0U)
 425
 426 /**
 427   \brief   Data Synchronization Barrier
 428   \details Acts as a special kind of Data Memory Barrier.
 429            It completes when all explicit memory accesses before this instruction complete.
 430  */
 431 #define __DSB() do {\
 432                    __schedule_barrier();\
 433                    __dsb(0xF);\
 434                    __schedule_barrier();\
 435                 } while (0U)
 436
 437 /**
 438   \brief   Data Memory Barrier
 439   \details Ensures the apparent order of the explicit memory operations before
 440            and after the instruction, without ensuring their completion.
 441  */
 442 #define __DMB() do {\
 443                    __schedule_barrier();\
 444                    __dmb(0xF);\
 445                    __schedule_barrier();\
 446                 } while (0U)
 447
 448 /**
 449   \brief   Reverse byte order (32 bit)
 450   \details Reverses the byte order in integer value.
 451   \param [in]    value  Value to reverse
 452   \return               Reversed value
 453  */
 454 #define __REV                             __rev
 455
 456
 457 /**
 458   \brief   Reverse byte order (16 bit)
 459   \details Reverses the byte order in two unsigned short values.
 460   \param [in]    value  Value to reverse
 461   \return               Reversed value
 462  */
 463 #ifndef __NO_EMBEDDED_ASM
 464 __attribute__((section(".rev16_text"))) __STATIC_INLINE __ASM uint16_t __REV16(uint16_t value)
 465 {
 466   rev16 r0, r0
 467   bx lr
 468 }
 469 #endif
 470
 471
 472 /**
 473   \brief   Reverse byte order in signed short value
 474   \details Reverses the byte order in a signed short value with sign extension to integer.
 475   \param [in]    value  Value to reverse
 476   \return               Reversed value
 477  */
 478 #ifndef __NO_EMBEDDED_ASM
 479 __attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int16_t __REVSH(int16_t value)
 480 {
 481   revsh r0, r0
 482   bx lr
 483 }
 484 #endif
 485
 486
 487 /**
 488   \brief   Rotate Right in unsigned value (32 bit)
 489   \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
 490   \param [in]    op1  Value to rotate
 491   \param [in]    op2  Number of Bits to rotate
 492   \return               Rotated value
 493  */
 494 #define __ROR                             __ror
 495
 496
 497 /**
 498   \brief   Breakpoint
 499   \details Causes the processor to enter Debug state.
 500            Debug tools can use this to investigate system state when the instruction at a particular address is reached.
 501   \param [in]    value  is ignored by the processor.
 502                  If required, a debugger can use it to store additional information about the breakpoint.
 503  */
 504 #define __BKPT(value)                       __breakpoint(value)
 505
 506
 507 /**
 508   \brief   Reverse bit order of value
 509   \details Reverses the bit order of the given value.
 510   \param [in]    value  Value to reverse
 511   \return               Reversed value
 512  */
 513 #if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
 514      (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 515   #define __RBIT                          __rbit
 516 #else
 517 __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
 518 {
 519   uint32_t result;
 520   uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */
 521
 522   result = value;                      /* r will be reversed bits of v; first get LSB of v */
 523   for (value >>= 1U; value != 0U; value >>= 1U)
 524   {
 525     result <<= 1U;
 526     result |= value & 1U;
 527     s--;
 528   }
 529   result <<= s;                        /* shift when v's highest bits are zero */
 530   return result;
 531 }
 532 #endif
 533
 534
 535 /**
 536   \brief   Count leading zeros
 537   \details Counts the number of leading zeros of a data value.
 538   \param [in]  value  Value to count the leading zeros
 539   \return             number of leading zeros in value
 540  */
 541 #define __CLZ                             __clz
 542
 543
 544 #if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
 545      (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 546
 547 /**
 548   \brief   LDR Exclusive (8 bit)
 549   \details Executes a exclusive LDR instruction for 8 bit value.
 550   \param [in]    ptr  Pointer to data
 551   \return             value of type uint8_t at (*ptr)
 552  */
 553 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
 554   #define __LDREXB(ptr)                                                        ((uint8_t ) __ldrex(ptr))
 555 #else
 556   #define __LDREXB(ptr)          _Pragma("push") _Pragma("diag_suppress 3731") ((uint8_t ) __ldrex(ptr))  _Pragma("pop")
 557 #endif
 558
 559
 560 /**
 561   \brief   LDR Exclusive (16 bit)
 562   \details Executes a exclusive LDR instruction for 16 bit values.
 563   \param [in]    ptr  Pointer to data
 564   \return        value of type uint16_t at (*ptr)
 565  */
 566 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
 567   #define __LDREXH(ptr)                                                        ((uint16_t) __ldrex(ptr))
 568 #else
 569   #define __LDREXH(ptr)          _Pragma("push") _Pragma("diag_suppress 3731") ((uint16_t) __ldrex(ptr))  _Pragma("pop")
 570 #endif
 571
 572
 573 /**
 574   \brief   LDR Exclusive (32 bit)
 575   \details Executes a exclusive LDR instruction for 32 bit values.
 576   \param [in]    ptr  Pointer to data
 577   \return        value of type uint32_t at (*ptr)
 578  */
 579 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
 580   #define __LDREXW(ptr)                                                        ((uint32_t ) __ldrex(ptr))
 581 #else
 582   #define __LDREXW(ptr)          _Pragma("push") _Pragma("diag_suppress 3731") ((uint32_t ) __ldrex(ptr))  _Pragma("pop")
 583 #endif
 584
 585
 586 /**
 587   \brief   STR Exclusive (8 bit)
 588   \details Executes a exclusive STR instruction for 8 bit values.
 589   \param [in]  value  Value to store
 590   \param [in]    ptr  Pointer to location
 591   \return          0  Function succeeded
 592   \return          1  Function failed
 593  */
 594 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
 595   #define __STREXB(value, ptr)                                                 __strex(value, ptr)
 596 #else
 597   #define __STREXB(value, ptr)   _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr)        _Pragma("pop")
 598 #endif
 599
 600
 601 /**
 602   \brief   STR Exclusive (16 bit)
 603   \details Executes a exclusive STR instruction for 16 bit values.
 604   \param [in]  value  Value to store
 605   \param [in]    ptr  Pointer to location
 606   \return          0  Function succeeded
 607   \return          1  Function failed
 608  */
 609 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
 610   #define __STREXH(value, ptr)                                                 __strex(value, ptr)
 611 #else
 612   #define __STREXH(value, ptr)   _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr)        _Pragma("pop")
 613 #endif
 614
 615
 616 /**
 617   \brief   STR Exclusive (32 bit)
 618   \details Executes a exclusive STR instruction for 32 bit values.
 619   \param [in]  value  Value to store
 620   \param [in]    ptr  Pointer to location
 621   \return          0  Function succeeded
 622   \return          1  Function failed
 623  */
 624 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
 625   #define __STREXW(value, ptr)                                                 __strex(value, ptr)
 626 #else
 627   #define __STREXW(value, ptr)   _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr)        _Pragma("pop")
 628 #endif
 629
 630
 631 /**
 632   \brief   Remove the exclusive lock
 633   \details Removes the exclusive lock which is created by LDREX.
 634  */
 635 #define __CLREX                           __clrex
 636
 637
 638 /**
 639   \brief   Signed Saturate
 640   \details Saturates a signed value.
 641   \param [in]  value  Value to be saturated
 642   \param [in]    sat  Bit position to saturate to (1..32)
 643   \return             Saturated value
 644  */
 645 #define __SSAT                            __ssat
 646
 647
 648 /**
 649   \brief   Unsigned Saturate
 650   \details Saturates an unsigned value.
 651   \param [in]  value  Value to be saturated
 652   \param [in]    sat  Bit position to saturate to (0..31)
 653   \return             Saturated value
 654  */
 655 #define __USAT                            __usat
 656
 657
 658 /**
 659   \brief   Rotate Right with Extend (32 bit)
 660   \details Moves each bit of a bitstring right by one bit.
 661            The carry input is shifted in at the left end of the bitstring.
 662   \param [in]    value  Value to rotate
 663   \return               Rotated value
 664  */
 665 #ifndef __NO_EMBEDDED_ASM
 666 __attribute__((section(".rrx_text"))) __STATIC_INLINE __ASM uint32_t __RRX(uint32_t value)
 667 {
 668   rrx r0, r0
 669   bx lr
 670 }
 671 #endif
 672
 673
 674 /**
 675   \brief   LDRT Unprivileged (8 bit)
 676   \details Executes a Unprivileged LDRT instruction for 8 bit value.
 677   \param [in]    ptr  Pointer to data
 678   \return             value of type uint8_t at (*ptr)
 679  */
 680 #define __LDRBT(ptr)                      ((uint8_t )  __ldrt(ptr))
 681
 682
 683 /**
 684   \brief   LDRT Unprivileged (16 bit)
 685   \details Executes a Unprivileged LDRT instruction for 16 bit values.
 686   \param [in]    ptr  Pointer to data
 687   \return        value of type uint16_t at (*ptr)
 688  */
 689 #define __LDRHT(ptr)                      ((uint16_t)  __ldrt(ptr))
 690
 691
 692 /**
 693   \brief   LDRT Unprivileged (32 bit)
 694   \details Executes a Unprivileged LDRT instruction for 32 bit values.
 695   \param [in]    ptr  Pointer to data
 696   \return        value of type uint32_t at (*ptr)
 697  */
 698 #define __LDRT(ptr)                       ((uint32_t ) __ldrt(ptr))
 699
 700
 701 /**
 702   \brief   STRT Unprivileged (8 bit)
 703   \details Executes a Unprivileged STRT instruction for 8 bit values.
 704   \param [in]  value  Value to store
 705   \param [in]    ptr  Pointer to location
 706  */
 707 #define __STRBT(value, ptr)               __strt(value, ptr)
 708
 709
 710 /**
 711   \brief   STRT Unprivileged (16 bit)
 712   \details Executes a Unprivileged STRT instruction for 16 bit values.
 713   \param [in]  value  Value to store
 714   \param [in]    ptr  Pointer to location
 715  */
 716 #define __STRHT(value, ptr)               __strt(value, ptr)
 717
 718
 719 /**
 720   \brief   STRT Unprivileged (32 bit)
 721   \details Executes a Unprivileged STRT instruction for 32 bit values.
 722   \param [in]  value  Value to store
 723   \param [in]    ptr  Pointer to location
 724  */
 725 #define __STRT(value, ptr)                __strt(value, ptr)
 726
 727 #else  /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
 728            (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 729
 730 /**
 731   \brief   Signed Saturate
 732   \details Saturates a signed value.
 733   \param [in]  value  Value to be saturated
 734   \param [in]    sat  Bit position to saturate to (1..32)
 735   \return             Saturated value
 736  */
 737 __attribute__((always_inline)) __STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat) {
 738   if ((sat >= 1U) && (sat <= 32U)) {
 739     const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
 740     const int32_t min = -1 - max ;
 741     if (val > max) {
 742       return max;
 743     } else if (val < min) {
 744       return min;
 745     }
 746   }
 747   return val;
 748 }
 749
 750 /**
 751   \brief   Unsigned Saturate
 752   \details Saturates an unsigned value.
 753   \param [in]  value  Value to be saturated
 754   \param [in]    sat  Bit position to saturate to (0..31)
 755   \return             Saturated value
 756  */
 757 __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAT(uint32_t val, uint32_t sat) {
 758   if (sat <= 31U) {
 759     const uint32_t max = ((1U << sat) - 1U);
 760     if (val > max) {
 761       return max;
 762     }
 763   }
 764   return val;
 765 }
 766
 767 #endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
 768            (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 769
 770 /*@}*/ /* end of group CMSIS_Core_InstructionInterface */
 771
 772
 773 /* ###################  Compiler specific Intrinsics  ########################### */
 774 /** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
 775   Access to dedicated SIMD instructions
 776   @{
 777 */
 778
 779 #if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 780
 781 #define __SADD8                           __sadd8
 782 #define __QADD8                           __qadd8
 783 #define __SHADD8                          __shadd8
 784 #define __UADD8                           __uadd8
 785 #define __UQADD8                          __uqadd8
 786 #define __UHADD8                          __uhadd8
 787 #define __SSUB8                           __ssub8
 788 #define __QSUB8                           __qsub8
 789 #define __SHSUB8                          __shsub8
 790 #define __USUB8                           __usub8
 791 #define __UQSUB8                          __uqsub8
 792 #define __UHSUB8                          __uhsub8
 793 #define __SADD16                          __sadd16
 794 #define __QADD16                          __qadd16
 795 #define __SHADD16                         __shadd16
 796 #define __UADD16                          __uadd16
 797 #define __UQADD16                         __uqadd16
 798 #define __UHADD16                         __uhadd16
 799 #define __SSUB16                          __ssub16
 800 #define __QSUB16                          __qsub16
 801 #define __SHSUB16                         __shsub16
 802 #define __USUB16                          __usub16
 803 #define __UQSUB16                         __uqsub16
 804 #define __UHSUB16                         __uhsub16
 805 #define __SASX                            __sasx
 806 #define __QASX                            __qasx
 807 #define __SHASX                           __shasx
 808 #define __UASX                            __uasx
 809 #define __UQASX                           __uqasx
 810 #define __UHASX                           __uhasx
 811 #define __SSAX                            __ssax
 812 #define __QSAX                            __qsax
 813 #define __SHSAX                           __shsax
 814 #define __USAX                            __usax
 815 #define __UQSAX                           __uqsax
 816 #define __UHSAX                           __uhsax
 817 #define __USAD8                           __usad8
 818 #define __USADA8                          __usada8
 819 #define __SSAT16                          __ssat16
 820 #define __USAT16                          __usat16
 821 #define __UXTB16                          __uxtb16
 822 #define __UXTAB16                         __uxtab16
 823 #define __SXTB16                          __sxtb16
 824 #define __SXTAB16                         __sxtab16
 825 #define __SMUAD                           __smuad
 826 #define __SMUADX                          __smuadx
 827 #define __SMLAD                           __smlad
 828 #define __SMLADX                          __smladx
 829 #define __SMLALD                          __smlald
 830 #define __SMLALDX                         __smlaldx
 831 #define __SMUSD                           __smusd
 832 #define __SMUSDX                          __smusdx
 833 #define __SMLSD                           __smlsd
 834 #define __SMLSDX                          __smlsdx
 835 #define __SMLSLD                          __smlsld
 836 #define __SMLSLDX                         __smlsldx
 837 #define __SEL                             __sel
 838 #define __QADD                            __qadd
 839 #define __QSUB                            __qsub
 840
 841 #define __PKHBT(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0x0000FFFFUL) |  \
 842                                            ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL)  )
 843
 844 #define __PKHTB(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0xFFFF0000UL) |  \
 845                                            ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL)  )
 846
 847 #define __SMMLA(ARG1,ARG2,ARG3)          ( (int32_t)((((int64_t)(ARG1) * (ARG2)) + \
 848                                                       ((int64_t)(ARG3) << 32U)     ) >> 32U))
 849
 850 #endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 851 /*@} end of group CMSIS_SIMD_intrinsics */
 852
 853
 854 #endif /* __CMSIS_ARMCC_H */