arch/sparc/lib/NG4memcpy.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /* NG4memcpy.S: Niagara-4 optimized memcpy.
   3  *
   4  * Copyright (C) 2012 David S. Miller (davem@davemloft.net)
   5  */
   6
   7 #ifdef __KERNEL__
   8 #include <linux/linkage.h>
   9 #include <asm/visasm.h>
  10 #include <asm/asi.h>
  11 #define GLOBAL_SPARE    %g7
  12 #else
  13 #define ASI_BLK_INIT_QUAD_LDD_P 0xe2
  14 #define FPRS_FEF  0x04
  15
  16 /* On T4 it is very expensive to access ASRs like %fprs and
  17  * %asi, avoiding a read or a write can save ~50 cycles.
  18  */
  19 #define FPU_ENTER                       \
  20         rd      %fprs, %o5;             \
  21         andcc   %o5, FPRS_FEF, %g0;     \
  22         be,a,pn %icc, 999f;             \
  23          wr     %g0, FPRS_FEF, %fprs;   \
  24         999:
  25
  26 #ifdef MEMCPY_DEBUG
  27 #define VISEntryHalf FPU_ENTER; \
  28                      clr %g1; clr %g2; clr %g3; clr %g5; subcc %g0, %g0, %g0;
  29 #define VISExitHalf and %o5, FPRS_FEF, %o5; wr %o5, 0x0, %fprs
  30 #else
  31 #define VISEntryHalf FPU_ENTER
  32 #define VISExitHalf and %o5, FPRS_FEF, %o5; wr %o5, 0x0, %fprs
  33 #endif
  34
  35 #define GLOBAL_SPARE    %g5
  36 #endif
  37
  38 #ifndef STORE_ASI
  39 #ifndef SIMULATE_NIAGARA_ON_NON_NIAGARA
  40 #define STORE_ASI       ASI_BLK_INIT_QUAD_LDD_P
  41 #else
  42 #define STORE_ASI       0x80            /* ASI_P */
  43 #endif
  44 #endif
  45
  46 #if !defined(EX_LD) && !defined(EX_ST)
  47 #define NON_USER_COPY
  48 #endif
  49
  50 #ifndef EX_LD
  51 #define EX_LD(x,y)      x
  52 #endif
  53 #ifndef EX_LD_FP
  54 #define EX_LD_FP(x,y)   x
  55 #endif
  56
  57 #ifndef EX_ST
  58 #define EX_ST(x,y)      x
  59 #endif
  60 #ifndef EX_ST_FP
  61 #define EX_ST_FP(x,y)   x
  62 #endif
  63
  64
  65 #ifndef LOAD
  66 #define LOAD(type,addr,dest)    type [addr], dest
  67 #endif
  68
  69 #ifndef STORE
  70 #ifndef MEMCPY_DEBUG
  71 #define STORE(type,src,addr)    type src, [addr]
  72 #else
  73 #define STORE(type,src,addr)    type##a src, [addr] %asi
  74 #endif
  75 #endif
  76
  77 #ifndef STORE_INIT
  78 #define STORE_INIT(src,addr)    stxa src, [addr] STORE_ASI
  79 #endif
  80
  81 #ifndef FUNC_NAME
  82 #define FUNC_NAME       NG4memcpy
  83 #endif
  84 #ifndef PREAMBLE
  85 #define PREAMBLE
  86 #endif
  87
  88 #ifndef XCC
  89 #define XCC xcc
  90 #endif
  91
  92         .register       %g2,#scratch
  93         .register       %g3,#scratch
  94
  95         .text
  96 #ifndef EX_RETVAL
  97 #define EX_RETVAL(x)    x
  98 #endif
  99         .align          64
 100
 101         .globl  FUNC_NAME
 102         .type   FUNC_NAME,#function
 103 FUNC_NAME:      /* %o0=dst, %o1=src, %o2=len */
 104 #ifdef MEMCPY_DEBUG
 105         wr              %g0, 0x80, %asi
 106 #endif
 107         srlx            %o2, 31, %g2
 108         cmp             %g2, 0
 109         tne             %XCC, 5
 110         PREAMBLE
 111         mov             %o0, %o3
 112         brz,pn          %o2, .Lexit
 113          cmp            %o2, 3
 114         ble,pn          %icc, .Ltiny
 115          cmp            %o2, 19
 116         ble,pn          %icc, .Lsmall
 117          or             %o0, %o1, %g2
 118         cmp             %o2, 128
 119         bl,pn           %icc, .Lmedium
 120          nop
 121
 122 .Llarge:/* len >= 0x80 */
 123         /* First get dest 8 byte aligned.  */
 124         sub             %g0, %o0, %g1
 125         and             %g1, 0x7, %g1
 126         brz,pt          %g1, 51f
 127          sub            %o2, %g1, %o2
 128
 129
 130 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 131         add             %o1, 1, %o1
 132         subcc           %g1, 1, %g1
 133         add             %o0, 1, %o0
 134         bne,pt          %icc, 1b
 135          EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
 136
 137 51:     LOAD(prefetch, %o1 + 0x040, #n_reads_strong)
 138         LOAD(prefetch, %o1 + 0x080, #n_reads_strong)
 139         LOAD(prefetch, %o1 + 0x0c0, #n_reads_strong)
 140         LOAD(prefetch, %o1 + 0x100, #n_reads_strong)
 141         LOAD(prefetch, %o1 + 0x140, #n_reads_strong)
 142         LOAD(prefetch, %o1 + 0x180, #n_reads_strong)
 143         LOAD(prefetch, %o1 + 0x1c0, #n_reads_strong)
 144         LOAD(prefetch, %o1 + 0x200, #n_reads_strong)
 145
 146         /* Check if we can use the straight fully aligned
 147          * loop, or we require the alignaddr/faligndata variant.
 148          */
 149         andcc           %o1, 0x7, %o5
 150         bne,pn          %icc, .Llarge_src_unaligned
 151          sub            %g0, %o0, %g1
 152
 153         /* Legitimize the use of initializing stores by getting dest
 154          * to be 64-byte aligned.
 155          */
 156         and             %g1, 0x3f, %g1
 157         brz,pt          %g1, .Llarge_aligned
 158          sub            %o2, %g1, %o2
 159
 160 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 161         add             %o1, 8, %o1
 162         subcc           %g1, 8, %g1
 163         add             %o0, 8, %o0
 164         bne,pt          %icc, 1b
 165          EX_ST(STORE(stx, %g2, %o0 - 0x08), memcpy_retl_o2_plus_g1_plus_8)
 166
 167 .Llarge_aligned:
 168         /* len >= 0x80 && src 8-byte aligned && dest 8-byte aligned */
 169         andn            %o2, 0x3f, %o4
 170         sub             %o2, %o4, %o2
 171
 172 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o4)
 173         add             %o1, 0x40, %o1
 174         EX_LD(LOAD(ldx, %o1 - 0x38, %g2), memcpy_retl_o2_plus_o4)
 175         subcc           %o4, 0x40, %o4
 176         EX_LD(LOAD(ldx, %o1 - 0x30, %g3), memcpy_retl_o2_plus_o4_plus_64)
 177         EX_LD(LOAD(ldx, %o1 - 0x28, GLOBAL_SPARE), memcpy_retl_o2_plus_o4_plus_64)
 178         EX_LD(LOAD(ldx, %o1 - 0x20, %o5), memcpy_retl_o2_plus_o4_plus_64)
 179         EX_ST(STORE_INIT(%g1, %o0), memcpy_retl_o2_plus_o4_plus_64)
 180         add             %o0, 0x08, %o0
 181         EX_ST(STORE_INIT(%g2, %o0), memcpy_retl_o2_plus_o4_plus_56)
 182         add             %o0, 0x08, %o0
 183         EX_LD(LOAD(ldx, %o1 - 0x18, %g2), memcpy_retl_o2_plus_o4_plus_48)
 184         EX_ST(STORE_INIT(%g3, %o0), memcpy_retl_o2_plus_o4_plus_48)
 185         add             %o0, 0x08, %o0
 186         EX_LD(LOAD(ldx, %o1 - 0x10, %g3), memcpy_retl_o2_plus_o4_plus_40)
 187         EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), memcpy_retl_o2_plus_o4_plus_40)
 188         add             %o0, 0x08, %o0
 189         EX_LD(LOAD(ldx, %o1 - 0x08, GLOBAL_SPARE), memcpy_retl_o2_plus_o4_plus_32)
 190         EX_ST(STORE_INIT(%o5, %o0), memcpy_retl_o2_plus_o4_plus_32)
 191         add             %o0, 0x08, %o0
 192         EX_ST(STORE_INIT(%g2, %o0), memcpy_retl_o2_plus_o4_plus_24)
 193         add             %o0, 0x08, %o0
 194         EX_ST(STORE_INIT(%g3, %o0), memcpy_retl_o2_plus_o4_plus_16)
 195         add             %o0, 0x08, %o0
 196         EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), memcpy_retl_o2_plus_o4_plus_8)
 197         add             %o0, 0x08, %o0
 198         bne,pt          %icc, 1b
 199          LOAD(prefetch, %o1 + 0x200, #n_reads_strong)
 200
 201         membar          #StoreLoad | #StoreStore
 202
 203         brz,pn          %o2, .Lexit
 204          cmp            %o2, 19
 205         ble,pn          %icc, .Lsmall_unaligned
 206          nop
 207         ba,a,pt         %icc, .Lmedium_noprefetch
 208
 209 .Lexit: retl
 210          mov            EX_RETVAL(%o3), %o0
 211
 212 .Llarge_src_unaligned:
 213 #ifdef NON_USER_COPY
 214         VISEntryHalfFast(.Lmedium_vis_entry_fail)
 215 #else
 216         VISEntryHalf
 217 #endif
 218         andn            %o2, 0x3f, %o4
 219         sub             %o2, %o4, %o2
 220         alignaddr       %o1, %g0, %g1
 221         add             %o1, %o4, %o1
 222         EX_LD_FP(LOAD(ldd, %g1 + 0x00, %f0), memcpy_retl_o2_plus_o4)
 223 1:      EX_LD_FP(LOAD(ldd, %g1 + 0x08, %f2), memcpy_retl_o2_plus_o4)
 224         subcc           %o4, 0x40, %o4
 225         EX_LD_FP(LOAD(ldd, %g1 + 0x10, %f4), memcpy_retl_o2_plus_o4_plus_64)
 226         EX_LD_FP(LOAD(ldd, %g1 + 0x18, %f6), memcpy_retl_o2_plus_o4_plus_64)
 227         EX_LD_FP(LOAD(ldd, %g1 + 0x20, %f8), memcpy_retl_o2_plus_o4_plus_64)
 228         EX_LD_FP(LOAD(ldd, %g1 + 0x28, %f10), memcpy_retl_o2_plus_o4_plus_64)
 229         EX_LD_FP(LOAD(ldd, %g1 + 0x30, %f12), memcpy_retl_o2_plus_o4_plus_64)
 230         EX_LD_FP(LOAD(ldd, %g1 + 0x38, %f14), memcpy_retl_o2_plus_o4_plus_64)
 231         faligndata      %f0, %f2, %f16
 232         EX_LD_FP(LOAD(ldd, %g1 + 0x40, %f0), memcpy_retl_o2_plus_o4_plus_64)
 233         faligndata      %f2, %f4, %f18
 234         add             %g1, 0x40, %g1
 235         faligndata      %f4, %f6, %f20
 236         faligndata      %f6, %f8, %f22
 237         faligndata      %f8, %f10, %f24
 238         faligndata      %f10, %f12, %f26
 239         faligndata      %f12, %f14, %f28
 240         faligndata      %f14, %f0, %f30
 241         EX_ST_FP(STORE(std, %f16, %o0 + 0x00), memcpy_retl_o2_plus_o4_plus_64)
 242         EX_ST_FP(STORE(std, %f18, %o0 + 0x08), memcpy_retl_o2_plus_o4_plus_56)
 243         EX_ST_FP(STORE(std, %f20, %o0 + 0x10), memcpy_retl_o2_plus_o4_plus_48)
 244         EX_ST_FP(STORE(std, %f22, %o0 + 0x18), memcpy_retl_o2_plus_o4_plus_40)
 245         EX_ST_FP(STORE(std, %f24, %o0 + 0x20), memcpy_retl_o2_plus_o4_plus_32)
 246         EX_ST_FP(STORE(std, %f26, %o0 + 0x28), memcpy_retl_o2_plus_o4_plus_24)
 247         EX_ST_FP(STORE(std, %f28, %o0 + 0x30), memcpy_retl_o2_plus_o4_plus_16)
 248         EX_ST_FP(STORE(std, %f30, %o0 + 0x38), memcpy_retl_o2_plus_o4_plus_8)
 249         add             %o0, 0x40, %o0
 250         bne,pt          %icc, 1b
 251          LOAD(prefetch, %g1 + 0x200, #n_reads_strong)
 252 #ifdef NON_USER_COPY
 253         VISExitHalfFast
 254 #else
 255         VISExitHalf
 256 #endif
 257         brz,pn          %o2, .Lexit
 258          cmp            %o2, 19
 259         ble,pn          %icc, .Lsmall_unaligned
 260          nop
 261         ba,a,pt         %icc, .Lmedium_unaligned
 262
 263 #ifdef NON_USER_COPY
 264 .Lmedium_vis_entry_fail:
 265          or             %o0, %o1, %g2
 266 #endif
 267 .Lmedium:
 268         LOAD(prefetch, %o1 + 0x40, #n_reads_strong)
 269         andcc           %g2, 0x7, %g0
 270         bne,pn          %icc, .Lmedium_unaligned
 271          nop
 272 .Lmedium_noprefetch:
 273         andncc          %o2, 0x20 - 1, %o5
 274         be,pn           %icc, 2f
 275          sub            %o2, %o5, %o2
 276 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
 277         EX_LD(LOAD(ldx, %o1 + 0x08, %g2), memcpy_retl_o2_plus_o5)
 278         EX_LD(LOAD(ldx, %o1 + 0x10, GLOBAL_SPARE), memcpy_retl_o2_plus_o5)
 279         EX_LD(LOAD(ldx, %o1 + 0x18, %o4), memcpy_retl_o2_plus_o5)
 280         add             %o1, 0x20, %o1
 281         subcc           %o5, 0x20, %o5
 282         EX_ST(STORE(stx, %g1, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_32)
 283         EX_ST(STORE(stx, %g2, %o0 + 0x08), memcpy_retl_o2_plus_o5_plus_24)
 284         EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x10), memcpy_retl_o2_plus_o5_plus_24)
 285         EX_ST(STORE(stx, %o4, %o0 + 0x18), memcpy_retl_o2_plus_o5_plus_8)
 286         bne,pt          %icc, 1b
 287          add            %o0, 0x20, %o0
 288 2:      andcc           %o2, 0x18, %o5
 289         be,pt           %icc, 3f
 290          sub            %o2, %o5, %o2
 291
 292 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
 293         add             %o1, 0x08, %o1
 294         add             %o0, 0x08, %o0
 295         subcc           %o5, 0x08, %o5
 296         bne,pt          %icc, 1b
 297          EX_ST(STORE(stx, %g1, %o0 - 0x08), memcpy_retl_o2_plus_o5_plus_8)
 298 3:      brz,pt          %o2, .Lexit
 299          cmp            %o2, 0x04
 300         bl,pn           %icc, .Ltiny
 301          nop
 302         EX_LD(LOAD(lduw, %o1 + 0x00, %g1), memcpy_retl_o2)
 303         add             %o1, 0x04, %o1
 304         add             %o0, 0x04, %o0
 305         subcc           %o2, 0x04, %o2
 306         bne,pn          %icc, .Ltiny
 307          EX_ST(STORE(stw, %g1, %o0 - 0x04), memcpy_retl_o2_plus_4)
 308         ba,a,pt         %icc, .Lexit
 309 .Lmedium_unaligned:
 310         /* First get dest 8 byte aligned.  */
 311         sub             %g0, %o0, %g1
 312         and             %g1, 0x7, %g1
 313         brz,pt          %g1, 2f
 314          sub            %o2, %g1, %o2
 315
 316 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 317         add             %o1, 1, %o1
 318         subcc           %g1, 1, %g1
 319         add             %o0, 1, %o0
 320         bne,pt          %icc, 1b
 321          EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
 322 2:
 323         and             %o1, 0x7, %g1
 324         brz,pn          %g1, .Lmedium_noprefetch
 325          sll            %g1, 3, %g1
 326         mov             64, %g2
 327         sub             %g2, %g1, %g2
 328         andn            %o1, 0x7, %o1
 329         EX_LD(LOAD(ldx, %o1 + 0x00, %o4), memcpy_retl_o2)
 330         sllx            %o4, %g1, %o4
 331         andn            %o2, 0x08 - 1, %o5
 332         sub             %o2, %o5, %o2
 333 1:      EX_LD(LOAD(ldx, %o1 + 0x08, %g3), memcpy_retl_o2_plus_o5)
 334         add             %o1, 0x08, %o1
 335         subcc           %o5, 0x08, %o5
 336         srlx            %g3, %g2, GLOBAL_SPARE
 337         or              GLOBAL_SPARE, %o4, GLOBAL_SPARE
 338         EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_8)
 339         add             %o0, 0x08, %o0
 340         bne,pt          %icc, 1b
 341          sllx           %g3, %g1, %o4
 342         srl             %g1, 3, %g1
 343         add             %o1, %g1, %o1
 344         brz,pn          %o2, .Lexit
 345          nop
 346         ba,pt           %icc, .Lsmall_unaligned
 347
 348 .Ltiny:
 349         EX_LD(LOAD(ldub, %o1 + 0x00, %g1), memcpy_retl_o2)
 350         subcc           %o2, 1, %o2
 351         be,pn           %icc, .Lexit
 352          EX_ST(STORE(stb, %g1, %o0 + 0x00), memcpy_retl_o2_plus_1)
 353         EX_LD(LOAD(ldub, %o1 + 0x01, %g1), memcpy_retl_o2)
 354         subcc           %o2, 1, %o2
 355         be,pn           %icc, .Lexit
 356          EX_ST(STORE(stb, %g1, %o0 + 0x01), memcpy_retl_o2_plus_1)
 357         EX_LD(LOAD(ldub, %o1 + 0x02, %g1), memcpy_retl_o2)
 358         ba,pt           %icc, .Lexit
 359          EX_ST(STORE(stb, %g1, %o0 + 0x02), memcpy_retl_o2)
 360
 361 .Lsmall:
 362         andcc           %g2, 0x3, %g0
 363         bne,pn          %icc, .Lsmall_unaligned
 364          andn           %o2, 0x4 - 1, %o5
 365         sub             %o2, %o5, %o2
 366 1:
 367         EX_LD(LOAD(lduw, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
 368         add             %o1, 0x04, %o1
 369         subcc           %o5, 0x04, %o5
 370         add             %o0, 0x04, %o0
 371         bne,pt          %icc, 1b
 372          EX_ST(STORE(stw, %g1, %o0 - 0x04), memcpy_retl_o2_plus_o5_plus_4)
 373         brz,pt          %o2, .Lexit
 374          nop
 375         ba,a,pt         %icc, .Ltiny
 376
 377 .Lsmall_unaligned:
 378 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g1), memcpy_retl_o2)
 379         add             %o1, 1, %o1
 380         add             %o0, 1, %o0
 381         subcc           %o2, 1, %o2
 382         bne,pt          %icc, 1b
 383          EX_ST(STORE(stb, %g1, %o0 - 0x01), memcpy_retl_o2_plus_1)
 384         ba,a,pt         %icc, .Lexit
 385          nop
 386         .size           FUNC_NAME, .-FUNC_NAME