/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Changes:
 * 2010-08-11 Steve McIntyre <steve.mcintyre@arm.com>
 *    Added small changes to the two functions to make them work on the
 *    specified number of 16- or 32-bit values rather than the original
 *    code which was specified as a count of bytes. More verbose comments
 *    to aid future maintenance.
 */

    .text
    .align

    .global arm_memset32
    .type   arm_memset32, %function
    .global arm_memset16
    .type   arm_memset16, %function

/*
 * Optimized memset functions for ARM.
 *
 * void arm_memset16(uint16_t* dst, uint16_t value, int count);
 * void arm_memset32(uint32_t* dst, uint32_t value, int count);
 *
 */
arm_memset16:
        .fnstart
        push        {lr}

        /* expand the data to 32 bits */
        orr         r1, r1, lsl #16

        /* align to 32 bits */
        tst         r0, #2
        strneh      r1, [r0], #2
        subne       r2, r2, #2

        /* Multiply count by 2 - go from the number of 16-bit shorts
         * to the number of bytes desired. */
        mov         r2, r2, lsl #1

        /* Now jump into the main loop below. */
        b           .Lwork_32
        .fnend

arm_memset32:
        .fnstart
        push        {lr}

        /* Multiply count by 4 - go from the number of 32-bit words to
         * the number of bytes desired. */
        mov         r2, r2, lsl #2

.Lwork_32:
        /* Set up registers ready for writing them out. */
        mov         ip, r1
        mov         lr, r1

        /* Try to align the destination to a cache line. Assume 32
         * byte (8 word) cache lines, it's the common case. */
        rsb         r3, r0, #0
        ands        r3, r3, #0x1C
        beq         .Laligned32
        cmp         r3, r2
        andhi       r3, r2, #0x1C
        sub         r2, r2, r3

        /* (Optionally) write any unaligned leading bytes.
         * (0-28 bytes, length in r3) */
        movs        r3, r3, lsl #28
        stmcsia     r0!, {r1, lr}
        stmcsia     r0!, {r1, lr}
        stmmiia     r0!, {r1, lr}
        movs        r3, r3, lsl #2
        strcs       r1, [r0], #4

        /* Now quickly loop through the cache-aligned data. */
.Laligned32:
        mov         r3, r1
1:      subs        r2, r2, #32
        stmhsia     r0!, {r1,r3,ip,lr}
        stmhsia     r0!, {r1,r3,ip,lr}
        bhs         1b
        add         r2, r2, #32

        /* (Optionally) store any remaining trailing bytes.
         * (0-30 bytes, length in r2) */
        movs        r2, r2, lsl #28
        stmcsia     r0!, {r1,r3,ip,lr}
        stmmiia     r0!, {r1,lr}
        movs        r2, r2, lsl #2
        strcs       r1, [r0], #4
        strmih      lr, [r0], #2

        pop         {pc}
        .fnend