Subversion Repositories openrisc_me

/*  -*- Mode: Asm -*-  */
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
   Contributed by Denis Chertykov <denisc@overta.ru>

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

#define __zero_reg__ r1
#define __tmp_reg__ r0
#define __SREG__ 0x3f
#define __SP_H__ 0x3e
#define __SP_L__ 0x3d

/* Most of the functions here are called directly from avr.md
   patterns, instead of using the standard libcall mechanisms.
   This can make better code because GCC knows exactly which
   of the call-used registers (not all of them) are clobbered.  */

        .section .text.libgcc, "ax", @progbits

        .macro  mov_l  r_dest, r_src
#if defined (__AVR_HAVE_MOVW__)
        movw    \r_dest, \r_src
#else
        mov     \r_dest, \r_src
#endif
        .endm

        .macro  mov_h  r_dest, r_src
#if defined (__AVR_HAVE_MOVW__)
        ; empty
#else
        mov     \r_dest, \r_src
#endif
        .endm

/* Note: mulqi3, mulhi3 are open-coded on the enhanced core.  */
#if !defined (__AVR_ENHANCED__)
/*******************************************************
               Multiplication  8 x 8
*******************************************************/
#if defined (L_mulqi3)

#define r_arg2  r22             /* multiplicand */
#define r_arg1  r24             /* multiplier */
#define r_res   __tmp_reg__     /* result */

        .global __mulqi3
        .func   __mulqi3
__mulqi3:
        clr     r_res           ; clear result
__mulqi3_loop:
        sbrc    r_arg1,0
        add     r_res,r_arg2
        add     r_arg2,r_arg2   ; shift multiplicand
        breq    __mulqi3_exit   ; while multiplicand != 0
        lsr     r_arg1          ; 
        brne    __mulqi3_loop   ; exit if multiplier = 0
__mulqi3_exit:  
        mov     r_arg1,r_res    ; result to return register
        ret

#undef r_arg2  
#undef r_arg1  
#undef r_res   
        
.endfunc
#endif  /* defined (L_mulqi3) */

#if defined (L_mulqihi3)
        .global __mulqihi3
        .func   __mulqihi3
__mulqihi3:
        clr     r25
        sbrc    r24, 7
        dec     r25
        clr     r23
        sbrc    r22, 7
        dec     r22
        rjmp    __mulhi3
        .endfunc
#endif /* defined (L_mulqihi3) */

#if defined (L_umulqihi3)
        .global __umulqihi3
        .func   __umulqihi3
__umulqihi3:
        clr     r25
        clr     r23
        rjmp    __mulhi3
        .endfunc
#endif /* defined (L_umulqihi3) */

/*******************************************************
               Multiplication  16 x 16
*******************************************************/
#if defined (L_mulhi3)
#define r_arg1L r24             /* multiplier Low */
#define r_arg1H r25             /* multiplier High */
#define r_arg2L r22             /* multiplicand Low */
#define r_arg2H r23             /* multiplicand High */
#define r_resL  __tmp_reg__     /* result Low */
#define r_resH  r21             /* result High */

        .global __mulhi3
        .func   __mulhi3
__mulhi3:
        clr     r_resH          ; clear result
        clr     r_resL          ; clear result
__mulhi3_loop:
        sbrs    r_arg1L,0
        rjmp    __mulhi3_skip1
        add     r_resL,r_arg2L  ; result + multiplicand
        adc     r_resH,r_arg2H
__mulhi3_skip1: 
        add     r_arg2L,r_arg2L ; shift multiplicand
        adc     r_arg2H,r_arg2H

        cp      r_arg2L,__zero_reg__
        cpc     r_arg2H,__zero_reg__
        breq    __mulhi3_exit   ; while multiplicand != 0

        lsr     r_arg1H         ; gets LSB of multiplier
        ror     r_arg1L
        sbiw    r_arg1L,0
        brne    __mulhi3_loop   ; exit if multiplier = 0
__mulhi3_exit:
        mov     r_arg1H,r_resH  ; result to return register
        mov     r_arg1L,r_resL
        ret

