powerpc/64s: Add new exception vector macros

Create arch/powerpc/include/asm/head-64.h with macros that specify
an exception vector (name, type, location), which will be used to
label and lay out exceptions into the object file.

Naming is moved out of exception-64s.h, which is used to specify the
implementation of exception handlers.

objdump of generated code in exception vectors is unchanged except for
names. Alignment directives scattered around are annoying, but done
this way so that disassembly can verify identical instruction
generation before and after patch. These get cleaned up in future
patch.

We change the way KVMTEST works, explicitly passing EXC_HV or EXC_STD
rather than overloading the trap number. This removes the need to have
SOFTEN values for the overloaded trap numbers, eg. 0x502.

Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>

2 files changed, 217 insertions, 81 deletions

diff --git a/arch/powerpc/include/asm/exception-64s.h b/arch/powerpc/include/asm/exception-64s.h
index 5032a80e8f6a..72f2b1e3f343 100644
--- a/arch/powerpc/include/asm/exception-64s.h
+++ b/arch/powerpc/include/asm/exception-64s.h
@@ -34,6 +34,7 @@
  * exception handlers (including pSeries LPAR) and iSeries LPAR
  * implementations as possible.
  */
+#include <asm/head-64.h>
 
 #define EX_R9           0
 #define EX_R10          8
@@ -191,10 +192,10 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
         EXCEPTION_PROLOG_1(area, extra, vec);                           \
         EXCEPTION_PROLOG_PSERIES_1(label, h);
 
-#define __KVMTEST(n)                                                    \
-        lbz     r10,HSTATE_IN_GUEST(r13);                       \
+#define __KVMTEST(h, n)                                                 \
+        lbz     r10,HSTATE_IN_GUEST(r13);                               \
         cmpwi   r10,0;                                                  \
-        bne     do_kvm_##n
+        bne     do_kvm_##h##n
 
 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
 /*
@@ -207,8 +208,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 #define kvmppc_interrupt kvmppc_interrupt_pr
 #endif
 
-#define __KVM_HANDLER(area, h, n)                                       \
-do_kvm_##n:                                                             \
+#define __KVM_HANDLER_PROLOG(area, n)                                   \
         BEGIN_FTR_SECTION_NESTED(947)                                   \
         ld      r10,area+EX_CFAR(r13);                                  \
         std     r10,HSTATE_CFAR(r13);                                   \
@@ -221,21 +221,23 @@ do_kvm_##n:								\
         stw     r9,HSTATE_SCRATCH1(r13);                                \
         ld      r9,area+EX_R9(r13);                                     \
         std     r12,HSTATE_SCRATCH0(r13);                               \
+
+#define __KVM_HANDLER(area, h, n)                                       \
+        __KVM_HANDLER_PROLOG(area, n)                                   \
         li      r12,n;                                                  \
         b       kvmppc_interrupt
 
 #define __KVM_HANDLER_SKIP(area, h, n)                                  \
-do_kvm_##n:                                                             \
         cmpwi   r10,KVM_GUEST_MODE_SKIP;                                \
         ld      r10,area+EX_R10(r13);                                   \
         beq     89f;                                                    \
-        stw     r9,HSTATE_SCRATCH1(r13);                        \
+        stw     r9,HSTATE_SCRATCH1(r13);                                \
         BEGIN_FTR_SECTION_NESTED(948)                                   \
         ld      r9,area+EX_PPR(r13);                                    \
         std     r9,HSTATE_PPR(r13);                                     \
         END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,948);    \
         ld      r9,area+EX_R9(r13);                                     \
-        std     r12,HSTATE_SCRATCH0(r13);                       \
+        std     r12,HSTATE_SCRATCH0(r13);                               \
         li      r12,n;                                                  \
         b       kvmppc_interrupt;                                       \
 89:     mtocrf  0x80,r9;                                                \
@@ -243,12 +245,12 @@ do_kvm_##n:								\
         b       kvmppc_skip_##h##interrupt
 
 #ifdef CONFIG_KVM_BOOK3S_64_HANDLER
-#define KVMTEST(n)                      __KVMTEST(n)
+#define KVMTEST(h, n)                   __KVMTEST(h, n)
 #define KVM_HANDLER(area, h, n)         __KVM_HANDLER(area, h, n)
 #define KVM_HANDLER_SKIP(area, h, n)    __KVM_HANDLER_SKIP(area, h, n)
 
 #else
-#define KVMTEST(n)
+#define KVMTEST(h, n)
 #define KVM_HANDLER(area, h, n)
 #define KVM_HANDLER_SKIP(area, h, n)
 #endif
@@ -332,94 +334,79 @@ do_kvm_##n:								\
 /*
  * Exception vectors.
  */
