arch/parisc/lib/lusercopy.S

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  *    User Space Access Routines
   4  *
   5  *    Copyright (C) 2000-2002 Hewlett-Packard (John Marvin)
   6  *    Copyright (C) 2000 Richard Hirst <rhirst with parisc-linux.org>
   7  *    Copyright (C) 2001 Matthieu Delahaye <delahaym at esiee.fr>
   8  *    Copyright (C) 2003 Randolph Chung <tausq with parisc-linux.org>
   9  *    Copyright (C) 2017 Helge Deller <deller@gmx.de>
  10  *    Copyright (C) 2017 John David Anglin <dave.anglin@bell.net>
  11  */
  12
  13 /*
  14  * These routines still have plenty of room for optimization
  15  * (word & doubleword load/store, dual issue, store hints, etc.).
  16  */
  17
  18 /*
  19  * The following routines assume that space register 3 (sr3) contains
  20  * the space id associated with the current users address space.
  21  */
  22
  23
  24         .text
  25
  26 #include <asm/assembly.h>
  27 #include <asm/errno.h>
  28 #include <linux/linkage.h>
  29
  30         /*
  31          * unsigned long lclear_user(void *to, unsigned long n)
  32          *
  33          * Returns 0 for success.
  34          * otherwise, returns number of bytes not transferred.
  35          */
  36
  37 ENTRY_CFI(lclear_user)
  38         comib,=,n   0,%r25,$lclu_done
  39 $lclu_loop:
  40         addib,<>    -1,%r25,$lclu_loop
  41 1:      stbs,ma     %r0,1(%sr3,%r26)
  42
  43 $lclu_done:
  44         bv          %r0(%r2)
  45         copy        %r25,%r28
  46
  47 2:      b           $lclu_done
  48         ldo         1(%r25),%r25
  49
  50         ASM_EXCEPTIONTABLE_ENTRY(1b,2b)
  51 ENDPROC_CFI(lclear_user)
  52
  53
  54 /*
  55  * unsigned long pa_memcpy(void *dstp, const void *srcp, unsigned long len)
  56  *
  57  * Inputs:
  58  * - sr1 already contains space of source region
  59  * - sr2 already contains space of destination region
  60  *
  61  * Returns:
  62  * - number of bytes that could not be copied.
  63  *   On success, this will be zero.
  64  *
  65  * This code is based on a C-implementation of a copy routine written by
  66  * Randolph Chung, which in turn was derived from the glibc.
  67  *
  68  * Several strategies are tried to try to get the best performance for various
  69  * conditions. In the optimal case, we copy by loops that copy 32- or 16-bytes
  70  * at a time using general registers.  Unaligned copies are handled either by
  71  * aligning the destination and then using shift-and-write method, or in a few
  72  * cases by falling back to a byte-at-a-time copy.
  73  *
  74  * Testing with various alignments and buffer sizes shows that this code is
  75  * often >10x faster than a simple byte-at-a-time copy, even for strangely
  76  * aligned operands. It is interesting to note that the glibc version of memcpy
  77  * (written in C) is actually quite fast already. This routine is able to beat
  78  * it by 30-40% for aligned copies because of the loop unrolling, but in some
  79  * cases the glibc version is still slightly faster. This lends more
  80  * credibility that gcc can generate very good code as long as we are careful.
  81  *
  82  * Possible optimizations:
  83  * - add cache prefetching
  84  * - try not to use the post-increment address modifiers; they may create
  85  *   additional interlocks. Assumption is that those were only efficient on old
  86  *   machines (pre PA8000 processors)
  87  */
  88
  89         dst = arg0
  90         src = arg1
  91         len = arg2
  92         end = arg3
  93         t1  = r19
  94         t2  = r20
  95         t3  = r21
  96         t4  = r22
  97         srcspc = sr1
  98         dstspc = sr2
  99
 100         t0 = r1
 101         a1 = t1
 102         a2 = t2
 103         a3 = t3
 104         a0 = t4
 105
 106         save_src = ret0
 107         save_dst = ret1
 108         save_len = r31
 109
 110 ENTRY_CFI(pa_memcpy)
 111         /* Last destination address */
 112         add     dst,len,end
 113
 114         /* short copy with less than 16 bytes? */
 115         cmpib,COND(>>=),n 15,len,.Lbyte_loop
 116
 117         /* same alignment? */
 118         xor     src,dst,t0
 119         extru   t0,31,2,t1
 120         cmpib,<>,n  0,t1,.Lunaligned_copy
 121
 122 #ifdef CONFIG_64BIT
 123         /* only do 64-bit copies if we can get aligned. */
 124         extru   t0,31,3,t1
 125         cmpib,<>,n  0,t1,.Lalign_loop32
 126
 127         /* loop until we are 64-bit aligned */
 128 .Lalign_loop64:
 129         extru   dst,31,3,t1
 130         cmpib,=,n       0,t1,.Lcopy_loop_16_start
 131 20:     ldb,ma  1(srcspc,src),t1
 132 21:     stb,ma  t1,1(dstspc,dst)
 133         b       .Lalign_loop64
 134         ldo     -1(len),len
 135
 136         ASM_EXCEPTIONTABLE_ENTRY(20b,.Lcopy_done)
 137         ASM_EXCEPTIONTABLE_ENTRY(21b,.Lcopy_done)
 138
 139 .Lcopy_loop_16_start:
 140         ldi     31,t0
 141 .Lcopy_loop_16:
 142         cmpb,COND(>>=),n t0,len,.Lword_loop
 143
 144 10:     ldd     0(srcspc,src),t1
 145 11:     ldd     8(srcspc,src),t2
 146         ldo     16(src),src
 147 12:     std,ma  t1,8(dstspc,dst)
 148 13:     std,ma  t2,8(dstspc,dst)
 149 14:     ldd     0(srcspc,src),t1
 150 15:     ldd     8(srcspc,src),t2
 151         ldo     16(src),src
 152 16:     std,ma  t1,8(dstspc,dst)
 153 17:     std,ma  t2,8(dstspc,dst)
 154
 155         ASM_EXCEPTIONTABLE_ENTRY(10b,.Lcopy_done)
 156         ASM_EXCEPTIONTABLE_ENTRY(11b,.Lcopy16_fault)
 157         ASM_EXCEPTIONTABLE_ENTRY(12b,.Lcopy_done)
 158         ASM_EXCEPTIONTABLE_ENTRY(13b,.Lcopy_done)
 159         ASM_EXCEPTIONTABLE_ENTRY(14b,.Lcopy_done)
 160         ASM_EXCEPTIONTABLE_ENTRY(15b,.Lcopy16_fault)
 161         ASM_EXCEPTIONTABLE_ENTRY(16b,.Lcopy_done)
 162         ASM_EXCEPTIONTABLE_ENTRY(17b,.Lcopy_done)
 163
 164         b       .Lcopy_loop_16
 165         ldo     -32(len),len
 166
 167 .Lword_loop:
 168         cmpib,COND(>>=),n 3,len,.Lbyte_loop
 169 20:     ldw,ma  4(srcspc,src),t1
 170 21:     stw,ma  t1,4(dstspc,dst)
 171         b       .Lword_loop
 172         ldo     -4(len),len
 173
 174         ASM_EXCEPTIONTABLE_ENTRY(20b,.Lcopy_done)
 175         ASM_EXCEPTIONTABLE_ENTRY(21b,.Lcopy_done)
 176
 177 #endif /* CONFIG_64BIT */
 178
 179         /* loop until we are 32-bit aligned */
 180 .Lalign_loop32:
 181         extru   dst,31,2,t1
 182         cmpib,=,n       0,t1,.Lcopy_loop_8
 183 20:     ldb,ma  1(srcspc,src),t1
 184 21:     stb,ma  t1,1(dstspc,dst)
 185         b       .Lalign_loop32
 186         ldo     -1(len),len
 187
 188         ASM_EXCEPTIONTABLE_ENTRY(20b,.Lcopy_done)
 189         ASM_EXCEPTIONTABLE_ENTRY(21b,.Lcopy_done)
 190
 191
 192 .Lcopy_loop_8:
 193         cmpib,COND(>>=),n 15,len,.Lbyte_loop
 194
 195 10:     ldw     0(srcspc,src),t1
 196 11:     ldw     4(srcspc,src),t2
 197 12:     stw,ma  t1,4(dstspc,dst)
 198 13:     stw,ma  t2,4(dstspc,dst)
 199 14:     ldw     8(srcspc,src),t1
 200 15:     ldw     12(srcspc,src),t2
 201         ldo     16(src),src
 202 16:     stw,ma  t1,4(dstspc,dst)
 203 17:     stw,ma  t2,4(dstspc,dst)
 204
 205         ASM_EXCEPTIONTABLE_ENTRY(10b,.Lcopy_done)
 206         ASM_EXCEPTIONTABLE_ENTRY(11b,.Lcopy8_fault)
 207         ASM_EXCEPTIONTABLE_ENTRY(12b,.Lcopy_done)
 208         ASM_EXCEPTIONTABLE_ENTRY(13b,.Lcopy_done)
 209         ASM_EXCEPTIONTABLE_ENTRY(14b,.Lcopy_done)
 210         ASM_EXCEPTIONTABLE_ENTRY(15b,.Lcopy8_fault)
 211         ASM_EXCEPTIONTABLE_ENTRY(16b,.Lcopy_done)
 212         ASM_EXCEPTIONTABLE_ENTRY(17b,.Lcopy_done)
 213
 214         b       .Lcopy_loop_8
 215         ldo     -16(len),len
 216
 217 .Lbyte_loop:
 218         cmpclr,COND(<>) len,%r0,%r0
 219         b,n     .Lcopy_done
 220 20:     ldb     0(srcspc,src),t1
 221         ldo     1(src),src
 222 21:     stb,ma  t1,1(dstspc,dst)
 223         b       .Lbyte_loop
 224         ldo     -1(len),len
 225
 226         ASM_EXCEPTIONTABLE_ENTRY(20b,.Lcopy_done)
 227         ASM_EXCEPTIONTABLE_ENTRY(21b,.Lcopy_done)
 228
 229 .Lcopy_done:
 230         bv      %r0(%r2)
 231         sub     end,dst,ret0
 232
 233
 234         /* src and dst are not aligned the same way. */
 235         /* need to go the hard way */
 236 .Lunaligned_copy:
 237         /* align until dst is 32bit-word-aligned */
 238         extru   dst,31,2,t1
 239         cmpib,=,n       0,t1,.Lcopy_dstaligned
 240 20:     ldb     0(srcspc,src),t1
 241         ldo     1(src),src
 242 21:     stb,ma  t1,1(dstspc,dst)
 243         b       .Lunaligned_copy
 244         ldo     -1(len),len
 245
 246         ASM_EXCEPTIONTABLE_ENTRY(20b,.Lcopy_done)
 247         ASM_EXCEPTIONTABLE_ENTRY(21b,.Lcopy_done)
 248
 249 .Lcopy_dstaligned:
 250
 251         /* store src, dst and len in safe place */
 252         copy    src,save_src
 253         copy    dst,save_dst
 254         copy    len,save_len
 255
 256         /* len now needs give number of words to copy */
 257         SHRREG  len,2,len
 258
 259         /*
 260          * Copy from a not-aligned src to an aligned dst using shifts.
 261          * Handles 4 words per loop.
 262          */
 263
 264         depw,z src,28,2,t0
 265         subi 32,t0,t0
 266         mtsar t0
 267         extru len,31,2,t0
 268         cmpib,= 2,t0,.Lcase2
 269         /* Make src aligned by rounding it down.  */
 270         depi 0,31,2,src
 271
 272         cmpiclr,<> 3,t0,%r0
 273         b,n .Lcase3
 274         cmpiclr,<> 1,t0,%r0
 275         b,n .Lcase1
 276 .Lcase0:
 277         cmpb,COND(=) %r0,len,.Lcda_finish
 278         nop
 279
 280 1:      ldw,ma 4(srcspc,src), a3
 281         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 282 1:      ldw,ma 4(srcspc,src), a0
 283         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 284         b,n .Ldo3
 285 .Lcase1:
 286 1:      ldw,ma 4(srcspc,src), a2
 287         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 288 1:      ldw,ma 4(srcspc,src), a3
 289         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 290         ldo -1(len),len
 291         cmpb,COND(=),n %r0,len,.Ldo0
 292 .Ldo4:
 293 1:      ldw,ma 4(srcspc,src), a0
 294         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 295         shrpw a2, a3, %sar, t0
 296 1:      stw,ma t0, 4(dstspc,dst)
 297         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcopy_done)
 298 .Ldo3:
 299 1:      ldw,ma 4(srcspc,src), a1
 300         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 301         shrpw a3, a0, %sar, t0
 302 1:      stw,ma t0, 4(dstspc,dst)
 303         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcopy_done)
 304 .Ldo2:
 305 1:      ldw,ma 4(srcspc,src), a2
 306         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 307         shrpw a0, a1, %sar, t0
 308 1:      stw,ma t0, 4(dstspc,dst)
 309         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcopy_done)
 310 .Ldo1:
 311 1:      ldw,ma 4(srcspc,src), a3
 312         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 313         shrpw a1, a2, %sar, t0
 314 1:      stw,ma t0, 4(dstspc,dst)
 315         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcopy_done)
 316         ldo -4(len),len
 317         cmpb,COND(<>) %r0,len,.Ldo4
 318         nop
 319 .Ldo0:
 320         shrpw a2, a3, %sar, t0
 321 1:      stw,ma t0, 4(dstspc,dst)
 322         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcopy_done)
 323
 324 .Lcda_rdfault:
 325 .Lcda_finish:
 326         /* calculate new src, dst and len and jump to byte-copy loop */
 327         sub     dst,save_dst,t0
 328         add     save_src,t0,src
 329         b       .Lbyte_loop
 330         sub     save_len,t0,len
 331
 332 .Lcase3:
 333 1:      ldw,ma 4(srcspc,src), a0
 334         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 335 1:      ldw,ma 4(srcspc,src), a1
 336         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 337         b .Ldo2
 338         ldo 1(len),len
 339 .Lcase2:
 340 1:      ldw,ma 4(srcspc,src), a1
 341         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 342 1:      ldw,ma 4(srcspc,src), a2
 343         ASM_EXCEPTIONTABLE_ENTRY(1b,.Lcda_rdfault)
 344         b .Ldo1
 345         ldo 2(len),len
 346
 347
 348         /* fault exception fixup handlers: */
 349 #ifdef CONFIG_64BIT
 350 .Lcopy16_fault:
 351         b       .Lcopy_done
 352 10:     std,ma  t1,8(dstspc,dst)
 353         ASM_EXCEPTIONTABLE_ENTRY(10b,.Lcopy_done)
 354 #endif
 355
 356 .Lcopy8_fault:
 357         b       .Lcopy_done
 358 10:     stw,ma  t1,4(dstspc,dst)
 359         ASM_EXCEPTIONTABLE_ENTRY(10b,.Lcopy_done)
 360 ENDPROC_CFI(pa_memcpy)
 361
 362         .end