Subversion Repositories scarts

/* Copyright (C) 1998, 1999, 2000, 2005 Free Software Foundation, Inc.

   Contributed by Wolfgang Puffitsch 

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

under the terms of the GNU General Public License as published by the

Free Software Foundation; either version 2, or (at your option) any

later version.

In addition to the permissions in the GNU General Public License, the

Free Software Foundation gives you unlimited permission to link the

compiled version of this file into combinations with other programs,

and to distribute those combinations without any restriction coming

from the use of this file.  (The General Public License restrictions

do apply in other respects; for example, they cover modification of

the file, and distribution when not linked into a combine

executable.)

This file 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 for more details.

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

along with this program; see the file COPYING.  If not, write to

the Free Software Foundation, 59 Temple Place - Suite 330,

Boston, MA 02111-1307, USA.  */

        .file   "libgcc.S"

/* Most of the functions here are called directly from scarts.md

   patterns, instead of using the standard libcall mechanisms.

   This can make better code because GCC knows exactly which

   of the call-used registers (not all of them) are clobbered.  */

/*******************************************************

                Multiplication  16 x 16

*******************************************************/

#ifdef L_mulhi3

        .section        .text

        .global __mulhi3

        .type   __mulhi3, @function

__mulhi3:

        ldli r0, 0              ; clear result

__mulhi3_loop:

        btest r2, 0

        add_ct r0, r1

        sli r1, 1

        sri r2, 1

        cmpi_eq r2, 0

        jmpi_cf __mulhi3_loop

        rts

        .size   __mulhi3, .-__mulhi3

#endif

/*******************************************************

                Multiplication  32 x 32

*******************************************************/

#ifdef L_mulsi3

        .section        .text

        .global __mulsi3

        .type   __mulsi3, @function

__mulsi3:

        ldfpz r4,0

        ldfpz r5,1

        mov r0,r1

        ldli r6, 0

        ldli r7, 0

__mulsi3_loop:

        btest r2, 0

        add_ct r6, r4

        addc_ct r7, r5

        sli r4, 1

        addc r5, r5

        sri r3, 1

        rrc r2

        cmpi_eq r2, 0

        jmpi_cf __mulsi3_loop

        cmpi_eq r3, 0

        jmpi_cf __mulsi3_loop

        mov r13,r0

        sth r6,r13

        addi r13, 2

        sth r7,r13

        rts

        .size   __mulsi3, .-__mulsi3

#endif

/*******************************************************

                Division 16 x 16

*******************************************************/

#ifdef L_divhi3

        .section        .text

        .global __divhi3

        .type   __divhi3, @function

__divhi3:

        cmpi_eq r2, 0           ; avoid division by zero

        jmpi_ct __divhi3_end

        cmpi_eq r1, 0           ; we need not divide zero

        mov_ct r0, r1

        jmpi_ct __divhi3_end

__divhi3_cmpsign:

        mov r3, r1              ; compute the sign of the result

        eor r3, r2

        cmpi_lt r1, 0           ; make positive

        neg_ct r1

        cmpi_lt r2, 0           ; make positive

        neg_ct r2

__divhi3_copy:

        mov r13, r2             ; make a copy of the divisor

__divhi3_scale:

        btest r2, 15            ; scale divisor up

        sli_cf r2, 1

        jmpi_cf __divhi3_scale

        ldli r0, 0              ; clear result

__divhi3_loop:

        cmpu_lt r2, r13         ; check if the divisor is reached

        jmpi_ct __divhi3_resign

        sli r0, 1

        cmpu_gt r2, r1          ; need to scale back?

        sub_cf r1, r2

        addi_cf r0, 1

        sri r2, 1

        jmpi __divhi3_loop

__divhi3_resign:                ; add sign again

        cmpi_lt r3, 0

        neg_ct r0

__divhi3_end:

        rts

        .size   __divhi3, .-__divhi3

#endif

