Commit 2b05d2b3 authored by Jesper Nilsson's avatar Jesper Nilsson Committed by Linus Torvalds
Browse files

CRISv10 usercopy library add lineendings to asm 



Removes warning when compiling arch/cris/arch-v10/lib/usercopy.c

No change except adding \n\ on the end of the lines has been done.
Removes warning about multi-line string literals.

Signed-off-by: default avatarJesper Nilsson <jesper.nilsson@axis.com>
Cc: Mikael Starvik <mikael.starvik@axis.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 3eed6393

arch/cris/arch-v10/lib/usercopy.c

+157 −157
Original line number Diff line number Diff line
@@ -92,58 +92,58 @@ __copy_user (void __user *pdst, const void *psrc, unsigned long pn) 
	.ifnc %0%1%2%3,$r13$r11$r12$r10					\n\

	.err								\n\

	.endif								\n\



	;; Save the registers we'll use in the movem process

	;; on the stack.

	subq	11*4,$sp

	movem	$r10,[$sp]



	;; Now we've got this:

	;; r11 - src

	;; r13 - dst

	;; r12 - n



	;; Update n for the first loop

	subq	44,$r12



; Since the noted PC of a faulting instruction in a delay-slot of a taken

; branch, is that of the branch target, we actually point at the from-movem

; for this case.  There is no ambiguity here; if there was a fault in that

; instruction (meaning a kernel oops), the faulted PC would be the address

; after *that* movem.



0:

	movem	[$r11+],$r10

	subq   44,$r12

	bge	0b

	movem	$r10,[$r13+]

1:

	addq   44,$r12  ;; compensate for last loop underflowing n



	;; Restore registers from stack

	movem [$sp+],$r10

2:

	.section .fixup,\"ax\"



; To provide a correct count in r10 of bytes that failed to be copied,

; we jump back into the loop if the loop-branch was taken.  There is no

; performance penalty for sany use; the program will segfault soon enough.



3:

	move.d [$sp],$r10

	addq 44,$r10

	move.d $r10,[$sp]

	jump 0b

4:

	movem [$sp+],$r10

	addq 44,$r10

	addq 44,$r12

	jump 2b



	.previous

	.section __ex_table,\"a\"

	.dword 0b,3b

	.dword 1b,4b

									\n\

	;; Save the registers we'll use in the movem process		\n\

	;; on the stack.						\n\

	subq	11*4,$sp						\n\

	movem	$r10,[$sp]						\n\

									\n\

	;; Now we've got this:						\n\

	;; r11 - src							\n\

	;; r13 - dst							\n\

	;; r12 - n							\n\

									\n\

	;; Update n for the first loop					\n\

	subq	44,$r12							\n\

									\n\

; Since the noted PC of a faulting instruction in a delay-slot of a taken \n\

; branch, is that of the branch target, we actually point at the from-movem \n\

; for this case.  There is no ambiguity here; if there was a fault in that \n\

; instruction (meaning a kernel oops), the faulted PC would be the address \n\

; after *that* movem.							\n\

									\n\

0:									\n\

	movem	[$r11+],$r10						\n\

	subq   44,$r12							\n\

	bge	0b							\n\

	movem	$r10,[$r13+]						\n\

1:									\n\

	addq   44,$r12  ;; compensate for last loop underflowing n	\n\

									\n\

	;; Restore registers from stack					\n\

	movem [$sp+],$r10						\n\

2:									\n\

	.section .fixup,\"ax\"						\n\

									\n\

; To provide a correct count in r10 of bytes that failed to be copied,	\n\

; we jump back into the loop if the loop-branch was taken.  There is no	\n\

; performance penalty for sany use; the program will segfault soon enough.\n\

									\n\

3:									\n\

	move.d [$sp],$r10						\n\

	addq 44,$r10							\n\

	move.d $r10,[$sp]						\n\

	jump 0b								\n\