#undef r_arg1L
#undef r_arg1H
#undef r_arg2L
#undef r_arg2H
#undef r_resL   
#undef r_resH 

.endfunc
#endif /* defined (L_mulhi3) */
#endif /* !defined (__AVR_ENHANCED__) */

#if defined (L_mulhisi3)
        .global __mulhisi3
        .func   __mulhisi3
__mulhisi3:
        mov_l   r18, r24
        mov_h   r19, r25
        clr     r24
        sbrc    r23, 7
        dec     r24
        mov     r25, r24
        clr     r20
        sbrc    r19, 7
        dec     r20
        mov     r21, r20
        rjmp    __mulsi3
        .endfunc
#endif /* defined (L_mulhisi3) */

#if defined (L_umulhisi3)
        .global __umulhisi3
        .func   __umulhisi3
__umulhisi3:
        mov_l   r18, r24
        mov_h   r19, r25
        clr     r24
        clr     r25
        clr     r20
        clr     r21
        rjmp    __mulsi3
        .endfunc
#endif /* defined (L_umulhisi3) */

#if defined (L_mulsi3)
/*******************************************************
               Multiplication  32 x 32
*******************************************************/
#define r_arg1L  r22            /* multiplier Low */
#define r_arg1H  r23
#define r_arg1HL r24
#define r_arg1HH r25            /* multiplier High */


#define r_arg2L  r18            /* multiplicand Low */
#define r_arg2H  r19    
#define r_arg2HL r20
#define r_arg2HH r21            /* multiplicand High */
        
#define r_resL   r26            /* result Low */
#define r_resH   r27
#define r_resHL  r30
#define r_resHH  r31            /* result High */

        
        .global __mulsi3
        .func   __mulsi3
__mulsi3:
#if defined (__AVR_ENHANCED__)
        mul     r_arg1L, r_arg2L
        movw    r_resL, r0
        mul     r_arg1H, r_arg2H
        movw    r_resHL, r0
        mul     r_arg1HL, r_arg2L
        add     r_resHL, r0
        adc     r_resHH, r1
        mul     r_arg1L, r_arg2HL
        add     r_resHL, r0
        adc     r_resHH, r1
        mul     r_arg1HH, r_arg2L
        add     r_resHH, r0
        mul     r_arg1HL, r_arg2H
        add     r_resHH, r0
        mul     r_arg1H, r_arg2HL
        add     r_resHH, r0
        mul     r_arg1L, r_arg2HH
        add     r_resHH, r0
        clr     r_arg1HH        ; use instead of __zero_reg__ to add carry
        mul     r_arg1H, r_arg2L
        add     r_resH, r0
        adc     r_resHL, r1
        adc     r_resHH, r_arg1HH ; add carry
        mul     r_arg1L, r_arg2H
        add     r_resH, r0
        adc     r_resHL, r1
        adc     r_resHH, r_arg1HH ; add carry
        movw    r_arg1L, r_resL
        movw    r_arg1HL, r_resHL
        clr     r1              ; __zero_reg__ clobbered by "mul"
        ret
#else
        clr     r_resHH         ; clear result
        clr     r_resHL         ; clear result
        clr     r_resH          ; clear result
        clr     r_resL          ; clear result
__mulsi3_loop:
        sbrs    r_arg1L,0
        rjmp    __mulsi3_skip1
        add     r_resL,r_arg2L          ; result + multiplicand
        adc     r_resH,r_arg2H
        adc     r_resHL,r_arg2HL
        adc     r_resHH,r_arg2HH
__mulsi3_skip1:
        add     r_arg2L,r_arg2L         ; shift multiplicand
        adc     r_arg2H,r_arg2H
        adc     r_arg2HL,r_arg2HL
        adc     r_arg2HH,r_arg2HH
        
        lsr     r_arg1HH        ; gets LSB of multiplier
        ror     r_arg1HL
        ror     r_arg1H
        ror     r_arg1L
        brne    __mulsi3_loop
        sbiw    r_arg1HL,0
        cpc     r_arg1H,r_arg1L
        brne    __mulsi3_loop           ; exit if multiplier = 0
