 
























 







! INPUT PARAMETERS





 



	.text
	.align	4
	.global  mpihelp_add_n  
 mpihelp_add_n  :
	xor	%o2 ,%o0 ,%g1
	andcc	%g1,4,%g0
	bne	L1			! branch if alignment differs
	nop
! **  V1a  **
L0:	andcc	%o0 ,4,%g0		! %o0  unaligned? Side effect: cy=0
	be	L_v1			! if no, branch
	nop
 
	ld	[%o1 ],%g4
	add	%o1 ,4,%o1 
	ld	[%o2 ],%g2
	add	%o2 ,4,%o2 
	add	%o3 ,-1,%o3 
	addcc	%g4,%g2,%o4
	st	%o4,[%o0 ]
	add	%o0 ,4,%o0 
L_v1:	addx	%g0,%g0,%o4		! save cy in register
	cmp	%o3 ,2			! if %o3  < 2 ...
	bl	Lend2			! ... branch to tail code
	subcc	%g0,%o4,%g0		! restore cy

	ld	[%o1 +0],%g4
	addcc	%o3 ,-10,%o3 
	ld	[%o1 +4],%g1
	ldd	[%o2 +0],%g2
	blt	Lfin1
	subcc	%g0,%o4,%g0		! restore cy
 
Loop1:	addxcc	%g4,%g2,%o4
	ld	[%o1 +8],%g4
	addxcc	%g1,%g3,%o5
	ld	[%o1 +12],%g1
	ldd	[%o2 +8],%g2
	std	%o4,[%o0 +0]
	addxcc	%g4,%g2,%o4
	ld	[%o1 +16],%g4
	addxcc	%g1,%g3,%o5
	ld	[%o1 +20],%g1
	ldd	[%o2 +16],%g2
	std	%o4,[%o0 +8]
	addxcc	%g4,%g2,%o4
	ld	[%o1 +24],%g4
	addxcc	%g1,%g3,%o5
	ld	[%o1 +28],%g1
	ldd	[%o2 +24],%g2
	std	%o4,[%o0 +16]
	addxcc	%g4,%g2,%o4
	ld	[%o1 +32],%g4
	addxcc	%g1,%g3,%o5
	ld	[%o1 +36],%g1
	ldd	[%o2 +32],%g2
	std	%o4,[%o0 +24]
	addx	%g0,%g0,%o4		! save cy in register
	addcc	%o3 ,-8,%o3 
	add	%o1 ,32,%o1 
	add	%o2 ,32,%o2 
	add	%o0 ,32,%o0 
	bge	Loop1
	subcc	%g0,%o4,%g0		! restore cy

Lfin1:	addcc	%o3 ,8-2,%o3 
	blt	Lend1
	subcc	%g0,%o4,%g0		! restore cy
 
Loope1: addxcc	%g4,%g2,%o4
	ld	[%o1 +8],%g4
	addxcc	%g1,%g3,%o5
	ld	[%o1 +12],%g1
	ldd	[%o2 +8],%g2
	std	%o4,[%o0 +0]
	addx	%g0,%g0,%o4		! save cy in register
	addcc	%o3 ,-2,%o3 
	add	%o1 ,8,%o1 
	add	%o2 ,8,%o2 
	add	%o0 ,8,%o0 
	bge	Loope1
	subcc	%g0,%o4,%g0		! restore cy
Lend1:	addxcc	%g4,%g2,%o4
	addxcc	%g1,%g3,%o5
	std	%o4,[%o0 +0]
	addx	%g0,%g0,%o4		! save cy in register

	andcc	%o3 ,1,%g0
	be	Lret1
	subcc	%g0,%o4,%g0		! restore cy
 
	ld	[%o1 +8],%g4
	ld	[%o2 +8],%g2
	addxcc	%g4,%g2,%o4
	st	%o4,[%o0 +8]

Lret1:	retl
	addx	%g0,%g0,%o0	! return carry-out from most sign. limb

L1:	xor	%o1 ,%o0 ,%g1
	andcc	%g1,4,%g0
	bne	L2
	nop
! **  V1b  **
	mov	%o2 ,%g1
	mov	%o1 ,%o2 
	b	L0
	mov	%g1,%o1 

! **  V2  **
 




L2:	cmp	%o3 ,1
	be	Ljone
	nop
	andcc	%o1 ,4,%g0		! %o1  unaligned? Side effect: cy=0
	be	L_v2			! if no, branch
	nop
 
	ld	[%o1 ],%g4
	add	%o1 ,4,%o1 
	ld	[%o2 ],%g2
	add	%o2 ,4,%o2 
	add	%o3 ,-1,%o3 
	addcc	%g4,%g2,%o4
	st	%o4,[%o0 ]
	add	%o0 ,4,%o0 

L_v2:	addx	%g0,%g0,%o4		! save cy in register
	addcc	%o3 ,-8,%o3 
	blt	Lfin2
	subcc	%g0,%o4,%g0		! restore cy
 
Loop2:	ldd	[%o1 +0],%g2
	ldd	[%o2 +0],%o4
	addxcc	%g2,%o4,%g2
	st	%g2,[%o0 +0]
	addxcc	%g3,%o5,%g3
	st	%g3,[%o0 +4]
	ldd	[%o1 +8],%g2
	ldd	[%o2 +8],%o4
	addxcc	%g2,%o4,%g2
	st	%g2,[%o0 +8]
	addxcc	%g3,%o5,%g3
	st	%g3,[%o0 +12]
	ldd	[%o1 +16],%g2
	ldd	[%o2 +16],%o4
	addxcc	%g2,%o4,%g2
	st	%g2,[%o0 +16]
	addxcc	%g3,%o5,%g3
	st	%g3,[%o0 +20]
	ldd	[%o1 +24],%g2
	ldd	[%o2 +24],%o4
	addxcc	%g2,%o4,%g2
	st	%g2,[%o0 +24]
	addxcc	%g3,%o5,%g3
	st	%g3,[%o0 +28]
	addx	%g0,%g0,%o4		! save cy in register
	addcc	%o3 ,-8,%o3 
	add	%o1 ,32,%o1 
	add	%o2 ,32,%o2 
	add	%o0 ,32,%o0 
	bge	Loop2
	subcc	%g0,%o4,%g0		! restore cy

Lfin2:	addcc	%o3 ,8-2,%o3 
	blt	Lend2
	subcc	%g0,%o4,%g0		! restore cy
Loope2: ldd	[%o1 +0],%g2
	ldd	[%o2 +0],%o4
	addxcc	%g2,%o4,%g2
	st	%g2,[%o0 +0]
	addxcc	%g3,%o5,%g3
	st	%g3,[%o0 +4]
	addx	%g0,%g0,%o4		! save cy in register
	addcc	%o3 ,-2,%o3 
	add	%o1 ,8,%o1 
	add	%o2 ,8,%o2 
	add	%o0 ,8,%o0 
	bge	Loope2
	subcc	%g0,%o4,%g0		! restore cy
Lend2:	andcc	%o3 ,1,%g0
	be	Lret2
	subcc	%g0,%o4,%g0		! restore cy
 
Ljone:	ld	[%o1 ],%g4
	ld	[%o2 ],%g2
	addxcc	%g4,%g2,%o4
	st	%o4,[%o0 ]

Lret2:	retl
	addx	%g0,%g0,%o0	! return carry-out from most sign. limb



