arm/string/bzero.s

   1 /*
   2  * Copyright (c) 2006 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 #include <mach/machine/asm.h>
  25 #include <architecture/arm/asm_help.h>
  26
  27 /*
  28  * A reasonably well-optimized bzero/memset. Should work equally well on arm11 and arm9 based
  29  * cores.
  30  *
  31  * The algorithm is to align the destination pointer on a 32 byte boundary and then
  32  * blast data 64 bytes at a time, in two stores of 32 bytes per loop.
  33  */
  34         .text
  35         .align 2
  36
  37         .globl _memset
  38 /* void *memset(void *ptr, int c, size_t len); */
  39 _memset:
  40         /* move len into r1, unpack c into r2 */
  41         mov             r3, r2
  42         and             r1, r1, #0xff
  43         orr             r1, r1, r1, lsl #8
  44         orr             r2, r1, r1, lsl #16
  45         mov             r1, r3
  46         b               Lbzeroengine
  47
  48         .globl _bzero
  49 /* void bzero(void *ptr, size_t len); */
  50 _bzero:
  51         /* zero out r2 so we can be just like memset(0) */
  52         mov             r2, #0
  53
  54 Lbzeroengine:
  55         /* move the base pointer into r12 and leave r0 alone so that we return the original pointer */
  56         mov             r12, r0
  57
  58         /* copy r2 into r3 for 64-bit stores */
  59         mov             r3, r2
  60
  61         /* check for zero len */
  62         cmp             r1, #0
  63         bxeq    lr
  64
  65         /* fall back to a bytewise store for less than 32 bytes */
  66         cmp             r1, #32
  67         blt             L_bytewise
  68
  69         /* check for 32 byte unaligned ptr */
  70         tst             r12, #0x1f
  71         bne             L_unaligned
  72
  73         /* make sure we have more than 64 bytes to zero */
  74         cmp             r1, #64
  75         blt             L_lessthan64aligned
  76
  77         /* >= 64 bytes of len, 32 byte aligned */
  78 L_64ormorealigned:
  79
  80         /* we need some registers, avoid r7 (frame pointer) and r9 (thread register) */
  81         stmfd   sp!, { r4-r6, r8, r10-r11 }
  82         mov             r4, r2
  83         mov             r5, r2
  84         mov             r6, r2
  85         mov             r8, r2
  86         mov             r10, r2
  87         mov             r11, r2
  88
  89         /* pre-subtract 64 from the len to avoid an extra compare in the loop */
  90         sub             r1, r1, #64
  91
  92 L_64loop:
  93         stmia   r12!, { r2-r6, r8, r10-r11 }
  94         subs    r1, r1, #64
  95         stmia   r12!, { r2-r6, r8, r10-r11 }
  96         bge             L_64loop
  97
  98         /* restore the saved regs */
  99         ldmfd   sp!, { r4-r6, r8, r10-r11 }
 100
 101         /* check for completion (had previously subtracted an extra 64 from len) */
 102         adds    r1, r1, #64
 103         bxeq    lr
 104
 105 L_lessthan64aligned:
 106         /* do we have 16 or more bytes left */
 107         cmp             r1, #16
 108         stmgeia r12!, { r2-r3 }
 109         stmgeia r12!, { r2-r3 }
 110         subges  r1, r1, #16
 111         bgt             L_lessthan64aligned
 112         bxeq    lr
 113
 114 L_lessthan16aligned:
 115         /* store 0 to 15 bytes */
 116         mov             r1, r1, lsl #28         /* move the remaining len bits [3:0] to the flags area of cpsr */
 117         msr             cpsr_f, r1
 118
 119         stmmiia r12!, { r2-r3 }         /* n is set, store 8 bytes */
 120         streq   r2, [r12], #4           /* z is set, store 4 bytes */
 121         strcsh  r2, [r12], #2           /* c is set, store 2 bytes */
 122         strvsb  r2, [r12], #1           /* v is set, store 1 byte */
 123         bx              lr
 124
 125 L_bytewise:
 126         /* bytewise copy, 2 bytes at a time, alignment not guaranteed */
 127         subs    r1, r1, #2
 128         strb    r2, [r12], #1
 129         strplb  r2, [r12], #1
 130         bhi             L_bytewise
 131         bx              lr
 132
 133 L_unaligned:
 134         /* unaligned on 32 byte boundary, store 1-15 bytes until we're 16 byte aligned */
 135         mov             r3, r12, lsl #28
 136         rsb     r3, r3, #0x00000000
 137         msr             cpsr_f, r3
 138
 139         strvsb  r2, [r12], #1           /* v is set, unaligned in the 1s column */
 140         strcsh  r2, [r12], #2           /* c is set, unaligned in the 2s column */
 141         streq   r2, [r12], #4           /* z is set, unaligned in the 4s column */
 142         strmi   r2, [r12], #4           /* n is set, unaligned in the 8s column */
 143         strmi   r2, [r12], #4
 144
 145         subs    r1, r1, r3, lsr #28
 146         bxeq    lr
 147
 148         /* we had previously trashed r3, restore it */
 149         mov             r3, r2
 150
 151         /* now make sure we're 32 byte aligned */
 152         tst             r12, #(1 << 4)
 153         stmneia r12!, { r2-r3 }
 154         stmneia r12!, { r2-r3 }
 155         subnes  r1, r1, #16
 156
 157         /* we're now aligned, check for >= 64 bytes left */
 158         cmp             r1, #64
 159         bge             L_64ormorealigned
 160         b               L_lessthan64aligned
 161
 162 X_LEAF(___bzero, _bzero)