/*******************************************************

                Division 32 x 32

*******************************************************/

#ifdef L_divsi3

        .section        .text

        .global __divsi3

        .type   __divsi3, @function

__divsi3:

        stfpz_dec r1,-1

        ldfpz r4,1

        ldfpz r5,2

        cmpi_eq r4, 0           ; avoid division by zero

        jmpi_cf __divsi3_start

        cmpi_eq r5, 0

        jmpi_ct __divsi3_end

__divsi3_start:

        cmpi_eq r2, 0           ; we need not divide zero

        jmpi_cf __divsi3_cmpsign

        cmpi_eq r3, 0

        mov_ct r0, r2

        mov_ct r1, r3

        jmpi_ct __divsi3_end

__divsi3_cmpsign:

        mov r8, r3

        eor r8, r5

        ldli r13, 0             ; we use that for incrementing

        cmpi_lt r3, 0           ; make positive

        not_ct r2

        not_ct r3

        addi_ct r2, 1

        addc_ct r3, r13

        cmpi_lt r5, 0           ; make positive

        not_ct r4

        not_ct r5

        addi_ct r4, 1

        addc_ct r5, r13

__divsi3_copy:

        mov r6, r4              ; make a copy of the divisor

        mov r7, r5

__divsi3_scale:

        btest r5, 15            ; scale divisor up

        sli_cf r4, 1

        addc_cf r5, r5

        jmpi_cf __divsi3_scale

        ldli r0, 0              ; clear result

        ldli r1, 0

__divsi3_loop:

        cmpu_lt r5, r7          ; check if the divisor is reached

        jmpi_ct __divsi3_resign

        cmpu_gt r5, r7

        jmpi_ct __divsi3_noteq

        cmpu_lt r4, r6

        jmpi_ct __divsi3_resign

__divsi3_noteq:

        sli r0, 1

        addc r1, r1

        cmpu_gt r5, r3          ; need to scale back?

        jmpi_ct __divsi3_nosub

        cmpu_lt r5, r3

        jmpi_ct __divsi3_sub

        cmpu_gt r4, r2

        jmpi_ct __divsi3_nosub

__divsi3_sub:

        sub r2, r4

        subc r3, r5

        addi r0, 1

        addc r1, r13

__divsi3_nosub:

        sri r5, 1

        rrc r4

        jmpi __divsi3_loop

__divsi3_resign:

        cmpi_lt r8, 0           ; add sign again

        not_ct r0

        not_ct r1

        addi_ct r0, 1

        addc_ct r1, r13

__divsi3_end:

        ldfpz r13, 0

        sth r0, r13

        addi r13, 2

        sth r1, r13

        ldfpz_inc r0, 0

        rts

        .size   __divsi3, .-__divsi3

#endif

/*******************************************************

                Unsigned Division 16 x 16

*******************************************************/

#ifdef L_udivhi3

        .section        .text

        .global __udivhi3

        .type   __udivhi3, @function

__udivhi3:

        cmpi_eq r2, 0           ; avoid division by zero

        jmpi_ct __udivhi3_end

        cmpi_eq r1, 0           ; we need not divide zero

        mov_ct r0, r1

        jmpi_ct __udivhi3_end

__udivhi3_copy:

        mov r13, r2             ; make a copy of the divisor

__udivhi3_scale:

        btest r2, 15            ; scale divisor up

        sli_cf r2, 1

        jmpi_cf __udivhi3_scale

        ldli r0, 0              ; clear result

__udivhi3_loop:

        cmpu_lt r2, r13         ; check if the divisor is reached

        jmpi_ct __udivhi3_end

        sli r0, 1

        cmpu_gt r2, r1          ; need to scale back?

        sub_cf r1, r2

        addi_cf r0, 1

        sri r2, 1

        jmpi __udivhi3_loop

__udivhi3_end:

        rts

        .size   __udivhi3, .-__udivhi3

#endif