-#define STD_EXCEPTION_PSERIES(vec, label)               \
-        . = vec;                                        \
-        .globl label##_pSeries;                         \
-label##_pSeries:                                        \
+#define STD_EXCEPTION_PSERIES(vec, label)                       \
         SET_SCRATCH0(r13);              /* save r13 */          \
-        EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label##_common,    \
-                                 EXC_STD, KVMTEST, vec)
+        EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label,             \
+                                 EXC_STD, KVMTEST_PR, vec);     \
 
 /* Version of above for when we have to branch out-of-line */
+#define __OOL_EXCEPTION(vec, label, hdlr)                       \
+        SET_SCRATCH0(r13)                                       \
+        EXCEPTION_PROLOG_0(PACA_EXGEN)                          \
+        b hdlr;
+
 #define STD_EXCEPTION_PSERIES_OOL(vec, label)                   \
-        .globl label##_pSeries;                                 \
-label##_pSeries:                                                \
-        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST, vec);   \
-        EXCEPTION_PROLOG_PSERIES_1(label##_common, EXC_STD)
-
-#define STD_EXCEPTION_HV(loc, vec, label)               \
-        . = loc;                                        \
-        .globl label##_hv;                              \
-label##_hv:                                             \
+        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST_PR, vec);        \
+        EXCEPTION_PROLOG_PSERIES_1(label, EXC_STD)
+
+#define STD_EXCEPTION_HV(loc, vec, label)                       \
         SET_SCRATCH0(r13);      /* save r13 */                  \
-        EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label##_common,    \
-                                 EXC_HV, KVMTEST, vec)
+        EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label,             \
+                                 EXC_HV, KVMTEST_HV, vec);
 
-/* Version of above for when we have to branch out-of-line */
-#define STD_EXCEPTION_HV_OOL(vec, label)                \
-        .globl label##_hv;                              \
-label##_hv:                                             \
-        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST, vec);   \
-        EXCEPTION_PROLOG_PSERIES_1(label##_common, EXC_HV)
+#define STD_EXCEPTION_HV_OOL(vec, label)                        \
+        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST_HV, vec);        \
+        EXCEPTION_PROLOG_PSERIES_1(label, EXC_HV)
 
 #define STD_RELON_EXCEPTION_PSERIES(loc, vec, label)    \
-        . = loc;                                        \
-        .globl label##_relon_pSeries;                   \
-label##_relon_pSeries:                                  \
         /* No guest interrupts come through here */     \
         SET_SCRATCH0(r13);              /* save r13 */  \
-        EXCEPTION_RELON_PROLOG_PSERIES(PACA_EXGEN, label##_common, \
-                                       EXC_STD, NOTEST, vec)
+        EXCEPTION_RELON_PROLOG_PSERIES(PACA_EXGEN, label, EXC_STD, NOTEST, vec);
 
 #define STD_RELON_EXCEPTION_PSERIES_OOL(vec, label)             \
-        .globl label##_relon_pSeries;                           \
-label##_relon_pSeries:                                          \
         EXCEPTION_PROLOG_1(PACA_EXGEN, NOTEST, vec);            \