__mulsi3_exit:
        mov_h   r_arg1HH,r_resHH        ; result to return register
        mov_l   r_arg1HL,r_resHL
        mov_h   r_arg1H,r_resH
        mov_l   r_arg1L,r_resL
        ret
#endif /* !defined (__AVR_ENHANCED__) */
#undef r_arg1L 
#undef r_arg1H 
#undef r_arg1HL
#undef r_arg1HH
             
             
#undef r_arg2L 
#undef r_arg2H 
#undef r_arg2HL
#undef r_arg2HH
             
#undef r_resL  
#undef r_resH  
#undef r_resHL 
#undef r_resHH 

.endfunc
#endif /* defined (L_mulsi3) */
        
/*******************************************************
       Division 8 / 8 => (result + remainder)
*******************************************************/
#define r_rem   r25     /* remainder */
#define r_arg1  r24     /* dividend, quotient */
#define r_arg2  r22     /* divisor */
#define r_cnt   r23     /* loop count */

#if defined (L_udivmodqi4)
        .global __udivmodqi4
        .func   __udivmodqi4
__udivmodqi4:
        sub     r_rem,r_rem     ; clear remainder and carry
        ldi     r_cnt,9         ; init loop counter
        rjmp    __udivmodqi4_ep ; jump to entry point
__udivmodqi4_loop:
        rol     r_rem           ; shift dividend into remainder
        cp      r_rem,r_arg2    ; compare remainder & divisor
        brcs    __udivmodqi4_ep ; remainder <= divisor
        sub     r_rem,r_arg2    ; restore remainder
__udivmodqi4_ep:
        rol     r_arg1          ; shift dividend (with CARRY)
        dec     r_cnt           ; decrement loop counter
        brne    __udivmodqi4_loop
        com     r_arg1          ; complement result 
                                ; because C flag was complemented in loop
        ret
        .endfunc
#endif /* defined (L_udivmodqi4) */

#if defined (L_divmodqi4)
        .global __divmodqi4
        .func   __divmodqi4
__divmodqi4:
        bst     r_arg1,7        ; store sign of dividend
        mov     __tmp_reg__,r_arg1
        eor     __tmp_reg__,r_arg2; r0.7 is sign of result
        sbrc    r_arg1,7
        neg     r_arg1          ; dividend negative : negate
        sbrc    r_arg2,7
        neg     r_arg2          ; divisor negative : negate
        rcall   __udivmodqi4    ; do the unsigned div/mod
        brtc    __divmodqi4_1
        neg     r_rem           ; correct remainder sign
__divmodqi4_1:
        sbrc    __tmp_reg__,7
        neg     r_arg1          ; correct result sign
__divmodqi4_exit:
        ret
        .endfunc
#endif /* defined (L_divmodqi4) */

#undef r_rem
#undef r_arg1
#undef r_arg2
#undef r_cnt
        
                
/*******************************************************
       Division 16 / 16 => (result + remainder)
*******************************************************/
#define r_remL  r26     /* remainder Low */
#define r_remH  r27     /* remainder High */

/* return: remainder */
#define r_arg1L r24     /* dividend Low */
#define r_arg1H r25     /* dividend High */

/* return: quotient */
#define r_arg2L r22     /* divisor Low */
#define r_arg2H r23     /* divisor High */
        
#define r_cnt   r21     /* loop count */

#if defined (L_udivmodhi4)
        .global __udivmodhi4
        .func   __udivmodhi4
__udivmodhi4:
        sub     r_remL,r_remL
        sub     r_remH,r_remH   ; clear remainder and carry
        ldi     r_cnt,17        ; init loop counter
        rjmp    __udivmodhi4_ep ; jump to entry point
__udivmodhi4_loop:
        rol     r_remL          ; shift dividend into remainder
        rol     r_remH
        cp      r_remL,r_arg2L  ; compare remainder & divisor
        cpc     r_remH,r_arg2H
        brcs    __udivmodhi4_ep ; remainder < divisor
        sub     r_remL,r_arg2L  ; restore remainder
        sbc     r_remH,r_arg2H
