MdePkg/Library/BaseLib/Ipf/AccessKr.s

   1 /// @file
   2 ///  IPF specific AsmReadKrX() and AsmWriteKrX functions, 'X' is from '0' to '7'
   3 ///
   4 /// Copyright (c) 2006, Intel Corporation
   5 /// All rights reserved. This program and the accompanying materials
   6 /// are licensed and made available under the terms and conditions of the BSD License
   7 /// which accompanies this distribution.  The full text of the license may be found at
   8 /// http://opensource.org/licenses/bsd-license.php
   9 ///
  10 /// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 /// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 ///
  13 /// Module Name: AccessKr.s
  14 ///
  15 ///
  16
  17 //---------------------------------------------------------------------------------
  18 //++
  19 // AsmReadKr0
  20 //
  21 // This routine is used to get KR0.
  22 //
  23 // Arguments :
  24 //
  25 // On Entry :  None.
  26 //
  27 // Return Value: The value store in KR0.
  28 //
  29 //--
  30 //----------------------------------------------------------------------------------
  31 .text
  32 .type   AsmReadKr0, @function
  33 .proc   AsmReadKr0
  34
  35 AsmReadKr0::
  36         mov             r8 = ar.k0;;
  37         br.ret.dpnt     b0;;
  38 .endp   AsmReadKr0
  39
  40 //---------------------------------------------------------------------------------
  41 //++
  42 // AsmWriteKr0
  43 //
  44 // This routine is used to Write KR0.
  45 //
  46 // Arguments :
  47 //
  48 // On Entry :  None.
  49 //
  50 // Return Value: The value written to the KR0.
  51 //
  52 //--
  53 //----------------------------------------------------------------------------------
  54
  55 .text
  56 .type   AsmWriteKr0, @function
  57 .proc   AsmWriteKr0
  58 .regstk 1, 0, 0, 0
  59
  60 AsmWriteKr0::
  61         mov             ar.k0 = in0
  62         mov             r8 = in0;;
  63         br.ret.dpnt     b0;;
  64 .endp   AsmWriteKr0
  65
  66
  67 //---------------------------------------------------------------------------------
  68 //++
  69 // AsmReadKr1
  70 //
  71 // This routine is used to get KR1.
  72 //
  73 // Arguments :
  74 //
  75 // On Entry :  None.
  76 //
  77 // Return Value: The value store in KR1.
  78 //
  79 //--
  80 //----------------------------------------------------------------------------------
  81 .text
  82 .type   AsmReadKr1, @function
  83 .proc   AsmReadKr1
  84
  85 AsmReadKr1::
  86         mov             r8 = ar.k1;;
  87         br.ret.dpnt     b0;;
  88 .endp   AsmReadKr1
  89
  90 //---------------------------------------------------------------------------------
  91 //++
  92 // AsmWriteKr1
  93 //
  94 // This routine is used to Write KR1.
  95 //
  96 // Arguments :
  97 //
  98 // On Entry :  None.
  99 //
 100 // Return Value: The value written to the KR1.
 101 //
 102 //--
 103 //----------------------------------------------------------------------------------
 104 .text
 105 .type   AsmWriteKr1, @function
 106 .proc   AsmWriteKr1
 107
 108 AsmWriteKr1::
 109         mov             ar.k1 = in0
 110         mov             r8 = in0;;
 111         br.ret.dpnt     b0;;
 112 .endp   AsmWriteKr1
 113
 114
 115 //---------------------------------------------------------------------------------
 116 //++
 117 // AsmReadKr2
 118 //
 119 // This routine is used to get KR2.
 120 //
 121 // Arguments :
 122 //
 123 // On Entry :  None.
 124 //
 125 // Return Value: The value store in KR2.
 126 //
 127 //--
 128 //----------------------------------------------------------------------------------
 129 .text
 130 .type   AsmReadKr2, @function
 131 .proc   AsmReadKr2
 132
 133 AsmReadKr2::
 134         mov             r8 = ar.k2;;
 135         br.ret.dpnt     b0;;
 136 .endp   AsmReadKr2
 137
 138 //---------------------------------------------------------------------------------
 139 //++
 140 // AsmWriteKr2
 141 //
 142 // This routine is used to Write KR2.
 143 //
 144 // Arguments :
 145 //
 146 // On Entry :  None.
 147 //
 148 // Return Value: The value written to the KR2.
 149 //
 150 //--
 151 //----------------------------------------------------------------------------------
 152 .text
 153 .type   AsmWriteKr2, @function
 154 .proc   AsmWriteKr2
 155
 156 AsmWriteKr2::
 157         mov             ar.k2 = in0
 158         mov             r8 = in0;;
 159         br.ret.dpnt     b0;;
 160 .endp   AsmWriteKr2
 161
 162
 163 //---------------------------------------------------------------------------------
 164 //++
 165 // AsmReadKr3
 166 //
 167 // This routine is used to get KR3.
 168 //
 169 // Arguments :
 170 //
 171 // On Entry :  None.
 172 //
 173 // Return Value: The value store in KR3.
 174 //
 175 //--
 176 //----------------------------------------------------------------------------------
 177 .text
 178 .type   AsmReadKr3, @function
 179 .proc   AsmReadKr3
 180
 181 AsmReadKr3::
 182         mov             r8 = ar.k3;;
 183         br.ret.dpnt     b0;;
 184 .endp   AsmReadKr3
 185
 186 //---------------------------------------------------------------------------------
 187 //++
 188 // AsmWriteKr3
 189 //
 190 // This routine is used to Write KR3.
 191 //
 192 // Arguments :
 193 //
 194 // On Entry :  None.
 195 //
 196 // Return Value: The value written to the KR3.
 197 //
 198 //--
 199 //----------------------------------------------------------------------------------
 200 .text
 201 .type   AsmWriteKr3, @function
 202 .proc   AsmWriteKr3
 203
 204 AsmWriteKr3::
 205         mov             ar.k3 = in0
 206         mov             r8 = in0;;
 207         br.ret.dpnt     b0;;
 208 .endp   AsmWriteKr3
 209
 210
 211 //---------------------------------------------------------------------------------
 212 //++
 213 // AsmReadKr4
 214 //
 215 // This routine is used to get KR4.
 216 //
 217 // Arguments :
 218 //
 219 // On Entry :  None.
 220 //
 221 // Return Value: The value store in KR4.
 222 //
 223 //--
 224 //----------------------------------------------------------------------------------
 225 .text
 226 .type   AsmReadKr4, @function
 227 .proc   AsmReadKr4
 228
 229 AsmReadKr4::
 230         mov             r8 = ar.k4;;
 231         br.ret.dpnt     b0;;
 232 .endp   AsmReadKr4
 233
 234 //---------------------------------------------------------------------------------
 235 //++
 236 // AsmWriteKr4
 237 //
 238 // This routine is used to Write KR4.
 239 //
 240 // Arguments :
 241 //
 242 // On Entry :  None.
 243 //
 244 // Return Value: The value written to the KR4.
 245 //
 246 //--
 247 //----------------------------------------------------------------------------------
 248 .text
 249 .type   AsmWriteKr4, @function
 250 .proc   AsmWriteKr4
 251
 252 AsmWriteKr4::
 253         mov             ar.k4 = in0
 254         mov             r8 = in0;;
 255         br.ret.dpnt     b0;;
 256 .endp   AsmWriteKr4
 257
 258
 259 //---------------------------------------------------------------------------------
 260 //++
 261 // AsmReadKr5
 262 //
 263 // This routine is used to get KR5.
 264 //
 265 // Arguments :
 266 //
 267 // On Entry :  None.
 268 //
 269 // Return Value: The value store in KR5.
 270 //
 271 //--
 272 //----------------------------------------------------------------------------------
 273 .text
 274 .type   AsmReadKr5, @function
 275 .proc   AsmReadKr5
 276
 277 AsmReadKr5::
 278         mov             r8 = ar.k5;;
 279         br.ret.dpnt     b0;;
 280 .endp   AsmReadKr5
 281
 282 //---------------------------------------------------------------------------------
 283 //++
 284 // AsmWriteKr5
 285 //
 286 // This routine is used to Write KR5.
 287 //
 288 // Arguments :
 289 //
 290 // On Entry :  None.
 291 //
 292 // Return Value: The value written to the KR5.
 293 //
 294 //--
 295 //----------------------------------------------------------------------------------
 296 .text
 297 .type   AsmWriteKr5, @function
 298 .proc   AsmWriteKr5
 299
 300 AsmWriteKr5::
 301         mov             ar.k5 = in0
 302         mov             r8 = in0;;
 303         br.ret.dpnt     b0;;
 304 .endp   AsmWriteKr5
 305
 306
 307 //---------------------------------------------------------------------------------
 308 //++
 309 // AsmReadKr6
 310 //
 311 // This routine is used to get KR6.
 312 //
 313 // Arguments :
 314 //
 315 // On Entry :  None.
 316 //
 317 // Return Value: The value store in KR6.
 318 //
 319 //--
 320 //----------------------------------------------------------------------------------
 321 .text
 322 .type   AsmReadKr6, @function
 323 .proc   AsmReadKr6
 324
 325 AsmReadKr6::
 326         mov             r8 = ar.k6;;
 327         br.ret.dpnt     b0;;
 328 .endp   AsmReadKr6
 329
 330 //---------------------------------------------------------------------------------
 331 //++
 332 // AsmWriteKr6
 333 //
 334 // This routine is used to write KR6.
 335 //
 336 // Arguments :
 337 //
 338 // On Entry :  None.
 339 //
 340 // Return Value: The value written to the KR6.
 341 //
 342 //--
 343 //----------------------------------------------------------------------------------
 344 .text
 345 .type   AsmWriteKr6, @function
 346 .proc   AsmWriteKr6
 347
 348 AsmWriteKr6::
 349         mov             ar.k6 = in0
 350         mov             r8 = in0;;
 351         br.ret.dpnt     b0;;
 352 .endp   AsmWriteKr6
 353
 354
 355 //---------------------------------------------------------------------------------
 356 //++
 357 // AsmReadKr7
 358 //
 359 // This routine is used to get KR7.
 360 //
 361 // Arguments :
 362 //
 363 // On Entry :  None.
 364 //
 365 // Return Value: The value store in KR7.
 366 //
 367 //--
 368 //----------------------------------------------------------------------------------
 369 .text
 370 .type   AsmReadKr7, @function
 371 .proc   AsmReadKr7
 372
 373 AsmReadKr7::
 374         mov             r8 = ar.k7;;
 375         br.ret.dpnt     b0;;
 376 .endp   AsmReadKr7
 377
 378 //---------------------------------------------------------------------------------
 379 //++
 380 // AsmWriteKr7
 381 //
 382 // This routine is used to write KR7.
 383 //
 384 // Arguments :
 385 //
 386 // On Entry :  None.
 387 //
 388 // Return Value: The value written to the KR7.
 389 //
 390 //--
 391 //----------------------------------------------------------------------------------
 392 .text
 393 .type   AsmWriteKr7, @function
 394 .proc   AsmWriteKr7
 395
 396 AsmWriteKr7::
 397         mov             ar.k7 = in0
 398         mov             r8 = in0;;
 399         br.ret.dpnt     b0;;
 400 .endp   AsmWriteKr7