begriffs open source - cmsis/blob - CMSIS/CoreValidation/Source/CV_CoreInstr.c

   1 /*-----------------------------------------------------------------------------
   2  *      Name:         CV_CoreInstr.c
   3  *      Purpose:      CMSIS CORE validation tests implementation
   4  *-----------------------------------------------------------------------------
   5  *      Copyright (c) 2017 - 2021 Arm Limited. All rights reserved.
   6  *----------------------------------------------------------------------------*/
   7
   8 #include "CV_Framework.h"
   9 #include "cmsis_cv.h"
  10
  11 #if defined(__CORTEX_M)
  12 #elif defined(__CORTEX_A)
  13 #include "irq_ctrl.h"
  14 #else
  15 #error __CORTEX_M or __CORTEX_A must be defined!
  16 #endif
  17
  18 /*-----------------------------------------------------------------------------
  19  *      Test implementation
  20  *----------------------------------------------------------------------------*/
  21
  22 /*-----------------------------------------------------------------------------
  23  *      Test cases
  24  *----------------------------------------------------------------------------*/
  25
  26 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  27 /**
  28 \brief Test case: TC_CoreInstr_NOP
  29 \details
  30 - Check if __NOP instrinsic is available
  31 - No real assertion is deployed, just a compile time check.
  32 */
  33 void TC_CoreInstr_NOP (void) {
  34   __NOP();
  35   ASSERT_TRUE(1U == 1U);
  36 }
  37
  38 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  39 /**
  40 \brief Test case: TC_CoreInstr_SEV
  41 \details
  42 - Check if __SEV instrinsic is available
  43 - No real assertion is deployed, just a compile time check.
  44 */
  45 void TC_CoreInstr_SEV (void) {
  46   __SEV();
  47   ASSERT_TRUE(1U == 1U);
  48 }
  49
  50 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  51 /**
  52 \brief Test case: TC_CoreInstr_BKPT
  53 \details
  54 - Check if __BKPT instrinsic is available
  55 - No real assertion is deployed, just a compile time check.
  56 */
  57 void TC_CoreInstr_BKPT (void) {
  58   __BKPT(0xABU);
  59   ASSERT_TRUE(1U == 1U);
  60 }
  61
  62 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  63 /**
  64 \brief Test case: TC_CoreInstr_ISB
  65 \details
  66 - Check if __ISB instrinsic is available
  67 - No real assertion is deployed, just a compile time check.
  68 */
  69 void TC_CoreInstr_ISB (void) {
  70   __ISB();
  71   ASSERT_TRUE(1U == 1U);
  72 }
  73
  74 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  75 /**
  76 \brief Test case: TC_CoreInstr_DSB
  77 \details
  78 - Check if __DSB instrinsic is available
  79 - No real assertion is deployed, just a compile time check.
  80 */
  81 void TC_CoreInstr_DSB (void) {
  82   __DSB();
  83   ASSERT_TRUE(1U == 1U);
  84 }
  85
  86 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  87 /**
  88 \brief Test case: TC_CoreInstr_DMB
  89 \details
  90 - Check if __DNB instrinsic is available
  91 - No real assertion is deployed, just a compile time check.
  92 */
  93 void TC_CoreInstr_DMB (void) {
  94   __DMB();
  95   ASSERT_TRUE(1U == 1U);
  96 }
  97
  98 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  99 /**
 100 \brief Test case: TC_CoreInstr_WFI
 101 \details
 102 - Check if __WFI instrinsic is available
 103 - No real assertion is deployed, just a compile time check.
 104 */
 105 void TC_CoreInstr_WFI (void) {
 106   __WFI();
 107   ASSERT_TRUE(1U == 1U);
 108 }
 109
 110 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 111 /**
 112 \brief Test case: TC_CoreInstr_WFE
 113 \details
 114 - Check if __WFE instrinsic is available
 115 - No real assertion is deployed, just a compile time check.
 116 */
 117 void TC_CoreInstr_WFE (void) {
 118   __WFE();
 119   ASSERT_TRUE(1U == 1U);
 120 }
 121
 122 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 123 /**
 124 \brief Test case: TC_CoreInstr_REV
 125 \details
 126 - Check if __REV instrinsic swaps all bytes in a word.
 127 */
 128 void TC_CoreInstr_REV (void) {
 129   volatile uint32_t op1_u32;
 130   volatile uint32_t res_u32;
 131
 132   op1_u32 = 0x47110815U;
 133   res_u32 = __REV(op1_u32);
 134   ASSERT_TRUE(res_u32 == 0x15081147U);
 135
 136   op1_u32 = 0x80000000U;
 137   res_u32 = __REV(op1_u32);
 138   ASSERT_TRUE(res_u32 == 0x00000080U);
 139
 140   op1_u32 = 0x00000080U;
 141   res_u32 = __REV(op1_u32);
 142   ASSERT_TRUE(res_u32 == 0x80000000U);
 143 }
 144
 145 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 146 /**
 147 \brief Test case: TC_CoreInstr_REV16
 148 \details
 149 - Check if __REV16 instrinsic swaps the bytes in both halfwords independendly.
 150 */
 151 void TC_CoreInstr_REV16(void) {
 152   volatile uint32_t op1_u32;
 153   volatile uint32_t res_u32;
 154
 155   op1_u32 = 0x47110815U;
 156   res_u32 = __REV16(op1_u32);
 157   ASSERT_TRUE(res_u32 == 0x11471508U);
 158
 159   op1_u32 = 0x00001234U;
 160   res_u32 = __REV16(op1_u32);
 161   ASSERT_TRUE(res_u32 == 0x00003412U);
 162 }
 163
 164 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 165 /**
 166 \brief Test case: TC_CoreInstr_REVSH
 167 \details
 168 - Check if __REVSH instrinsic swaps bytes in a signed halfword keeping the sign.
 169 */
 170 void TC_CoreInstr_REVSH(void) {
 171   volatile int16_t value  = 0U;
 172            int16_t result = 0U;
 173
 174   value = 0x4711;
 175   result = __REVSH(value);
 176   ASSERT_TRUE(result == 0x1147);
 177
 178   value = (int16_t)0x8000;
 179   result = __REVSH(value);
 180   ASSERT_TRUE(result == 0x0080);
 181
 182   value = 0x0080;
 183   result = __REVSH(value);
 184   ASSERT_TRUE(result == (int16_t)0x8000);
 185
 186   value = -0x1234;
 187   result = __REVSH(value);
 188   ASSERT_TRUE(result == (int16_t)0xcced);
 189 }
 190
 191 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 192 /**
 193 \brief Test case: TC_CoreInstr_RBIT
 194 \details
 195 - Check if __RBIT instrinsic revserses the bit order of arbitrary words.
 196 */
 197 void TC_CoreInstr_RBIT (void) {
 198   volatile uint32_t value  = 0U;
 199            uint32_t result = 0U;
 200
 201   value = 0xAAAAAAAAU;
 202   result = __RBIT(value);
 203   ASSERT_TRUE(result == 0x55555555U);
 204
 205   value = 0x55555555U;
 206   result = __RBIT(value);
 207   ASSERT_TRUE(result == 0xAAAAAAAAU);
 208
 209   value = 0x00000001U;
 210   result = __RBIT(value);
 211   ASSERT_TRUE(result == 0x80000000U);
 212
 213   value = 0x80000000U;
 214   result = __RBIT(value);
 215   ASSERT_TRUE(result == 0x00000001U);
 216
 217   value = 0xDEADBEEFU;
 218   result = __RBIT(value);
 219   ASSERT_TRUE(result == 0xF77DB57BU);
 220 }
 221
 222 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 223 /**
 224 \brief Test case: TC_CoreInstr_ROR
 225 \details
 226 - Check if __ROR instrinsic moves all bits as expected.
 227 */
 228 void TC_CoreInstr_ROR(void) {
 229   volatile uint32_t value  = 0U;
 230            uint32_t result = 0U;
 231
 232   value = 0x00000001U;
 233   result = __ROR(value, 1U);
 234   ASSERT_TRUE(result == 0x80000000U);
 235
 236   value = 0x80000000U;
 237   result = __ROR(value, 1U);
 238   ASSERT_TRUE(result == 0x40000000U);
 239
 240   value = 0x40000000U;
 241   result = __ROR(value, 30U);
 242   ASSERT_TRUE(result == 0x00000001U);
 243
 244   value = 0x00000001U;
 245   result = __ROR(value, 32U);
 246   ASSERT_TRUE(result == 0x00000001U);
 247
 248   value = 0x08154711U;
 249   result = __ROR(value, 8U);
 250   ASSERT_TRUE(result == 0x11081547U);
 251 }
 252
 253 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 254 /**
 255 \brief Test case: TC_CoreInstr_CLZ
 256 \details
 257 - Check if __CLZ instrinsic counts leading zeros.
 258 */
 259 void TC_CoreInstr_CLZ (void) {
 260   volatile uint32_t value  = 0U;
 261            uint32_t result = 0U;
 262
 263   value = 0x00000000U;
 264   result = __CLZ(value);
 265   ASSERT_TRUE(result == 32);
 266
 267   value = 0x00000001U;
 268   result = __CLZ(value);
 269   ASSERT_TRUE(result == 31);
 270
 271   value = 0x40000000U;
 272   result = __CLZ(value);
 273   ASSERT_TRUE(result == 1);
 274
 275   value = 0x80000000U;
 276   result = __CLZ(value);
 277   ASSERT_TRUE(result == 0);
 278
 279   value = 0xFFFFFFFFU;
 280   result = __CLZ(value);
 281   ASSERT_TRUE(result == 0);
 282
 283   value = 0x80000001U;
 284   result = __CLZ(value);
 285   ASSERT_TRUE(result == 0);
 286 }
 287
 288 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 289 /**
 290 \brief Test case: TC_CoreInstr_SSAT
 291 \details
 292 - Check if __SSAT instrinsic saturates signed integer values.
 293 */
 294 void TC_CoreInstr_SSAT (void) {
 295   volatile int32_t value  = 0;
 296            int32_t result = 0;
 297
 298   value = INT32_MAX;
 299   result = __SSAT(value, 32U);
 300   ASSERT_TRUE(result == INT32_MAX);
 301
 302   value = INT32_MAX;
 303   result = __SSAT(value, 16U);
 304   ASSERT_TRUE(result == INT16_MAX);
 305
 306   value = INT32_MAX;
 307   result = __SSAT(value, 8U);
 308   ASSERT_TRUE(result == INT8_MAX);
 309
 310   value = INT32_MAX;
 311   result = __SSAT(value, 1U);
 312   ASSERT_TRUE(result == 0);
 313
 314   value = INT32_MIN;
 315   result = __SSAT(value, 32U);
 316   ASSERT_TRUE(result == INT32_MIN);
 317
 318   value = INT32_MIN;
 319   result = __SSAT(value, 16U);
 320   ASSERT_TRUE(result == INT16_MIN);
 321
 322   value = INT32_MIN;
 323   result = __SSAT(value, 8U);
 324   ASSERT_TRUE(result == INT8_MIN);
 325
 326   value = INT32_MIN;
 327   result = __SSAT(value, 1U);
 328   ASSERT_TRUE(result == -1);
 329 }
 330
 331 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 332 /**
 333 \brief Test case: TC_CoreInstr_USAT
 334 \details
 335 - Check if __USAT instrinsic saturates unsigned integer values.
 336 */
 337 void TC_CoreInstr_USAT (void) {
 338   volatile  int32_t value  = 0U;
 339            uint32_t result = 0U;
 340
 341   value = INT32_MAX;
 342   result = __USAT(value, 31U);
 343   ASSERT_TRUE(result == (UINT32_MAX >> 1U));
 344
 345   value = INT32_MAX;
 346   result = __USAT(value, 16U);
 347   ASSERT_TRUE(result == UINT16_MAX);
 348
 349   value = INT32_MAX;
 350   result = __USAT(value, 8U);
 351   ASSERT_TRUE(result == UINT8_MAX);
 352
 353   value = INT32_MAX;
 354   result = __USAT(value, 0U);
 355   ASSERT_TRUE(result == 0U);
 356
 357   value = INT32_MIN;
 358   result = __USAT(value, 31U);
 359   ASSERT_TRUE(result == 0U);
 360
 361   value = INT32_MIN;
 362   result = __USAT(value, 16U);
 363   ASSERT_TRUE(result == 0U);
 364
 365   value = INT32_MIN;
 366   result = __USAT(value, 8U);
 367   ASSERT_TRUE(result == 0U);
 368
 369   value = INT32_MIN;
 370   result = __USAT(value, 0U);
 371   ASSERT_TRUE(result == 0U);
 372 }
 373
 374 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 375 /**
 376 \brief Test case: TC_CoreInstr_RRX
 377 \details
 378 - Check if __USAT instrinsic saturates unsigned integer values.
 379 */
 380 void TC_CoreInstr_RRX (void) {
 381 #if ((defined (__ARM_ARCH_7M__        ) && (__ARM_ARCH_7M__        == 1)) || \
 382      (defined (__ARM_ARCH_7EM__       ) && (__ARM_ARCH_7EM__       == 1)) || \
 383      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 384      (defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1))    )
 385
 386   volatile uint32_t  value  = 0U;
 387   volatile uint32_t  result = 0U;
 388   volatile xPSR_Type xPSR;
 389
 390   value = 0x80000002;
 391   xPSR.w = __get_xPSR();
 392   result = __RRX(value);
 393   ASSERT_TRUE(result == (0x40000001 | (uint32_t)(xPSR.b.C << 31)));
 394 #endif
 395 }
 396
 397 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 398 #if ((defined (__ARM_ARCH_7M__        ) && (__ARM_ARCH_7M__        == 1)) || \
 399      (defined (__ARM_ARCH_7EM__       ) && (__ARM_ARCH_7EM__       == 1)) || \
 400      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 401      (defined (__ARM_ARCH_8M_BASE__   ) && (__ARM_ARCH_8M_BASE__   == 1)) || \
 402      (defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1)) || \
 403      (defined(__CORTEX_A)                                               )    )
 404
 405 /// Exclusive byte value
 406 static volatile uint8_t TC_CoreInstr_LoadStoreExclusive_byte = 0x47U;
 407
 408 /// Exclusive halfword value
 409 static volatile uint16_t TC_CoreInstr_LoadStoreExclusive_hword = 0x0815U;
 410
 411 /// Exclusive word value
 412 static volatile uint32_t TC_CoreInstr_LoadStoreExclusive_word = 0x08154711U;
 413
 414 /**
 415 \brief Interrupt function for TC_CoreInstr_LoadStoreExclusive
 416 \details
 417 The interrupt manipulates all the global data
 418 which disrupts the exclusive sequences in the test
 419 */
 420 static void TC_CoreInstr_LoadStoreExclusive_IRQHandler(void) {
 421
 422   const uint8_t b = __LDREXB(&TC_CoreInstr_LoadStoreExclusive_byte);
 423   __STREXB((uint8_t)~b, &TC_CoreInstr_LoadStoreExclusive_byte);
 424
 425   const uint16_t hw = __LDREXH(&TC_CoreInstr_LoadStoreExclusive_hword);
 426   __STREXH((uint16_t)~hw, &TC_CoreInstr_LoadStoreExclusive_hword);
 427
 428   const uint32_t w = __LDREXW(&TC_CoreInstr_LoadStoreExclusive_word);
 429   __STREXW((uint32_t)~w, &TC_CoreInstr_LoadStoreExclusive_word);
 430 }
 431
 432 /**
 433 \brief Helper function for TC_CoreInstr_LoadStoreExclusive to enable test interrupt.
 434 \details
 435 This helper function implements interrupt enabling according to target
 436 architecture, i.e. Cortex-A or Cortex-M.
 437 */
 438 static void TC_CoreInstr_LoadStoreExclusive_IRQEnable(void) {
 439 #if defined(__CORTEX_M)
 440   TST_IRQHandler = TC_CoreInstr_LoadStoreExclusive_IRQHandler;
 441   NVIC_EnableIRQ(Interrupt0_IRQn);
 442 #elif defined(__CORTEX_A)
 443   IRQ_SetHandler(SGI0_IRQn, TC_CoreInstr_LoadStoreExclusive_IRQHandler);
 444   IRQ_Enable(SGI0_IRQn);
 445 #else
 446   #error __CORTEX_M or __CORTEX_A must be defined!
 447 #endif
 448   __enable_irq();
 449 }
 450
 451 /**
 452 \brief Helper function for TC_CoreInstr_LoadStoreExclusive to set test interrupt pending.
 453 \details
 454 This helper function implements set pending the test interrupt according to target
 455 architecture, i.e. Cortex-A or Cortex-M.
 456 */
 457 static void TC_CoreInstr_LoadStoreExclusive_IRQPend(void) {
 458 #if defined(__CORTEX_M)
 459   NVIC_SetPendingIRQ(Interrupt0_IRQn);
 460 #elif defined(__CORTEX_A)
 461   IRQ_SetPending(SGI0_IRQn);
 462 #else
 463   #error __CORTEX_M or __CORTEX_A must be defined!
 464 #endif
 465   for(uint32_t i = 10U; i > 0U; --i) {}
 466 }
 467
 468 /**
 469 \brief Helper function for TC_CoreInstr_LoadStoreExclusive to disable test interrupt.
 470 \details
 471 This helper function implements interrupt disabling according to target
 472 architecture, i.e. Cortex-A or Cortex-M.
 473 */
 474 static void TC_CoreInstr_LoadStoreExclusive_IRQDisable(void) {
 475   __disable_irq();
 476 #if defined(__CORTEX_M)
 477   NVIC_DisableIRQ(Interrupt0_IRQn);
 478   TST_IRQHandler = NULL;
 479 #elif defined(__CORTEX_A)
 480   IRQ_Disable(SGI0_IRQn);
 481   IRQ_SetHandler(SGI0_IRQn, NULL);
 482 #else
 483   #error __CORTEX_M or __CORTEX_A must be defined!
 484 #endif
 485 }
 486 #endif
 487
 488 /**
 489 \brief Test case: TC_CoreInstr_LoadStoreExclusive
 490 \details
 491 Checks exclusive load and store instructions:
 492 - LDREXB, LDREXH, LDREXW
 493 - STREXB, STREXH, STREXW
 494 - CLREX
 495 */
 496 void TC_CoreInstr_LoadStoreExclusive (void) {
 497 #if ((defined (__ARM_ARCH_7M__        ) && (__ARM_ARCH_7M__        == 1)) || \
 498      (defined (__ARM_ARCH_7EM__       ) && (__ARM_ARCH_7EM__       == 1)) || \
 499      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 500      (defined (__ARM_ARCH_8M_BASE__   ) && (__ARM_ARCH_8M_BASE__   == 1)) || \
 501      (defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1)) || \
 502      (defined(__CORTEX_A)                                               )    )
 503   uint8_t  u8,  u8Inv;
 504   uint16_t u16, u16Inv;
 505   uint32_t u32, u32Inv;
 506   uint32_t result;
 507
 508   /* 1. Test exclusives without interruption */
 509   u8 = __LDREXB(&TC_CoreInstr_LoadStoreExclusive_byte);
 510   ASSERT_TRUE(u8 == TC_CoreInstr_LoadStoreExclusive_byte);
 511
 512   result = __STREXB(u8+1U, &TC_CoreInstr_LoadStoreExclusive_byte);
 513   ASSERT_TRUE(result == 0U);
 514   ASSERT_TRUE(TC_CoreInstr_LoadStoreExclusive_byte == u8+1U);
 515
 516   u16 = __LDREXH(&TC_CoreInstr_LoadStoreExclusive_hword);
 517   ASSERT_TRUE(u16 == TC_CoreInstr_LoadStoreExclusive_hword);
 518
 519   result = __STREXH(u16+1U, &TC_CoreInstr_LoadStoreExclusive_hword);
 520   ASSERT_TRUE(result == 0U);
 521   ASSERT_TRUE(TC_CoreInstr_LoadStoreExclusive_hword == u16+1U);
 522
 523   u32 = __LDREXW(&TC_CoreInstr_LoadStoreExclusive_word);
 524   ASSERT_TRUE(u32 == TC_CoreInstr_LoadStoreExclusive_word);
 525
 526   result = __STREXW(u32+1U, &TC_CoreInstr_LoadStoreExclusive_word);
 527   ASSERT_TRUE(result == 0U);
 528   ASSERT_TRUE(TC_CoreInstr_LoadStoreExclusive_word == u32+1U);
 529
 530   /* 2. Test exclusives with clear */
 531   u8 = __LDREXB(&TC_CoreInstr_LoadStoreExclusive_byte);
 532   ASSERT_TRUE(u8 == TC_CoreInstr_LoadStoreExclusive_byte);
 533
 534   __CLREX();
 535
 536   result = __STREXB(u8+1U, &TC_CoreInstr_LoadStoreExclusive_byte);
 537   ASSERT_TRUE(result == 1U);
 538   ASSERT_TRUE(TC_CoreInstr_LoadStoreExclusive_byte == u8);
 539
 540   u16 = __LDREXH(&TC_CoreInstr_LoadStoreExclusive_hword);
 541   ASSERT_TRUE(u16 == TC_CoreInstr_LoadStoreExclusive_hword);
 542
 543   __CLREX();
 544
 545   result = __STREXH(u16+1U, &TC_CoreInstr_LoadStoreExclusive_hword);
 546   ASSERT_TRUE(result == 1U);
 547   ASSERT_TRUE(TC_CoreInstr_LoadStoreExclusive_hword == u16);
 548
 549   u32 = __LDREXW(&TC_CoreInstr_LoadStoreExclusive_word);
 550   ASSERT_TRUE(u32 == TC_CoreInstr_LoadStoreExclusive_word);
 551
 552   __CLREX();
 553
 554   result = __STREXW(u32+1U, &TC_CoreInstr_LoadStoreExclusive_word);
 555   ASSERT_TRUE(result == 1U);
 556   ASSERT_TRUE(TC_CoreInstr_LoadStoreExclusive_word == u32);
 557
 558   /* 3. Test exclusives with interruption */
 559   TC_CoreInstr_LoadStoreExclusive_IRQEnable();
 560
 561   u8 = __LDREXB(&TC_CoreInstr_LoadStoreExclusive_byte);
 562   ASSERT_TRUE(u8 == TC_CoreInstr_LoadStoreExclusive_byte);
 563
 564   TC_CoreInstr_LoadStoreExclusive_IRQPend();
 565
 566   result = __STREXB(u8+1U, &TC_CoreInstr_LoadStoreExclusive_byte);
 567   ASSERT_TRUE(result == 1U);
 568   u8Inv = (uint8_t)~u8;
 569   ASSERT_TRUE(u8Inv == TC_CoreInstr_LoadStoreExclusive_byte);
 570
 571   u16 = __LDREXH(&TC_CoreInstr_LoadStoreExclusive_hword);
 572   ASSERT_TRUE(u16 == TC_CoreInstr_LoadStoreExclusive_hword);
 573
 574   TC_CoreInstr_LoadStoreExclusive_IRQPend();
 575
 576   result = __STREXH(u16+1U, &TC_CoreInstr_LoadStoreExclusive_hword);
 577   ASSERT_TRUE(result == 1U);
 578   u16Inv = (uint16_t)~u16;
 579   ASSERT_TRUE(u16Inv == TC_CoreInstr_LoadStoreExclusive_hword);
 580
 581   u32 = __LDREXW(&TC_CoreInstr_LoadStoreExclusive_word);
 582   ASSERT_TRUE(u32 == TC_CoreInstr_LoadStoreExclusive_word);
 583
 584   TC_CoreInstr_LoadStoreExclusive_IRQPend();
 585
 586   result = __STREXW(u32+1U, &TC_CoreInstr_LoadStoreExclusive_word);
 587   ASSERT_TRUE(result == 1U);
 588   u32Inv = (uint32_t)~u32;
 589   ASSERT_TRUE(u32Inv == TC_CoreInstr_LoadStoreExclusive_word);
 590
 591   TC_CoreInstr_LoadStoreExclusive_IRQDisable();
 592 #endif
 593 }
 594
 595 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 596 #if ((defined (__ARM_ARCH_7M__        ) && (__ARM_ARCH_7M__        == 1)) || \
 597      (defined (__ARM_ARCH_7EM__       ) && (__ARM_ARCH_7EM__       == 1)) || \
 598      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 599      (defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1))    )
 600
 601 /// byte value unprivileged access
 602 static volatile uint8_t TC_CoreInstr_LoadStoreUnpriv_byte = 0x47U;
 603
 604 /// halfword value unprivileged access
 605 static volatile uint16_t TC_CoreInstr_LoadStoreUnpriv_hword = 0x0815U;
 606
 607 /// word value unprivileged access
 608 static volatile uint32_t TC_CoreInstr_LoadStoreUnpriv_word = 0x08154711U;
 609 #endif
 610
 611
 612 /**
 613 \brief Test case: TC_CoreInstr_LoadStoreUnpriv
 614 \details
 615 Checks load/store unprivileged instructions:
 616 - LDRBT, LDRHT, LDRT
 617 - STRBT, STRHT, STRT
 618 */
 619 void TC_CoreInstr_LoadStoreUnpriv (void) {
 620 #if ((defined (__ARM_ARCH_7M__        ) && (__ARM_ARCH_7M__        == 1)) || \
 621      (defined (__ARM_ARCH_7EM__       ) && (__ARM_ARCH_7EM__       == 1)) || \
 622      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 623      (defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1))    )
 624   uint8_t  u8     = 0U;
 625   uint16_t u16    = 0U;
 626   uint32_t u32    = 0U;
 627
 628   /* 1. Test without interruption */
 629   u8 = __LDRBT(&TC_CoreInstr_LoadStoreUnpriv_byte);
 630   ASSERT_TRUE(u8 == TC_CoreInstr_LoadStoreUnpriv_byte);
 631
 632   __STRBT(u8+1U, &TC_CoreInstr_LoadStoreUnpriv_byte);
 633   ASSERT_TRUE(TC_CoreInstr_LoadStoreUnpriv_byte == u8+1U);
 634
 635   u16 = __LDRHT(&TC_CoreInstr_LoadStoreUnpriv_hword);
 636   ASSERT_TRUE(u16 == TC_CoreInstr_LoadStoreUnpriv_hword);
 637
 638   __STRHT(u16+1U, &TC_CoreInstr_LoadStoreUnpriv_hword);
 639   ASSERT_TRUE(TC_CoreInstr_LoadStoreUnpriv_hword == u16+1U);
 640
 641   u32 = __LDRT(&TC_CoreInstr_LoadStoreUnpriv_word);
 642   ASSERT_TRUE(u32 == TC_CoreInstr_LoadStoreUnpriv_word);
 643
 644   __STRT(u32+1U, &TC_CoreInstr_LoadStoreUnpriv_word);
 645   ASSERT_TRUE(TC_CoreInstr_LoadStoreUnpriv_word == u32+1U);
 646 #endif
 647 }
 648
 649 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 650 #if ((defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1)) || \
 651      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 652      (defined (__ARM_ARCH_8M_BASE__   ) && (__ARM_ARCH_8M_BASE__   == 1))    )
 653
 654 /// byte value unprivileged access
 655 static volatile uint8_t TC_CoreInstr_LoadStoreAcquire_byte = 0x47U;
 656
 657 /// halfword value unprivileged access
 658 static volatile uint16_t TC_CoreInstr_LoadStoreAcquire_hword = 0x0815U;
 659
 660 /// word value unprivileged access
 661 static volatile uint32_t TC_CoreInstr_LoadStoreAcquire_word = 0x08154711U;
 662 #endif
 663
 664
 665 /**
 666 \brief Test case: TC_CoreInstr_LoadStoreAquire
 667 \details
 668 Checks Load-Acquire and Store-Release instructions:
 669 - LDAB, LDAH, LDA
 670 - STLB, STLH, STL
 671 */
 672 void TC_CoreInstr_LoadStoreAcquire (void) {
 673 #if ((defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1)) || \
 674      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 675      (defined (__ARM_ARCH_8M_BASE__   ) && (__ARM_ARCH_8M_BASE__   == 1))    )
 676   uint8_t  u8     = 0U;
 677   uint16_t u16    = 0U;
 678   uint32_t u32    = 0U;
 679
 680   /* 1. Test without interruption */
 681   u8 = __LDAB(&TC_CoreInstr_LoadStoreAcquire_byte);
 682   ASSERT_TRUE(u8 == TC_CoreInstr_LoadStoreAcquire_byte);
 683
 684   __STLB(u8+1U, &TC_CoreInstr_LoadStoreAcquire_byte);
 685   ASSERT_TRUE(TC_CoreInstr_LoadStoreAcquire_byte == u8+1U);
 686
 687   u16 = __LDAH(&TC_CoreInstr_LoadStoreAcquire_hword);
 688   ASSERT_TRUE(u16 == TC_CoreInstr_LoadStoreAcquire_hword);
 689
 690   __STLH(u16+1U, &TC_CoreInstr_LoadStoreAcquire_hword);
 691   ASSERT_TRUE(TC_CoreInstr_LoadStoreAcquire_hword == u16+1U);
 692
 693   u32 = __LDA(&TC_CoreInstr_LoadStoreAcquire_word);
 694   ASSERT_TRUE(u32 == TC_CoreInstr_LoadStoreAcquire_word);
 695
 696   __STL(u32+1U, &TC_CoreInstr_LoadStoreAcquire_word);
 697   ASSERT_TRUE(TC_CoreInstr_LoadStoreAcquire_word == u32+1U);
 698 #endif
 699 }
 700
 701 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 702 #if ((defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1)) || \
 703      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 704      (defined (__ARM_ARCH_8M_BASE__   ) && (__ARM_ARCH_8M_BASE__   == 1))    )
 705
 706 /// byte value unprivileged access
 707 static volatile uint8_t TC_CoreInstr_LoadStoreAcquireExclusive_byte = 0x47U;
 708
 709 /// halfword value unprivileged access
 710 static volatile uint16_t TC_CoreInstr_LoadStoreAcquireExclusive_hword = 0x0815U;
 711
 712 /// word value unprivileged access
 713 static volatile uint32_t TC_CoreInstr_LoadStoreAcquireExclusive_word = 0x08154711U;
 714 #endif
 715
 716
 717 /**
 718 \brief Test case: TC_CoreInstr_LoadStoreAquire
 719 \details
 720 Checks Load-Acquire and Store-Release exclusive instructions:
 721 - LDAEXB, LDAEXH, LDAEX
 722 - STLEXB, STLEXH, STLEX
 723 */
 724 void TC_CoreInstr_LoadStoreAcquireExclusive (void) {
 725 #if ((defined (__ARM_ARCH_8_1M_MAIN__ ) && (__ARM_ARCH_8_1M_MAIN__ == 1)) || \
 726      (defined (__ARM_ARCH_8M_MAIN__   ) && (__ARM_ARCH_8M_MAIN__   == 1)) || \
 727      (defined (__ARM_ARCH_8M_BASE__   ) && (__ARM_ARCH_8M_BASE__   == 1))    )
 728   uint8_t  u8     = 0U;
 729   uint16_t u16    = 0U;
 730   uint32_t u32    = 0U;
 731   uint32_t result = 0U;
 732
 733   /* 1. Test without interruption */
 734   u8 = __LDAEXB(&TC_CoreInstr_LoadStoreAcquireExclusive_byte);
 735   ASSERT_TRUE(u8 == TC_CoreInstr_LoadStoreAcquireExclusive_byte);
 736
 737   result = __STLEXB(u8+1U, &TC_CoreInstr_LoadStoreAcquireExclusive_byte);
 738   ASSERT_TRUE(result == 0U);
 739   ASSERT_TRUE(TC_CoreInstr_LoadStoreAcquireExclusive_byte == u8+1U);
 740
 741   u16 = __LDAEXH(&TC_CoreInstr_LoadStoreAcquireExclusive_hword);
 742   ASSERT_TRUE(u16 == TC_CoreInstr_LoadStoreAcquireExclusive_hword);
 743
 744   result = __STLEXH(u16+1U, &TC_CoreInstr_LoadStoreAcquireExclusive_hword);
 745   ASSERT_TRUE(result == 0U);
 746   ASSERT_TRUE(TC_CoreInstr_LoadStoreAcquireExclusive_hword == u16+1U);
 747
 748   u32 = __LDAEX(&TC_CoreInstr_LoadStoreAcquireExclusive_word);
 749   ASSERT_TRUE(u32 == TC_CoreInstr_LoadStoreAcquireExclusive_word);
 750
 751   result = __STLEX(u32+1U, &TC_CoreInstr_LoadStoreAcquireExclusive_word);
 752   ASSERT_TRUE(result == 0U);
 753   ASSERT_TRUE(TC_CoreInstr_LoadStoreAcquireExclusive_word == u32+1U);
 754 #endif
 755 }
 756
 757
 758 /**
 759 \brief Test case: TC_CoreInstr_UnalignedUint16
 760 \details
 761 Checks macro functions to access unaligned uint16_t values:
 762 - __UNALIGNED_UINT16_READ
 763 - __UNALIGNED_UINT16_WRITE
 764 */
 765 void TC_CoreInstr_UnalignedUint16(void) {
 766   uint8_t buffer[3] = { 0U, 0U, 0U };
 767   uint16_t val;
 768
 769   for(int i=0; i<2; i++) {
 770     __UNALIGNED_UINT16_WRITE(&(buffer[i]), 0x4711U);
 771     ASSERT_TRUE(buffer[i]       == 0x11U);
 772     ASSERT_TRUE(buffer[i+1]     == 0x47U);
 773     ASSERT_TRUE(buffer[(i+2)%3] == 0x00U);
 774
 775     buffer[i] = 0x12U;
 776     buffer[i+1] = 0x46U;
 777
 778     val = __UNALIGNED_UINT16_READ(&(buffer[i]));
 779     ASSERT_TRUE(val == 0x4612U);
 780
 781     buffer[i]   = 0x00U;
 782     buffer[i+1] = 0x00U;
 783   }
 784 }
 785
 786
 787 /**
 788 \brief Test case: TC_CoreInstr_UnalignedUint32
 789 \details
 790 Checks macro functions to access unaligned uint32_t values:
 791 - __UNALIGNED_UINT32_READ
 792 - __UNALIGNED_UINT32_WRITE
 793 */
 794 void TC_CoreInstr_UnalignedUint32(void) {
 795   uint8_t buffer[7] = { 0U, 0U, 0U, 0U, 0U, 0U, 0U };
 796   uint32_t val;
 797
 798   for(int i=0; i<4; i++) {
 799     __UNALIGNED_UINT32_WRITE(&(buffer[i]), 0x08154711UL);
 800     ASSERT_TRUE(buffer[i+0]     == 0x11U);
 801     ASSERT_TRUE(buffer[i+1]     == 0x47U);
 802     ASSERT_TRUE(buffer[i+2]     == 0x15U);
 803     ASSERT_TRUE(buffer[i+3]     == 0x08U);
 804     ASSERT_TRUE(buffer[(i+4)%7] == 0x00U);
 805     ASSERT_TRUE(buffer[(i+5)%7] == 0x00U);
 806     ASSERT_TRUE(buffer[(i+6)%7] == 0x00U);
 807
 808     buffer[i+0] = 0x12U;
 809     buffer[i+1] = 0x46U;
 810     buffer[i+2] = 0x14U;
 811     buffer[i+3] = 0x09U;
 812
 813     val = __UNALIGNED_UINT32_READ(&(buffer[i]));
 814     ASSERT_TRUE(val == 0x09144612UL);
 815
 816     buffer[i+0] = 0x00U;
 817     buffer[i+1] = 0x00U;
 818     buffer[i+2] = 0x00U;
 819     buffer[i+3] = 0x00U;
 820   }
 821 }