[S390] Whitespace cleanup.

Huge s390 assembly files whitespace cleanup.

Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 234 insertions, 235 deletions

diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index 0c712b78a7e8..dddc3de30401 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -4,8 +4,8 @@
  *
  *    Copyright (C) IBM Corp. 1999,2006
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
- *               Hartmut Penner (hp@de.ibm.com),
- *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
+ *               Hartmut Penner (hp@de.ibm.com),
+ *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
  *               Heiko Carstens <heiko.carstens@de.ibm.com>
  */
 
@@ -24,29 +24,29 @@
  * Stack layout for the system_call stack entry.
  * The first few entries are identical to the user_regs_struct.
  */
-SP_PTREGS    =  STACK_FRAME_OVERHEAD
-SP_ARGS      =  STACK_FRAME_OVERHEAD + __PT_ARGS
-SP_PSW       =  STACK_FRAME_OVERHEAD + __PT_PSW
-SP_R0        =  STACK_FRAME_OVERHEAD + __PT_GPRS
-SP_R1        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 4
-SP_R2        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 8
-SP_R3        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 12
-SP_R4        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 16
-SP_R5        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 20
-SP_R6        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 24
-SP_R7        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 28
-SP_R8        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 32
-SP_R9        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 36
-SP_R10       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 40
-SP_R11       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 44
-SP_R12       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 48
-SP_R13       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 52
-SP_R14       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 56
-SP_R15       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 60
-SP_ORIG_R2   =  STACK_FRAME_OVERHEAD + __PT_ORIG_GPR2
-SP_ILC       =  STACK_FRAME_OVERHEAD + __PT_ILC
-SP_TRAP      =  STACK_FRAME_OVERHEAD + __PT_TRAP
-SP_SIZE      =  STACK_FRAME_OVERHEAD + __PT_SIZE
+SP_PTREGS    =  STACK_FRAME_OVERHEAD
+SP_ARGS      =  STACK_FRAME_OVERHEAD + __PT_ARGS
+SP_PSW       =  STACK_FRAME_OVERHEAD + __PT_PSW
+SP_R0        =  STACK_FRAME_OVERHEAD + __PT_GPRS
+SP_R1        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 4
+SP_R2        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 8
+SP_R3        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 12
+SP_R4        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 16
+SP_R5        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 20
+SP_R6        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 24
+SP_R7        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 28
+SP_R8        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 32
+SP_R9        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 36
+SP_R10       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 40
+SP_R11       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 44
+SP_R12       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 48
+SP_R13       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 52
+SP_R14       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 56
+SP_R15       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 60
+SP_ORIG_R2   =  STACK_FRAME_OVERHEAD + __PT_ORIG_GPR2
+SP_ILC       =  STACK_FRAME_OVERHEAD + __PT_ILC
+SP_TRAP      =  STACK_FRAME_OVERHEAD + __PT_TRAP
+SP_SIZE      =  STACK_FRAME_OVERHEAD + __PT_SIZE
 
 _TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK | _TIF_NEED_RESCHED | \
                  _TIF_MCCK_PENDING | _TIF_RESTART_SVC | _TIF_SINGLE_STEP )
@@ -81,14 +81,14 @@ STACK_SIZE  = 1 << STACK_SHIFT
  *    R15 - kernel stack pointer
  */
 
-        .macro  STORE_TIMER lc_offset
+        .macro  STORE_TIMER lc_offset
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
         stpt    \lc_offset
 #endif
         .endm
 
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
-        .macro  UPDATE_VTIME lc_from,lc_to,lc_sum
+        .macro  UPDATE_VTIME lc_from,lc_to,lc_sum
         lm      %r10,%r11,\lc_from
         sl      %r10,\lc_to
         sl      %r11,\lc_to+4
@@ -147,7 +147,7 @@ STACK_SIZE  = 1 << STACK_SHIFT
 2:
         .endm
 
-        .macro  CREATE_STACK_FRAME psworg,savearea
+        .macro  CREATE_STACK_FRAME psworg,savearea
         s       %r15,BASED(.Lc_spsize)  # make room for registers & psw
         mvc     SP_PSW(8,%r15),0(%r12)  # move user PSW to stack
         la      %r12,\psworg
@@ -160,7 +160,7 @@ STACK_SIZE  = 1 << STACK_SHIFT
         st      %r12,__SF_BACKCHAIN(%r15)       # clear back chain
         .endm
 
-        .macro  RESTORE_ALL psworg,sync
+        .macro  RESTORE_ALL psworg,sync
         mvc     \psworg(8),SP_PSW(%r15) # move user PSW to lowcore
         .if !\sync
         ni      \psworg+1,0xfd          # clear wait state bit
@@ -177,16 +177,16 @@ STACK_SIZE  = 1 << STACK_SHIFT
  * Returns:
  *  gpr2 = prev
  */
