git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/RISC-V-Qemu-sifive_e-Eclipse-GCC/full_demo/RegTest.S

   1 /*\r
   2  * FreeRTOS Kernel V10.2.1\r
   3  * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   6  * this software and associated documentation files (the "Software"), to deal in\r
   7  * the Software without restriction, including without limitation the rights to\r
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
   9  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  10  * subject to the following conditions:\r
  11  *\r
  12  * The above copyright notice and this permission notice shall be included in all\r
  13  * copies or substantial portions of the Software.\r
  14  *\r
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  21  *\r
  22  * http://www.FreeRTOS.org\r
  23  * http://aws.amazon.com/freertos\r
  24  *\r
  25  * 1 tab == 4 spaces!\r
  26  */\r
  27 \r
  28         .extern ulRegTest1LoopCounter\r
  29         .extern ulRegTest2LoopCounter\r
  30 \r
  31         .global vRegTest1Implementation\r
  32         .global vRegTest2Implementation\r
  33 \r
  34 /*-----------------------------------------------------------*/\r
  35 \r
  36 /*\r
  37  * The register check tasks are described in the comments at the top of\r
  38  * main_full.c.\r
  39  */\r
  40 \r
  41 .align( 4 )\r
  42 vRegTest1Implementation:\r
  43 \r
  44         /* Fill the core registers with known values. */\r
  45         li x5, 0x5\r
  46         li x6, 0x6\r
  47         li x7, 0x7\r
  48         li x8, 0x8\r
  49         li x9, 0x9\r
  50         li x10, 0xa\r
  51         li x11, 0xb\r
  52         li x12, 0xc\r
  53         li x13, 0xd\r
  54         li x14, 0xe\r
  55         li x15, 0xf\r
  56         li x16, 0x10\r
  57         li x17, 0x11\r
  58         li x18, 0x12\r
  59         li x19, 0x13\r
  60         li x20, 0x14\r
  61         li x21, 0x15\r
  62         li x22, 0x16\r
  63         li x23, 0x17\r
  64         li x24, 0x18\r
  65         li x25, 0x19\r
  66         li x26, 0x1a\r
  67         li x27, 0x1b\r
  68         li x28, 0x1c\r
  69         li x29, 0x1d\r
  70         li x30, 0x1e\r
  71 \r
  72 reg1_loop:\r
  73 \r
  74         /* Check each register still contains the expected known value.\r
  75         vRegTest1Implementation uses x31 as the temporary, vRegTest2Implementation\r
  76         uses x5 as the temporary. */\r
  77         li x31, 0x5\r
  78         bne x31, x5, reg1_error_loop\r
  79         li x31, 0x6\r
  80         bne x31, x6, reg1_error_loop\r
  81         li x31, 0x7\r
  82         bne x31, x7, reg1_error_loop\r
  83         li x31, 0x8\r
  84         bne x31, x8, reg1_error_loop\r
  85         li x31, 0x9\r
  86         bne x31, x9, reg1_error_loop\r
  87         li x31, 0xa\r
  88         bne x31, x10, reg1_error_loop\r
  89         li x31, 0xb\r
  90         bne x31, x11, reg1_error_loop\r
  91         li x31, 0xc\r
  92         bne x31, x12, reg1_error_loop\r
  93         li x31, 0xd\r
  94         bne x31, x13, reg1_error_loop\r
  95         li x31, 0xe\r
  96         bne x31, x14, reg1_error_loop\r
  97         li x31, 0xf\r
  98         bne x31, x15, reg1_error_loop\r
  99         li x31, 0x10\r
 100         bne x31, x16, reg1_error_loop\r
 101         li x31, 0x11\r
 102         bne x31, x17, reg1_error_loop\r
 103         li x31, 0x12\r
 104         bne x31, x18, reg1_error_loop\r
 105         li x31, 0x13\r
 106         bne x31, x19, reg1_error_loop\r
 107         li x31, 0x14\r
 108         bne x31, x20, reg1_error_loop\r
 109         li x31, 0x15\r
 110         bne x31, x21, reg1_error_loop\r
 111         li x31, 0x16\r
 112         bne x31, x22, reg1_error_loop\r
 113         li x31, 0x17\r
 114         bne x31, x23, reg1_error_loop\r
 115         li x31, 0x18\r
 116         bne x31, x24, reg1_error_loop\r
 117         li x31, 0x19\r
 118         bne x31, x25, reg1_error_loop\r
 119         li x31, 0x1a\r
 120         bne x31, x26, reg1_error_loop\r
 121         li x31, 0x1b\r
 122         bne x31, x27, reg1_error_loop\r
 123         li x31, 0x1c\r
 124         bne x31, x28, reg1_error_loop\r
 125         li x31, 0x1d\r
 126         bne x31, x29, reg1_error_loop\r
 127         li x31, 0x1e\r
 128         bne x31, x30, reg1_error_loop\r
 129 \r
 130         /* Everything passed, increment the loop counter. */\r
 131         lw x31, ulRegTest1LoopCounterConst\r
 132         lw x30, 0(x31)\r
 133         addi x30, x30, 1\r
 134         sw x30, 0(x31)\r
 135 \r
 136         /* Restore clobbered register reading for next loop. */\r
 137         li x30, 0x1e\r
 138 \r
 139         /* Yield to increase code coverage. */\r
 140         ecall\r
 141 \r
 142         /* Start again. */\r
 143         jal reg1_loop\r
 144 \r
 145 reg1_error_loop:\r
 146         /* Jump here if a register contains an uxpected value.  This stops the loop\r
 147         counter being incremented so the check task knows an error was found. */\r
 148         jal reg1_error_loop\r
 149 \r
 150 .align( 4 )\r
 151 ulRegTest1LoopCounterConst: .word ulRegTest1LoopCounter\r
 152 \r
 153 /*-----------------------------------------------------------*/\r
 154 \r
 155 .align( 4 )\r
 156 vRegTest2Implementation:\r
 157 \r
 158         /* Fill the core registers with known values. */\r
 159         li x6, 0x61\r
 160         li x7, 0x71\r
 161         li x8, 0x81\r
 162         li x9, 0x91\r
 163         li x10, 0xa1\r
 164         li x11, 0xb1\r
 165         li x12, 0xc1\r
 166         li x13, 0xd1\r
 167         li x14, 0xe1\r
 168         li x15, 0xf1\r
 169         li x16, 0x20\r
 170         li x17, 0x21\r
 171         li x18, 0x22\r
 172         li x19, 0x23\r
 173         li x20, 0x24\r
 174         li x21, 0x25\r
 175         li x22, 0x26\r
 176         li x23, 0x27\r
 177         li x24, 0x28\r
 178         li x25, 0x29\r
 179         li x26, 0x2a\r
 180         li x27, 0x2b\r
 181         li x28, 0x2c\r
 182         li x29, 0x2d\r
 183         li x30, 0x2e\r
 184         li x31, 0x2f\r
 185 \r
 186 Reg2_loop:\r
 187 \r
 188         /* Check each register still contains the expected known value.\r
 189         vRegTest2Implementation uses x5 as the temporary, vRegTest1Implementation\r
 190         uses x31 as the temporary. */\r
 191         li x5, 0x61\r
 192         bne x5, x6, reg2_error_loop\r
 193         li x5, 0x71\r
 194         bne x5, x7, reg2_error_loop\r
 195         li x5, 0x81\r
 196         bne x5, x8, reg2_error_loop\r
 197         li x5, 0x91\r
 198         bne x5, x9, reg2_error_loop\r
 199         li x5, 0xa1\r
 200         bne x5, x10, reg2_error_loop\r
 201         li x5, 0xb1\r
 202         bne x5, x11, reg2_error_loop\r
 203         li x5, 0xc1\r
 204         bne x5, x12, reg2_error_loop\r
 205         li x5, 0xd1\r
 206         bne x5, x13, reg2_error_loop\r
 207         li x5, 0xe1\r
 208         bne x5, x14, reg2_error_loop\r
 209         li x5, 0xf1\r
 210         bne x5, x15, reg2_error_loop\r
 211         li x5, 0x20\r
 212         bne x5, x16, reg2_error_loop\r
 213         li x5, 0x21\r
 214         bne x5, x17, reg2_error_loop\r
 215         li x5, 0x22\r
 216         bne x5, x18, reg2_error_loop\r
 217         li x5, 0x23\r
 218         bne x5, x19, reg2_error_loop\r
 219         li x5, 0x24\r
 220         bne x5, x20, reg2_error_loop\r
 221         li x5, 0x25\r
 222         bne x5, x21, reg2_error_loop\r
 223         li x5, 0x26\r
 224         bne x5, x22, reg2_error_loop\r
 225         li x5, 0x27\r
 226         bne x5, x23, reg2_error_loop\r
 227         li x5, 0x28\r
 228         bne x5, x24, reg2_error_loop\r
 229         li x5, 0x29\r
 230         bne x5, x25, reg2_error_loop\r
 231         li x5, 0x2a\r
 232         bne x5, x26, reg2_error_loop\r
 233         li x5, 0x2b\r
 234         bne x5, x27, reg2_error_loop\r
 235         li x5, 0x2c\r
 236         bne x5, x28, reg2_error_loop\r
 237         li x5, 0x2d\r
 238         bne x5, x29, reg2_error_loop\r
 239         li x5, 0x2e\r
 240         bne x5, x30, reg2_error_loop\r
 241         li x5, 0x2f\r
 242         bne x5, x31, reg2_error_loop\r
 243 \r
 244         /* Everything passed, increment the loop counter. */\r
 245         lw x5, ulRegTest2LoopCounterConst\r
 246         lw x6, 0(x5)\r
 247         addi x6, x6, 1\r
 248         sw x6, 0(x5)\r
 249 \r
 250         /* Restore clobbered register reading for next loop. */\r
 251         li x6, 0x61\r
 252 \r
 253         /* Start again. */\r
 254         jal Reg2_loop\r
 255 \r
 256 reg2_error_loop:\r
 257         /* Jump here if a register contains an uxpected value.  This stops the loop\r
 258         counter being incremented so the check task knows an error was found. */\r
 259         jal reg2_error_loop\r
 260 \r
 261 .align( 4 )\r
 262 ulRegTest2LoopCounterConst: .word ulRegTest2LoopCounter\r
 263 \r
 264 \r