powerpc/64s/exception: fix line wrap and semicolon inconsistencies in macros

By convention, all lines should be separated by a semicolons. Last line
should have neither semicolon or line wrap.

No generated code change.

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

diff --git a/arch/powerpc/include/asm/exception-64s.h b/arch/powerpc/include/asm/exception-64s.h
index bef4e05a6823dace27cd18a57f5b9d238874bb9b..b590765f6e45e2cf4c585d5874e5fcd869a69dfe 100644 (file)
--- a/arch/powerpc/include/asm/exception-64s.h
+++ b/arch/powerpc/include/asm/exception-64s.h
@@ -189,11 +189,11 @@
  */
 #define LOAD_HANDLER(reg, label)                                       \
        ld      reg,PACAKBASE(r13);     /* get high part of &label */   \
-       ori     reg,reg,FIXED_SYMBOL_ABS_ADDR(label);
+       ori     reg,reg,FIXED_SYMBOL_ABS_ADDR(label)
 
 #define __LOAD_HANDLER(reg, label)                                     \
        ld      reg,PACAKBASE(r13);                                     \
-       ori     reg,reg,(ABS_ADDR(label))@l;
+       ori     reg,reg,(ABS_ADDR(label))@l
 
 /*
  * Branches from unrelocated code (e.g., interrupts) to labels outside
@@ -202,7 +202,7 @@
 #define __LOAD_FAR_HANDLER(reg, label)                                 \
        ld      reg,PACAKBASE(r13);                                     \
        ori     reg,reg,(ABS_ADDR(label))@l;                            \
-       addis   reg,reg,(ABS_ADDR(label))@h;
+       addis   reg,reg,(ABS_ADDR(label))@h
 
 /* Exception register prefixes */
 #define EXC_HV H
@@ -277,7 +277,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
        OPT_SAVE_REG_TO_PACA(area+EX_CFAR, r10, CPU_FTR_CFAR);          \
        INTERRUPT_TO_KERNEL;                                            \
        SAVE_CTR(r10, area);                                            \
-       mfcr    r9;
+       mfcr    r9
 
 #define __EXCEPTION_PROLOG_1_POST(area)                                        \
        std     r11,area+EX_R11(r13);                                   \
@@ -294,7 +294,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 #define MASKABLE_EXCEPTION_PROLOG_1(area, extra, vec, bitmask)                 \
        __EXCEPTION_PROLOG_1_PRE(area);                                 \
        extra(vec, bitmask);                                            \
-       __EXCEPTION_PROLOG_1_POST(area);
+       __EXCEPTION_PROLOG_1_POST(area)
 
 /*
  * This version of the EXCEPTION_PROLOG_1 is intended
@@ -303,7 +303,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 #define _EXCEPTION_PROLOG_1(area, extra, vec)                          \
        __EXCEPTION_PROLOG_1_PRE(area);                                 \
        extra(vec);                                                     \
-       __EXCEPTION_PROLOG_1_POST(area);
+       __EXCEPTION_PROLOG_1_POST(area)
 
 #define EXCEPTION_PROLOG_1(area, extra, vec)                           \
        _EXCEPTION_PROLOG_1(area, extra, vec)
@@ -311,7 +311,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 #define __EXCEPTION_PROLOG_2(label, h)                                 \
        ld      r10,PACAKMSR(r13);      /* get MSR value for kernel */  \
        mfspr   r11,SPRN_##h##SRR0;     /* save SRR0 */                 \
-       LOAD_HANDLER(r12,label)                                         \
+       LOAD_HANDLER(r12,label);                                        \
        mtspr   SPRN_##h##SRR0,r12;                                     \
        mfspr   r12,SPRN_##h##SRR1;     /* and SRR1 */                  \
        mtspr   SPRN_##h##SRR1,r10;                                     \
@@ -325,7 +325,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
        ld      r10,PACAKMSR(r13);      /* get MSR value for kernel */  \
        xori    r10,r10,MSR_RI;         /* Clear MSR_RI */              \
        mfspr   r11,SPRN_##h##SRR0;     /* save SRR0 */                 \
-       LOAD_HANDLER(r12,label)                                         \
+       LOAD_HANDLER(r12,label);                                        \
        mtspr   SPRN_##h##SRR0,r12;                                     \
        mfspr   r12,SPRN_##h##SRR1;     /* and SRR1 */                  \
        mtspr   SPRN_##h##SRR1,r10;                                     \
@@ -339,7 +339,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
        SET_SCRATCH0(r13);              /* save r13 */                  \
        EXCEPTION_PROLOG_0(area);                                       \
        EXCEPTION_PROLOG_1(area, extra, vec);                           \
