;
; Copyright (C) 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
; Contributed by Red Hat, Inc and Ubicom, Inc.
;
; This file is part of GCC.
;
; GCC 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 with other programs, and to distribute
; those programs 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 another program.)
;
; GCC 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 GCC; see the file COPYING.  If not, write to
; the Free Software Foundation, 59 Temple Place - Suite 330,
; Boston, MA 02111-1307, USA.  */

/*******************************************************
	load byte from arbitrary memory
	address passed in first bank register, result in W

*******************************************************/
	.macro	movb	to, from
	mov	w, \from
	mov	\to, w
	.endm


#if defined (L_indcall)
/* __indcall - given register containing an address, call the function
 *	at that address.
 */

	.sect	.pram.libgcc,"ax"
	.global	__indcall
	.func	_indcall,__indcall

__indcall:
	page	1f
	call	1f
1:	pop	callh			; Get the call target
	pop	calll
	ret				; Transfer to new function

	.endfunc
#endif


#if defined (L_mulhi3)
	.sect	.pram.libgcc,"ax"
	.global	__mulhi3
	.func	_mulhi3, __mulhi3

__mulhi3:
	mov	w, 2(SP)		; First upper half partial product
	mulu	w, 3(SP)
	mov	3(SP), w
	mov	w, 1(SP)		; Second upper half partial product
	mulu	w, 4(SP)
	add	3(SP), w
	mov	w, 2(SP)		; Lower half partial product
	mulu	w, 4(SP)
	mov	4(SP), w
	mov	w, MULH
	add	3(SP), w

	mov	w, #2			; Adjust the stack leaving the result to
	add	spl, w			; be popped off later.
	ret

	.endfunc

#endif /* defined (L_mulhi3) */

#if defined (L_mulsi3)
/*******************************************************
               Multiplication  32 x 32
*******************************************************/
	
	.sect	.text.libgcc,"ax"
	.global	__mulsi3
	.func	_mulsi3, __mulsi3

__mulsi3:
	clr	$80			; Assume zero result
	clr	$81
	clr	$82
	clr	$83

2:	mov	w, 1(sp)
	or	w, 2(sp)
	or	w, 3(sp)
	or	w, 4(sp)
	snz				; Any more significant bits to multiply?
	page	3f
	jmp	3f

	sb	4(sp), 0		; Check LSB of multiplier
	page	1f			; zero => scale multiplicand & multiplier
	jmp	1f

	mov	w, 8(sp)		; Accumulate product
	add	$83, w
	mov	w, 7(sp)
	addc	$82, w
	mov	w, 6(sp)
	addc	$81, w
	mov	w, 5(sp)
	addc	$80, w
1:	clrb	status, 0		; scale multiplier down
	rr	1(sp)	
	rr	2(sp)
	rr	3(sp)
	rr	4(sp)
	clrb	status, 0
	rl	8(sp)
	rl	7(sp)
	rl	6(sp)
	rl	5(sp)
	page	2b
	jmp	2b

3:	mov	w, #8
	add	spl ,w
	ret

	.endfunc

#endif /* defined (L_mulsi3) */
	
#if defined (L_muldi3)
/*******************************************************
               Multiplication  64 x 64
*******************************************************/
	
	.sect	.text.libgcc,"ax"
	.global	__muldi3
	.func	_muldi3, __muldi3

__muldi3:
	clr	$80			; Assume zero result
	clr	$81
	clr	$82
	clr	$83
	clr	$84
	clr	$85
	clr	$86
	clr	$87

2:	mov	w, 1(sp)
	or	w, 2(sp)
	or	w, 3(sp)
	or	w, 4(sp)
	or	w, 5(sp)
	or	w, 6(sp)
	or	w, 7(sp)
	or	w, 8(sp)
	snz				; Any more significant bits to multiply?
	page	3f
	jmp	3f

	sb	8(sp), 0		; Check LSB of multiplier
	page	1f			; zero => scale multiplicand & multiplier
	jmp	1f

	mov	w, 16(sp)		; Accumulate product
	add	$87, w
	mov	w, 15(sp)
	addc	$86, w
	mov	w, 14(sp)
	addc	$85, w
	mov	w, 13(sp)
	addc	$84, w
	mov	w, 12(sp)
	addc	$83, w
	mov	w, 11(sp)
	addc	$82, w
	mov	w, 10(sp)
	addc	$81, w
	mov	w, 9(sp)
	addc	$80, w