__udivmodhi4_ep:
        rol     r_arg1L         ; shift dividend (with CARRY)
        rol     r_arg1H
        dec     r_cnt           ; decrement loop counter
        brne    __udivmodhi4_loop
        com     r_arg1L
        com     r_arg1H
; div/mod results to return registers, as for the div() function
        mov_l   r_arg2L, r_arg1L        ; quotient
        mov_h   r_arg2H, r_arg1H
        mov_l   r_arg1L, r_remL         ; remainder
        mov_h   r_arg1H, r_remH
        ret
        .endfunc
#endif /* defined (L_udivmodhi4) */

#if defined (L_divmodhi4)
        .global __divmodhi4
        .func   __divmodhi4
__divmodhi4:
        .global _div
_div:
        bst     r_arg1H,7       ; store sign of dividend
        mov     __tmp_reg__,r_arg1H
        eor     __tmp_reg__,r_arg2H   ; r0.7 is sign of result
        rcall   __divmodhi4_neg1 ; dividend negative : negate
        sbrc    r_arg2H,7
        rcall   __divmodhi4_neg2 ; divisor negative : negate
        rcall   __udivmodhi4    ; do the unsigned div/mod
        rcall   __divmodhi4_neg1 ; correct remainder sign
        tst     __tmp_reg__
        brpl    __divmodhi4_exit
__divmodhi4_neg2:
        com     r_arg2H
        neg     r_arg2L         ; correct divisor/result sign
        sbci    r_arg2H,0xff
__divmodhi4_exit:
        ret
__divmodhi4_neg1:
        brtc    __divmodhi4_exit
        com     r_arg1H
        neg     r_arg1L         ; correct dividend/remainder sign
        sbci    r_arg1H,0xff
        ret
        .endfunc
#endif /* defined (L_divmodhi4) */

#undef r_remH  
#undef r_remL  
             
#undef r_arg1H 
#undef r_arg1L 
             
#undef r_arg2H 
#undef r_arg2L 
                
#undef r_cnt    
        
/*******************************************************
       Division 32 / 32 => (result + remainder)
*******************************************************/
#define r_remHH r31     /* remainder High */
#define r_remHL r30
#define r_remH  r27
#define r_remL  r26     /* remainder Low */

/* return: remainder */
#define r_arg1HH r25    /* dividend High */
#define r_arg1HL r24
#define r_arg1H  r23
#define r_arg1L  r22    /* dividend Low */

/* return: quotient */
#define r_arg2HH r21    /* divisor High */
#define r_arg2HL r20
#define r_arg2H  r19
#define r_arg2L  r18    /* divisor Low */
        
#define r_cnt __zero_reg__  /* loop count (0 after the loop!) */

#if defined (L_udivmodsi4)
        .global __udivmodsi4
        .func   __udivmodsi4
__udivmodsi4:
        ldi     r_remL, 33      ; init loop counter
        mov     r_cnt, r_remL
        sub     r_remL,r_remL
        sub     r_remH,r_remH   ; clear remainder and carry
        mov_l   r_remHL, r_remL
        mov_h   r_remHH, r_remH
        rjmp    __udivmodsi4_ep ; jump to entry point
__udivmodsi4_loop:
        rol     r_remL          ; shift dividend into remainder
        rol     r_remH
        rol     r_remHL
        rol     r_remHH
        cp      r_remL,r_arg2L  ; compare remainder & divisor
        cpc     r_remH,r_arg2H
        cpc     r_remHL,r_arg2HL
        cpc     r_remHH,r_arg2HH
        brcs    __udivmodsi4_ep ; remainder <= divisor
        sub     r_remL,r_arg2L  ; restore remainder
        sbc     r_remH,r_arg2H
        sbc     r_remHL,r_arg2HL
        sbc     r_remHH,r_arg2HH
__udivmodsi4_ep:
        rol     r_arg1L         ; shift dividend (with CARRY)
        rol     r_arg1H
        rol     r_arg1HL
        rol     r_arg1HH
        dec     r_cnt           ; decrement loop counter
        brne    __udivmodsi4_loop
                                ; __zero_reg__ now restored (r_cnt == 0)
        com     r_arg1L
        com     r_arg1H
        com     r_arg1HL
        com     r_arg1HH
