begriffs open source - cmsis/blob - CMSIS/DoxyGen/Core/src/Ref_CompilerControl.txt

   1 /**************************************************************************************************/
   2 /**
   3 \defgroup   compiler_conntrol_gr    Compiler Control
   4 \brief      Compiler agnostic \#define symbols for generic C/C++ source code
   5 \details
   6 The CMSIS-Core provides the header file <b>cmsis_compiler.h</b> with consistent \#define symbols for generate C or C++ source files that should be compiler agnostic.
   7 Each CMSIS compliant compiler should support the functionality described in this section.
   8
   9 The header file <b>cmsis_compiler.h</b> is also included by each \ref device_h_pg so that these definitions are available.
  10 @{
  11 */
  12
  13 /**
  14 \def __ARM_ARCH_6M__
  15 \brief Set to 1 when generating code for ARMv6-M (Cortex-M0, Cortex-M1)
  16 \details
  17 The <b>\#define __ARM_ARCH_6M__</b> is set to 1 when generating code for the ARMv6-M architecture. This architecture is for example used by the Cortex-M0, Cortex-M0+, and Cortex-M1 processor.
  18 */
  19 #define __ARM_ARCH_6M__
  20
  21 /**
  22 \def __ARM_ARCH_7M__
  23 \brief Set to 1 when generating code for ARMv7-M (Cortex-M3)
  24 \details
  25 The <b>\#define __ARM_ARCH_7M__</b> is set to 1 when generating code for the ARMv7-M architecture. This architecture is for example used by the Cortex-M3 processor.
  26 */
  27 #define __ARM_ARCH_7M__
  28
  29 /**
  30 \def __ARM_ARCH_7EM__
  31 \brief Set to 1 when generating code for ARMv7-M (Cortex-M4) with FPU
  32 \details
  33 The <b>\#define __ARM_ARCH_7EM__</b> is set to 1 when generating code for the ARMv7-M architecture with floating point extension. This architecture is for example used by the Cortex-M4 processor with FPU
  34 */
  35 #define __ARM_ARCH_7EM__
  36
  37 /**
  38 \def __ARM_ARCH_8M_BASE__
  39 \brief Set to 1 when generating code for ARMv8-M Baseline
  40 \details
  41 The <b>\#define __ARM_ARCH_8M_BASE__</b> is set to 1 when generating code for the ARMv8-M architecture baseline variant.
  42 */
  43 #define __ARM_ARCH_8M_BASE__
  44
  45 /**
  46 \def __ARM_ARCH_8M_MAIN__
  47 \brief Set to 1 when generating code for ARMv8-M Mainline
  48 \details
  49 The <b>\#define __ARM_ARCH_8M_MAIN__</b> is set to 1 when generating code for the ARMv8-M architecture mainline variant.
  50 */
  51 #define __ARM_ARCH_8M_MAIN__
  52
  53
  54
  55 /**************************************************************************************************/
  56 /**
  57 \def __ASM
  58 \brief Pass information from the compiler to the assembler.
  59 \details
  60 The \b __ASM keyword can declare or define an embedded assembly function or incorporate inline assembly into a function
  61 (shown in the code example below).
  62
  63 <b>Code Example:</b>
  64 \code
  65 // Reverse bit order of value
  66
  67 __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
  68 {
  69   uint32_t result;
  70
  71    __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );
  72    return(result);
  73 }
  74 \endcode
  75
  76 */
  77 #define __ASM
  78
  79 /**************************************************************************************************/
  80 /**
  81 \def __INLINE
  82 \brief Recommend that function should be inlined by the compiler.
  83 \details
  84 Inline functions offer a trade-off between code size and performance. By default, the compiler decides during optimization whether to
  85 inline code or not. The \b __INLINE attribute gives the compiler an hint to inline this function. Still, the compiler may decide not to inline
  86 the function.  As the function is global an callable function is also generated.
  87
  88 <b> Code Example:</b>
  89 \code
  90 const uint32_t led_mask[] = {1UL << 4, 1UL << 5, 1UL << 6, 1UL << 7};
  91
  92 /*------------------------------------------------------------------------------
  93   Switch on LEDs
  94  *------------------------------------------------------------------------------*/
  95 __INLINE static void LED_On (uint32_t led) {
  96
  97   PTD->PCOR   = led_mask[led];
  98 }
  99 \endcode
 100
 101 */
 102 #define __INLINE
 103
 104 /**************************************************************************************************/
 105 /**
 106 \def __STATIC_INLINE
 107 \brief Define a static function should be inlined by the compiler.
 108 \details
 109 Defines a static function that may be inlined by the compiler. If the compiler generates inline code for
 110 all calls to this functions, no additional function implementation is generated which may further optimize space.
 111
 112 <b> Code Example:</b>
 113 \code
 114 \\ Get Interrupt Vector
 115 __STATIC_INLINE uint32_t NVIC_GetVector(IRQn_Type IRQn)
 116 {
 117     uint32_t *vectors = (uint32_t *)SCB->VTOR;
 118     return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
 119 }
 120 \endcode
 121
 122 */
 123 #define __STATIC_INLINE
 124
 125 /**************************************************************************************************/
 126 /**
 127 \def __NO_RETURN
 128 \brief Inform the compiler that a function does not return.
 129 \details
 130 Informs the compiler that the function does not return. The compiler can then perform optimizations by
 131 removing code that is never reached.
 132
 133 <b> Code Example:</b>
 134 \code
 135 // OS idle demon (running when no other thread is ready to run).
 136
 137 __NO_RETURN void os_idle_demon (void);
 138 \endcode
 139
 140 */
 141 #define __NO_RETURN
 142
 143 /**************************************************************************************************/
 144 /**
 145 \def __USED
 146 \brief Inform that a variable shall be retained in executable image.
 147 \details
 148 Definitions tagged with \b __USED in the source code should be not removed by the linker when detected as unused.
 149
 150 <b> Code Example:</b>
 151 \code
 152 /* Export following variables for debugging */
 153 __USED uint32_t const CMSIS_RTOS_API_Version = osCMSIS;
 154 __USED uint32_t const CMSIS_RTOS_RTX_Version = osCMSIS_RTX;
 155 __USED uint32_t const os_clockrate = OS_TICK;
 156 __USED uint32_t const os_timernum  = 0;
 157 \endcode
 158
 159 */
 160 #define __USED
 161
 162 /**************************************************************************************************/
 163 /**
 164 \def __WEAK
 165 \brief Export a function or variable weakly to allow overwrites.
 166 \details
 167 Functions defined with \b __WEAK export their symbols weakly. A weakly defined function behaves like a normally defined
 168 function unless a non-weakly defined function of the same name is linked into the same image. If both a non-weakly defined
 169 function and a weakly defined function exist in the same image then all calls to the function resolve to call the non-weak
 170 function.
 171
 172 Functions declared with \b __WEAK and then defined without \b __WEAK behave as non-weak functions.
 173
 174 <b> Code Example:</b>
 175 \code
 176 __WEAK void SystemInit(void)
 177 {
 178   SystemCoreSetup();
 179   SystemCoreClockSetup();
 180 }
 181 \endcode
 182
 183 */
 184 #define __WEAK
 185
 186 /**************************************************************************************************/
 187 /**
 188 \def __UNALIGNED_UINT32
 189 \brief Pointer for unaligned access of a uint32_t variable.
 190 \details
 191 Defines a pointer to a uint32_t from an address that does not need to be aligned. This can then be used in read/write
 192 operations. The compiler will generate the appropriate access (aligned or non-aligned) depending on the underlying ARM
 193 processor core and compiler settings.
 194
 195 <b> Code Example:</b>
 196 \code
 197 uint32_t val32;
 198
 199 void test (uint8_t *ptr) {
 200   __UNALIGNED_UINT32(ptr) = val32;
 201 }
 202 \endcode
 203
 204 */
 205 #define __UNALIGNED_UINT32
 206
 207 /**************************************************************************************************/
 208 /**
 209 \def __ALIGNED
 210 \brief Minimum alignment for a variable.
 211 \details
 212 Specifies a minimum alignment for a variable or structure field, measured in bytes.
 213
 214 <b> Code Example:</b>
 215 \code
 216 uint32_t stack_space[0x100] __ALIGNED(8);   // 8-byte alignment required
 217 \endcode
 218
 219 */
 220 #define __ALIGNED
 221
 222 /**************************************************************************************************/
 223 /**
 224 \def __PACKED
 225 \brief Request smallest possible alignment.
 226 \details
 227 Specifies that a type must have the smallest possible alignment.
 228
 229 <b> Code Example:</b>
 230 \code
 231 struct foo {
 232   uint8_t  u8;
 233   uint32_t u32[2] __PACKED;
 234 };
 235 \endcode
 236
 237 */
 238 #define __PACKED
 239
 240 /**************************************************************************************************/
 241 /**
 242 \def __PACKED_STRUCT
 243 \brief Request smallest possible alignment for a structure.
 244 \details
 245 Specifies that a structure must have the smallest possible alignment.
 246
 247 <b> Code Example:</b>
 248 \code
 249 __PACKED_STRUCT foo {
 250   uint8_t   u8;
 251   uint32_t  u32;
 252   uint16_t  u16;
 253 };
 254 \endcode
 255
 256 */
 257 #define __PACKED_STRUCT
 258
 259 /** @} */ /** end of compiler_conntrol_gr **/