divrem.m4 revision 1.6
1 /* $NetBSD: divrem.m4,v 1.6 1996/09/09 00:51:27 cgd 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 (at) 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 47 define(A, `t10') 48 define(B, `t11') 49 define(RESULT, `t12') 50 51 define(BIT, `t0') 52 define(I, `t1') 53 define(CC, `t2') 54 define(T_0, `t3') 55 ifelse(S, `true', `define(NEG, `t4')') 56 57 #include "DEFS.h" 58 59 LEAF(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) 65 ifelse(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 71 ifelse(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 78 ifelse(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. */ 87 ifelse(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. */ 94 LnegB: 95 /* B is definitely negative, no matter how we got here. */ 96 ifelse(WORDSIZE, `32', ` 97 /* top 32 bits may be random junk */ 98 zap B, 0xf0, B 99 ') 100 subq zero, B, B 101 Ldoit: 102 ') 103 ifelse(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 */ 127 LBbits: 128 CONST(1, T_0) /* I = 0; BIT = 1<<WORDSIZE-1 */ 129 mov zero, I 130 sll T_0, WORDSIZE-1, BIT 131 LBloop: 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 139 LAbits: 140 beq I, Ldodiv /* If I = 0, divide now. */ 141 CONST(1, T_0) /* BIT = 1<<WORDSIZE-1 */ 142 sll T_0, WORDSIZE-1, BIT 143 144 LAloop: 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 151 Ldodiv: 152 sll B, I, B /* B <<= i */ 153 CONST(1, T_0) 154 sll T_0, I, BIT 155 156 Ldivloop: 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 167 Lret_result: 168 ifelse(OP, `div', 169 `', ` mov A, RESULT 170 ') 171 ifelse(S, `true', 172 ` 173 /* Check to see if we should negate it. */ 174 subqv 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) 182 ifelse(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 189 Ldotrap: 190 CONST(-2, a0) /* This is the signal to SIGFPE! */ 191 call_pal PAL_gentrap 192 ifelse(OP, `div', 193 `', ` mov zero, A /* so that zero will be returned */ 194 ') 195 br zero, Lret_result 196 197 END(NAME) 198
Indexes created Tue Sep 30 10:09:55 GMT 2025