URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [h8300/] [lib1funcs.S] - Blame information for rev 734

Details | Compare with Previous | View Log


;; libgcc routines for the Renesas H8/300 CPU.
;; Contributed by Steve Chamberlain 
;; Optimizations by Toshiyasu Morita 
 
/* Copyright (C) 1994, 2000, 2001, 2002, 2003, 2004, 2009
   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 3, or (at your option) any
later version.
 
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.
 
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
 
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
.  */
 
/* 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 */

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [h8300/] [lib1funcs.S] - Blame information for rev 734

Line No.	Rev	Author	Line
1	734	jeremybenn	`;; libgcc routines for the Renesas H8/300 CPU.`
2			`;; Contributed by Steve Chamberlain`
3			`;; Optimizations by Toshiyasu Morita`
4
5			`/* Copyright (C) 1994, 2000, 2001, 2002, 2003, 2004, 2009`
6			`Free Software Foundation, Inc.`
7
8			`This file is free software; you can redistribute it and/or modify it`
9			`under the terms of the GNU General Public License as published by the`
10			`Free Software Foundation; either version 3, or (at your option) any`
11			`later version.`
12
13			`This file is distributed in the hope that it will be useful, but`
14			`WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
16			`General Public License for more details.`
17
18			`Under Section 7 of GPL version 3, you are granted additional`
19			`permissions described in the GCC Runtime Library Exception, version`
20			`3.1, as published by the Free Software Foundation.`
21
22			`You should have received a copy of the GNU General Public License and`
23			`a copy of the GCC Runtime Library Exception along with this program;`
24			`see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
25			`. */`
26
27			`/* Assembler register definitions. */`
28
29			`#define A0 r0`
30			`#define A0L r0l`
31			`#define A0H r0h`
32
33			`#define A1 r1`
34			`#define A1L r1l`
35			`#define A1H r1h`
36
37			`#define A2 r2`
38			`#define A2L r2l`
39			`#define A2H r2h`
40
41			`#define A3 r3`
42			`#define A3L r3l`
43			`#define A3H r3h`
44
45			`#define S0 r4`
46			`#define S0L r4l`
47			`#define S0H r4h`
48
49			`#define S1 r5`
50			`#define S1L r5l`
51			`#define S1H r5h`
52
53			`#define S2 r6`
54			`#define S2L r6l`
55			`#define S2H r6h`
56
57			`#ifdef __H8300__`
58			`#define PUSHP push`
59			`#define POPP pop`
60
61			`#define A0P r0`
62			`#define A1P r1`
63			`#define A2P r2`
64			`#define A3P r3`
65			`#define S0P r4`
66			`#define S1P r5`
67			`#define S2P r6`
68			`#endif`
69
70			`#if defined (__H8300H__) \|\| defined (__H8300S__) \|\| defined (__H8300SX__)`
71			`#define PUSHP push.l`
72			`#define POPP pop.l`
73
74			`#define A0P er0`
75			`#define A1P er1`
76			`#define A2P er2`
77			`#define A3P er3`
78			`#define S0P er4`
79			`#define S1P er5`
80			`#define S2P er6`
81
82			`#define A0E e0`
83			`#define A1E e1`
84			`#define A2E e2`
85			`#define A3E e3`
86			`#endif`
87
88			`#ifdef __H8300H__`
89			`#ifdef __NORMAL_MODE__`
90			`.h8300hn`
91			`#else`
92			`.h8300h`
93			`#endif`
94			`#endif`
95
96			`#ifdef __H8300S__`
97			`#ifdef __NORMAL_MODE__`
98			`.h8300sn`
99			`#else`
100			`.h8300s`
101			`#endif`
102			`#endif`
103			`#ifdef __H8300SX__`
104			`#ifdef __NORMAL_MODE__`
105			`.h8300sxn`
106			`#else`
107			`.h8300sx`
108			`#endif`
109			`#endif`
110
111			`#ifdef L_cmpsi2`
112			`#ifdef __H8300__`
113			`.section .text`
114			`.align 2`
115			`.global ___cmpsi2`
116			`___cmpsi2:`
117			`cmp.w A0,A2`
118			`bne .L2`
119			`cmp.w A1,A3`
120			`bne .L4`
121			`mov.w #1,A0`
122			`rts`
123			`.L2:`
124			`bgt .L5`
125			`.L3:`
126			`mov.w #2,A0`
127			`rts`
128			`.L4:`
129			`bls .L3`
130			`.L5:`
131			`sub.w A0,A0`
132			`rts`
133			`.end`
134			`#endif`
135			`#endif /* L_cmpsi2 */`
136
137			`#ifdef L_ucmpsi2`
138			`#ifdef __H8300__`
139			`.section .text`
140			`.align 2`
141			`.global ___ucmpsi2`
142			`___ucmpsi2:`
143			`cmp.w A0,A2`
144			`bne .L2`
145			`cmp.w A1,A3`
146			`bne .L4`
147			`mov.w #1,A0`
148			`rts`
149			`.L2:`
150			`bhi .L5`
151			`.L3:`
152			`mov.w #2,A0`
153			`rts`
154			`.L4:`
155			`bls .L3`
156			`.L5:`
157			`sub.w A0,A0`
158			`rts`
159			`.end`
160			`#endif`
161			`#endif /* L_ucmpsi2 */`
162
163			`#ifdef L_divhi3`
164
165			`;; HImode divides for the H8/300.`
166			`;; We bunch all of this into one object file since there are several`
167			`;; "supporting routines".`
168
169			`; general purpose normalize routine`
170			`;`
171			`; divisor in A0`
172			`; dividend in A1`
173			`; turns both into +ve numbers, and leaves what the answer sign`
174			`; should be in A2L`
175
176			`#ifdef __H8300__`
177			`.section .text`
178			`.align 2`
179			`divnorm:`
180			`or A0H,A0H ; is divisor > 0`
181			`stc ccr,A2L`
182			`bge _lab1`
183			`not A0H ; no - then make it +ve`
184			`not A0L`
185			`adds #1,A0`
186			`_lab1: or A1H,A1H ; look at dividend`
187			`bge _lab2`
188			`not A1H ; it is -ve, make it positive`
189			`not A1L`
190			`adds #1,A1`
191			`xor #0x8,A2L; and toggle sign of result`
192			`_lab2: rts`
193			`;; Basically the same, except that the sign of the divisor determines`
194			`;; the sign.`
195			`modnorm:`
196			`or A0H,A0H ; is divisor > 0`
197			`stc ccr,A2L`
198			`bge _lab7`
199			`not A0H ; no - then make it +ve`
200			`not A0L`
201			`adds #1,A0`
202			`_lab7: or A1H,A1H ; look at dividend`
203			`bge _lab8`
204			`not A1H ; it is -ve, make it positive`
205			`not A1L`
206			`adds #1,A1`
207			`_lab8: rts`
208
209			`; A0=A0/A1 signed`
210
211			`.global ___divhi3`
212			`___divhi3:`
213			`bsr divnorm`
214			`bsr ___udivhi3`
215			`negans: btst #3,A2L ; should answer be negative ?`
216			`beq _lab4`
217			`not A0H ; yes, so make it so`
218			`not A0L`
219			`adds #1,A0`
220			`_lab4: rts`
221
222			`; A0=A0%A1 signed`
223
224			`.global ___modhi3`
225			`___modhi3:`
226			`bsr modnorm`
227			`bsr ___udivhi3`
228			`mov A3,A0`
229			`bra negans`
230
231			`; A0=A0%A1 unsigned`
232
233			`.global ___umodhi3`
234			`___umodhi3:`
235			`bsr ___udivhi3`
236			`mov A3,A0`
237			`rts`
238
239			`; A0=A0/A1 unsigned`
240			`; A3=A0%A1 unsigned`
241			`; A2H trashed`
242			`; D high 8 bits of denom`
243			`; d low 8 bits of denom`
244			`; N high 8 bits of num`
245			`; n low 8 bits of num`
246			`; M high 8 bits of mod`
247			`; m low 8 bits of mod`
248			`; Q high 8 bits of quot`
249			`; q low 8 bits of quot`
250			`; P preserve`
251
252			`; The H8/300 only has a 16/8 bit divide, so we look at the incoming and`
253			`; see how to partition up the expression.`
254
255			`.global ___udivhi3`
256			`___udivhi3:`
257			`; A0 A1 A2 A3`
258			`; Nn Dd P`
259			`sub.w A3,A3 ; Nn Dd xP 00`
260			`or A1H,A1H`
261			`bne divlongway`
262			`or A0H,A0H`
263			`beq _lab6`
264
265			`; we know that D == 0 and N is != 0`
266			`mov.b A0H,A3L ; Nn Dd xP 0N`
267			`divxu A1L,A3 ; MQ`
268			`mov.b A3L,A0H ; Q`
269			`; dealt with N, do n`
270			`_lab6: mov.b A0L,A3L ; n`
271			`divxu A1L,A3 ; mq`
272			`mov.b A3L,A0L ; Qq`
273			`mov.b A3H,A3L ; m`
274			`mov.b #0x0,A3H ; Qq 0m`
275			`rts`
276
277			`; D != 0 - which means the denominator is`
278			`; loop around to get the result.`
279
280			`divlongway:`
281			`mov.b A0H,A3L ; Nn Dd xP 0N`
282			`mov.b #0x0,A0H ; high byte of answer has to be zero`
283			`mov.b #0x8,A2H ; 8`
284			`div8: add.b A0L,A0L ; n*=2`
285			`rotxl A3L ; Make remainder bigger`
286			`rotxl A3H`
287			`sub.w A1,A3 ; Q-=N`
288			`bhs setbit ; set a bit ?`
289			`add.w A1,A3 ; no : too far , Q+=N`
290
291			`dec A2H`
292			`bne div8 ; next bit`
293			`rts`
294
295			`setbit: inc A0L ; do insert bit`
296			`dec A2H`
297			`bne div8 ; next bit`
298			`rts`
299
300			`#endif /* __H8300__ */`
301			`#endif /* L_divhi3 */`
302
303			`#ifdef L_divsi3`
304
305			`;; 4 byte integer divides for the H8/300.`
306			`;;`
307			`;; We have one routine which does all the work and lots of`
308			`;; little ones which prepare the args and massage the sign.`
309			`;; We bunch all of this into one object file since there are several`
310			`;; "supporting routines".`
311
312			`.section .text`
313			`.align 2`
314
315			`; Put abs SIs into r0/r1 and r2/r3, and leave a 1 in r6l with sign of rest.`
316			`; This function is here to keep branch displacements small.`
317
318			`#ifdef __H8300__`
319
320			`divnorm:`
321			`mov.b A0H,A0H ; is the numerator -ve`
322			`stc ccr,S2L ; keep the sign in bit 3 of S2L`
323			`bge postive`
324
325			`; negate arg`
326			`not A0H`
327			`not A1H`
328			`not A0L`
329			`not A1L`
330
331			`add #1,A1L`
332			`addx #0,A1H`
333			`addx #0,A0L`
334			`addx #0,A0H`
335			`postive:`
336			`mov.b A2H,A2H ; is the denominator -ve`
337			`bge postive2`
338			`not A2L`
339			`not A2H`
340			`not A3L`
341			`not A3H`
342			`add.b #1,A3L`
343			`addx #0,A3H`
344			`addx #0,A2L`
345			`addx #0,A2H`
346			`xor.b #0x08,S2L ; toggle the result sign`
347			`postive2:`
348			`rts`
349
350			`;; Basically the same, except that the sign of the divisor determines`
351			`;; the sign.`
352			`modnorm:`
353			`mov.b A0H,A0H ; is the numerator -ve`
354			`stc ccr,S2L ; keep the sign in bit 3 of S2L`
355			`bge mpostive`
356
357			`; negate arg`
358			`not A0H`
359			`not A1H`
360			`not A0L`
361			`not A1L`
362
363			`add #1,A1L`
364			`addx #0,A1H`
365			`addx #0,A0L`
366			`addx #0,A0H`
367			`mpostive:`
368			`mov.b A2H,A2H ; is the denominator -ve`
369			`bge mpostive2`
370			`not A2L`
371			`not A2H`
372			`not A3L`
373			`not A3H`
374			`add.b #1,A3L`
375			`addx #0,A3H`
376			`addx #0,A2L`
377			`addx #0,A2H`
378			`mpostive2:`
379			`rts`
380
381			`#else /* __H8300H__ */`
382
383			`divnorm:`
384			`mov.l A0P,A0P ; is the numerator -ve`
385			`stc ccr,S2L ; keep the sign in bit 3 of S2L`
386			`bge postive`
387
388			`neg.l A0P ; negate arg`
389
390			`postive:`
391			`mov.l A1P,A1P ; is the denominator -ve`
392			`bge postive2`
393
394			`neg.l A1P ; negate arg`
395			`xor.b #0x08,S2L ; toggle the result sign`
396
397			`postive2:`
398			`rts`
399
400			`;; Basically the same, except that the sign of the divisor determines`
401			`;; the sign.`
402			`modnorm:`
403			`mov.l A0P,A0P ; is the numerator -ve`
404			`stc ccr,S2L ; keep the sign in bit 3 of S2L`
405			`bge mpostive`
406
407			`neg.l A0P ; negate arg`
408
409			`mpostive:`
410			`mov.l A1P,A1P ; is the denominator -ve`
411			`bge mpostive2`
412
413			`neg.l A1P ; negate arg`
414
415			`mpostive2:`
416			`rts`
417
418			`#endif`
419
420			`; numerator in A0/A1`
421			`; denominator in A2/A3`
422			`.global ___modsi3`
423			`___modsi3:`
424			`#ifdef __H8300__`
425			`PUSHP S2P`
426			`PUSHP S0P`
427			`PUSHP S1P`
428			`bsr modnorm`
429			`bsr divmodsi4`
430			`mov S0,A0`
431			`mov S1,A1`
432			`bra exitdiv`
433			`#else`
434			`PUSHP S2P`
435			`bsr modnorm`
436			`bsr ___udivsi3`
437			`mov.l er3,er0`
438			`bra exitdiv`
439			`#endif`
440
441			`;; H8/300H and H8S version of ___udivsi3 is defined later in`
442			`;; the file.`
443			`#ifdef __H8300__`
444			`.global ___udivsi3`
445			`___udivsi3:`
446			`PUSHP S2P`
447			`PUSHP S0P`
448			`PUSHP S1P`
449			`bsr divmodsi4`
450			`bra reti`
451			`#endif`
452
453			`.global ___umodsi3`
454			`___umodsi3:`
455			`#ifdef __H8300__`
456			`PUSHP S2P`
457			`PUSHP S0P`
458			`PUSHP S1P`
459			`bsr divmodsi4`
460			`mov S0,A0`
461			`mov S1,A1`
462			`bra reti`
463			`#else`
464			`bsr ___udivsi3`
465			`mov.l er3,er0`
466			`rts`
467			`#endif`
468
469			`.global ___divsi3`
470			`___divsi3:`
471			`#ifdef __H8300__`
472			`PUSHP S2P`
473			`PUSHP S0P`
474			`PUSHP S1P`
475			`jsr divnorm`
476			`jsr divmodsi4`
477			`#else`
478			`PUSHP S2P`
479			`jsr divnorm`
480			`bsr ___udivsi3`
481			`#endif`
482
483			`; examine what the sign should be`
484			`exitdiv:`
485			`btst #3,S2L`
486			`beq reti`
487
488			`; should be -ve`
489			`#ifdef __H8300__`
490			`not A0H`
491			`not A1H`
492			`not A0L`
493			`not A1L`
494
495			`add #1,A1L`
496			`addx #0,A1H`
497			`addx #0,A0L`
498			`addx #0,A0H`
499			`#else /* __H8300H__ */`
500			`neg.l A0P`
501			`#endif`
502
503			`reti:`
504			`#ifdef __H8300__`
505			`POPP S1P`
506			`POPP S0P`
507			`#endif`
508			`POPP S2P`
509			`rts`
510
511			`; takes A0/A1 numerator (A0P for H8/300H)`
512			`; A2/A3 denominator (A1P for H8/300H)`
513			`; returns A0/A1 quotient (A0P for H8/300H)`
514			`; S0/S1 remainder (S0P for H8/300H)`
515			`; trashes S2H`
516
517			`#ifdef __H8300__`
518
519			`divmodsi4:`
520			`sub.w S0,S0 ; zero play area`
521			`mov.w S0,S1`
522			`mov.b A2H,S2H`
523			`or A2L,S2H`
524			`or A3H,S2H`
525			`bne DenHighNonZero`
526			`mov.b A0H,A0H`
527			`bne NumByte0Zero`
528			`mov.b A0L,A0L`
529			`bne NumByte1Zero`
530			`mov.b A1H,A1H`
531			`bne NumByte2Zero`
532			`bra NumByte3Zero`
533			`NumByte0Zero:`
534			`mov.b A0H,S1L`
535			`divxu A3L,S1`
536			`mov.b S1L,A0H`
537			`NumByte1Zero:`
538			`mov.b A0L,S1L`
539			`divxu A3L,S1`
540			`mov.b S1L,A0L`
541			`NumByte2Zero:`
542			`mov.b A1H,S1L`
543			`divxu A3L,S1`
544			`mov.b S1L,A1H`
545			`NumByte3Zero:`
546			`mov.b A1L,S1L`
547			`divxu A3L,S1`
548			`mov.b S1L,A1L`
549
550			`mov.b S1H,S1L`
551			`mov.b #0x0,S1H`
552			`rts`
553
554			`; have to do the divide by shift and test`
555			`DenHighNonZero:`
556			`mov.b A0H,S1L`
557			`mov.b A0L,A0H`
558			`mov.b A1H,A0L`
559			`mov.b A1L,A1H`
560
561			`mov.b #0,A1L`
562			`mov.b #24,S2H ; only do 24 iterations`
563
564			`nextbit:`
565			`add.w A1,A1 ; double the answer guess`
566			`rotxl A0L`
567			`rotxl A0H`
568
569			`rotxl S1L ; double remainder`
570			`rotxl S1H`
571			`rotxl S0L`
572			`rotxl S0H`
573			`sub.w A3,S1 ; does it all fit`
574			`subx A2L,S0L`
575			`subx A2H,S0H`
576			`bhs setone`
577
578			`add.w A3,S1 ; no, restore mistake`
579			`addx A2L,S0L`
580			`addx A2H,S0H`
581
582			`dec S2H`
583			`bne nextbit`
584			`rts`
585
586			`setone:`
587			`inc A1L`
588			`dec S2H`
589			`bne nextbit`
590			`rts`
591
592			`#else /* __H8300H__ */`
593
594			`;; This function also computes the remainder and stores it in er3.`
595			`.global ___udivsi3`
596			`___udivsi3:`
597			`mov.w A1E,A1E ; denominator top word 0?`
598			`bne DenHighNonZero`
599
600			`; do it the easy way, see page 107 in manual`
601			`mov.w A0E,A2`
602			`extu.l A2P`
603			`divxu.w A1,A2P`
604			`mov.w A2E,A0E`
605			`divxu.w A1,A0P`
606			`mov.w A0E,A3`
607			`mov.w A2,A0E`
608			`extu.l A3P`
609			`rts`
610
611			`; er0 = er0 / er1`
612			`; er3 = er0 % er1`
613			`; trashes er1 er2`
614			`; expects er1 >= 2^16`
615			`DenHighNonZero:`
616			`mov.l er0,er3`
617			`mov.l er1,er2`
618			`#ifdef __H8300H__`
619			`divmod_L21:`
620			`shlr.l er0`
621			`shlr.l er2 ; make divisor < 2^16`
622			`mov.w e2,e2`
623			`bne divmod_L21`
624			`#else`
625			`shlr.l #2,er2 ; make divisor < 2^16`
626			`mov.w e2,e2`
627			`beq divmod_L22A`
628			`divmod_L21:`
629			`shlr.l #2,er0`
630			`divmod_L22:`
631			`shlr.l #2,er2 ; make divisor < 2^16`
632			`mov.w e2,e2`
633			`bne divmod_L21`
634			`divmod_L22A:`
635			`rotxl.w r2`
636			`bcs divmod_L23`
637			`shlr.l er0`
638			`bra divmod_L24`
639			`divmod_L23:`
640			`rotxr.w r2`
641			`shlr.l #2,er0`
642			`divmod_L24:`
643			`#endif`
644			`;; At this point,`
645			`;; er0 contains shifted dividend`
646			`;; er1 contains divisor`
647			`;; er2 contains shifted divisor`
648			`;; er3 contains dividend, later remainder`
649			`divxu.w r2,er0 ; r0 now contains the approximate quotient (AQ)`
650			`extu.l er0`
651			`beq divmod_L25`
652			`subs #1,er0 ; er0 = AQ - 1`
653			`mov.w e1,r2`
654			`mulxu.w r0,er2 ; er2 = upper (AQ - 1) * divisor`
655			`sub.w r2,e3 ; dividend - 65536 * er2`
656			`mov.w r1,r2`
657			`mulxu.w r0,er2 ; compute er3 = remainder (tentative)`
658			`sub.l er2,er3 ; er3 = dividend - (AQ - 1) * divisor`
659			`divmod_L25:`
660			`cmp.l er1,er3 ; is divisor < remainder?`
661			`blo divmod_L26`
662			`adds #1,er0`
663			`sub.l er1,er3 ; correct the remainder`
664			`divmod_L26:`
665			`rts`
666
667			`#endif`
668			`#endif /* L_divsi3 */`
669
670			`#ifdef L_mulhi3`
671
672			`;; HImode multiply.`
673			`; The H8/300 only has an 8*8->16 multiply.`
674			`; The answer is the same as:`
675			`;`
676			`; product = (srca.l * srcb.l) + ((srca.h * srcb.l) + (srcb.h * srca.l)) * 256`
677			`; (we can ignore A1.h * A0.h cause that will all off the top)`
678			`; A0 in`
679			`; A1 in`
680			`; A0 answer`
681
682			`#ifdef __H8300__`
683			`.section .text`
684			`.align 2`
685			`.global ___mulhi3`
686			`___mulhi3:`
687			`mov.b A1L,A2L ; A2l gets srcb.l`
688			`mulxu A0L,A2 ; A2 gets first sub product`
689
690			`mov.b A0H,A3L ; prepare for`
691			`mulxu A1L,A3 ; second sub product`
692
693			`add.b A3L,A2H ; sum first two terms`
694
695			`mov.b A1H,A3L ; third sub product`
696			`mulxu A0L,A3`
697
698			`add.b A3L,A2H ; almost there`
699			`mov.w A2,A0 ; that is`
700			`rts`
701
702			`#endif`
703			`#endif /* L_mulhi3 */`
704
705			`#ifdef L_mulsi3`
706
707			`;; SImode multiply.`
708			`;;`
709			`;; I think that shift and add may be sufficient for this. Using the`
710			`;; supplied 8x8->16 would need 10 ops of 14 cycles each + overhead. This way`
711			`;; the inner loop uses maybe 20 cycles + overhead, but terminates`
712			`;; quickly on small args.`
713			`;;`
714			`;; A0/A1 src_a`
715			`;; A2/A3 src_b`
716			`;;`
717			`;; while (a)`
718			`;; {`
719			`;; if (a & 1)`
720			`;; r += b;`
721			`;; a >>= 1;`
722			`;; b <<= 1;`
723			`;; }`
724
725			`.section .text`
726			`.align 2`
727
728			`#ifdef __H8300__`
729
730			`.global ___mulsi3`
731			`___mulsi3:`
732			`PUSHP S0P`
733			`PUSHP S1P`
734
735			`sub.w S0,S0`
736			`sub.w S1,S1`
737
738			`; while (a)`
739			`_top: mov.w A0,A0`
740			`bne _more`
741			`mov.w A1,A1`
742			`beq _done`
743			`_more: ; if (a & 1)`
744			`bld #0,A1L`
745			`bcc _nobit`
746			`; r += b`
747			`add.w A3,S1`
748			`addx A2L,S0L`
749			`addx A2H,S0H`
750			`_nobit:`
751			`; a >>= 1`
752			`shlr A0H`
753			`rotxr A0L`
754			`rotxr A1H`
755			`rotxr A1L`
756
757			`; b <<= 1`
758			`add.w A3,A3`
759			`addx A2L,A2L`
760			`addx A2H,A2H`
761			`bra _top`
762
763			`_done:`
764			`mov.w S0,A0`
765			`mov.w S1,A1`
766			`POPP S1P`
767			`POPP S0P`
768			`rts`
769
770			`#else /* __H8300H__ */`
771
772			`;`
773			`; mulsi3 for H8/300H - based on Renesas SH implementation`
774			`;`
775			`; by Toshiyasu Morita`
776			`;`
777			`; Old code:`
778			`;`
779			`; 16b * 16b = 372 states (worst case)`
780			`; 32b * 32b = 724 states (worst case)`
781			`;`
782			`; New code:`
783			`;`
784			`; 16b * 16b = 48 states`
785			`; 16b * 32b = 72 states`
786			`; 32b * 32b = 92 states`
787			`;`
788
789			`.global ___mulsi3`
790			`___mulsi3:`
791			`mov.w r1,r2 ; ( 2 states) b * d`
792			`mulxu r0,er2 ; (22 states)`
793
794			`mov.w e0,r3 ; ( 2 states) a * d`
795			`beq L_skip1 ; ( 4 states)`
796			`mulxu r1,er3 ; (22 states)`
797			`add.w r3,e2 ; ( 2 states)`
798
799			`L_skip1:`
800			`mov.w e1,r3 ; ( 2 states) c * b`
801			`beq L_skip2 ; ( 4 states)`
802			`mulxu r0,er3 ; (22 states)`
803			`add.w r3,e2 ; ( 2 states)`
804
805			`L_skip2:`
806			`mov.l er2,er0 ; ( 2 states)`
807			`rts ; (10 states)`
808
809			`#endif`
810			`#endif /* L_mulsi3 */`
811			`#ifdef L_fixunssfsi_asm`
812			`/* For the h8300 we use asm to save some bytes, to`
813			`allow more programs to fit into the tiny address`
814			`space. For the H8/300H and H8S, the C version is good enough. */`
815			`#ifdef __H8300__`
816			`/* We still treat NANs different than libgcc2.c, but then, the`
817			`behavior is undefined anyways. */`
818			`.global ___fixunssfsi`
819			`___fixunssfsi:`
820			`cmp.b #0x4f,r0h`
821			`bge Large_num`
822			`jmp @___fixsfsi`
823			`Large_num:`
824			`bhi L_huge_num`
825			`xor.b #0x80,A0L`
826			`bmi L_shift8`
827			`L_huge_num:`
828			`mov.w #65535,A0`
829			`mov.w A0,A1`
830			`rts`
831			`L_shift8:`
832			`mov.b A0L,A0H`
833			`mov.b A1H,A0L`
834			`mov.b A1L,A1H`
835			`mov.b #0,A1L`
836			`rts`
837			`#endif`
838			`#endif /* L_fixunssfsi_asm */`