Subversion Repositories openrisc_me

;; libgcc routines for the Renesas H8/300 CPU.
;; Contributed by Steve Chamberlain <sac@cygnus.com>
;; Optimizations by Toshiyasu Morita <toshiyasu.morita@renesas.com>

/* Copyright (C) 1994, 2000, 2001, 2002, 2003, 2004
   Free Software Foundation, Inc.

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, 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

/* Assembler register definitions.  */

#define A0 r0
#define A0L r0l
#define A0H r0h

#define A1 r1
#define A1L r1l
#define A1H r1h

#define A2 r2
#define A2L r2l
#define A2H r2h

#define A3 r3
#define A3L r3l
#define A3H r3h

#define S0 r4
#define S0L r4l
#define S0H r4h

#define S1 r5
#define S1L r5l
#define S1H r5h

#define S2 r6
#define S2L r6l
#define S2H r6h

#ifdef __H8300__
#define PUSHP   push
#define POPP    pop

#define A0P     r0
#define A1P     r1
#define A2P     r2
#define A3P     r3
#define S0P     r4
#define S1P     r5
#define S2P     r6
#endif

#if defined (__H8300H__) || defined (__H8300S__) || defined (__H8300SX__)
#define PUSHP   push.l
#define POPP    pop.l

#define A0P     er0
#define A1P     er1
#define A2P     er2
#define A3P     er3
#define S0P     er4
#define S1P     er5
#define S2P     er6

#define A0E     e0
#define A1E     e1
#define A2E     e2
#define A3E     e3
#endif

#ifdef __H8300H__
#ifdef __NORMAL_MODE__
        .h8300hn
#else
        .h8300h
#endif
#endif

#ifdef __H8300S__
#ifdef __NORMAL_MODE__
        .h8300sn
#else
        .h8300s
#endif
#endif
#ifdef __H8300SX__
#ifdef __NORMAL_MODE__
        .h8300sxn
#else
        .h8300sx
#endif
#endif

#ifdef L_cmpsi2
#ifdef __H8300__
        .section .text
        .align 2
        .global ___cmpsi2
___cmpsi2:
        cmp.w   A0,A2
        bne     .L2
        cmp.w   A1,A3
        bne     .L4
        mov.w   #1,A0
        rts
.L2:
        bgt     .L5
.L3:
        mov.w   #2,A0
        rts
.L4:
        bls     .L3
.L5:
        sub.w   A0,A0
        rts
        .end
#endif
#endif /* L_cmpsi2 */

#ifdef L_ucmpsi2
#ifdef __H8300__
        .section .text
        .align 2
        .global ___ucmpsi2
___ucmpsi2:
        cmp.w   A0,A2
        bne     .L2
        cmp.w   A1,A3
        bne     .L4
        mov.w   #1,A0
        rts
.L2:
        bhi     .L5
.L3:
        mov.w   #2,A0
        rts
.L4:
        bls     .L3
.L5:
        sub.w   A0,A0
        rts
        .end
#endif
#endif /* L_ucmpsi2 */

#ifdef L_divhi3

;; HImode divides for the H8/300.
;; We bunch all of this into one object file since there are several
;; "supporting routines".

; general purpose normalize routine
;
; divisor in A0
; dividend in A1
; turns both into +ve numbers, and leaves what the answer sign
; should be in A2L

#ifdef __H8300__
        .section .text
        .align 2
divnorm:
        or      A0H,A0H         ; is divisor > 0
        stc     ccr,A2L
        bge     _lab1
        not     A0H             ; no - then make it +ve
        not     A0L
        adds    #1,A0
_lab1:  or      A1H,A1H ; look at dividend
        bge     _lab2
        not     A1H             ; it is -ve, make it positive
        not     A1L
        adds    #1,A1
        xor     #0x8,A2L; and toggle sign of result
_lab2:  rts
;; Basically the same, except that the sign of the divisor determines
;; the sign.
modnorm:
        or      A0H,A0H         ; is divisor > 0
        stc     ccr,A2L
        bge     _lab7
        not     A0H             ; no - then make it +ve
        not     A0L
        adds    #1,A0
_lab7:  or      A1H,A1H ; look at dividend
        bge     _lab8
        not     A1H             ; it is -ve, make it positive
        not     A1L
        adds    #1,A1