1:	clrb	status, 0		; scale multiplier down
	rr	1(sp)	
	rr	2(sp)
	rr	3(sp)
	rr	4(sp)
	rr	5(sp)
	rr	6(sp)
	rr	7(sp)
	rr	8(sp)
	clrb	status, 0
	rl	16(sp)
	rl	15(sp)
	rl	14(sp)
	rl	13(sp)
	rl	12(sp)
	rl	11(sp)
	rl	10(sp)
	rl	9(sp)
	page	2b
	jmp	2b

3:	mov	w, #16
	add	spl, w
	ret

	.endfunc

#endif /* defined (L_muldi3) */

#if defined (L_divmodhi4)
#define	arg1h 1(SP)
#define arg1l 2(SP)
#define arg2h 3(SP)
#define arg2l 4(SP)
#define resl $81
#define resh $80
#define reml $83
#define remh $82
#define tmp_var	$84
#define cnt $85
#define arg1_sign $86
#define res_sign $87

	.sect	.text.libgcc,"ax"
	.global	__divmodhi4
	.func	_divmodhi4, __divmodhi4

__divmodhi4:
	mov	w,arg2h
	mov	res_sign,w
	mov	w,arg1h
	mov	arg1_sign,w
	xor	res_sign,w

	sb	arg1h,7
	page	1f
	jmp	1f

	not	arg1h
	not	arg1l
	incsnz	arg1l
	inc	arg1h

1:	sb	arg2h, 7
	page	1f
	jmp	1f

	not	arg2h
	not	arg2l
	incsnz	arg2l
	inc	arg2h

1:	page	__udivmodhi4		; Do the unsigned div/mod
	call	__udivmodhi4

	sb	arg1_sign, 7
	page	1f
	jmp	1f

	not	reml
	not	remh
	incsnz	reml
	inc	remh

1:	sb	res_sign, 7
	ret

	not	resl
	not	resh
	incsnz	resl
	inc	resh
	ret

	.endfunc

#undef arg1h
#undef arg1l
#undef arg2h
#undef arg2l
#undef resl
#undef resh
#undef reml
#undef remh
#undef tmp_var
#undef cnt
#undef arg1_sign
#undef res_sign

#endif /* defined (L_divmodhi4) */
	
#if defined (L_udivmodhi4)

#define	arg1h 1(SP)
#define arg1l 2(SP)
#define arg2h 3(SP)
#define arg2l 4(SP)
#define resl $81
#define resh $80
#define reml $83
#define remh $82
#define tmp_var	$84
#define cnt $85

	.sect	.text.libgcc,"ax"
	.global	__udivmodhi4
	.func	_udivmodhi4, __udivmodhi4

__udivmodhi4:
	clr	reml
	clr	remh
	mov	w, #17
	mov	cnt,w
	clrb	status, 0
	page	1f
	jmp	1f

2:	rl	reml
	rl	remh
	mov	w, arg2l
	sub	w, reml
	mov	tmp_var, w
	mov	w, arg2h
	subc	w, remh
	sc
	page	1f
	jmp	1f
	mov	remh, w
	mov	w, tmp_var
	mov	reml, w

1:	rl	arg1l
	rl	arg1h
	decsz	cnt
	page	2b
	jmp	2b
	
	pop	resh
	pop	resl	
	mov	w, #2
	add	spl, w
	ret

	.endfunc

#undef arg1h
#undef arg1l
#undef arg2h
#undef arg2l
#undef resl
#undef resh
#undef reml
#undef remh
#undef tmp_var
#undef cnt

#endif	/* defined (L_udivmodhi4) */

#if defined (L_divmodsi4)

#define	arg1a 1(SP)
#define arg1b 2(SP)
#define arg1c 3(SP)
#define arg1d 4(SP)

