arch/sparc64/lib/U3memcpy.S

   1 /* U3memcpy.S: UltraSparc-III optimized memcpy.
   2  *
   3  * Copyright (C) 1999, 2000, 2004 David S. Miller (davem@redhat.com)
   4  */
   5
   6 #ifdef __KERNEL__
   7 #include <asm/visasm.h>
   8 #include <asm/asi.h>
   9 #else
  10 #define ASI_BLK_P 0xf0
  11 #define FPRS_FEF  0x04
  12 #ifdef MEMCPY_DEBUG
  13 #define VISEntryHalf rd %fprs, %o5; wr %g0, FPRS_FEF, %fprs; \
  14                      clr %g1; clr %g2; clr %g3; subcc %g0, %g0, %g0;
  15 #define VISExitHalf and %o5, FPRS_FEF, %o5; wr %o5, 0x0, %fprs
  16 #else
  17 #define VISEntryHalf rd %fprs, %o5; wr %g0, FPRS_FEF, %fprs
  18 #define VISExitHalf and %o5, FPRS_FEF, %o5; wr %o5, 0x0, %fprs
  19 #endif
  20 #endif
  21
  22 #ifndef EX_LD
  23 #define EX_LD(x)        x
  24 #endif
  25
  26 #ifndef EX_ST
  27 #define EX_ST(x)        x
  28 #endif
  29
  30 #ifndef EX_RETVAL
  31 #define EX_RETVAL(x)    x
  32 #endif
  33
  34 #ifndef LOAD
  35 #define LOAD(type,addr,dest)    type [addr], dest
  36 #endif
  37
  38 #ifndef STORE
  39 #define STORE(type,src,addr)    type src, [addr]
  40 #endif
  41
  42 #ifndef STORE_BLK
  43 #define STORE_BLK(src,addr)     stda src, [addr] ASI_BLK_P
  44 #endif
  45
  46 #ifndef FUNC_NAME
  47 #define FUNC_NAME       U3memcpy
  48 #endif
  49
  50 #ifndef PREAMBLE
  51 #define PREAMBLE
  52 #endif
  53
  54 #ifndef XCC
  55 #define XCC xcc
  56 #endif
  57
  58         .register       %g2,#scratch
  59         .register       %g3,#scratch
  60
  61         /* Special/non-trivial issues of this code:
  62          *
  63          * 1) %o5 is preserved from VISEntryHalf to VISExitHalf
  64          * 2) Only low 32 FPU registers are used so that only the
  65          *    lower half of the FPU register set is dirtied by this
  66          *    code.  This is especially important in the kernel.
  67          * 3) This code never prefetches cachelines past the end
  68          *    of the source buffer.
  69          */
  70
  71         .text
  72         .align          64
  73
  74         /* The cheetah's flexible spine, oversized liver, enlarged heart,
  75          * slender muscular body, and claws make it the swiftest hunter
  76          * in Africa and the fastest animal on land.  Can reach speeds
  77          * of up to 2.4GB per second.
  78          */
  79
  80         .globl  FUNC_NAME
  81         .type   FUNC_NAME,#function
  82 FUNC_NAME:      /* %o0=dst, %o1=src, %o2=len */
  83         PREAMBLE
  84         mov             %o0, %g5
  85         cmp             %o2, 0
  86         be,pn           %XCC, 85f
  87          or             %o0, %o1, %o3
  88         cmp             %o2, 16
  89         blu,a,pn        %XCC, 80f
  90          or             %o3, %o2, %o3
  91
  92         cmp             %o2, (3 * 64)
  93         blu,pt          %XCC, 70f
  94          andcc          %o3, 0x7, %g0
  95
  96         /* Clobbers o5/g1/g2/g3/g7/icc/xcc.  We must preserve
  97          * o5 from here until we hit VISExitHalf.
  98          */
  99         VISEntryHalf
 100
 101         /* Is 'dst' already aligned on an 64-byte boundary? */
 102         andcc           %o0, 0x3f, %g2
 103         be,pt           %XCC, 2f
 104
 105         /* Compute abs((dst & 0x3f) - 0x40) into %g2.  This is the number
 106          * of bytes to copy to make 'dst' 64-byte aligned.  We pre-
 107          * subtract this from 'len'.
 108          */
 109          sub            %o0, %o1, %o4
 110         sub             %g2, 0x40, %g2
 111         sub             %g0, %g2, %g2
 112         sub             %o2, %g2, %o2
 113         andcc           %g2, 0x7, %g1
 114         be,pt           %icc, 2f
 115          and            %g2, 0x38, %g2
 116
 117 1:      subcc           %g1, 0x1, %g1
 118         EX_LD(LOAD(ldub, %o1 + 0x00, %o3))
 119         EX_ST(STORE(stb, %o3, %o1 + %o4))
 120         bgu,pt          %XCC, 1b
 121          add            %o1, 0x1, %o1
 122
 123         add             %o1, %o4, %o0
 124
 125 2:      cmp             %g2, 0x0
 126         and             %o1, 0x7, %g1
 127         be,pt           %icc, 3f
 128          alignaddr      %o1, %g0, %o1
 129
 130         EX_LD(LOAD(ldd, %o1, %f4))
 131 1:      EX_LD(LOAD(ldd, %o1 + 0x8, %f6))
 132         add             %o1, 0x8, %o1
 133         subcc           %g2, 0x8, %g2
 134         faligndata      %f4, %f6, %f0
 135         EX_ST(STORE(std, %f0, %o0))
 136         be,pn           %icc, 3f
 137          add            %o0, 0x8, %o0
 138
 139         EX_LD(LOAD(ldd, %o1 + 0x8, %f4))
 140         add             %o1, 0x8, %o1
 141         subcc           %g2, 0x8, %g2
 142         faligndata      %f6, %f4, %f2
 143         EX_ST(STORE(std, %f2, %o0))
 144         bne,pt          %icc, 1b
 145          add            %o0, 0x8, %o0
 146
 147 3:      LOAD(prefetch, %o1 + 0x000, #one_read)
 148         LOAD(prefetch, %o1 + 0x040, #one_read)
 149         andn            %o2, (0x40 - 1), %o4
 150         LOAD(prefetch, %o1 + 0x080, #one_read)
 151         LOAD(prefetch, %o1 + 0x0c0, #one_read)
 152         LOAD(prefetch, %o1 + 0x100, #one_read)
 153         EX_LD(LOAD(ldd, %o1 + 0x000, %f0))
 154         LOAD(prefetch, %o1 + 0x140, #one_read)
 155         EX_LD(LOAD(ldd, %o1 + 0x008, %f2))
 156         LOAD(prefetch, %o1 + 0x180, #one_read)
 157         EX_LD(LOAD(ldd, %o1 + 0x010, %f4))
 158         LOAD(prefetch, %o1 + 0x1c0, #one_read)
 159         faligndata      %f0, %f2, %f16
 160         EX_LD(LOAD(ldd, %o1 + 0x018, %f6))
 161         faligndata      %f2, %f4, %f18
 162         EX_LD(LOAD(ldd, %o1 + 0x020, %f8))
 163         faligndata      %f4, %f6, %f20
 164         EX_LD(LOAD(ldd, %o1 + 0x028, %f10))
 165         faligndata      %f6, %f8, %f22
 166
 167         EX_LD(LOAD(ldd, %o1 + 0x030, %f12))
 168         faligndata      %f8, %f10, %f24
 169         EX_LD(LOAD(ldd, %o1 + 0x038, %f14))
 170         faligndata      %f10, %f12, %f26
 171         EX_LD(LOAD(ldd, %o1 + 0x040, %f0))
 172
 173         subcc           %o4, 0x80, %o4
 174         add             %o1, 0x40, %o1
 175         bgu,pt          %XCC, 1f
 176          srl            %o4, 6, %o3
 177         ba,pt           %xcc, 2f
 178          nop
 179
 180         .align          64
 181 1:
 182         EX_LD(LOAD(ldd, %o1 + 0x008, %f2))
 183         faligndata      %f12, %f14, %f28
 184         EX_LD(LOAD(ldd, %o1 + 0x010, %f4))
 185         faligndata      %f14, %f0, %f30
 186         EX_ST(STORE_BLK(%f16, %o0))
 187         EX_LD(LOAD(ldd, %o1 + 0x018, %f6))
 188         faligndata      %f0, %f2, %f16
 189         add             %o0, 0x40, %o0
 190
 191         EX_LD(LOAD(ldd, %o1 + 0x020, %f8))
 192         faligndata      %f2, %f4, %f18
 193         EX_LD(LOAD(ldd, %o1 + 0x028, %f10))
 194         faligndata      %f4, %f6, %f20
 195         EX_LD(LOAD(ldd, %o1 + 0x030, %f12))
 196         subcc           %o3, 0x01, %o3
 197         faligndata      %f6, %f8, %f22
 198         EX_LD(LOAD(ldd, %o1 + 0x038, %f14))
 199
 200         faligndata      %f8, %f10, %f24
 201         EX_LD(LOAD(ldd, %o1 + 0x040, %f0))
 202         LOAD(prefetch, %o1 + 0x1c0, #one_read)
 203         faligndata      %f10, %f12, %f26
 204         bg,pt           %XCC, 1b
 205          add            %o1, 0x40, %o1
 206
 207         /* Finally we copy the last full 64-byte block. */
 208 2:
 209         EX_LD(LOAD(ldd, %o1 + 0x008, %f2))
 210         faligndata      %f12, %f14, %f28
 211         EX_LD(LOAD(ldd, %o1 + 0x010, %f4))
 212         faligndata      %f14, %f0, %f30
 213         EX_ST(STORE_BLK(%f16, %o0))
 214         EX_LD(LOAD(ldd, %o1 + 0x018, %f6))
 215         faligndata      %f0, %f2, %f16
 216         EX_LD(LOAD(ldd, %o1 + 0x020, %f8))
 217         faligndata      %f2, %f4, %f18
 218         EX_LD(LOAD(ldd, %o1 + 0x028, %f10))
 219         faligndata      %f4, %f6, %f20
 220         EX_LD(LOAD(ldd, %o1 + 0x030, %f12))
 221         faligndata      %f6, %f8, %f22
 222         EX_LD(LOAD(ldd, %o1 + 0x038, %f14))
 223         faligndata      %f8, %f10, %f24
 224         cmp             %g1, 0
 225         be,pt           %XCC, 1f
 226          add            %o0, 0x40, %o0
 227         EX_LD(LOAD(ldd, %o1 + 0x040, %f0))
 228 1:      faligndata      %f10, %f12, %f26
 229         faligndata      %f12, %f14, %f28
 230         faligndata      %f14, %f0, %f30
 231         EX_ST(STORE_BLK(%f16, %o0))
 232         add             %o0, 0x40, %o0
 233         add             %o1, 0x40, %o1
 234         membar          #Sync
 235
 236         /* Now we copy the (len modulo 64) bytes at the end.
 237          * Note how we borrow the %f0 loaded above.
 238          *
 239          * Also notice how this code is careful not to perform a
 240          * load past the end of the src buffer.
 241          */
 242         and             %o2, 0x3f, %o2
 243         andcc           %o2, 0x38, %g2
 244         be,pn           %XCC, 2f
 245          subcc          %g2, 0x8, %g2
 246         be,pn           %XCC, 2f
 247          cmp            %g1, 0
 248
 249         sub             %o2, %g2, %o2
 250         be,a,pt         %XCC, 1f
 251          EX_LD(LOAD(ldd, %o1 + 0x00, %f0))
 252
 253 1:      EX_LD(LOAD(ldd, %o1 + 0x08, %f2))
 254         add             %o1, 0x8, %o1
 255         subcc           %g2, 0x8, %g2
 256         faligndata      %f0, %f2, %f8
 257         EX_ST(STORE(std, %f8, %o0))
 258         be,pn           %XCC, 2f
 259          add            %o0, 0x8, %o0
 260         EX_LD(LOAD(ldd, %o1 + 0x08, %f0))
 261         add             %o1, 0x8, %o1
 262         subcc           %g2, 0x8, %g2
 263         faligndata      %f2, %f0, %f8
 264         EX_ST(STORE(std, %f8, %o0))
 265         bne,pn          %XCC, 1b
 266          add            %o0, 0x8, %o0
 267
 268         /* If anything is left, we copy it one byte at a time.
 269          * Note that %g1 is (src & 0x3) saved above before the
 270          * alignaddr was performed.
 271          */
 272 2:
 273         cmp             %o2, 0
 274         add             %o1, %g1, %o1
 275         VISExitHalf
 276         be,pn           %XCC, 85f
 277          sub            %o0, %o1, %o3
 278
 279         andcc           %g1, 0x7, %g0
 280         bne,pn          %icc, 90f
 281          andcc          %o2, 0x8, %g0
 282         be,pt           %icc, 1f
 283          nop
 284         EX_LD(LOAD(ldx, %o1, %o5))
 285         EX_ST(STORE(stx, %o5, %o1 + %o3))
 286         add             %o1, 0x8, %o1
 287
 288 1:      andcc           %o2, 0x4, %g0
 289         be,pt           %icc, 1f
 290          nop
 291         EX_LD(LOAD(lduw, %o1, %o5))
 292         EX_ST(STORE(stw, %o5, %o1 + %o3))
 293         add             %o1, 0x4, %o1
 294
 295 1:      andcc           %o2, 0x2, %g0
 296         be,pt           %icc, 1f
 297          nop
 298         EX_LD(LOAD(lduh, %o1, %o5))
 299         EX_ST(STORE(sth, %o5, %o1 + %o3))
 300         add             %o1, 0x2, %o1
 301
 302 1:      andcc           %o2, 0x1, %g0
 303         be,pt           %icc, 85f
 304          nop
 305         EX_LD(LOAD(ldub, %o1, %o5))
 306         ba,pt           %xcc, 85f
 307          EX_ST(STORE(stb, %o5, %o1 + %o3))
 308
 309         .align          64
 310 70: /* 16 < len <= 64 */
 311         bne,pn          %XCC, 75f
 312          sub            %o0, %o1, %o3
 313
 314 72:
 315         andn            %o2, 0xf, %o4
 316         and             %o2, 0xf, %o2
 317 1:      subcc           %o4, 0x10, %o4
 318         EX_LD(LOAD(ldx, %o1 + 0x00, %o5))
 319         EX_LD(LOAD(ldx, %o1 + 0x08, %g1))
 320         EX_ST(STORE(stx, %o5, %o1 + %o3))
 321         add             %o1, 0x8, %o1
 322         EX_ST(STORE(stx, %g1, %o1 + %o3))
 323         bgu,pt          %XCC, 1b
 324          add            %o1, 0x8, %o1
 325 73:     andcc           %o2, 0x8, %g0
 326         be,pt           %XCC, 1f
 327          nop
 328         sub             %o2, 0x8, %o2
 329         EX_LD(LOAD(ldx, %o1, %o5))
 330         EX_ST(STORE(stx, %o5, %o1 + %o3))
 331         add             %o1, 0x8, %o1
 332 1:      andcc           %o2, 0x4, %g0
 333         be,pt           %XCC, 1f
 334          nop
 335         sub             %o2, 0x4, %o2
 336         EX_LD(LOAD(lduw, %o1, %o5))
 337         EX_ST(STORE(stw, %o5, %o1 + %o3))
 338         add             %o1, 0x4, %o1
 339 1:      cmp             %o2, 0
 340         be,pt           %XCC, 85f
 341          nop
 342         ba,pt           %xcc, 90f
 343          nop
 344
 345 75:
 346         andcc           %o0, 0x7, %g1
 347         sub             %g1, 0x8, %g1
 348         be,pn           %icc, 2f
 349          sub            %g0, %g1, %g1
 350         sub             %o2, %g1, %o2
 351
 352 1:      subcc           %g1, 1, %g1
 353         EX_LD(LOAD(ldub, %o1, %o5))
 354         EX_ST(STORE(stb, %o5, %o1 + %o3))
 355         bgu,pt          %icc, 1b
 356          add            %o1, 1, %o1
 357
 358 2:      add             %o1, %o3, %o0
 359         andcc           %o1, 0x7, %g1
 360         bne,pt          %icc, 8f
 361          sll            %g1, 3, %g1
 362
 363         cmp             %o2, 16
 364         bgeu,pt         %icc, 72b
 365          nop
 366         ba,a,pt         %xcc, 73b
 367
 368 8:      mov             64, %o3
 369         andn            %o1, 0x7, %o1
 370         EX_LD(LOAD(ldx, %o1, %g2))
 371         sub             %o3, %g1, %o3
 372         andn            %o2, 0x7, %o4
 373         sllx            %g2, %g1, %g2
 374 1:      EX_LD(LOAD(ldx, %o1 + 0x8, %g3))
 375         subcc           %o4, 0x8, %o4
 376         add             %o1, 0x8, %o1
 377         srlx            %g3, %o3, %o5
 378         or              %o5, %g2, %o5
 379         EX_ST(STORE(stx, %o5, %o0))
 380         add             %o0, 0x8, %o0
 381         bgu,pt          %icc, 1b
 382          sllx           %g3, %g1, %g2
 383
 384         srl             %g1, 3, %g1
 385         andcc           %o2, 0x7, %o2
 386         be,pn           %icc, 85f
 387          add            %o1, %g1, %o1
 388         ba,pt           %xcc, 90f
 389          sub            %o0, %o1, %o3
 390
 391         .align          64
 392 80: /* 0 < len <= 16 */
 393         andcc           %o3, 0x3, %g0
 394         bne,pn          %XCC, 90f
 395          sub            %o0, %o1, %o3
 396
 397 1:
 398         subcc           %o2, 4, %o2
 399         EX_LD(LOAD(lduw, %o1, %g1))
 400         EX_ST(STORE(stw, %g1, %o1 + %o3))
 401         bgu,pt          %XCC, 1b
 402          add            %o1, 4, %o1
 403
 404 85:     retl
 405          mov            EX_RETVAL(%g5), %o0
 406
 407         .align          32
 408 90:
 409         subcc           %o2, 1, %o2
 410         EX_LD(LOAD(ldub, %o1, %g1))
 411         EX_ST(STORE(stb, %g1, %o1 + %o3))
 412         bgu,pt          %XCC, 90b
 413          add            %o1, 1, %o1
 414         retl
 415          mov            EX_RETVAL(%g5), %o0
 416
 417         .size           FUNC_NAME, .-FUNC_NAME