_lab8:  rts

; A0=A0/A1 signed

        .global ___divhi3
___divhi3:
        bsr     divnorm
        bsr     ___udivhi3
negans: btst    #3,A2L  ; should answer be negative ?
        beq     _lab4
        not     A0H     ; yes, so make it so
        not     A0L
        adds    #1,A0
_lab4:  rts

; A0=A0%A1 signed

        .global ___modhi3
___modhi3:
        bsr     modnorm
        bsr     ___udivhi3
        mov     A3,A0
        bra     negans

; A0=A0%A1 unsigned

        .global ___umodhi3
___umodhi3:
        bsr     ___udivhi3
        mov     A3,A0
        rts

; A0=A0/A1 unsigned
; A3=A0%A1 unsigned
; A2H trashed
; D high 8 bits of denom
; d low 8 bits of denom
; N high 8 bits of num
; n low 8 bits of num
; M high 8 bits of mod
; m low 8 bits of mod
; Q high 8 bits of quot
; q low 8 bits of quot
; P preserve

; The H8/300 only has a 16/8 bit divide, so we look at the incoming and
; see how to partition up the expression.

        .global ___udivhi3
___udivhi3:
                                ; A0 A1 A2 A3
                                ; Nn Dd       P
        sub.w   A3,A3           ; Nn Dd xP 00
        or      A1H,A1H
        bne     divlongway
        or      A0H,A0H
        beq     _lab6

; we know that D == 0 and N is != 0
        mov.b   A0H,A3L         ; Nn Dd xP 0N
        divxu   A1L,A3          ;          MQ
        mov.b   A3L,A0H         ; Q
; dealt with N, do n
_lab6:  mov.b   A0L,A3L         ;           n
        divxu   A1L,A3          ;          mq
        mov.b   A3L,A0L         ; Qq
        mov.b   A3H,A3L         ;           m
        mov.b   #0x0,A3H        ; Qq       0m
        rts

; D != 0 - which means the denominator is
;          loop around to get the result.

divlongway:
        mov.b   A0H,A3L         ; Nn Dd xP 0N
        mov.b   #0x0,A0H        ; high byte of answer has to be zero
        mov.b   #0x8,A2H        ;       8
div8:   add.b   A0L,A0L         ; n*=2
        rotxl   A3L             ; Make remainder bigger
        rotxl   A3H
        sub.w   A1,A3           ; Q-=N
        bhs     setbit          ; set a bit ?
        add.w   A1,A3           ;  no : too far , Q+=N

        dec     A2H
        bne     div8            ; next bit
        rts

setbit: inc     A0L             ; do insert bit
        dec     A2H
        bne     div8            ; next bit
        rts

#endif /* __H8300__ */
#endif /* L_divhi3 */

#ifdef L_divsi3

;; 4 byte integer divides for the H8/300.
;;
;; We have one routine which does all the work and lots of
;; little ones which prepare the args and massage the sign.
;; We bunch all of this into one object file since there are several
;; "supporting routines".

        .section .text
        .align 2

; Put abs SIs into r0/r1 and r2/r3, and leave a 1 in r6l with sign of rest.
; This function is here to keep branch displacements small.

#ifdef __H8300__

divnorm:
        mov.b   A0H,A0H         ; is the numerator -ve
        stc     ccr,S2L         ; keep the sign in bit 3 of S2L
        bge     postive

        ; negate arg
        not     A0H
        not     A1H
        not     A0L
        not     A1L

        add     #1,A1L
        addx    #0,A1H
        addx    #0,A0L
        addx    #0,A0H
postive:
        mov.b   A2H,A2H         ; is the denominator -ve
        bge     postive2
        not     A2L
        not     A2H
        not     A3L
        not     A3H
        add.b   #1,A3L
        addx    #0,A3H
        addx    #0,A2L
        addx    #0,A2H
        xor.b   #0x08,S2L       ; toggle the result sign
postive2:
        rts

;; Basically the same, except that the sign of the divisor determines
;; the sign.
modnorm:
        mov.b   A0H,A0H         ; is the numerator -ve
        stc     ccr,S2L         ; keep the sign in bit 3 of S2L
        bge     mpostive

        ; negate arg
        not     A0H
        not     A1H
        not     A0L
        not     A1L

        add     #1,A1L
        addx    #0,A1H
        addx    #0,A0L
        addx    #0,A0H
