80-column cleanup for entry.S

index 12701cf..b5eb2ed 100644
@@ -66,8 +66,8 @@ ENTRY(ia64_execve)
 .ret0:
 #ifdef CONFIG_IA32_SUPPORT
 	/*
-	 * Check if we're returning to ia32 mode. If so, we need to restore ia32 registers
-	 * from pt_regs.
+	 * Check if we're returning to ia32 mode. If so, we need to restore
+	 * ia32 registers from pt_regs.
 	 */
 	adds r16=PT(CR_IPSR)+16,sp
 	;;

@@ -78,16 +78,17 @@ #endif
 	sxt4 r8=r8			// return 64-bit result
 	;;
 	stf.spill [sp]ð
-(p6)	cmp.ne pKStk,pUStk=r0,r0	// a successful execve() lands us in user-mode...
+(p6)	cmp.ne pKStk,pUStk=r0,r0	// a successful execve() lands us 
+					//   in user-mode...
 	mov rp=loc0
 (p6)	mov ar.pfs=r0			// clear ar.pfs on success
 (p7)	br.ret.sptk.many rp
 
 	/*
 	 * In theory, we'd have to zap this state only to prevent leaking of
-	 * security sensitive state (e.g., if current->mm->dumpable is zero).  However,
-	 * this executes in less than 20 cycles even on Itanium, so it's not worth
-	 * optimizing for...).
+	 * security sensitive state (e.g., if current->mm->dumpable is zero).
+	 * However, this executes in less than 20 cycles even on Itanium, so
+	 * it's not worth optimizing for...).
 	 */
 	mov ar.unat=0; 		mov ar.lc=0
 	mov r4=0;		mov f2ð;		mov b1=r0

@@ -111,8 +112,8 @@ #endif
 END(ia64_execve)
 
 /*
- * sys_clone2(u64 flags, u64 ustack_base, u64 ustack_size, u64 parent_tidptr, u64 child_tidptr,
- *	      u64 tls)
+ * sys_clone2(u64 flags, u64 ustack_base, u64 ustack_size, u64 parent_tidptr,
+ *            u64 child_tidptr, u64 tls)
  */
 GLOBAL_ENTRY(sys_clone2)
 	/*

@@ -123,15 +124,18 @@ GLOBAL_ENTRY(sys_clone2)
 	DO_SAVE_SWITCH_STACK
 	adds r2=PT(R16)+IA64_SWITCH_STACK_SIZE+16,sp
 	mov loc0=rp
-	mov loc1=r16				// save ar.pfs across do_fork
+	mov loc1=r16			// save ar.pfs across do_fork
 	.body
 	mov out1=in1
 	mov out3=in2
 	tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-	mov out4=in3	// parent_tidptr: valid only w/CLONE_PARENT_SETTID
+	mov out4=in3			// parent_tidptr: valid only with
+					//   CLONE_PARENT_SETTID
 	;;
-(p6)	st8 [r2]=in5				// store TLS in r16 for copy_thread()
-	mov out5=in4	// child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+(p6)	st8 [r2]=in5			// store TLS in r16 for copy_thread()
+	mov out5=in4			// child_tidptr:  valid only with
+					//   CLONE_CHILD_SETTID or 
+					//   CLONE_CHILD_CLEARTID
 	adds out2=IA64_SWITCH_STACK_SIZE+16,sp	// out2 = &regs
 	mov out0=in0				// out0 = clone_flags
 	br.call.sptk.many rp=do_fork

@@ -143,7 +147,8 @@ (p6)	st8 [r2]=in5				// store TLS in r16
 END(sys_clone2)
 
 /*
- * sys_clone(u64 flags, u64 ustack_base, u64 parent_tidptr, u64 child_tidptr, u64 tls)
+ * sys_clone(u64 flags, u64 ustack_base, u64 parent_tidptr, u64 child_tidptr,
+ *           u64 tls)
  *	Deprecated.  Use sys_clone2() instead.
  */
 GLOBAL_ENTRY(sys_clone)

@@ -158,12 +163,16 @@ GLOBAL_ENTRY(sys_clone)
 	mov loc1=r16				// save ar.pfs across do_fork
 	.body
 	mov out1=in1
-	mov out3				// stacksize (compensates for 16-byte scratch area)
+	mov out3				// stacksize (compensates for
+						//   16-byte scratch area)
 	tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-	mov out4=in2	// parent_tidptr: valid only w/CLONE_PARENT_SETTID
+	mov out4=in2				// parent_tidptr: valid only
+						//   w/CLONE_PARENT_SETTID
 	;;
 (p6)	st8 [r2]=in4				// store TLS in r13 (tp)
-	mov out5=in3	// child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+	mov out5=in3				// child_tidptr:  valid only
+						//   w/CLONE_CHILD_SETTID or
+						//   CLONE_CHILD_CLEARTID
 	adds out2=IA64_SWITCH_STACK_SIZE+16,sp	// out2 = &regs
 	mov out0=in0				// out0 = clone_flags
 	br.call.sptk.many rp=do_fork

@@ -176,9 +185,9 @@ END(sys_clone)
 
 /*
  * prev_task <- ia64_switch_to(struct task_struct *next)
- *	With Ingo's new scheduler, interrupts are disabled when this routine gets
- *	called.  The code starting at .map relies on this.  The rest of the code
- *	doesn't care about the interrupt masking status.
+ *	With Ingo's new scheduler, interrupts are disabled when this routine
+ *	gets called.  The code starting at .map relies on this.  The rest of
+ *	the code doesn't care about the interrupt masking status.
  */
 GLOBAL_ENTRY(ia64_switch_to)
 	.prologue

@@ -190,33 +199,40 @@ GLOBAL_ENTRY(ia64_switch_to)
 	movl r25=init_task
 	mov r27=IA64_KR(CURRENT_STACK)
 	adds r21=IA64_TASK_THREAD_KSP_OFFSET,in0
-	dep r20=0,in0,61,3		// physical address of "next"
+	dep r20=0,in0,61,3			// physical address of "next"
 	;;
-	st8 [r22]=sp			// save kernel stack pointer of old task
+	st8 [r22]=sp				// save kernel stack pointer 
+						//   of old task
 	shr.u r26=r20,IA64_GRANULE_SHIFT
 	cmp.eq p7,p6=r25,in0
 	;;
 	/*
-	 * If we've already mapped this task's page, we can skip doing it again.
+	 * If we've already mapped this task's page, we can skip doing it
+	 * again.
 	 */
 (p6)	cmp.eq p7,p6=r26,r27
 (p6)	br.cond.dpnt .map
 	;;
 .done:
-	ld8 sp=[r21]			// load kernel stack pointer of new task
-	mov IA64_KR(CURRENT)=in0	// update "current" application register
-	mov r8=r13			// return pointer to previously running task
+	ld8 sp=[r21]			// load kernel stack pointer of 
+					//   new task
+	mov IA64_KR(CURRENT)=in0	// update "current" application
+					//   register
+	mov r8=r13			// return pointer to previously
+					//   running task
 	mov r13=in0			// set "current" pointer
 	;;
 	DO_LOAD_SWITCH_STACK
 
 #ifdef CONFIG_SMP
-	sync.i				// ensure "fc"s done by this CPU are visible on other CPUs
+	sync.i				// ensure "fc"s done by this CPU are
+					//   visible on other CPUs
 #endif
 	br.ret.sptk.many rp		// boogie on out in new context
 
 .map:
-	rsm psr.ic			// interrupts (psr.i) are already disabled here
+	rsm psr.ic			// interrupts (psr.i) are already
+					//   disabled here
 	movl r25=PAGE_KERNEL
 	;;
 	srlz.d

@@ -237,13 +253,14 @@ #endif
 END(ia64_switch_to)
 
 /*
- * Note that interrupts are enabled during save_switch_stack and load_switch_stack.  This
- * means that we may get an interrupt with "sp" pointing to the new kernel stack while
- * ar.bspstore is still pointing to the old kernel backing store area.  Since ar.rsc,
- * ar.rnat, ar.bsp, and ar.bspstore are all preserved by interrupts, this is not a
- * problem.  Also, we don't need to specify unwind information for preserved registers
- * that are not modified in save_switch_stack as the right unwind information is already
- * specified at the call-site of save_switch_stack.
+ * Note that interrupts are enabled during save_switch_stack and 
+ * load_switch_stack.  This means that we may get an interrupt with "sp"
+ * pointing to the new kernel stack while ar.bspstore is still pointing 
+ * to the old kernel backing store area.  Since ar.rsc, ar.rnat, ar.bsp,
+ * and ar.bspstore are all preserved by interrupts, this is not a problem.
+ * Also, we don't need to specify unwind information for preserved registers
+ * that are not modified in save_switch_stack as the right unwind information
+ * is already specified at the call-site of save_switch_stack.
  */
 
 /*

@@ -255,7 +272,8 @@ END(ia64_switch_to)
 GLOBAL_ENTRY(save_switch_stack)
 	.prologue
 	.altrp b7
-	flushrs			// flush dirty regs to backing store (must be first in insn group)
+	flushrs			// flush dirty regs to backing store (must
+				//   be first in insn group)
 	.save @priunat,r17
 	mov r17=ar.unat		// preserve caller's
 	.body

@@ -264,7 +282,7 @@ #ifdef CONFIG_ITANIUM
 	adds r3+64,sp
 	adds r14=SW(R4)+16,sp
 	;;
-	st8.spill [r14]=r4,16		// spill r4
+	st8.spill [r14]=r4,16			// spill r4
 	lfetch.fault.excl.nt1 [r3],128
 	;;
 	lfetch.fault.excl.nt1 [r2],128

@@ -278,24 +296,26 @@ #else
 	add r3,sp
 	add r14=SW(R4)+16,sp
 	;;
-	st8.spill [r14]=r4,SW(R6)-SW(R4)	// spill r4 and prefetch offset 0x1c0
-	lfetch.fault.excl.nt1 [r3],128	//		prefetch offset 0x010
+	st8.spill [r14]=r4,SW(R6)-SW(R4)	// spill r4 and prefetch
+						//   offset 0x1c0
+	lfetch.fault.excl.nt1 [r3],128		// prefetch offset 0x010
 	;;
-	lfetch.fault.excl.nt1 [r3],128	//		prefetch offset 0x090
-	lfetch.fault.excl.nt1 [r2],128	//		prefetch offset 0x190
+	lfetch.fault.excl.nt1 [r3],128		// prefetch offset 0x090
+	lfetch.fault.excl.nt1 [r2],128		// prefetch offset 0x190
 	;;
-	lfetch.fault.excl.nt1 [r3]	//		prefetch offset 0x110
-	lfetch.fault.excl.nt1 [r2]	//		prefetch offset 0x210
+	lfetch.fault.excl.nt1 [r3]		// prefetch offset 0x110
+	lfetch.fault.excl.nt1 [r2]		// prefetch offset 0x210
 	adds r15=SW(R5)+16,sp
 #endif
 	;;
 	st8.spill [r15]=r5,SW(R7)-SW(R5)	// spill r5
-	mov.m ar.rsc=0			// put RSE in mode: enforced lazy, little endian, pl 0
-	add r2=SW(F2)+16,sp		// r2 = &sw->f2
+	mov.m ar.rsc=0				// put RSE in mode: enforced
+						//   lazy, little endian, pl 0
+	add r2=SW(F2)+16,sp			// r2 = &sw->f2
 	;;
 	st8.spill [r14]=r6,SW(B0)-SW(R6)	// spill r6
-	mov.m r18=ar.fpsr		// preserve fpsr
-	add r3=SW(F3)+16,sp		// r3 = &sw->f3
+	mov.m r18=ar.fpsr			// preserve fpsr
+	add r3=SW(F3)+16,sp			// r3 = &sw->f3
 	;;
 	stf.spill [r2]ò,32
 	mov.m r19=ar.rnat

@@ -365,7 +385,8 @@ #endif
 	;;
 	st8 [r2]=r20				// save ar.bspstore
 	st8 [r14]=r18				// save fpsr
-	mov ar.rsc=3		// put RSE back into eager mode, pl 0
+	mov ar.rsc=3				// put RSE back into eager 
+						//   mode, pl 0
 	br.cond.sptk.many b7
 END(save_switch_stack)
 

@@ -383,30 +404,31 @@ ENTRY(load_switch_stack)
 	lfetch.fault.nt1 [sp]
 	adds r2=SW(AR_BSPSTORE)+16,sp
 	adds r3=SW(AR_UNAT)+16,sp
-	mov ar.rsc=0						// put RSE into enforced lazy mode
+	mov ar.rsc=0				// put RSE into enforced 
+						//   lazy mode
 	adds r14=SW(CALLER_UNAT)+16,sp
 	adds r15=SW(AR_FPSR)+16,sp
 	;;
 	ld8 r27=[r2],(SW(B0)-SW(AR_BSPSTORE))	// bspstore
 	ld8 r29=[r3],(SW(B1)-SW(AR_UNAT))	// unat
 	;;
-	ld8 r21=[r2],16		// restore b0
-	ld8 r22=[r3],16		// restore b1
+	ld8 r21=[r2],16				// restore b0
+	ld8 r22=[r3],16				// restore b1
 	;;
-	ld8 r23=[r2],16		// restore b2
-	ld8 r24=[r3],16		// restore b3
+	ld8 r23=[r2],16				// restore b2
+	ld8 r24=[r3],16				// restore b3
 	;;
-	ld8 r25=[r2],16		// restore b4
-	ld8 r26=[r3],16		// restore b5
+	ld8 r25=[r2],16				// restore b4
+	ld8 r26=[r3],16				// restore b5
 	;;
 	ld8 r16=[r2],(SW(PR)-SW(AR_PFS))	// ar.pfs
 	ld8 r17=[r3],(SW(AR_RNAT)-SW(AR_LC))	// ar.lc
 	;;
-	ld8 r28=[r2]		// restore pr
-	ld8 r30=[r3]		// restore rnat
+	ld8 r28=[r2]				// restore pr
+	ld8 r30=[r3]				// restore rnat
 	;;
-	ld8 r18=[r14],16	// restore caller's unat
-	ld8 r19=[r15],24	// restore fpsr
+	ld8 r18=[r14],16			// restore caller's unat
+	ld8 r19=[r15],24			// restore fpsr
 	;;
 	ldf.fill f2=[r14],32
 	ldf.fill f3=[r15],32

@@ -436,7 +458,8 @@ ENTRY(load_switch_stack)
 	mov b2=r23
 	;;
 	mov ar.bspstore=r27
-	mov ar.unat=r29		// establish unat holding the NaT bits for r4-r7
+	mov ar.unat=r29			// establish unat holding the NaT
+					//   bits for r4-r7
 	mov b3=r24
 	;;
 	ldf.fill f24=[r14],32

@@ -463,9 +486,11 @@ ENTRY(load_switch_stack)
 	ld8.fill r7=[r15],16
 
 	mov ar.unat=r18				// restore caller's unat
-	mov ar.rnat=r30				// must restore after bspstore but before rsc!
+	mov ar.rnat=r30				// must restore after bspstore
+						//   but before rsc!
 	mov ar.fpsr=r19				// restore fpsr
-	mov ar.rsc=3				// put RSE back into eager mode, pl 0
+	mov ar.rsc=3				// put RSE back into eager 
+						//   mode, pl 0
 	br.cond.sptk.many b7
 END(load_switch_stack)
 

@@ -527,7 +552,8 @@ GLOBAL_ENTRY(ia64_trace_syscall)
 	;;
  	stf.spill [r16]ñ0
  	stf.spill [r17]ñ1
-	br.call.sptk.many rp=syscall_trace_enter // give parent a chance to catch syscall args
+	br.call.sptk.many rp=syscall_trace_enter // give parent a chance to 
+						 //   catch syscall args
 	adds r16=PT(F6)+16,sp
 	adds r17=PT(F7)+16,sp
 	;;

@@ -539,9 +565,9 @@ GLOBAL_ENTRY(ia64_trace_syscall)
 	;;
 	ldf.fill f10=[r16]
 	ldf.fill f11=[r17]
-	// the syscall number may have changed, so re-load it and re-calculate the
-	// syscall entry-point:
-	adds r15=PT(R15)+16,sp			// r15 = &pt_regs.r15 (syscall #)
+	// the syscall number may have changed, so re-load it and re-calculate
+	// the syscall entry-point:
+	adds r15=PT(R15)+16,sp			// r15 = &pt_regs.r15 (syscall#)
 	;;
 	ld8 r15=[r15]
 	mov r3=NR_syscalls - 1

@@ -549,10 +575,12 @@ GLOBAL_ENTRY(ia64_trace_syscall)
 	adds r15=-1024,r15
 	movl r16=sys_call_table
 	;;
-	shladd r20=r15,3,r16			// r20 = sys_call_table + 8*(syscall-1024)
+	shladd r20=r15,3,r16			// r20 = sys_call_table + 
+						//       8*(syscall-1024)
 	cmp.leu p6,p7=r15,r3
 	;;
-(p6)	ld8 r20=[r20]				// load address of syscall entry point
+(p6)	ld8 r20=[r20]				// load address of syscall
+						//   entry point
 (p7)	movl r20=sys_ni_syscall
 	;;
 	mov b6=r20

@@ -565,16 +593,20 @@ (p7)	movl r20=sys_ni_syscall
 (p6)	br.cond.sptk strace_error		// syscall failed ->
 	;;					// avoid RAW on r10
 .strace_save_retval:
-.mem.offset 0,0; st8.spill [r2]=r8		// store return value in slot for r8
-.mem.offset 8,0; st8.spill [r3]=r10		// clear error indication in slot for r10
-	br.call.sptk.many rp=syscall_trace_leave // give parent a chance to catch return value
+.mem.offset 0,0; st8.spill [r2]=r8		// store return value in slot
+						//   for r8
+.mem.offset 8,0; st8.spill [r3]=r10		// clear error indication in
+						//   slot for r10
+	br.call.sptk.many rp=syscall_trace_leave // give parent a chance to
+						 //   catch return value
 .ret3:
 (pUStk)	cmp.eq.unc p6,p0=r0,r0			// p6 <- pUStk
 	br.cond.sptk .work_pending_syscall_end
 
 strace_error:
 	ld8 r3=[r2]				// load pt_regs.r8
-	sub r9=0,r8				// negate return value to get errno value
+	sub r9=0,r8				// negate return value to get
+						//   errno value
 	;;
 	cmp.ne p6,p0=r3,r0			// is pt_regs.r8!=0?
 	adds r3,r2				// r3=&pt_regs.r10

@@ -585,18 +617,21 @@ (p6)	mov r8=r9
 END(ia64_trace_syscall)
 
 	/*
-	 * When traced and returning from sigreturn, we invoke syscall_trace but then
-	 * go straight to ia64_leave_kernel rather than ia64_leave_syscall.
+	 * When traced and returning from sigreturn, we invoke syscall_trace
+	 * but then go straight to ia64_leave_kernel rather than 
+	 * ia64_leave_syscall.
 	 */
 GLOBAL_ENTRY(ia64_strace_leave_kernel)
 	PT_REGS_UNWIND_INFO(0)
 {	/*
-	 * Some versions of gas generate bad unwind info if the first instruction of a
-	 * procedure doesn't go into the first slot of a bundle.  This is a workaround.
+	 * Some versions of gas generate bad unwind info if the first 
+	 * instruction of a procedure doesn't go into the first slot of
+	 * a bundle.  This is a workaround.
 	 */
 	nop.m 0
 	nop.i 0
-	br.call.sptk.many rp=syscall_trace_leave // give parent a chance to catch return value
+	br.call.sptk.many rp=syscall_trace_leave // give parent a chance to
+						 //   catch return value
 }
 .ret4:	br.cond.sptk ia64_leave_kernel
 END(ia64_strace_leave_kernel)