-       EXCEPTION_PROLOG_2(label, h);
+       EXCEPTION_PROLOG_2(label, h)
 
 #define __KVMTEST(h, n)                                                        \
        lbz     r10,HSTATE_IN_GUEST(r13);                               \
@@ -413,7 +413,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 #define EXCEPTION_PROLOG_NORI(area, label, h, extra, vec)              \
        EXCEPTION_PROLOG_0(area);                                       \
        EXCEPTION_PROLOG_1(area, extra, vec);                           \
-       EXCEPTION_PROLOG_2_NORI(label, h);
+       EXCEPTION_PROLOG_2_NORI(label, h)
 
 
 #define __KVM_HANDLER(area, h, n)                                      \
@@ -550,16 +550,16 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 
 /* 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;
+       SET_SCRATCH0(r13);                                      \
+       EXCEPTION_PROLOG_0(PACA_EXGEN);                         \
+       b hdlr
 
 #define STD_EXCEPTION_OOL(vec, label)                          \
        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST_PR, vec);        \
        EXCEPTION_PROLOG_2(label, EXC_STD)
 
 #define STD_EXCEPTION_HV(loc, vec, label)                      \
-       EXCEPTION_PROLOG(PACA_EXGEN, label, EXC_HV, KVMTEST_HV, vec);
+       EXCEPTION_PROLOG(PACA_EXGEN, label, EXC_HV, KVMTEST_HV, vec)
 
 #define STD_EXCEPTION_HV_OOL(vec, label)                       \
        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST_HV, vec);        \
@@ -567,14 +567,14 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 
 #define STD_RELON_EXCEPTION(loc, vec, label)           \
        /* No guest interrupts come through here */     \
-       EXCEPTION_RELON_PROLOG(PACA_EXGEN, label, EXC_STD, NOTEST, vec);
+       EXCEPTION_RELON_PROLOG(PACA_EXGEN, label, EXC_STD, NOTEST, vec)
 
 #define STD_RELON_EXCEPTION_OOL(vec, label)                    \
        EXCEPTION_PROLOG_1(PACA_EXGEN, NOTEST, vec);            \
        EXCEPTION_PROLOG_2_RELON(label, EXC_STD)
 
 #define STD_RELON_EXCEPTION_HV(loc, vec, label)                \
-       EXCEPTION_RELON_PROLOG(PACA_EXGEN, label, EXC_HV, KVMTEST_HV, vec);
+       EXCEPTION_RELON_PROLOG(PACA_EXGEN, label, EXC_HV, KVMTEST_HV, vec)
 
 #define STD_RELON_EXCEPTION_HV_OOL(vec, label)                 \
        EXCEPTION_PROLOG_1(PACA_EXGEN, KVMTEST_HV, vec);        \
@@ -619,7 +619,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
        SET_SCRATCH0(r13);    /* save r13 */                            \
        EXCEPTION_PROLOG_0(PACA_EXGEN);                                 \
        MASKABLE_EXCEPTION_PROLOG_1(PACA_EXGEN, extra, vec, bitmask);   \
-       EXCEPTION_PROLOG_2(label, h);
+       EXCEPTION_PROLOG_2(label, h)
 
 #define MASKABLE_EXCEPTION(vec, label, bitmask)                                \
        __MASKABLE_EXCEPTION(vec, label, EXC_STD, SOFTEN_TEST_PR, bitmask)
@@ -646,7 +646,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 
 #define MASKABLE_RELON_EXCEPTION_OOL(vec, label, bitmask)              \
        MASKABLE_EXCEPTION_PROLOG_1(PACA_EXGEN, SOFTEN_NOTEST_PR, vec, bitmask);\
-       EXCEPTION_PROLOG_2(label, EXC_STD);
+       EXCEPTION_PROLOG_2(label, EXC_STD)
 
 #define MASKABLE_RELON_EXCEPTION_HV(vec, label, bitmask)               \
        __MASKABLE_RELON_EXCEPTION(vec, label, EXC_HV, SOFTEN_TEST_HV, bitmask)

diff --git a/arch/powerpc/include/asm/head-64.h b/arch/powerpc/include/asm/head-64.h
index a4f9478887440340b6dbb487662d5119d7375f20..e34b3d06bf61063fb64bcd4b3c37575d34e7597c 100644 (file)
--- a/arch/powerpc/include/asm/head-64.h
+++ b/arch/powerpc/include/asm/head-64.h
@@ -255,135 +255,135 @@ name:
 
 #define EXC_VIRT_NONE(start, size)                             \
        FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); \
