![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r3kd.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to r3kd.s CVS log | Up to [PGP] / pgp / src |
1.1 root 1: /* Multiprecision multiply routine. . . This assumes the ability to
2: * do a 32x32->64 multiply. I have put in dummy code for the multiplies
3: * which should be easily identifiable in the resulting source.
4: * This code was designed for the MIPS series processors, however
5: * should work pretty well on any machine with hardware multiply.
6: * The lack of a carry bit in the R3000 resulted in some of the
7: * machinations which take place.
8: *
9: * See code in dmul_proto.c for the prototype, and appropriate
10: * documentation.
11: *
12: * Note that this has hooks for both byte orderings of MIPS processors,
13: * and that if you have the wrong flags being set in your cpp,
14: * you may wind up with no code at all. (DEC's version will, when
15: * compiling for the other byte ordering, leave BOTH things defined,
16: * which is bad. . . )
17: *
18: * - Castor Fu Wed Sep 30 11:48:38 PDT 1992
19: */
20:
21: #if defined(MIPSEL) && !defined(MIPSEB)
22: .verstamp 2 10
23: .extern global_precision 2
24: .text
25: .align 2
26: .file 2 "ndmulprotoEL.c"
27: .globl p_dmul
28: .loc 2 69
29: # 69 {
30: .ent p_dmul 2
31: p_dmul:
32: .option O2
33: subu $sp, 168
34: sd $30, 32($sp)
35: sd $22, 24($sp)
36: sd $20, 16($sp)
37: sd $18, 8($sp)
38: sd $16, 0($sp)
39: .mask 0xC0FF0000, -132
40: .frame $sp, 168, $31
41: sw $5, 172($sp)
42: sw $6, 176($sp)
43: .loc 2 76
44: # 76 preca = global_precision;
45: lh $14, global_precision
46: sw $14, 164($sp)
47: .loc 2 77
48: # 77 pp=msbptr(multiplicand,preca);
49: .loc 2 78
50: # 78 while(*post_lowerunit(pp) == 0 && preca > 0) preca--;
51: mul $2, $14, 4
52: lw $15, 172($sp)
53: addu $3, $15, $2
54: lw $11, -4($3)
55: addu $20, $3, -8
56: bne $11, 0, $33
57: ble $14, 0, $33
58: $32:
59: lw $24, 164($sp)
60: addu $25, $24, -1
61: sw $25, 164($sp)
62: lw $11, 0($20)
63: addu $20, $20, -4
64: bne $11, 0, $33
65: bgt $25, 0, $32
66: $33:
67: .loc 2 80
68: # 79
69: # 80 precb = global_precision;
70: lh $15, global_precision
71: sw $15, 160($sp)
72: .loc 2 81
73: # 81 pp = msbptr(multiplier,precb);
74: .loc 2 82
75: # 82 while(*post_lowerunit(pp) == 0 && precb > 0) precb--;
76: lw $14, 176($sp)
77: addu $3, $14, $2
78: lw $11, -4($3)
79: addu $20, $3, -8
80: bne $11, 0, $35
81: ble $15, 0, $35
82: $34:
83: lw $24, 160($sp)
84: addu $25, $24, -1
85: sw $25, 160($sp)
86: lw $11, 0($20)
87: addu $20, $20, -4
88: bne $11, 0, $35
89: bgt $25, 0, $34
90: $35:
91: .loc 2 84
92: # 83
93: # 84 prec2 = global_precision<<1;
94: lh $3, global_precision
95: sll $3, $3, 1
96: move $2, $3
97: .loc 2 86
98: # 85
99: # 86 pp = msbptr(prod,prec2);
100: mul $14, $3, 4
101: addu $20, $4, $14
102: addu $20, $20, -4
103: .loc 2 87
104: # 87 for (i= preca+precb; i < prec2 ; i++) {
105: lw $15, 164($sp)
106: lw $24, 160($sp)
107: addu $25, $15, $24
108: sw $25, 72($sp)
109: move $21, $25
110: bge $25, $3, $37
111: $36:
112: .loc 2 88
113: # 88 *post_lowerunit(pp) = 0;
114: sw $0, 0($20)
115: addu $20, $20, -4
116: .loc 2 89
117: # 89 }
118: .loc 2 89
119: addu $21, $21, 1
120: blt $21, $2, $36
121: $37:
122: .loc 2 90
123: # 90 if (preca == 0 || precb == 0) {
124: lw $14, 164($sp)
125: beq $14, 0, $38
126: lw $15, 160($sp)
127: bne $15, 0, $41
128: $38:
129: .loc 2 91
130: # 91 pp = lsbptr(prod,prec2);
131: move $20, $4
132: .loc 2 92
133: # 92 for (i=0; i < preca + precb; i++)
134: move $21, $0
135: lw $24, 72($sp)
136: ble $24, 0, $61
137: and $2, $24, 3
138: beq $2, 0, $40
139: $39:
140: sw $0, 0($20)
141: addu $20, $20, 4
142: addu $21, $21, 1
143: bne $2, $21, $39
144: lw $25, 72($sp)
145: beq $21, $25, $61
146: $40:
147: .loc 2 93
148: # 93 *(post_higherunit(pp)) = 0;
149: sw $0, 0($20)
150: addu $20, $20, 4
151: sw $0, 0($20)
152: addu $20, $20, 4
153: sw $0, 0($20)
154: addu $20, $20, 4
155: sw $0, 0($20)
156: addu $20, $20, 4
157: addu $21, $21, 4
158: lw $14, 72($sp)
159: bne $21, $14, $40
160: .loc 2 94
161: # 94 return;
162: b $61
163: $41:
164: .loc 2 97
165: # 95 }
166: # 96 /* Canonicalize length(a) >= length(b) */
167: # 97 if (preca < precb) {
168: lw $15, 164($sp)
169: lw $24, 160($sp)
170: bge $15, $24, $42
171: .loc 2 98
172: # 98 pp = multiplicand;
173: lw $20, 172($sp)
174: .loc 2 99
175: # 99 multiplicand = multiplier;
176: lw $25, 176($sp)
177: sw $25, 172($sp)
178: .loc 2 100
179: # 100 multiplier = pp;
180: sw $20, 176($sp)
181: .loc 2 101
182: # 101 i = preca;
183: move $21, $15
184: .loc 2 102
185: # 102 preca = precb;
186: sw $24, 164($sp)
187: .loc 2 103
188: # 103 precb = i;
189: sw $21, 160($sp)
190: .loc 2 104
191: # 104 }
192: lw $14, 164($sp)
193: lw $25, 160($sp)
194: addu $15, $14, $25
195: sw $15, 72($sp)
196: $42:
197: .loc 2 107
198: # 105 make_lsbptr(multiplicand, global_precision);
199: # 106 make_lsbptr(multiplier, global_precision);
200: # 107 pp = lsbptr(prod,prec2);
201: move $20, $4
202: .loc 2 108
203: # 108 ah = 0;
204: move $12, $0
205: .loc 2 109
206: # 109 carryl = 0;
207: move $19, $0
208: .loc 2 110
209: # 110 carryh =0;
210: move $18, $0
211: .loc 2 111
212: # 111 al = 0;
213: .loc 2 114
214: # 112
215: # 113
216: # 114 amin = 0;
217: .loc 2 115
218: # 115 for (i=0; i < precb; i++) {
219: move $21, $0
220: lw $24, 160($sp)
221: ble $24, 0, $48
222: lw $23, 172($sp)
223: addu $30, $23, -4
224: lw $14, 176($sp)
225: addu $25, $14, 4
226: sw $25, 56($sp)
227: $43:
228: .loc 2 116
229: # 116 amax = i;
230: .loc 2 117
231: # 117 ma = word_index(multiplicand,i -1);
232: move $13, $30
233: .loc 2 118
234: # 118 mb = word_index(multiplier,1);
235: lw $16, 56($sp)
236: .loc 2 119
237: # 119 lmul(word_v(ma,1),word_v(mb,-1),ml, mh);
238: lw $2, 0($23)
239: lw $15, 176($sp)
240: lw $3, 0($15)
241: multu $2, $3
242: mflo $9
243: mfhi $10
244: .loc 2 120
245: # 120 al = ah+ carryl;
246: addu $4, $12, $19
247: move $8, $4
248: .loc 2 121
249: # 121 carryl = carryh + (al < ah);
250: sltu $24, $4, $12
251: addu $19, $18, $24
252: .loc 2 122
253: # 122 ah = 0;
254: move $12, $0
255: .loc 2 123
256: # 123 carryh = 0;
257: move $18, $0
258: .loc 2 124
259: # 124 j = amax - amin;
260: move $5, $21
261: move $31, $5
262: .loc 2 125
263: # 125 k = j & 3;
264: .loc 2 126
265: # 126 while (k--) {
266: and $6, $5, 3
267: addu $17, $6, -1
268: beq $6, $0, $45
269: $44:
270: .loc 2 127
271: # 127 lmul( *ma, *mb, nml, nmh);
272: lw $2, 0($13)
273: lw $3, 0($16)
274: multu $2, $3
275: .loc 2 128
276: # 128 al += ml;
277: addu $8, $8, $9
278: .loc 2 129
279: # 129 carryl += (al < ml);
280: sltu $14, $8, $9
281: addu $19, $19, $14
282: .loc 2 130
283: # 130 ah += mh;
284: addu $12, $12, $10
285: .loc 2 131
286: # 131 carryh += (ah < mh);
287: sltu $25, $12, $10
288: addu $18, $18, $25
289: .loc 2 132
290: # 132 post_lowerunit(ma);
291: addu $13, $13, -4
292: .loc 2 133
293: # 133 post_higherunit(mb);
294: addu $16, $16, 4
295: .loc 2 134
296: # 134 ml = nml;
297: mflo $9
298: .loc 2 135
299: # 135 mh = nmh;
300: mfhi $10
301: .loc 2 136
302: # 136 }
303: .loc 2 136
304: move $11, $17
305: addu $17, $17, -1
306: bne $11, 0, $44
307: $45:
308: .loc 2 137
309: # 137 k = j >> 2;
310: .loc 2 138
311: # 138 while (k--) {
312: sra $2, $31, 2
313: addu $17, $2, -1
314: beq $2, $0, $47
315: $46:
316: .loc 2 139
317: # 139 lmul( word_v(ma,0), word_v(mb,0), nml, nmh);
318: lw $2, 0($13)
319: lw $3, 0($16)
320: multu $2, $3
321: .loc 2 140
322: # 140 al += ml;
323: addu $8, $8, $9
324: .loc 2 141
325: # 141 carryl += (al < ml);
326: sltu $15, $8, $9
327: addu $19, $19, $15
328: .loc 2 142
329: # 142 ah += mh;
330: addu $12, $12, $10
331: .loc 2 143
332: # 143 carryh += (ah < mh);
333: sltu $24, $12, $10
334: addu $18, $18, $24
335: .loc 2 144
336: # 144 ml = nml;
337: mflo $9
338: .loc 2 145
339: # 145 mh = nmh;
340: mfhi $10
341: .loc 2 147
342: # 146
343: # 147 lmul( word_v(ma,-1), word_v(mb,1), nml, nmh);
344: lw $4, -4($13)
345: lw $5, 4($16)
346: multu $4, $5
347: .loc 2 148
348: # 148 al += ml;
349: addu $8, $8, $9
350: .loc 2 149
351: # 149 carryl += (al < ml);
352: sltu $14, $8, $9
353: addu $19, $19, $14
354: .loc 2 150
355: # 150 ah += mh;
356: addu $12, $12, $10
357: .loc 2 151
358: # 151 carryh += (ah < mh);
359: sltu $25, $12, $10
360: addu $18, $18, $25
361: .loc 2 152
362: # 152 ml = nml;
363: mflo $9
364: .loc 2 153
365: # 153 mh = nmh;
366: mfhi $10
367: .loc 2 155
368: # 154
369: # 155 lmul( word_v(ma,-2), word_v(mb,2), nml, nmh);
370: lw $2, -8($13)
371: lw $3, 8($16)
372: multu $2, $3
373: .loc 2 156
374: # 156 al += ml;
375: addu $8, $8, $9
376: .loc 2 157
377: # 157 carryl += (al < ml);
378: sltu $15, $8, $9
379: addu $19, $19, $15
380: .loc 2 158
381: # 158 ah += mh;
382: addu $12, $12, $10
383: .loc 2 159
384: # 159 carryh += (ah < mh);
385: sltu $24, $12, $10
386: addu $18, $18, $24
387: .loc 2 160
388: # 160 ml = nml;
389: mflo $9
390: .loc 2 161
391: # 161 mh = nmh;
392: mfhi $10
393: .loc 2 163
394: # 162
395: # 163 lmul( word_v(ma,-3), word_v(mb,3), nml, nmh);
396: lw $4, -12($13)
397: lw $5, 12($16)
398: multu $4, $5
399: .loc 2 164
400: # 164 al += ml;
401: addu $8, $8, $9
402: .loc 2 165
403: # 165 carryl += (al < ml);
404: sltu $14, $8, $9
405: addu $19, $19, $14
406: .loc 2 166
407: # 166 ah += mh;
408: addu $12, $12, $10
409: .loc 2 167
410: # 167 carryh += (ah < mh);
411: sltu $25, $12, $10
412: addu $18, $18, $25
413: .loc 2 168
414: # 168 ml = nml;
415: mflo $9
416: .loc 2 169
417: # 169 mh = nmh;
418: mfhi $10
419: .loc 2 171
420: # 170
421: # 171 nlowerunit(ma,4); nhigherunit(mb,4);
422: addu $13, $13, -16
423: addu $16, $16, 16
424: .loc 2 173
425: # 172
426: # 173 }
427: .loc 2 173
428: move $11, $17
429: addu $17, $17, -1
430: bne $11, 0, $46
431: $47:
432: .loc 2 175
433: # 174
434: # 175 al += ml;
435: addu $8, $8, $9
436: .loc 2 176
437: # 176 carryl += (al < ml);
438: sltu $15, $8, $9
439: addu $19, $19, $15
440: .loc 2 177
441: # 177 *pp = al;
442: sw $8, 0($20)
443: .loc 2 178
444: # 178 ah += mh;
445: addu $12, $12, $10
446: .loc 2 179
447: # 179 carryh += (ah < mh);
448: sltu $24, $12, $10
449: addu $18, $18, $24
450: .loc 2 180
451: # 180 post_higherunit(pp);
452: addu $20, $20, 4
453: .loc 2 181
454: # 181 }
455: .loc 2 181
456: addu $21, $21, 1
457: addu $23, $23, 4
458: addu $30, $30, 4
459: lw $14, 160($sp)
460: bne $21, $14, $43
461: $48:
462: .loc 2 182
463: # 182 amax = precb-1;
464: .loc 2 183
465: # 183 for (i=precb; i < preca; i++) {
466: lw $25, 160($sp)
467: move $21, $25
468: lw $15, 164($sp)
469: bge $25, $15, $54
470: mul $22, $21, 4
471: lw $24, 172($sp)
472: addu $23, $24, $22
473: addu $30, $23, -4
474: lw $14, 176($sp)
475: addu $24, $14, 4
476: sw $24, 56($sp)
477: mul $14, $15, 4
478: sw $14, 52($sp)
479: addu $2, $25, -1
480: move $31, $2
481: and $24, $2, 3
482: sw $24, 44($sp)
483: addu $15, $24, -1
484: sw $15, 40($sp)
485: $49:
486: .loc 2 184
487: # 184 ma = word_index( multiplicand,i-1);
488: move $13, $30
489: .loc 2 185
490: # 185 mb = word_index(multiplier,1);
491: lw $16, 56($sp)
492: .loc 2 186
493: # 186 lmul(word_v(ma,1),word_v(mb,-1),ml, mh);
494: lw $2, 0($23)
495: lw $14, 176($sp)
496: lw $3, 0($14)
497: multu $2, $3
498: mflo $9
499: mfhi $10
500: .loc 2 187
501: # 187 al = ah+ carryl;
502: addu $4, $12, $19
503: move $8, $4
504: .loc 2 188
505: # 188 carryl = carryh + (al < ah);
506: sltu $25, $4, $12
507: addu $19, $18, $25
508: .loc 2 189
509: # 189 ah = 0;
510: move $12, $0
511: .loc 2 190
512: # 190 carryh = 0;
513: move $18, $0
514: .loc 2 191
515: # 191 j = amax - amin;
516: .loc 2 192
517: # 192 k = j & 3;
518: .loc 2 193
519: # 193 while (k--) {
520: lw $17, 40($sp)
521: lw $24, 44($sp)
522: beq $24, $0, $51
523: $50:
524: .loc 2 194
525: # 194 lmul( *ma, *mb, nml, nmh);
526: lw $2, 0($13)
527: lw $3, 0($16)
528: multu $2, $3
529: .loc 2 195
530: # 195 al += ml;
531: addu $8, $8, $9
532: .loc 2 196
533: # 196 carryl += (al < ml);
534: sltu $15, $8, $9
535: addu $19, $19, $15
536: .loc 2 197
537: # 197 ah += mh;
538: addu $12, $12, $10
539: .loc 2 198
540: # 198 carryh += (ah < mh);
541: sltu $14, $12, $10
542: addu $18, $18, $14
543: .loc 2 199
544: # 199 post_lowerunit(ma);
545: addu $13, $13, -4
546: .loc 2 200
547: # 200 post_higherunit(mb);
548: addu $16, $16, 4
549: .loc 2 201
550: # 201 ml = nml;
551: mflo $9
552: .loc 2 202
553: # 202 mh = nmh;
554: mfhi $10
555: .loc 2 203
556: # 203 }
557: .loc 2 203
558: move $11, $17
559: addu $17, $17, -1
560: bne $11, 0, $50
561: $51:
562: .loc 2 204
563: # 204 k = j >> 2;
564: .loc 2 205
565: # 205 while (k--) {
566: sra $2, $31, 2
567: addu $17, $2, -1
568: beq $2, $0, $53
569: $52:
570: .loc 2 206
571: # 206 lmul( word_v(ma,0), word_v(mb,0), nml, nmh);
572: lw $2, 0($13)
573: lw $3, 0($16)
574: multu $2, $3
575: .loc 2 207
576: # 207 al += ml;
577: addu $8, $8, $9
578: .loc 2 208
579: # 208 carryl += (al < ml);
580: sltu $25, $8, $9
581: addu $19, $19, $25
582: .loc 2 209
583: # 209 ah += mh;
584: addu $12, $12, $10
585: .loc 2 210
586: # 210 carryh += (ah < mh);
587: sltu $24, $12, $10
588: addu $18, $18, $24
589: .loc 2 211
590: # 211 ml = nml;
591: mflo $9
592: .loc 2 212
593: # 212 mh = nmh;
594: mfhi $10
595: .loc 2 214
596: # 213
597: # 214 lmul( word_v(ma,-1), word_v(mb,1), nml, nmh);
598: lw $4, -4($13)
599: lw $5, 4($16)
600: multu $4, $5
601: .loc 2 215
602: # 215 al += ml;
603: addu $8, $8, $9
604: .loc 2 216
605: # 216 carryl += (al < ml);
606: sltu $15, $8, $9
607: addu $19, $19, $15
608: .loc 2 217
609: # 217 ah += mh;
610: addu $12, $12, $10
611: .loc 2 218
612: # 218 carryh += (ah < mh);
613: sltu $14, $12, $10
614: addu $18, $18, $14
615: .loc 2 219
616: # 219 ml = nml;
617: mflo $9
618: .loc 2 220
619: # 220 mh = nmh;
620: mfhi $10
621: .loc 2 222
622: # 221
623: # 222 lmul( word_v(ma,-2), word_v(mb,2), nml, nmh);
624: lw $2, -8($13)
625: lw $3, 8($16)
626: multu $2, $3
627: .loc 2 223
628: # 223 al += ml;
629: addu $8, $8, $9
630: .loc 2 224
631: # 224 carryl += (al < ml);
632: sltu $25, $8, $9
633: addu $19, $19, $25
634: .loc 2 225
635: # 225 ah += mh;
636: addu $12, $12, $10
637: .loc 2 226
638: # 226 carryh += (ah < mh);
639: sltu $24, $12, $10
640: addu $18, $18, $24
641: .loc 2 227
642: # 227 ml = nml;
643: mflo $9
644: .loc 2 228
645: # 228 mh = nmh;
646: mfhi $10
647: .loc 2 230
648: # 229
649: # 230 lmul( word_v(ma,-3), word_v(mb,3), nml, nmh);
650: lw $4, -12($13)
651: lw $5, 12($16)
652: multu $4, $5
653: .loc 2 231
654: # 231 al += ml;
655: addu $8, $8, $9
656: .loc 2 232
657: # 232 carryl += (al < ml);
658: sltu $15, $8, $9
659: addu $19, $19, $15
660: .loc 2 233
661: # 233 ah += mh;
662: addu $12, $12, $10
663: .loc 2 234
664: # 234 carryh += (ah < mh);
665: sltu $14, $12, $10
666: addu $18, $18, $14
667: .loc 2 235
668: # 235 ml = nml;
669: mflo $9
670: .loc 2 236
671: # 236 mh = nmh;
672: mfhi $10
673: .loc 2 238
674: # 237
675: # 238 nlowerunit(ma,4);
676: addu $13, $13, -16
677: .loc 2 239
678: # 239 nhigherunit(mb,4);
679: addu $16, $16, 16
680: .loc 2 240
681: # 240 }
682: .loc 2 240
683: move $11, $17
684: addu $17, $17, -1
685: bne $11, 0, $52
686: $53:
687: .loc 2 242
688: # 241
689: # 242 al += ml;
690: addu $8, $8, $9
691: .loc 2 243
692: # 243 carryl += (al < ml);
693: sltu $25, $8, $9
694: addu $19, $19, $25
695: .loc 2 244
696: # 244 *pp = al;
697: sw $8, 0($20)
698: .loc 2 245
699: # 245 ah += mh;
700: addu $12, $12, $10
701: .loc 2 246
702: # 246 carryh += (ah < mh);
703: sltu $24, $12, $10
704: addu $18, $18, $24
705: .loc 2 247
706: # 247 post_higherunit(pp);
707: addu $20, $20, 4
708: .loc 2 248
709: # 248 }
710: .loc 2 248
711: addu $22, $22, 4
712: addu $23, $23, 4
713: addu $30, $30, 4
714: lw $15, 52($sp)
715: blt $22, $15, $49
716: $54:
717: .loc 2 249
718: # 249 amax = precb-1;
719: .loc 2 250
720: # 250 for (i=preca; i < preca + precb -1; i++) {
721: lw $14, 164($sp)
722: move $21, $14
723: lw $25, 72($sp)
724: addu $24, $25, -1
725: sw $24, 68($sp)
726: bge $14, $24, $60
727: lw $15, 160($sp)
728: addu $25, $15, -1
729: sw $25, 72($sp)
730: lw $24, 172($sp)
731: mul $15, $14, 4
732: addu $30, $24, $15
733: addu $25, $30, -8
734: sw $25, 60($sp)
735: lw $24, 176($sp)
736: subu $15, $21, $14
737: mul $25, $15, 4
738: addu $22, $24, $25
739: addu $23, $22, 8
740: $55:
741: .loc 2 251
742: # 251 amin = i-preca + 1;
743: .loc 2 252
744: # 252 ma = word_index(multiplicand,preca-2);
745: lw $13, 60($sp)
746: .loc 2 253
747: # 253 mb = word_index(multiplier, - preca + 2 +i) ;
748: move $16, $23
749: .loc 2 254
750: # 254 lmul(word_v(ma,1),word_v(mb,-1),ml, mh);
751: lw $2, -4($30)
752: lw $3, 4($22)
753: multu $2, $3
754: mflo $9
755: mfhi $10
756: .loc 2 255
757: # 255 al = ah+ carryl;
758: addu $4, $12, $19
759: move $8, $4
760: .loc 2 256
761: # 256 carryl = carryh + (al < ah);
762: sltu $14, $4, $12
763: addu $19, $18, $14
764: .loc 2 257
765: # 257 ah = 0;
766: move $12, $0
767: .loc 2 258
768: # 258 carryh = 0;
769: move $18, $0
770: .loc 2 259
771: # 259 j = amax - amin;
772: lw $15, 72($sp)
773: lw $24, 164($sp)
774: subu $25, $21, $24
775: subu $5, $15, $25
776: addu $5, $5, -1
777: move $31, $5
778: .loc 2 260
779: # 260 k = j & 3;
780: .loc 2 261
781: # 261 while (k--) {
782: and $6, $5, 3
783: addu $17, $6, -1
784: beq $6, $0, $57
785: $56:
786: .loc 2 262
787: # 262 lmul( *ma, *mb, nml, nmh);
788: lw $2, 0($13)
789: lw $3, 0($16)
790: multu $2, $3
791: .loc 2 263
792: # 263 al += ml;
793: addu $8, $8, $9
794: .loc 2 264
795: # 264 carryl += (al < ml);
796: sltu $14, $8, $9
797: addu $19, $19, $14
798: .loc 2 265
799: # 265 ah += mh;
800: addu $12, $12, $10
801: .loc 2 266
802: # 266 carryh += (ah < mh);
803: sltu $24, $12, $10
804: addu $18, $18, $24
805: .loc 2 267
806: # 267 post_lowerunit(ma);
807: addu $13, $13, -4
808: .loc 2 268
809: # 268 post_higherunit(mb);
810: addu $16, $16, 4
811: .loc 2 269
812: # 269 ml = nml;
813: mflo $9
814: .loc 2 270
815: # 270 mh = nmh;
816: mfhi $10
817: .loc 2 271
818: # 271 }
819: .loc 2 271
820: move $11, $17
821: addu $17, $17, -1
822: bne $11, 0, $56
823: $57:
824: .loc 2 272
825: # 272 k = j >> 2;
826: .loc 2 273
827: # 273 while (k--) {
828: sra $2, $31, 2
829: addu $17, $2, -1
830: beq $2, $0, $59
831: $58:
832: .loc 2 274
833: # 274 lmul( word_v(ma,0), word_v(mb,0), nml, nmh);
834: lw $2, 0($13)
835: lw $3, 0($16)
836: multu $2, $3
837: .loc 2 275
838: # 275 al += ml;
839: addu $8, $8, $9
840: .loc 2 276
841: # 276 carryl += (al < ml);
842: sltu $15, $8, $9
843: addu $19, $19, $15
844: .loc 2 277
845: # 277 ah += mh;
846: addu $12, $12, $10
847: .loc 2 278
848: # 278 carryh += (ah < mh);
849: sltu $25, $12, $10
850: addu $18, $18, $25
851: .loc 2 279
852: # 279 ml = nml;
853: mflo $9
854: .loc 2 280
855: # 280 mh = nmh;
856: mfhi $10
857: .loc 2 282
858: # 281
859: # 282 lmul( word_v(ma,-1), word_v(mb,1), nml, nmh);
860: lw $4, -4($13)
861: lw $5, 4($16)
862: multu $4, $5
863: .loc 2 283
864: # 283 al += ml;
865: addu $8, $8, $9
866: .loc 2 284
867: # 284 carryl += (al < ml);
868: sltu $14, $8, $9
869: addu $19, $19, $14
870: .loc 2 285
871: # 285 ah += mh;
872: addu $12, $12, $10
873: .loc 2 286
874: # 286 carryh += (ah < mh);
875: sltu $24, $12, $10
876: addu $18, $18, $24
877: .loc 2 287
878: # 287 ml = nml;
879: mflo $9
880: .loc 2 288
881: # 288 mh = nmh;
882: mfhi $10
883: .loc 2 290
884: # 289
885: # 290 lmul( word_v(ma,-2), word_v(mb,2), nml, nmh);
886: lw $2, -8($13)
887: lw $3, 8($16)
888: multu $2, $3
889: .loc 2 291
890: # 291 al += ml;
891: addu $8, $8, $9
892: .loc 2 292
893: # 292 carryl += (al < ml);
894: sltu $15, $8, $9
895: addu $19, $19, $15
896: .loc 2 293
897: # 293 ah += mh;
898: addu $12, $12, $10
899: .loc 2 294
900: # 294 carryh += (ah < mh);
901: sltu $25, $12, $10
902: addu $18, $18, $25
903: .loc 2 295
904: # 295 ml = nml;
905: mflo $9
906: .loc 2 296
907: # 296 mh = nmh;
908: mfhi $10
909: .loc 2 298
910: # 297
911: # 298 lmul( word_v(ma,-3), word_v(mb,3), nml, nmh);
912: lw $4, -12($13)
913: lw $5, 12($16)
914: multu $4, $5
915: .loc 2 299
916: # 299 al += ml;
917: addu $8, $8, $9
918: .loc 2 300
919: # 300 carryl += (al < ml);
920: sltu $14, $8, $9
921: addu $19, $19, $14
922: .loc 2 301
923: # 301 ah += mh;
924: addu $12, $12, $10
925: .loc 2 302
926: # 302 carryh += (ah < mh);
927: sltu $24, $12, $10
928: addu $18, $18, $24
929: .loc 2 303
930: # 303 ml = nml;
931: mflo $9
932: .loc 2 304
933: # 304 mh = nmh;
934: mfhi $10
935: .loc 2 306
936: # 305
937: # 306 nlowerunit(ma,4);
938: addu $13, $13, -16
939: .loc 2 307
940: # 307 nhigherunit(mb,4);
941: addu $16, $16, 16
942: .loc 2 308
943: # 308 }
944: .loc 2 308
945: move $11, $17
946: addu $17, $17, -1
947: bne $11, 0, $58
948: $59:
949: .loc 2 310
950: # 309
951: # 310 al += ml;
952: addu $8, $8, $9
953: .loc 2 311
954: # 311 carryl += (al < ml);
955: sltu $15, $8, $9
956: addu $19, $19, $15
957: .loc 2 312
958: # 312 *pp = al;
959: sw $8, 0($20)
960: .loc 2 313
961: # 313 ah += mh;
962: addu $12, $12, $10
963: .loc 2 314
964: # 314 carryh += (ah < mh);
965: sltu $25, $12, $10
966: addu $18, $18, $25
967: .loc 2 315
968: # 315 post_higherunit(pp);
969: addu $20, $20, 4
970: .loc 2 316
971: # 316 }
972: .loc 2 316
973: addu $21, $21, 1
974: addu $22, $22, 4
975: addu $23, $23, 4
976: lw $14, 68($sp)
977: blt $21, $14, $55
978: $60:
979: .loc 2 317
980: # 317 al = ah + carryl;
981: .loc 2 318
982: # 318 carryh += (al < ah);
983: .loc 2 319
984: # 319 *pp = al;
985: addu $24, $12, $19
986: sw $24, 0($20)
987: .loc 2 320
988: # 320 }
989: $61:
990: ld $16, 0($sp)
991: ld $18, 8($sp)
992: ld $20, 16($sp)
993: ld $22, 24($sp)
994: ld $30, 32($sp)
995: addu $sp, 168
996: j $31
997: .end p_dmul
998: #endif
999:
1000: #if defined(MIPSEB) && !defined(MIPSEL)
1001: .verstamp 2 10
1002: .extern global_precision 2
1003: .text
1004: .align 2
1005: .file 2 "ndmulprotoEB.c"
1006: .globl p_dmul
1007: .loc 2 69
1008: # 69 {
1009: .ent p_dmul 2
1010: p_dmul:
1011: .option O2
1012: subu $sp, 168
1013: sd $30, 32($sp)
1014: sd $22, 24($sp)
1015: sd $20, 16($sp)
1016: sd $18, 8($sp)
1017: sd $16, 0($sp)
1018: .mask 0xC0FF0000, -132
1019: .frame $sp, 168, $31
1020: sw $5, 172($sp)
1021: sw $6, 176($sp)
1022: .loc 2 76
1023: # 76 preca = global_precision;
1024: lh $14, global_precision
1025: sw $14, 164($sp)
1026: .loc 2 77
1027: # 77 pp=msbptr(multiplicand,preca);
1028: .loc 2 78
1029: # 78 while(*post_lowerunit(pp) == 0 && preca > 0) preca--;
1030: lw $15, 172($sp)
1031: lw $11, 0($15)
1032: addu $20, $15, 4
1033: bne $11, 0, $33
1034: ble $14, 0, $33
1035: $32:
1036: lw $24, 164($sp)
1037: addu $25, $24, -1
1038: sw $25, 164($sp)
1039: lw $11, 0($20)
1040: addu $20, $20, 4
1041: bne $11, 0, $33
1042: bgt $25, 0, $32
1043: $33:
1044: .loc 2 80
1045: # 79
1046: # 80 precb = global_precision;
1047: lh $15, global_precision
1048: sw $15, 160($sp)
1049: .loc 2 81
1050: # 81 pp = msbptr(multiplier,precb);
1051: .loc 2 82
1052: # 82 while(*post_lowerunit(pp) == 0 && precb > 0) precb--;
1053: lw $14, 176($sp)
1054: lw $11, 0($14)
1055: addu $20, $14, 4
1056: bne $11, 0, $35
1057: ble $15, 0, $35
1058: $34:
1059: lw $24, 160($sp)
1060: addu $25, $24, -1
1061: sw $25, 160($sp)
1062: lw $11, 0($20)
1063: addu $20, $20, 4
1064: bne $11, 0, $35
1065: bgt $25, 0, $34
1066: $35:
1067: .loc 2 84
1068: # 83
1069: # 84 prec2 = global_precision<<1;
1070: lh $3, global_precision
1071: sll $3, $3, 1
1072: move $2, $3
1073: .loc 2 86
1074: # 85
1075: # 86 pp = msbptr(prod,prec2);
1076: move $20, $4
1077: .loc 2 87
1078: # 87 for (i= preca+precb; i < prec2 ; i++) {
1079: lw $14, 164($sp)
1080: lw $15, 160($sp)
1081: addu $24, $14, $15
1082: sw $24, 72($sp)
1083: move $21, $24
1084: bge $24, $3, $37
1085: $36:
1086: .loc 2 88
1087: # 88 *post_lowerunit(pp) = 0;
1088: sw $0, 0($20)
1089: addu $20, $20, 4
1090: .loc 2 89
1091: # 89 }
1092: .loc 2 89
1093: addu $21, $21, 1
1094: blt $21, $2, $36
1095: $37:
1096: .loc 2 90
1097: # 90 if (preca == 0 || precb == 0) {
1098: lw $25, 164($sp)
1099: beq $25, 0, $38
1100: lw $14, 160($sp)
1101: bne $14, 0, $41
1102: $38:
1103: .loc 2 91
1104: # 91 pp = lsbptr(prod,prec2);
1105: mul $15, $2, 4
1106: addu $20, $4, $15
1107: addu $20, $20, -4
1108: .loc 2 92
1109: # 92 for (i=0; i < preca + precb; i++)
1110: move $21, $0
1111: lw $24, 72($sp)
1112: ble $24, 0, $61
1113: and $2, $24, 3
1114: beq $2, 0, $40
1115: $39:
1116: sw $0, 0($20)
1117: addu $20, $20, -4
1118: addu $21, $21, 1
1119: bne $2, $21, $39
1120: lw $25, 72($sp)
1121: beq $21, $25, $61
1122: $40:
1123: .loc 2 93
1124: # 93 *(post_higherunit(pp)) = 0;
1125: sw $0, 0($20)
1126: addu $20, $20, -4
1127: sw $0, 0($20)
1128: addu $20, $20, -4
1129: sw $0, 0($20)
1130: addu $20, $20, -4
1131: sw $0, 0($20)
1132: addu $20, $20, -4
1133: addu $21, $21, 4
1134: lw $14, 72($sp)
1135: bne $21, $14, $40
1136: .loc 2 94
1137: # 94 return;
1138: b $61
1139: $41:
1140: .loc 2 97
1141: # 95 }
1142: # 96 /* Canonicalize length(a) >= length(b) */
1143: # 97 if (preca < precb) {
1144: lw $15, 164($sp)
1145: lw $24, 160($sp)
1146: bge $15, $24, $42
1147: .loc 2 98
1148: # 98 pp = multiplicand;
1149: lw $20, 172($sp)
1150: .loc 2 99
1151: # 99 multiplicand = multiplier;
1152: lw $25, 176($sp)
1153: sw $25, 172($sp)
1154: .loc 2 100
1155: # 100 multiplier = pp;
1156: sw $20, 176($sp)
1157: .loc 2 101
1158: # 101 i = preca;
1159: move $21, $15
1160: .loc 2 102
1161: # 102 preca = precb;
1162: sw $24, 164($sp)
1163: .loc 2 103
1164: # 103 precb = i;
1165: sw $21, 160($sp)
1166: .loc 2 104
1167: # 104 }
1168: lw $14, 164($sp)
1169: lw $25, 160($sp)
1170: addu $15, $14, $25
1171: sw $15, 72($sp)
1172: $42:
1173: .loc 2 105
1174: # 105 make_lsbptr(multiplicand, global_precision);
1175: lh $3, global_precision
1176: mul $3, $3, 4
1177: lw $24, 172($sp)
1178: addu $14, $24, $3
1179: addu $25, $14, -4
1180: sw $25, 172($sp)
1181: .loc 2 106
1182: # 106 make_lsbptr(multiplier, global_precision);
1183: lw $15, 176($sp)
1184: addu $24, $15, $3
1185: addu $14, $24, -4
1186: sw $14, 176($sp)
1187: .loc 2 107
1188: # 107 pp = lsbptr(prod,prec2);
1189: mul $15, $2, 4
1190: addu $20, $4, $15
1191: addu $20, $20, -4
1192: .loc 2 108
1193: # 108 ah = 0;
1194: move $12, $0
1195: .loc 2 109
1196: # 109 carryl = 0;
1197: move $19, $0
1198: .loc 2 110
1199: # 110 carryh =0;
1200: move $18, $0
1201: .loc 2 111
1202: # 111 al = 0;
1203: .loc 2 114
1204: # 112
1205: # 113
1206: # 114 amin = 0;
1207: .loc 2 115
1208: # 115 for (i=0; i < precb; i++) {
1209: move $21, $0
1210: lw $24, 160($sp)
1211: ble $24, 0, $48
1212: move $23, $25
1213: addu $30, $23, 4
1214: addu $15, $14, -4
1215: sw $15, 56($sp)
1216: $43:
1217: .loc 2 116
1218: # 116 amax = i;
1219: .loc 2 117
1220: # 117 ma = word_index(multiplicand,i -1);
1221: move $13, $30
1222: .loc 2 118
1223: # 118 mb = word_index(multiplier,1);
1224: lw $16, 56($sp)
1225: .loc 2 119
1226: # 119 lmul(word_v(ma,1),word_v(mb,-1),ml, mh);
1227: lw $3, 0($23)
1228: lw $24, 176($sp)
1229: lw $2, 0($24)
1230: multu $3,$2
1231: mflo $9
1232: mfhi $10
1233: .loc 2 120
1234: # 120 al = ah+ carryl;
1235: addu $4, $12, $19
1236: move $8, $4
1237: .loc 2 121
1238: # 121 carryl = carryh + (al < ah);
1239: sltu $25, $4, $12
1240: addu $19, $18, $25
1241: .loc 2 122
1242: # 122 ah = 0;
1243: move $12, $0
1244: .loc 2 123
1245: # 123 carryh = 0;
1246: move $18, $0
1247: .loc 2 124
1248: # 124 j = amax - amin;
1249: move $5, $21
1250: move $31, $5
1251: .loc 2 125
1252: # 125 k = j & 3;
1253: .loc 2 126
1254: # 126 while (k--) {
1255: and $6, $5, 3
1256: addu $17, $6, -1
1257: beq $6, $0, $45
1258: $44:
1259: .loc 2 127
1260: # 127 lmul( *ma, *mb, nml, nmh);
1261: lw $2, 0($13)
1262: lw $3, 0($16)
1263: multu $2, $3
1264: .loc 2 128
1265: # 128 al += ml;
1266: addu $8, $8, $9
1267: .loc 2 129
1268: # 129 carryl += (al < ml);
1269: sltu $14, $8, $9
1270: addu $19, $19, $14
1271: .loc 2 130
1272: # 130 ah += mh;
1273: addu $12, $12, $10
1274: .loc 2 131
1275: # 131 carryh += (ah < mh);
1276: sltu $15, $12, $10
1277: addu $18, $18, $15
1278: .loc 2 132
1279: # 132 post_lowerunit(ma);
1280: addu $13, $13, 4
1281: .loc 2 133
1282: # 133 post_higherunit(mb);
1283: addu $16, $16, -4
1284: .loc 2 134
1285: # 134 ml = nml;
1286: mflo $9
1287: .loc 2 135
1288: # 135 mh = nmh;
1289: mfhi $10
1290: .loc 2 136
1291: # 136 }
1292: .loc 2 136
1293: move $11, $17
1294: addu $17, $17, -1
1295: bne $11, 0, $44
1296: $45:
1297: .loc 2 137
1298: # 137 k = j >> 2;
1299: .loc 2 138
1300: # 138 while (k--) {
1301: sra $2, $31, 2
1302: addu $17, $2, -1
1303: beq $2, $0, $47
1304: $46:
1305: .loc 2 139
1306: # 139 lmul( word_v(ma,0), word_v(mb,0), nml, nmh);
1307: lw $2, 0($13)
1308: lw $3, 0($16)
1309: multu $2, $3
1310: .loc 2 140
1311: # 140 al += ml;
1312: addu $8, $8, $9
1313: .loc 2 141
1314: # 141 carryl += (al < ml);
1315: sltu $24, $8, $9
1316: addu $19, $19, $24
1317: .loc 2 142
1318: # 142 ah += mh;
1319: addu $12, $12, $10
1320: .loc 2 143
1321: # 143 carryh += (ah < mh);
1322: sltu $25, $12, $10
1323: addu $18, $18, $25
1324: .loc 2 144
1325: # 144 ml = nml;
1326: mflo $9
1327: .loc 2 145
1328: # 145 mh = nmh;
1329: mfhi $10
1330: .loc 2 147
1331: # 146
1332: # 147 lmul( word_v(ma,-1), word_v(mb,1), nml, nmh);
1333: lw $4, 4($13)
1334: lw $5, -4($16)
1335: multu $4, $5
1336: .loc 2 148
1337: # 148 al += ml;
1338: addu $8, $8, $9
1339: .loc 2 149
1340: # 149 carryl += (al < ml);
1341: sltu $14, $8, $9
1342: addu $19, $19, $14
1343: .loc 2 150
1344: # 150 ah += mh;
1345: addu $12, $12, $10
1346: .loc 2 151
1347: # 151 carryh += (ah < mh);
1348: sltu $15, $12, $10
1349: addu $18, $18, $15
1350: .loc 2 152
1351: # 152 ml = nml;
1352: mflo $9
1353: .loc 2 153
1354: # 153 mh = nmh;
1355: mfhi $10
1356: .loc 2 155
1357: # 154
1358: # 155 lmul( word_v(ma,-2), word_v(mb,2), nml, nmh);
1359: lw $2, 8($13)
1360: lw $3, -8($16)
1361: multu $2, $3
1362: .loc 2 156
1363: # 156 al += ml;
1364: addu $8, $8, $9
1365: .loc 2 157
1366: # 157 carryl += (al < ml);
1367: sltu $24, $8, $9
1368: addu $19, $19, $24
1369: .loc 2 158
1370: # 158 ah += mh;
1371: addu $12, $12, $10
1372: .loc 2 159
1373: # 159 carryh += (ah < mh);
1374: sltu $25, $12, $10
1375: addu $18, $18, $25
1376: .loc 2 160
1377: # 160 ml = nml;
1378: mflo $9
1379: .loc 2 161
1380: # 161 mh = nmh;
1381: mfhi $10
1382: .loc 2 163
1383: # 162
1384: # 163 lmul( word_v(ma,-3), word_v(mb,3), nml, nmh);
1385: lw $4, 12($13)
1386: lw $5, -12($16)
1387: multu $4, $5
1388: .loc 2 164
1389: # 164 al += ml;
1390: addu $8, $8, $9
1391: .loc 2 165
1392: # 165 carryl += (al < ml);
1393: sltu $14, $8, $9
1394: addu $19, $19, $14
1395: .loc 2 166
1396: # 166 ah += mh;
1397: addu $12, $12, $10
1398: .loc 2 167
1399: # 167 carryh += (ah < mh);
1400: sltu $15, $12, $10
1401: addu $18, $18, $15
1402: .loc 2 168
1403: # 168 ml = nml;
1404: mflo $9
1405: .loc 2 169
1406: # 169 mh = nmh;
1407: mfhi $10
1408: .loc 2 171
1409: # 170
1410: # 171 nlowerunit(ma,4); nhigherunit(mb,4);
1411: addu $13, $13, 16
1412: addu $16, $16, -16
1413: .loc 2 173
1414: # 172
1415: # 173 }
1416: .loc 2 173
1417: move $11, $17
1418: addu $17, $17, -1
1419: bne $11, 0, $46
1420: $47:
1421: .loc 2 175
1422: # 174
1423: # 175 al += ml;
1424: addu $8, $8, $9
1425: .loc 2 176
1426: # 176 carryl += (al < ml);
1427: sltu $24, $8, $9
1428: addu $19, $19, $24
1429: .loc 2 177
1430: # 177 *pp = al;
1431: sw $8, 0($20)
1432: .loc 2 178
1433: # 178 ah += mh;
1434: addu $12, $12, $10
1435: .loc 2 179
1436: # 179 carryh += (ah < mh);
1437: sltu $25, $12, $10
1438: addu $18, $18, $25
1439: .loc 2 180
1440: # 180 post_higherunit(pp);
1441: addu $20, $20, -4
1442: .loc 2 181
1443: # 181 }
1444: .loc 2 181
1445: addu $21, $21, 1
1446: addu $23, $23, -4
1447: addu $30, $30, -4
1448: lw $14, 160($sp)
1449: bne $21, $14, $43
1450: $48:
1451: .loc 2 182
1452: # 182 amax = precb-1;
1453: .loc 2 183
1454: # 183 for (i=precb; i < preca; i++) {
1455: lw $15, 160($sp)
1456: move $21, $15
1457: lw $24, 164($sp)
1458: bge $15, $24, $54
1459: negu $22, $21
1460: mul $22, $22, 4
1461: lw $25, 172($sp)
1462: addu $23, $25, $22
1463: addu $30, $23, 4
1464: lw $14, 176($sp)
1465: addu $25, $14, -4
1466: sw $25, 56($sp)
1467: mul $14, $24, -4
1468: sw $14, 52($sp)
1469: addu $2, $15, -1
1470: move $31, $2
1471: and $25, $2, 3
1472: sw $25, 44($sp)
1473: addu $24, $25, -1
1474: sw $24, 40($sp)
1475: $49:
1476: .loc 2 184
1477: # 184 ma = word_index( multiplicand,i-1);
1478: move $13, $30
1479: .loc 2 185
1480: # 185 mb = word_index(multiplier,1);
1481: lw $16, 56($sp)
1482: .loc 2 186
1483: # 186 lmul(word_v(ma,1),word_v(mb,-1),ml, mh);
1484: lw $3, 0($23)
1485: lw $14, 176($sp)
1486: lw $2, 0($14)
1487: multu $3,$2
1488: mflo $9
1489: mfhi $10
1490: .loc 2 187
1491: # 187 al = ah+ carryl;
1492: addu $4, $12, $19
1493: move $8, $4
1494: .loc 2 188
1495: # 188 carryl = carryh + (al < ah);
1496: sltu $15, $4, $12
1497: addu $19, $18, $15
1498: .loc 2 189
1499: # 189 ah = 0;
1500: move $12, $0
1501: .loc 2 190
1502: # 190 carryh = 0;
1503: move $18, $0
1504: .loc 2 191
1505: # 191 j = amax - amin;
1506: .loc 2 192
1507: # 192 k = j & 3;
1508: .loc 2 193
1509: # 193 while (k--) {
1510: lw $17, 40($sp)
1511: lw $25, 44($sp)
1512: beq $25, $0, $51
1513: $50:
1514: .loc 2 194
1515: # 194 lmul( *ma, *mb, nml, nmh);
1516: lw $2, 0($13)
1517: lw $3, 0($16)
1518: multu $2, $3
1519: .loc 2 195
1520: # 195 al += ml;
1521: addu $8, $8, $9
1522: .loc 2 196
1523: # 196 carryl += (al < ml);
1524: sltu $24, $8, $9
1525: addu $19, $19, $24
1526: .loc 2 197
1527: # 197 ah += mh;
1528: addu $12, $12, $10
1529: .loc 2 198
1530: # 198 carryh += (ah < mh);
1531: sltu $14, $12, $10
1532: addu $18, $18, $14
1533: .loc 2 199
1534: # 199 post_lowerunit(ma);
1535: addu $13, $13, 4
1536: .loc 2 200
1537: # 200 post_higherunit(mb);
1538: addu $16, $16, -4
1539: .loc 2 201
1540: # 201 ml = nml;
1541: mflo $9
1542: .loc 2 202
1543: # 202 mh = nmh;
1544: mfhi $10
1545: .loc 2 203
1546: # 203 }
1547: .loc 2 203
1548: move $11, $17
1549: addu $17, $17, -1
1550: bne $11, 0, $50
1551: $51:
1552: .loc 2 204
1553: # 204 k = j >> 2;
1554: .loc 2 205
1555: # 205 while (k--) {
1556: sra $2, $31, 2
1557: addu $17, $2, -1
1558: beq $2, $0, $53
1559: $52:
1560: .loc 2 206
1561: # 206 lmul( word_v(ma,0), word_v(mb,0), nml, nmh);
1562: lw $2, 0($13)
1563: lw $3, 0($16)
1564: multu $2, $3
1565: .loc 2 207
1566: # 207 al += ml;
1567: addu $8, $8, $9
1568: .loc 2 208
1569: # 208 carryl += (al < ml);
1570: sltu $15, $8, $9
1571: addu $19, $19, $15
1572: .loc 2 209
1573: # 209 ah += mh;
1574: addu $12, $12, $10
1575: .loc 2 210
1576: # 210 carryh += (ah < mh);
1577: sltu $25, $12, $10
1578: addu $18, $18, $25
1579: .loc 2 211
1580: # 211 ml = nml;
1581: mflo $9
1582: .loc 2 212
1583: # 212 mh = nmh;
1584: mfhi $10
1585: .loc 2 214
1586: # 213
1587: # 214 lmul( word_v(ma,-1), word_v(mb,1), nml, nmh);
1588: lw $4, 4($13)
1589: lw $5, -4($16)
1590: multu $4, $5
1591: .loc 2 215
1592: # 215 al += ml;
1593: addu $8, $8, $9
1594: .loc 2 216
1595: # 216 carryl += (al < ml);
1596: sltu $24, $8, $9
1597: addu $19, $19, $24
1598: .loc 2 217
1599: # 217 ah += mh;
1600: addu $12, $12, $10
1601: .loc 2 218
1602: # 218 carryh += (ah < mh);
1603: sltu $14, $12, $10
1604: addu $18, $18, $14
1605: .loc 2 219
1606: # 219 ml = nml;
1607: mflo $9
1608: .loc 2 220
1609: # 220 mh = nmh;
1610: mfhi $10
1611: .loc 2 222
1612: # 221
1613: # 222 lmul( word_v(ma,-2), word_v(mb,2), nml, nmh);
1614: lw $2, 8($13)
1615: lw $3, -8($16)
1616: multu $2, $3
1617: .loc 2 223
1618: # 223 al += ml;
1619: addu $8, $8, $9
1620: .loc 2 224
1621: # 224 carryl += (al < ml);
1622: sltu $15, $8, $9
1623: addu $19, $19, $15
1624: .loc 2 225
1625: # 225 ah += mh;
1626: addu $12, $12, $10
1627: .loc 2 226
1628: # 226 carryh += (ah < mh);
1629: sltu $25, $12, $10
1630: addu $18, $18, $25
1631: .loc 2 227
1632: # 227 ml = nml;
1633: mflo $9
1634: .loc 2 228
1635: # 228 mh = nmh;
1636: mfhi $10
1637: .loc 2 230
1638: # 229
1639: # 230 lmul( word_v(ma,-3), word_v(mb,3), nml, nmh);
1640: lw $4, 12($13)
1641: lw $5, -12($16)
1642: multu $4, $5
1643: .loc 2 231
1644: # 231 al += ml;
1645: addu $8, $8, $9
1646: .loc 2 232
1647: # 232 carryl += (al < ml);
1648: sltu $24, $8, $9
1649: addu $19, $19, $24
1650: .loc 2 233
1651: # 233 ah += mh;
1652: addu $12, $12, $10
1653: .loc 2 234
1654: # 234 carryh += (ah < mh);
1655: sltu $14, $12, $10
1656: addu $18, $18, $14
1657: .loc 2 235
1658: # 235 ml = nml;
1659: mflo $9
1660: .loc 2 236
1661: # 236 mh = nmh;
1662: mfhi $10
1663: .loc 2 238
1664: # 237
1665: # 238 nlowerunit(ma,4);
1666: addu $13, $13, 16
1667: .loc 2 239
1668: # 239 nhigherunit(mb,4);
1669: addu $16, $16, -16
1670: .loc 2 240
1671: # 240 }
1672: .loc 2 240
1673: move $11, $17
1674: addu $17, $17, -1
1675: bne $11, 0, $52
1676: $53:
1677: .loc 2 242
1678: # 241
1679: # 242 al += ml;
1680: addu $8, $8, $9
1681: .loc 2 243
1682: # 243 carryl += (al < ml);
1683: sltu $15, $8, $9
1684: addu $19, $19, $15
1685: .loc 2 244
1686: # 244 *pp = al;
1687: sw $8, 0($20)
1688: .loc 2 245
1689: # 245 ah += mh;
1690: addu $12, $12, $10
1691: .loc 2 246
1692: # 246 carryh += (ah < mh);
1693: sltu $25, $12, $10
1694: addu $18, $18, $25
1695: .loc 2 247
1696: # 247 post_higherunit(pp);
1697: addu $20, $20, -4
1698: .loc 2 248
1699: # 248 }
1700: .loc 2 248
1701: addu $22, $22, -4
1702: addu $23, $23, -4
1703: addu $30, $30, -4
1704: lw $24, 52($sp)
1705: blt $24, $22, $49
1706: $54:
1707: .loc 2 249
1708: # 249 amax = precb-1;
1709: .loc 2 250
1710: # 250 for (i=preca; i < preca + precb -1; i++) {
1711: lw $14, 164($sp)
1712: move $21, $14
1713: lw $15, 72($sp)
1714: addu $25, $15, -1
1715: sw $25, 68($sp)
1716: bge $14, $25, $60
1717: lw $24, 160($sp)
1718: addu $15, $24, -1
1719: sw $15, 72($sp)
1720: negu $2, $14
1721: lw $25, 172($sp)
1722: mul $24, $2, 4
1723: addu $30, $25, $24
1724: addu $15, $30, 8
1725: sw $15, 56($sp)
1726: lw $14, 176($sp)
1727: addu $25, $2, $21
1728: negu $24, $25
1729: mul $15, $24, 4
1730: addu $22, $14, $15
1731: addu $23, $22, -8
1732: $55:
1733: .loc 2 251
1734: # 251 amin = i-preca + 1;
1735: .loc 2 252
1736: # 252 ma = word_index(multiplicand,preca-2);
1737: lw $13, 56($sp)
1738: .loc 2 253
1739: # 253 mb = word_index(multiplier, - preca + 2 +i) ;
1740: move $16, $23
1741: .loc 2 254
1742: # 254 lmul(word_v(ma,1),word_v(mb,-1),ml, mh);
1743: lw $2, 4($30)
1744: lw $3, -4($22)
1745: multu $3,$2
1746: mflo $9
1747: mfhi $10
1748: .loc 2 255
1749: # 255 al = ah+ carryl;
1750: addu $4, $12, $19
1751: move $8, $4
1752: .loc 2 256
1753: # 256 carryl = carryh + (al < ah);
1754: sltu $25, $4, $12
1755: addu $19, $18, $25
1756: .loc 2 257
1757: # 257 ah = 0;
1758: move $12, $0
1759: .loc 2 258
1760: # 258 carryh = 0;
1761: move $18, $0
1762: .loc 2 259
1763: # 259 j = amax - amin;
1764: lw $24, 72($sp)
1765: lw $14, 164($sp)
1766: subu $15, $21, $14
1767: subu $5, $24, $15
1768: addu $5, $5, -1
1769: move $31, $5
1770: .loc 2 260
1771: # 260 k = j & 3;
1772: .loc 2 261
1773: # 261 while (k--) {
1774: and $6, $5, 3
1775: addu $17, $6, -1
1776: beq $6, $0, $57
1777: $56:
1778: .loc 2 262
1779: # 262 lmul( *ma, *mb, nml, nmh);
1780: lw $2, 0($13)
1781: lw $3, 0($16)
1782: multu $2, $3
1783: .loc 2 263
1784: # 263 al += ml;
1785: addu $8, $8, $9
1786: .loc 2 264
1787: # 264 carryl += (al < ml);
1788: sltu $25, $8, $9
1789: addu $19, $19, $25
1790: .loc 2 265
1791: # 265 ah += mh;
1792: addu $12, $12, $10
1793: .loc 2 266
1794: # 266 carryh += (ah < mh);
1795: sltu $14, $12, $10
1796: addu $18, $18, $14
1797: .loc 2 267
1798: # 267 post_lowerunit(ma);
1799: addu $13, $13, 4
1800: .loc 2 268
1801: # 268 post_higherunit(mb);
1802: addu $16, $16, -4
1803: .loc 2 269
1804: # 269 ml = nml;
1805: mflo $9
1806: .loc 2 270
1807: # 270 mh = nmh;
1808: mfhi $10
1809: .loc 2 271
1810: # 271 }
1811: .loc 2 271
1812: move $11, $17
1813: addu $17, $17, -1
1814: bne $11, 0, $56
1815: $57:
1816: .loc 2 272
1817: # 272 k = j >> 2;
1818: .loc 2 273
1819: # 273 while (k--) {
1820: sra $2, $31, 2
1821: addu $17, $2, -1
1822: beq $2, $0, $59
1823: $58:
1824: .loc 2 274
1825: # 274 lmul( word_v(ma,0), word_v(mb,0), nml, nmh);
1826: lw $2, 0($13)
1827: lw $3, 0($16)
1828: multu $2, $3
1829: .loc 2 275
1830: # 275 al += ml;
1831: addu $8, $8, $9
1832: .loc 2 276
1833: # 276 carryl += (al < ml);
1834: sltu $24, $8, $9
1835: addu $19, $19, $24
1836: .loc 2 277
1837: # 277 ah += mh;
1838: addu $12, $12, $10
1839: .loc 2 278
1840: # 278 carryh += (ah < mh);
1841: sltu $15, $12, $10
1842: addu $18, $18, $15
1843: .loc 2 279
1844: # 279 ml = nml;
1845: mflo $9
1846: .loc 2 280
1847: # 280 mh = nmh;
1848: mfhi $10
1849: .loc 2 282
1850: # 281
1851: # 282 lmul( word_v(ma,-1), word_v(mb,1), nml, nmh);
1852: lw $4, 4($13)
1853: lw $5, -4($16)
1854: multu $4, $5
1855: .loc 2 283
1856: # 283 al += ml;
1857: addu $8, $8, $9
1858: .loc 2 284
1859: # 284 carryl += (al < ml);
1860: sltu $25, $8, $9
1861: addu $19, $19, $25
1862: .loc 2 285
1863: # 285 ah += mh;
1864: addu $12, $12, $10
1865: .loc 2 286
1866: # 286 carryh += (ah < mh);
1867: sltu $14, $12, $10
1868: addu $18, $18, $14
1869: .loc 2 287
1870: # 287 ml = nml;
1871: mflo $9
1872: .loc 2 288
1873: # 288 mh = nmh;
1874: mfhi $10
1875: .loc 2 290
1876: # 289
1877: # 290 lmul( word_v(ma,-2), word_v(mb,2), nml, nmh);
1878: lw $2, 8($13)
1879: lw $3, -8($16)
1880: multu $2, $3
1881: .loc 2 291
1882: # 291 al += ml;
1883: addu $8, $8, $9
1884: .loc 2 292
1885: # 292 carryl += (al < ml);
1886: sltu $24, $8, $9
1887: addu $19, $19, $24
1888: .loc 2 293
1889: # 293 ah += mh;
1890: addu $12, $12, $10
1891: .loc 2 294
1892: # 294 carryh += (ah < mh);
1893: sltu $15, $12, $10
1894: addu $18, $18, $15
1895: .loc 2 295
1896: # 295 ml = nml;
1897: mflo $9
1898: .loc 2 296
1899: # 296 mh = nmh;
1900: mfhi $10
1901: .loc 2 298
1902: # 297
1903: # 298 lmul( word_v(ma,-3), word_v(mb,3), nml, nmh);
1904: lw $4, 12($13)
1905: lw $5, -12($16)
1906: multu $4, $5
1907: .loc 2 299
1908: # 299 al += ml;
1909: addu $8, $8, $9
1910: .loc 2 300
1911: # 300 carryl += (al < ml);
1912: sltu $25, $8, $9
1913: addu $19, $19, $25
1914: .loc 2 301
1915: # 301 ah += mh;
1916: addu $12, $12, $10
1917: .loc 2 302
1918: # 302 carryh += (ah < mh);
1919: sltu $14, $12, $10
1920: addu $18, $18, $14
1921: .loc 2 303
1922: # 303 ml = nml;
1923: mflo $9
1924: .loc 2 304
1925: # 304 mh = nmh;
1926: mfhi $10
1927: .loc 2 306
1928: # 305
1929: # 306 nlowerunit(ma,4);
1930: addu $13, $13, 16
1931: .loc 2 307
1932: # 307 nhigherunit(mb,4);
1933: addu $16, $16, -16
1934: .loc 2 308
1935: # 308 }
1936: .loc 2 308
1937: move $11, $17
1938: addu $17, $17, -1
1939: bne $11, 0, $58
1940: $59:
1941: .loc 2 310
1942: # 309
1943: # 310 al += ml;
1944: addu $8, $8, $9
1945: .loc 2 311
1946: # 311 carryl += (al < ml);
1947: sltu $24, $8, $9
1948: addu $19, $19, $24
1949: .loc 2 312
1950: # 312 *pp = al;
1951: sw $8, 0($20)
1952: .loc 2 313
1953: # 313 ah += mh;
1954: addu $12, $12, $10
1955: .loc 2 314
1956: # 314 carryh += (ah < mh);
1957: sltu $15, $12, $10
1958: addu $18, $18, $15
1959: .loc 2 315
1960: # 315 post_higherunit(pp);
1961: addu $20, $20, -4
1962: .loc 2 316
1963: # 316 }
1964: .loc 2 316
1965: addu $21, $21, 1
1966: addu $22, $22, -4
1967: addu $23, $23, -4
1968: lw $25, 68($sp)
1969: blt $21, $25, $55
1970: $60:
1971: .loc 2 317
1972: # 317 al = ah + carryl;
1973: .loc 2 318
1974: # 318 carryh += (al < ah);
1975: .loc 2 319
1976: # 319 *pp = al;
1977: addu $14, $12, $19
1978: sw $14, 0($20)
1979: .loc 2 320
1980: # 320 }
1981: $61:
1982: ld $16, 0($sp)
1983: ld $18, 8($sp)
1984: ld $20, 16($sp)
1985: ld $22, 24($sp)
1986: ld $30, 32($sp)
1987: addu $sp, 168
1988: j $31
1989: .end p_dmul
1990: #endif /* MIPSEB */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.