git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_R4F_RZ_T_GCC_IAR/src/Full_Demo/reg_test_IAR.asm

   1 /*\r
   2     FreeRTOS V8.2.2 - Copyright (C) 2014 Real Time Engineers Ltd.\r
   3 \r
   4     FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME.  PLEASE VISIT\r
   5     http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
   6 \r
   7     ***************************************************************************\r
   8      *                                                                       *\r
   9      *    FreeRTOS tutorial books are available in pdf and paperback.        *\r
  10      *    Complete, revised, and edited pdf reference manuals are also       *\r
  11      *    available.                                                         *\r
  12      *                                                                       *\r
  13      *    Purchasing FreeRTOS documentation will not only help you, by       *\r
  14      *    ensuring you get running as quickly as possible and with an        *\r
  15      *    in-depth knowledge of how to use FreeRTOS, it will also help       *\r
  16      *    the FreeRTOS project to continue with its mission of providing     *\r
  17      *    professional grade, cross platform, de facto standard solutions    *\r
  18      *    for microcontrollers - completely free of charge!                  *\r
  19      *                                                                       *\r
  20      *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *\r
  21      *                                                                       *\r
  22      *    Thank you for using FreeRTOS, and thank you for your support!      *\r
  23      *                                                                       *\r
  24     ***************************************************************************\r
  25 \r
  26 \r
  27     This file is part of the FreeRTOS distribution.\r
  28 \r
  29     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  30     the terms of the GNU General Public License (version 2) as published by the\r
  31     Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
  32 \r
  33     >>>>>>NOTE<<<<<< The modification to the GPL is included to allow you to\r
  34     distribute a combined work that includes FreeRTOS without being obliged to\r
  35     provide the source code for proprietary components outside of the FreeRTOS\r
  36     kernel.\r
  37 \r
  38     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  39     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  40     FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more\r
  41     details. You should have received a copy of the GNU General Public License\r
  42     and the FreeRTOS license exception along with FreeRTOS; if not itcan be\r
  43     viewed here: http://www.freertos.org/a00114.html and also obtained by\r
  44     writing to Real Time Engineers Ltd., contact details for whom are available\r
  45     on the FreeRTOS WEB site.\r
  46 \r
  47     1 tab == 4 spaces!\r
  48 \r
  49     ***************************************************************************\r
  50      *                                                                       *\r
  51      *    Having a problem?  Start by reading the FAQ "My application does   *\r
  52      *    not run, what could be wrong?"                                     *\r
  53      *                                                                       *\r
  54      *    http://www.FreeRTOS.org/FAQHelp.html                               *\r
  55      *                                                                       *\r
  56     ***************************************************************************\r
  57 \r
  58 \r
  59     http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
  60     license and Real Time Engineers Ltd. contact details.\r
  61 \r
  62     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  63     including FreeRTOS+Trace - an indispensable productivity tool, and our new\r
  64     fully thread aware and reentrant UDP/IP stack.\r
  65 \r
  66     http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
  67     Integrity Systems, who sell the code with commercial support,\r
  68     indemnification and middleware, under the OpenRTOS brand.\r
  69 \r
  70     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  71     engineered and independently SIL3 certified version for use in safety and\r
  72     mission critical applications that require provable dependability.\r
  73 */\r
  74 \r
  75         PUBLIC vRegTest1Implementation\r
  76         PUBLIC vRegTest2Implementation\r
  77         EXTERN ulRegTest1LoopCounter\r
  78         EXTERN ulRegTest2LoopCounter\r
  79 \r
  80         SECTION intvec:CODE:ROOT(2)\r
  81     ARM\r
  82 \r
  83         /* This function is explained in the comments at the top of main-full.c. */\r
  84 vRegTest1Implementation:\r
  85 \r
  86         /* Fill each general purpose register with a known value. */\r
  87         mov             r0,  #0xFF\r
  88         mov             r1,  #0x11\r
  89         mov             r2,  #0x22\r
  90         mov             r3,  #0x33\r
  91         mov     r4,  #0x44\r
  92         mov     r5,  #0x55\r
  93         mov     r6,  #0x66\r
  94         mov     r7,  #0x77\r
  95         mov     r8,  #0x88\r
  96         mov     r9,  #0x99\r
  97         mov     r10, #0xAA\r
  98         mov     r11, #0xBB\r
  99         mov     r12, #0xCC\r
 100         mov             r14, #0xEE\r
 101 \r
 102 \r
 103         /* Fill each FPU register with a known value. */\r
 104         vmov    d0, r0, r1\r
 105         vmov    d1, r2, r3\r
 106         vmov    d2, r4, r5\r
 107         vmov    d3, r6, r7\r
 108         vmov    d4, r8, r9\r
 109         vmov    d5, r10, r11\r
 110         vmov    d6, r0, r1\r
 111         vmov    d7, r2, r3\r
 112         vmov    d8, r4, r5\r
 113         vmov    d9, r6, r7\r
 114         vmov    d10, r8, r9\r
 115         vmov    d11, r10, r11\r
 116         vmov    d12, r0, r1\r
 117         vmov    d13, r2, r3\r
 118         vmov    d14, r4, r5\r
 119         vmov    d15, r6, r7\r
 120 \r
 121         /* Loop, checking each iteration that each register still contains the\r
 122         expected value. */\r
 123 reg1_loop:\r
 124         /* Yield to increase test coverage */\r
 125         svc 0\r
 126 \r
 127         /* Check all the VFP registers still contain the values set above.\r
 128         First save registers that are clobbered by the test. */\r
 129         push { r0-r1 }\r
 130 \r
 131         vmov    r0, r1, d0\r
 132         cmp     r0, #0xFF\r
 133         bne     reg1_error_loopf\r
 134         cmp     r1, #0x11\r
 135         bne     reg1_error_loopf\r
 136         vmov    r0, r1, d1\r
 137         cmp     r0, #0x22\r
 138         bne     reg1_error_loopf\r
 139         cmp     r1, #0x33\r
 140         bne     reg1_error_loopf\r
 141         vmov    r0, r1, d2\r
 142         cmp     r0, #0x44\r
 143         bne     reg1_error_loopf\r
 144         cmp     r1, #0x55\r
 145         bne     reg1_error_loopf\r
 146         vmov    r0, r1, d3\r
 147         cmp     r0, #0x66\r
 148         bne     reg1_error_loopf\r
 149         cmp     r1, #0x77\r
 150         bne     reg1_error_loopf\r
 151         vmov    r0, r1, d4\r
 152         cmp     r0, #0x88\r
 153         bne     reg1_error_loopf\r
 154         cmp     r1, #0x99\r
 155         bne     reg1_error_loopf\r
 156         vmov    r0, r1, d5\r
 157         cmp     r0, #0xAA\r
 158         bne     reg1_error_loopf\r
 159         cmp     r1, #0xBB\r
 160         bne     reg1_error_loopf\r
 161         vmov    r0, r1, d6\r
 162         cmp     r0, #0xFF\r
 163         bne     reg1_error_loopf\r
 164         cmp     r1, #0x11\r
 165         bne     reg1_error_loopf\r
 166         vmov    r0, r1, d7\r
 167         cmp     r0, #0x22\r
 168         bne     reg1_error_loopf\r
 169         cmp     r1, #0x33\r
 170         bne     reg1_error_loopf\r
 171         vmov    r0, r1, d8\r
 172         cmp     r0, #0x44\r
 173         bne     reg1_error_loopf\r
 174         cmp     r1, #0x55\r
 175         bne     reg1_error_loopf\r
 176         vmov    r0, r1, d9\r
 177         cmp     r0, #0x66\r
 178         bne     reg1_error_loopf\r
 179         cmp     r1, #0x77\r
 180         bne     reg1_error_loopf\r
 181         vmov    r0, r1, d10\r
 182         cmp     r0, #0x88\r
 183         bne     reg1_error_loopf\r
 184         cmp     r1, #0x99\r
 185         bne     reg1_error_loopf\r
 186         vmov    r0, r1, d11\r
 187         cmp     r0, #0xAA\r
 188         bne     reg1_error_loopf\r
 189         cmp     r1, #0xBB\r
 190         bne     reg1_error_loopf\r
 191         vmov    r0, r1, d12\r
 192         cmp     r0, #0xFF\r
 193         bne     reg1_error_loopf\r
 194         cmp     r1, #0x11\r
 195         bne     reg1_error_loopf\r
 196         vmov    r0, r1, d13\r
 197         cmp     r0, #0x22\r
 198         bne     reg1_error_loopf\r
 199         cmp     r1, #0x33\r
 200         bne     reg1_error_loopf\r
 201         vmov    r0, r1, d14\r
 202         cmp     r0, #0x44\r
 203         bne     reg1_error_loopf\r
 204         cmp     r1, #0x55\r
 205         bne     reg1_error_loopf\r
 206         vmov    r0, r1, d15\r
 207         cmp     r0, #0x66\r
 208         bne     reg1_error_loopf\r
 209         cmp     r1, #0x77\r
 210         bne     reg1_error_loopf\r
 211 \r
 212 \r
 213         /* Restore the registers that were clobbered by the test. */\r
 214         pop     {r0-r1}\r
 215 \r
 216         /* VFP register test passed.  Jump to the core register test. */\r
 217         b               reg1_loopf_pass\r
 218 \r
 219 reg1_error_loopf:\r
 220         /* If this line is hit then a VFP register value was found to be\r
 221         incorrect. */\r
 222         b reg1_error_loopf\r
 223 \r
 224 reg1_loopf_pass:\r
 225 \r
 226         /* Test each general purpose register to check that it still contains the\r
 227         expected known value, jumping to reg1_error_loop if any register contains\r
 228         an unexpected value. */\r
 229         cmp             r0, #0xFF\r
 230         bne             reg1_error_loop\r
 231         cmp             r1, #0x11\r
 232         bne             reg1_error_loop\r
 233         cmp             r2, #0x22\r
 234         bne             reg1_error_loop\r
 235         cmp             r3, #0x33\r
 236         bne             reg1_error_loop\r
 237         cmp             r4, #0x44\r
 238         bne             reg1_error_loop\r
 239         cmp             r5, #0x55\r
 240         bne             reg1_error_loop\r
 241         cmp             r6, #0x66\r
 242         bne             reg1_error_loop\r
 243         cmp             r7, #0x77\r
 244         bne             reg1_error_loop\r
 245         cmp             r8, #0x88\r
 246         bne             reg1_error_loop\r
 247         cmp             r9, #0x99\r
 248         bne             reg1_error_loop\r
 249         cmp             r10, #0xAA\r
 250         bne             reg1_error_loop\r
 251         cmp             r11, #0xBB\r
 252         bne             reg1_error_loop\r
 253         cmp             r12, #0xCC\r
 254         bne             reg1_error_loop\r
 255         cmp             r14, #0xEE\r
 256         bne             reg1_error_loop\r
 257 \r
 258         /* Everything passed, increment the loop counter. */\r
 259         push { r0-r1 }\r
 260         ldr     r0, =ulRegTest1LoopCounter\r
 261         ldr r1, [r0]\r
 262         adds r1, r1, #1\r
 263         str r1, [r0]\r
 264         pop { r0-r1 }\r
 265 \r
 266         /* Start again. */\r
 267         b reg1_loop\r
 268 \r
 269 reg1_error_loop:\r
 270         /* If this line is hit then there was an error in a core register value.\r
 271         The loop ensures the loop counter stops incrementing. */\r
 272         b reg1_error_loop\r
 273         nop\r
 274 \r
 275 /*-----------------------------------------------------------*/\r
 276 \r
 277 vRegTest2Implementation:\r
 278 \r
 279         /* Put a known value in each register. */\r
 280         mov             r0,  #0xFF000000\r
 281         mov             r1,  #0x11000000\r
 282         mov             r2,  #0x22000000\r
 283         mov             r3,  #0x33000000\r
 284         mov     r4,  #0x44000000\r
 285         mov     r5,  #0x55000000\r
 286         mov     r6,  #0x66000000\r
 287         mov     r7,  #0x77000000\r
 288         mov     r8,  #0x88000000\r
 289         mov     r9,  #0x99000000\r
 290         mov     r10, #0xAA000000\r
 291         mov     r11, #0xBB000000\r
 292         mov     r12, #0xCC000000\r
 293         mov     r14, #0xEE000000\r
 294 \r
 295         /* Likewise the floating point registers */\r
 296         vmov    d0, r0, r1\r
 297         vmov    d1, r2, r3\r
 298         vmov    d2, r4, r5\r
 299         vmov    d3, r6, r7\r
 300         vmov    d4, r8, r9\r
 301         vmov    d5, r10, r11\r
 302         vmov    d6, r0, r1\r
 303         vmov    d7, r2, r3\r
 304         vmov    d8, r4, r5\r
 305         vmov    d9, r6, r7\r
 306         vmov    d10, r8, r9\r
 307         vmov    d11, r10, r11\r
 308         vmov    d12, r0, r1\r
 309         vmov    d13, r2, r3\r
 310         vmov    d14, r4, r5\r
 311         vmov    d15, r6, r7\r
 312 \r
 313         /* Loop, checking each iteration that each register still contains the\r
 314         expected value. */\r
 315 reg2_loop:\r
 316         /* Check all the VFP registers still contain the values set above.\r
 317         First save registers that are clobbered by the test. */\r
 318         push    { r0-r1 }\r
 319 \r
 320         vmov    r0, r1, d0\r
 321         cmp     r0, #0xFF000000\r
 322         bne     reg2_error_loopf\r
 323         cmp     r1, #0x11000000\r
 324         bne     reg2_error_loopf\r
 325         vmov    r0, r1, d1\r
 326         cmp     r0, #0x22000000\r
 327         bne     reg2_error_loopf\r
 328         cmp     r1, #0x33000000\r
 329         bne     reg2_error_loopf\r
 330         vmov    r0, r1, d2\r
 331         cmp     r0, #0x44000000\r
 332         bne     reg2_error_loopf\r
 333         cmp     r1, #0x55000000\r
 334         bne     reg2_error_loopf\r
 335         vmov    r0, r1, d3\r
 336         cmp     r0, #0x66000000\r
 337         bne     reg2_error_loopf\r
 338         cmp     r1, #0x77000000\r
 339         bne     reg2_error_loopf\r
 340         vmov    r0, r1, d4\r
 341         cmp     r0, #0x88000000\r
 342         bne     reg2_error_loopf\r
 343         cmp     r1, #0x99000000\r
 344         bne     reg2_error_loopf\r
 345         vmov    r0, r1, d5\r
 346         cmp     r0, #0xAA000000\r
 347         bne     reg2_error_loopf\r
 348         cmp     r1, #0xBB000000\r
 349         bne     reg2_error_loopf\r
 350         vmov    r0, r1, d6\r
 351         cmp     r0, #0xFF000000\r
 352         bne     reg2_error_loopf\r
 353         cmp     r1, #0x11000000\r
 354         bne     reg2_error_loopf\r
 355         vmov    r0, r1, d7\r
 356         cmp     r0, #0x22000000\r
 357         bne     reg2_error_loopf\r
 358         cmp     r1, #0x33000000\r
 359         bne     reg2_error_loopf\r
 360         vmov    r0, r1, d8\r
 361         cmp     r0, #0x44000000\r
 362         bne     reg2_error_loopf\r
 363         cmp     r1, #0x55000000\r
 364         bne     reg2_error_loopf\r
 365         vmov    r0, r1, d9\r
 366         cmp     r0, #0x66000000\r
 367         bne     reg2_error_loopf\r
 368         cmp     r1, #0x77000000\r
 369         bne     reg2_error_loopf\r
 370         vmov    r0, r1, d10\r
 371         cmp     r0, #0x88000000\r
 372         bne     reg2_error_loopf\r
 373         cmp     r1, #0x99000000\r
 374         bne     reg2_error_loopf\r
 375         vmov    r0, r1, d11\r
 376         cmp     r0, #0xAA000000\r
 377         bne     reg2_error_loopf\r
 378         cmp     r1, #0xBB000000\r
 379         bne     reg2_error_loopf\r
 380         vmov    r0, r1, d12\r
 381         cmp     r0, #0xFF000000\r
 382         bne     reg2_error_loopf\r
 383         cmp     r1, #0x11000000\r
 384         bne     reg2_error_loopf\r
 385         vmov    r0, r1, d13\r
 386         cmp     r0, #0x22000000\r
 387         bne     reg2_error_loopf\r
 388         cmp     r1, #0x33000000\r
 389         bne     reg2_error_loopf\r
 390         vmov    r0, r1, d14\r
 391         cmp     r0, #0x44000000\r
 392         bne     reg2_error_loopf\r
 393         cmp     r1, #0x55000000\r
 394         bne     reg2_error_loopf\r
 395         vmov    r0, r1, d15\r
 396         cmp     r0, #0x66000000\r
 397         bne     reg2_error_loopf\r
 398         cmp     r1, #0x77000000\r
 399         bne     reg2_error_loopf\r
 400 \r
 401         /* Restore the registers that were clobbered by the test. */\r
 402         pop     {r0-r1}\r
 403 \r
 404         /* VFP register test passed.  Jump to the core register test. */\r
 405         b               reg2_loopf_pass\r
 406 \r
 407 reg2_error_loopf:\r
 408         /* If this line is hit then a VFP register value was found to be\r
 409         incorrect. */\r
 410         b               reg2_error_loopf\r
 411 \r
 412 reg2_loopf_pass:\r
 413 \r
 414         cmp             r0, #0xFF000000\r
 415         bne             reg2_error_loop\r
 416         cmp             r1, #0x11000000\r
 417         bne             reg2_error_loop\r
 418         cmp             r2, #0x22000000\r
 419         bne             reg2_error_loop\r
 420         cmp             r3, #0x33000000\r
 421         bne             reg2_error_loop\r
 422         cmp             r4, #0x44000000\r
 423         bne             reg2_error_loop\r
 424         cmp             r5, #0x55000000\r
 425         bne             reg2_error_loop\r
 426         cmp             r6, #0x66000000\r
 427         bne             reg2_error_loop\r
 428         cmp             r7, #0x77000000\r
 429         bne             reg2_error_loop\r
 430         cmp             r8, #0x88000000\r
 431         bne             reg2_error_loop\r
 432         cmp             r9, #0x99000000\r
 433         bne             reg2_error_loop\r
 434         cmp             r10, #0xAA000000\r
 435         bne             reg2_error_loop\r
 436         cmp             r11, #0xBB000000\r
 437         bne             reg2_error_loop\r
 438         cmp             r12, #0xCC000000\r
 439         bne             reg2_error_loop\r
 440         cmp     r14, #0xEE000000\r
 441         bne             reg2_error_loop\r
 442 \r
 443         /* Everything passed, increment the loop counter. */\r
 444         push    { r0-r1 }\r
 445         ldr             r0, =ulRegTest2LoopCounter\r
 446         ldr     r1, [r0]\r
 447         adds    r1, r1, #1\r
 448         str     r1, [r0]\r
 449         pop     { r0-r1 }\r
 450 \r
 451         /* Start again. */\r
 452         b               reg2_loop\r
 453 \r
 454 reg2_error_loop:\r
 455         /* If this line is hit then there was an error in a core register value.\r
 456         The loop ensures the loop counter stops incrementing. */\r
 457         b               reg2_error_loop\r
 458         nop\r
 459 \r
 460 \r
 461         END\r
 462 \r