mpostive:
        mov.b   A2H,A2H         ; is the denominator -ve
        bge     mpostive2
        not     A2L
        not     A2H
        not     A3L
        not     A3H
        add.b   #1,A3L
        addx    #0,A3H
        addx    #0,A2L
        addx    #0,A2H
mpostive2:
        rts

#else /* __H8300H__ */

divnorm:
        mov.l   A0P,A0P         ; is the numerator -ve
        stc     ccr,S2L         ; keep the sign in bit 3 of S2L
        bge     postive

        neg.l   A0P             ; negate arg

postive:
        mov.l   A1P,A1P         ; is the denominator -ve
        bge     postive2

        neg.l   A1P             ; negate arg
        xor.b   #0x08,S2L       ; toggle the result sign

postive2:
        rts

;; Basically the same, except that the sign of the divisor determines
;; the sign.
modnorm:
        mov.l   A0P,A0P         ; is the numerator -ve
        stc     ccr,S2L         ; keep the sign in bit 3 of S2L
        bge     mpostive

        neg.l   A0P             ; negate arg

mpostive:
        mov.l   A1P,A1P         ; is the denominator -ve
        bge     mpostive2

        neg.l   A1P             ; negate arg

mpostive2:
        rts

#endif

; numerator in A0/A1
; denominator in A2/A3
        .global ___modsi3
___modsi3:
#ifdef __H8300__
        PUSHP   S2P
        PUSHP   S0P
        PUSHP   S1P
        bsr     modnorm
        bsr     divmodsi4
        mov     S0,A0
        mov     S1,A1
        bra     exitdiv
#else
        PUSHP   S2P
        bsr     modnorm
        bsr     ___udivsi3
        mov.l   er3,er0
        bra     exitdiv
#endif

        ;; H8/300H and H8S version of ___udivsi3 is defined later in
        ;; the file.
#ifdef __H8300__
        .global ___udivsi3
___udivsi3:
        PUSHP   S2P
        PUSHP   S0P
        PUSHP   S1P
        bsr     divmodsi4
        bra     reti
#endif

        .global ___umodsi3
___umodsi3:
#ifdef __H8300__
        PUSHP   S2P
        PUSHP   S0P
        PUSHP   S1P
        bsr     divmodsi4
        mov     S0,A0
        mov     S1,A1
        bra     reti
#else
        bsr     ___udivsi3
        mov.l   er3,er0
        rts
#endif

        .global ___divsi3
___divsi3:
#ifdef __H8300__
        PUSHP   S2P
        PUSHP   S0P
        PUSHP   S1P
        jsr     divnorm
        jsr     divmodsi4
#else
        PUSHP   S2P
        jsr     divnorm
        bsr     ___udivsi3
#endif

        ; examine what the sign should be
exitdiv:
        btst    #3,S2L
        beq     reti

        ; should be -ve
#ifdef __H8300__
        not     A0H
        not     A1H
        not     A0L
        not     A1L

        add     #1,A1L
        addx    #0,A1H
        addx    #0,A0L
        addx    #0,A0H
#else /* __H8300H__ */
        neg.l   A0P
#endif

reti:
#ifdef __H8300__
        POPP    S1P
        POPP    S0P
#endif
        POPP    S2P
        rts

        ; takes A0/A1 numerator (A0P for H8/300H)
        ; A2/A3 denominator (A1P for H8/300H)
        ; returns A0/A1 quotient (A0P for H8/300H)
        ; S0/S1 remainder (S0P for H8/300H)
        ; trashes S2H

#ifdef __H8300__

divmodsi4:
        sub.w   S0,S0           ; zero play area
        mov.w   S0,S1
        mov.b   A2H,S2H
        or      A2L,S2H
        or      A3H,S2H
        bne     DenHighNonZero
        mov.b   A0H,A0H
        bne     NumByte0Zero
        mov.b   A0L,A0L
        bne     NumByte1Zero
        mov.b   A1H,A1H
        bne     NumByte2Zero
        bra     NumByte3Zero
NumByte0Zero:
        mov.b   A0H,S1L
        divxu   A3L,S1
        mov.b   S1L,A0H