/*******************************************************

                Unsigned Division 32 x 32

*******************************************************/

#ifdef L_udivsi3

        .section        .text

        .global __udivsi3

        .type   __udivsi3, @function

__udivsi3:

        stfpz_dec r1,-1

        ldfpz r4,1

        ldfpz r5,2

        cmpi_eq r4, 0           ; avoid division by zero

        jmpi_cf __udivsi3_start

        cmpi_eq r5, 0

        jmpi_ct __udivsi3_end

__udivsi3_start:

        cmpi_eq r2, 0           ; we need not divide zero

        jmpi_cf __udivsi3_copy

        cmpi_eq r3, 0

        mov_ct r0, r2

        mov_ct r1, r3

        jmpi_ct __udivsi3_end

__udivsi3_copy:

        mov r6, r4              ; make a copy of the divisor

        mov r7, r5

__udivsi3_scale:

        btest r5, 15            ; scale divisor up

        sli_cf r4, 1

        addc_cf r5, r5

        jmpi_cf __udivsi3_scale

        ldli r0, 0              ; clear result

        ldli r1, 0

        ldli r13, 0             ; we use that for incrementing

__udivsi3_loop:

        cmpu_lt r5, r7          ; check if the divisor is reached

        jmpi_ct __udivsi3_end

        cmpu_gt r5, r7

        jmpi_ct __udivsi3_noteq

        cmpu_lt r4, r6

        jmpi_ct __udivsi3_end

__udivsi3_noteq:

        sli r0, 1

        addc r1, r1

        cmpu_gt r5, r3          ; need to scale back?

        jmpi_ct __udivsi3_nosub

        cmpu_lt r5, r3

        jmpi_ct __udivsi3_sub

        cmpu_gt r4, r2

        jmpi_ct __udivsi3_nosub

__udivsi3_sub:

        sub r2, r4

        subc r3, r5

        addi r0, 1

        addc r1, r13

__udivsi3_nosub:

        sri r5, 1

        rrc r4

        jmpi __udivsi3_loop

__udivsi3_end:

        ldfpz r13, 0

        sth r0, r13

        addi r13, 2

        sth r1, r13

        ldfpz_inc r0, 0

        rts

        .size   __udivsi3, .-__udivsi3

#endif

/*******************************************************

                Modulo 16 x 16

*******************************************************/

#ifdef L_modhi3

        .section        .text

        .global __modhi3

        .type   __modhi3, @function

__modhi3:

        cmpi_eq r2, 0           ; avoid division by zero

        jmpi_ct __modhi3_end

        cmpi_eq r1, 0           ; we need not divide zero

        mov_ct r0, r1

        jmpi_ct __modhi3_end

__modhi3_cmpsign:

        mov r3, r1              ; compute the sign of the result

        cmpi_lt r1, 0           ; make positive

        neg_ct r1

        cmpi_lt r2, 0           ; make positive

        neg_ct r2

__modhi3_copy:

        mov r13, r2             ; make a copy of the divisor

__modhi3_scale:

        btest r2, 15            ; scale divisor up

        sli_cf r2, 1

        jmpi_cf __modhi3_scale

__modhi3_loop:

        cmpu_lt r2, r13         ; check if the divisor is reached

        jmpi_ct __modhi3_resign

        cmpu_gt r2, r1          ; need to scale back?

        sub_cf r1, r2

        sri r2, 1

        jmpi __modhi3_loop

__modhi3_resign:                ; add sign again

        mov r0, r1

        cmpi_lt r3, 0

        neg_ct r0

__modhi3_end:

        rts

        .size   __modhi3, .-__modhi3

#endif

/*******************************************************

                Modulo 32 x 32

*******************************************************/

#ifdef L_modsi3

        .section        .text

        .global __modsi3

        .type   __modsi3, @function

__modsi3:

        ldfpz r4,0

        ldfpz r5,1

        cmpi_eq r4, 0           ; avoid division by zero

        jmpi_cf __modsi3_start

        cmpi_eq r5, 0

        jmpi_ct __modsi3_end

