arch/ia64/kvm/vmm_ivt.S

   1 /*
   2  * arch/ia64/kvm/vmm_ivt.S
   3  *
   4  * Copyright (C) 1998-2001, 2003 Hewlett-Packard Co
   5  *      Stephane Eranian <eranian@hpl.hp.com>
   6  *      David Mosberger <davidm@hpl.hp.com>
   7  * Copyright (C) 2000, 2002-2003 Intel Co
   8  *      Asit Mallick <asit.k.mallick@intel.com>
   9  *      Suresh Siddha <suresh.b.siddha@intel.com>
  10  *      Kenneth Chen <kenneth.w.chen@intel.com>
  11  *      Fenghua Yu <fenghua.yu@intel.com>
  12  *
  13  *
  14  * 00/08/23 Asit Mallick <asit.k.mallick@intel.com> TLB handling
  15  * for SMP
  16  * 00/12/20 David Mosberger-Tang <davidm@hpl.hp.com> DTLB/ITLB
  17  * handler now uses virtual PT.
  18  *
  19  * 07/6/20 Xuefei Xu  (Anthony Xu) (anthony.xu@intel.com)
  20  *              Supporting Intel virtualization architecture
  21  *
  22  */
  23
  24 /*
  25  * This file defines the interruption vector table used by the CPU.
  26  * It does not include one entry per possible cause of interruption.
  27  *
  28  * The first 20 entries of the table contain 64 bundles each while the
  29  * remaining 48 entries contain only 16 bundles each.
  30  *
  31  * The 64 bundles are used to allow inlining the whole handler for
  32  * critical
  33  * interruptions like TLB misses.
  34  *
  35  *  For each entry, the comment is as follows:
  36  *
  37  *              // 0x1c00 Entry 7 (size 64 bundles) Data Key Miss
  38  *              (12,51)
  39  *  entry offset ----/     /         /                  /
  40  *  /
  41  *  entry number ---------/         /                  /
  42  *  /
  43  *  size of the entry -------------/                  /
  44  *  /
  45  *  vector name -------------------------------------/
  46  *  /
  47  *  interruptions triggering this vector
  48  *  ----------------------/
  49  *
  50  * The table is 32KB in size and must be aligned on 32KB
  51  * boundary.
  52  * (The CPU ignores the 15 lower bits of the address)
  53  *
  54  * Table is based upon EAS2.6 (Oct 1999)
  55  */
  56
  57
  58 #include <asm/asmmacro.h>
  59 #include <asm/cache.h>
  60 #include <asm/pgtable.h>
  61
  62 #include "asm-offsets.h"
  63 #include "vcpu.h"
  64 #include "kvm_minstate.h"
  65 #include "vti.h"
  66
  67 #if 1
  68 # define PSR_DEFAULT_BITS   psr.ac
  69 #else
  70 # define PSR_DEFAULT_BITS   0
  71 #endif
  72
  73 #define KVM_FAULT(n)    \
  74         kvm_fault_##n:;          \
  75         mov r19=n;;          \
  76         br.sptk.many kvm_vmm_panic;         \
  77         ;;                  \
  78
  79 #define KVM_REFLECT(n)    \
  80         mov r31=pr;           \
  81         mov r19=n;       /* prepare to save predicates */ \
  82         mov r29=cr.ipsr;      \
  83         ;;      \
  84         tbit.z p6,p7=r29,IA64_PSR_VM_BIT;       \
  85 (p7)    br.sptk.many kvm_dispatch_reflection;        \
  86         br.sptk.many kvm_vmm_panic;      \
  87
  88 GLOBAL_ENTRY(kvm_vmm_panic)
  89         KVM_SAVE_MIN_WITH_COVER_R19
  90         alloc r14=ar.pfs,0,0,1,0
  91         mov out0=r15
  92         adds r3=8,r2                // set up second base pointer
  93         ;;
  94         ssm psr.ic
  95         ;;
  96         srlz.i    // guarantee that interruption collection is on
  97         ;;
  98         (p15) ssm psr.i               // restore psr.
  99         addl r14=@gprel(ia64_leave_hypervisor),gp
 100         ;;
 101         KVM_SAVE_REST
 102         mov rp=r14
 103         ;;
 104         br.call.sptk.many b6=vmm_panic_handler;
 105 END(kvm_vmm_panic)
 106
 107     .section .text.ivt,"ax"
 108
 109     .align 32768    // align on 32KB boundary
 110     .global kvm_ia64_ivt
 111 kvm_ia64_ivt:
 112 ///////////////////////////////////////////////////////////////
 113 // 0x0000 Entry 0 (size 64 bundles) VHPT Translation (8,20,47)
 114 ENTRY(kvm_vhpt_miss)
 115         KVM_FAULT(0)
 116 END(kvm_vhpt_miss)
 117
 118     .org kvm_ia64_ivt+0x400
 119 ////////////////////////////////////////////////////////////////
 120 // 0x0400 Entry 1 (size 64 bundles) ITLB (21)
 121 ENTRY(kvm_itlb_miss)
 122         mov r31 = pr
 123         mov r29=cr.ipsr;
 124         ;;
 125         tbit.z p6,p7=r29,IA64_PSR_VM_BIT;
 126 (p6)    br.sptk kvm_alt_itlb_miss
 127         mov r19 = 1
 128         br.sptk kvm_itlb_miss_dispatch
 129         KVM_FAULT(1);
 130 END(kvm_itlb_miss)
 131
 132     .org kvm_ia64_ivt+0x0800
 133 //////////////////////////////////////////////////////////////////
 134 // 0x0800 Entry 2 (size 64 bundles) DTLB (9,48)
 135 ENTRY(kvm_dtlb_miss)
 136         mov r31 = pr
 137         mov r29=cr.ipsr;
 138         ;;
 139         tbit.z p6,p7=r29,IA64_PSR_VM_BIT;
 140 (p6)    br.sptk kvm_alt_dtlb_miss
 141         br.sptk kvm_dtlb_miss_dispatch
 142 END(kvm_dtlb_miss)
 143
 144      .org kvm_ia64_ivt+0x0c00
 145 ////////////////////////////////////////////////////////////////////
 146 // 0x0c00 Entry 3 (size 64 bundles) Alt ITLB (19)
 147 ENTRY(kvm_alt_itlb_miss)
 148         mov r16=cr.ifa    // get address that caused the TLB miss
 149         ;;
 150         movl r17=PAGE_KERNEL
 151         mov r24=cr.ipsr
 152         movl r19=(((1 << IA64_MAX_PHYS_BITS) - 1) & ~0xfff)
 153         ;;
 154         and r19=r19,r16     // clear ed, reserved bits, and PTE control bits
 155         ;;
 156         or r19=r17,r19      // insert PTE control bits into r19
 157         ;;
 158         movl r20=IA64_GRANULE_SHIFT<<2
 159         ;;
 160         mov cr.itir=r20
 161         ;;
 162         itc.i r19               // insert the TLB entry
 163         mov pr=r31,-1
 164         rfi
 165 END(kvm_alt_itlb_miss)
 166
 167     .org kvm_ia64_ivt+0x1000
 168 /////////////////////////////////////////////////////////////////////
 169 // 0x1000 Entry 4 (size 64 bundles) Alt DTLB (7,46)
 170 ENTRY(kvm_alt_dtlb_miss)
 171         mov r16=cr.ifa          // get address that caused the TLB miss
 172         ;;
 173         movl r17=PAGE_KERNEL
 174         movl r19=(((1 << IA64_MAX_PHYS_BITS) - 1) & ~0xfff)
 175         mov r24=cr.ipsr
 176         ;;
 177         and r19=r19,r16     // clear ed, reserved bits, and PTE control bits
 178         ;;
 179         or r19=r19,r17  // insert PTE control bits into r19
 180         ;;
 181         movl r20=IA64_GRANULE_SHIFT<<2
 182         ;;
 183         mov cr.itir=r20
 184         ;;
 185         itc.d r19               // insert the TLB entry
 186         mov pr=r31,-1
 187         rfi
 188 END(kvm_alt_dtlb_miss)
 189
 190     .org kvm_ia64_ivt+0x1400
 191 //////////////////////////////////////////////////////////////////////
 192 // 0x1400 Entry 5 (size 64 bundles) Data nested TLB (6,45)
 193 ENTRY(kvm_nested_dtlb_miss)
 194         KVM_FAULT(5)
 195 END(kvm_nested_dtlb_miss)
 196
 197     .org kvm_ia64_ivt+0x1800
 198 /////////////////////////////////////////////////////////////////////
 199 // 0x1800 Entry 6 (size 64 bundles) Instruction Key Miss (24)
 200 ENTRY(kvm_ikey_miss)
 201         KVM_REFLECT(6)
 202 END(kvm_ikey_miss)
 203
 204     .org kvm_ia64_ivt+0x1c00
 205 /////////////////////////////////////////////////////////////////////
 206 // 0x1c00 Entry 7 (size 64 bundles) Data Key Miss (12,51)
 207 ENTRY(kvm_dkey_miss)
 208         KVM_REFLECT(7)
 209 END(kvm_dkey_miss)
 210
 211     .org kvm_ia64_ivt+0x2000
 212 ////////////////////////////////////////////////////////////////////
 213 // 0x2000 Entry 8 (size 64 bundles) Dirty-bit (54)
 214 ENTRY(kvm_dirty_bit)
 215         KVM_REFLECT(8)
 216 END(kvm_dirty_bit)
 217
 218     .org kvm_ia64_ivt+0x2400
 219 ////////////////////////////////////////////////////////////////////
 220 // 0x2400 Entry 9 (size 64 bundles) Instruction Access-bit (27)
 221 ENTRY(kvm_iaccess_bit)
 222         KVM_REFLECT(9)
 223 END(kvm_iaccess_bit)
 224
 225     .org kvm_ia64_ivt+0x2800
 226 ///////////////////////////////////////////////////////////////////
 227 // 0x2800 Entry 10 (size 64 bundles) Data Access-bit (15,55)
 228 ENTRY(kvm_daccess_bit)
 229         KVM_REFLECT(10)
 230 END(kvm_daccess_bit)
 231
 232     .org kvm_ia64_ivt+0x2c00
 233 /////////////////////////////////////////////////////////////////
 234 // 0x2c00 Entry 11 (size 64 bundles) Break instruction (33)
 235 ENTRY(kvm_break_fault)
 236         mov r31=pr
 237         mov r19=11
 238         mov r29=cr.ipsr
 239         ;;
 240         KVM_SAVE_MIN_WITH_COVER_R19
 241         ;;
 242         alloc r14=ar.pfs,0,0,4,0 //(must be first in insn group!)
 243         mov out0=cr.ifa
 244         mov out2=cr.isr     // FIXME: pity to make this slow access twice
 245         mov out3=cr.iim     // FIXME: pity to make this slow access twice
 246         adds r3=8,r2                // set up second base pointer
 247         ;;
 248         ssm psr.ic
 249         ;;
 250         srlz.i         // guarantee that interruption collection is on
 251         ;;
 252         (p15)ssm psr.i               // restore psr.i
 253         addl r14=@gprel(ia64_leave_hypervisor),gp
 254         ;;
 255         KVM_SAVE_REST
 256         mov rp=r14
 257         ;;
 258         adds out1=16,sp
 259         br.call.sptk.many b6=kvm_ia64_handle_break
 260         ;;
 261 END(kvm_break_fault)
 262
 263     .org kvm_ia64_ivt+0x3000
 264 /////////////////////////////////////////////////////////////////
 265 // 0x3000 Entry 12 (size 64 bundles) External Interrupt (4)
 266 ENTRY(kvm_interrupt)
 267         mov r31=pr              // prepare to save predicates
 268         mov r19=12
 269         mov r29=cr.ipsr
 270         ;;
 271         tbit.z p6,p7=r29,IA64_PSR_VM_BIT
 272         tbit.z p0,p15=r29,IA64_PSR_I_BIT
 273         ;;
 274 (p7)    br.sptk kvm_dispatch_interrupt
 275         ;;
 276         mov r27=ar.rsc          /* M */
 277         mov r20=r1                      /* A */
 278         mov r25=ar.unat         /* M */
 279         mov r26=ar.pfs          /* I */
 280         mov r28=cr.iip          /* M */
 281         cover                   /* B (or nothing) */
 282         ;;
 283         mov r1=sp
 284         ;;
 285         invala                  /* M */
 286         mov r30=cr.ifs
 287         ;;
 288         addl r1=-VMM_PT_REGS_SIZE,r1
 289         ;;
 290         adds r17=2*L1_CACHE_BYTES,r1    /* really: biggest cache-line size */
 291         adds r16=PT(CR_IPSR),r1
 292         ;;
 293         lfetch.fault.excl.nt1 [r17],L1_CACHE_BYTES
 294         st8 [r16]=r29                   /* save cr.ipsr */
 295         ;;
 296         lfetch.fault.excl.nt1 [r17]
 297         mov r29=b0
 298         ;;
 299         adds r16=PT(R8),r1      /* initialize first base pointer */
 300         adds r17=PT(R9),r1      /* initialize second base pointer */
 301         mov r18=r0                      /* make sure r18 isn't NaT */
 302         ;;
 303 .mem.offset 0,0; st8.spill [r16]=r8,16
 304 .mem.offset 8,0; st8.spill [r17]=r9,16
 305         ;;
 306 .mem.offset 0,0; st8.spill [r16]=r10,24
 307 .mem.offset 8,0; st8.spill [r17]=r11,24
 308         ;;
 309         st8 [r16]=r28,16                /* save cr.iip */
 310         st8 [r17]=r30,16                /* save cr.ifs */
 311         mov r8=ar.fpsr          /* M */
 312         mov r9=ar.csd
 313         mov r10=ar.ssd
 314         movl r11=FPSR_DEFAULT   /* L-unit */
 315         ;;
 316         st8 [r16]=r25,16                /* save ar.unat */
 317         st8 [r17]=r26,16                /* save ar.pfs */
 318         shl r18=r18,16          /* compute ar.rsc to be used for "loadrs" */
 319         ;;
 320         st8 [r16]=r27,16                /* save ar.rsc */
 321         adds r17=16,r17         /* skip over ar_rnat field */
 322         ;;
 323         st8 [r17]=r31,16                /* save predicates */
 324         adds r16=16,r16         /* skip over ar_bspstore field */
 325         ;;
 326         st8 [r16]=r29,16                /* save b0 */
 327         st8 [r17]=r18,16                /* save ar.rsc value for "loadrs" */
 328         ;;
 329 .mem.offset 0,0; st8.spill [r16]=r20,16    /* save original r1 */
 330 .mem.offset 8,0; st8.spill [r17]=r12,16
 331         adds r12=-16,r1
 332         /* switch to kernel memory stack (with 16 bytes of scratch) */
 333         ;;
 334 .mem.offset 0,0; st8.spill [r16]=r13,16
 335 .mem.offset 8,0; st8.spill [r17]=r8,16 /* save ar.fpsr */
 336         ;;
 337 .mem.offset 0,0; st8.spill [r16]=r15,16
 338 .mem.offset 8,0; st8.spill [r17]=r14,16
 339         dep r14=-1,r0,60,4
 340         ;;
 341 .mem.offset 0,0; st8.spill [r16]=r2,16
 342 .mem.offset 8,0; st8.spill [r17]=r3,16
 343         adds r2=VMM_PT_REGS_R16_OFFSET,r1
 344         adds r14 = VMM_VCPU_GP_OFFSET,r13
 345         ;;
 346         mov r8=ar.ccv
 347         ld8 r14 = [r14]
 348         ;;
 349         mov r1=r14       /* establish kernel global pointer */
 350         ;;                                          \
 351         bsw.1
 352         ;;
 353         alloc r14=ar.pfs,0,0,1,0        // must be first in an insn group
 354         mov out0=r13
 355         ;;
 356         ssm psr.ic
 357         ;;
 358         srlz.i
 359         ;;
 360         //(p15) ssm psr.i
 361         adds r3=8,r2            // set up second base pointer for SAVE_REST
 362         srlz.i                  // ensure everybody knows psr.ic is back on
 363         ;;
 364 .mem.offset 0,0; st8.spill [r2]=r16,16
 365 .mem.offset 8,0; st8.spill [r3]=r17,16
 366         ;;
 367 .mem.offset 0,0; st8.spill [r2]=r18,16
 368 .mem.offset 8,0; st8.spill [r3]=r19,16
 369         ;;
 370 .mem.offset 0,0; st8.spill [r2]=r20,16
 371 .mem.offset 8,0; st8.spill [r3]=r21,16
 372         mov r18=b6
 373         ;;
 374 .mem.offset 0,0; st8.spill [r2]=r22,16
 375 .mem.offset 8,0; st8.spill [r3]=r23,16
 376         mov r19=b7
 377         ;;
 378 .mem.offset 0,0; st8.spill [r2]=r24,16
 379 .mem.offset 8,0; st8.spill [r3]=r25,16
 380         ;;
 381 .mem.offset 0,0; st8.spill [r2]=r26,16
 382 .mem.offset 8,0; st8.spill [r3]=r27,16
 383         ;;
 384 .mem.offset 0,0; st8.spill [r2]=r28,16
 385 .mem.offset 8,0; st8.spill [r3]=r29,16
 386         ;;
 387 .mem.offset 0,0; st8.spill [r2]=r30,16
 388 .mem.offset 8,0; st8.spill [r3]=r31,32
 389         ;;
 390         mov ar.fpsr=r11       /* M-unit */
 391         st8 [r2]=r8,8         /* ar.ccv */
 392         adds r24=PT(B6)-PT(F7),r3
 393         ;;
 394         stf.spill [r2]=f6,32
 395         stf.spill [r3]=f7,32
 396         ;;
 397         stf.spill [r2]=f8,32
 398         stf.spill [r3]=f9,32
 399         ;;
 400         stf.spill [r2]=f10
 401         stf.spill [r3]=f11
 402         adds r25=PT(B7)-PT(F11),r3
 403         ;;
 404         st8 [r24]=r18,16       /* b6 */
 405         st8 [r25]=r19,16       /* b7 */
 406         ;;
 407         st8 [r24]=r9           /* ar.csd */
 408         st8 [r25]=r10          /* ar.ssd */
 409         ;;
 410         srlz.d          // make sure we see the effect of cr.ivr
 411         addl r14=@gprel(ia64_leave_nested),gp
 412         ;;
 413         mov rp=r14
 414         br.call.sptk.many b6=kvm_ia64_handle_irq
 415         ;;
 416 END(kvm_interrupt)
 417
 418     .global kvm_dispatch_vexirq
 419     .org kvm_ia64_ivt+0x3400
 420 //////////////////////////////////////////////////////////////////////
 421 // 0x3400 Entry 13 (size 64 bundles) Reserved
 422 ENTRY(kvm_virtual_exirq)
 423         mov r31=pr
 424         mov r19=13
 425         mov r30 =r0
 426         ;;
 427 kvm_dispatch_vexirq:
 428         cmp.eq p6,p0 = 1,r30
 429         ;;
 430 (p6)    add r29 = VMM_VCPU_SAVED_GP_OFFSET,r21
 431         ;;
 432 (p6)    ld8 r1 = [r29]
 433         ;;
 434         KVM_SAVE_MIN_WITH_COVER_R19
 435         alloc r14=ar.pfs,0,0,1,0
 436         mov out0=r13
 437
 438         ssm psr.ic
 439         ;;
 440         srlz.i // guarantee that interruption collection is on
 441         ;;
 442         (p15) ssm psr.i               // restore psr.i
 443         adds r3=8,r2                // set up second base pointer
 444         ;;
 445         KVM_SAVE_REST
 446         addl r14=@gprel(ia64_leave_hypervisor),gp
 447         ;;
 448         mov rp=r14
 449         br.call.sptk.many b6=kvm_vexirq
 450 END(kvm_virtual_exirq)
 451
 452     .org kvm_ia64_ivt+0x3800
 453 /////////////////////////////////////////////////////////////////////
 454 // 0x3800 Entry 14 (size 64 bundles) Reserved
 455         KVM_FAULT(14)
 456         // this code segment is from 2.6.16.13
 457
 458     .org kvm_ia64_ivt+0x3c00
 459 ///////////////////////////////////////////////////////////////////////
 460 // 0x3c00 Entry 15 (size 64 bundles) Reserved
 461         KVM_FAULT(15)
 462
 463     .org kvm_ia64_ivt+0x4000
 464 ///////////////////////////////////////////////////////////////////////
 465 // 0x4000 Entry 16 (size 64 bundles) Reserved
 466         KVM_FAULT(16)
 467
 468     .org kvm_ia64_ivt+0x4400
 469 //////////////////////////////////////////////////////////////////////
 470 // 0x4400 Entry 17 (size 64 bundles) Reserved
 471         KVM_FAULT(17)
 472
 473     .org kvm_ia64_ivt+0x4800
 474 //////////////////////////////////////////////////////////////////////
 475 // 0x4800 Entry 18 (size 64 bundles) Reserved
 476         KVM_FAULT(18)
 477
 478     .org kvm_ia64_ivt+0x4c00
 479 //////////////////////////////////////////////////////////////////////
 480 // 0x4c00 Entry 19 (size 64 bundles) Reserved
 481         KVM_FAULT(19)
 482
 483     .org kvm_ia64_ivt+0x5000
 484 //////////////////////////////////////////////////////////////////////
 485 // 0x5000 Entry 20 (size 16 bundles) Page Not Present
 486 ENTRY(kvm_page_not_present)
 487         KVM_REFLECT(20)
 488 END(kvm_page_not_present)
 489
 490     .org kvm_ia64_ivt+0x5100
 491 ///////////////////////////////////////////////////////////////////////
 492 // 0x5100 Entry 21 (size 16 bundles) Key Permission vector
 493 ENTRY(kvm_key_permission)
 494         KVM_REFLECT(21)
 495 END(kvm_key_permission)
 496
 497     .org kvm_ia64_ivt+0x5200
 498 //////////////////////////////////////////////////////////////////////
 499 // 0x5200 Entry 22 (size 16 bundles) Instruction Access Rights (26)
 500 ENTRY(kvm_iaccess_rights)
 501         KVM_REFLECT(22)
 502 END(kvm_iaccess_rights)
 503
 504     .org kvm_ia64_ivt+0x5300
 505 //////////////////////////////////////////////////////////////////////
 506 // 0x5300 Entry 23 (size 16 bundles) Data Access Rights (14,53)
 507 ENTRY(kvm_daccess_rights)
 508         KVM_REFLECT(23)
 509 END(kvm_daccess_rights)
 510
 511     .org kvm_ia64_ivt+0x5400
 512 /////////////////////////////////////////////////////////////////////
 513 // 0x5400 Entry 24 (size 16 bundles) General Exception (5,32,34,36,38,39)
 514 ENTRY(kvm_general_exception)
 515         KVM_REFLECT(24)
 516         KVM_FAULT(24)
 517 END(kvm_general_exception)
 518
 519     .org kvm_ia64_ivt+0x5500
 520 //////////////////////////////////////////////////////////////////////
 521 // 0x5500 Entry 25 (size 16 bundles) Disabled FP-Register (35)
 522 ENTRY(kvm_disabled_fp_reg)
 523         KVM_REFLECT(25)
 524 END(kvm_disabled_fp_reg)
 525
 526     .org kvm_ia64_ivt+0x5600
 527 ////////////////////////////////////////////////////////////////////
 528 // 0x5600 Entry 26 (size 16 bundles) Nat Consumption (11,23,37,50)
 529 ENTRY(kvm_nat_consumption)
 530         KVM_REFLECT(26)
 531 END(kvm_nat_consumption)
 532
 533     .org kvm_ia64_ivt+0x5700
 534 /////////////////////////////////////////////////////////////////////
 535 // 0x5700 Entry 27 (size 16 bundles) Speculation (40)
 536 ENTRY(kvm_speculation_vector)
 537         KVM_REFLECT(27)
 538 END(kvm_speculation_vector)
 539
 540     .org kvm_ia64_ivt+0x5800
 541 /////////////////////////////////////////////////////////////////////
 542 // 0x5800 Entry 28 (size 16 bundles) Reserved
 543         KVM_FAULT(28)
 544
 545     .org kvm_ia64_ivt+0x5900
 546 ///////////////////////////////////////////////////////////////////
 547 // 0x5900 Entry 29 (size 16 bundles) Debug (16,28,56)
 548 ENTRY(kvm_debug_vector)
 549         KVM_FAULT(29)
 550 END(kvm_debug_vector)
 551
 552     .org kvm_ia64_ivt+0x5a00
 553 ///////////////////////////////////////////////////////////////
 554 // 0x5a00 Entry 30 (size 16 bundles) Unaligned Reference (57)
 555 ENTRY(kvm_unaligned_access)
 556         KVM_REFLECT(30)
 557 END(kvm_unaligned_access)
 558
 559     .org kvm_ia64_ivt+0x5b00
 560 //////////////////////////////////////////////////////////////////////
 561 // 0x5b00 Entry 31 (size 16 bundles) Unsupported Data Reference (57)
 562 ENTRY(kvm_unsupported_data_reference)
 563         KVM_REFLECT(31)
 564 END(kvm_unsupported_data_reference)
 565
 566     .org kvm_ia64_ivt+0x5c00
 567 ////////////////////////////////////////////////////////////////////
 568 // 0x5c00 Entry 32 (size 16 bundles) Floating Point FAULT (65)
 569 ENTRY(kvm_floating_point_fault)
 570         KVM_REFLECT(32)
 571 END(kvm_floating_point_fault)
 572
 573     .org kvm_ia64_ivt+0x5d00
 574 /////////////////////////////////////////////////////////////////////
 575 // 0x5d00 Entry 33 (size 16 bundles) Floating Point Trap (66)
 576 ENTRY(kvm_floating_point_trap)
 577         KVM_REFLECT(33)
 578 END(kvm_floating_point_trap)
 579
 580     .org kvm_ia64_ivt+0x5e00
 581 //////////////////////////////////////////////////////////////////////
 582 // 0x5e00 Entry 34 (size 16 bundles) Lower Privilege Transfer Trap (66)
 583 ENTRY(kvm_lower_privilege_trap)
 584         KVM_REFLECT(34)
 585 END(kvm_lower_privilege_trap)
 586
 587     .org kvm_ia64_ivt+0x5f00
 588 //////////////////////////////////////////////////////////////////////
 589 // 0x5f00 Entry 35 (size 16 bundles) Taken Branch Trap (68)
 590 ENTRY(kvm_taken_branch_trap)
 591         KVM_REFLECT(35)
 592 END(kvm_taken_branch_trap)
 593
 594     .org kvm_ia64_ivt+0x6000
 595 ////////////////////////////////////////////////////////////////////
 596 // 0x6000 Entry 36 (size 16 bundles) Single Step Trap (69)
 597 ENTRY(kvm_single_step_trap)
 598         KVM_REFLECT(36)
 599 END(kvm_single_step_trap)
 600     .global kvm_virtualization_fault_back
 601     .org kvm_ia64_ivt+0x6100
 602 /////////////////////////////////////////////////////////////////////
 603 // 0x6100 Entry 37 (size 16 bundles) Virtualization Fault
 604 ENTRY(kvm_virtualization_fault)
 605         mov r31=pr
 606         adds r16 = VMM_VCPU_SAVED_GP_OFFSET,r21
 607         ;;
 608         st8 [r16] = r1
 609         adds r17 = VMM_VCPU_GP_OFFSET, r21
 610         ;;
 611         ld8 r1 = [r17]
 612         cmp.eq p6,p0=EVENT_MOV_FROM_AR,r24
 613         cmp.eq p7,p0=EVENT_MOV_FROM_RR,r24
 614         cmp.eq p8,p0=EVENT_MOV_TO_RR,r24
 615         cmp.eq p9,p0=EVENT_RSM,r24
 616         cmp.eq p10,p0=EVENT_SSM,r24
 617         cmp.eq p11,p0=EVENT_MOV_TO_PSR,r24
 618         cmp.eq p12,p0=EVENT_THASH,r24
 619 (p6)    br.dptk.many kvm_asm_mov_from_ar
 620 (p7)    br.dptk.many kvm_asm_mov_from_rr
 621 (p8)    br.dptk.many kvm_asm_mov_to_rr
 622 (p9)    br.dptk.many kvm_asm_rsm
 623 (p10)   br.dptk.many kvm_asm_ssm
 624 (p11)   br.dptk.many kvm_asm_mov_to_psr
 625 (p12)   br.dptk.many kvm_asm_thash
 626         ;;
 627 kvm_virtualization_fault_back:
 628         adds r16 = VMM_VCPU_SAVED_GP_OFFSET,r21
 629         ;;
 630         ld8 r1 = [r16]
 631         ;;
 632         mov r19=37
 633         adds r16 = VMM_VCPU_CAUSE_OFFSET,r21
 634         adds r17 = VMM_VCPU_OPCODE_OFFSET,r21
 635         ;;
 636         st8 [r16] = r24
 637         st8 [r17] = r25
 638         ;;
 639         cmp.ne p6,p0=EVENT_RFI, r24
 640 (p6)    br.sptk kvm_dispatch_virtualization_fault
 641         ;;
 642         adds r18=VMM_VPD_BASE_OFFSET,r21
 643         ;;
 644         ld8 r18=[r18]
 645         ;;
 646         adds r18=VMM_VPD_VIFS_OFFSET,r18
 647         ;;
 648         ld8 r18=[r18]
 649         ;;
 650         tbit.z p6,p0=r18,63
 651 (p6)    br.sptk kvm_dispatch_virtualization_fault
 652         ;;
 653 //if vifs.v=1 desert current register frame
 654         alloc r18=ar.pfs,0,0,0,0
 655         br.sptk kvm_dispatch_virtualization_fault
 656 END(kvm_virtualization_fault)
 657
 658     .org kvm_ia64_ivt+0x6200
 659 //////////////////////////////////////////////////////////////
 660 // 0x6200 Entry 38 (size 16 bundles) Reserved
 661         KVM_FAULT(38)
 662
 663     .org kvm_ia64_ivt+0x6300
 664 /////////////////////////////////////////////////////////////////
 665 // 0x6300 Entry 39 (size 16 bundles) Reserved
 666         KVM_FAULT(39)
 667
 668     .org kvm_ia64_ivt+0x6400
 669 /////////////////////////////////////////////////////////////////
 670 // 0x6400 Entry 40 (size 16 bundles) Reserved
 671         KVM_FAULT(40)
 672
 673     .org kvm_ia64_ivt+0x6500
 674 //////////////////////////////////////////////////////////////////
 675 // 0x6500 Entry 41 (size 16 bundles) Reserved
 676         KVM_FAULT(41)
 677
 678     .org kvm_ia64_ivt+0x6600
 679 //////////////////////////////////////////////////////////////////
 680 // 0x6600 Entry 42 (size 16 bundles) Reserved
 681         KVM_FAULT(42)
 682
 683     .org kvm_ia64_ivt+0x6700
 684 //////////////////////////////////////////////////////////////////
 685 // 0x6700 Entry 43 (size 16 bundles) Reserved
 686         KVM_FAULT(43)
 687
 688     .org kvm_ia64_ivt+0x6800
 689 //////////////////////////////////////////////////////////////////
 690 // 0x6800 Entry 44 (size 16 bundles) Reserved
 691         KVM_FAULT(44)
 692
 693     .org kvm_ia64_ivt+0x6900
 694 ///////////////////////////////////////////////////////////////////
 695 // 0x6900 Entry 45 (size 16 bundles) IA-32 Exeception
 696 //(17,18,29,41,42,43,44,58,60,61,62,72,73,75,76,77)
 697 ENTRY(kvm_ia32_exception)
 698         KVM_FAULT(45)
 699 END(kvm_ia32_exception)
 700
 701     .org kvm_ia64_ivt+0x6a00
 702 ////////////////////////////////////////////////////////////////////
 703 // 0x6a00 Entry 46 (size 16 bundles) IA-32 Intercept  (30,31,59,70,71)
 704 ENTRY(kvm_ia32_intercept)
 705         KVM_FAULT(47)
 706 END(kvm_ia32_intercept)
 707
 708     .org kvm_ia64_ivt+0x6c00
 709 /////////////////////////////////////////////////////////////////////
 710 // 0x6c00 Entry 48 (size 16 bundles) Reserved
 711         KVM_FAULT(48)
 712
 713     .org kvm_ia64_ivt+0x6d00
 714 //////////////////////////////////////////////////////////////////////
 715 // 0x6d00 Entry 49 (size 16 bundles) Reserved
 716         KVM_FAULT(49)
 717
 718     .org kvm_ia64_ivt+0x6e00
 719 //////////////////////////////////////////////////////////////////////
 720 // 0x6e00 Entry 50 (size 16 bundles) Reserved
 721         KVM_FAULT(50)
 722
 723     .org kvm_ia64_ivt+0x6f00
 724 /////////////////////////////////////////////////////////////////////
 725 // 0x6f00 Entry 51 (size 16 bundles) Reserved
 726         KVM_FAULT(52)
 727
 728     .org kvm_ia64_ivt+0x7100
 729 ////////////////////////////////////////////////////////////////////
 730 // 0x7100 Entry 53 (size 16 bundles) Reserved
 731         KVM_FAULT(53)
 732
 733     .org kvm_ia64_ivt+0x7200
 734 /////////////////////////////////////////////////////////////////////
 735 // 0x7200 Entry 54 (size 16 bundles) Reserved
 736         KVM_FAULT(54)
 737
 738     .org kvm_ia64_ivt+0x7300
 739 ////////////////////////////////////////////////////////////////////
 740 // 0x7300 Entry 55 (size 16 bundles) Reserved
 741         KVM_FAULT(55)
 742
 743     .org kvm_ia64_ivt+0x7400
 744 ////////////////////////////////////////////////////////////////////
 745 // 0x7400 Entry 56 (size 16 bundles) Reserved
 746         KVM_FAULT(56)
 747
 748     .org kvm_ia64_ivt+0x7500
 749 /////////////////////////////////////////////////////////////////////
 750 // 0x7500 Entry 57 (size 16 bundles) Reserved
 751         KVM_FAULT(57)
 752
 753     .org kvm_ia64_ivt+0x7600
 754 /////////////////////////////////////////////////////////////////////
 755 // 0x7600 Entry 58 (size 16 bundles) Reserved
 756         KVM_FAULT(58)
 757
 758     .org kvm_ia64_ivt+0x7700
 759 ////////////////////////////////////////////////////////////////////
 760 // 0x7700 Entry 59 (size 16 bundles) Reserved
 761         KVM_FAULT(59)
 762
 763     .org kvm_ia64_ivt+0x7800
 764 ////////////////////////////////////////////////////////////////////
 765 // 0x7800 Entry 60 (size 16 bundles) Reserved
 766         KVM_FAULT(60)
 767
 768     .org kvm_ia64_ivt+0x7900
 769 /////////////////////////////////////////////////////////////////////
 770 // 0x7900 Entry 61 (size 16 bundles) Reserved
 771         KVM_FAULT(61)
 772
 773     .org kvm_ia64_ivt+0x7a00
 774 /////////////////////////////////////////////////////////////////////
 775 // 0x7a00 Entry 62 (size 16 bundles) Reserved
 776         KVM_FAULT(62)
 777
 778     .org kvm_ia64_ivt+0x7b00
 779 /////////////////////////////////////////////////////////////////////
 780 // 0x7b00 Entry 63 (size 16 bundles) Reserved
 781         KVM_FAULT(63)
 782
 783     .org kvm_ia64_ivt+0x7c00
 784 ////////////////////////////////////////////////////////////////////
 785 // 0x7c00 Entry 64 (size 16 bundles) Reserved
 786         KVM_FAULT(64)
 787
 788     .org kvm_ia64_ivt+0x7d00
 789 /////////////////////////////////////////////////////////////////////
 790 // 0x7d00 Entry 65 (size 16 bundles) Reserved
 791         KVM_FAULT(65)
 792
 793     .org kvm_ia64_ivt+0x7e00
 794 /////////////////////////////////////////////////////////////////////
 795 // 0x7e00 Entry 66 (size 16 bundles) Reserved
 796         KVM_FAULT(66)
 797
 798     .org kvm_ia64_ivt+0x7f00
 799 ////////////////////////////////////////////////////////////////////
 800 // 0x7f00 Entry 67 (size 16 bundles) Reserved
 801         KVM_FAULT(67)
 802
 803     .org kvm_ia64_ivt+0x8000
 804 // There is no particular reason for this code to be here, other than that
 805 // there happens to be space here that would go unused otherwise.  If this
 806 // fault ever gets "unreserved", simply moved the following code to a more
 807 // suitable spot...
 808
 809
 810 ENTRY(kvm_dtlb_miss_dispatch)
 811         mov r19 = 2
 812         KVM_SAVE_MIN_WITH_COVER_R19
 813         alloc r14=ar.pfs,0,0,3,0
 814         mov out0=cr.ifa
 815         mov out1=r15
 816         adds r3=8,r2                // set up second base pointer
 817         ;;
 818         ssm psr.ic
 819         ;;
 820         srlz.i     // guarantee that interruption collection is on
 821         ;;
 822         (p15) ssm psr.i               // restore psr.i
 823         addl r14=@gprel(ia64_leave_hypervisor_prepare),gp
 824         ;;
 825         KVM_SAVE_REST
 826         KVM_SAVE_EXTRA
 827         mov rp=r14
 828         ;;
 829         adds out2=16,r12
 830         br.call.sptk.many b6=kvm_page_fault
 831 END(kvm_dtlb_miss_dispatch)
 832
 833 ENTRY(kvm_itlb_miss_dispatch)
 834
 835         KVM_SAVE_MIN_WITH_COVER_R19
 836         alloc r14=ar.pfs,0,0,3,0
 837         mov out0=cr.ifa
 838         mov out1=r15
 839         adds r3=8,r2                // set up second base pointer
 840         ;;
 841         ssm psr.ic
 842         ;;
 843         srlz.i   // guarantee that interruption collection is on
 844         ;;
 845         (p15) ssm psr.i               // restore psr.i
 846         addl r14=@gprel(ia64_leave_hypervisor),gp
 847         ;;
 848         KVM_SAVE_REST
 849         mov rp=r14
 850         ;;
 851         adds out2=16,r12
 852         br.call.sptk.many b6=kvm_page_fault
 853 END(kvm_itlb_miss_dispatch)
 854
 855 ENTRY(kvm_dispatch_reflection)
 856 /*
 857  * Input:
 858  *  psr.ic: off
 859  *  r19:    intr type (offset into ivt, see ia64_int.h)
 860  *  r31:    contains saved predicates (pr)
 861  */
 862         KVM_SAVE_MIN_WITH_COVER_R19
 863         alloc r14=ar.pfs,0,0,5,0
 864         mov out0=cr.ifa
 865         mov out1=cr.isr
 866         mov out2=cr.iim
 867         mov out3=r15
 868         adds r3=8,r2                // set up second base pointer
 869         ;;
 870         ssm psr.ic
 871         ;;
 872         srlz.i   // guarantee that interruption collection is on
 873         ;;
 874         (p15) ssm psr.i               // restore psr.i
 875         addl r14=@gprel(ia64_leave_hypervisor),gp
 876         ;;
 877         KVM_SAVE_REST
 878         mov rp=r14
 879         ;;
 880         adds out4=16,r12
 881         br.call.sptk.many b6=reflect_interruption
 882 END(kvm_dispatch_reflection)
 883
 884 ENTRY(kvm_dispatch_virtualization_fault)
 885         adds r16 = VMM_VCPU_CAUSE_OFFSET,r21
 886         adds r17 = VMM_VCPU_OPCODE_OFFSET,r21
 887         ;;
 888         st8 [r16] = r24
 889         st8 [r17] = r25
 890         ;;
 891         KVM_SAVE_MIN_WITH_COVER_R19
 892         ;;
 893         alloc r14=ar.pfs,0,0,2,0 // (must be first in insn group!)
 894         mov out0=r13        //vcpu
 895         adds r3=8,r2                // set up second base pointer
 896         ;;
 897         ssm psr.ic
 898         ;;
 899         srlz.i    // guarantee that interruption collection is on
 900         ;;
 901         (p15) ssm psr.i               // restore psr.i
 902         addl r14=@gprel(ia64_leave_hypervisor_prepare),gp
 903         ;;
 904         KVM_SAVE_REST
 905         KVM_SAVE_EXTRA
 906         mov rp=r14
 907         ;;
 908         adds out1=16,sp         //regs
 909         br.call.sptk.many b6=kvm_emulate
 910 END(kvm_dispatch_virtualization_fault)
 911
 912
 913 ENTRY(kvm_dispatch_interrupt)
 914         KVM_SAVE_MIN_WITH_COVER_R19     // uses r31; defines r2 and r3
 915         ;;
 916         alloc r14=ar.pfs,0,0,1,0 // must be first in an insn group
 917         adds r3=8,r2            // set up second base pointer for SAVE_REST
 918         ;;
 919         ssm psr.ic
 920         ;;
 921         srlz.i
 922         ;;
 923         (p15) ssm psr.i
 924         addl r14=@gprel(ia64_leave_hypervisor),gp
 925         ;;
 926         KVM_SAVE_REST
 927         mov rp=r14
 928         ;;
 929         mov out0=r13            // pass pointer to pt_regs as second arg
 930         br.call.sptk.many b6=kvm_ia64_handle_irq
 931 END(kvm_dispatch_interrupt)
 932
 933 GLOBAL_ENTRY(ia64_leave_nested)
 934         rsm psr.i
 935         ;;
 936         adds r21=PT(PR)+16,r12
 937         ;;
 938         lfetch [r21],PT(CR_IPSR)-PT(PR)
 939         adds r2=PT(B6)+16,r12
 940         adds r3=PT(R16)+16,r12
 941         ;;
 942         lfetch [r21]
 943         ld8 r28=[r2],8          // load b6
 944         adds r29=PT(R24)+16,r12
 945
 946         ld8.fill r16=[r3]
 947         adds r3=PT(AR_CSD)-PT(R16),r3
 948         adds r30=PT(AR_CCV)+16,r12
 949         ;;
 950         ld8.fill r24=[r29]
 951         ld8 r15=[r30]           // load ar.ccv
 952         ;;
 953         ld8 r29=[r2],16         // load b7
 954         ld8 r30=[r3],16         // load ar.csd
 955         ;;
 956         ld8 r31=[r2],16         // load ar.ssd
 957         ld8.fill r8=[r3],16
 958         ;;
 959         ld8.fill r9=[r2],16
 960         ld8.fill r10=[r3],PT(R17)-PT(R10)
 961         ;;
 962         ld8.fill r11=[r2],PT(R18)-PT(R11)
 963         ld8.fill r17=[r3],16
 964         ;;
 965         ld8.fill r18=[r2],16
 966         ld8.fill r19=[r3],16
 967         ;;
 968         ld8.fill r20=[r2],16
 969         ld8.fill r21=[r3],16
 970         mov ar.csd=r30
 971         mov ar.ssd=r31
 972         ;;
 973         rsm psr.i | psr.ic
 974         // initiate turning off of interrupt and interruption collection
 975         invala                  // invalidate ALAT
 976         ;;
 977         srlz.i
 978         ;;
 979         ld8.fill r22=[r2],24
 980         ld8.fill r23=[r3],24
 981         mov b6=r28
 982         ;;
 983         ld8.fill r25=[r2],16
 984         ld8.fill r26=[r3],16
 985         mov b7=r29
 986         ;;
 987         ld8.fill r27=[r2],16
 988         ld8.fill r28=[r3],16
 989         ;;
 990         ld8.fill r29=[r2],16
 991         ld8.fill r30=[r3],24
 992         ;;
 993         ld8.fill r31=[r2],PT(F9)-PT(R31)
 994         adds r3=PT(F10)-PT(F6),r3
 995         ;;
 996         ldf.fill f9=[r2],PT(F6)-PT(F9)
 997         ldf.fill f10=[r3],PT(F8)-PT(F10)
 998         ;;
 999         ldf.fill f6=[r2],PT(F7)-PT(F6)