-        .globl  __switch_to
+        .globl  __switch_to
 __switch_to:
-        basr    %r1,0
+        basr    %r1,0
 __switch_to_base:
         tm      __THREAD_per(%r3),0xe8          # new process is using per ?
         bz      __switch_to_noper-__switch_to_base(%r1) # if not we're fine
-        stctl   %c9,%c11,__SF_EMPTY(%r15)       # We are using per stuff
-        clc     __THREAD_per(12,%r3),__SF_EMPTY(%r15)
-        be      __switch_to_noper-__switch_to_base(%r1) # we got away w/o bashing TLB's
-        lctl    %c9,%c11,__THREAD_per(%r3)      # Nope we didn't
+        stctl   %c9,%c11,__SF_EMPTY(%r15)       # We are using per stuff
+        clc     __THREAD_per(12,%r3),__SF_EMPTY(%r15)
+        be      __switch_to_noper-__switch_to_base(%r1) # we got away w/o bashing TLB's
+        lctl    %c9,%c11,__THREAD_per(%r3)      # Nope we didn't
 __switch_to_noper:
         l       %r4,__THREAD_info(%r2)          # get thread_info of prev
         tm      __TI_flags+3(%r4),_TIF_MCCK_PENDING # machine check pending?
@@ -195,13 +195,13 @@ __switch_to_noper:
         l       %r4,__THREAD_info(%r3)          # get thread_info of next
         oi      __TI_flags+3(%r4),_TIF_MCCK_PENDING # set it in next
 __switch_to_no_mcck:
-        stm     %r6,%r15,__SF_GPRS(%r15)# store __switch_to registers of prev task
+        stm     %r6,%r15,__SF_GPRS(%r15)# store __switch_to registers of prev task
         st      %r15,__THREAD_ksp(%r2)  # store kernel stack to prev->tss.ksp
         l       %r15,__THREAD_ksp(%r3)  # load kernel stack from next->tss.ksp
         lm      %r6,%r15,__SF_GPRS(%r15)# load __switch_to registers of next task
         st      %r3,__LC_CURRENT        # __LC_CURRENT = current task struct
         lctl    %c4,%c4,__TASK_pid(%r3) # load pid to control reg. 4
-        l       %r3,__THREAD_info(%r3)  # load thread_info from task struct
+        l       %r3,__THREAD_info(%r3)  # load thread_info from task struct
         st      %r3,__LC_THREAD_INFO
         ahi     %r3,STACK_SIZE
         st      %r3,__LC_KERNEL_STACK   # __LC_KERNEL_STACK = new kernel stack
@@ -213,7 +213,7 @@ __critical_start:
  * are executed with interrupts enabled.
  */
 
-        .globl  system_call
+        .globl  system_call
 system_call:
         STORE_TIMER __LC_SYNC_ENTER_TIMER
 sysc_saveall:
@@ -233,24 +233,24 @@ sysc_update:
 #endif
 sysc_do_svc:
         l       %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
-        sla     %r7,2             # *4 and test for svc 0
-        bnz     BASED(sysc_nr_ok) # svc number > 0
+        sla     %r7,2                   # *4 and test for svc 0
+        bnz     BASED(sysc_nr_ok)       # svc number > 0
         # svc 0: system call number in %r1
         cl      %r1,BASED(.Lnr_syscalls)
         bnl     BASED(sysc_nr_ok)
-        lr      %r7,%r1           # copy svc number to %r7
-        sla     %r7,2             # *4
+        lr      %r7,%r1           # copy svc number to %r7
+        sla     %r7,2             # *4
 sysc_nr_ok:
         mvc     SP_ARGS(4,%r15),SP_R7(%r15)
 sysc_do_restart:
         l       %r8,BASED(.Lsysc_table)
         tm      __TI_flags+3(%r9),(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT)
         l       %r8,0(%r7,%r8)    # get system call addr.
-        bnz     BASED(sysc_tracesys)
-        basr    %r14,%r8          # call sys_xxxx
-        st      %r2,SP_R2(%r15)   # store return value (change R2 on stack)
-                                  # ATTENTION: check sys_execve_glue before
-                                  # changing anything here !!
+        bnz     BASED(sysc_tracesys)
+        basr    %r14,%r8          # call sys_xxxx
+        st      %r2,SP_R2(%r15)   # store return value (change R2 on stack)
+                                  # ATTENTION: check sys_execve_glue before
+                                  # changing anything here !!
 
 sysc_return:
         tm      SP_PSW+1(%r15),0x01     # returning to user ?
@@ -258,14 +258,14 @@ sysc_return:
         tm      __TI_flags+3(%r9),_TIF_WORK_SVC
         bnz     BASED(sysc_work)  # there is work to do (signals etc.)
 sysc_leave:
-        RESTORE_ALL __LC_RETURN_PSW,1
+        RESTORE_ALL __LC_RETURN_PSW,1
 
 #
 # recheck if there is more work to do
 #
 sysc_work_loop:
         tm      __TI_flags+3(%r9),_TIF_WORK_SVC
-        bz      BASED(sysc_leave)      # there is no work to do
+        bz      BASED(sysc_leave)       # there is no work to do
 #
 # One of the work bits is on. Find out which one.
 #
@@ -284,11 +284,11 @@ sysc_work:
 
 #
 # _TIF_NEED_RESCHED is set, call schedule
-#       
-sysc_reschedule:        
-        l       %r1,BASED(.Lschedule)
-        la      %r14,BASED(sysc_work_loop)
-        br      %r1                    # call scheduler
+#
+sysc_reschedule:
+        l       %r1,BASED(.Lschedule)
+        la      %r14,BASED(sysc_work_loop)
+        br      %r1                     # call scheduler
 
 #
 # _TIF_MCCK_PENDING is set, call handler
@@ -301,11 +301,11 @@ sysc_mcck_pending:
 #
 # _TIF_SIGPENDING or _TIF_RESTORE_SIGMASK is set, call do_signal
 #
-sysc_sigpending:     
+sysc_sigpending:
         ni      __TI_flags+3(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        l       %r1,BASED(.Ldo_signal)
-        basr    %r14,%r1               # call do_signal
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        l       %r1,BASED(.Ldo_signal)
+        basr    %r14,%r1                # call do_signal
         tm      __TI_flags+3(%r9),_TIF_RESTART_SVC
         bo      BASED(sysc_restart)
         tm      __TI_flags+3(%r9),_TIF_SINGLE_STEP
@@ -317,11 +317,11 @@ sysc_sigpending:
 #
 sysc_restart:
         ni      __TI_flags+3(%r9),255-_TIF_RESTART_SVC # clear TIF_RESTART_SVC
-        l       %r7,SP_R2(%r15)        # load new svc number
+        l       %r7,SP_R2(%r15)         # load new svc number
         sla     %r7,2
         mvc     SP_R2(4,%r15),SP_ORIG_R2(%r15) # restore first argument
-        lm      %r2,%r6,SP_R2(%r15)    # load svc arguments
-        b       BASED(sysc_do_restart) # restart svc
+        lm      %r2,%r6,SP_R2(%r15)     # load svc arguments
+        b       BASED(sysc_do_restart)  # restart svc
 
 #
 # _TIF_SINGLE_STEP is set, call do_single_step
@@ -338,8 +338,8 @@ sysc_singlestep:
 # call trace before and after sys_call
 #
 sysc_tracesys:
-        l       %r1,BASED(.Ltrace)
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
+        l       %r1,BASED(.Ltrace)
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
         la      %r3,0
         srl     %r7,2
         st      %r7,SP_R2(%r15)
@@ -347,19 +347,19 @@ sysc_tracesys:
         clc     SP_R2(4,%r15),BASED(.Lnr_syscalls)
         bnl     BASED(sysc_tracenogo)
         l       %r8,BASED(.Lsysc_table)
-        l       %r7,SP_R2(%r15)        # strace might have changed the 
-        sll     %r7,2                  #  system call
+        l       %r7,SP_R2(%r15)         # strace might have changed the
+        sll     %r7,2                   #  system call
         l       %r8,0(%r7,%r8)
 sysc_tracego:
         lm      %r3,%r6,SP_R3(%r15)
         l       %r2,SP_ORIG_R2(%r15)
-        basr    %r14,%r8          # call sys_xxx
-        st      %r2,SP_R2(%r15)   # store return value
+        basr    %r14,%r8                # call sys_xxx
+        st      %r2,SP_R2(%r15)         # store return value
 sysc_tracenogo:
         tm      __TI_flags+3(%r9),(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT)
-        bz      BASED(sysc_return)
+        bz      BASED(sysc_return)
         l       %r1,BASED(.Ltrace)
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
         la      %r3,1
         la      %r14,BASED(sysc_return)
         br      %r1
@@ -367,17 +367,17 @@ sysc_tracenogo:
 #
 # a new process exits the kernel with ret_from_fork
 #
-        .globl  ret_from_fork
+        .globl  ret_from_fork
 ret_from_fork:
         l       %r13,__LC_SVC_NEW_PSW+4
         l       %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
         tm      SP_PSW+1(%r15),0x01     # forking a kernel thread ?
         bo      BASED(0f)
         st      %r15,SP_R15(%r15)       # store stack pointer for new kthread
-0:      l       %r1,BASED(.Lschedtail)
-        basr    %r14,%r1
+0:      l       %r1,BASED(.Lschedtail)
+        basr    %r14,%r1
         TRACE_IRQS_ON
-        stosm   __SF_EMPTY(%r15),0x03     # reenable interrupts
+        stosm   __SF_EMPTY(%r15),0x03   # reenable interrupts
         b       BASED(sysc_return)
 
 #
@@ -386,52 +386,51 @@ ret_from_fork:
 # but are called with different parameter.
 # return-address is set up above
 #
-sys_clone_glue: 
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        l       %r1,BASED(.Lclone)
-        br      %r1                   # branch to sys_clone
-
-sys_fork_glue:  
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        l       %r1,BASED(.Lfork)
-        br      %r1                   # branch to sys_fork
-
-sys_vfork_glue: 
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        l       %r1,BASED(.Lvfork)
-        br      %r1                   # branch to sys_vfork
-
-sys_execve_glue:        
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs
-        l       %r1,BASED(.Lexecve)
-        lr      %r12,%r14             # save return address
-        basr    %r14,%r1              # call sys_execve
-        ltr     %r2,%r2               # check if execve failed
-        bnz     0(%r12)               # it did fail -> store result in gpr2
-        b       4(%r12)               # SKIP ST 2,SP_R2(15) after BASR 14,8
-                                      # in system_call/sysc_tracesys
-
-sys_sigreturn_glue:     
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter
-        l       %r1,BASED(.Lsigreturn)
-        br      %r1                   # branch to sys_sigreturn
-
-sys_rt_sigreturn_glue:     
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter
-        l       %r1,BASED(.Lrt_sigreturn)
-        br      %r1                   # branch to sys_sigreturn
+sys_clone_glue:
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        l       %r1,BASED(.Lclone)
+        br      %r1                     # branch to sys_clone
 
-sys_sigaltstack_glue:
-        la      %r4,SP_PTREGS(%r15)   # load pt_regs as parameter
-        l       %r1,BASED(.Lsigaltstack)
-        br      %r1                   # branch to sys_sigreturn
+sys_fork_glue:
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        l       %r1,BASED(.Lfork)
+        br      %r1                     # branch to sys_fork
 
+sys_vfork_glue:
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        l       %r1,BASED(.Lvfork)
+        br      %r1                     # branch to sys_vfork
+
+sys_execve_glue:
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        l       %r1,BASED(.Lexecve)
+        lr      %r12,%r14               # save return address
+        basr    %r14,%r1                # call sys_execve
+        ltr     %r2,%r2                 # check if execve failed
+        bnz     0(%r12)                 # it did fail -> store result in gpr2
+        b       4(%r12)                 # SKIP ST 2,SP_R2(15) after BASR 14,8
+                                        # in system_call/sysc_tracesys
+
+sys_sigreturn_glue:
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs as parameter
+        l       %r1,BASED(.Lsigreturn)
+        br      %r1                     # branch to sys_sigreturn
+
+sys_rt_sigreturn_glue:
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs as parameter
+        l       %r1,BASED(.Lrt_sigreturn)
+        br      %r1                     # branch to sys_sigreturn
+
+sys_sigaltstack_glue:
+        la      %r4,SP_PTREGS(%r15)     # load pt_regs as parameter
+        l       %r1,BASED(.Lsigaltstack)
+        br      %r1                     # branch to sys_sigreturn
 
 /*
  * Program check handler routine
  */
 
-        .globl  pgm_check_handler
+        .globl  pgm_check_handler
 pgm_check_handler:
 /*
  * First we need to check for a special case:
@@ -448,8 +447,8 @@ pgm_check_handler:
  */
         STORE_TIMER __LC_SYNC_ENTER_TIMER
         SAVE_ALL_BASE __LC_SAVE_AREA
-        tm      __LC_PGM_INT_CODE+1,0x80 # check whether we got a per exception
-        bnz     BASED(pgm_per)           # got per exception -> special case
+        tm      __LC_PGM_INT_CODE+1,0x80 # check whether we got a per exception
+        bnz     BASED(pgm_per)          # got per exception -> special case
         SAVE_ALL_SYNC __LC_PGM_OLD_PSW,__LC_SAVE_AREA
         CREATE_STACK_FRAME __LC_PGM_OLD_PSW,__LC_SAVE_AREA
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
@@ -461,29 +460,29 @@ pgm_check_handler:
 pgm_no_vtime:
 #endif
         l       %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
-        l       %r3,__LC_PGM_ILC         # load program interruption code
+        l       %r3,__LC_PGM_ILC        # load program interruption code
         la      %r8,0x7f
         nr      %r8,%r3
 pgm_do_call:
-        l       %r7,BASED(.Ljump_table)
-        sll     %r8,2
-        l       %r7,0(%r8,%r7)           # load address of handler routine
-        la      %r2,SP_PTREGS(%r15)      # address of register-save area
-        la      %r14,BASED(sysc_return)
-        br      %r7                      # branch to interrupt-handler
+        l       %r7,BASED(.Ljump_table)
+        sll     %r8,2
+        l       %r7,0(%r8,%r7)          # load address of handler routine
+        la      %r2,SP_PTREGS(%r15)     # address of register-save area
+        la      %r14,BASED(sysc_return)
+        br      %r7                     # branch to interrupt-handler
 
 #
 # handle per exception
 #
 pgm_per:
-        tm      __LC_PGM_OLD_PSW,0x40    # test if per event recording is on
-        bnz     BASED(pgm_per_std)       # ok, normal per event from user space
+        tm      __LC_PGM_OLD_PSW,0x40   # test if per event recording is on
+        bnz     BASED(pgm_per_std)      # ok, normal per event from user space
 # ok its one of the special cases, now we need to find out which one
-        clc     __LC_PGM_OLD_PSW(8),__LC_SVC_NEW_PSW
-        be      BASED(pgm_svcper)
+        clc     __LC_PGM_OLD_PSW(8),__LC_SVC_NEW_PSW
+        be      BASED(pgm_svcper)
 # no interesting special case, ignore PER event
-        lm      %r12,%r15,__LC_SAVE_AREA
-        lpsw    0x28
+        lm      %r12,%r15,__LC_SAVE_AREA
+        lpsw    0x28
 
 #
 # Normal per exception
@@ -507,10 +506,10 @@ pgm_no_vtime2:
         oi      __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP
         tm      SP_PSW+1(%r15),0x01     # kernel per event ?
         bz      BASED(kernel_per)
-        l       %r3,__LC_PGM_ILC         # load program interruption code
+        l       %r3,__LC_PGM_ILC        # load program interruption code
         la      %r8,0x7f
-        nr      %r8,%r3                  # clear per-event-bit and ilc
-        be      BASED(sysc_return)       # only per or per+check ?
+        nr      %r8,%r3                 # clear per-event-bit and ilc
+        be      BASED(sysc_return)      # only per or per+check ?
         b       BASED(pgm_do_call)
 
 #
@@ -552,7 +551,7 @@ kernel_per:
  * IO interrupt handler routine
  */
 
-        .globl io_int_handler
+        .globl io_int_handler
 io_int_handler:
         STORE_TIMER __LC_ASYNC_ENTER_TIMER
         stck    __LC_INT_CLOCK
@@ -569,42 +568,42 @@ io_no_vtime:
 #endif
         l       %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
         TRACE_IRQS_OFF
-        l       %r1,BASED(.Ldo_IRQ)        # load address of do_IRQ
-        la      %r2,SP_PTREGS(%r15) # address of register-save area
-        basr    %r14,%r1          # branch to standard irq handler
+        l       %r1,BASED(.Ldo_IRQ)     # load address of do_IRQ
+        la      %r2,SP_PTREGS(%r15)     # address of register-save area
+        basr    %r14,%r1                # branch to standard irq handler
         TRACE_IRQS_ON
 
 io_return:
-        tm      SP_PSW+1(%r15),0x01    # returning to user ?
+        tm      SP_PSW+1(%r15),0x01     # returning to user ?
 #ifdef CONFIG_PREEMPT
-        bno     BASED(io_preempt)      # no -> check for preemptive scheduling
+        bno     BASED(io_preempt)       # no -> check for preemptive scheduling
 #else
-        bno     BASED(io_leave)        # no-> skip resched & signal
+        bno     BASED(io_leave)         # no-> skip resched & signal
 #endif
         tm      __TI_flags+3(%r9),_TIF_WORK_INT
-        bnz     BASED(io_work)         # there is work to do (signals etc.)
+        bnz     BASED(io_work)          # there is work to do (signals etc.)
 io_leave:
-        RESTORE_ALL __LC_RETURN_PSW,0
+        RESTORE_ALL __LC_RETURN_PSW,0
 io_done:
 
 #ifdef CONFIG_PREEMPT
 io_preempt:
         icm     %r0,15,__TI_precount(%r9)
-        bnz     BASED(io_leave)
+        bnz     BASED(io_leave)
         l       %r1,SP_R15(%r15)
         s       %r1,BASED(.Lc_spsize)
         mvc     SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15)
