/* $NetBSD: divrem.m4,v 1.5 1996/10/17 04:26:25 cgd Exp $ */
/*
* Copyright (c) 1994, 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Chris G. Demetriou
*
* Permission to use, copy, modify and distribute this software and
* its documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* Division and remainder.
*
* The use of m4 is modeled after the sparc code, but the algorithm is
* simple binary long division.
*
* Note that the loops could probably benefit from unrolling.
*/
/*
* M4 Parameters
* __divqu name of function to generate
* div div=div: t10 / t11 -> t12; div=rem: t10 % t11 -> t12
* false false=true: signed; false=false: unsigned
* 64 total number of bits
*/
/*
* LEAF
* Declare a global leaf function.
* A leaf function does not call other functions AND does not
* use any register that is callee-saved AND does not modify
* the stack pointer.
*/
.globl _name_; \
.ent _name_ 0; \
_name_:; \
.frame sp,0,ra
/*
* END
* Function delimiter
*/
.end _name_
LEAF(__divqu, 0) /* XXX */
lda sp, -64(sp)
stq t0, 0(sp)
stq t1, 8(sp)
stq t2, 16(sp)
stq t3, 24(sp)
stq t10, 40(sp)
stq t11, 48(sp)
mov zero, t12 /* Initialize result to zero */
/* kill the special cases. */
beq t11, L0dotrap /* division by zero! */
cmpult t10, t11, t2 /* t10 < t11? */
/* t12 is already zero, from above. t10 is untouched. */
bne t2, L0ret_result
cmpeq t10, t11, t2 /* t10 == t11? */
cmovne t2, 1, t12
cmovne t2, zero, t10
bne t2, L0ret_result
/*
* Find out how many bits of zeros are at the beginning of the divisor.
*/
L0Bbits:
ldiq t3, 1 /* t1 = 0; t0 = 1<<64-1 */
mov zero, t1
sll t3, 64-1, t0
L0Bloop:
and t11, t0, t2 /* if bit in t11 is set, done. */
bne t2, L0Abits
addq t1, 1, t1 /* increment t1, bit */
srl t0, 1, t0
cmplt t1, 64-1, t2 /* if t1 leaves one bit, done. */
bne t2, L0Bloop
L0Abits:
beq t1, L0dodiv /* If t1 = 0, divide now. */
ldiq t3, 1 /* t0 = 1<<64-1 */
sll t3, 64-1, t0
L0Aloop:
and t10, t0, t2 /* if bit in t10 is set, done. */
bne t2, L0dodiv
subq t1, 1, t1 /* decrement t1, bit */
srl t0, 1, t0
bne t1, L0Aloop /* If t1 != 0, loop again */
L0dodiv:
sll t11, t1, t11 /* t11 <<= i */
ldiq t3, 1
sll t3, t1, t0
L0divloop:
cmpult t10, t11, t2
or t12, t0, t3
cmoveq t2, t3, t12
subq t10, t11, t3
cmoveq t2, t3, t10
srl t0, 1, t0
srl t11, 1, t11
beq t10, L0ret_result
bne t0, L0divloop
L0ret_result:
ldq t0, 0(sp)
ldq t1, 8(sp)
ldq t2, 16(sp)
ldq t3, 24(sp)
ldq t10, 40(sp)
ldq t11, 48(sp)
lda sp, 64(sp)
ret zero, (t9), 1
L0dotrap:
ldiq a0, -2 /* This is the signal to SIGFPE! */
call_pal PAL_gentrap
br zero, L0ret_result
END(__divqu)
/* $NetBSD: divrem.m4,v 1.5 1996/10/17 04:26:25 cgd Exp $ */
/*
* Copyright (c) 1994, 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Chris G. Demetriou
*
* Permission to use, copy, modify and distribute this software and
* its documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* Division and remainder.
*
* The use of m4 is modeled after the sparc code, but the algorithm is
* simple binary long division.
*
* Note that the loops could probably benefit from unrolling.
*/
/*
* M4 Parameters
* __divlu name of function to generate
* div div=div: t10 / t11 -> t12; div=rem: t10 % t11 -> t12
* false false=true: signed; false=false: unsigned
* 32 total number of bits
*/
LEAF(__divlu, 0) /* XXX */
lda sp, -64(sp)
stq t0, 0(sp)
stq t1, 8(sp)
stq t2, 16(sp)
stq t3, 24(sp)
stq t10, 40(sp)
stq t11, 48(sp)
mov zero, t12 /* Initialize result to zero */
/*
* Clear the top 32 bits of each operand, as they may
* sign extension (if negated above), or random junk.
*/
zap t10, 0xf0, t10
zap t11, 0xf0, t11
/* kill the special cases. */
beq t11, L1dotrap /* division by zero! */
cmpult t10, t11, t2 /* t10 < t11? */
/* t12 is already zero, from above. t10 is untouched. */
bne t2, L1ret_result
cmpeq t10, t11, t2 /* t10 == t11? */
cmovne t2, 1, t12
cmovne t2, zero, t10
bne t2, L1ret_result
/*
* Find out how many bits of zeros are at the beginning of the divisor.
*/
L1Bbits:
ldiq t3, 1 /* t1 = 0; t0 = 1<<32-1 */
mov zero, t1
sll t3, 32-1, t0
L1Bloop:
and t11, t0, t2 /* if bit in t11 is set, done. */
bne t2, L1Abits
addq t1, 1, t1 /* increment t1, bit */
srl t0, 1, t0
cmplt t1, 32-1, t2 /* if t1 leaves one bit, done. */
bne t2, L1Bloop
L1Abits:
beq t1, L1dodiv /* If t1 = 0, divide now. */
ldiq t3, 1 /* t0 = 1<<32-1 */
sll t3, 32-1, t0
L1Aloop:
and t10, t0, t2 /* if bit in t10 is set, done. */
bne t2, L1dodiv
subq t1, 1, t1 /* decrement t1, bit */
srl t0, 1, t0
bne t1, L1Aloop /* If t1 != 0, loop again */
L1dodiv:
sll t11, t1, t11 /* t11 <<= i */
ldiq t3, 1
sll t3, t1, t0
L1divloop:
cmpult t10, t11, t2
or t12, t0, t3
cmoveq t2, t3, t12
subq t10, t11, t3
cmoveq t2, t3, t10
srl t0, 1, t0
srl t11, 1, t11
beq t10, L1ret_result
bne t0, L1divloop
L1ret_result:
ldq t0, 0(sp)
ldq t1, 8(sp)
ldq t2, 16(sp)
ldq t3, 24(sp)
ldq t10, 40(sp)
ldq t11, 48(sp)
lda sp, 64(sp)
ret zero, (t9), 1
L1dotrap:
ldiq a0, -2 /* This is the signal to SIGFPE! */
call_pal PAL_gentrap
br zero, L1ret_result
END(__divlu)
/* $NetBSD: divrem.m4,v 1.5 1996/10/17 04:26:25 cgd Exp $ */
/*
* Copyright (c) 1994, 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Chris G. Demetriou
*
* Permission to use, copy, modify and distribute this software and
* its documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* Division and remainder.
*
* The use of m4 is modeled after the sparc code, but the algorithm is
* simple binary long division.
*
* Note that the loops could probably benefit from unrolling.
*/
/*
* M4 Parameters
* __remlu name of function to generate
* rem rem=div: t10 / t11 -> t12; rem=rem: t10 % t11 -> t12
* false false=true: signed; false=false: unsigned
* 32 total number of bits
*/
LEAF(__remlu, 0) /* XXX */
lda sp, -64(sp)
stq t0, 0(sp)
stq t1, 8(sp)
stq t2, 16(sp)
stq t3, 24(sp)
stq t10, 40(sp)
stq t11, 48(sp)
mov zero, t12 /* Initialize result to zero */
/*
* Clear the top 32 bits of each operand, as they may
* sign extension (if negated above), or random junk.
*/
zap t10, 0xf0, t10
zap t11, 0xf0, t11
/* kill the special cases. */
beq t11, L2dotrap /* division by zero! */
cmpult t10, t11, t2 /* t10 < t11? */
/* t12 is already zero, from above. t10 is untouched. */
bne t2, L2ret_result
cmpeq t10, t11, t2 /* t10 == t11? */
cmovne t2, 1, t12
cmovne t2, zero, t10
bne t2, L2ret_result
/*
* Find out how many bits of zeros are at the beginning of the divisor.
*/
L2Bbits:
ldiq t3, 1 /* t1 = 0; t0 = 1<<32-1 */
mov zero, t1
sll t3, 32-1, t0
L2Bloop:
and t11, t0, t2 /* if bit in t11 is set, done. */
bne t2, L2Abits
addq t1, 1, t1 /* increment t1, bit */
srl t0, 1, t0
cmplt t1, 32-1, t2 /* if t1 leaves one bit, done. */
bne t2, L2Bloop
L2Abits:
beq t1, L2dodiv /* If t1 = 0, divide now. */
ldiq t3, 1 /* t0 = 1<<32-1 */
sll t3, 32-1, t0
L2Aloop:
and t10, t0, t2 /* if bit in t10 is set, done. */
bne t2, L2dodiv
subq t1, 1, t1 /* decrement t1, bit */
srl t0, 1, t0
bne t1, L2Aloop /* If t1 != 0, loop again */
L2dodiv:
sll t11, t1, t11 /* t11 <<= i */
ldiq t3, 1
sll t3, t1, t0
L2divloop:
cmpult t10, t11, t2
or t12, t0, t3
cmoveq t2, t3, t12
subq t10, t11, t3
cmoveq t2, t3, t10
srl t0, 1, t0
srl t11, 1, t11
beq t10, L2ret_result
bne t0, L2divloop
L2ret_result:
mov t10, t12
ldq t0, 0(sp)
ldq t1, 8(sp)
ldq t2, 16(sp)
ldq t3, 24(sp)
ldq t10, 40(sp)
ldq t11, 48(sp)
lda sp, 64(sp)
ret zero, (t9), 1
L2dotrap:
ldiq a0, -2 /* This is the signal to SIGFPE! */
call_pal PAL_gentrap
mov zero, t10 /* so that zero will be returned */
br zero, L2ret_result
END(__remlu)
/* $NetBSD: divrem.m4,v 1.5 1996/10/17 04:26:25 cgd Exp $ */
/*
* Copyright (c) 1994, 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Chris G. Demetriou
*
* Permission to use, copy, modify and distribute this software and
* its documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* Division and remainder.
*
* The use of m4 is modeled after the sparc code, but the algorithm is
* simple binary long division.
*
* Note that the loops could probably benefit from unrolling.
*/
/*
* M4 Parameters
* __remqu name of function to generate
* rem rem=div: t10 / t11 -> t12; rem=rem: t10 % t11 -> t12
* false false=true: signed; false=false: unsigned
* 64 total number of bits
*/
LEAF(__remqu, 0) /* XXX */
lda sp, -64(sp)
stq t0, 0(sp)
stq t1, 8(sp)
stq t2, 16(sp)
stq t3, 24(sp)
stq t10, 40(sp)
stq t11, 48(sp)
mov zero, t12 /* Initialize result to zero */
/* kill the special cases. */
beq t11, L3dotrap /* division by zero! */
cmpult t10, t11, t2 /* t10 < t11? */
/* t12 is already zero, from above. t10 is untouched. */
bne t2, L3ret_result
cmpeq t10, t11, t2 /* t10 == t11? */
cmovne t2, 1, t12
cmovne t2, zero, t10
bne t2, L3ret_result
/*
* Find out how many bits of zeros are at the beginning of the divisor.
*/
L3Bbits:
ldiq t3, 1 /* t1 = 0; t0 = 1<<64-1 */
mov zero, t1
sll t3, 64-1, t0
L3Bloop:
and t11, t0, t2 /* if bit in t11 is set, done. */
bne t2, L3Abits
addq t1, 1, t1 /* increment t1, bit */
srl t0, 1, t0
cmplt t1, 64-1, t2 /* if t1 leaves one bit, done. */
bne t2, L3Bloop
L3Abits:
beq t1, L3dodiv /* If t1 = 0, divide now. */
ldiq t3, 1 /* t0 = 1<<64-1 */
sll t3, 64-1, t0
L3Aloop:
and t10, t0, t2 /* if bit in t10 is set, done. */
bne t2, L3dodiv
subq t1, 1, t1 /* decrement t1, bit */
srl t0, 1, t0
bne t1, L3Aloop /* If t1 != 0, loop again */
L3dodiv:
sll t11, t1, t11 /* t11 <<= i */
ldiq t3, 1
sll t3, t1, t0
L3divloop:
cmpult t10, t11, t2
or t12, t0, t3
cmoveq t2, t3, t12
subq t10, t11, t3
cmoveq t2, t3, t10
srl t0, 1, t0
srl t11, 1, t11
beq t10, L3ret_result
bne t0, L3divloop
L3ret_result:
mov t10, t12
ldq t0, 0(sp)
ldq t1, 8(sp)
ldq t2, 16(sp)
ldq t3, 24(sp)
ldq t10, 40(sp)
ldq t11, 48(sp)
lda sp, 64(sp)
ret zero, (t9), 1
L3dotrap:
ldiq a0, -2 /* This is the signal to SIGFPE! */
call_pal PAL_gentrap
mov zero, t10 /* so that zero will be returned */
br zero, L3ret_result
END(__remqu)