1000         ;;
1001         ldf.fill f7=[r2],PT(F11)-PT(F7)
1002         ldf.fill f8=[r3],32
1003         ;;
1004         srlz.i                  // ensure interruption collection is off
1005         mov ar.ccv=r15
1006         ;;
1007         bsw.0   // switch back to bank 0 (no stop bit required beforehand...)
1008         ;;
1009         ldf.fill f11=[r2]
1010 //      mov r18=r13
1011 //      mov r21=r13
1012         adds r16=PT(CR_IPSR)+16,r12
1013         adds r17=PT(CR_IIP)+16,r12
1014         ;;
1015         ld8 r29=[r16],16        // load cr.ipsr
1016         ld8 r28=[r17],16        // load cr.iip
1017         ;;
1018         ld8 r30=[r16],16        // load cr.ifs
1019         ld8 r25=[r17],16        // load ar.unat
1020         ;;
1021         ld8 r26=[r16],16        // load ar.pfs
1022         ld8 r27=[r17],16        // load ar.rsc
1023         cmp.eq p9,p0=r0,r0
1024         // set p9 to indicate that we should restore cr.ifs
1025         ;;
1026         ld8 r24=[r16],16        // load ar.rnat (may be garbage)
1027         ld8 r23=[r17],16// load ar.bspstore (may be garbage)
1028         ;;
1029         ld8 r31=[r16],16        // load predicates
1030         ld8 r22=[r17],16        // load b0
1031         ;;
1032         ld8 r19=[r16],16        // load ar.rsc value for "loadrs"
1033         ld8.fill r1=[r17],16    // load r1
1034         ;;
1035         ld8.fill r12=[r16],16
1036         ld8.fill r13=[r17],16
1037         ;;
1038         ld8 r20=[r16],16        // ar.fpsr
1039         ld8.fill r15=[r17],16
1040         ;;
1041         ld8.fill r14=[r16],16
1042         ld8.fill r2=[r17]
1043         ;;
1044         ld8.fill r3=[r16]
1045         ;;
1046         mov r16=ar.bsp          // get existing backing store pointer
1047         ;;
1048         mov b0=r22
1049         mov ar.pfs=r26
1050         mov cr.ifs=r30
1051         mov cr.ipsr=r29
1052         mov ar.fpsr=r20
1053         mov cr.iip=r28
1054         ;;
1055         mov ar.rsc=r27
1056         mov ar.unat=r25
1057         mov pr=r31,-1
1058         rfi
1059 END(ia64_leave_nested)
1060
1061 GLOBAL_ENTRY(ia64_leave_hypervisor_prepare)
1062 /*
1063  * work.need_resched etc. mustn't get changed
1064  *by this CPU before it returns to
1065  * user- or fsys-mode, hence we disable interrupts early on:
1066  */
1067         adds r2 = PT(R4)+16,r12
1068         adds r3 = PT(R5)+16,r12
1069         adds r8 = PT(EML_UNAT)+16,r12
1070         ;;
1071         ld8 r8 = [r8]
1072         ;;
1073         mov ar.unat=r8
1074         ;;
1075         ld8.fill r4=[r2],16    //load r4
1076         ld8.fill r5=[r3],16    //load r5
1077         ;;
1078         ld8.fill r6=[r2]    //load r6
1079         ld8.fill r7=[r3]    //load r7
1080         ;;
1081 END(ia64_leave_hypervisor_prepare)
1082 //fall through
1083 GLOBAL_ENTRY(ia64_leave_hypervisor)
1084         rsm psr.i
1085         ;;
1086         br.call.sptk.many b0=leave_hypervisor_tail
1087         ;;
1088         adds r20=PT(PR)+16,r12
1089         adds r8=PT(EML_UNAT)+16,r12
1090         ;;
1091         ld8 r8=[r8]
1092         ;;
1093         mov ar.unat=r8
1094         ;;
1095         lfetch [r20],PT(CR_IPSR)-PT(PR)
1096         adds r2 = PT(B6)+16,r12
1097         adds r3 = PT(B7)+16,r12
1098         ;;
1099         lfetch [r20]
1100         ;;
1101         ld8 r24=[r2],16        /* B6 */
1102         ld8 r25=[r3],16        /* B7 */
1103         ;;
1104         ld8 r26=[r2],16        /* ar_csd */
1105         ld8 r27=[r3],16        /* ar_ssd */
1106         mov b6 = r24
1107         ;;
1108         ld8.fill r8=[r2],16
1109         ld8.fill r9=[r3],16
1110         mov b7 = r25
1111         ;;
1112         mov ar.csd = r26
1113         mov ar.ssd = r27
1114         ;;
1115         ld8.fill r10=[r2],PT(R15)-PT(R10)
1116         ld8.fill r11=[r3],PT(R14)-PT(R11)
1117         ;;
1118         ld8.fill r15=[r2],PT(R16)-PT(R15)
1119         ld8.fill r14=[r3],PT(R17)-PT(R14)
1120         ;;
1121         ld8.fill r16=[r2],16
1122         ld8.fill r17=[r3],16
1123         ;;
1124         ld8.fill r18=[r2],16
1125         ld8.fill r19=[r3],16
1126         ;;
1127         ld8.fill r20=[r2],16
1128         ld8.fill r21=[r3],16
1129         ;;
1130         ld8.fill r22=[r2],16
1131         ld8.fill r23=[r3],16
1132         ;;
1133         ld8.fill r24=[r2],16
1134         ld8.fill r25=[r3],16
1135         ;;
1136         ld8.fill r26=[r2],16
1137         ld8.fill r27=[r3],16
1138         ;;
1139         ld8.fill r28=[r2],16
1140         ld8.fill r29=[r3],16
1141         ;;
1142         ld8.fill r30=[r2],PT(F6)-PT(R30)
1143         ld8.fill r31=[r3],PT(F7)-PT(R31)
1144         ;;
1145         rsm psr.i | psr.ic
1146         // initiate turning off of interrupt and interruption collection
1147         invala          // invalidate ALAT
1148         ;;
1149         srlz.i          // ensure interruption collection is off
1150         ;;
1151         bsw.0
1152         ;;
1153         adds r16 = PT(CR_IPSR)+16,r12
1154         adds r17 = PT(CR_IIP)+16,r12
1155         mov r21=r13             // get current
1156         ;;
1157         ld8 r31=[r16],16    // load cr.ipsr
1158         ld8 r30=[r17],16    // load cr.iip
1159         ;;
1160         ld8 r29=[r16],16    // load cr.ifs
1161         ld8 r28=[r17],16    // load ar.unat
1162         ;;
1163         ld8 r27=[r16],16    // load ar.pfs
1164         ld8 r26=[r17],16    // load ar.rsc
1165         ;;
1166         ld8 r25=[r16],16    // load ar.rnat
1167         ld8 r24=[r17],16    // load ar.bspstore
1168         ;;
1169         ld8 r23=[r16],16    // load predicates
1170         ld8 r22=[r17],16    // load b0
1171         ;;
1172         ld8 r20=[r16],16    // load ar.rsc value for "loadrs"
1173         ld8.fill r1=[r17],16    //load r1
1174         ;;
1175         ld8.fill r12=[r16],16    //load r12
1176         ld8.fill r13=[r17],PT(R2)-PT(R13)    //load r13
1177         ;;
1178         ld8 r19=[r16],PT(R3)-PT(AR_FPSR)    //load ar_fpsr
1179         ld8.fill r2=[r17],PT(AR_CCV)-PT(R2)    //load r2
1180         ;;
1181         ld8.fill r3=[r16]       //load r3
1182         ld8 r18=[r17]   //load ar_ccv
1183         ;;
1184         mov ar.fpsr=r19
1185         mov ar.ccv=r18
1186         shr.u r18=r20,16
1187         ;;
1188 kvm_rbs_switch:
1189         mov r19=96
1190
1191 kvm_dont_preserve_current_frame:
1192 /*
1193     * To prevent leaking bits between the hypervisor and guest domain,
1194     * we must clear the stacked registers in the "invalid" partition here.
1195     * 5 registers/cycle on McKinley).
1196     */
1197 #   define pRecurse     p6
1198 #   define pReturn      p7
1199 #   define Nregs        14
1200
1201         alloc loc0=ar.pfs,2,Nregs-2,2,0
1202         shr.u loc1=r18,9        // RNaTslots <= floor(dirtySize / (64*8))
1203         sub r19=r19,r18         // r19 = (physStackedSize + 8) - dirtySize
1204         ;;
1205         mov ar.rsc=r20          // load ar.rsc to be used for "loadrs"
1206         shladd in0=loc1,3,r19
1207         mov in1=0
1208         ;;
1209         TEXT_ALIGN(32)
1210 kvm_rse_clear_invalid:
1211         alloc loc0=ar.pfs,2,Nregs-2,2,0
1212         cmp.lt pRecurse,p0=Nregs*8,in0
1213         // if more than Nregs regs left to clear, (re)curse
1214         add out0=-Nregs*8,in0
1215         add out1=1,in1          // increment recursion count
1216         mov loc1=0
1217         mov loc2=0
1218         ;;
1219         mov loc3=0
1220         mov loc4=0
1221         mov loc5=0
1222         mov loc6=0
1223         mov loc7=0
1224 (pRecurse) br.call.dptk.few b0=kvm_rse_clear_invalid
1225         ;;
1226         mov loc8=0
1227         mov loc9=0
1228         cmp.ne pReturn,p0=r0,in1
1229         // if recursion count != 0, we need to do a br.ret
1230         mov loc10=0
1231         mov loc11=0
1232 (pReturn) br.ret.dptk.many b0
1233
1234 #       undef pRecurse
1235 #       undef pReturn
1236
1237 // loadrs has already been shifted
1238         alloc r16=ar.pfs,0,0,0,0    // drop current register frame
1239         ;;
1240         loadrs
1241         ;;
1242         mov ar.bspstore=r24
1243         ;;
1244         mov ar.unat=r28
1245         mov ar.rnat=r25
1246         mov ar.rsc=r26
1247         ;;
1248         mov cr.ipsr=r31
1249         mov cr.iip=r30
1250         mov cr.ifs=r29
1251         mov ar.pfs=r27
1252         adds r18=VMM_VPD_BASE_OFFSET,r21
1253         ;;
1254         ld8 r18=[r18]   //vpd
1255         adds r17=VMM_VCPU_ISR_OFFSET,r21
1256         ;;
1257         ld8 r17=[r17]
1258         adds r19=VMM_VPD_VPSR_OFFSET,r18
1259         ;;
1260         ld8 r19=[r19]        //vpsr
1261         mov r25=r18
1262         adds r16= VMM_VCPU_GP_OFFSET,r21
1263         ;;
1264         ld8 r16= [r16] // Put gp in r24
1265         movl r24=@gprel(ia64_vmm_entry)  // calculate return address
1266         ;;
1267         add  r24=r24,r16
1268         ;;
1269         br.sptk.many  kvm_vps_sync_write       // call the service
1270         ;;
1271 END(ia64_leave_hypervisor)
1272 // fall through
1273 GLOBAL_ENTRY(ia64_vmm_entry)
1274 /*
1275  *  must be at bank 0
1276  *  parameter:
1277  *  r17:cr.isr
1278  *  r18:vpd
1279  *  r19:vpsr
1280  *  r22:b0
1281  *  r23:predicate
1282  */
1283         mov r24=r22
1284         mov r25=r18
1285         tbit.nz p1,p2 = r19,IA64_PSR_IC_BIT        // p1=vpsr.ic
1286 (p1)    br.cond.sptk.few kvm_vps_resume_normal
1287 (p2)    br.cond.sptk.many kvm_vps_resume_handler
1288         ;;
1289 END(ia64_vmm_entry)
1290
1291 /*
1292  * extern u64 ia64_call_vsa(u64 proc, u64 arg1, u64 arg2,
1293  *                  u64 arg3, u64 arg4, u64 arg5,
1294  *                  u64 arg6, u64 arg7);
1295  *
1296  * XXX: The currently defined services use only 4 args at the max. The
1297  *  rest are not consumed.
1298  */
1299 GLOBAL_ENTRY(ia64_call_vsa)
1300     .regstk 4,4,0,0
1301
1302 rpsave  =   loc0
1303 pfssave =   loc1
1304 psrsave =   loc2
1305 entry   =   loc3
1306 hostret =   r24
1307
1308         alloc   pfssave=ar.pfs,4,4,0,0
1309         mov rpsave=rp
1310         adds entry=VMM_VCPU_VSA_BASE_OFFSET, r13
1311         ;;
1312         ld8 entry=[entry]
1313 1:      mov hostret=ip
1314         mov r25=in1         // copy arguments
1315         mov r26=in2
1316         mov r27=in3
1317         mov psrsave=psr
1318         ;;
1319         tbit.nz p6,p0=psrsave,14    // IA64_PSR_I
1320         tbit.nz p7,p0=psrsave,13    // IA64_PSR_IC
1321         ;;
1322         add hostret=2f-1b,hostret   // calculate return address
1323         add entry=entry,in0
1324         ;;
1325         rsm psr.i | psr.ic
1326         ;;
1327         srlz.i
1328         mov b6=entry
1329         br.cond.sptk b6         // call the service
1330 2:
1331 // Architectural sequence for enabling interrupts if necessary
1332 (p7)    ssm psr.ic
1333         ;;
1334 (p7)    srlz.i
1335         ;;
1336 (p6)    ssm psr.i
1337         ;;
1338         mov rp=rpsave
1339         mov ar.pfs=pfssave
1340         mov r8=r31
1341         ;;
1342         srlz.d
1343         br.ret.sptk rp
1344
1345 END(ia64_call_vsa)
1346
1347 #define  INIT_BSPSTORE  ((4<<30)-(12<<20)-0x100)
1348
1349 GLOBAL_ENTRY(vmm_reset_entry)
1350         //set up ipsr, iip, vpd.vpsr, dcr
1351         // For IPSR: it/dt/rt=1, i/ic=1, si=1, vm/bn=1
1352         // For DCR: all bits 0
1353         bsw.0
1354         ;;
1355         mov r21 =r13
1356         adds r14=-VMM_PT_REGS_SIZE, r12
1357         ;;
1358         movl r6=0x501008826000      // IPSR dt/rt/it:1;i/ic:1, si:1, vm/bn:1
1359         movl r10=0x8000000000000000
1360         adds r16=PT(CR_IIP), r14
1361         adds r20=PT(R1), r14
1362         ;;
1363         rsm psr.ic | psr.i
1364         ;;
1365         srlz.i
1366         ;;
1367         mov ar.rsc = 0
1368         ;;
1369         flushrs
1370         ;;
1371         mov ar.bspstore = 0
1372         // clear BSPSTORE
1373         ;;
1374         mov cr.ipsr=r6
1375         mov cr.ifs=r10
1376         ld8 r4 = [r16] // Set init iip for first run.
1377         ld8 r1 = [r20]
1378         ;;
1379         mov cr.iip=r4
1380         adds r16=VMM_VPD_BASE_OFFSET,r13
1381         ;;
1382         ld8 r18=[r16]
1383         ;;
1384         adds r19=VMM_VPD_VPSR_OFFSET,r18
1385         ;;
1386         ld8 r19=[r19]
1387         mov r17=r0
1388         mov r22=r0
1389         mov r23=r0
1390         br.cond.sptk ia64_vmm_entry
1391         br.ret.sptk  b0
1392 END(vmm_reset_entry)