EdkCompatibilityPkg/Foundation/Library/EdkIIGlueLib/Library/BaseLib/Ipf/AccessKr.s

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