__modsi3_start:

        cmpi_eq r2, 0           ; we need not divide zero

        jmpi_cf __modsi3_cmpsign

        cmpi_eq r3, 0

        jmpi_ct __modsi3_end

__modsi3_cmpsign:

        mov r0, r3              ; compute the sign of result

        ldli r13, 0             ; we use that for incrementing

        cmpi_lt r3, 0           ; make positive

        not_ct r2

        not_ct r3

        addi_ct r2, 1

        addc_ct r3, r13

        cmpi_lt r5, 0           ; make positive

        not_ct r4

        not_ct r5

        addi_ct r4, 1

        addc_ct r5, r13

__modsi3_copy:

        mov r6, r4              ; make a copy of the divisor

        mov r7, r5

__modsi3_scale:

        btest r5, 15            ; scale divisor up

        sli_cf r4, 1

        addc_cf r5, r5

        jmpi_cf __modsi3_scale

__modsi3_loop:

        cmpu_lt r5, r7          ; check if the divisor is reached

        jmpi_ct __modsi3_resign

        cmpu_gt r5, r7

        jmpi_ct __modsi3_noteq

        cmpu_lt r4, r6

        jmpi_ct __modsi3_resign

__modsi3_noteq:

        cmpu_gt r5, r3          ; need to scale back?

        jmpi_ct __modsi3_nosub

        cmpu_lt r5, r3

        jmpi_ct __modsi3_sub

        cmpu_gt r4, r2

        jmpi_ct __modsi3_nosub

__modsi3_sub:

        sub r2, r4

        subc r3, r5

__modsi3_nosub:

        sri r5, 1

        rrc r4

        jmpi __modsi3_loop

__modsi3_resign:

        cmpi_lt r0, 0           ; add sign again

        not_ct r2

        not_ct r3

        addi_ct r2, 1

        addc_ct r3, r13

__modsi3_end:

        mov r13, r1

        sth r2, r13

        addi r13, 2

        sth r3, r13

        mov r0, r1

        rts

        .size   __modsi3, .-__modsi3

#endif

/*******************************************************

                Unsigned Modulo 16 x 16

*******************************************************/

#ifdef L_umodhi3

        .section        .text

        .global __umodhi3

        .type   __umodhi3, @function

__umodhi3:

        cmpi_eq r2, 0           ; avoid division by zero

        jmpi_ct __umodhi3_end

        cmpi_eq r1, 0           ; we need not divide zero

        mov_ct r0, r1

        jmpi_ct __umodhi3_end

__umodhi3_copy:

        mov r13, r2             ; make a copy of the divisor

__umodhi3_scale:

        btest r2, 15            ; scale divisor up

        sli_cf r2, 1

        jmpi_cf __umodhi3_scale

__umodhi3_loop:

        cmpu_lt r2, r13         ; check if the divisor is reached

        jmpi_ct __umodhi3_end

        cmpu_gt r2, r1          ; need to scale back?

        sub_cf r1, r2

        sri r2, 1

        jmpi __umodhi3_loop

__umodhi3_end:

        mov r0, r1

        rts

        .size   __umodhi3, .-__umodhi3

#endif

/*******************************************************

                Unsigned Modulo 32 x 32

*******************************************************/

#ifdef L_umodsi3

        .section        .text

        .global __umodsi3

        .type   __umodsi3, @function

__umodsi3:

        ldfpz r4,0

        ldfpz r5,1

        cmpi_eq r4, 0           ; avoid division by zero

        jmpi_cf __umodsi3_start

        cmpi_eq r5, 0

        jmpi_ct __umodsi3_end

__umodsi3_start:

        cmpi_eq r2, 0           ; we need not divide zero

        jmpi_cf __umodsi3_copy

        cmpi_eq r3, 0

        mov_ct r4, r2

        mov_ct r5, r3

        jmpi_ct __umodsi3_end