@@ -604,15 +639,16 @@ END(ia64_strace_leave_kernel)
 GLOBAL_ENTRY(ia64_ret_from_clone)
 	PT_REGS_UNWIND_INFO(0)
 {	/*
-	 * Some versions of gas generate bad unwind info if the first instruction of a
-	 * procedure doesn't go into the first slot of a bundle.  This is a workaround.
+	 * Some versions of gas generate bad unwind info if the first
+	 * instruction of a procedure doesn't go into the first slot of
+	 * a bundle.  This is a workaround.
 	 */
 	nop.m 0
 	nop.i 0
 	/*
-	 * We need to call schedule_tail() to complete the scheduling process.
-	 * Called by ia64_switch_to() after do_fork()->copy_thread().  r8 contains the
-	 * address of the previously executing task.
+	 * We need to call schedule_tail() to complete the scheduling
+	 * process.  Called by ia64_switch_to() after do_fork()->copy_thread().
+	 * Register r8 contains the address of the previously executing task.
 	 */
 	br.call.sptk.many rp=ia64_invoke_schedule_tail
 }

@@ -626,15 +662,19 @@ GLOBAL_ENTRY(ia64_ret_from_clone)
 	;;
 	cmp.ne p6,p0=r2,r0
 (p6)	br.cond.spnt .strace_check_retval
-	;;					// added stop bits to prevent r8 dependency
+	;;					// added stop bits to prevent
+						//   r8 dependency
 END(ia64_ret_from_clone)
 	// fall through
 GLOBAL_ENTRY(ia64_ret_from_syscall)
 	PT_REGS_UNWIND_INFO(0)
-	cmp.ge p6,p7=r8,r0			// syscall executed successfully?
+	cmp.ge p6,p7=r8,r0			// did syscall execute
+						//   successfully?
 	adds r2=PT(R8)+16,sp			// r2 = &pt_regs.r8