#define arg2a 5(SP)
#define arg2b 6(SP)
#define arg2c 7(SP)
#define arg2d 8(SP)
	
#define resa $80
#define resb $81
#define resc $82
#define resd $83

#define rema $84
#define remb $85
#define remc $86
#define remd $87

#define tmp_var	$88
#define tmp_var1 $89
#define tmp_var2 $8a
#define cnt $8b
#define arg1_sign $8c
#define res_sign $8d

	.sect	.text.libgcc,"ax"
	.global	__divmodsi4
	.func	_divmodsi4, __divmodsi4

__divmodsi4:
	mov	w, arg2a
	mov	res_sign, w
	mov	w, arg1a
	mov	arg1_sign, w
	xor	res_sign, w

	sb	arg1a, 7
	page	1f
	jmp	1f

	not	arg1d
	not	arg1c
	not	arg1b
	not	arg1a
	incsnz	arg1d
	incsz	arg1c
	page	1f
	jmp	1f
	incsnz	arg1b
	inc	arg1a

1:	sb	arg2a, 7
	page	1f
	jmp	1f

	not	arg2d
	not	arg2c
	not	arg2b
	not	arg2a
	incsnz	arg2d
	incsz	arg2c
	page	1f
	jmp	1f
	incsnz	arg2b
	inc	arg2a

1:	page	__udivmodsi4		; Do the unsigned div/mod.
	call	__udivmodsi4

	sb	arg1_sign, 7
	page	1f
	jmp	1f

	not	remd
	not	remc
	not	remb
	not	rema
	incsnz	remd
	incsz	remc
	page	1f
	jmp	1f
	incsnz	remb
	inc	rema

1:	sb	res_sign, 7
	ret

	not	resd
	not	resc
	not	resb
	not	resa
	incsnz	resd
	incsz	resc
	ret
	incsnz	resb
	inc	resa
	ret

	.endfunc

#undef arg1a
#undef arg1b
#undef arg1c
#undef arg1d

#undef arg2a
#undef arg2b
#undef arg2c
#undef arg2d
	
#undef resa
#undef resb
#undef resc
#undef resd

#undef rema
#undef remb
#undef remc
#undef remd

#undef tmp_var
#undef tmp_var1
#undef tmp_var2
#undef cnt
#undef arg1_sign
#undef res_sign

#endif /* defined (L_divmodsi4) */

#if defined (L_udivmodsi4)		
#define	arg1a 1(SP)
#define arg1b 2(SP)
#define arg1c 3(SP)
#define arg1d 4(SP)

#define arg2a 5(SP)
#define arg2b 6(SP)
#define arg2c 7(SP)
#define arg2d 8(SP)
	
#define resa $80
#define resb $81
#define resc $82
#define resd $83

#define rema $84
#define remb $85
#define remc $86
#define remd $87

#define tmp_var	$88
#define tmp_var1 $89
#define tmp_var2 $8a
#define cnt $8b

	.sect	.text.libgcc,"ax"
	.global	__udivmodsi4
	.func	_udivmodsi4, __udivmodsi4

__udivmodsi4:
	clr	remd
	clr	remc
	clr	remb
	clr	rema
	mov	w, #33
	mov	cnt, w
	clrb	status, 0
	page	1f
	jmp	1f

2:	rl	remd
	rl	remc
	rl	remb
	rl	rema
	mov	w, arg2d
	sub	w, remd
	mov	tmp_var, w
	mov	w, arg2c
	subc	w, remc
	mov	tmp_var1, w
	mov	w, arg2b
	subc	w, remb
	mov	tmp_var2, w
	mov	w, arg2a
	subc	w, rema
	sc
	page	1f
	jmp	1f

	mov	rema, w
	mov	w, tmp_var2
	mov	remb, w
	mov	w, tmp_var1
	mov	remc, w
	mov	w, tmp_var
	mov	remd, w

1:	rl	arg1d
	rl	arg1c
	rl	arg1b
	rl	arg1a
	decsz	cnt
	page	2b
	jmp	2b

	pop	resa
	pop	resb
	pop	resc
	pop	resd
	mov	w, #4
	add	spl, w
	ret

	.endfunc

