# 

# Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# This code is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 2 only, as

# published by the Free Software Foundation.

#

# This code is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# version 2 for more details (a copy is included in the LICENSE file that

# accompanied this code).

#

# You should have received a copy of the GNU General Public License version

# 2 along with this work; if not, write to the Free Software Foundation,

# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

# 

        # NOTE WELL!  The _Copy functions are called directly

	# from server-compiler-generated code via CallLeafNoFP,

	# which means that they *must* either not use floating

	# point or use it in the same manner as does the server

	# compiler.

        .globl _Copy_conjoint_bytes

	.type _Copy_conjoint_bytes, %function

        .globl _Copy_arrayof_conjoint_bytes

	.type _Copy_arrayof_conjoint_bytes, %function

	.globl _Copy_disjoint_words

	.type _Copy_disjoint_words, %function

	.globl _Copy_conjoint_words

	.type _Copy_conjoint_words, %function

        .globl _Copy_conjoint_jshorts_atomic

	.type _Copy_conjoint_jshorts_atomic, %function

	.globl _Copy_arrayof_conjoint_jshorts

	.type _Copy_arrayof_conjoint_jshorts, %function

        .globl _Copy_conjoint_jints_atomic

	.type _Copy_conjoint_jints_atomic, %function

        .globl _Copy_arrayof_conjoint_jints

	.type _Copy_arrayof_conjoint_jints, %function

	.globl _Copy_conjoint_jlongs_atomic

	.type _Copy_conjoint_jlongs_atomic, %function

	.globl _Copy_arrayof_conjoint_jlongs

	.type _Copy_arrayof_conjoint_jlongs, %function

	.text

        .globl  SpinPause

        .type SpinPause, %function

SpinPause:

        bx      LR

        # Support for void Copy::conjoint_bytes(void* from,

        #                                       void* to,

        #                                       size_t count)

_Copy_conjoint_bytes:

        swi     0x9f0001

        # Support for void Copy::arrayof_conjoint_bytes(void* from,

        #                                               void* to,

        #                                               size_t count)

_Copy_arrayof_conjoint_bytes:

        swi     0x9f0001

        # Support for void Copy::disjoint_words(void* from,

        #                                       void* to,

        #                                       size_t count)