-	mov r10=r0				// clear error indication in r10
-(p7)	br.cond.spnt handle_syscall_error	// handle potential syscall failure
+	mov r10=r0				// clear error indication is
+						//   in r10
+(p7)	br.cond.spnt handle_syscall_error	// handle potential syscall
+						//   failure
 END(ia64_ret_from_syscall)
 	// fall through
 /*

@@ -684,14 +724,16 @@ END(ia64_ret_from_syscall)
 ENTRY(ia64_leave_syscall)
 	PT_REGS_UNWIND_INFO(0)
 	/*
-	 * work.need_resched etc. mustn't get changed by this CPU before it returns to
-	 * user- or fsys-mode, hence we disable interrupts early on.
+	 * work.need_resched etc. mustn't get changed by this CPU before
+	 * it returns to user- or fsys-mode, hence we disable interrupts
+	 * early on.
 	 *
-	 * p6 controls whether current_thread_info()->flags needs to be check for
-	 * extra work.  We always check for extra work when returning to user-level.
-	 * With CONFIG_PREEMPT, we also check for extra work when the preempt_count
-	 * is 0.  After extra work processing has been completed, execution
-	 * resumes at .work_processed_syscall with p6 set to 1 if the extra-work-check
+	 * p6 controls whether current_thread_info()->flags needs to be 
+	 * checked for extra work.  We always check for extra work when 
+	 * returning to user-level.  With CONFIG_PREEMPT, we also check 
+	 * for extra work when the preempt_count is 0.  After extra work
+	 * processing has been completed, execution resumes at 
+	 * .work_processed_syscall with p6 set to 1 if the extra-work-check
 	 * needs to be redone.
 	 */
 #ifdef CONFIG_PREEMPT

@@ -714,26 +756,33 @@ #endif
 	adds r3=PT(AR_BSPSTORE)+16,r12
 	adds r18=TI_FLAGS+IA64_TASK_SIZE,r13
 	;;
-(p6)	ld4 r31=[r18]				// load current_thread_info()->flags
-	ld8 r19=[r2],PT(B6)-PT(LOADRS)		// load ar.rsc value for "loadrs"
+(p6)	ld4 r31=[r18]			// load current_thread_info()->flags
+	ld8 r19=[r2],PT(B6)-PT(LOADRS)	// load ar.rsc value for "loadrs"
 	nop.i 0
 	;;
-	mov r16=ar.bsp				// M2  get existing backing store pointer
-	ld8 r18=[r2],PT(R9)-PT(B6)		// load b6
-(p6)	and r15=TIF_WORK_MASK,r31		// any work other than TIF_SYSCALL_TRACE?
+	mov r16=ar.bsp			// M2 get existing backing store 
+					//   pointer
+	ld8 r18=[r2],PT(R9)-PT(B6)	// load b6
+(p6)	and r15=TIF_WORK_MASK,r31	// any work other than 
+					//   TIF_SYSCALL_TRACE?
 	;;
-	ld8 r23=[r3],PT(R11)-PT(AR_BSPSTORE)	// load ar.bspstore (may be garbage)
+	ld8 r23=[r3],PT(R11)-PT(AR_BSPSTORE)	// load ar.bspstore (may be
+						//   garbage)
 (p6)	cmp4.ne.unc p6,p0=r15, r0		// any special work pending?
 (p6)	br.cond.spnt .work_pending_syscall
 	;;
-	// start restoring the state saved on the kernel stack (struct pt_regs):
+	// start restoring the state saved on the kernel stack
+	// (struct pt_regs):
 	ld8 r9=[r2],PT(CR_IPSR)-PT(R9)
 	ld8 r11=[r3],PT(CR_IIP)-PT(R11)
-(pNonSys) break 0		//      bug check: we shouldn't be here if pNonSys is TRUE!
+(pNonSys) break 0		// bug check: we shouldn't be here if pNonSys
+				//   is TRUE!
 	;;
 	invala			// M0|1 invalidate ALAT
-	rsm psr.i | psr.ic	// M2   turn off interrupts and interruption collection
-	cmp.eq p9,p0=r0,r0	// A    set p9 to indicate that we should restore cr.ifs
+	rsm psr.i | psr.ic	// M2   turn off interrupts and interruption
+				//      collection
+	cmp.eq p9,p0=r0,r0	// A    set p9 to indicate that we should
+				//      restore cr.ifs
 
 	ld8 r29=[r2],16		// M0|1 load cr.ipsr
 	ld8 r28=[r3],16		// M0|1 load cr.iip

@@ -744,14 +793,16 @@ (pNonSys) break 0		//      bug check: we
 (pUStk) add r14=IA64_TASK_THREAD_ON_USTACK_OFFSET,r13
 	;;
 	ld8 r26=[r2],PT(B0)-PT(AR_PFS)	// M0|1 load ar.pfs
-(pKStk)	mov r22=psr			// M2   read PSR now that interrupts are disabled
+(pKStk)	mov r22=psr			// M2   read PSR now that interrupts
+					//      are disabled
 	nop 0
 	;;
 	ld8 r21=[r2],PT(AR_RNAT)-PT(B0) // M0|1 load b0
 	ld8 r27=[r3],PT(PR)-PT(AR_RSC)	// M0|1 load ar.rsc
 	mov f6ð			// F    clear f6
 	;;
-	ld8 r24=[r2],PT(AR_FPSR)-PT(AR_RNAT)	// M0|1 load ar.rnat (may be garbage)
+	ld8 r24=[r2],PT(AR_FPSR)-PT(AR_RNAT)	// M0|1 load ar.rnat (may be
+						//      garbage)
 	ld8 r31=[r3],PT(R1)-PT(PR)		// M0|1 load predicates
 	mov f7ð				// F    clear f7
 	;;

@@ -771,11 +822,15 @@ (pUStk) st1 [r14]=r17				// M2|3
 	mov f9ð					// F    clear f9
 (pKStk) br.cond.dpnt.many skip_rbs_switch		// B
 
-	srlz.d				// M0   ensure interruption collection is off (for cover)
-	shr.u r18=r19,16		// I0|1 get byte size of existing "dirty" partition
-	cover				// B    add current frame into dirty partition & set cr.ifs
-	;;
-(pUStk) ld4 r17=[r17]			// M0|1 r17 = cpu_data->phys_stacked_size_p8
+	srlz.d				// M0   ensure interruption collection
+					//	is off (for cover)
+	shr.u r18=r19,16		// I0|1 get byte size of existing 
+					//	"dirty" partition
+	cover				// B    add current frame into dirty
+					//	partition & set cr.ifs
+	;;
+(pUStk) ld4 r17=[r17]			// M0|1 r17 = cpu_data->
+					//	      phys_stacked_size_p8
 	mov r19=ar.bsp			// M2   get new backing store pointer
 	mov f10ð			// F    clear f10
 

@@ -784,7 +839,8 @@ (pUStk) ld4 r17=[r17]			// M0|1 r17 = cp
 	;;
 	mov.m ar.csd=r0			// M2   clear ar.csd
 	mov.m ar.ccv=r0			// M2   clear ar.ccv
-	mov b7=r14			// I0   clear b7 (hint with __kernel_syscall_via_epc)
+	mov b7=r14			// I0   clear b7 (hint with 
+					//	__kernel_syscall_via_epc)
 
 	mov.m ar.ssd=r0			// M2   clear ar.ssd
 	mov f11ð			// F    clear f11

@@ -794,27 +850,31 @@ END(ia64_leave_syscall)
 #ifdef CONFIG_IA32_SUPPORT
 GLOBAL_ENTRY(ia64_ret_from_ia32_execve)
 	PT_REGS_UNWIND_INFO(0)