-        xc      __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1) # clear back chain
+        xc      __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1) # clear back chain
         lr      %r15,%r1
 io_resume_loop:
         tm      __TI_flags+3(%r9),_TIF_NEED_RESCHED
         bno     BASED(io_leave)
-        mvc     __TI_precount(4,%r9),BASED(.Lc_pactive)
-        stosm   __SF_EMPTY(%r15),0x03  # reenable interrupts
-        l       %r1,BASED(.Lschedule)
+        mvc     __TI_precount(4,%r9),BASED(.Lc_pactive)
+        stosm   __SF_EMPTY(%r15),0x03  # reenable interrupts
+        l       %r1,BASED(.Lschedule)
         basr    %r14,%r1               # call schedule
-        stnsm   __SF_EMPTY(%r15),0xfc  # disable I/O and ext. interrupts
-        xc      __TI_precount(4,%r9),__TI_precount(%r9)
+        stnsm   __SF_EMPTY(%r15),0xfc  # disable I/O and ext. interrupts
+        xc      __TI_precount(4,%r9),__TI_precount(%r9)
         b       BASED(io_resume_loop)
 #endif
 
@@ -615,16 +614,16 @@ io_work:
         l       %r1,__LC_KERNEL_STACK
         s       %r1,BASED(.Lc_spsize)
         mvc     SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15)
