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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [config/] [h8300/] [lib1funcs.asm] - Blame information for rev 154

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
   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 */

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [config/] [h8300/] [lib1funcs.asm] - Blame information for rev 154

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