#undef arg1a
#undef arg1b
#undef arg1c
#undef arg1d

#undef arg2a
#undef arg2b
#undef arg2c
#undef arg2d
	
#undef resa
#undef resb
#undef resc
#undef resd

#undef rema
#undef remb
#undef remc
#undef remd

#undef tmp_var
#undef tmp_var1
#undef tmp_var2
#undef cnt

#endif /* defined (L_udivmodsi4) */

#if defined (L_divmoddi4)

#define	arg1s 1(SP)
#define arg1t 2(SP)
#define arg1u 3(SP)
#define arg1v 4(SP)
#define arg1w 5(SP)
#define arg1x 6(SP)
#define arg1y 7(SP)
#define arg1z 8(SP)

#define arg2s 9(SP)
#define arg2t 10(SP)
#define arg2u 11(SP)
#define arg2v 12(SP)
#define arg2w 13(SP)
#define arg2x 14(SP)
#define arg2y 15(SP)
#define arg2z 16(SP)
	
#define ress $80
#define rest $81
#define resu $82
#define resv $83
#define resw $84
#define resx $85
#define resy $86
#define resz $87

#define rems $88
#define remt $89
#define remu $8a
#define remv $8b
#define remw $8c
#define remx $8d
#define remy $8e
#define remz $8f

#define tmp_var	$90
#define tmp_var1 $91
#define tmp_var2 $92
#define tmp_var3 $93
#define tmp_var4 $94
#define tmp_var5 $95
#define tmp_var6 $96
#define cnt $97

	.sect	.text.libgcc,"ax"
	.global	__divmoddi4
	.func	_divmoddi4, __divmoddi4

__divmoddi4:
	rl	w, arg2s		; Use MULH to track sign bits.
	rl	MULH
	rl	w, arg1s
	rl	WREG
	xor	MULH, w
	rl	w, arg1s
	rl	MULH

	sb	arg1s, 7
	page	1f
	jmp	1f

	not	arg1s
	not	arg1t
	not	arg1u
	not	arg1v
	not	arg1w
	not	arg1x
	not	arg1y
	not	arg1z
	incsnz	arg1z
	incsz	arg1y
	page	1f
	jmp	1f
	incsnz	arg1x
	incsz	arg1w
	page	1f
	jmp	1f
	incsnz	arg1v
	incsz	arg1u
	page	1f
	jmp	1f
	incsnz	arg1t
	inc	arg1s

1:	sb	arg2s, 7
	page	1f
	jmp	1f

	not	arg2s
	not	arg2t
	not	arg2u
	not	arg2v
	not	arg2w
	not	arg2x
	not	arg2y
	not	arg2z
	incsnz	arg2z
	incsz	arg2y
	page	1f
	jmp	1f
	incsnz	arg2x
	incsz	arg2w
	page	1f
	jmp	1f
	incsnz	arg2v
	incsz	arg2u
	page	1f
	jmp	1f
	incsnz	arg2t
	inc	arg2s

1:	page	__udivmoddi4		; Do the unsigned div/mod.
	call	__udivmoddi4

	sb	MULH, 0			; Look at the save sign bit for arg 1.
	page	1f
	jmp	1f

	not	rems
	not	remt
	not	remu
	not	remv
	not	remw
	not	remx
	not	remy
	not	remz
	incsnz	remz
	incsz	remy
	page	1f
	jmp	1f
	incsnz	remx
	incsz	remw
	page	1f
	jmp	1f
	incsnz	remv
	incsz	remu
	page	1f
	jmp	1f
	incsnz	remt
	inc	rems

1:	sb	MULH, 1
	ret

	not	ress
	not	rest
	not	resu
	not	resv
	not	resw
	not	resx
	not	resy
	not	resz
	incsnz	resz
	incsz	resy
	ret
	incsnz	resx
	incsz	resw
	ret
	incsnz	resv
	incsz	resu
	ret
	incsnz	rest
	inc	ress
	ret

	.endfunc

#undef arg1s
#undef arg1t
#undef arg1u
#undef arg1v
#undef arg1w
#undef arg1x
#undef arg1y
#undef arg1z