; div/mod results to return registers, as for the ldiv() function
        mov_l   r_arg2L,  r_arg1L       ; quotient
        mov_h   r_arg2H,  r_arg1H
        mov_l   r_arg2HL, r_arg1HL
        mov_h   r_arg2HH, r_arg1HH
        mov_l   r_arg1L,  r_remL        ; remainder
        mov_h   r_arg1H,  r_remH
        mov_l   r_arg1HL, r_remHL
        mov_h   r_arg1HH, r_remHH
        ret
        .endfunc
#endif /* defined (L_udivmodsi4) */

#if defined (L_divmodsi4)
        .global __divmodsi4
        .func   __divmodsi4
__divmodsi4:
        bst     r_arg1HH,7      ; store sign of dividend
        mov     __tmp_reg__,r_arg1HH
        eor     __tmp_reg__,r_arg2HH   ; r0.7 is sign of result
        rcall   __divmodsi4_neg1 ; dividend negative : negate
        sbrc    r_arg2HH,7
        rcall   __divmodsi4_neg2 ; divisor negative : negate
        rcall   __udivmodsi4    ; do the unsigned div/mod
        rcall   __divmodsi4_neg1 ; correct remainder sign
        rol     __tmp_reg__
        brcc    __divmodsi4_exit
__divmodsi4_neg2:
        com     r_arg2HH
        com     r_arg2HL
        com     r_arg2H
        neg     r_arg2L         ; correct divisor/quotient sign
        sbci    r_arg2H,0xff
        sbci    r_arg2HL,0xff
        sbci    r_arg2HH,0xff
__divmodsi4_exit:
        ret
__divmodsi4_neg1:
        brtc    __divmodsi4_exit
        com     r_arg1HH
        com     r_arg1HL
        com     r_arg1H
        neg     r_arg1L         ; correct dividend/remainder sign
        sbci    r_arg1H, 0xff
        sbci    r_arg1HL,0xff
        sbci    r_arg1HH,0xff
        ret
        .endfunc
#endif /* defined (L_divmodsi4) */

/**********************************
 * This is a prologue subroutine
 **********************************/
#if defined (L_prologue)

        .global __prologue_saves__
        .func   __prologue_saves__
__prologue_saves__:
        push r2
        push r3
        push r4
        push r5
        push r6
        push r7
        push r8
        push r9
        push r10
        push r11
        push r12
        push r13
        push r14
        push r15
        push r16
        push r17
        push r28
        push r29
        in      r28,__SP_L__
        in      r29,__SP_H__
        sub     r28,r26
        sbc     r29,r27
        in      __tmp_reg__,__SREG__
        cli
        out     __SP_H__,r29
        out     __SREG__,__tmp_reg__
        out     __SP_L__,r28
        ijmp
.endfunc
#endif /* defined (L_prologue) */

/*
 * This is an epilogue subroutine
 */
#if defined (L_epilogue)

        .global __epilogue_restores__
        .func   __epilogue_restores__
__epilogue_restores__:
        ldd     r2,Y+18
        ldd     r3,Y+17
        ldd     r4,Y+16
        ldd     r5,Y+15
        ldd     r6,Y+14
        ldd     r7,Y+13
        ldd     r8,Y+12
        ldd     r9,Y+11
        ldd     r10,Y+10
        ldd     r11,Y+9
        ldd     r12,Y+8
        ldd     r13,Y+7
        ldd     r14,Y+6
        ldd     r15,Y+5
        ldd     r16,Y+4
        ldd     r17,Y+3
        ldd     r26,Y+2
        ldd     r27,Y+1
        add     r28,r30
        adc     r29,__zero_reg__
        in      __tmp_reg__,__SREG__
        cli
        out     __SP_H__,r29
        out     __SREG__,__tmp_reg__
        out     __SP_L__,r28
        mov_l   r28, r26
        mov_h   r29, r27
        ret
.endfunc
#endif /* defined (L_epilogue) */