-	adds r2=PT(R8)+16,sp			// r2 = &pt_regs.r8
-	adds r3=PT(R10)+16,sp			// r3 = &pt_regs.r10
+	adds r2=PT(R8)+16,sp		// r2 = &pt_regs.r8
+	adds r3=PT(R10)+16,sp		// r3 = &pt_regs.r10
 	;;
 	.mem.offset 0,0
-	st8.spill [r2]=r8	// store return value in slot for r8 and set unat bit
+	st8.spill [r2]=r8		// store return value in slot for r8
+					//   and set unat bit
 	.mem.offset 8,0
-	st8.spill [r3]=r0	// clear error indication in slot for r10 and set unat bit
+	st8.spill [r3]=r0		// clear error indication in slot for
+					//   r10 and set unat bit
 END(ia64_ret_from_ia32_execve)
 	// fall through
 #endif /* CONFIG_IA32_SUPPORT */
 GLOBAL_ENTRY(ia64_leave_kernel)
 	PT_REGS_UNWIND_INFO(0)
 	/*
-	 * work.need_resched etc. mustn't get changed by this CPU before it returns to
-	 * user- or fsys-mode, hence we disable interrupts early on.
+	 * work.need_resched etc. mustn't get changed by this CPU before 
+	 * it returns to user- or fsys-mode, hence we disable interrupts
+	 * early on.
 	 *
-	 * p6 controls whether current_thread_info()->flags needs to be check for
-	 * extra work.  We always check for extra work when returning to user-level.
-	 * With CONFIG_PREEMPT, we also check for extra work when the preempt_count
-	 * is 0.  After extra work processing has been completed, execution
-	 * resumes at .work_processed_syscall with p6 set to 1 if the extra-work-check
+	 * p6 controls whether current_thread_info()->flags needs to be 
+	 * checked for extra work.  We always check for extra work when 
+	 * returning to user-level.  With CONFIG_PREEMPT, we also check 
+	 * for extra work when the preempt_count is 0.  After extra work 
+	 * processing has been completed, execution resumes at
+	 * .work_processed_syscall with p6 set to 1 if the extra-work-check
 	 * needs to be redone.
 	 */
 #ifdef CONFIG_PREEMPT

@@ -835,7 +895,7 @@ #endif
 .work_processed_kernel:
 	adds r17=TI_FLAGS+IA64_TASK_SIZE,r13
 	;;
-(p6)	ld4 r31=[r17]				// load current_thread_info()->flags
+(p6)	ld4 r31=[r17]			// load current_thread_info()->flags
 	adds r21=PT(PR)+16,r12
 	;;
 

@@ -844,22 +904,23 @@ (p6)	ld4 r31=[r17]				// load current_th
 	adds r3=PT(R16)+16,r12
 	;;
 	lfetch [r21]
-	ld8 r28=[r2],8		// load b6
+	ld8 r28=[r2],8				// load b6
 	adds r29=PT(R24)+16,r12
 
 	ld8.fill r16=[r3],PT(AR_CSD)-PT(R16)
 	adds r30=PT(AR_CCV)+16,r12
-(p6)	and r19=TIF_WORK_MASK,r31		// any work other than TIF_SYSCALL_TRACE?
+(p6)	and r19=TIF_WORK_MASK,r31		// any work other than 
+						//   TIF_SYSCALL_TRACE?
 	;;
 	ld8.fill r24=[r29]
-	ld8 r15=[r30]		// load ar.ccv
+	ld8 r15=[r30]				// load ar.ccv
 (p6)	cmp4.ne.unc p6,p0=r19, r0		// any special work pending?
 	;;
-	ld8 r29=[r2],16		// load b7
-	ld8 r30=[r3],16		// load ar.csd
+	ld8 r29=[r2],16				// load b7
+	ld8 r30=[r3],16				// load ar.csd
 (p6)	br.cond.spnt .work_pending
 	;;
-	ld8 r31=[r2],16		// load ar.ssd
+	ld8 r31=[r2],16				// load ar.ssd
 	ld8.fill r8=[r3],16
 	;;
 	ld8.fill r9=[r2],16

@@ -876,8 +937,9 @@ (p6)	br.cond.spnt .work_pending
 	mov ar.csd=r30
 	mov ar.ssd=r31
 	;;
-	rsm psr.i | psr.ic	// initiate turning off of interrupt and interruption collection
-	invala			// invalidate ALAT
+	rsm psr.i | psr.ic		// initiate turning off of interrupt
+					//   and interruption collection
+	invala				// invalidate ALAT
 	;;
 	ld8.fill r22=[r2],24
 	ld8.fill r23=[r3],24

@@ -904,44 +966,49 @@ (p6)	br.cond.spnt .work_pending
 	ldf.fill f7=[r2],PT(F11)-PT(F7)
 	ldf.fill f8=[r3],32
 	;;
-	srlz.d	// ensure that inter. collection is off (VHPT is don't care, since text is pinned)
+	srlz.d				// ensure that interrupt collection 
+					//   is off (VHPT is don't care, since
+					//   text is pinned)
 	mov ar.ccv=r15
 	;;
 	ldf.fill f11=[r2]
-	bsw.0			// switch back to bank 0 (no stop bit required beforehand...)
+	bsw.0				// switch back to bank 0 (no stop bit
+					//   required beforehand...)
 	;;
-(pUStk)	mov r18=IA64_KR(CURRENT)// M2 (12 cycle read latency)
+(pUStk)	mov r18=IA64_KR(CURRENT)	// M2 (12 cycle read latency)
 	adds r16=PT(CR_IPSR)+16,r12
 	adds r17=PT(CR_IIP)+16,r12
 
-(pKStk)	mov r22=psr		// M2 read PSR now that interrupts are disabled
+(pKStk)	mov r22=psr			// M2 read PSR now that interrupts 
+					//    are disabled
 	nop.i 0
 	nop.i 0
 	;;
-	ld8 r29=[r16],16	// load cr.ipsr
-	ld8 r28=[r17],16	// load cr.iip
+	ld8 r29=[r16],16		// load cr.ipsr
+	ld8 r28=[r17],16		// load cr.iip
 	;;
-	ld8 r30=[r16],16	// load cr.ifs
-	ld8 r25=[r17],16	// load ar.unat
+	ld8 r30=[r16],16		// load cr.ifs
+	ld8 r25=[r17],16		// load ar.unat
 	;;
-	ld8 r26=[r16],16	// load ar.pfs
-	ld8 r27=[r17],16	// load ar.rsc
-	cmp.eq p9,p0=r0,r0	// set p9 to indicate that we should restore cr.ifs
+	ld8 r26=[r16],16		// load ar.pfs
+	ld8 r27=[r17],16		// load ar.rsc
+	cmp.eq p9,p0=r0,r0		// set p9 to indicate that we should
+					//   restore cr.ifs
 	;;
-	ld8 r24=[r16],16	// load ar.rnat (may be garbage)
-	ld8 r23=[r17],16	// load ar.bspstore (may be garbage)
+	ld8 r24=[r16],16		// load ar.rnat (may be garbage)
+	ld8 r23=[r17],16		// load ar.bspstore (may be garbage)
 	;;