#undef arg2s
#undef arg2t
#undef arg2u
#undef arg2v
#undef arg2w
#undef arg2x
#undef arg2y
#undef arg2z
	
#undef ress
#undef rest
#undef resu
#undef resv
#undef resw
#undef resx
#undef resy
#undef resz

#undef rems
#undef remt
#undef remu
#undef remv
#undef remw
#undef remx
#undef remy
#undef remz

#undef tmp_var
#undef tmp_var1
#undef tmp_var2
#undef tmp_var3
#undef tmp_var4
#undef tmp_var5
#undef tmp_var6
#undef cnt

#endif /* defined (L_divmoddi4) */

#if defined (L_udivmoddi4)		
#define	arg1s 1(SP)
#define arg1t 2(SP)
#define arg1u 3(SP)
#define arg1v 4(SP)
#define arg1w 5(SP)
#define arg1x 6(SP)
#define arg1y 7(SP)
#define arg1z 8(SP)

#define arg2s 9(SP)
#define arg2t 10(SP)
#define arg2u 11(SP)
#define arg2v 12(SP)
#define arg2w 13(SP)
#define arg2x 14(SP)
#define arg2y 15(SP)
#define arg2z 16(SP)
	
#define ress $80
#define rest $81
#define resu $82
#define resv $83
#define resw $84
#define resx $85
#define resy $86
#define resz $87

#define rems $88
#define remt $89
#define remu $8a
#define remv $8b
#define remw $8c
#define remx $8d
#define remy $8e
#define remz $8f

#define tmp_var	$90
#define tmp_var1 $91
#define tmp_var2 $92
#define tmp_var3 $93
#define tmp_var4 $94
#define tmp_var5 $95
#define tmp_var6 $96
#define cnt $97

	.sect	.text.libgcc,"ax"
	.global	__udivmoddi4
	.func	_udivmoddi4, __udivmoddi4

__udivmoddi4:
	clr	rems
	clr	remt
	clr	remu
	clr	remv
	clr	remw
	clr	remx
	clr	remy
	clr	remz
	mov	w, #65
	mov	cnt, w
	clrb	status, 0
	page	1f
	jmp	1f

2:	rl	remz
	rl	remy
	rl	remx
	rl	remw
	rl	remv
	rl	remu
	rl	remt
	rl	rems
	mov	w, arg2z
	sub	w, remz
	mov	tmp_var, w
	mov	w, arg2y
	subc	w, remy
	mov	tmp_var1, w
	mov	w, arg2x
	subc	w, remx
	mov	tmp_var2, w
	mov	w, arg2w
	subc	w, remw
	mov	tmp_var3, w
	mov	w, arg2v
	subc	w, remv
	mov	tmp_var4, w
	mov	w, arg2u
	subc	w, remu
	mov	tmp_var5, w
	mov	w, arg2t
	subc	w, remt
	mov	tmp_var6, w
	mov	w, arg2s
	subc	w, rems
	sc
	page	1f
	jmp	1f

	mov	rems, w
	mov	w, tmp_var6
	mov	remt, w
	mov	w, tmp_var5
	mov	remu, w
	mov	w, tmp_var4
	mov	remv, w
	mov	w, tmp_var3
	mov	remw, w
	mov	w, tmp_var2
	mov	remx, w
	mov	w, tmp_var1
	mov	remy, w
	mov	w, tmp_var
	mov	remz, w

1:	rl	arg1z
	rl	arg1y
	rl	arg1x
	rl	arg1w
	rl	arg1v
	rl	arg1u
	rl	arg1t
	rl	arg1s
	decsz	cnt
	page	2b
	jmp	2b

	pop	ress
	pop	rest
	pop	resu
	pop	resv
	pop	resw
	pop	resx
	pop	resy
	pop	resz
	mov	w, #8
	add	spl, w
	ret

	.endfunc

#undef arg1s
#undef arg1t
#undef arg1u
#undef arg1v
#undef arg1w
#undef arg1x
#undef arg1y
#undef arg1z

#undef arg2s
#undef arg2t
#undef arg2u
#undef arg2v
#undef arg2w
#undef arg2x
#undef arg2y
#undef arg2z
	