-        xc      __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1) # clear back chain
+        xc      __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1) # clear back chain
         lr      %r15,%r1
 #
 # One of the work bits is on. Find out which one.
 # Checked are: _TIF_SIGPENDING, _TIF_RESTORE_SIGMASK, _TIF_NEED_RESCHED
-#               and _TIF_MCCK_PENDING
+#               and _TIF_MCCK_PENDING
 #
 io_work_loop:
         tm      __TI_flags+3(%r9),_TIF_MCCK_PENDING
-        bo      BASED(io_mcck_pending)
+        bo      BASED(io_mcck_pending)
         tm      __TI_flags+3(%r9),_TIF_NEED_RESCHED
         bo      BASED(io_reschedule)
         tm      __TI_flags+3(%r9),(_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)
@@ -637,36 +636,36 @@ io_work_loop:
 io_mcck_pending:
         l       %r1,BASED(.Ls390_handle_mcck)
         la      %r14,BASED(io_work_loop)
-        br      %r1                    # TIF bit will be cleared by handler
+        br      %r1                     # TIF bit will be cleared by handler
 
 #
 # _TIF_NEED_RESCHED is set, call schedule
-#       
-io_reschedule:        
-        l       %r1,BASED(.Lschedule)
-        stosm   __SF_EMPTY(%r15),0x03  # reenable interrupts
-        basr    %r14,%r1               # call scheduler
-        stnsm   __SF_EMPTY(%r15),0xfc  # disable I/O and ext. interrupts
+#
+io_reschedule:
+        l       %r1,BASED(.Lschedule)
+        stosm   __SF_EMPTY(%r15),0x03   # reenable interrupts
+        basr    %r14,%r1                # call scheduler
+        stnsm   __SF_EMPTY(%r15),0xfc   # disable I/O and ext. interrupts
         tm      __TI_flags+3(%r9),_TIF_WORK_INT