-        EXCEPTION_RELON_PROLOG_PSERIES_1(label##_common, EXC_STD)
+        EXCEPTION_RELON_PROLOG_PSERIES_1(label, EXC_STD)
 
 #define STD_RELON_EXCEPTION_HV(loc, vec, label)         \
-        . = loc;                                        \
-        .globl label##_relon_hv;                        \
-label##_relon_hv:                                       \
         /* No guest interrupts come through here */     \
         SET_SCRATCH0(r13);      /* save r13 */          \
-        EXCEPTION_RELON_PROLOG_PSERIES(PACA_EXGEN, label##_common, \
-                                       EXC_HV, NOTEST, vec)
+        EXCEPTION_RELON_PROLOG_PSERIES(PACA_EXGEN, label, EXC_HV, NOTEST, vec);
 
 #define STD_RELON_EXCEPTION_HV_OOL(vec, label)                  \
-        .globl label##_relon_hv;                                \
-label##_relon_hv:                                               \
         EXCEPTION_PROLOG_1(PACA_EXGEN, NOTEST, vec);            \
-        EXCEPTION_RELON_PROLOG_PSERIES_1(label##_common, EXC_HV)
+        EXCEPTION_RELON_PROLOG_PSERIES_1(label, EXC_HV)
 
 /* This associate vector numbers with bits in paca->irq_happened */
 #define SOFTEN_VALUE_0x500      PACA_IRQ_EE
-#define SOFTEN_VALUE_0x502      PACA_IRQ_EE
 #define SOFTEN_VALUE_0x900      PACA_IRQ_DEC
-#define SOFTEN_VALUE_0x982      PACA_IRQ_DEC
+#define SOFTEN_VALUE_0x980      PACA_IRQ_DEC
 #define SOFTEN_VALUE_0xa00      PACA_IRQ_DBELL
 #define SOFTEN_VALUE_0xe80      PACA_IRQ_DBELL
-#define SOFTEN_VALUE_0xe82      PACA_IRQ_DBELL
 #define SOFTEN_VALUE_0xe60      PACA_IRQ_HMI
-#define SOFTEN_VALUE_0xe62      PACA_IRQ_HMI
 #define SOFTEN_VALUE_0xea0      PACA_IRQ_EE
-#define SOFTEN_VALUE_0xea2      PACA_IRQ_EE
 
 #define __SOFTEN_TEST(h, vec)                                           \
         lbz     r10,PACASOFTIRQEN(r13);                                 \
         cmpwi   r10,0;                                                  \
         li      r10,SOFTEN_VALUE_##vec;                                 \
         beq     masked_##h##interrupt
+
 #define _SOFTEN_TEST(h, vec)    __SOFTEN_TEST(h, vec)
 
 #define SOFTEN_TEST_PR(vec)                                             \
-        KVMTEST(vec);                                                   \
+        KVMTEST(EXC_STD, vec);                                          \
         _SOFTEN_TEST(EXC_STD, vec)
 
 #define SOFTEN_TEST_HV(vec)                                             \
-        KVMTEST(vec);                                                   \
+        KVMTEST(EXC_HV, vec);                                           \
         _SOFTEN_TEST(EXC_HV, vec)
 
+#define KVMTEST_PR(vec)                                                 \
+        KVMTEST(EXC_STD, vec)
+
+#define KVMTEST_HV(vec)                                                 \
+        KVMTEST(EXC_HV, vec)
+
 #define SOFTEN_NOTEST_PR(vec)           _SOFTEN_TEST(EXC_STD, vec)
 #define SOFTEN_NOTEST_HV(vec)           _SOFTEN_TEST(EXC_HV, vec)
 
@@ -427,58 +414,47 @@ label##_relon_hv:						\
         SET_SCRATCH0(r13);    /* save r13 */                            \
         EXCEPTION_PROLOG_0(PACA_EXGEN);                                 \
         __EXCEPTION_PROLOG_1(PACA_EXGEN, extra, vec);                   \
-        EXCEPTION_PROLOG_PSERIES_1(label##_common, h);
+        EXCEPTION_PROLOG_PSERIES_1(label, h);
 
 #define _MASKABLE_EXCEPTION_PSERIES(vec, label, h, extra)               \
         __MASKABLE_EXCEPTION_PSERIES(vec, label, h, extra)
 
 #define MASKABLE_EXCEPTION_PSERIES(loc, vec, label)                     \
-        . = loc;                                                        \
-        .globl label##_pSeries;                                         \
-label##_pSeries:                                                        \
         _MASKABLE_EXCEPTION_PSERIES(vec, label,                         \
                                     EXC_STD, SOFTEN_TEST_PR)
 
+#define MASKABLE_EXCEPTION_PSERIES_OOL(vec, label)                      \
+        EXCEPTION_PROLOG_1(PACA_EXGEN, SOFTEN_TEST_PR, vec);            \
+        EXCEPTION_PROLOG_PSERIES_1(label, EXC_STD)
+
 #define MASKABLE_EXCEPTION_HV(loc, vec, label)                          \
-        . = loc;                                                        \
-        .globl label##_hv;                                              \
-label##_hv:                                                             \
         _MASKABLE_EXCEPTION_PSERIES(vec, label,                         \
                                     EXC_HV, SOFTEN_TEST_HV)
 
 #define MASKABLE_EXCEPTION_HV_OOL(vec, label)                           \
-        .globl label##_hv;                                              \
-label##_hv:                                                             \
         EXCEPTION_PROLOG_1(PACA_EXGEN, SOFTEN_TEST_HV, vec);            \
-        EXCEPTION_PROLOG_PSERIES_1(label##_common, EXC_HV);
+        EXCEPTION_PROLOG_PSERIES_1(label, EXC_HV)
 
 #define __MASKABLE_RELON_EXCEPTION_PSERIES(vec, label, h, extra)        \
         SET_SCRATCH0(r13);    /* save r13 */                            \
         EXCEPTION_PROLOG_0(PACA_EXGEN);                                 \
-        __EXCEPTION_PROLOG_1(PACA_EXGEN, extra, vec);           \
-        EXCEPTION_RELON_PROLOG_PSERIES_1(label##_common, h);
-#define _MASKABLE_RELON_EXCEPTION_PSERIES(vec, label, h, extra) \
+        __EXCEPTION_PROLOG_1(PACA_EXGEN, extra, vec);                   \
+        EXCEPTION_RELON_PROLOG_PSERIES_1(label, h)
+
+#define _MASKABLE_RELON_EXCEPTION_PSERIES(vec, label, h, extra)         \
         __MASKABLE_RELON_EXCEPTION_PSERIES(vec, label, h, extra)
 
 #define MASKABLE_RELON_EXCEPTION_PSERIES(loc, vec, label)               \
-        . = loc;                                                        \
-        .globl label##_relon_pSeries;                                   \
-label##_relon_pSeries:                                                  \
         _MASKABLE_RELON_EXCEPTION_PSERIES(vec, label,                   \
                                           EXC_STD, SOFTEN_NOTEST_PR)
 
 #define MASKABLE_RELON_EXCEPTION_HV(loc, vec, label)                    \
-        . = loc;                                                        \
-        .globl label##_relon_hv;                                        \
-label##_relon_hv:                                                       \
         _MASKABLE_RELON_EXCEPTION_PSERIES(vec, label,                   \
                                           EXC_HV, SOFTEN_NOTEST_HV)
 
 #define MASKABLE_RELON_EXCEPTION_HV_OOL(vec, label)                     \
-        .globl label##_relon_hv;                                        \
-label##_relon_hv:                                                       \
         EXCEPTION_PROLOG_1(PACA_EXGEN, SOFTEN_NOTEST_HV, vec);          \
-        EXCEPTION_PROLOG_PSERIES_1(label##_common, EXC_HV);
+        EXCEPTION_PROLOG_PSERIES_1(label, EXC_HV)
 
 /*
  * Our exception common code can be passed various "additions"
@@ -504,9 +480,6 @@ BEGIN_FTR_SECTION				\
 END_FTR_SECTION_IFSET(CPU_FTR_CTRL)
 
 #define EXCEPTION_COMMON(trap, label, hdlr, ret, additions)     \
-        .align  7;                                              \
-        .globl label##_common;                                  \
-label##_common:                                                 \
         EXCEPTION_PROLOG_COMMON(trap, PACA_EXGEN);              \
         /* Volatile regs are potentially clobbered here */      \
         additions;                                              \
diff --git a/arch/powerpc/include/asm/head-64.h b/arch/powerpc/include/asm/head-64.h
new file mode 100644
index 000000000000..358c25c80c62
--- /dev/null
+++ b/arch/powerpc/include/asm/head-64.h
@@ -0,0 +1,163 @@
+#ifndef _ASM_POWERPC_HEAD_64_H
+#define _ASM_POWERPC_HEAD_64_H
+
+#include <asm/cache.h>
+
+#define EXC_REAL_BEGIN(name, start, end)                        \
+        . = start ;                                                     \
+        .global exc_real_##start##_##name ;                             \
+exc_real_##start##_##name:
+
+#define EXC_REAL_END(name, start, end)
+
+#define EXC_VIRT_BEGIN(name, start, end)                        \
+        . = start ;                                                     \
+        .global exc_virt_##start##_##name ;                             \
+exc_virt_##start##_##name:
+
+#define EXC_VIRT_END(name, start, end)
+
+#define EXC_COMMON_BEGIN(name)                                  \
+        .global name;                                                   \
+name:
+
+#define TRAMP_REAL_BEGIN(name)                                  \
+        .global name ;                                                  \
+name:
+
+#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
+#define TRAMP_KVM_BEGIN(name)                                           \
+        TRAMP_REAL_BEGIN(name)
+#else
+#define TRAMP_KVM_BEGIN(name)
+#endif
+
+#define EXC_REAL_NONE(start, end)
+
+#define EXC_VIRT_NONE(start, end)
+
+
+#define EXC_REAL(name, start, end)                              \
+        EXC_REAL_BEGIN(name, start, end);                       \
+        STD_EXCEPTION_PSERIES(start, name##_common);                    \
+        EXC_REAL_END(name, start, end);
+
+#define EXC_VIRT(name, start, end, realvec)                     \
+        EXC_VIRT_BEGIN(name, start, end);                       \
+        STD_RELON_EXCEPTION_PSERIES(start, realvec, name##_common);     \
+        EXC_VIRT_END(name, start, end);
+
+#define EXC_REAL_MASKABLE(name, start, end)                     \
+        EXC_REAL_BEGIN(name, start, end);                       \
+        MASKABLE_EXCEPTION_PSERIES(start, start, name##_common);        \
+        EXC_REAL_END(name, start, end);
+
+#define EXC_VIRT_MASKABLE(name, start, end, realvec)            \
+        EXC_VIRT_BEGIN(name, start, end);                       \
+        MASKABLE_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \
+        EXC_VIRT_END(name, start, end);
+
+#define EXC_REAL_HV(name, start, end)                   \
+        EXC_REAL_BEGIN(name, start, end);                       \
+        STD_EXCEPTION_HV(start, start, name##_common);                  \
+        EXC_REAL_END(name, start, end);
+
+#define EXC_VIRT_HV(name, start, end, realvec)          \
+        EXC_VIRT_BEGIN(name, start, end);                       \
+        STD_RELON_EXCEPTION_HV(start, realvec, name##_common);          \
+        EXC_VIRT_END(name, start, end);
+
+#define __EXC_REAL_OOL(name, start, end)                        \
+        EXC_REAL_BEGIN(name, start, end);                       \
+        __OOL_EXCEPTION(start, label, tramp_real_##name);               \
+        EXC_REAL_END(name, start, end);
+
+#define __TRAMP_REAL_REAL_OOL(name, vec)                                \
+        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
+        STD_EXCEPTION_PSERIES_OOL(vec, name##_common);                  \
+
+#define __EXC_REAL_OOL_MASKABLE(name, start, end)               \
+        __EXC_REAL_OOL(name, start, end);
+
+#define __TRAMP_REAL_REAL_OOL_MASKABLE(name, vec)                       \
+        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
+        MASKABLE_EXCEPTION_PSERIES_OOL(vec, name##_common);             \
+
+#define __EXC_REAL_OOL_HV_DIRECT(name, start, end, handler)     \
+        EXC_REAL_BEGIN(name, start, end);                       \
+        __OOL_EXCEPTION(start, label, handler);                         \
+        EXC_REAL_END(name, start, end);
+
+#define __EXC_REAL_OOL_HV(name, start, end)                     \
+        __EXC_REAL_OOL(name, start, end);
+
+#define __TRAMP_REAL_REAL_OOL_HV(name, vec)                             \
+        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
+        STD_EXCEPTION_HV_OOL(vec, name##_common);                       \
+
+#define __EXC_REAL_OOL_MASKABLE_HV(name, start, end)            \
+        __EXC_REAL_OOL(name, start, end);
+
+#define __TRAMP_REAL_REAL_OOL_MASKABLE_HV(name, vec)                    \
+        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
+        MASKABLE_EXCEPTION_HV_OOL(vec, name##_common);                  \
+
+#define __EXC_VIRT_OOL(name, start, end)                        \
+        EXC_VIRT_BEGIN(name, start, end);                       \
+        __OOL_EXCEPTION(start, label, tramp_virt_##name);               \
+        EXC_VIRT_END(name, start, end);
+
+#define __TRAMP_REAL_VIRT_OOL(name, realvec)                            \
+        TRAMP_REAL_BEGIN(tramp_virt_##name);                            \
+        STD_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common);        \
+
+#define __EXC_VIRT_OOL_MASKABLE(name, start, end)               \
+        __EXC_VIRT_OOL(name, start, end);
+
+#define __TRAMP_REAL_VIRT_OOL_MASKABLE(name, realvec)           \
+        TRAMP_REAL_BEGIN(tramp_virt_##name);                            \
+        MASKABLE_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common);   \
+
+#define __EXC_VIRT_OOL_HV(name, start, end)                     \
+        __EXC_VIRT_OOL(name, start, end);
+
+#define __TRAMP_REAL_VIRT_OOL_HV(name, realvec)                 \
+        TRAMP_REAL_BEGIN(tramp_virt_##name);                            \
+        STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common);             \
+
+#define __EXC_VIRT_OOL_MASKABLE_HV(name, start, end)            \
+        __EXC_VIRT_OOL(name, start, end);
+
+#define __TRAMP_REAL_VIRT_OOL_MASKABLE_HV(name, realvec)                \
+        TRAMP_REAL_BEGIN(tramp_virt_##name);                            \
+        MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common);        \
+
+#define TRAMP_KVM(area, n)                                              \
+        TRAMP_KVM_BEGIN(do_kvm_##n);                                    \
+        KVM_HANDLER(area, EXC_STD, n);                                  \
+
+#define TRAMP_KVM_SKIP(area, n)                                         \
+        TRAMP_KVM_BEGIN(do_kvm_##n);                                    \
+        KVM_HANDLER_SKIP(area, EXC_STD, n);                             \
+
+#define TRAMP_KVM_HV(area, n)                                           \
+        TRAMP_KVM_BEGIN(do_kvm_H##n);                                   \
+        KVM_HANDLER(area, EXC_HV, n + 0x2);                             \
+
+#define TRAMP_KVM_HV_SKIP(area, n)                                      \
+        TRAMP_KVM_BEGIN(do_kvm_H##n);                                   \
+        KVM_HANDLER_SKIP(area, EXC_HV, n + 0x2);                        \
+
+#define EXC_COMMON(name, realvec, hdlr)                         \
+        EXC_COMMON_BEGIN(name);                                 \
+        STD_EXCEPTION_COMMON(realvec, name, hdlr);                      \
+
+#define EXC_COMMON_ASYNC(name, realvec, hdlr)                   \
+        EXC_COMMON_BEGIN(name);                                 \
+        STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr);                \
+
+#define EXC_COMMON_HV(name, realvec, hdlr)                              \
+        EXC_COMMON_BEGIN(name);                                 \
+        STD_EXCEPTION_COMMON(realvec + 0x2, name, hdlr);                \
+
+#endif  /* _ASM_POWERPC_HEAD_64_H */