4:									\n\

	movem [$sp+],$r10						\n\

	addq 44,$r10							\n\

	addq 44,$r12							\n\

	jump 2b								\n\

									\n\

	.previous							\n\

	.section __ex_table,\"a\"					\n\

	.dword 0b,3b							\n\

	.dword 1b,4b							\n\

	.previous"



     /* Outputs */ : "=r" (dst), "=r" (src), "=r" (n), "=r" (retn)
@@ -253,59 +253,59 @@ __copy_user_zeroing (void __user *pdst, const void *psrc, unsigned long pn) 
       If you want to check that the allocation was right; then

       check the equalities in the first comment.  It should say

       "r13=r13, r11=r11, r12=r12" */

    __asm__ volatile ("

    __asm__ volatile ("\n\

	.ifnc %0%1%2%3,$r13$r11$r12$r10					\n\

	.err								\n\

	.endif								\n\



	;; Save the registers we'll use in the movem process

	;; on the stack.

	subq	11*4,$sp

	movem	$r10,[$sp]



	;; Now we've got this:

	;; r11 - src

	;; r13 - dst

	;; r12 - n



	;; Update n for the first loop

	subq	44,$r12

0:

	movem	[$r11+],$r10

1:

	subq   44,$r12

	bge	0b

	movem	$r10,[$r13+]



	addq   44,$r12  ;; compensate for last loop underflowing n



	;; Restore registers from stack

	movem [$sp+],$r10

4:

	.section .fixup,\"ax\"



;; Do not jump back into the loop if we fail.  For some uses, we get a

;; page fault somewhere on the line.  Without checking for page limits,

;; we don't know where, but we need to copy accurately and keep an

;; accurate count; not just clear the whole line.  To do that, we fall

;; down in the code below, proceeding with smaller amounts.  It should

;; be kept in mind that we have to cater to code like what at one time

;; was in fs/super.c:

;;  i = size - copy_from_user((void *)page, data, size);

;; which would cause repeated faults while clearing the remainder of

;; the SIZE bytes at PAGE after the first fault.

;; A caveat here is that we must not fall through from a failing page

;; to a valid page.



3:

	movem  [$sp+],$r10

	addq	44,$r12 ;; Get back count before faulting point.

	subq	44,$r11 ;; Get back pointer to faulting movem-line.

	jump	4b	;; Fall through, pretending the fault didn't happen.



	.previous

	.section __ex_table,\"a\"

	.dword 1b,3b

									\n\

	;; Save the registers we'll use in the movem process		\n\

	;; on the stack.						\n\

	subq	11*4,$sp						\n\

	movem	$r10,[$sp]						\n\

									\n\

	;; Now we've got this:						\n\

	;; r11 - src							\n\

	;; r13 - dst							\n\

	;; r12 - n							\n\

									\n\

	;; Update n for the first loop					\n\

	subq	44,$r12							\n\

0:									\n\

	movem	[$r11+],$r10						\n\

1:									\n\

	subq   44,$r12							\n\

	bge	0b							\n\

	movem	$r10,[$r13+]						\n\

									\n\

	addq   44,$r12  ;; compensate for last loop underflowing n	\n\

									\n\

	;; Restore registers from stack					\n\

	movem [$sp+],$r10						\n\

4:									\n\

	.section .fixup,\"ax\"						\n\

									\n\

;; Do not jump back into the loop if we fail.  For some uses, we get a	\n\

;; page fault somewhere on the line.  Without checking for page limits,	\n\

;; we don't know where, but we need to copy accurately and keep an	\n\

;; accurate count; not just clear the whole line.  To do that, we fall	\n\

;; down in the code below, proceeding with smaller amounts.  It should	\n\

;; be kept in mind that we have to cater to code like what at one time	\n\

;; was in fs/super.c:							\n\

;;  i = size - copy_from_user((void *)page, data, size);		\n\

;; which would cause repeated faults while clearing the remainder of	\n\

;; the SIZE bytes at PAGE after the first fault.			\n\

;; A caveat here is that we must not fall through from a failing page	\n\

;; to a valid page.							\n\

									\n\

3:									\n\

	movem  [$sp+],$r10						\n\

	addq	44,$r12 ;; Get back count before faulting point.	\n\

	subq	44,$r11 ;; Get back pointer to faulting movem-line.	\n\

	jump	4b	;; Fall through, pretending the fault didn't happen.\n\

									\n\

	.previous							\n\

	.section __ex_table,\"a\"					\n\

	.dword 1b,3b							\n\

	.previous"



     /* Outputs */ : "=r" (dst), "=r" (src), "=r" (n), "=r" (retn)
@@ -425,64 +425,64 @@ __do_clear_user (void __user *pto, unsigned long pn) 
      If you want to check that the allocation was right; then

      check the equalities in the first comment.  It should say

      something like "r13=r13, r11=r11, r12=r12". */

    __asm__ volatile ("

    __asm__ volatile ("\n\

	.ifnc %0%1%2,$r13$r12$r10					\n\

	.err								\n\

	.endif								\n\



	;; Save the registers we'll clobber in the movem process

	;; on the stack.  Don't mention them to gcc, it will only be

	;; upset.

	subq	11*4,$sp

	movem	$r10,[$sp]



	clear.d $r0

	clear.d $r1

	clear.d $r2

	clear.d $r3

	clear.d $r4

	clear.d $r5

	clear.d $r6

	clear.d $r7

	clear.d $r8

	clear.d $r9

	clear.d $r10

	clear.d $r11



	;; Now we've got this:

	;; r13 - dst

	;; r12 - n



	;; Update n for the first loop

	subq	12*4,$r12

0:

	subq   12*4,$r12

	bge	0b

	movem	$r11,[$r13+]

1:

	addq   12*4,$r12        ;; compensate for last loop underflowing n



	;; Restore registers from stack

	movem [$sp+],$r10

2:

	.section .fixup,\"ax\"

3:

	move.d [$sp],$r10

	addq 12*4,$r10

	move.d $r10,[$sp]

	clear.d $r10

	jump 0b



4:

	movem [$sp+],$r10

	addq 12*4,$r10

	addq 12*4,$r12

	jump 2b



	.previous

	.section __ex_table,\"a\"

	.dword 0b,3b

	.dword 1b,4b

									\n\

	;; Save the registers we'll clobber in the movem process	\n\

	;; on the stack.  Don't mention them to gcc, it will only be	\n\

	;; upset.							\n\

	subq	11*4,$sp						\n\

	movem	$r10,[$sp]						\n\

									\n\

	clear.d $r0							\n\

	clear.d $r1							\n\

	clear.d $r2							\n\

	clear.d $r3							\n\

	clear.d $r4							\n\

	clear.d $r5							\n\

	clear.d $r6							\n\

	clear.d $r7							\n\

	clear.d $r8							\n\

	clear.d $r9							\n\

	clear.d $r10							\n\

	clear.d $r11							\n\

									\n\

	;; Now we've got this:						\n\

	;; r13 - dst							\n\

	;; r12 - n							\n\

									\n\

	;; Update n for the first loop					\n\

	subq	12*4,$r12						\n\

0:									\n\

	subq   12*4,$r12						\n\

	bge	0b							\n\

	movem	$r11,[$r13+]						\n\

1:									\n\

	addq   12*4,$r12        ;; compensate for last loop underflowing n\n\

									\n\

	;; Restore registers from stack					\n\

	movem [$sp+],$r10						\n\

2:									\n\

	.section .fixup,\"ax\"						\n\

3:									\n\

	move.d [$sp],$r10						\n\

	addq 12*4,$r10							\n\

	move.d $r10,[$sp]						\n\

	clear.d $r10							\n\

	jump 0b								\n\

									\n\

4:									\n\

	movem [$sp+],$r10						\n\

	addq 12*4,$r10							\n\

	addq 12*4,$r12							\n\

	jump 2b								\n\

									\n\

	.previous							\n\

	.section __ex_table,\"a\"					\n\

	.dword 0b,3b							\n\

	.dword 1b,4b							\n\

	.previous"



     /* Outputs */ : "=r" (dst), "=r" (n), "=r" (retn)

CRA Git | Maintained and supported by SUSTech CRA and CCSE