-        bz      BASED(io_leave)        # there is no work to do
+        bz      BASED(io_leave)         # there is no work to do
         b       BASED(io_work_loop)
 
 #
 # _TIF_SIGPENDING or _TIF_RESTORE_SIGMASK is set, call do_signal
 #
-io_sigpending:     
-        stosm   __SF_EMPTY(%r15),0x03  # reenable interrupts
-        la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        l       %r1,BASED(.Ldo_signal)
-        basr    %r14,%r1               # call do_signal
-        stnsm   __SF_EMPTY(%r15),0xfc  # disable I/O and ext. interrupts
+io_sigpending:
+        stosm   __SF_EMPTY(%r15),0x03   # reenable interrupts
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        l       %r1,BASED(.Ldo_signal)
+        basr    %r14,%r1                # call do_signal
+        stnsm   __SF_EMPTY(%r15),0xfc   # disable I/O and ext. interrupts
         b       BASED(io_work_loop)
 
 /*
  * External interrupt handler routine
  */
 
-        .globl  ext_int_handler
+        .globl  ext_int_handler
 ext_int_handler:
         STORE_TIMER __LC_ASYNC_ENTER_TIMER
         stck    __LC_INT_CLOCK
@@ -683,8 +682,8 @@ ext_no_vtime:
 #endif
         l       %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
         TRACE_IRQS_OFF
-        la      %r2,SP_PTREGS(%r15)    # address of register-save area
-        lh      %r3,__LC_EXT_INT_CODE  # get interruption code
+        la      %r2,SP_PTREGS(%r15)     # address of register-save area
+        lh      %r3,__LC_EXT_INT_CODE   # get interruption code
         l       %r1,BASED(.Ldo_extint)
         basr    %r14,%r1
         TRACE_IRQS_ON
@@ -696,13 +695,13 @@ __critical_end:
  * Machine check handler routines
  */
 
-        .globl mcck_int_handler
+        .globl mcck_int_handler
 mcck_int_handler:
         spt     __LC_CPU_TIMER_SAVE_AREA        # revalidate cpu timer
         lm      %r0,%r15,__LC_GPREGS_SAVE_AREA  # revalidate gprs
         SAVE_ALL_BASE __LC_SAVE_AREA+32
         la      %r12,__LC_MCK_OLD_PSW
-        tm      __LC_MCCK_CODE,0x80     # system damage?
+        tm      __LC_MCCK_CODE,0x80     # system damage?
         bo      BASED(mcck_int_main)    # yes -> rest of mcck code invalid
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
         mvc     __LC_SAVE_AREA+52(8),__LC_ASYNC_ENTER_TIMER