-	ld8 r31=[r16],16	// load predicates
-	ld8 r21=[r17],16	// load b0
+	ld8 r31=[r16],16		// load predicates
+	ld8 r21=[r17],16		// load b0
 	;;
-	ld8 r19=[r16],16	// load ar.rsc value for "loadrs"
-	ld8.fill r1=[r17],16	// load r1
+	ld8 r19=[r16],16		// load ar.rsc value for "loadrs"
+	ld8.fill r1=[r17],16		// load r1
 	;;
 	ld8.fill r12=[r16],16
 	ld8.fill r13=[r17],16
 (pUStk)	adds r18=IA64_TASK_THREAD_ON_USTACK_OFFSET,r18
 	;;
-	ld8 r20=[r16],16	// ar.fpsr
+	ld8 r20=[r16],16		// ar.fpsr
 	ld8.fill r15=[r17],16
 	;;
 	ld8.fill r14=[r16],16

@@ -949,13 +1016,14 @@ (pUStk)	adds r18=IA64_TASK_THREAD_ON_UST
 (pUStk)	mov r17=1
 	;;
 	ld8.fill r3=[r16]
-(pUStk)	st1 [r18]=r17		// restore current->thread.on_ustack
-	shr.u r18=r19,16	// get byte size of existing "dirty" partition
+(pUStk)	st1 [r18]=r17			// restore current->thread.on_ustack
+	shr.u r18=r19,16		// get byte size of existing "dirty"
+					//   partition
 	;;
-	mov r16=ar.bsp		// get existing backing store pointer
+	mov r16=ar.bsp			// get existing backing store pointer
 	addl r17=THIS_CPU(ia64_phys_stacked_size_p8),r0
 	;;
-	ld4 r17=[r17]		// r17 = cpu_data->phys_stacked_size_p8
+	ld4 r17=[r17]			// r17 = cpu_data->phys_stacked_size_p8
 (pKStk)	br.cond.dpnt skip_rbs_switch
 
 	/*

@@ -964,17 +1032,21 @@ (pKStk)	br.cond.dpnt skip_rbs_switch
 	 * NOTE: alloc, loadrs, and cover can't be predicated.
 	 */
 (pNonSys) br.cond.dpnt dont_preserve_current_frame
-	cover				// add current frame into dirty partition and set cr.ifs
+	cover				// add current frame into dirty 
+					//   partition and set cr.ifs
 	;;
 	mov r19=ar.bsp			// get new backing store pointer
 rbs_switch:
-	sub r16=r16,r18			// krbs = old bsp - size of dirty partition
+	sub r16=r16,r18			// krbs = old bsp - size of dirty
+					//   partition
 	cmp.ne p9,p0=r0,r0		// clear p9 to skip restore of cr.ifs
 	;;
-	sub r19=r19,r16			// calculate total byte size of dirty partition
+	sub r19=r19,r16			// calculate total byte size of dirty
+					//   partition
 	add r18d,r18			// don't force in0-in7 into memory...
 	;;
-	shl r19=r19,16			// shift size of dirty partition into loadrs position
+	shl r19=r19,16			// shift size of dirty partition into
+					//   loadrs position
 	;;
 dont_preserve_current_frame:
 	/*

@@ -991,8 +1063,8 @@ #else
 #	define Nregs	14
 #endif
 	alloc loc0=ar.pfs,2,Nregs-2,2,0
-	shr.u loc1=r18,9		// RNaTslots <= floor(dirtySize / (64*8))
-	sub r17=r17,r18			// r17 = (physStackedSize + 8) - dirtySize
+	shr.u loc1=r18,9		// RNaTslots <= floor(dirtySize/(64*8))
+	sub r17=r17,r18			// r17 = (physStackedSize+8)-dirtySize
 	;;
 	mov ar.rsc=r19			// load ar.rsc to be used for "loadrs"
 	shladd in0=loc1,3,r17

@@ -1004,12 +1076,13 @@ #ifdef CONFIG_ITANIUM
 	// cycle 0
  { .mii
 	alloc loc0=ar.pfs,2,Nregs-2,2,0
-	cmp.lt pRecurse,p0=Nregs*8,in0	// if more than Nregs regs left to clear, (re)curse
+	cmp.lt pRecurse,p0=Nregs*8,in0	// if more than Nregs registers left 
+					//   to clear, (re)curse
 	add out0=-Nregs*8,in0
 }{ .mfb
 	add out1=1,in1			// increment recursion count
 	nop.f 0
-	nop.b 0				// can't do br.call here because of alloc (WAW on CFM)
+	nop.b 0				// can't do br.call here because of 						//   alloc (WAW on CFM)
 	;;
 }{ .mfi	// cycle 1
 	mov loc1=0

@@ -1023,7 +1096,8 @@ (pRecurse) br.call.sptk.many b0=rse_clea
 }{ .mfi	// cycle 2
 	mov loc5=0
 	nop.f 0
-	cmp.ne pReturn,p0=r0,in1	// if recursion count != 0, we need to do a br.ret
+	cmp.ne pReturn,p0=r0,in1	// if recursion count != 0, we need 
+					//   to do a br.ret
 }{ .mib
 	mov loc6=0
 	mov loc7=0

@@ -1031,7 +1105,8 @@ (pReturn) br.ret.sptk.many b0
 }
 #else /* !CONFIG_ITANIUM */
 	alloc loc0=ar.pfs,2,Nregs-2,2,0
-	cmp.lt pRecurse,p0=Nregs*8,in0	// if more than Nregs regs left to clear, (re)curse
+	cmp.lt pRecurse,p0=Nregs*8,in0	// if more than Nregs registers left
+					//   to clear, (re)curse
 	add out0=-Nregs*8,in0
 	add out1=1,in1			// increment recursion count
 	mov loc1=0

@@ -1046,7 +1121,8 @@ (pRecurse) br.call.dptk.few b0=rse_clear
 	;;
 	mov loc8=0
 	mov loc9=0
-	cmp.ne pReturn,p0=r0,in1	// if recursion count != 0, we need to do a br.ret
+	cmp.ne pReturn,p0=r0,in1	// if recursion count != 0, we need
+					//   to do a br.ret
 	mov loc10=0
 	mov loc11=0
 (pReturn) br.ret.dptk.many b0

@@ -1059,33 +1135,38 @@ #	undef pReturn
 	loadrs
 	;;
 skip_rbs_switch:
-	mov ar.unat=r25		// M2
-(pKStk)	extr.u r22=r22,21,1	// I0 extract current value of psr.pp from r22
-(pLvSys)mov r19=r0		// A  clear r19 for leave_syscall, no-op otherwise
-	;;
-(pUStk)	mov ar.bspstore=r23	// M2
-(pKStk)	dep r29=r22,r29,21,1	// I0 update ipsr.pp with psr.pp
-(pLvSys)mov r16=r0		// A  clear r16 for leave_syscall, no-op otherwise
-	;;
-	mov cr.ipsr=r29		// M2
-	mov ar.pfs=r26		// I0
-(pLvSys)mov r17=r0		// A  clear r17 for leave_syscall, no-op otherwise
+	mov ar.unat=r25			// M2
+(pKStk)	extr.u r22=r22,21,1		// I0 extract current value of psr.pp
+					//    from r22
+(pLvSys)mov r19=r0			// A  clear r19 for leave_syscall, 
+					//    no-op otherwise
+	;;
+(pUStk)	mov ar.bspstore=r23		// M2
+(pKStk)	dep r29=r22,r29,21,1		// I0 update ipsr.pp with psr.pp
+(pLvSys)mov r16=r0			// A  clear r16 for leave_syscall, 
+					//    no-op otherwise
+	;;
+	mov cr.ipsr=r29			// M2
+	mov ar.pfs=r26			// I0
+(pLvSys)mov r17=r0			// A  clear r17 for leave_syscall, 
+					//    no-op otherwise
 