__umodsi3_copy:

        mov r6, r4              ; make a copy of the divisor

        mov r7, r5

__umodsi3_scale:

        btest r5, 15            ; scale divisor up

        sli_cf r4, 1

        addc_cf r5, r5

        jmpi_cf __umodsi3_scale

__umodsi3_loop:

        cmpu_lt r5, r7          ; check if the divisor is reached

        jmpi_ct __umodsi3_end

        cmpu_gt r5, r7

        jmpi_ct __umodsi3_noteq

        cmpu_lt r4, r6

        jmpi_ct __umodsi3_end

__umodsi3_noteq:

        cmpu_gt r5, r3          ; need to scale back?

        jmpi_ct __umodsi3_nosub

        cmpu_lt r5, r3

        jmpi_ct __umodsi3_sub

        cmpu_gt r4, r2

        jmpi_ct __umodsi3_nosub

__umodsi3_sub:

        sub r2, r4

        subc r3, r5

__umodsi3_nosub:

        sri r5, 1

        rrc r4

        jmpi __umodsi3_loop

__umodsi3_end:

        mov r13, r1

        sth r2, r13

        addi r13, 2

        sth r3, r13

        mov r0, r1

        rts

        .size   __umodsi3, .-__umodsi3

#endif

/*******************************************************

                Shift right logic 32

*******************************************************/

#ifdef L_lshrsi3

        .section        .text

        .global __lshrsi3

        .type   __lshrsi3, @function

__lshrsi3:

        mov r0,r1

__lshrsi3_loop:

        cmpi_gt r4, 0

        sri_ct r3, 1

        rrc_ct r2

        addi_ct r4, -1

        jmpi_ct __lshrsi3_loop

        mov r13,r0

        sth r2, r13

        addi r13, 2

        sth r3, r13

        rts

        .size   __lshrsi3, .-__lshrsi3

#endif

/*******************************************************

                Shift right logic 64

*******************************************************/

#ifdef L_lshrdi3

        .section        .text

        .global __lshrdi3

        .type   __lshrdi3, @function

__lshrdi3:

        mov r0,r1

        ldfpz r1, 0

        ldfpz r2, 1

        ldfpz r3, 2

        ldfpz r4, 3

        ldfpz r5, 4

__lshrdi3_loop:

        cmpi_gt r5, 0

        sri_ct r4, 1

        rrc_ct r3

        rrc_ct r2

        rrc_ct r1

        addi_ct r5, -1

        jmpi_ct __lshrdi3_loop

        mov r13,r0

        sth r1,r13

        addi r13, 2

        sth r2,r13

        addi r13, 2

        sth r3,r13

        addi r13, 2

        sth r4,r13

        rts

        .size   __lshrdi3, .-__lshrdi3

#endif

/*******************************************************

                Shift right arithmetic 32

*******************************************************/

#ifdef L_ashrsi3

        .section        .text

        .global __ashrsi3

        .type   __ashrsi3, @function

__ashrsi3:

        mov r0,r1

__ashrsi3_loop:

        cmpi_gt r4, 0

        srai_ct r3, 1

        rrc_ct r2

        addi_ct r4, -1

        jmpi_ct __ashrsi3_loop

        mov r13,r0

        sth r2, r13

        addi r13, 2

        sth r3, r13

        rts

        .size   __ashrsi3, .-__ashrsi3

#endif

/*******************************************************

                Shift right arithmetic 64

*******************************************************/

#ifdef L_ashrdi3

        .section        .text

        .global __ashrdi3

        .type   __ashrdi3, @function

__ashrdi3:

        mov r0,r1

        ldfpz r1, 0

        ldfpz r2, 1

        ldfpz r3, 2

        ldfpz r4, 3

        ldfpz r5, 4

