1/* $NetBSD: divrem.m4,v 1.6 2002/01/24 00:45:22 ross Exp $ */ 2 3/* 4 * Copyright (c) 1994, 1995 Carnegie-Mellon University. 5 * All rights reserved. 6 * 7 * Author: Chris G. Demetriou 8 * 9 * Permission to use, copy, modify and distribute this software and 10 * its documentation is hereby granted, provided that both the copyright 11 * notice and this permission notice appear in all copies of the 12 * software, derivative works or modified versions, and any portions 13 * thereof, and that both notices appear in supporting documentation. 14 * 15 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 16 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 17 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 18 * 19 * Carnegie Mellon requests users of this software to return to 20 * 21 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 22 * School of Computer Science 23 * Carnegie Mellon University 24 * Pittsburgh PA 15213-3890 25 * 26 * any improvements or extensions that they make and grant Carnegie the 27 * rights to redistribute these changes. 28 */ 29 30/* 31 * Division and remainder. 32 * 33 * The use of m4 is modeled after the sparc code, but the algorithm is 34 * simple binary long division. 35 * 36 * Note that the loops could probably benefit from unrolling. 37 */ 38 39/* 40 * M4 Parameters 41 * NAME name of function to generate 42 * OP OP=div: t10 / t11 -> t12; OP=rem: t10 % t11 -> t12 43 * S S=true: signed; S=false: unsigned 44 * WORDSIZE total number of bits 45 */ 46 47define(A, `t10') 48define(B, `t11') 49define(RESULT, `t12') 50 51define(BIT, `t0') 52define(I, `t1') 53define(CC, `t2') 54define(T_0, `t3') 55ifelse(S, `true', `define(NEG, `t4')') 56 57#include <machine/asm.h> 58 59LEAF(NAME, 0) /* XXX */ 60 lda sp, -64(sp) 61 stq BIT, 0(sp) 62 stq I, 8(sp) 63 stq CC, 16(sp) 64 stq T_0, 24(sp) 65ifelse(S, `true', 66` stq NEG, 32(sp)') 67 stq A, 40(sp) 68 stq B, 48(sp) 69 mov zero, RESULT /* Initialize result to zero */ 70 71ifelse(S, `true', 72` 73 /* Compute sign of result. If either is negative, this is easy. */ 74 or A, B, NEG /* not the sign, but... */ 75 srl NEG, WORDSIZE - 1, NEG /* rather, or of high bits */ 76 blbc NEG, Ldoit /* neither negative? do it! */ 77 78ifelse(OP, `div', 79` xor A, B, NEG /* THIS is the sign! */ 80', ` mov A, NEG /* sign follows A. */ 81') 82 srl NEG, WORDSIZE - 1, NEG /* make negation the low bit. */ 83 84 srl A, WORDSIZE - 1, I /* is A negative? */ 85 blbc I, LnegB /* no. */ 86 /* A is negative; flip it. */ 87ifelse(WORDSIZE, `32', ` 88 /* top 32 bits may be random junk */ 89 zap A, 0xf0, A 90') 91 subq zero, A, A 92 srl B, WORDSIZE - 1, I /* is B negative? */ 93 blbc I, Ldoit /* no. */ 94LnegB: 95 /* B is definitely negative, no matter how we got here. */ 96ifelse(WORDSIZE, `32', ` 97 /* top 32 bits may be random junk */ 98 zap B, 0xf0, B 99') 100 subq zero, B, B 101Ldoit: 102') 103ifelse(WORDSIZE, `32', ` 104 /* 105 * Clear the top 32 bits of each operand, as they may 106 * sign extension (if negated above), or random junk. 107 */ 108 zap A, 0xf0, A 109 zap B, 0xf0, B 110') 111 112 /* kill the special cases. */ 113 beq B, Ldotrap /* division by zero! */ 114 115 cmpult A, B, CC /* A < B? */ 116 /* RESULT is already zero, from above. A is untouched. */ 117 bne CC, Lret_result 118 119 cmpeq A, B, CC /* A == B? */ 120 cmovne CC, 1, RESULT 121 cmovne CC, zero, A 122 bne CC, Lret_result 123 124 /* 125 * Find out how many bits of zeros are at the beginning of the divisor. 126 */ 127LBbits: 128 ldiq T_0, 1 /* I = 0; BIT = 1<<WORDSIZE-1 */ 129 mov zero, I 130 sll T_0, WORDSIZE-1, BIT 131LBloop: 132 and B, BIT, CC /* if bit in B is set, done. */ 133 bne CC, LAbits 134 addq I, 1, I /* increment I, shift bit */ 135 srl BIT, 1, BIT 136 cmplt I, WORDSIZE-1, CC /* if I leaves one bit, done. */ 137 bne CC, LBloop 138 139LAbits: 140 beq I, Ldodiv /* If I = 0, divide now. */ 141 ldiq T_0, 1 /* BIT = 1<<WORDSIZE-1 */ 142 sll T_0, WORDSIZE-1, BIT 143 144LAloop: 145 and A, BIT, CC /* if bit in A is set, done. */ 146 bne CC, Ldodiv 147 subq I, 1, I /* decrement I, shift bit */ 148 srl BIT, 1, BIT 149 bne I, LAloop /* If I != 0, loop again */ 150 151Ldodiv: 152 sll B, I, B /* B <<= i */ 153 ldiq T_0, 1 154 sll T_0, I, BIT 155 156Ldivloop: 157 cmpult A, B, CC 158 or RESULT, BIT, T_0 159 cmoveq CC, T_0, RESULT 160 subq A, B, T_0 161 cmoveq CC, T_0, A 162 srl BIT, 1, BIT 163 srl B, 1, B 164 beq A, Lret_result 165 bne BIT, Ldivloop 166 167Lret_result: 168ifelse(OP, `div', 169`', ` mov A, RESULT 170') 171ifelse(S, `true', 172` 173 /* Check to see if we should negate it. */ 174 subq zero, RESULT, T_0 175 cmovlbs NEG, T_0, RESULT 176') 177 178 ldq BIT, 0(sp) 179 ldq I, 8(sp) 180 ldq CC, 16(sp) 181 ldq T_0, 24(sp) 182ifelse(S, `true', 183` ldq NEG, 32(sp)') 184 ldq A, 40(sp) 185 ldq B, 48(sp) 186 lda sp, 64(sp) 187 ret zero, (t9), 1 188 189Ldotrap: 190 ldiq a0, -2 /* This is the signal to SIGFPE! */ 191 call_pal PAL_gentrap 192ifelse(OP, `div', 193`', ` mov zero, A /* so that zero will be returned */ 194') 195 br zero, Lret_result 196 197END(NAME) 198