-(p9)	mov cr.ifs=r30		// M2
-	mov b0=r21		// I0
-(pLvSys)mov r18=r0		// A  clear r18 for leave_syscall, no-op otherwise
+(p9)	mov cr.ifs=r30			// M2
+	mov b0=r21			// I0
+(pLvSys)mov r18=r0			// A  clear r18 for leave_syscall, 
+					//    no-op otherwise
 
-	mov ar.fpsr=r20		// M2
-	mov cr.iip=r28		// M2
+	mov ar.fpsr=r20			// M2
+	mov cr.iip=r28			// M2
 	nop 0
 	;;
-(pUStk)	mov ar.rnat=r24		// M2 must happen with RSE in lazy mode
+(pUStk)	mov ar.rnat=r24			// M2 must happen with RSE in lazy mode
 	nop 0
 (pLvSys)mov r2=r0
 
-	mov ar.rsc=r27		// M2
-	mov pr=r31,-1		// I0
-	rfi			// B
+	mov ar.rsc=r27			// M2
+	mov pr=r31,-1			// I0
+	rfi				// B
 
 	/*
 	 * On entry:

@@ -1101,31 +1182,32 @@ (pLvSys)mov r2=r0
 	st8 [r2]=r8
 	st8 [r3]=r10
 .work_pending:
-	tbit.z p6,p0=r31,TIF_NEED_RESCHED		// current_thread_info()->need_resched=0?
+	tbit.z p6,p0=r31,TIF_NEED_RESCHED	// current_thread_info()->
+						//   need_resched = 0?
 (p6)	br.cond.sptk.few .notify
 #ifdef CONFIG_PREEMPT
 (pKStk) dep r21=-1,r0,PREEMPT_ACTIVE_BIT,1
 	;;
 (pKStk) st4 [r20]=r21
-	ssm psr.i		// enable interrupts
+	ssm psr.i				// enable interrupts
 #endif
 	br.call.spnt.many rp=schedule
-.ret9:	cmp.eq p6,p0=r0,r0				// p6 <- 1
-	rsm psr.i		// disable interrupts
+.ret9:	cmp.eq p6,p0=r0,r0			// p6 <- 1
+	rsm psr.i				// disable interrupts
 	;;
 #ifdef CONFIG_PREEMPT
 (pKStk)	adds r20=TI_PRE_COUNT+IA64_TASK_SIZE,r13
 	;;
-(pKStk)	st4 [r20]=r0		// preempt_count() <- 0
+(pKStk)	st4 [r20]=r0				// preempt_count() <- 0
 #endif
 (pLvSys)br.cond.sptk.few  .work_pending_syscall_end
-	br.cond.sptk.many .work_processed_kernel	// re-check
+	br.cond.sptk.many .work_processed_kernel // re-check
 
 .notify:
 (pUStk)	br.call.spnt.many rp=notify_resume_user
-.ret10:	cmp.ne p6,p0=r0,r0				// p6 <- 0
+.ret10:	cmp.ne p6,p0=r0,r0			// p6 <- 0
 (pLvSys)br.cond.sptk.few  .work_pending_syscall_end
-	br.cond.sptk.many .work_processed_kernel	// don't re-check
+	br.cond.sptk.many .work_processed_kernel // don't re-check
 
 .work_pending_syscall_end:
 	adds r2=PT(R8)+16,r12

@@ -1133,36 +1215,37 @@ (pLvSys)br.cond.sptk.few  .work_pending_
 	;;
 	ld8 r8=[r2]
 	ld8 r10=[r3]
-	br.cond.sptk.many .work_processed_syscall	// re-check
+	br.cond.sptk.many .work_processed_syscall // re-check
 
 END(ia64_leave_kernel)
 
 ENTRY(handle_syscall_error)
 	/*
-	 * Some system calls (e.g., ptrace, mmap) can return arbitrary values which could
-	 * lead us to mistake a negative return value as a failed syscall.  Those syscall
-	 * must deposit a non-zero value in pt_regs.r8 to indicate an error.  If
-	 * pt_regs.r8 is zero, we assume that the call completed successfully.
+	 * Some system calls (e.g., ptrace, mmap) can return arbitrary
+	 * values which could lead us to mistake a negative return value
+	 * as a failed syscall.  Those syscalls must deposit a non-zero
+	 * value in pt_regs.r8 to indicate an error.  If pt_regs.r8 is 
+	 * zero, we assume that the call completed successfully.
 	 */
 	PT_REGS_UNWIND_INFO(0)
-	ld8 r3=[r2]		// load pt_regs.r8
+	ld8 r3=[r2]			// load pt_regs.r8
 	;;
-	cmp.eq p6,p7=r3,r0	// is pt_regs.r8=0?
+	cmp.eq p6,p7=r3,r0		// is pt_regs.r8=0?
 	;;
 (p7)	mov r10=-1
-(p7)	sub r8=0,r8		// negate return value to get errno
+(p7)	sub r8=0,r8			// negate return value to get errno
 	br.cond.sptk ia64_leave_syscall
 END(handle_syscall_error)
 
 	/*
-	 * Invoke schedule_tail(task) while preserving in0-in7, which may be needed
-	 * in case a system call gets restarted.
+	 * Invoke schedule_tail(task) while preserving in0-in7, which may 
+	 * be needed in case a system call gets restarted.
 	 */
 GLOBAL_ENTRY(ia64_invoke_schedule_tail)
 	.prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
 	alloc loc1=ar.pfs,8,2,1,0
 	mov loc0=rp
-	mov out0=r8				// Address of previous task
+	mov out0=r8			// Address of previous task
 	;;
 	br.call.sptk.many rp=schedule_tail
 .ret11:	mov ar.pfs=loc1

@@ -1171,13 +1254,16 @@ GLOBAL_ENTRY(ia64_invoke_schedule_tail)
 END(ia64_invoke_schedule_tail)
 
 	/*
-	 * Setup stack and call do_notify_resume_user().  Note that pSys and pNonSys need to
-	 * be set up by the caller.  We declare 8 input registers so the system call
-	 * args get preserved, in case we need to restart a system call.
+	 * Setup stack and call do_notify_resume_user().  Note that pSys 
+	 * and pNonSys need to be set up by the caller.  We declare 8 
+	 * input registers so the system call args get preserved, in case
+	 * we need to restart a system call.
 	 */
 ENTRY(notify_resume_user)
 	.prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
-	alloc loc1=ar.pfs,8,2,3,0 // preserve all eight input regs in case of syscall restart!
+	alloc loc1=ar.pfs,8,2,3,0 		// preserve all eight input 
+						//   registers in case of a
+						//   syscall restart!
 	mov r9=ar.unat
 	mov loc0=rp				// save return address
 	mov out0=0				// there is no "oldset"

@@ -1187,14 +1273,16 @@ (pSys)	mov out2=1				// out2=1 => we're
 (pNonSys) mov out2=0				// out2=0 => not a syscall
 	.fframe 16
 	.spillsp ar.unat, 16