#undef ress
#undef rest
#undef resu
#undef resv
#undef resw
#undef resx
#undef resy
#undef resz

#undef rems
#undef remt
#undef remu
#undef remv
#undef remw
#undef remx
#undef remy
#undef remz

#undef tmp_var
#undef tmp_var1
#undef tmp_var2
#undef tmp_var3
#undef tmp_var4
#undef tmp_var5
#undef tmp_var6
#undef cnt

#endif /* defined (L_udivmoddi4) */

#define LT	#0
#define EQ	#1
#define GT	#2

#if defined(L_cmphi2)
#define arg1l 2(sp)
#define arg1h 1(sp)
#define arg2l 4(sp)
#define arg2h 3(sp)

	.sect	.text.libgcc,"ax"
	.global	__cmphi2
	.global	__cmp_ret
	.global	__cmpqi_ret
	.func	_cmphi2, __cmphi2

__cmphi2:
	mov	w,arg1l	
	sub	w,arg2l
	snz
	page	2f
	jmp	2f
	mov	w,arg1h
1:
	subc	w,arg2h
	clr	arg2l
	rl	arg2l
	snb	arg1h,7
	setb	arg2l,2
	snb	arg2h,7
	setb	arg2l,1
	mov	w,#3

__cmp_ret:
	add	spl,w			;  sign1
	pop	wreg			;   sign2

__cmpqi_ret:
	add	pcl,w			;    carry of arg1 - arg2
	retw	GT			; [000] arg1 > arg2
	retw	LT			; [001] arg1 < arg2
	retw	GT			; [010] arg1 > arg2
	retw	GT			; [011] arg1 > arg2
	retw	LT			; [100] arg1 < arg2
	retw	LT			; [101] arg1 < arg2
	retw	GT			; [110] arg1 > arg2
	retw	LT			; [111] arg1 < arg2
2:
	mov	w,arg1h
	cse	w,arg2h
	page	1b
	jmp	1b
	mov	w,#4
	add	spl,w
	retw	EQ

	.endfunc
#undef arg1l
#undef arg1h
#undef arg2l
#undef arg2h
#endif  /* L_cmphi2 */

#if defined(L_cmpqi2)
#define arg1 1(sp)
#define arg2 2(sp)

	.sect	.text.libgcc,"ax"
	.global	__cmpqi2
	.func	_cmpqi2, __cmpqi2

__cmpqi2:
	mov	w, arg1
	sub	w, arg2
	snz
	page	2f
	jmp	2f

	clr	wreg
	rl	wreg
	snb	arg1, 7
	setb	wreg, 2
	snb	arg2, 7
	setb	wreg, 1
	inc	spl
	inc	spl
	page	__cmpqi_ret
	jmp	__cmpqi_ret

2:	mov	w, #2
	add	spl, w
	retw	EQ

	.endfunc
#undef arg1l
#undef arg2l
#endif  /* L_cmpqi2 */

#if defined(L_cmpsi2)
#define arg1d 4(sp)
#define arg1c 3(sp)
#define arg1b 2(sp)
#define arg1a 1(sp)
#define arg2d 8(sp)
#define arg2c 7(sp)
#define arg2b 6(sp)
#define arg2a 5(sp)
	
	.sect	.text.libgcc,"ax"
	.global	__cmpsi2
	.func	_cmpsi2, __cmpsi2

__cmpsi2:
	mov	w, arg1d
	sub	w, arg2d
	snz
	page	2f
	jmp	2f

1:	mov	w, arg1c
	subc	w, arg2c
	mov	w, arg1b
	subc	w, arg2b
	mov	w, arg1a
	subc	w, arg2a

	clr	arg2d
	rl	arg2d
	snb	arg1a, 7
	setb	arg2d, 2
	snb	arg2a, 7
	setb	arg2d, 1
	mov	w, #7
	page	__cmp_ret
	jmp	__cmp_ret

2:	mov	w, arg1c
	cse	w, arg2c
	page	1b
	jmp	1b

	mov	w, arg1b
	cse	w, arg2b
	page	1b
	jmp	1b

	mov	w, arg1a
	cse	w, arg2a
	page	1b
	jmp	1b

	mov	w, #8
	add	spl, w
	retw	EQ

	.endfunc