@@ -741,7 +740,7 @@ mcck_int_main:
         l       %r15,__LC_PANIC_STACK   # load panic stack
 0:      CREATE_STACK_FRAME __LC_MCK_OLD_PSW,__LC_SAVE_AREA+32
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
-        tm      __LC_MCCK_CODE+2,0x08   # mwp of old psw valid?
+        tm      __LC_MCCK_CODE+2,0x08   # mwp of old psw valid?
         bno     BASED(mcck_no_vtime)    # no -> skip cleanup critical
         tm      SP_PSW+1(%r15),0x01     # interrupting from user ?
         bz      BASED(mcck_no_vtime)
@@ -752,14 +751,14 @@ mcck_no_vtime:
 #endif
         l       %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
         la      %r2,SP_PTREGS(%r15)     # load pt_regs
-        l       %r1,BASED(.Ls390_mcck)
-        basr    %r14,%r1                # call machine check handler
-        tm      SP_PSW+1(%r15),0x01     # returning to user ?
+        l       %r1,BASED(.Ls390_mcck)
+        basr    %r14,%r1                # call machine check handler
+        tm      SP_PSW+1(%r15),0x01     # returning to user ?
         bno     BASED(mcck_return)
-        l       %r1,__LC_KERNEL_STACK   # switch to kernel stack
+        l       %r1,__LC_KERNEL_STACK   # switch to kernel stack
         s       %r1,BASED(.Lc_spsize)
         mvc     SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15)
-        xc      __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1) # clear back chain
+        xc      __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1) # clear back chain
         lr      %r15,%r1
         stosm   __SF_EMPTY(%r15),0x04   # turn dat on
         tm      __TI_flags+3(%r9),_TIF_MCCK_PENDING
@@ -783,36 +782,36 @@ mcck_return:
         lm      %r0,%r15,SP_R0(%r15)    # load gprs 0-15
         lpsw    __LC_RETURN_MCCK_PSW    # back to caller
 
-        RESTORE_ALL __LC_RETURN_MCCK_PSW,0
+        RESTORE_ALL __LC_RETURN_MCCK_PSW,0
 
 #ifdef CONFIG_SMP
 /*
  * Restart interruption handler, kick starter for additional CPUs
  */
-        .globl restart_int_handler
+        .globl restart_int_handler
 restart_int_handler:
-        l       %r15,__LC_SAVE_AREA+60 # load ksp
-        lctl    %c0,%c15,__LC_CREGS_SAVE_AREA # get new ctl regs
-        lam     %a0,%a15,__LC_AREGS_SAVE_AREA
-        lm      %r6,%r15,__SF_GPRS(%r15) # load registers from clone
-        stosm   __SF_EMPTY(%r15),0x04    # now we can turn dat on
-        basr    %r14,0
-        l       %r14,restart_addr-.(%r14)
-        br      %r14                   # branch to start_secondary
+        l       %r15,__LC_SAVE_AREA+60  # load ksp
+        lctl    %c0,%c15,__LC_CREGS_SAVE_AREA # get new ctl regs
+        lam     %a0,%a15,__LC_AREGS_SAVE_AREA
+        lm      %r6,%r15,__SF_GPRS(%r15) # load registers from clone
+        stosm   __SF_EMPTY(%r15),0x04   # now we can turn dat on
+        basr    %r14,0
+        l       %r14,restart_addr-.(%r14)
+        br      %r14                    # branch to start_secondary
 restart_addr:
-        .long   start_secondary
+        .long   start_secondary
 #else
 /*
  * If we do not run with SMP enabled, let the new CPU crash ...
  */
-        .globl restart_int_handler
+        .globl restart_int_handler
 restart_int_handler:
-        basr    %r1,0
+        basr    %r1,0
 restart_base:
-        lpsw    restart_crash-restart_base(%r1)
-        .align 8
+        lpsw    restart_crash-restart_base(%r1)
+        .align  8
 restart_crash:
-        .long  0x000a0000,0x00000000
+        .long   0x000a0000,0x00000000
 restart_go:
 #endif
 
@@ -834,11 +833,11 @@ stack_overflow:
         be      BASED(0f)
         la      %r1,__LC_SAVE_AREA+16
 0:      mvc     SP_R12(16,%r15),0(%r1)  # move %r12-%r15 to stack
-        xc      __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear back chain
+        xc      __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear back chain
         l       %r1,BASED(1f)           # branch to kernel_stack_overflow
-        la      %r2,SP_PTREGS(%r15)     # load pt_regs
+        la      %r2,SP_PTREGS(%r15)     # load pt_regs
         br      %r1
-1:      .long  kernel_stack_overflow
+1:      .long   kernel_stack_overflow
 #endif
 
 cleanup_table_system_call:
@@ -940,10 +939,10 @@ cleanup_novtime:
 cleanup_system_call_insn:
         .long   sysc_saveall + 0x80000000
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
-        .long   system_call + 0x80000000
-        .long   sysc_vtime + 0x80000000
-        .long   sysc_stime + 0x80000000
-        .long   sysc_update + 0x80000000
+        .long   system_call + 0x80000000
+        .long   sysc_vtime + 0x80000000
+        .long   sysc_stime + 0x80000000
+        .long   sysc_update + 0x80000000
 #endif
 
 cleanup_sysc_return:
@@ -1009,57 +1008,57 @@ cleanup_io_leave_insn:
 /*
  * Integer constants
  */
-               .align 4
-.Lc_spsize:    .long  SP_SIZE
-.Lc_overhead:  .long  STACK_FRAME_OVERHEAD
-.Lc_pactive:   .long  PREEMPT_ACTIVE
-.Lnr_syscalls: .long  NR_syscalls
-.L0x018:       .short 0x018
-.L0x020:       .short 0x020
-.L0x028:       .short 0x028
-.L0x030:       .short 0x030
-.L0x038:       .short 0x038
-.Lc_1:         .long  1
+                .align  4
+.Lc_spsize:     .long   SP_SIZE
+.Lc_overhead:   .long   STACK_FRAME_OVERHEAD
+.Lc_pactive:    .long   PREEMPT_ACTIVE
+.Lnr_syscalls:  .long   NR_syscalls
+.L0x018:        .short  0x018
+.L0x020:        .short  0x020
+.L0x028:        .short  0x028
+.L0x030:        .short  0x030
+.L0x038:        .short  0x038
+.Lc_1:          .long   1
 
 /*
  * Symbol constants
  */
-.Ls390_mcck:   .long  s390_do_machine_check
+.Ls390_mcck:    .long   s390_do_machine_check
 .Ls390_handle_mcck:
-               .long  s390_handle_mcck
-.Lmck_old_psw: .long  __LC_MCK_OLD_PSW
-.Ldo_IRQ:      .long  do_IRQ
-.Ldo_extint:   .long  do_extint
-.Ldo_signal:   .long  do_signal
-.Lhandle_per:  .long  do_single_step
-.Ljump_table:  .long  pgm_check_table
-.Lschedule:    .long  schedule
-.Lclone:       .long  sys_clone
-.Lexecve:      .long  sys_execve
-.Lfork:        .long  sys_fork
-.Lrt_sigreturn:.long  sys_rt_sigreturn
+                .long   s390_handle_mcck
+.Lmck_old_psw:  .long   __LC_MCK_OLD_PSW
+.Ldo_IRQ:       .long   do_IRQ
+.Ldo_extint:    .long   do_extint
+.Ldo_signal:    .long   do_signal
+.Lhandle_per:   .long   do_single_step
+.Ljump_table:   .long   pgm_check_table
+.Lschedule:     .long   schedule
+.Lclone:        .long   sys_clone
+.Lexecve:       .long   sys_execve
+.Lfork:         .long   sys_fork
+.Lrt_sigreturn: .long   sys_rt_sigreturn
 .Lrt_sigsuspend:
-               .long  sys_rt_sigsuspend
-.Lsigreturn:   .long  sys_sigreturn
-.Lsigsuspend:  .long  sys_sigsuspend
-.Lsigaltstack: .long  sys_sigaltstack
-.Ltrace:       .long  syscall_trace
-.Lvfork:       .long  sys_vfork
-.Lschedtail:   .long  schedule_tail
-.Lsysc_table:  .long  sys_call_table
+                .long   sys_rt_sigsuspend
+.Lsigreturn:    .long   sys_sigreturn
+.Lsigsuspend:   .long   sys_sigsuspend
+.Lsigaltstack:  .long   sys_sigaltstack
+.Ltrace:        .long   syscall_trace
+.Lvfork:        .long   sys_vfork
+.Lschedtail:    .long   schedule_tail
+.Lsysc_table:   .long   sys_call_table
 #ifdef CONFIG_TRACE_IRQFLAGS
-.Ltrace_irq_on:.long  trace_hardirqs_on
+.Ltrace_irq_on: .long   trace_hardirqs_on
 .Ltrace_irq_off:
-               .long  trace_hardirqs_off
+                .long   trace_hardirqs_off
 #endif
 .Lcritical_start:
-               .long  __critical_start + 0x80000000
+                .long   __critical_start + 0x80000000
 .Lcritical_end:
-               .long  __critical_end + 0x80000000
+                .long   __critical_end + 0x80000000
 .Lcleanup_critical:
-               .long  cleanup_critical
+                .long   cleanup_critical
 
-               .section .rodata, "a"
+                .section .rodata, "a"
 #define SYSCALL(esa,esame,emu)  .long esa
 sys_call_table:
 #include "syscalls.S"