-	st8 [sp]=r9,-16				// allocate space for ar.unat and save it
+	st8 [sp]=r9,-16				// allocate space for ar.unat
+						//   and save it
 	st8 [out1]=loc1,-8			// save ar.pfs, out1=&sigscratch
 	.body
 	br.call.sptk.many rp=do_notify_resume_user
 .ret15:	.restore sp
 	adds sp,sp				// pop scratch stack space
 	;;
-	ld8 r9=[sp]				// load new unat from sigscratch->scratch_unat
+	ld8 r9=[sp]				// load new unat from 
+						//   sigscratch->scratch_unat
 	mov rp=loc0
 	;;
 	mov ar.unat=r9

@@ -1204,7 +1292,9 @@ END(notify_resume_user)
 
 GLOBAL_ENTRY(sys_rt_sigsuspend)
 	.prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
-	alloc loc1=ar.pfs,8,2,3,0 // preserve all eight input regs in case of syscall restart!
+	alloc loc1=ar.pfs,8,2,3,0 		// preserve all eight input 
+						//   registers in case of a
+						//   syscall restart!
 	mov r9=ar.unat
 	mov loc0=rp				// save return address
 	mov out0=in0				// mask

@@ -1213,14 +1303,16 @@ GLOBAL_ENTRY(sys_rt_sigsuspend)
 	;;
 	.fframe 16
 	.spillsp ar.unat, 16
-	st8 [sp]=r9,-16				// allocate space for ar.unat and save it
+	st8 [sp]=r9,-16				// allocate space for ar.unat
+						//   and save it
 	st8 [out2]=loc1,-8			// save ar.pfs, out2=&sigscratch
 	.body
 	br.call.sptk.many rp=ia64_rt_sigsuspend
 .ret17:	.restore sp
 	adds sp,sp				// pop scratch stack space
 	;;
-	ld8 r9=[sp]				// load new unat from sw->caller_unat
+	ld8 r9=[sp]				// load new unat from 
+						//   sw->caller_unat
 	mov rp=loc0
 	;;
 	mov ar.unat=r9

@@ -1238,13 +1330,15 @@ ENTRY(sys_rt_sigreturn)
 	PT_REGS_SAVES(16)
 	adds sp=-16,sp
 	.body
-	cmp.eq pNonSys,pSys=r0,r0		// sigreturn isn't a normal syscall...
+	cmp.eq pNonSys,pSys=r0,r0		// sigreturn isn't a normal
+						//   syscall...
 	;;
 	/*
-	 * leave_kernel() restores f6-f11 from pt_regs, but since the streamlined
-	 * syscall-entry path does not save them we save them here instead.  Note: we
-	 * don't need to save any other registers that are not saved by the stream-lined
-	 * syscall path, because restore_sigcontext() restores them.
+	 * leave_kernel() restores f6-f11 from pt_regs, but since the 
+	 * streamlined syscall-entry path does not save them we save them 
+	 * here instead.  Note: we don't need to save any other registers 
+	 * that are not saved by the stream-lined syscall path, because 
+	 * restore_sigcontext() restores them.
 	 */
 	adds r16=PT(F6)+32,sp
 	adds r17=PT(F7)+32,sp

@@ -1276,10 +1370,10 @@ GLOBAL_ENTRY(ia64_prepare_handle_unalign
 	 */
 	mov r16=r0
 	DO_SAVE_SWITCH_STACK
-	br.call.sptk.many rp=ia64_handle_unaligned	// stack frame setup in ivt
+	br.call.sptk.many rp=ia64_handle_unaligned  // stack frame setup in ivt
 .ret21:	.body
 	DO_LOAD_SWITCH_STACK
-	br.cond.sptk.many rp				// goes to ia64_leave_kernel
+	br.cond.sptk.many rp			// goes to ia64_leave_kernel
 END(ia64_prepare_handle_unaligned)
 
 	//

@@ -1309,7 +1403,8 @@ GLOBAL_ENTRY(unw_init_running)
 	br.call.sptk.many rp=unw_init_frame_info
 1:	adds out0,sp				// &info
 	mov b6=loc2
-	mov loc2=gp				// save gp across indirect function call
+	mov loc2=gp				// save gp across indirect 
+						//   function call
 	;;
 	ld8 gp=[in0]
 	mov out1=in1				// arg

@@ -1331,7 +1426,8 @@ END(unw_init_running)
 	.align 8
 	.globl sys_call_table
 sys_call_table:
-	data8 sys_ni_syscall		//  This must be sys_ni_syscall!  See ivt.S.
+	data8 sys_ni_syscall			// This must be sys_ni_syscall!
+						//   See ivt.S.
 	data8 sys_exit				// 1025
 	data8 sys_read
 	data8 sys_write

@@ -1427,9 +1523,9 @@ sys_call_table:
 	data8 sys_syslog
 	data8 sys_setitimer
 	data8 sys_getitimer
-	data8 sys_ni_syscall			// 1120		/* was: ia64_oldstat */
-	data8 sys_ni_syscall					/* was: ia64_oldlstat */
-	data8 sys_ni_syscall					/* was: ia64_oldfstat */
+	data8 sys_ni_syscall			// 1120	/* was: ia64_oldstat */
+	data8 sys_ni_syscall			/* was: ia64_oldlstat */
+	data8 sys_ni_syscall			/* was: ia64_oldfstat */
 	data8 sys_vhangup
 	data8 sys_lchown
 	data8 sys_remap_file_pages		// 1125

@@ -1439,16 +1535,16 @@ sys_call_table:
 	data8 sys_setdomainname
 	data8 sys_newuname			// 1130
 	data8 sys_adjtimex
-	data8 sys_ni_syscall					/* was: ia64_create_module */
+	data8 sys_ni_syscall			/* was: ia64_create_module */
 	data8 sys_init_module
 	data8 sys_delete_module
-	data8 sys_ni_syscall			// 1135		/* was: sys_get_kernel_syms */
-	data8 sys_ni_syscall					/* was: sys_query_module */
+	data8 sys_ni_syscall		// 1135	/* was: sys_get_kernel_syms */
+	data8 sys_ni_syscall			/* was: sys_query_module */
 	data8 sys_quotactl
 	data8 sys_bdflush
 	data8 sys_sysfs
 	data8 sys_personality			// 1140
-	data8 sys_ni_syscall		// sys_afs_syscall
+	data8 sys_ni_syscall			// sys_afs_syscall
 	data8 sys_setfsuid
 	data8 sys_setfsgid
 	data8 sys_getdents

@@ -1495,8 +1593,8 @@ sys_call_table:
 	data8 sys_capget			// 1185
 	data8 sys_capset
 	data8 sys_sendfile64
-	data8 sys_ni_syscall		// sys_getpmsg (STREAMS)
-	data8 sys_ni_syscall		// sys_putpmsg (STREAMS)
+	data8 sys_ni_syscall			// sys_getpmsg (STREAMS)
+	data8 sys_ni_syscall			// sys_putpmsg (STREAMS)
 	data8 sys_socket			// 1190
 	data8 sys_bind
 	data8 sys_connect

@@ -1611,4 +1709,5 @@ sys_call_table:
 	data8 sys_tee
 	data8 sys_vmsplice
 
-	.org sys_call_table + 8*NR_syscalls	// guard against failures to increase NR_syscalls
+	.org sys_call_table + 8*NR_syscalls	// guard against failures to
+						//   increase NR_syscalls