#undef arg1d
#undef arg1c
#undef arg1b
#undef arg1a
#undef arg2d
#undef arg2c
#undef arg2b
#undef arg2a
#endif  /* L_cmpsi2 */

#if defined(L_cmpdi2)
#define arg1z 8(sp)
#define arg1y 7(sp)
#define arg1x 6(sp)
#define arg1w 5(sp)
#define arg1v 4(sp)
#define arg1u 3(sp)
#define arg1t 2(sp)
#define arg1s 1(sp)

#define arg2z 16(sp)
#define arg2y 15(sp)
#define arg2x 14(sp)
#define arg2w 13(sp)
#define arg2v 12(sp)
#define arg2u 11(sp)
#define arg2t 10(sp)
#define arg2s 9(sp)
	
	.sect	.text.libgcc,"ax"
	.global	__cmpdi2
	.func	_cmpdi2, __cmpdi2

__cmpdi2:
	mov	w, arg1z
	sub	w, arg2z
	snz
	page	2f
	jmp	2f

1:	mov	w, arg1y
	subc	w, arg2y
	mov	w, arg1x
	subc	w, arg2x
	mov	w, arg1w
	subc	w, arg2w
	mov	w, arg1v
	subc	w, arg2v
	mov	w, arg1u
	subc	w, arg2u
	mov	w, arg1t
	subc	w, arg2t
	mov	w, arg1s
	subc	w, arg2s
	clr	arg2z
	rl	arg2z
	snb	arg1s, 7
	setb	arg2z, 2
	snb	arg2s, 7
	setb	arg2z, 1
	mov	w, #15
	page	__cmp_ret
	jmp	__cmp_ret

2:	mov	w, arg1y
	cse	w, arg2y
	page	1b
	jmp	1b

	mov	w, arg1x
	cse	w, arg2x
	page	1b
	jmp	1b

	mov	w, arg1w
	cse	w, arg2w
	page	1b
	jmp	1b

	mov	w, arg1v
	cse	w, arg2v
	page	1b
	jmp	1b

	mov	w, arg1u
	cse	w, arg2u
	page	1b
	jmp	1b

	mov	w, arg1t
	cse	w, arg2t
	page	1b
	jmp	1b

	mov	w, arg1s
	cse	w, arg2s
	page	1b
	jmp	1b

	mov	w, #16
	add	spl, w
	retw	EQ

	.endfunc
	
#undef arg1z
#undef arg1y
#undef arg1x
#undef arg1w
#undef arg1v
#undef arg1u
#undef arg1t
#undef arg1s
#undef arg2z
#undef arg2y
#undef arg2x
#undef arg2w
#undef arg2v
#undef arg2u
#undef arg2t
#undef arg2s

#endif  /* L_cmpdi2 */
	
#if defined(L_cmpdi2_dp)
	.sect	.text.libgcc,"ax"
	.global	__cmpdi2_dp
	.func	_cmpdi2_dp, __cmpdi2_dp

__cmpdi2_dp:
	push	7(dp)
	push	6(dp)
	push	5(dp)
	push	4(dp)
	push	3(dp)
	push	2(dp)
	push	1(dp)
	push	(dp)
	page	__cmpdi2
	jmp	__cmpdi2

	.endfunc
#endif  /* L_cmpdi2_dp */

#if defined(L_fp_pop_args_ret)
	.sect	.pram.libgcc,"ax"
	.global	__fp_pop_args_ret
	.global	__pop_args_ret
	.global	__pop2_args_ret
	.func	__fp_pop2_args_ret, __fp_pop2_args_ret

__fp_pop2_args_ret:
	mov	w, #2
__fp_pop_args_ret:
	pop	0xfd
	pop	0xfe
__pop_args_ret:
	pop	callh
	pop	calll
	add	spl, w
	ret

	.endfunc
#endif /* L_fp_pop_args_ret */

#if defined(L__pop2_args_ret)
	.sect	.pram.libgcc,"ax"
	.global	__pop2_args_ret
	.func	__pop2_args_ret, __pop2_args_ret