__ashrdi3_loop:

        cmpi_gt r5, 0

        srai_ct r4, 1

        rrc_ct r3

        rrc_ct r2

        rrc_ct r1

        addi_ct r5, -1

        jmpi_ct __ashrdi3_loop

        mov r13,r0

        sth r1,r13

        addi r13, 2

        sth r2,r13

        addi r13, 2

        sth r3,r13

        addi r13, 2

        sth r4,r13

        rts

        .size   __ashrdi3, .-__ashrdi3

#endif

/*******************************************************

                Shift left 32

*******************************************************/

#ifdef L_ashlsi3

        .section        .text

        .global __ashlsi3

        .type   __ashlsi3, @function

__ashlsi3:

        mov r0,r1

__ashlsi3_loop:

        cmpi_gt r4, 0

        sli_ct r2, 1

        addc_ct r3, r3

        addi_ct r4, -1

        jmpi_ct __ashlsi3_loop

        mov r13,r0

        sth r2, r13

        addi r13, 2

        sth r3, r13

        rts

        .size   __ashlsi3, .-__ashlsi3

#endif

/*******************************************************

                Shift left 64

*******************************************************/

#ifdef L_ashldi3

        .section        .text

        .global __ashldi3

        .type   __ashldi3, @function

__ashldi3:

        mov r0,r1

        ldfpz r1, 0

        ldfpz r2, 1

        ldfpz r3, 2

        ldfpz r4, 3

        ldfpz r5, 4

__ashldi3_loop:

        cmpi_gt r5, 0

        sli_ct r1, 1

        addc_ct r2, r2

        addc_ct r3, r3

        addc_ct r4, r4

        addi_ct r5, -1

        jmpi_ct __ashldi3_loop

        mov r13,r0

        sth r1,r13

        addi r13, 2

        sth r2,r13

        addi r13, 2

        sth r3,r13

        addi r13, 2

        sth r4,r13

        rts

        .size   __ashldi3, .-__ashldi3

#endif

/*******************************************************

                Find first set bit 16

*******************************************************/

#ifdef L_ffshi2

        .section        .text

        .global __ffshi2

        .type   __ffshi2, @function

__ffshi2:

        cmpi_eq r1, 0           ; return zero if no bit is set

        mov_ct r0, r1

        jmpi_ct __ffshi2_end

        ldli r0, 1

__ffshi2_loop:

        btest r1, 0             ; test bit

        sri_cf r1, 1

        addi_cf r0, 1           ; update loop counter

        jmpi_cf __ffshi2_loop

__ffshi2_end:

        rts

        .size   __ffshi2, .-__ffshi2

#endif

/*******************************************************

                Find first set bit 32

*******************************************************/

#ifdef L_ffssi2

        .section        .text

        .global __ffssi2

        .type   __ffssi2, @function

__ffssi2:

        cmpi_eq r1, 0           ; return zero if no bit is set

        jmpi_cf __ffssi2_start

        cmpi_eq r2, 0

        mov_ct r0, r1

        jmpi_ct __ffssi2_end

__ffssi2_start:

        ldli r0, 1

__ffssi2_loop:

        btest r1, 0             ; test bit

        sri_cf r2, 1

        rrc_cf r1

        addi_cf r0, 1           ; update loop counter

        jmpi_cf __ffssi2_loop

__ffssi2_end:

        rts

        .size   __ffssi2, .-__ffssi2

#endif

/*******************************************************

                Count trailing zero bits 16

*******************************************************/

#ifdef L_ctzhi2

        .section        .text

        .global __ctzhi2

        .type   __ctzhi2, @function

__ctzhi2:

        ldli r0, 16             ; return 16 if no bit is set

        cmpi_eq r1, 0

        jmpi_ct __ctzhi2_end

        ldli r0, 0

__ctzhi2_loop:

        btest r1, 0             ; test bit

        sri_cf r1, 1

        addi_cf r0, 1           ; update loop counter

        jmpi_cf __ctzhi2_loop