_Copy_disjoint_words:

        stmdb    sp!, {r3 - r9, ip}

        cmp     r2, #0

        beq     disjoint_words_finish

        pld     [r1, #0]

        cmp     r2, #12

        ble disjoint_words_small

        .align 3

dw_f2b_loop_32:

        subs    r2, #32

	blt	dw_f2b_loop_32_finish

        ldmia r1!, {r3 - r9, ip}

        nop

	pld     [r1]

        stmia r0!, {r3 - r9, ip}

        bgt     dw_f2b_loop_32

dw_f2b_loop_32_finish:

        addlts  r2, #32

        beq     disjoint_words_finish

        cmp     r2, #16

	blt	disjoint_words_small

        ldmia r1!, {r3 - r6}

        subge   r2, r2, #16

        stmia r0!, {r3 - r6}

        beq     disjoint_words_finish

disjoint_words_small:

        cmp     r2, #8

        ldr     r7, [r1], #4

        ldrge   r8, [r1], #4

        ldrgt   r9, [r1], #4

        str     r7, [r0], #4

        strge   r8, [r0], #4

        strgt   r9, [r0], #4

disjoint_words_finish:

        ldmia   sp!, {r3 - r9, ip}

        bx      lr

        # Support for void Copy::conjoint_words(void* from,

        #                                       void* to,

        #                                       size_t count)

_Copy_conjoint_words:

        stmdb    sp!, {r3 - r9, ip}

	cmp	r2, #0

	beq	conjoint_words_finish

        pld     [r1, #0]

        cmp     r2, #12

        ble conjoint_words_small

        subs    r3, r0, r1

        cmphi   r2, r3

        bhi     cw_b2f_copy

        .align 3

cw_f2b_loop_32:

        subs    r2, #32

	blt	cw_f2b_loop_32_finish

        ldmia r1!, {r3 - r9, ip}

        nop

	pld     [r1]

        stmia r0!, {r3 - r9, ip}

        bgt     cw_f2b_loop_32

cw_f2b_loop_32_finish:

        addlts  r2, #32

        beq     conjoint_words_finish

        cmp     r2, #16

	blt	conjoint_words_small

        ldmia r1!, {r3 - r6}

        subge   r2, r2, #16

        stmia r0!, {r3 - r6}

        beq     conjoint_words_finish

conjoint_words_small:

        cmp     r2, #8

        ldr     r7, [r1], #4

        ldrge   r8, [r1], #4

        ldrgt   r9, [r1], #4

        str     r7, [r0], #4

        strge   r8, [r0], #4

        strgt   r9, [r0], #4

        b       conjoint_words_finish

	# Src and dest overlap, copy in a descending order

cw_b2f_copy:

        add     r1, r2

        pld     [r1, #-32]

        add     r0, r2

        .align 3

cw_b2f_loop_32:

        subs    r2, #32

	blt	cw_b2f_loop_32_finish

        ldmdb r1!, {r3-r9,ip}

        nop

	pld     [r1, #-32]

        stmdb r0!, {r3-r9,ip}

        bgt     cw_b2f_loop_32

cw_b2f_loop_32_finish:

        addlts  r2, #32

        beq     conjoint_words_finish

        cmp     r2, #16

	blt	cw_b2f_copy_small

        ldmdb r1!, {r3 - r6}

        subge   r2, r2, #16

        stmdb r0!, {r3 - r6}

        beq     conjoint_words_finish

cw_b2f_copy_small:

        cmp     r2, #8

        ldr     r7, [r1, #-4]!

        ldrge   r8, [r1, #-4]!

        ldrgt   r9, [r1, #-4]!

        str     r7, [r0, #-4]!

        strge   r8, [r0, #-4]!

        strgt   r9, [r0, #-4]!

conjoint_words_finish:

        ldmia   sp!, {r3 - r9, ip}

        bx      lr

        # Support for void Copy::conjoint_jshorts_atomic(void* from,

        #                                                void* to,

        #                                                size_t count)

_Copy_conjoint_jshorts_atomic:

        stmdb   sp!, {r3 - r9, ip}

	cmp	r2, #0

	beq	conjoint_shorts_finish	

        subs    r3, r0, r1

        cmphi   r2, r3

        bhi     cs_b2f_copy

        pld     [r1]

        ands    r3, r0, #3

        bne     cs_f2b_dest_u

        ands    r3, r1, #3

        bne     cs_f2b_src_u

	# Aligned source address

        .align 3

cs_f2b_loop_32:

        subs    r2, #32

	blt	cs_f2b_loop_32_finish

        ldmia r1!, {r3 - r9, ip}

        nop

        pld     [r1]

        stmia r0!, {r3 - r9, ip}

        bgt     cs_f2b_loop_32

cs_f2b_loop_32_finish:

        addlts  r2, #32

        beq     conjoint_shorts_finish

        movs    r6, r2, lsr #3

        .align 3

cs_f2b_8_loop:

        beq     cs_f2b_4

        ldmia   r1!, {r4-r5}

        subs    r6, #1

        stmia   r0!, {r4-r5}

        bgt     cs_f2b_8_loop

cs_f2b_4:

        ands    r2, #7

        beq     conjoint_shorts_finish

        cmp     r2, #4

        ldrh    r3, [r1], #2

        ldrgeh  r4, [r1], #2

        ldrgth  r5, [r1], #2

        strh    r3, [r0], #2

        strgeh  r4, [r0], #2

        strgth  r5, [r0], #2

        b       conjoint_shorts_finish

	# Destination not aligned

cs_f2b_dest_u:

        ldrh    r3, [r1], #2

        subs    r2, #2

        strh    r3, [r0], #2

        beq     conjoint_shorts_finish

	# Check to see if source is not aligned ether

        ands    r3, r1, #3

        beq     cs_f2b_loop_32

cs_f2b_src_u:

        cmp     r2, #16

        blt     cs_f2b_8_u

	# Load 2 first bytes to r7 and make src ptr word aligned

        bic     r1, #3

        ldr     r7, [r1], #4

	# Destination aligned, source not

        mov     r8, r2, lsr #4

        .align 3

cs_f2b_16_u_loop:

        mov     r3, r7, lsr #16

        ldmia   r1!, {r4 - r7}

        orr     r3, r3, r4, lsl #16

        mov     r4, r4, lsr #16

        pld     [r1]

        orr     r4, r4, r5, lsl #16

        mov     r5, r5, lsr #16

        orr     r5, r5, r6, lsl #16

        mov     r6, r6, lsr #16

        orr     r6, r6, r7, lsl #16

        stmia   r0!, {r3 - r6}

        subs    r8, #1

        bgt     cs_f2b_16_u_loop

        ands    r2, #0xf

        beq     conjoint_shorts_finish

        sub     r1, #2

cs_f2b_8_u:

        cmp     r2, #8

        blt     cs_f2b_4_u

        ldrh    r4, [r1], #2

        ldr     r5, [r1], #4

        ldrh    r6, [r1], #2

        orr     r4, r4, r5, lsl #16

        mov     r5, r5, lsr #16

        orr     r5, r5, r6, lsl #16

        subs    r2, #8

        stmia	r0!, {r4 - r5}

cs_f2b_4_u:

        beq     conjoint_shorts_finish

        cmp     r2, #4

        ldrh    r3, [r1], #2

        ldrgeh  r4, [r1], #2

        ldrgth  r5, [r1], #2

        strh    r3, [r0], #2

        strgeh  r4, [r0], #2

        strgth  r5, [r0], #2

        b       conjoint_shorts_finish

	# Src and dest overlap, copy in a descending order

cs_b2f_copy:

        add     r1, r2

        pld     [r1, #-32]

        add     r0, r2

        ands    r3, r0, #3

        bne     cs_b2f_dest_u

        ands    r3, r1, #3

        bne     cs_b2f_src_u

        .align 3

cs_b2f_loop_32:

        subs    r2, #32

	blt	cs_b2f_loop_32_finish

        ldmdb r1!, {r3-r9,ip}

        nop

        pld     [r1, #-32]

        stmdb r0!, {r3-r9,ip}

        bgt     cs_b2f_loop_32

cs_b2f_loop_32_finish:

        addlts  r2, #32

        beq     conjoint_shorts_finish

        cmp     r2, #24

        blt     cs_b2f_16

        ldmdb   r1!, {r3-r8}

        sub     r2, #24

        stmdb   r0!, {r3-r8}

        beq     conjoint_shorts_finish

cs_b2f_16:

        cmp     r2, #16

        blt     cs_b2f_8

        ldmdb   r1!, {r3-r6}

        sub     r2, #16

        stmdb   r0!, {r3-r6}

        beq     conjoint_shorts_finish

cs_b2f_8:

        cmp     r2, #8

        blt     cs_b2f_all_copy

        ldmdb   r1!, {r3-r4}

        sub     r2, #8

        stmdb   r0!, {r3-r4}

        beq     conjoint_shorts_finish

cs_b2f_all_copy:

        cmp     r2, #4

        ldrh    r3, [r1, #-2]!

        ldrgeh  r4, [r1, #-2]!

        ldrgth  r5, [r1, #-2]!

        strh    r3, [r0, #-2]!

        strgeh  r4, [r0, #-2]!

        strgth  r5, [r0, #-2]!

        b       conjoint_shorts_finish

	# Destination not aligned

cs_b2f_dest_u:

        ldrh    r3, [r1, #-2]!

        strh    r3, [r0, #-2]!

        sub     r2, #2

	# Check source alignment as well

        ands    r3, r1, #3

        beq     cs_b2f_loop_32

	# Source not aligned

cs_b2f_src_u:

        bic     r1, #3

        .align 3

cs_b2f_16_loop_u:

        subs    r2, #16

        blt     cs_b2f_16_loop_u_finished

        ldr     r7, [r1]

        mov     r3, r7

        ldmdb   r1!, {r4 - r7}

        mov     r4, r4, lsr #16

        orr     r4, r4, r5, lsl #16

        pld     [r1, #-32]

        mov     r5, r5, lsr #16

        orr     r5, r5, r6, lsl #16

        mov     r6, r6, lsr #16

        orr     r6, r6, r7, lsl #16

        mov     r7, r7, lsr #16

        orr     r7, r7, r3, lsl #16

        stmdb   r0!, {r4 - r7}

        bgt     cs_b2f_16_loop_u

        beq     conjoint_shorts_finish

cs_b2f_16_loop_u_finished:

        addlts  r2, #16

        ldr     r3, [r1]

	cmp     r2, #10

        blt     cs_b2f_2_u_loop

        ldmdb   r1!, {r4 - r5}

        mov     r6, r4, lsr #16

        orr     r6, r6, r5, lsl #16

        mov     r7, r5, lsr #16

        orr     r7, r7, r3, lsl #16

        stmdb   r0!, {r6-r7}

        sub     r2, #8

	.align 3

cs_b2f_2_u_loop:

        subs    r2, #2

        ldrh    r3, [r1], #-2

        strh    r3, [r0, #-2]!

        bgt     cs_b2f_2_u_loop

conjoint_shorts_finish:

        ldmia   sp!, {r3 - r9, ip}

        bx      lr

        # Support for void Copy::arrayof_conjoint_jshorts(void* from,

        #                                                 void* to,

        #                                                 size_t count)

_Copy_arrayof_conjoint_jshorts:

        swi     0x9f0001

        # Support for void Copy::conjoint_jints_atomic(void* from,

        #                                              void* to,

        #                                              size_t count)

_Copy_conjoint_jints_atomic:

_Copy_arrayof_conjoint_jints:

        swi     0x9f0001

        # Support for void Copy::conjoint_jlongs_atomic(jlong* from,

        #                                               jlong* to,

        #                                               size_t count)

_Copy_conjoint_jlongs_atomic:

_Copy_arrayof_conjoint_jlongs:

        stmdb    sp!, {r3 - r9, ip}

	cmp	r2, #0

	beq	conjoint_longs_finish

        pld     [r1, #0]

        cmp     r2, #24

        ble conjoint_longs_small

        subs    r3, r0, r1

        cmphi   r2, r3

        bhi     cl_b2f_copy

        .align 3

cl_f2b_loop_32:

        subs    r2, #32

	blt	cl_f2b_loop_32_finish

        ldmia r1!, {r3 - r9, ip}

        nop

	pld     [r1]

        stmia r0!, {r3 - r9, ip}

        bgt     cl_f2b_loop_32

cl_f2b_loop_32_finish:

        addlts  r2, #32

        beq     conjoint_longs_finish

conjoint_longs_small:

        cmp     r2, #16

	blt	cl_f2b_copy_8

	bgt	cl_f2b_copy_24

        ldmia 	r1!, {r3 - r6}

        stmia 	r0!, {r3 - r6}

	b	conjoint_longs_finish

cl_f2b_copy_8:

        ldmia   r1!, {r3 - r4}

        stmia   r0!, {r3 - r4}

        b       conjoint_longs_finish

cl_f2b_copy_24:

	ldmia   r1!, {r3 - r8}

        stmia   r0!, {r3 - r8}

        b       conjoint_longs_finish

	# Src and dest overlap, copy in a descending order

cl_b2f_copy:

        add     r1, r2

        pld     [r1, #-32]

        add     r0, r2

        .align 3

cl_b2f_loop_32:

        subs    r2, #32

	blt	cl_b2f_loop_32_finish

        ldmdb 	r1!, {r3 - r9, ip}

        nop

	pld     [r1]

        stmdb 	r0!, {r3 - r9, ip}

        bgt     cl_b2f_loop_32

cl_b2f_loop_32_finish:

        addlts  r2, #32

        beq     conjoint_longs_finish

        cmp     r2, #16

	blt	cl_b2f_copy_8

	bgt	cl_b2f_copy_24

        ldmdb   r1!, {r3 - r6}

        stmdb   r0!, {r3 - r6}

        b       conjoint_longs_finish

cl_b2f_copy_8:

	ldmdb   r1!, {r3 - r4}

        stmdb   r0!, {r3 - r4}

        b       conjoint_longs_finish

cl_b2f_copy_24:

	ldmdb   r1!, {r3 - r8}

        stmdb   r0!, {r3 - r8}

conjoint_longs_finish:

        ldmia   sp!, {r3 - r9, ip}

        bx      lr