-       FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size);
+       FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size)
 
 
 #define EXC_REAL(name, start, size)                                    \
        EXC_REAL_BEGIN(name, start, size);                              \
        STD_EXCEPTION(start, name##_common);                            \
-       EXC_REAL_END(name, start, size);
+       EXC_REAL_END(name, start, size)
 
 #define EXC_VIRT(name, start, size, realvec)                           \
        EXC_VIRT_BEGIN(name, start, size);                              \
        STD_RELON_EXCEPTION(start, realvec, name##_common);             \
-       EXC_VIRT_END(name, start, size);
+       EXC_VIRT_END(name, start, size)
 
 #define EXC_REAL_MASKABLE(name, start, size, bitmask)                  \
        EXC_REAL_BEGIN(name, start, size);                              \
        MASKABLE_EXCEPTION(start, name##_common, bitmask);              \
-       EXC_REAL_END(name, start, size);
+       EXC_REAL_END(name, start, size)
 
 #define EXC_VIRT_MASKABLE(name, start, size, realvec, bitmask)         \
        EXC_VIRT_BEGIN(name, start, size);                              \
        MASKABLE_RELON_EXCEPTION(realvec, name##_common, bitmask);      \
-       EXC_VIRT_END(name, start, size);
+       EXC_VIRT_END(name, start, size)
 
 #define EXC_REAL_HV(name, start, size)                                 \
        EXC_REAL_BEGIN(name, start, size);                              \
        STD_EXCEPTION_HV(start, start, name##_common);                  \
-       EXC_REAL_END(name, start, size);
+       EXC_REAL_END(name, start, size)
 
 #define EXC_VIRT_HV(name, start, size, realvec)                                \
        EXC_VIRT_BEGIN(name, start, size);                              \
        STD_RELON_EXCEPTION_HV(start, realvec, name##_common);          \
-       EXC_VIRT_END(name, start, size);
+       EXC_VIRT_END(name, start, size)
 
 #define __EXC_REAL_OOL(name, start, size)                              \
        EXC_REAL_BEGIN(name, start, size);                              \
        __OOL_EXCEPTION(start, label, tramp_real_##name);               \
-       EXC_REAL_END(name, start, size);
+       EXC_REAL_END(name, start, size)
 
 #define __TRAMP_REAL_OOL(name, vec)                                    \
        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
-       STD_EXCEPTION_OOL(vec, name##_common);
+       STD_EXCEPTION_OOL(vec, name##_common)
 
 #define EXC_REAL_OOL(name, start, size)                                        \
        __EXC_REAL_OOL(name, start, size);                              \
-       __TRAMP_REAL_OOL(name, start);
+       __TRAMP_REAL_OOL(name, start)
 
 #define __EXC_REAL_OOL_MASKABLE(name, start, size)                     \
-       __EXC_REAL_OOL(name, start, size);
+       __EXC_REAL_OOL(name, start, size)
 
 #define __TRAMP_REAL_OOL_MASKABLE(name, vec, bitmask)                  \
        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
-       MASKABLE_EXCEPTION_OOL(vec, name##_common, bitmask);
+       MASKABLE_EXCEPTION_OOL(vec, name##_common, bitmask)
 
 #define EXC_REAL_OOL_MASKABLE(name, start, size, bitmask)              \
        __EXC_REAL_OOL_MASKABLE(name, start, size);                     \
-       __TRAMP_REAL_OOL_MASKABLE(name, start, bitmask);
+       __TRAMP_REAL_OOL_MASKABLE(name, start, bitmask)
 
 #define __EXC_REAL_OOL_HV_DIRECT(name, start, size, handler)           \
        EXC_REAL_BEGIN(name, start, size);                              \
        __OOL_EXCEPTION(start, label, handler);                         \
-       EXC_REAL_END(name, start, size);
+       EXC_REAL_END(name, start, size)
 
 #define __EXC_REAL_OOL_HV(name, start, size)                           \
-       __EXC_REAL_OOL(name, start, size);
+       __EXC_REAL_OOL(name, start, size)
 
 #define __TRAMP_REAL_OOL_HV(name, vec)                                 \
        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
-       STD_EXCEPTION_HV_OOL(vec, name##_common);                       \
+       STD_EXCEPTION_HV_OOL(vec, name##_common)
 
 #define EXC_REAL_OOL_HV(name, start, size)                             \
        __EXC_REAL_OOL_HV(name, start, size);                           \
-       __TRAMP_REAL_OOL_HV(name, start);
+       __TRAMP_REAL_OOL_HV(name, start)
 
 #define __EXC_REAL_OOL_MASKABLE_HV(name, start, size)                  \
-       __EXC_REAL_OOL(name, start, size);
+       __EXC_REAL_OOL(name, start, size)
 
 #define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec, bitmask)               \
        TRAMP_REAL_BEGIN(tramp_real_##name);                            \
-       MASKABLE_EXCEPTION_HV_OOL(vec, name##_common, bitmask);         \
+       MASKABLE_EXCEPTION_HV_OOL(vec, name##_common, bitmask)
 
 #define EXC_REAL_OOL_MASKABLE_HV(name, start, size, bitmask)           \
        __EXC_REAL_OOL_MASKABLE_HV(name, start, size);                  \
-       __TRAMP_REAL_OOL_MASKABLE_HV(name, start, bitmask);
+       __TRAMP_REAL_OOL_MASKABLE_HV(name, start, bitmask)
 
 #define __EXC_VIRT_OOL(name, start, size)                              \
        EXC_VIRT_BEGIN(name, start, size);                              \
        __OOL_EXCEPTION(start, label, tramp_virt_##name);               \
-       EXC_VIRT_END(name, start, size);
+       EXC_VIRT_END(name, start, size)
 
 #define __TRAMP_VIRT_OOL(name, realvec)                                        \
        TRAMP_VIRT_BEGIN(tramp_virt_##name);                            \
-       STD_RELON_EXCEPTION_OOL(realvec, name##_common);
+       STD_RELON_EXCEPTION_OOL(realvec, name##_common)
 
 #define EXC_VIRT_OOL(name, start, size, realvec)                       \
        __EXC_VIRT_OOL(name, start, size);                              \
-       __TRAMP_VIRT_OOL(name, realvec);
+       __TRAMP_VIRT_OOL(name, realvec)
 
 #define __EXC_VIRT_OOL_MASKABLE(name, start, size)                     \
-       __EXC_VIRT_OOL(name, start, size);
+       __EXC_VIRT_OOL(name, start, size)
 
 #define __TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask)              \
        TRAMP_VIRT_BEGIN(tramp_virt_##name);                            \
-       MASKABLE_RELON_EXCEPTION_OOL(realvec, name##_common, bitmask);
+       MASKABLE_RELON_EXCEPTION_OOL(realvec, name##_common, bitmask)
 
 #define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec, bitmask)     \
        __EXC_VIRT_OOL_MASKABLE(name, start, size);                     \
-       __TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask);
+       __TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask)
 
 #define __EXC_VIRT_OOL_HV(name, start, size)                           \
-       __EXC_VIRT_OOL(name, start, size);
+       __EXC_VIRT_OOL(name, start, size)
 
 #define __TRAMP_VIRT_OOL_HV(name, realvec)                             \
        TRAMP_VIRT_BEGIN(tramp_virt_##name);                            \
-       STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common);             \
+       STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common)
 
 #define EXC_VIRT_OOL_HV(name, start, size, realvec)                    \
        __EXC_VIRT_OOL_HV(name, start, size);                           \
-       __TRAMP_VIRT_OOL_HV(name, realvec);
+       __TRAMP_VIRT_OOL_HV(name, realvec)
 
 #define __EXC_VIRT_OOL_MASKABLE_HV(name, start, size)                  \
-       __EXC_VIRT_OOL(name, start, size);
+       __EXC_VIRT_OOL(name, start, size)
 
 #define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask)           \
        TRAMP_VIRT_BEGIN(tramp_virt_##name);                            \
-       MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common, bitmask);\
+       MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common, bitmask)
 
 #define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec, bitmask)  \
        __EXC_VIRT_OOL_MASKABLE_HV(name, start, size);                  \
-       __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask);
+       __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask)
 
 #define TRAMP_KVM(area, n)                                             \
        TRAMP_KVM_BEGIN(do_kvm_##n);                                    \
@@ -406,11 +406,11 @@ name:
 
 #define EXC_COMMON(name, realvec, hdlr)                                        \
        EXC_COMMON_BEGIN(name);                                         \
-       STD_EXCEPTION_COMMON(realvec, name, hdlr);                      \
+       STD_EXCEPTION_COMMON(realvec, name, hdlr)
 
 #define EXC_COMMON_ASYNC(name, realvec, hdlr)                          \
        EXC_COMMON_BEGIN(name);                                         \
-       STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr);                \
+       STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr)
 
 #endif /* __ASSEMBLY__ */