#ifdef L_exit
        .section .fini9,"ax",@progbits
        .global _exit
        .func   _exit
_exit:
        .weak   exit
exit:

        /* Code from .fini8 ... .fini1 sections inserted by ld script.  */

        .section .fini0,"ax",@progbits
__stop_program:
        rjmp    __stop_program
        .endfunc
#endif /* defined (L_exit) */

#ifdef L_cleanup
        .weak   _cleanup
        .func   _cleanup
_cleanup:
        ret
.endfunc
#endif /* defined (L_cleanup) */

#ifdef L_tablejump
        .global __tablejump2__
        .func   __tablejump2__
__tablejump2__:
        lsl     r30
        rol     r31
        .global __tablejump__
__tablejump__:
#if defined (__AVR_ENHANCED__)
        lpm     __tmp_reg__, Z+
        lpm     r31, Z
        mov     r30, __tmp_reg__
        ijmp
#else
        lpm
        adiw    r30, 1
        push    r0
        lpm
        push    r0
        ret
#endif
        .endfunc
#endif /* defined (L_tablejump) */

/* __do_copy_data is only necessary if there is anything in .data section.
   Does not use RAMPZ - crt*.o provides a replacement for >64K devices.  */

#ifdef L_copy_data
        .section .init4,"ax",@progbits
        .global __do_copy_data
__do_copy_data:
        ldi     r17, hi8(__data_end)
        ldi     r26, lo8(__data_start)
        ldi     r27, hi8(__data_start)
        ldi     r30, lo8(__data_load_start)
        ldi     r31, hi8(__data_load_start)
        rjmp    .do_copy_data_start
.do_copy_data_loop:
#if defined (__AVR_HAVE_LPMX__)
        lpm     r0, Z+
#else
        lpm
        adiw    r30, 1
#endif
        st      X+, r0
.do_copy_data_start:
        cpi     r26, lo8(__data_end)
        cpc     r27, r17
        brne    .do_copy_data_loop
#endif /* L_copy_data */

/* __do_clear_bss is only necessary if there is anything in .bss section.  */

#ifdef L_clear_bss
        .section .init4,"ax",@progbits
        .global __do_clear_bss
__do_clear_bss:
        ldi     r17, hi8(__bss_end)
        ldi     r26, lo8(__bss_start)
        ldi     r27, hi8(__bss_start)
        rjmp    .do_clear_bss_start
.do_clear_bss_loop:
        st      X+, __zero_reg__
.do_clear_bss_start:
        cpi     r26, lo8(__bss_end)
        cpc     r27, r17
        brne    .do_clear_bss_loop
#endif /* L_clear_bss */

/* __do_global_ctors and __do_global_dtors are only necessary
   if there are any constructors/destructors.  */

#if defined (__AVR_MEGA__)
#define XCALL call
#else
#define XCALL rcall
#endif

#ifdef L_ctors
        .section .init6,"ax",@progbits
        .global __do_global_ctors
__do_global_ctors:
        ldi     r17, hi8(__ctors_start)
        ldi     r28, lo8(__ctors_end)
        ldi     r29, hi8(__ctors_end)
        rjmp    .do_global_ctors_start
.do_global_ctors_loop:
        sbiw    r28, 2
        mov_h   r31, r29
        mov_l   r30, r28
        XCALL   __tablejump__
.do_global_ctors_start:
        cpi     r28, lo8(__ctors_start)
        cpc     r29, r17
        brne    .do_global_ctors_loop
#endif /* L_ctors */

#ifdef L_dtors
        .section .fini6,"ax",@progbits
        .global __do_global_dtors
__do_global_dtors:
        ldi     r17, hi8(__dtors_end)
        ldi     r28, lo8(__dtors_start)
        ldi     r29, hi8(__dtors_start)
        rjmp    .do_global_dtors_start
.do_global_dtors_loop:
        mov_h   r31, r29
        mov_l   r30, r28
        XCALL   __tablejump__
        adiw    r28, 2
.do_global_dtors_start:
        cpi     r28, lo8(__dtors_end)
        cpc     r29, r17
        brne    .do_global_dtors_loop
#endif /* L_dtors */