__pop2_args_ret:
	mov	w, #2
	pop	callh
	pop	calll
	add	spl, w
	ret

	.endfunc
#endif /* L__pop2_args_ret */

#if defined(L_leaf_fp_pop_args_ret)
	.sect	.pram.libgcc,"ax"
	.global	__leaf_fp_pop_args_ret, __leaf_fp_pop2_args_ret
	.func	__leaf_fp2_pop_args_ret, __leaf_fp_pop2_args_ret

__leaf_fp_pop2_args_ret:
	mov	w, #2
__leaf_fp_pop_args_ret:
	pop	0xfd
	pop	0xfe
	add	spl, w
	ret

	.endfunc
#endif /* L_leaf_fp_pop_args_ret */

#if defined(L_movmemhi_countqi)
	.sect	.pram.libgcc,"ax"
	.global	__movmemhi_countqi
	.func	_movmemhi_countqi, __movmemhi_countqi

__movmemhi_countqi:
	push	dph			; Save our pointer regs
	push	dpl
	push	iph
	push	ipl

	mov	w, 5(SP)		; Get our dest pointer
	mov	dph, w
	mov	w, 6(SP)
	mov	dpl, w
	mov	w, 7(SP)		; And our source pointer
	mov	iph, w
	mov	w, 8(SP)
	mov	ipl, w

1:	push	(IP)			; *dest++ = *src++
	pop	0(DP)
	inc	ipl
	inc	dpl
	decsz	9(SP)			; Loop until completed
	page	1b
	jmp	1b

	pop	ipl			; Restore our pointer regs
	pop	iph
	pop	dpl
	pop	dph

	mov	w, #5			; Tidy up our stack args
	add	spl, w
	ret

	.endfunc
#endif

#if defined(L_movmemhi_counthi)
	.sect	.text.libgcc,"ax"
	.global	__movmemhi_counthi
	.func	_movmemhi_counthi, __movmemhi_counthi

__movmemhi_counthi:
	push	dph			; Save our pointer regs
	push	dpl
	push	iph
	push	ipl

	mov	w, 5(SP)		; Get our dest pointer
	mov	dph, w
	mov	w, 6(SP)
	mov	dpl, w
	mov	w, 7(SP)		; And our source pointer
	mov	iph, w
	mov	w, 8(SP)
	mov	ipl, w

	test	10(SP)			; If we have a nonzero LSB then adjust the
	sz				; MSB of the loop count to allow us to use
	inc	9(SP)			; skip tricks!

1:	push	(IP)			; *dest++ = *src++
	pop	0(DP)
	inc	ipl
	inc	dpl
	decsnz	10(SP)			; Loop until completed - note the skip trick
	decsz	9(SP)			; on the MSB!
	page	1b
	jmp	1b

	pop	ipl			; Restore our pointer regs
	pop	iph
	pop	dpl
	pop	dph

	mov	w, #6			; Tidy up our stacked args.
	add	spl, w
	ret

	.endfunc
#endif

#if defined(L_exit)
	.sect	.text.libgcc,"ax"
	.global	__exit
	.global	_exit
	.func	_exit, __exit
	.weak	__exit
	.weak	_exit

_exit:		
__exit:
	pop	$88
	pop	wreg
	or	w, $88
	push    wreg
	push	#0
	push	#1
	system				; Exit wreg
	page	__exit			; Never return
	jmp	__exit

	.endfunc
#endif

#if defined(Labort)
	.sect	.text.libgcc,"ax"
	.global	_abort
	.func	abort, _abort

_abort:
	push	#1
	push	#0
	push	#1
	system				; Exit 1
	ret

	.endfunc
#endif

#if defined(Lwrite)
	/* Dummy entry point to suppress problems with glue code.  */
	.sect	.text.libgcc,"ax"
	.global	_write
	.func	write, _write
;;
;; write (fil,buf,len) - say that write succeeds....
;; 
_write:
	movb	$80, 5(SP)
	movb	$81, 6(SP)		; Return length written
	mov	w, #6
	add	spl, w
	ret
	
	.endfunc
#endif