NumByte1Zero:
        mov.b   A0L,S1L
        divxu   A3L,S1
        mov.b   S1L,A0L
NumByte2Zero:
        mov.b   A1H,S1L
        divxu   A3L,S1
        mov.b   S1L,A1H
NumByte3Zero:
        mov.b   A1L,S1L
        divxu   A3L,S1
        mov.b   S1L,A1L

        mov.b   S1H,S1L
        mov.b   #0x0,S1H
        rts

; have to do the divide by shift and test
DenHighNonZero:
        mov.b   A0H,S1L
        mov.b   A0L,A0H
        mov.b   A1H,A0L
        mov.b   A1L,A1H

        mov.b   #0,A1L
        mov.b   #24,S2H ; only do 24 iterations

nextbit:
        add.w   A1,A1   ; double the answer guess
        rotxl   A0L
        rotxl   A0H

        rotxl   S1L     ; double remainder
        rotxl   S1H
        rotxl   S0L
        rotxl   S0H
        sub.w   A3,S1   ; does it all fit
        subx    A2L,S0L
        subx    A2H,S0H
        bhs     setone

        add.w   A3,S1   ; no, restore mistake
        addx    A2L,S0L
        addx    A2H,S0H

        dec     S2H
        bne     nextbit
        rts

setone:
        inc     A1L
        dec     S2H
        bne     nextbit
        rts

#else /* __H8300H__ */

        ;; This function also computes the remainder and stores it in er3.
        .global ___udivsi3
___udivsi3:
        mov.w   A1E,A1E         ; denominator top word 0?
        bne     DenHighNonZero

        ; do it the easy way, see page 107 in manual
        mov.w   A0E,A2
        extu.l  A2P
        divxu.w A1,A2P
        mov.w   A2E,A0E
        divxu.w A1,A0P
        mov.w   A0E,A3
        mov.w   A2,A0E
        extu.l  A3P
        rts

        ; er0 = er0 / er1
        ; er3 = er0 % er1
        ; trashes er1 er2
        ; expects er1 >= 2^16
DenHighNonZero:
        mov.l   er0,er3
        mov.l   er1,er2
#ifdef __H8300H__
divmod_L21:
        shlr.l  er0
        shlr.l  er2             ; make divisor < 2^16
        mov.w   e2,e2
        bne     divmod_L21
#else
        shlr.l  #2,er2          ; make divisor < 2^16
        mov.w   e2,e2
        beq     divmod_L22A
divmod_L21:
        shlr.l  #2,er0
divmod_L22:
        shlr.l  #2,er2          ; make divisor < 2^16
        mov.w   e2,e2
        bne     divmod_L21
divmod_L22A:
        rotxl.w r2
        bcs     divmod_L23
        shlr.l  er0
        bra     divmod_L24
divmod_L23:
        rotxr.w r2
        shlr.l  #2,er0
divmod_L24:
#endif
        ;; At this point,
        ;;  er0 contains shifted dividend
        ;;  er1 contains divisor
        ;;  er2 contains shifted divisor
        ;;  er3 contains dividend, later remainder
        divxu.w r2,er0          ; r0 now contains the approximate quotient (AQ)
        extu.l  er0
        beq     divmod_L25
        subs    #1,er0          ; er0 = AQ - 1
        mov.w   e1,r2
        mulxu.w r0,er2          ; er2 = upper (AQ - 1) * divisor
        sub.w   r2,e3           ; dividend - 65536 * er2
        mov.w   r1,r2
        mulxu.w r0,er2          ; compute er3 = remainder (tentative)
        sub.l   er2,er3         ; er3 = dividend - (AQ - 1) * divisor
divmod_L25:
        cmp.l   er1,er3         ; is divisor < remainder?
        blo     divmod_L26
        adds    #1,er0
        sub.l   er1,er3         ; correct the remainder
divmod_L26:
        rts

#endif
#endif /* L_divsi3 */

#ifdef L_mulhi3

;; HImode multiply.
; The H8/300 only has an 8*8->16 multiply.
; The answer is the same as:
;
; product = (srca.l * srcb.l) + ((srca.h * srcb.l) + (srcb.h * srca.l)) * 256
; (we can ignore A1.h * A0.h cause that will all off the top)
; A0 in
; A1 in
; A0 answer

#ifdef __H8300__
        .section .text
        .align 2
        .global ___mulhi3
___mulhi3:
        mov.b   A1L,A2L         ; A2l gets srcb.l
        mulxu   A0L,A2          ; A2 gets first sub product

        mov.b   A0H,A3L         ; prepare for
        mulxu   A1L,A3          ; second sub product

        add.b   A3L,A2H         ; sum first two terms

        mov.b   A1H,A3L         ; third sub product
        mulxu   A0L,A3

        add.b   A3L,A2H         ; almost there
        mov.w   A2,A0           ; that is
        rts

#endif
#endif /* L_mulhi3 */

#ifdef L_mulsi3

;; SImode multiply.
;;
;; I think that shift and add may be sufficient for this.  Using the
;; supplied 8x8->16 would need 10 ops of 14 cycles each + overhead.  This way
;; the inner loop uses maybe 20 cycles + overhead, but terminates
;; quickly on small args.
;;
;; A0/A1 src_a
;; A2/A3 src_b
;;
;;  while (a)
;;    {
;;      if (a & 1)
;;        r += b;
;;      a >>= 1;
;;      b <<= 1;
;;    }

        .section .text
        .align 2

#ifdef __H8300__

        .global ___mulsi3
___mulsi3:
        PUSHP   S0P
        PUSHP   S1P

        sub.w   S0,S0
        sub.w   S1,S1

        ; while (a)
_top:   mov.w   A0,A0
        bne     _more
        mov.w   A1,A1
        beq     _done
_more:  ; if (a & 1)
        bld     #0,A1L
        bcc     _nobit
        ; r += b
        add.w   A3,S1
        addx    A2L,S0L
        addx    A2H,S0H
_nobit:
        ; a >>= 1
        shlr    A0H
        rotxr   A0L
        rotxr   A1H
        rotxr   A1L

        ; b <<= 1
        add.w   A3,A3
        addx    A2L,A2L
        addx    A2H,A2H
        bra     _top

_done:
        mov.w   S0,A0
        mov.w   S1,A1
        POPP    S1P
        POPP    S0P
        rts

#else /* __H8300H__ */

;
; mulsi3 for H8/300H - based on Renesas SH implementation
;
; by Toshiyasu Morita
;
; Old code:
;
; 16b * 16b = 372 states (worst case)
; 32b * 32b = 724 states (worst case)
;
; New code:
;
; 16b * 16b =  48 states
; 16b * 32b =  72 states
; 32b * 32b =  92 states
;

        .global ___mulsi3
___mulsi3:
        mov.w   r1,r2   ; ( 2 states) b * d
        mulxu   r0,er2  ; (22 states)

        mov.w   e0,r3   ; ( 2 states) a * d
        beq     L_skip1 ; ( 4 states)
        mulxu   r1,er3  ; (22 states)
        add.w   r3,e2   ; ( 2 states)

L_skip1:
        mov.w   e1,r3   ; ( 2 states) c * b
        beq     L_skip2 ; ( 4 states)
        mulxu   r0,er3  ; (22 states)
        add.w   r3,e2   ; ( 2 states)

L_skip2:
        mov.l   er2,er0 ; ( 2 states)
        rts             ; (10 states)

#endif
#endif /* L_mulsi3 */
#ifdef L_fixunssfsi_asm
/* For the h8300 we use asm to save some bytes, to
   allow more programs to fit into the tiny address
   space.  For the H8/300H and H8S, the C version is good enough.  */
#ifdef __H8300__
/* We still treat NANs different than libgcc2.c, but then, the
   behavior is undefined anyways.  */
        .global ___fixunssfsi
___fixunssfsi:
        cmp.b #0x4f,r0h
        bge Large_num
        jmp     @___fixsfsi
Large_num:
        bhi L_huge_num
        xor.b #0x80,A0L
        bmi L_shift8
L_huge_num:
        mov.w #65535,A0
        mov.w A0,A1
        rts
L_shift8:
        mov.b A0L,A0H
        mov.b A1H,A0L
        mov.b A1L,A1H
        mov.b #0,A1L
        rts
#endif
#endif /* L_fixunssfsi_asm */