1 /* 32 and 64-bit millicode, original author Hewlett-Packard
2 adapted for gcc by Paul Bame <bame@debian.org>
3 and Alan Modra <alan@linuxcare.com.au>.
5 Copyright 2001, 2002, 2003, 2007, 2009 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 Under Section 7 of GPL version 3, you are granted additional
20 permissions described in the GCC Runtime Library Exception, version
21 3.1, as published by the Free Software Foundation.
23 You should have received a copy of the GNU General Public License and
24 a copy of the GCC Runtime Library Exception along with this program;
25 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
26 <http://www.gnu.org/licenses/>. */
32 /* Hardware General Registers. */
66 /* Hardware Space Registers. */
76 /* Hardware Floating Point Registers. */
94 /* Hardware Control Registers. */
96 sar: .reg %cr11 /* Shift Amount Register */
98 /* Software Architecture General Registers. */
99 rp: .reg r2 /* return pointer */
101 mrp: .reg r2 /* millicode return pointer */
103 mrp: .reg r31 /* millicode return pointer */
105 ret0: .reg r28 /* return value */
106 ret1: .reg r29 /* return value (high part of double) */
107 sp: .reg r30 /* stack pointer */
108 dp: .reg r27 /* data pointer */
109 arg0: .reg r26 /* argument */
110 arg1: .reg r25 /* argument or high part of double argument */
111 arg2: .reg r24 /* argument */
112 arg3: .reg r23 /* argument or high part of double argument */
114 /* Software Architecture Space Registers. */
115 /* sr0 ; return link from BLE */
116 sret: .reg sr1 /* return value */
117 sarg: .reg sr1 /* argument */
118 /* sr4 ; PC SPACE tracker */
119 /* sr5 ; process private data */
121 /* Frame Offsets (millicode convention!) Used when calling other
122 millicode routines. Stack unwinding is dependent upon these
124 r31_slot: .equ -20 /* "current RP" slot */
125 sr0_slot: .equ -16 /* "static link" slot */
127 mrp_slot: .equ -16 /* "current RP" slot */
128 psp_slot: .equ -8 /* "previous SP" slot */
130 mrp_slot: .equ -20 /* "current RP" slot (replacing "r31_slot") */
134 #define DEFINE(name,value)name: .EQU value
135 #define RDEFINE(name,value)name: .REG value
137 #define MILLI_BE(lbl) BE lbl(sr7,r0)
138 #define MILLI_BEN(lbl) BE,n lbl(sr7,r0)
139 #define MILLI_BLE(lbl) BLE lbl(sr7,r0)
140 #define MILLI_BLEN(lbl) BLE,n lbl(sr7,r0)
141 #define MILLIRETN BE,n 0(sr0,mrp)
142 #define MILLIRET BE 0(sr0,mrp)
143 #define MILLI_RETN BE,n 0(sr0,mrp)
144 #define MILLI_RET BE 0(sr0,mrp)
146 #define MILLI_BE(lbl) B lbl
147 #define MILLI_BEN(lbl) B,n lbl
148 #define MILLI_BLE(lbl) BL lbl,mrp
149 #define MILLI_BLEN(lbl) BL,n lbl,mrp
150 #define MILLIRETN BV,n 0(mrp)
151 #define MILLIRET BV 0(mrp)
152 #define MILLI_RETN BV,n 0(mrp)
153 #define MILLI_RET BV 0(mrp)
157 #define CAT(a,b) a##b
159 #define CAT(a,b) a/**/b
163 #define SUBSPA_MILLI .section .text
164 #define SUBSPA_MILLI_DIV .section .text.div,"ax",@progbits! .align 16
165 #define SUBSPA_MILLI_MUL .section .text.mul,"ax",@progbits! .align 16
167 #define SUBSPA_DATA .section .data
169 #define GLOBAL $global$
170 #define GSYM(sym) !sym:
171 #define LSYM(sym) !CAT(.L,sym:)
172 #define LREF(sym) CAT(.L,sym)
177 /* This used to be .milli but since link32 places different named
178 sections in different segments millicode ends up a long ways away
179 from .text (1meg?). This way they will be a lot closer.
181 The SUBSPA_MILLI_* specify locality sets for certain millicode
182 modules in order to ensure that modules that call one another are
183 placed close together. Without locality sets this is unlikely to
184 happen because of the Dynamite linker library search algorithm. We
185 want these modules close together so that short calls always reach
186 (we don't want to require long calls or use long call stubs). */
188 #define SUBSPA_MILLI .subspa .text
189 #define SUBSPA_MILLI_DIV .subspa .text$dv,align=16
190 #define SUBSPA_MILLI_MUL .subspa .text$mu,align=16
191 #define ATTR_MILLI .attr code,read,execute
192 #define SUBSPA_DATA .subspa .data
193 #define ATTR_DATA .attr init_data,read,write
196 #define SUBSPA_MILLI .subspa $MILLICODE$,QUAD=0,ALIGN=4,ACCESS=0x2c,SORT=8
197 #define SUBSPA_MILLI_DIV SUBSPA_MILLI
198 #define SUBSPA_MILLI_MUL SUBSPA_MILLI
200 #define SUBSPA_DATA .subspa $BSS$,quad=1,align=8,access=0x1f,sort=80,zero
202 #define GLOBAL $global$
204 #define SPACE_DATA .space $PRIVATE$,spnum=1,sort=16
206 #define GSYM(sym) !sym
207 #define LSYM(sym) !CAT(L$,sym)
208 #define LREF(sym) CAT(L$,sym)
215 .export $$dyncall,millicode
219 bb,>=,n %r22,30,LREF(1) ; branch if not plabel address
220 depi 0,31,2,%r22 ; clear the two least significant bits
221 ldw 4(%r22),%r19 ; load new LTP value
222 ldw 0(%r22),%r22 ; load address of target
225 bv %r0(%r22) ; branch to the real target
227 ldsid (%sr0,%r22),%r1 ; get the "space ident" selected by r22
228 mtsp %r1,%sr0 ; move that space identifier into sr0
229 be 0(%sr0,%r22) ; branch to the real target
231 stw %r2,-24(%r30) ; save return address into frame marker
237 /* ROUTINES: $$divI, $$divoI
239 Single precision divide for signed binary integers.
241 The quotient is truncated towards zero.
242 The sign of the quotient is the XOR of the signs of the dividend and
244 Divide by zero is trapped.
245 Divide of -2**31 by -1 is trapped for $$divoI but not for $$divI.
251 . sr0 == return space when called externally
258 OTHER REGISTERS AFFECTED:
262 . Causes a trap under the following conditions:
263 . divisor is zero (traps with ADDIT,= 0,25,0)
264 . dividend==-2**31 and divisor==-1 and routine is $$divoI
265 . (traps with ADDO 26,25,0)
266 . Changes memory at the following places:
271 . Suitable for internal or external millicode.
272 . Assumes the special millicode register conventions.
275 . Branchs to other millicode routines using BE
276 . $$div_# for # being 2,3,4,5,6,7,8,9,10,12,14,15
278 . For selected divisors, calls a divide by constant routine written by
279 . Karl Pettis. Eligible divisors are 1..15 excluding 11 and 13.
281 . The only overflow case is -2**31 divided by -1.
282 . Both routines return -2**31 but only $$divoI traps. */
285 RDEFINE(retreg,ret1) /* r29 */
289 .import $$divI_2,millicode
290 .import $$divI_3,millicode
291 .import $$divI_4,millicode
292 .import $$divI_5,millicode
293 .import $$divI_6,millicode
294 .import $$divI_7,millicode
295 .import $$divI_8,millicode
296 .import $$divI_9,millicode
297 .import $$divI_10,millicode
298 .import $$divI_12,millicode
299 .import $$divI_14,millicode
300 .import $$divI_15,millicode
301 .export $$divI,millicode
302 .export $$divoI,millicode
307 comib,=,n -1,arg1,LREF(negative1) /* when divisor == -1 */
309 ldo -1(arg1),temp /* is there at most one bit set ? */
310 and,<> arg1,temp,r0 /* if not, don't use power of 2 divide */
311 addi,> 0,arg1,r0 /* if divisor > 0, use power of 2 divide */
314 addi,>= 0,arg0,retreg /* if numerator is negative, add the */
315 add arg0,temp,retreg /* (denominaotr -1) to correct for shifts */
316 extru,= arg1,15,16,temp /* test denominator with 0xffff0000 */
317 extrs retreg,15,16,retreg /* retreg = retreg >> 16 */
318 or arg1,temp,arg1 /* arg1 = arg1 | (arg1 >> 16) */
319 ldi 0xcc,temp1 /* setup 0xcc in temp1 */
320 extru,= arg1,23,8,temp /* test denominator with 0xff00 */
321 extrs retreg,23,24,retreg /* retreg = retreg >> 8 */
322 or arg1,temp,arg1 /* arg1 = arg1 | (arg1 >> 8) */
323 ldi 0xaa,temp /* setup 0xaa in temp */
324 extru,= arg1,27,4,r0 /* test denominator with 0xf0 */
325 extrs retreg,27,28,retreg /* retreg = retreg >> 4 */
326 and,= arg1,temp1,r0 /* test denominator with 0xcc */
327 extrs retreg,29,30,retreg /* retreg = retreg >> 2 */
328 and,= arg1,temp,r0 /* test denominator with 0xaa */
329 extrs retreg,30,31,retreg /* retreg = retreg >> 1 */
332 addi,< 0,arg1,r0 /* if arg1 >= 0, it's not power of 2 */
333 b,n LREF(regular_seq)
334 sub r0,arg1,temp /* make denominator positive */
335 comb,=,n arg1,temp,LREF(regular_seq) /* test against 0x80000000 and 0 */
336 ldo -1(temp),retreg /* is there at most one bit set ? */
337 and,= temp,retreg,r0 /* if so, the denominator is power of 2 */
338 b,n LREF(regular_seq)
339 sub r0,arg0,retreg /* negate numerator */
340 comb,=,n arg0,retreg,LREF(regular_seq) /* test against 0x80000000 */
341 copy retreg,arg0 /* set up arg0, arg1 and temp */
342 copy temp,arg1 /* before branching to pow2 */
346 comib,>>=,n 15,arg1,LREF(small_divisor)
347 add,>= 0,arg0,retreg /* move dividend, if retreg < 0, */
349 subi 0,retreg,retreg /* make it positive */
350 sub 0,arg1,temp /* clear carry, */
351 /* negate the divisor */
352 ds 0,temp,0 /* set V-bit to the comple- */
353 /* ment of the divisor sign */
354 add retreg,retreg,retreg /* shift msb bit into carry */
355 ds r0,arg1,temp /* 1st divide step, if no carry */
356 addc retreg,retreg,retreg /* shift retreg with/into carry */
357 ds temp,arg1,temp /* 2nd divide step */
358 addc retreg,retreg,retreg /* shift retreg with/into carry */
359 ds temp,arg1,temp /* 3rd divide step */
360 addc retreg,retreg,retreg /* shift retreg with/into carry */
361 ds temp,arg1,temp /* 4th divide step */
362 addc retreg,retreg,retreg /* shift retreg with/into carry */
363 ds temp,arg1,temp /* 5th divide step */
364 addc retreg,retreg,retreg /* shift retreg with/into carry */
365 ds temp,arg1,temp /* 6th divide step */
366 addc retreg,retreg,retreg /* shift retreg with/into carry */
367 ds temp,arg1,temp /* 7th divide step */
368 addc retreg,retreg,retreg /* shift retreg with/into carry */
369 ds temp,arg1,temp /* 8th divide step */
370 addc retreg,retreg,retreg /* shift retreg with/into carry */
371 ds temp,arg1,temp /* 9th divide step */
372 addc retreg,retreg,retreg /* shift retreg with/into carry */
373 ds temp,arg1,temp /* 10th divide step */
374 addc retreg,retreg,retreg /* shift retreg with/into carry */
375 ds temp,arg1,temp /* 11th divide step */
376 addc retreg,retreg,retreg /* shift retreg with/into carry */
377 ds temp,arg1,temp /* 12th divide step */
378 addc retreg,retreg,retreg /* shift retreg with/into carry */
379 ds temp,arg1,temp /* 13th divide step */
380 addc retreg,retreg,retreg /* shift retreg with/into carry */
381 ds temp,arg1,temp /* 14th divide step */
382 addc retreg,retreg,retreg /* shift retreg with/into carry */
383 ds temp,arg1,temp /* 15th divide step */
384 addc retreg,retreg,retreg /* shift retreg with/into carry */
385 ds temp,arg1,temp /* 16th divide step */
386 addc retreg,retreg,retreg /* shift retreg with/into carry */
387 ds temp,arg1,temp /* 17th divide step */
388 addc retreg,retreg,retreg /* shift retreg with/into carry */
389 ds temp,arg1,temp /* 18th divide step */
390 addc retreg,retreg,retreg /* shift retreg with/into carry */
391 ds temp,arg1,temp /* 19th divide step */
392 addc retreg,retreg,retreg /* shift retreg with/into carry */
393 ds temp,arg1,temp /* 20th divide step */
394 addc retreg,retreg,retreg /* shift retreg with/into carry */
395 ds temp,arg1,temp /* 21st divide step */
396 addc retreg,retreg,retreg /* shift retreg with/into carry */
397 ds temp,arg1,temp /* 22nd divide step */
398 addc retreg,retreg,retreg /* shift retreg with/into carry */
399 ds temp,arg1,temp /* 23rd divide step */
400 addc retreg,retreg,retreg /* shift retreg with/into carry */
401 ds temp,arg1,temp /* 24th divide step */
402 addc retreg,retreg,retreg /* shift retreg with/into carry */
403 ds temp,arg1,temp /* 25th divide step */
404 addc retreg,retreg,retreg /* shift retreg with/into carry */
405 ds temp,arg1,temp /* 26th divide step */
406 addc retreg,retreg,retreg /* shift retreg with/into carry */
407 ds temp,arg1,temp /* 27th divide step */
408 addc retreg,retreg,retreg /* shift retreg with/into carry */
409 ds temp,arg1,temp /* 28th divide step */
410 addc retreg,retreg,retreg /* shift retreg with/into carry */
411 ds temp,arg1,temp /* 29th divide step */
412 addc retreg,retreg,retreg /* shift retreg with/into carry */
413 ds temp,arg1,temp /* 30th divide step */
414 addc retreg,retreg,retreg /* shift retreg with/into carry */
415 ds temp,arg1,temp /* 31st divide step */
416 addc retreg,retreg,retreg /* shift retreg with/into carry */
417 ds temp,arg1,temp /* 32nd divide step, */
418 addc retreg,retreg,retreg /* shift last retreg bit into retreg */
419 xor,>= arg0,arg1,0 /* get correct sign of quotient */
420 sub 0,retreg,retreg /* based on operand signs */
427 /* Clear the upper 32 bits of the arg1 register. We are working with */
428 /* small divisors (and 32-bit integers) We must not be mislead */
429 /* by "1" bits left in the upper 32 bits. */
434 /* table for divisor == 0,1, ... ,15 */
435 addit,= 0,arg1,r0 /* trap if divisor == 0 */
437 MILLIRET /* divisor == 1 */
439 MILLI_BEN($$divI_2) /* divisor == 2 */
441 MILLI_BEN($$divI_3) /* divisor == 3 */
443 MILLI_BEN($$divI_4) /* divisor == 4 */
445 MILLI_BEN($$divI_5) /* divisor == 5 */
447 MILLI_BEN($$divI_6) /* divisor == 6 */
449 MILLI_BEN($$divI_7) /* divisor == 7 */
451 MILLI_BEN($$divI_8) /* divisor == 8 */
453 MILLI_BEN($$divI_9) /* divisor == 9 */
455 MILLI_BEN($$divI_10) /* divisor == 10 */
457 b LREF(normal) /* divisor == 11 */
459 MILLI_BEN($$divI_12) /* divisor == 12 */
461 b LREF(normal) /* divisor == 13 */
463 MILLI_BEN($$divI_14) /* divisor == 14 */
465 MILLI_BEN($$divI_15) /* divisor == 15 */
469 sub 0,arg0,retreg /* result is negation of dividend */
471 addo arg0,arg1,r0 /* trap iff dividend==0x80000000 && divisor==-1 */
480 . Single precision divide for unsigned integers.
482 . Quotient is truncated towards zero.
483 . Traps on divide by zero.
489 . sr0 == return space when called externally
496 OTHER REGISTERS AFFECTED:
500 . Causes a trap under the following conditions:
502 . Changes memory at the following places:
507 . Does not create a stack frame.
508 . Suitable for internal or external millicode.
509 . Assumes the special millicode register conventions.
512 . Branchs to other millicode routines using BE:
513 . $$divU_# for 3,5,6,7,9,10,12,14,15
515 . For selected small divisors calls the special divide by constant
516 . routines written by Karl Pettis. These are: 3,5,6,7,9,10,12,14,15. */
519 RDEFINE(retreg,ret1) /* r29 */
523 .export $$divU,millicode
524 .import $$divU_3,millicode
525 .import $$divU_5,millicode
526 .import $$divU_6,millicode
527 .import $$divU_7,millicode
528 .import $$divU_9,millicode
529 .import $$divU_10,millicode
530 .import $$divU_12,millicode
531 .import $$divU_14,millicode
532 .import $$divU_15,millicode
537 /* The subtract is not nullified since it does no harm and can be used
538 by the two cases that branch back to "normal". */
539 ldo -1(arg1),temp /* is there at most one bit set ? */
540 and,= arg1,temp,r0 /* if so, denominator is power of 2 */
542 addit,= 0,arg1,0 /* trap for zero dvr */
544 extru,= arg1,15,16,temp /* test denominator with 0xffff0000 */
545 extru retreg,15,16,retreg /* retreg = retreg >> 16 */
546 or arg1,temp,arg1 /* arg1 = arg1 | (arg1 >> 16) */
547 ldi 0xcc,temp1 /* setup 0xcc in temp1 */
548 extru,= arg1,23,8,temp /* test denominator with 0xff00 */
549 extru retreg,23,24,retreg /* retreg = retreg >> 8 */
550 or arg1,temp,arg1 /* arg1 = arg1 | (arg1 >> 8) */
551 ldi 0xaa,temp /* setup 0xaa in temp */
552 extru,= arg1,27,4,r0 /* test denominator with 0xf0 */
553 extru retreg,27,28,retreg /* retreg = retreg >> 4 */
554 and,= arg1,temp1,r0 /* test denominator with 0xcc */
555 extru retreg,29,30,retreg /* retreg = retreg >> 2 */
556 and,= arg1,temp,r0 /* test denominator with 0xaa */
557 extru retreg,30,31,retreg /* retreg = retreg >> 1 */
561 comib,>= 15,arg1,LREF(special_divisor)
562 subi 0,arg1,temp /* clear carry, negate the divisor */
563 ds r0,temp,r0 /* set V-bit to 1 */
565 add arg0,arg0,retreg /* shift msb bit into carry */
566 ds r0,arg1,temp /* 1st divide step, if no carry */
567 addc retreg,retreg,retreg /* shift retreg with/into carry */
568 ds temp,arg1,temp /* 2nd divide step */
569 addc retreg,retreg,retreg /* shift retreg with/into carry */
570 ds temp,arg1,temp /* 3rd divide step */
571 addc retreg,retreg,retreg /* shift retreg with/into carry */
572 ds temp,arg1,temp /* 4th divide step */
573 addc retreg,retreg,retreg /* shift retreg with/into carry */
574 ds temp,arg1,temp /* 5th divide step */
575 addc retreg,retreg,retreg /* shift retreg with/into carry */
576 ds temp,arg1,temp /* 6th divide step */
577 addc retreg,retreg,retreg /* shift retreg with/into carry */
578 ds temp,arg1,temp /* 7th divide step */
579 addc retreg,retreg,retreg /* shift retreg with/into carry */
580 ds temp,arg1,temp /* 8th divide step */
581 addc retreg,retreg,retreg /* shift retreg with/into carry */
582 ds temp,arg1,temp /* 9th divide step */
583 addc retreg,retreg,retreg /* shift retreg with/into carry */
584 ds temp,arg1,temp /* 10th divide step */
585 addc retreg,retreg,retreg /* shift retreg with/into carry */
586 ds temp,arg1,temp /* 11th divide step */
587 addc retreg,retreg,retreg /* shift retreg with/into carry */
588 ds temp,arg1,temp /* 12th divide step */
589 addc retreg,retreg,retreg /* shift retreg with/into carry */
590 ds temp,arg1,temp /* 13th divide step */
591 addc retreg,retreg,retreg /* shift retreg with/into carry */
592 ds temp,arg1,temp /* 14th divide step */
593 addc retreg,retreg,retreg /* shift retreg with/into carry */
594 ds temp,arg1,temp /* 15th divide step */
595 addc retreg,retreg,retreg /* shift retreg with/into carry */
596 ds temp,arg1,temp /* 16th divide step */
597 addc retreg,retreg,retreg /* shift retreg with/into carry */
598 ds temp,arg1,temp /* 17th divide step */
599 addc retreg,retreg,retreg /* shift retreg with/into carry */
600 ds temp,arg1,temp /* 18th divide step */
601 addc retreg,retreg,retreg /* shift retreg with/into carry */
602 ds temp,arg1,temp /* 19th divide step */
603 addc retreg,retreg,retreg /* shift retreg with/into carry */
604 ds temp,arg1,temp /* 20th divide step */
605 addc retreg,retreg,retreg /* shift retreg with/into carry */
606 ds temp,arg1,temp /* 21st divide step */
607 addc retreg,retreg,retreg /* shift retreg with/into carry */
608 ds temp,arg1,temp /* 22nd divide step */
609 addc retreg,retreg,retreg /* shift retreg with/into carry */
610 ds temp,arg1,temp /* 23rd divide step */
611 addc retreg,retreg,retreg /* shift retreg with/into carry */
612 ds temp,arg1,temp /* 24th divide step */
613 addc retreg,retreg,retreg /* shift retreg with/into carry */
614 ds temp,arg1,temp /* 25th divide step */
615 addc retreg,retreg,retreg /* shift retreg with/into carry */
616 ds temp,arg1,temp /* 26th divide step */
617 addc retreg,retreg,retreg /* shift retreg with/into carry */
618 ds temp,arg1,temp /* 27th divide step */
619 addc retreg,retreg,retreg /* shift retreg with/into carry */
620 ds temp,arg1,temp /* 28th divide step */
621 addc retreg,retreg,retreg /* shift retreg with/into carry */
622 ds temp,arg1,temp /* 29th divide step */
623 addc retreg,retreg,retreg /* shift retreg with/into carry */
624 ds temp,arg1,temp /* 30th divide step */
625 addc retreg,retreg,retreg /* shift retreg with/into carry */
626 ds temp,arg1,temp /* 31st divide step */
627 addc retreg,retreg,retreg /* shift retreg with/into carry */
628 ds temp,arg1,temp /* 32nd divide step, */
630 addc retreg,retreg,retreg /* shift last retreg bit into retreg */
632 /* Handle the cases where divisor is a small constant or has high bit on. */
633 LSYM(special_divisor)
635 /* comib,>,n 0,arg1,LREF(big_divisor) ; nullify previous instruction */
637 /* Pratap 8/13/90. The 815 Stirling chip set has a bug that prevents us from
638 generating such a blr, comib sequence. A problem in nullification. So I
639 rewrote this code. */
642 /* Clear the upper 32 bits of the arg1 register. We are working with
643 small divisors (and 32-bit unsigned integers) We must not be mislead
644 by "1" bits left in the upper 32 bits. */
647 comib,> 0,arg1,LREF(big_divisor)
652 LSYM(zero_divisor) /* this label is here to provide external visibility */
653 addit,= 0,arg1,0 /* trap for zero dvr */
655 MILLIRET /* divisor == 1 */
657 MILLIRET /* divisor == 2 */
658 extru arg0,30,31,retreg
659 MILLI_BEN($$divU_3) /* divisor == 3 */
661 MILLIRET /* divisor == 4 */
662 extru arg0,29,30,retreg
663 MILLI_BEN($$divU_5) /* divisor == 5 */
665 MILLI_BEN($$divU_6) /* divisor == 6 */
667 MILLI_BEN($$divU_7) /* divisor == 7 */
669 MILLIRET /* divisor == 8 */
670 extru arg0,28,29,retreg
671 MILLI_BEN($$divU_9) /* divisor == 9 */
673 MILLI_BEN($$divU_10) /* divisor == 10 */
675 b LREF(normal) /* divisor == 11 */
676 ds r0,temp,r0 /* set V-bit to 1 */
677 MILLI_BEN($$divU_12) /* divisor == 12 */
679 b LREF(normal) /* divisor == 13 */
680 ds r0,temp,r0 /* set V-bit to 1 */
681 MILLI_BEN($$divU_14) /* divisor == 14 */
683 MILLI_BEN($$divU_15) /* divisor == 15 */
686 /* Handle the case where the high bit is on in the divisor.
687 Compute: if( dividend>=divisor) quotient=1; else quotient=0;
688 Note: dividend>==divisor iff dividend-divisor does not borrow
689 and not borrow iff carry. */
703 . $$remI returns the remainder of the division of two signed 32-bit
704 . integers. The sign of the remainder is the same as the sign of
712 . sr0 == return space when called externally
719 OTHER REGISTERS AFFECTED:
723 . Causes a trap under the following conditions: DIVIDE BY ZERO
724 . Changes memory at the following places: NONE
728 . Does not create a stack frame
729 . Is usable for internal or external microcode
732 . Calls other millicode routines via mrp: NONE
733 . Calls other millicode routines: NONE */
745 .export $$remI,MILLICODE
746 .export $$remoI,MILLICODE
747 ldo -1(arg1),tmp /* is there at most one bit set ? */
748 and,<> arg1,tmp,r0 /* if not, don't use power of 2 */
749 addi,> 0,arg1,r0 /* if denominator > 0, use power */
753 comb,>,n 0,arg0,LREF(neg_num) /* is numerator < 0 ? */
754 and arg0,tmp,retreg /* get the result */
757 subi 0,arg0,arg0 /* negate numerator */
758 and arg0,tmp,retreg /* get the result */
759 subi 0,retreg,retreg /* negate result */
762 addi,< 0,arg1,r0 /* if arg1 >= 0, it's not power */
764 b,n LREF(regular_seq)
765 sub r0,arg1,tmp /* make denominator positive */
766 comb,=,n arg1,tmp,LREF(regular_seq) /* test against 0x80000000 and 0 */
767 ldo -1(tmp),retreg /* is there at most one bit set ? */
768 and,= tmp,retreg,r0 /* if not, go to regular_seq */
769 b,n LREF(regular_seq)
770 comb,>,n 0,arg0,LREF(neg_num_2) /* if arg0 < 0, negate it */
771 and arg0,retreg,retreg
774 subi 0,arg0,tmp /* test against 0x80000000 */
775 and tmp,retreg,retreg
779 addit,= 0,arg1,0 /* trap if div by zero */
780 add,>= 0,arg0,retreg /* move dividend, if retreg < 0, */
781 sub 0,retreg,retreg /* make it positive */
782 sub 0,arg1, tmp /* clear carry, */
783 /* negate the divisor */
784 ds 0, tmp,0 /* set V-bit to the comple- */
785 /* ment of the divisor sign */
786 or 0,0, tmp /* clear tmp */
787 add retreg,retreg,retreg /* shift msb bit into carry */
788 ds tmp,arg1, tmp /* 1st divide step, if no carry */
789 /* out, msb of quotient = 0 */
790 addc retreg,retreg,retreg /* shift retreg with/into carry */
792 ds tmp,arg1, tmp /* 2nd divide step */
793 addc retreg,retreg,retreg /* shift retreg with/into carry */
794 ds tmp,arg1, tmp /* 3rd divide step */
795 addc retreg,retreg,retreg /* shift retreg with/into carry */
796 ds tmp,arg1, tmp /* 4th divide step */
797 addc retreg,retreg,retreg /* shift retreg with/into carry */
798 ds tmp,arg1, tmp /* 5th divide step */
799 addc retreg,retreg,retreg /* shift retreg with/into carry */
800 ds tmp,arg1, tmp /* 6th divide step */
801 addc retreg,retreg,retreg /* shift retreg with/into carry */
802 ds tmp,arg1, tmp /* 7th divide step */
803 addc retreg,retreg,retreg /* shift retreg with/into carry */
804 ds tmp,arg1, tmp /* 8th divide step */
805 addc retreg,retreg,retreg /* shift retreg with/into carry */
806 ds tmp,arg1, tmp /* 9th divide step */
807 addc retreg,retreg,retreg /* shift retreg with/into carry */
808 ds tmp,arg1, tmp /* 10th divide step */
809 addc retreg,retreg,retreg /* shift retreg with/into carry */
810 ds tmp,arg1, tmp /* 11th divide step */
811 addc retreg,retreg,retreg /* shift retreg with/into carry */
812 ds tmp,arg1, tmp /* 12th divide step */
813 addc retreg,retreg,retreg /* shift retreg with/into carry */
814 ds tmp,arg1, tmp /* 13th divide step */
815 addc retreg,retreg,retreg /* shift retreg with/into carry */
816 ds tmp,arg1, tmp /* 14th divide step */
817 addc retreg,retreg,retreg /* shift retreg with/into carry */
818 ds tmp,arg1, tmp /* 15th divide step */
819 addc retreg,retreg,retreg /* shift retreg with/into carry */
820 ds tmp,arg1, tmp /* 16th divide step */
821 addc retreg,retreg,retreg /* shift retreg with/into carry */
822 ds tmp,arg1, tmp /* 17th divide step */
823 addc retreg,retreg,retreg /* shift retreg with/into carry */
824 ds tmp,arg1, tmp /* 18th divide step */
825 addc retreg,retreg,retreg /* shift retreg with/into carry */
826 ds tmp,arg1, tmp /* 19th divide step */
827 addc retreg,retreg,retreg /* shift retreg with/into carry */
828 ds tmp,arg1, tmp /* 20th divide step */
829 addc retreg,retreg,retreg /* shift retreg with/into carry */
830 ds tmp,arg1, tmp /* 21st divide step */
831 addc retreg,retreg,retreg /* shift retreg with/into carry */
832 ds tmp,arg1, tmp /* 22nd divide step */
833 addc retreg,retreg,retreg /* shift retreg with/into carry */
834 ds tmp,arg1, tmp /* 23rd divide step */
835 addc retreg,retreg,retreg /* shift retreg with/into carry */
836 ds tmp,arg1, tmp /* 24th divide step */
837 addc retreg,retreg,retreg /* shift retreg with/into carry */
838 ds tmp,arg1, tmp /* 25th divide step */
839 addc retreg,retreg,retreg /* shift retreg with/into carry */
840 ds tmp,arg1, tmp /* 26th divide step */
841 addc retreg,retreg,retreg /* shift retreg with/into carry */
842 ds tmp,arg1, tmp /* 27th divide step */
843 addc retreg,retreg,retreg /* shift retreg with/into carry */
844 ds tmp,arg1, tmp /* 28th divide step */
845 addc retreg,retreg,retreg /* shift retreg with/into carry */
846 ds tmp,arg1, tmp /* 29th divide step */
847 addc retreg,retreg,retreg /* shift retreg with/into carry */
848 ds tmp,arg1, tmp /* 30th divide step */
849 addc retreg,retreg,retreg /* shift retreg with/into carry */
850 ds tmp,arg1, tmp /* 31st divide step */
851 addc retreg,retreg,retreg /* shift retreg with/into carry */
852 ds tmp,arg1, tmp /* 32nd divide step, */
853 addc retreg,retreg,retreg /* shift last bit into retreg */
854 movb,>=,n tmp,retreg,LREF(finish) /* branch if pos. tmp */
855 add,< arg1,0,0 /* if arg1 > 0, add arg1 */
856 add,tr tmp,arg1,retreg /* for correcting remainder tmp */
857 sub tmp,arg1,retreg /* else add absolute value arg1 */
859 add,>= arg0,0,0 /* set sign of remainder */
860 sub 0,retreg,retreg /* to sign of dividend */
873 . Single precision divide for remainder with unsigned binary integers.
875 . The remainder must be dividend-(dividend/divisor)*divisor.
876 . Divide by zero is trapped.
882 . sr0 == return space when called externally
889 OTHER REGISTERS AFFECTED:
893 . Causes a trap under the following conditions: DIVIDE BY ZERO
894 . Changes memory at the following places: NONE
898 . Does not create a stack frame.
899 . Suitable for internal or external millicode.
900 . Assumes the special millicode register conventions.
903 . Calls other millicode routines using mrp: NONE
904 . Calls other millicode routines: NONE */
908 RDEFINE(rmndr,ret1) /* r29 */
911 .export $$remU,millicode
916 ldo -1(arg1),temp /* is there at most one bit set ? */
917 and,= arg1,temp,r0 /* if not, don't use power of 2 */
919 addit,= 0,arg1,r0 /* trap on div by zero */
920 and arg0,temp,rmndr /* get the result for power of 2 */
923 comib,>=,n 0,arg1,LREF(special_case)
924 subi 0,arg1,rmndr /* clear carry, negate the divisor */
925 ds r0,rmndr,r0 /* set V-bit to 1 */
926 add arg0,arg0,temp /* shift msb bit into carry */
927 ds r0,arg1,rmndr /* 1st divide step, if no carry */
928 addc temp,temp,temp /* shift temp with/into carry */
929 ds rmndr,arg1,rmndr /* 2nd divide step */
930 addc temp,temp,temp /* shift temp with/into carry */
931 ds rmndr,arg1,rmndr /* 3rd divide step */
932 addc temp,temp,temp /* shift temp with/into carry */
933 ds rmndr,arg1,rmndr /* 4th divide step */
934 addc temp,temp,temp /* shift temp with/into carry */
935 ds rmndr,arg1,rmndr /* 5th divide step */
936 addc temp,temp,temp /* shift temp with/into carry */
937 ds rmndr,arg1,rmndr /* 6th divide step */
938 addc temp,temp,temp /* shift temp with/into carry */
939 ds rmndr,arg1,rmndr /* 7th divide step */
940 addc temp,temp,temp /* shift temp with/into carry */
941 ds rmndr,arg1,rmndr /* 8th divide step */
942 addc temp,temp,temp /* shift temp with/into carry */
943 ds rmndr,arg1,rmndr /* 9th divide step */
944 addc temp,temp,temp /* shift temp with/into carry */
945 ds rmndr,arg1,rmndr /* 10th divide step */
946 addc temp,temp,temp /* shift temp with/into carry */
947 ds rmndr,arg1,rmndr /* 11th divide step */
948 addc temp,temp,temp /* shift temp with/into carry */
949 ds rmndr,arg1,rmndr /* 12th divide step */
950 addc temp,temp,temp /* shift temp with/into carry */
951 ds rmndr,arg1,rmndr /* 13th divide step */
952 addc temp,temp,temp /* shift temp with/into carry */
953 ds rmndr,arg1,rmndr /* 14th divide step */
954 addc temp,temp,temp /* shift temp with/into carry */
955 ds rmndr,arg1,rmndr /* 15th divide step */
956 addc temp,temp,temp /* shift temp with/into carry */
957 ds rmndr,arg1,rmndr /* 16th divide step */
958 addc temp,temp,temp /* shift temp with/into carry */
959 ds rmndr,arg1,rmndr /* 17th divide step */
960 addc temp,temp,temp /* shift temp with/into carry */
961 ds rmndr,arg1,rmndr /* 18th divide step */
962 addc temp,temp,temp /* shift temp with/into carry */
963 ds rmndr,arg1,rmndr /* 19th divide step */
964 addc temp,temp,temp /* shift temp with/into carry */
965 ds rmndr,arg1,rmndr /* 20th divide step */
966 addc temp,temp,temp /* shift temp with/into carry */
967 ds rmndr,arg1,rmndr /* 21st divide step */
968 addc temp,temp,temp /* shift temp with/into carry */
969 ds rmndr,arg1,rmndr /* 22nd divide step */
970 addc temp,temp,temp /* shift temp with/into carry */
971 ds rmndr,arg1,rmndr /* 23rd divide step */
972 addc temp,temp,temp /* shift temp with/into carry */
973 ds rmndr,arg1,rmndr /* 24th divide step */
974 addc temp,temp,temp /* shift temp with/into carry */
975 ds rmndr,arg1,rmndr /* 25th divide step */
976 addc temp,temp,temp /* shift temp with/into carry */
977 ds rmndr,arg1,rmndr /* 26th divide step */
978 addc temp,temp,temp /* shift temp with/into carry */
979 ds rmndr,arg1,rmndr /* 27th divide step */
980 addc temp,temp,temp /* shift temp with/into carry */
981 ds rmndr,arg1,rmndr /* 28th divide step */
982 addc temp,temp,temp /* shift temp with/into carry */
983 ds rmndr,arg1,rmndr /* 29th divide step */
984 addc temp,temp,temp /* shift temp with/into carry */
985 ds rmndr,arg1,rmndr /* 30th divide step */
986 addc temp,temp,temp /* shift temp with/into carry */
987 ds rmndr,arg1,rmndr /* 31st divide step */
988 addc temp,temp,temp /* shift temp with/into carry */
989 ds rmndr,arg1,rmndr /* 32nd divide step, */
990 comiclr,<= 0,rmndr,r0
991 add rmndr,arg1,rmndr /* correction */
995 /* Putting >= on the last DS and deleting COMICLR does not work! */
997 sub,>>= arg0,arg1,rmndr
1007 /* ROUTINE: $$divI_2
1015 . $$divI_10 $$divU_10
1017 . $$divI_12 $$divU_12
1019 . $$divI_14 $$divU_14
1020 . $$divI_15 $$divU_15
1022 . $$divI_17 $$divU_17
1024 . Divide by selected constants for single precision binary integers.
1029 . sr0 == return space when called externally
1036 OTHER REGISTERS AFFECTED:
1040 . Causes a trap under the following conditions: NONE
1041 . Changes memory at the following places: NONE
1043 PERMISSIBLE CONTEXT:
1045 . Does not create a stack frame.
1046 . Suitable for internal or external millicode.
1047 . Assumes the special millicode register conventions.
1050 . Calls other millicode routines using mrp: NONE
1051 . Calls other millicode routines: NONE */
1054 /* TRUNCATED DIVISION BY SMALL INTEGERS
1056 We are interested in q(x) = floor(x/y), where x >= 0 and y > 0
1059 Let a = floor(z/y), for some choice of z. Note that z will be
1060 chosen so that division by z is cheap.
1062 Let r be the remainder(z/y). In other words, r = z - ay.
1064 Now, our method is to choose a value for b such that
1066 q'(x) = floor((ax+b)/z)
1068 is equal to q(x) over as large a range of x as possible. If the
1069 two are equal over a sufficiently large range, and if it is easy to
1070 form the product (ax), and it is easy to divide by z, then we can
1071 perform the division much faster than the general division algorithm.
1073 So, we want the following to be true:
1075 . For x in the following range:
1081 . k <= (ax+b)/z < (k+1)
1083 We want to determine b such that this is true for all k in the
1084 range {0..K} for some maximum K.
1086 Since (ax+b) is an increasing function of x, we can take each
1087 bound separately to determine the "best" value for b.
1089 (ax+b)/z < (k+1) implies
1091 (a((k+1)y-1)+b < (k+1)z implies
1093 b < a + (k+1)(z-ay) implies
1097 This needs to be true for all k in the range {0..K}. In
1098 particular, it is true for k = 0 and this leads to a maximum
1099 acceptable value for b.
1101 b < a+r or b <= a+r-1
1103 Taking the other bound, we have
1105 k <= (ax+b)/z implies
1107 k <= (aky+b)/z implies
1109 k(z-ay) <= b implies
1113 Clearly, the largest range for k will be achieved by maximizing b,
1114 when r is not zero. When r is zero, then the simplest choice for b
1115 is 0. When r is not 0, set
1119 Now, by construction, q'(x) = floor((ax+b)/z) = q(x) = floor(x/y)
1120 for all x in the range:
1124 We need to determine what K is. Of our two bounds,
1126 . b < a+(k+1)r is satisfied for all k >= 0, by construction.
1132 This is always true if r = 0. If r is not 0 (the usual case), then
1133 K = floor((a+r-1)/r), is the maximum value for k.
1135 Therefore, the formula q'(x) = floor((ax+b)/z) yields the correct
1136 answer for q(x) = floor(x/y) when x is in the range
1138 (0,(K+1)y-1) K = floor((a+r-1)/r)
1140 To be most useful, we want (K+1)y-1 = (max x) >= 2**32-1 so that
1141 the formula for q'(x) yields the correct value of q(x) for all x
1142 representable by a single word in HPPA.
1144 We are also constrained in that computing the product (ax), adding
1145 b, and dividing by z must all be done quickly, otherwise we will be
1146 better off going through the general algorithm using the DS
1147 instruction, which uses approximately 70 cycles.
1149 For each y, there is a choice of z which satisfies the constraints
1150 for (K+1)y >= 2**32. We may not, however, be able to satisfy the
1151 timing constraints for arbitrary y. It seems that z being equal to
1152 a power of 2 or a power of 2 minus 1 is as good as we can do, since
1153 it minimizes the time to do division by z. We want the choice of z
1154 to also result in a value for (a) that minimizes the computation of
1155 the product (ax). This is best achieved if (a) has a regular bit
1156 pattern (so the multiplication can be done with shifts and adds).
1157 The value of (a) also needs to be less than 2**32 so the product is
1158 always guaranteed to fit in 2 words.
1160 In actual practice, the following should be done:
1162 1) For negative x, you should take the absolute value and remember
1163 . the fact so that the result can be negated. This obviously does
1164 . not apply in the unsigned case.
1165 2) For even y, you should factor out the power of 2 that divides y
1166 . and divide x by it. You can then proceed by dividing by the
1169 Here is a table of some odd values of y, and corresponding choices
1170 for z which are "good".
1172 y z r a (hex) max x (hex)
1174 3 2**32 1 55555555 100000001
1175 5 2**32 1 33333333 100000003
1176 7 2**24-1 0 249249 (infinite)
1177 9 2**24-1 0 1c71c7 (infinite)
1178 11 2**20-1 0 1745d (infinite)
1179 13 2**24-1 0 13b13b (infinite)
1180 15 2**32 1 11111111 10000000d
1181 17 2**32 1 f0f0f0f 10000000f
1183 If r is 1, then b = a+r-1 = a. This simplifies the computation
1184 of (ax+b), since you can compute (x+1)(a) instead. If r is 0,
1185 then b = 0 is ok to use which simplifies (ax+b).
1187 The bit patterns for 55555555, 33333333, and 11111111 are obviously
1188 very regular. The bit patterns for the other values of a above are:
1192 7 249249 001001001001001001001001 << regular >>
1193 9 1c71c7 000111000111000111000111 << regular >>
1194 11 1745d 000000010111010001011101 << irregular >>
1195 13 13b13b 000100111011000100111011 << irregular >>
1197 The bit patterns for (a) corresponding to (y) of 11 and 13 may be
1198 too irregular to warrant using this method.
1200 When z is a power of 2 minus 1, then the division by z is slightly
1201 more complicated, involving an iterative solution.
1203 The code presented here solves division by 1 through 17, except for
1204 11 and 13. There are algorithms for both signed and unsigned
1209 divisor positive negative unsigned
1224 Now, the algorithm for 7, 9, and 14 is an iterative one. That is,
1225 a loop body is executed until the tentative quotient is 0. The
1226 number of times the loop body is executed varies depending on the
1227 dividend, but is never more than two times. If the dividend is
1228 less than the divisor, then the loop body is not executed at all.
1229 Each iteration adds 4 cycles to the timings.
1231 divisor positive negative unsigned
1233 . 7 19+4n 20+4n 20+4n n = number of iterations
1234 . 9 21+4n 22+4n 21+4n
1235 . 14 21+4n 22+4n 20+4n
1237 To give an idea of how the number of iterations varies, here is a
1238 table of dividend versus number of iterations when dividing by 7.
1240 smallest largest required
1241 dividend dividend iterations
1245 0x1000006 0xffffffff 2
1247 There is some overlap in the range of numbers requiring 1 and 2
1251 RDEFINE(x2,arg0) /* r26 */
1252 RDEFINE(t1,arg1) /* r25 */
1253 RDEFINE(x1,ret1) /* r29 */
1261 /* NONE of these routines require a stack frame
1262 ALL of these routines are unwindable from millicode */
1264 GSYM($$divide_by_constant)
1265 .export $$divide_by_constant,millicode
1266 /* Provides a "nice" label for the code covered by the unwind descriptor
1267 for things like gprof. */
1269 /* DIVISION BY 2 (shift by 1) */
1271 .export $$divI_2,millicode
1275 extrs arg0,30,31,ret1
1278 /* DIVISION BY 4 (shift by 2) */
1280 .export $$divI_4,millicode
1284 extrs arg0,29,30,ret1
1287 /* DIVISION BY 8 (shift by 3) */
1289 .export $$divI_8,millicode
1293 extrs arg0,28,29,ret1
1295 /* DIVISION BY 16 (shift by 4) */
1297 .export $$divI_16,millicode
1301 extrs arg0,27,28,ret1
1303 /****************************************************************************
1305 * DIVISION BY DIVISORS OF FFFFFFFF, and powers of 2 times these
1307 * includes 3,5,15,17 and also 6,10,12
1309 ****************************************************************************/
1311 /* DIVISION BY 3 (use z = 2**32; a = 55555555) */
1314 .export $$divI_3,millicode
1315 comb,<,N x2,0,LREF(neg3)
1317 addi 1,x2,x2 /* this cannot overflow */
1318 extru x2,1,2,x1 /* multiply by 5 to get started */
1324 subi 1,x2,x2 /* this cannot overflow */
1325 extru x2,1,2,x1 /* multiply by 5 to get started */
1331 .export $$divU_3,millicode
1332 addi 1,x2,x2 /* this CAN overflow */
1334 shd x1,x2,30,t1 /* multiply by 5 to get started */
1339 /* DIVISION BY 5 (use z = 2**32; a = 33333333) */
1342 .export $$divI_5,millicode
1343 comb,<,N x2,0,LREF(neg5)
1345 addi 3,x2,t1 /* this cannot overflow */
1346 sh1add x2,t1,x2 /* multiply by 3 to get started */
1351 sub 0,x2,x2 /* negate x2 */
1352 addi 1,x2,x2 /* this cannot overflow */
1353 shd 0,x2,31,x1 /* get top bit (can be 1) */
1354 sh1add x2,x2,x2 /* multiply by 3 to get started */
1359 .export $$divU_5,millicode
1360 addi 1,x2,x2 /* this CAN overflow */
1362 shd x1,x2,31,t1 /* multiply by 3 to get started */
1367 /* DIVISION BY 6 (shift to divide by 2 then divide by 3) */
1369 .export $$divI_6,millicode
1370 comb,<,N x2,0,LREF(neg6)
1371 extru x2,30,31,x2 /* divide by 2 */
1372 addi 5,x2,t1 /* compute 5*(x2+1) = 5*x2+5 */
1373 sh2add x2,t1,x2 /* multiply by 5 to get started */
1378 subi 2,x2,x2 /* negate, divide by 2, and add 1 */
1379 /* negation and adding 1 are done */
1380 /* at the same time by the SUBI */
1383 sh2add x2,x2,x2 /* multiply by 5 to get started */
1388 .export $$divU_6,millicode
1389 extru x2,30,31,x2 /* divide by 2 */
1390 addi 1,x2,x2 /* cannot carry */
1391 shd 0,x2,30,x1 /* multiply by 5 to get started */
1396 /* DIVISION BY 10 (shift to divide by 2 then divide by 5) */
1398 .export $$divU_10,millicode
1399 extru x2,30,31,x2 /* divide by 2 */
1400 addi 3,x2,t1 /* compute 3*(x2+1) = (3*x2)+3 */
1401 sh1add x2,t1,x2 /* multiply by 3 to get started */
1404 shd x1,x2,28,t1 /* multiply by 0x11 */
1409 shd x1,x2,24,t1 /* multiply by 0x101 */
1414 shd x1,x2,16,t1 /* multiply by 0x10001 */
1421 .export $$divI_10,millicode
1422 comb,< x2,0,LREF(neg10)
1424 extru x2,30,31,x2 /* divide by 2 */
1425 addib,TR 1,x2,LREF(pos) /* add 1 (cannot overflow) */
1426 sh1add x2,x2,x2 /* multiply by 3 to get started */
1429 subi 2,x2,x2 /* negate, divide by 2, and add 1 */
1430 /* negation and adding 1 are done */
1431 /* at the same time by the SUBI */
1433 sh1add x2,x2,x2 /* multiply by 3 to get started */
1435 shd x1,x2,28,t1 /* multiply by 0x11 */
1440 shd x1,x2,24,t1 /* multiply by 0x101 */
1445 shd x1,x2,16,t1 /* multiply by 0x10001 */
1452 /* DIVISION BY 12 (shift to divide by 4 then divide by 3) */
1454 .export $$divI_12,millicode
1455 comb,< x2,0,LREF(neg12)
1457 extru x2,29,30,x2 /* divide by 4 */
1458 addib,tr 1,x2,LREF(pos) /* compute 5*(x2+1) = 5*x2+5 */
1459 sh2add x2,x2,x2 /* multiply by 5 to get started */
1462 subi 4,x2,x2 /* negate, divide by 4, and add 1 */
1463 /* negation and adding 1 are done */
1464 /* at the same time by the SUBI */
1467 sh2add x2,x2,x2 /* multiply by 5 to get started */
1470 .export $$divU_12,millicode
1471 extru x2,29,30,x2 /* divide by 4 */
1472 addi 5,x2,t1 /* cannot carry */
1473 sh2add x2,t1,x2 /* multiply by 5 to get started */
1477 /* DIVISION BY 15 (use z = 2**32; a = 11111111) */
1479 .export $$divI_15,millicode
1480 comb,< x2,0,LREF(neg15)
1482 addib,tr 1,x2,LREF(pos)+4
1490 .export $$divU_15,millicode
1491 addi 1,x2,x2 /* this CAN overflow */
1495 /* DIVISION BY 17 (use z = 2**32; a = f0f0f0f) */
1497 .export $$divI_17,millicode
1498 comb,<,n x2,0,LREF(neg17)
1499 addi 1,x2,x2 /* this cannot overflow */
1500 shd 0,x2,28,t1 /* multiply by 0xf to get started */
1507 subi 1,x2,x2 /* this cannot overflow */
1508 shd 0,x2,28,t1 /* multiply by 0xf to get started */
1515 .export $$divU_17,millicode
1516 addi 1,x2,x2 /* this CAN overflow */
1518 shd x1,x2,28,t1 /* multiply by 0xf to get started */
1526 /* DIVISION BY DIVISORS OF FFFFFF, and powers of 2 times these
1527 includes 7,9 and also 14
1535 Also, in order to divide by z = 2**24-1, we approximate by dividing
1536 by (z+1) = 2**24 (which is easy), and then correcting.
1541 So to compute (ax)/z, compute q' = (ax)/(z+1) and r = (ax) mod (z+1)
1542 Then the true remainder of (ax)/z is (q'+r). Repeat the process
1543 with this new remainder, adding the tentative quotients together,
1544 until a tentative quotient is 0 (and then we are done). There is
1545 one last correction to be done. It is possible that (q'+r) = z.
1546 If so, then (q'+r)/(z+1) = 0 and it looks like we are done. But,
1547 in fact, we need to add 1 more to the quotient. Now, it turns
1548 out that this happens if and only if the original value x is
1549 an exact multiple of y. So, to avoid a three instruction test at
1550 the end, instead use 1 instruction to add 1 to x at the beginning. */
1552 /* DIVISION BY 7 (use z = 2**24-1; a = 249249) */
1554 .export $$divI_7,millicode
1555 comb,<,n x2,0,LREF(neg7)
1557 addi 1,x2,x2 /* cannot overflow */
1572 /* computed <t1,x2>. Now divide it by (2**24 - 1) */
1575 shd,= t1,x2,24,t1 /* tentative quotient */
1577 addb,tr t1,x1,LREF(2) /* add to previous quotient */
1578 extru x2,31,24,x2 /* new remainder (unadjusted) */
1583 addb,tr t1,x2,LREF(1) /* adjust remainder */
1584 extru,= x2,7,8,t1 /* new quotient */
1587 subi 1,x2,x2 /* negate x2 and add 1 */
1604 /* computed <t1,x2>. Now divide it by (2**24 - 1) */
1607 shd,= t1,x2,24,t1 /* tentative quotient */
1609 addb,tr t1,x1,LREF(4) /* add to previous quotient */
1610 extru x2,31,24,x2 /* new remainder (unadjusted) */
1613 sub 0,x1,x1 /* negate result */
1616 addb,tr t1,x2,LREF(3) /* adjust remainder */
1617 extru,= x2,7,8,t1 /* new quotient */
1620 .export $$divU_7,millicode
1621 addi 1,x2,x2 /* can carry */
1628 /* DIVISION BY 9 (use z = 2**24-1; a = 1c71c7) */
1630 .export $$divI_9,millicode
1631 comb,<,n x2,0,LREF(neg9)
1632 addi 1,x2,x2 /* cannot overflow */
1640 subi 1,x2,x2 /* negate and add 1 */
1648 .export $$divU_9,millicode
1649 addi 1,x2,x2 /* can carry */
1657 /* DIVISION BY 14 (shift to divide by 2 then divide by 7) */
1659 .export $$divI_14,millicode
1660 comb,<,n x2,0,LREF(neg14)
1662 .export $$divU_14,millicode
1663 b LREF(7) /* go to 7 case */
1664 extru x2,30,31,x2 /* divide by 2 */
1667 subi 2,x2,x2 /* negate (and add 2) */
1669 extru x2,30,31,x2 /* divide by 2 */
1676 /* VERSION "@(#)$$mulI $ Revision: 12.4 $ $ Date: 94/03/17 17:18:51 $" */
1677 /******************************************************************************
1678 This routine is used on PA2.0 processors when gcc -mno-fpregs is used
1685 $$mulI multiplies two single word integers, giving a single
1694 sr0 == return space when called externally
1703 OTHER REGISTERS AFFECTED:
1709 Causes a trap under the following conditions: NONE
1710 Changes memory at the following places: NONE
1712 PERMISSIBLE CONTEXT:
1715 Does not create a stack frame
1716 Is usable for internal or external microcode
1720 Calls other millicode routines via mrp: NONE
1721 Calls other millicode routines: NONE
1723 ***************************************************************************/
1731 #define a0__128a0 zdep a0,24,25,a0
1732 #define a0__256a0 zdep a0,23,24,a0
1733 #define a1_ne_0_b_l0 comb,<> a1,0,LREF(l0)
1734 #define a1_ne_0_b_l1 comb,<> a1,0,LREF(l1)
1735 #define a1_ne_0_b_l2 comb,<> a1,0,LREF(l2)
1736 #define b_n_ret_t0 b,n LREF(ret_t0)
1737 #define b_e_shift b LREF(e_shift)
1738 #define b_e_t0ma0 b LREF(e_t0ma0)
1739 #define b_e_t0 b LREF(e_t0)
1740 #define b_e_t0a0 b LREF(e_t0a0)
1741 #define b_e_t02a0 b LREF(e_t02a0)
1742 #define b_e_t04a0 b LREF(e_t04a0)
1743 #define b_e_2t0 b LREF(e_2t0)
1744 #define b_e_2t0a0 b LREF(e_2t0a0)
1745 #define b_e_2t04a0 b LREF(e2t04a0)
1746 #define b_e_3t0 b LREF(e_3t0)
1747 #define b_e_4t0 b LREF(e_4t0)
1748 #define b_e_4t0a0 b LREF(e_4t0a0)
1749 #define b_e_4t08a0 b LREF(e4t08a0)
1750 #define b_e_5t0 b LREF(e_5t0)
1751 #define b_e_8t0 b LREF(e_8t0)
1752 #define b_e_8t0a0 b LREF(e_8t0a0)
1753 #define r__r_a0 add r,a0,r
1754 #define r__r_2a0 sh1add a0,r,r
1755 #define r__r_4a0 sh2add a0,r,r
1756 #define r__r_8a0 sh3add a0,r,r
1757 #define r__r_t0 add r,t0,r
1758 #define r__r_2t0 sh1add t0,r,r
1759 #define r__r_4t0 sh2add t0,r,r
1760 #define r__r_8t0 sh3add t0,r,r
1761 #define t0__3a0 sh1add a0,a0,t0
1762 #define t0__4a0 sh2add a0,0,t0
1763 #define t0__5a0 sh2add a0,a0,t0
1764 #define t0__8a0 sh3add a0,0,t0
1765 #define t0__9a0 sh3add a0,a0,t0
1766 #define t0__16a0 zdep a0,27,28,t0
1767 #define t0__32a0 zdep a0,26,27,t0
1768 #define t0__64a0 zdep a0,25,26,t0
1769 #define t0__128a0 zdep a0,24,25,t0
1770 #define t0__t0ma0 sub t0,a0,t0
1771 #define t0__t0_a0 add t0,a0,t0
1772 #define t0__t0_2a0 sh1add a0,t0,t0
1773 #define t0__t0_4a0 sh2add a0,t0,t0
1774 #define t0__t0_8a0 sh3add a0,t0,t0
1775 #define t0__2t0_a0 sh1add t0,a0,t0
1776 #define t0__3t0 sh1add t0,t0,t0
1777 #define t0__4t0 sh2add t0,0,t0
1778 #define t0__4t0_a0 sh2add t0,a0,t0
1779 #define t0__5t0 sh2add t0,t0,t0
1780 #define t0__8t0 sh3add t0,0,t0
1781 #define t0__8t0_a0 sh3add t0,a0,t0
1782 #define t0__9t0 sh3add t0,t0,t0
1783 #define t0__16t0 zdep t0,27,28,t0
1784 #define t0__32t0 zdep t0,26,27,t0
1785 #define t0__256a0 zdep a0,23,24,t0
1793 .export $$mulI,millicode
1795 combt,<<= a1,a0,LREF(l4) /* swap args if unsigned a1>a0 */
1796 copy 0,r /* zero out the result */
1797 xor a0,a1,a0 /* swap a0 & a1 using the */
1798 xor a0,a1,a1 /* old xor trick */
1801 combt,<= 0,a0,LREF(l3) /* if a0>=0 then proceed like unsigned */
1802 zdep a1,30,8,t0 /* t0 = (a1&0xff)<<1 ********* */
1803 sub,> 0,a1,t0 /* otherwise negate both and */
1804 combt,<=,n a0,t0,LREF(l2) /* swap back if |a0|<|a1| */
1806 movb,tr,n t0,a0,LREF(l2) /* 10th inst. */
1808 LSYM(l0) r__r_t0 /* add in this partial product */
1809 LSYM(l1) a0__256a0 /* a0 <<= 8 ****************** */
1810 LSYM(l2) zdep a1,30,8,t0 /* t0 = (a1&0xff)<<1 ********* */
1811 LSYM(l3) blr t0,0 /* case on these 8 bits ****** */
1812 extru a1,23,24,a1 /* a1 >>= 8 ****************** */
1814 /*16 insts before this. */
1815 /* a0 <<= 8 ************************** */
1816 LSYM(x0) a1_ne_0_b_l2 ! a0__256a0 ! MILLIRETN ! nop
1817 LSYM(x1) a1_ne_0_b_l1 ! r__r_a0 ! MILLIRETN ! nop
1818 LSYM(x2) a1_ne_0_b_l1 ! r__r_2a0 ! MILLIRETN ! nop
1819 LSYM(x3) a1_ne_0_b_l0 ! t0__3a0 ! MILLIRET ! r__r_t0
1820 LSYM(x4) a1_ne_0_b_l1 ! r__r_4a0 ! MILLIRETN ! nop
1821 LSYM(x5) a1_ne_0_b_l0 ! t0__5a0 ! MILLIRET ! r__r_t0
1822 LSYM(x6) t0__3a0 ! a1_ne_0_b_l1 ! r__r_2t0 ! MILLIRETN
1823 LSYM(x7) t0__3a0 ! a1_ne_0_b_l0 ! r__r_4a0 ! b_n_ret_t0
1824 LSYM(x8) a1_ne_0_b_l1 ! r__r_8a0 ! MILLIRETN ! nop
1825 LSYM(x9) a1_ne_0_b_l0 ! t0__9a0 ! MILLIRET ! r__r_t0
1826 LSYM(x10) t0__5a0 ! a1_ne_0_b_l1 ! r__r_2t0 ! MILLIRETN
1827 LSYM(x11) t0__3a0 ! a1_ne_0_b_l0 ! r__r_8a0 ! b_n_ret_t0
1828 LSYM(x12) t0__3a0 ! a1_ne_0_b_l1 ! r__r_4t0 ! MILLIRETN
1829 LSYM(x13) t0__5a0 ! a1_ne_0_b_l0 ! r__r_8a0 ! b_n_ret_t0
1830 LSYM(x14) t0__3a0 ! t0__2t0_a0 ! b_e_shift ! r__r_2t0
1831 LSYM(x15) t0__5a0 ! a1_ne_0_b_l0 ! t0__3t0 ! b_n_ret_t0
1832 LSYM(x16) t0__16a0 ! a1_ne_0_b_l1 ! r__r_t0 ! MILLIRETN
1833 LSYM(x17) t0__9a0 ! a1_ne_0_b_l0 ! t0__t0_8a0 ! b_n_ret_t0
1834 LSYM(x18) t0__9a0 ! a1_ne_0_b_l1 ! r__r_2t0 ! MILLIRETN
1835 LSYM(x19) t0__9a0 ! a1_ne_0_b_l0 ! t0__2t0_a0 ! b_n_ret_t0
1836 LSYM(x20) t0__5a0 ! a1_ne_0_b_l1 ! r__r_4t0 ! MILLIRETN
1837 LSYM(x21) t0__5a0 ! a1_ne_0_b_l0 ! t0__4t0_a0 ! b_n_ret_t0
1838 LSYM(x22) t0__5a0 ! t0__2t0_a0 ! b_e_shift ! r__r_2t0
1839 LSYM(x23) t0__5a0 ! t0__2t0_a0 ! b_e_t0 ! t0__2t0_a0
1840 LSYM(x24) t0__3a0 ! a1_ne_0_b_l1 ! r__r_8t0 ! MILLIRETN
1841 LSYM(x25) t0__5a0 ! a1_ne_0_b_l0 ! t0__5t0 ! b_n_ret_t0
1842 LSYM(x26) t0__3a0 ! t0__4t0_a0 ! b_e_shift ! r__r_2t0
1843 LSYM(x27) t0__3a0 ! a1_ne_0_b_l0 ! t0__9t0 ! b_n_ret_t0
1844 LSYM(x28) t0__3a0 ! t0__2t0_a0 ! b_e_shift ! r__r_4t0
1845 LSYM(x29) t0__3a0 ! t0__2t0_a0 ! b_e_t0 ! t0__4t0_a0
1846 LSYM(x30) t0__5a0 ! t0__3t0 ! b_e_shift ! r__r_2t0
1847 LSYM(x31) t0__32a0 ! a1_ne_0_b_l0 ! t0__t0ma0 ! b_n_ret_t0
1848 LSYM(x32) t0__32a0 ! a1_ne_0_b_l1 ! r__r_t0 ! MILLIRETN
1849 LSYM(x33) t0__8a0 ! a1_ne_0_b_l0 ! t0__4t0_a0 ! b_n_ret_t0
1850 LSYM(x34) t0__16a0 ! t0__t0_a0 ! b_e_shift ! r__r_2t0
1851 LSYM(x35) t0__9a0 ! t0__3t0 ! b_e_t0 ! t0__t0_8a0
1852 LSYM(x36) t0__9a0 ! a1_ne_0_b_l1 ! r__r_4t0 ! MILLIRETN
1853 LSYM(x37) t0__9a0 ! a1_ne_0_b_l0 ! t0__4t0_a0 ! b_n_ret_t0
1854 LSYM(x38) t0__9a0 ! t0__2t0_a0 ! b_e_shift ! r__r_2t0
1855 LSYM(x39) t0__9a0 ! t0__2t0_a0 ! b_e_t0 ! t0__2t0_a0
1856 LSYM(x40) t0__5a0 ! a1_ne_0_b_l1 ! r__r_8t0 ! MILLIRETN
1857 LSYM(x41) t0__5a0 ! a1_ne_0_b_l0 ! t0__8t0_a0 ! b_n_ret_t0
1858 LSYM(x42) t0__5a0 ! t0__4t0_a0 ! b_e_shift ! r__r_2t0
1859 LSYM(x43) t0__5a0 ! t0__4t0_a0 ! b_e_t0 ! t0__2t0_a0
1860 LSYM(x44) t0__5a0 ! t0__2t0_a0 ! b_e_shift ! r__r_4t0
1861 LSYM(x45) t0__9a0 ! a1_ne_0_b_l0 ! t0__5t0 ! b_n_ret_t0
1862 LSYM(x46) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__t0_a0
1863 LSYM(x47) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__t0_2a0
1864 LSYM(x48) t0__3a0 ! a1_ne_0_b_l0 ! t0__16t0 ! b_n_ret_t0
1865 LSYM(x49) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__t0_4a0
1866 LSYM(x50) t0__5a0 ! t0__5t0 ! b_e_shift ! r__r_2t0
1867 LSYM(x51) t0__9a0 ! t0__t0_8a0 ! b_e_t0 ! t0__3t0
1868 LSYM(x52) t0__3a0 ! t0__4t0_a0 ! b_e_shift ! r__r_4t0
1869 LSYM(x53) t0__3a0 ! t0__4t0_a0 ! b_e_t0 ! t0__4t0_a0
1870 LSYM(x54) t0__9a0 ! t0__3t0 ! b_e_shift ! r__r_2t0
1871 LSYM(x55) t0__9a0 ! t0__3t0 ! b_e_t0 ! t0__2t0_a0
1872 LSYM(x56) t0__3a0 ! t0__2t0_a0 ! b_e_shift ! r__r_8t0
1873 LSYM(x57) t0__9a0 ! t0__2t0_a0 ! b_e_t0 ! t0__3t0
1874 LSYM(x58) t0__3a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__4t0_a0
1875 LSYM(x59) t0__9a0 ! t0__2t0_a0 ! b_e_t02a0 ! t0__3t0
1876 LSYM(x60) t0__5a0 ! t0__3t0 ! b_e_shift ! r__r_4t0
1877 LSYM(x61) t0__5a0 ! t0__3t0 ! b_e_t0 ! t0__4t0_a0
1878 LSYM(x62) t0__32a0 ! t0__t0ma0 ! b_e_shift ! r__r_2t0
1879 LSYM(x63) t0__64a0 ! a1_ne_0_b_l0 ! t0__t0ma0 ! b_n_ret_t0
1880 LSYM(x64) t0__64a0 ! a1_ne_0_b_l1 ! r__r_t0 ! MILLIRETN
1881 LSYM(x65) t0__8a0 ! a1_ne_0_b_l0 ! t0__8t0_a0 ! b_n_ret_t0
1882 LSYM(x66) t0__32a0 ! t0__t0_a0 ! b_e_shift ! r__r_2t0
1883 LSYM(x67) t0__8a0 ! t0__4t0_a0 ! b_e_t0 ! t0__2t0_a0
1884 LSYM(x68) t0__8a0 ! t0__2t0_a0 ! b_e_shift ! r__r_4t0
1885 LSYM(x69) t0__8a0 ! t0__2t0_a0 ! b_e_t0 ! t0__4t0_a0
1886 LSYM(x70) t0__64a0 ! t0__t0_4a0 ! b_e_t0 ! t0__t0_2a0
1887 LSYM(x71) t0__9a0 ! t0__8t0 ! b_e_t0 ! t0__t0ma0
1888 LSYM(x72) t0__9a0 ! a1_ne_0_b_l1 ! r__r_8t0 ! MILLIRETN
1889 LSYM(x73) t0__9a0 ! t0__8t0_a0 ! b_e_shift ! r__r_t0
1890 LSYM(x74) t0__9a0 ! t0__4t0_a0 ! b_e_shift ! r__r_2t0
1891 LSYM(x75) t0__9a0 ! t0__4t0_a0 ! b_e_t0 ! t0__2t0_a0
1892 LSYM(x76) t0__9a0 ! t0__2t0_a0 ! b_e_shift ! r__r_4t0
1893 LSYM(x77) t0__9a0 ! t0__2t0_a0 ! b_e_t0 ! t0__4t0_a0
1894 LSYM(x78) t0__9a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__2t0_a0
1895 LSYM(x79) t0__16a0 ! t0__5t0 ! b_e_t0 ! t0__t0ma0
1896 LSYM(x80) t0__16a0 ! t0__5t0 ! b_e_shift ! r__r_t0
1897 LSYM(x81) t0__9a0 ! t0__9t0 ! b_e_shift ! r__r_t0
1898 LSYM(x82) t0__5a0 ! t0__8t0_a0 ! b_e_shift ! r__r_2t0
1899 LSYM(x83) t0__5a0 ! t0__8t0_a0 ! b_e_t0 ! t0__2t0_a0
1900 LSYM(x84) t0__5a0 ! t0__4t0_a0 ! b_e_shift ! r__r_4t0
1901 LSYM(x85) t0__8a0 ! t0__2t0_a0 ! b_e_t0 ! t0__5t0
1902 LSYM(x86) t0__5a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__2t0_a0
1903 LSYM(x87) t0__9a0 ! t0__9t0 ! b_e_t02a0 ! t0__t0_4a0
1904 LSYM(x88) t0__5a0 ! t0__2t0_a0 ! b_e_shift ! r__r_8t0
1905 LSYM(x89) t0__5a0 ! t0__2t0_a0 ! b_e_t0 ! t0__8t0_a0
1906 LSYM(x90) t0__9a0 ! t0__5t0 ! b_e_shift ! r__r_2t0
1907 LSYM(x91) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__2t0_a0
1908 LSYM(x92) t0__5a0 ! t0__2t0_a0 ! b_e_4t0 ! t0__2t0_a0
1909 LSYM(x93) t0__32a0 ! t0__t0ma0 ! b_e_t0 ! t0__3t0
1910 LSYM(x94) t0__9a0 ! t0__5t0 ! b_e_2t0 ! t0__t0_2a0
1911 LSYM(x95) t0__9a0 ! t0__2t0_a0 ! b_e_t0 ! t0__5t0
1912 LSYM(x96) t0__8a0 ! t0__3t0 ! b_e_shift ! r__r_4t0
1913 LSYM(x97) t0__8a0 ! t0__3t0 ! b_e_t0 ! t0__4t0_a0
1914 LSYM(x98) t0__32a0 ! t0__3t0 ! b_e_t0 ! t0__t0_2a0
1915 LSYM(x99) t0__8a0 ! t0__4t0_a0 ! b_e_t0 ! t0__3t0
1916 LSYM(x100) t0__5a0 ! t0__5t0 ! b_e_shift ! r__r_4t0
1917 LSYM(x101) t0__5a0 ! t0__5t0 ! b_e_t0 ! t0__4t0_a0
1918 LSYM(x102) t0__32a0 ! t0__t0_2a0 ! b_e_t0 ! t0__3t0
1919 LSYM(x103) t0__5a0 ! t0__5t0 ! b_e_t02a0 ! t0__4t0_a0
1920 LSYM(x104) t0__3a0 ! t0__4t0_a0 ! b_e_shift ! r__r_8t0
1921 LSYM(x105) t0__5a0 ! t0__4t0_a0 ! b_e_t0 ! t0__5t0
1922 LSYM(x106) t0__3a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__4t0_a0
1923 LSYM(x107) t0__9a0 ! t0__t0_4a0 ! b_e_t02a0 ! t0__8t0_a0
1924 LSYM(x108) t0__9a0 ! t0__3t0 ! b_e_shift ! r__r_4t0
1925 LSYM(x109) t0__9a0 ! t0__3t0 ! b_e_t0 ! t0__4t0_a0
1926 LSYM(x110) t0__9a0 ! t0__3t0 ! b_e_2t0 ! t0__2t0_a0
1927 LSYM(x111) t0__9a0 ! t0__4t0_a0 ! b_e_t0 ! t0__3t0
1928 LSYM(x112) t0__3a0 ! t0__2t0_a0 ! b_e_t0 ! t0__16t0
1929 LSYM(x113) t0__9a0 ! t0__4t0_a0 ! b_e_t02a0 ! t0__3t0
1930 LSYM(x114) t0__9a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__3t0
1931 LSYM(x115) t0__9a0 ! t0__2t0_a0 ! b_e_2t0a0 ! t0__3t0
1932 LSYM(x116) t0__3a0 ! t0__2t0_a0 ! b_e_4t0 ! t0__4t0_a0
1933 LSYM(x117) t0__3a0 ! t0__4t0_a0 ! b_e_t0 ! t0__9t0
1934 LSYM(x118) t0__3a0 ! t0__4t0_a0 ! b_e_t0a0 ! t0__9t0
1935 LSYM(x119) t0__3a0 ! t0__4t0_a0 ! b_e_t02a0 ! t0__9t0
1936 LSYM(x120) t0__5a0 ! t0__3t0 ! b_e_shift ! r__r_8t0
1937 LSYM(x121) t0__5a0 ! t0__3t0 ! b_e_t0 ! t0__8t0_a0
1938 LSYM(x122) t0__5a0 ! t0__3t0 ! b_e_2t0 ! t0__4t0_a0
1939 LSYM(x123) t0__5a0 ! t0__8t0_a0 ! b_e_t0 ! t0__3t0
1940 LSYM(x124) t0__32a0 ! t0__t0ma0 ! b_e_shift ! r__r_4t0
1941 LSYM(x125) t0__5a0 ! t0__5t0 ! b_e_t0 ! t0__5t0
1942 LSYM(x126) t0__64a0 ! t0__t0ma0 ! b_e_shift ! r__r_2t0
1943 LSYM(x127) t0__128a0 ! a1_ne_0_b_l0 ! t0__t0ma0 ! b_n_ret_t0
1944 LSYM(x128) t0__128a0 ! a1_ne_0_b_l1 ! r__r_t0 ! MILLIRETN
1945 LSYM(x129) t0__128a0 ! a1_ne_0_b_l0 ! t0__t0_a0 ! b_n_ret_t0
1946 LSYM(x130) t0__64a0 ! t0__t0_a0 ! b_e_shift ! r__r_2t0
1947 LSYM(x131) t0__8a0 ! t0__8t0_a0 ! b_e_t0 ! t0__2t0_a0
1948 LSYM(x132) t0__8a0 ! t0__4t0_a0 ! b_e_shift ! r__r_4t0
1949 LSYM(x133) t0__8a0 ! t0__4t0_a0 ! b_e_t0 ! t0__4t0_a0
1950 LSYM(x134) t0__8a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__2t0_a0
1951 LSYM(x135) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__3t0
1952 LSYM(x136) t0__8a0 ! t0__2t0_a0 ! b_e_shift ! r__r_8t0
1953 LSYM(x137) t0__8a0 ! t0__2t0_a0 ! b_e_t0 ! t0__8t0_a0
1954 LSYM(x138) t0__8a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__4t0_a0
1955 LSYM(x139) t0__8a0 ! t0__2t0_a0 ! b_e_2t0a0 ! t0__4t0_a0
1956 LSYM(x140) t0__3a0 ! t0__2t0_a0 ! b_e_4t0 ! t0__5t0
1957 LSYM(x141) t0__8a0 ! t0__2t0_a0 ! b_e_4t0a0 ! t0__2t0_a0
1958 LSYM(x142) t0__9a0 ! t0__8t0 ! b_e_2t0 ! t0__t0ma0
1959 LSYM(x143) t0__16a0 ! t0__9t0 ! b_e_t0 ! t0__t0ma0
1960 LSYM(x144) t0__9a0 ! t0__8t0 ! b_e_shift ! r__r_2t0
1961 LSYM(x145) t0__9a0 ! t0__8t0 ! b_e_t0 ! t0__2t0_a0
1962 LSYM(x146) t0__9a0 ! t0__8t0_a0 ! b_e_shift ! r__r_2t0
1963 LSYM(x147) t0__9a0 ! t0__8t0_a0 ! b_e_t0 ! t0__2t0_a0
1964 LSYM(x148) t0__9a0 ! t0__4t0_a0 ! b_e_shift ! r__r_4t0
1965 LSYM(x149) t0__9a0 ! t0__4t0_a0 ! b_e_t0 ! t0__4t0_a0
1966 LSYM(x150) t0__9a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__2t0_a0
1967 LSYM(x151) t0__9a0 ! t0__4t0_a0 ! b_e_2t0a0 ! t0__2t0_a0
1968 LSYM(x152) t0__9a0 ! t0__2t0_a0 ! b_e_shift ! r__r_8t0
1969 LSYM(x153) t0__9a0 ! t0__2t0_a0 ! b_e_t0 ! t0__8t0_a0
1970 LSYM(x154) t0__9a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__4t0_a0
1971 LSYM(x155) t0__32a0 ! t0__t0ma0 ! b_e_t0 ! t0__5t0
1972 LSYM(x156) t0__9a0 ! t0__2t0_a0 ! b_e_4t0 ! t0__2t0_a0
1973 LSYM(x157) t0__32a0 ! t0__t0ma0 ! b_e_t02a0 ! t0__5t0
1974 LSYM(x158) t0__16a0 ! t0__5t0 ! b_e_2t0 ! t0__t0ma0
1975 LSYM(x159) t0__32a0 ! t0__5t0 ! b_e_t0 ! t0__t0ma0
1976 LSYM(x160) t0__5a0 ! t0__4t0 ! b_e_shift ! r__r_8t0
1977 LSYM(x161) t0__8a0 ! t0__5t0 ! b_e_t0 ! t0__4t0_a0
1978 LSYM(x162) t0__9a0 ! t0__9t0 ! b_e_shift ! r__r_2t0
1979 LSYM(x163) t0__9a0 ! t0__9t0 ! b_e_t0 ! t0__2t0_a0
1980 LSYM(x164) t0__5a0 ! t0__8t0_a0 ! b_e_shift ! r__r_4t0
1981 LSYM(x165) t0__8a0 ! t0__4t0_a0 ! b_e_t0 ! t0__5t0
1982 LSYM(x166) t0__5a0 ! t0__8t0_a0 ! b_e_2t0 ! t0__2t0_a0
1983 LSYM(x167) t0__5a0 ! t0__8t0_a0 ! b_e_2t0a0 ! t0__2t0_a0
1984 LSYM(x168) t0__5a0 ! t0__4t0_a0 ! b_e_shift ! r__r_8t0
1985 LSYM(x169) t0__5a0 ! t0__4t0_a0 ! b_e_t0 ! t0__8t0_a0
1986 LSYM(x170) t0__32a0 ! t0__t0_2a0 ! b_e_t0 ! t0__5t0
1987 LSYM(x171) t0__9a0 ! t0__2t0_a0 ! b_e_t0 ! t0__9t0
1988 LSYM(x172) t0__5a0 ! t0__4t0_a0 ! b_e_4t0 ! t0__2t0_a0
1989 LSYM(x173) t0__9a0 ! t0__2t0_a0 ! b_e_t02a0 ! t0__9t0
1990 LSYM(x174) t0__32a0 ! t0__t0_2a0 ! b_e_t04a0 ! t0__5t0
1991 LSYM(x175) t0__8a0 ! t0__2t0_a0 ! b_e_5t0 ! t0__2t0_a0
1992 LSYM(x176) t0__5a0 ! t0__4t0_a0 ! b_e_8t0 ! t0__t0_a0
1993 LSYM(x177) t0__5a0 ! t0__4t0_a0 ! b_e_8t0a0 ! t0__t0_a0
1994 LSYM(x178) t0__5a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__8t0_a0
1995 LSYM(x179) t0__5a0 ! t0__2t0_a0 ! b_e_2t0a0 ! t0__8t0_a0
1996 LSYM(x180) t0__9a0 ! t0__5t0 ! b_e_shift ! r__r_4t0
1997 LSYM(x181) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__4t0_a0
1998 LSYM(x182) t0__9a0 ! t0__5t0 ! b_e_2t0 ! t0__2t0_a0
1999 LSYM(x183) t0__9a0 ! t0__5t0 ! b_e_2t0a0 ! t0__2t0_a0
2000 LSYM(x184) t0__5a0 ! t0__9t0 ! b_e_4t0 ! t0__t0_a0
2001 LSYM(x185) t0__9a0 ! t0__4t0_a0 ! b_e_t0 ! t0__5t0
2002 LSYM(x186) t0__32a0 ! t0__t0ma0 ! b_e_2t0 ! t0__3t0
2003 LSYM(x187) t0__9a0 ! t0__4t0_a0 ! b_e_t02a0 ! t0__5t0
2004 LSYM(x188) t0__9a0 ! t0__5t0 ! b_e_4t0 ! t0__t0_2a0
2005 LSYM(x189) t0__5a0 ! t0__4t0_a0 ! b_e_t0 ! t0__9t0
2006 LSYM(x190) t0__9a0 ! t0__2t0_a0 ! b_e_2t0 ! t0__5t0
2007 LSYM(x191) t0__64a0 ! t0__3t0 ! b_e_t0 ! t0__t0ma0
2008 LSYM(x192) t0__8a0 ! t0__3t0 ! b_e_shift ! r__r_8t0
2009 LSYM(x193) t0__8a0 ! t0__3t0 ! b_e_t0 ! t0__8t0_a0
2010 LSYM(x194) t0__8a0 ! t0__3t0 ! b_e_2t0 ! t0__4t0_a0
2011 LSYM(x195) t0__8a0 ! t0__8t0_a0 ! b_e_t0 ! t0__3t0
2012 LSYM(x196) t0__8a0 ! t0__3t0 ! b_e_4t0 ! t0__2t0_a0
2013 LSYM(x197) t0__8a0 ! t0__3t0 ! b_e_4t0a0 ! t0__2t0_a0
2014 LSYM(x198) t0__64a0 ! t0__t0_2a0 ! b_e_t0 ! t0__3t0
2015 LSYM(x199) t0__8a0 ! t0__4t0_a0 ! b_e_2t0a0 ! t0__3t0
2016 LSYM(x200) t0__5a0 ! t0__5t0 ! b_e_shift ! r__r_8t0
2017 LSYM(x201) t0__5a0 ! t0__5t0 ! b_e_t0 ! t0__8t0_a0
2018 LSYM(x202) t0__5a0 ! t0__5t0 ! b_e_2t0 ! t0__4t0_a0
2019 LSYM(x203) t0__5a0 ! t0__5t0 ! b_e_2t0a0 ! t0__4t0_a0
2020 LSYM(x204) t0__8a0 ! t0__2t0_a0 ! b_e_4t0 ! t0__3t0
2021 LSYM(x205) t0__5a0 ! t0__8t0_a0 ! b_e_t0 ! t0__5t0
2022 LSYM(x206) t0__64a0 ! t0__t0_4a0 ! b_e_t02a0 ! t0__3t0
2023 LSYM(x207) t0__8a0 ! t0__2t0_a0 ! b_e_3t0 ! t0__4t0_a0
2024 LSYM(x208) t0__5a0 ! t0__5t0 ! b_e_8t0 ! t0__t0_a0
2025 LSYM(x209) t0__5a0 ! t0__5t0 ! b_e_8t0a0 ! t0__t0_a0
2026 LSYM(x210) t0__5a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__5t0
2027 LSYM(x211) t0__5a0 ! t0__4t0_a0 ! b_e_2t0a0 ! t0__5t0
2028 LSYM(x212) t0__3a0 ! t0__4t0_a0 ! b_e_4t0 ! t0__4t0_a0
2029 LSYM(x213) t0__3a0 ! t0__4t0_a0 ! b_e_4t0a0 ! t0__4t0_a0
2030 LSYM(x214) t0__9a0 ! t0__t0_4a0 ! b_e_2t04a0 ! t0__8t0_a0
2031 LSYM(x215) t0__5a0 ! t0__4t0_a0 ! b_e_5t0 ! t0__2t0_a0
2032 LSYM(x216) t0__9a0 ! t0__3t0 ! b_e_shift ! r__r_8t0
2033 LSYM(x217) t0__9a0 ! t0__3t0 ! b_e_t0 ! t0__8t0_a0
2034 LSYM(x218) t0__9a0 ! t0__3t0 ! b_e_2t0 ! t0__4t0_a0
2035 LSYM(x219) t0__9a0 ! t0__8t0_a0 ! b_e_t0 ! t0__3t0
2036 LSYM(x220) t0__3a0 ! t0__9t0 ! b_e_4t0 ! t0__2t0_a0
2037 LSYM(x221) t0__3a0 ! t0__9t0 ! b_e_4t0a0 ! t0__2t0_a0
2038 LSYM(x222) t0__9a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__3t0
2039 LSYM(x223) t0__9a0 ! t0__4t0_a0 ! b_e_2t0a0 ! t0__3t0
2040 LSYM(x224) t0__9a0 ! t0__3t0 ! b_e_8t0 ! t0__t0_a0
2041 LSYM(x225) t0__9a0 ! t0__5t0 ! b_e_t0 ! t0__5t0
2042 LSYM(x226) t0__3a0 ! t0__2t0_a0 ! b_e_t02a0 ! t0__32t0
2043 LSYM(x227) t0__9a0 ! t0__5t0 ! b_e_t02a0 ! t0__5t0
2044 LSYM(x228) t0__9a0 ! t0__2t0_a0 ! b_e_4t0 ! t0__3t0
2045 LSYM(x229) t0__9a0 ! t0__2t0_a0 ! b_e_4t0a0 ! t0__3t0
2046 LSYM(x230) t0__9a0 ! t0__5t0 ! b_e_5t0 ! t0__t0_a0
2047 LSYM(x231) t0__9a0 ! t0__2t0_a0 ! b_e_3t0 ! t0__4t0_a0
2048 LSYM(x232) t0__3a0 ! t0__2t0_a0 ! b_e_8t0 ! t0__4t0_a0
2049 LSYM(x233) t0__3a0 ! t0__2t0_a0 ! b_e_8t0a0 ! t0__4t0_a0
2050 LSYM(x234) t0__3a0 ! t0__4t0_a0 ! b_e_2t0 ! t0__9t0
2051 LSYM(x235) t0__3a0 ! t0__4t0_a0 ! b_e_2t0a0 ! t0__9t0
2052 LSYM(x236) t0__9a0 ! t0__2t0_a0 ! b_e_4t08a0 ! t0__3t0
2053 LSYM(x237) t0__16a0 ! t0__5t0 ! b_e_3t0 ! t0__t0ma0
2054 LSYM(x238) t0__3a0 ! t0__4t0_a0 ! b_e_2t04a0 ! t0__9t0
2055 LSYM(x239) t0__16a0 ! t0__5t0 ! b_e_t0ma0 ! t0__3t0
2056 LSYM(x240) t0__9a0 ! t0__t0_a0 ! b_e_8t0 ! t0__3t0
2057 LSYM(x241) t0__9a0 ! t0__t0_a0 ! b_e_8t0a0 ! t0__3t0
2058 LSYM(x242) t0__5a0 ! t0__3t0 ! b_e_2t0 ! t0__8t0_a0
2059 LSYM(x243) t0__9a0 ! t0__9t0 ! b_e_t0 ! t0__3t0
2060 LSYM(x244) t0__5a0 ! t0__3t0 ! b_e_4t0 ! t0__4t0_a0
2061 LSYM(x245) t0__8a0 ! t0__3t0 ! b_e_5t0 ! t0__2t0_a0
2062 LSYM(x246) t0__5a0 ! t0__8t0_a0 ! b_e_2t0 ! t0__3t0
2063 LSYM(x247) t0__5a0 ! t0__8t0_a0 ! b_e_2t0a0 ! t0__3t0
2064 LSYM(x248) t0__32a0 ! t0__t0ma0 ! b_e_shift ! r__r_8t0
2065 LSYM(x249) t0__32a0 ! t0__t0ma0 ! b_e_t0 ! t0__8t0_a0
2066 LSYM(x250) t0__5a0 ! t0__5t0 ! b_e_2t0 ! t0__5t0
2067 LSYM(x251) t0__5a0 ! t0__5t0 ! b_e_2t0a0 ! t0__5t0
2068 LSYM(x252) t0__64a0 ! t0__t0ma0 ! b_e_shift ! r__r_4t0
2069 LSYM(x253) t0__64a0 ! t0__t0ma0 ! b_e_t0 ! t0__4t0_a0
2070 LSYM(x254) t0__128a0 ! t0__t0ma0 ! b_e_shift ! r__r_2t0
2071 LSYM(x255) t0__256a0 ! a1_ne_0_b_l0 ! t0__t0ma0 ! b_n_ret_t0
2072 /*1040 insts before this. */
2073 LSYM(ret_t0) MILLIRET
2075 LSYM(e_shift) a1_ne_0_b_l2
2076 a0__256a0 /* a0 <<= 8 *********** */
2078 LSYM(e_t0ma0) a1_ne_0_b_l0
2082 LSYM(e_t0a0) a1_ne_0_b_l0
2086 LSYM(e_t02a0) a1_ne_0_b_l0
2090 LSYM(e_t04a0) a1_ne_0_b_l0
2094 LSYM(e_2t0) a1_ne_0_b_l1
2097 LSYM(e_2t0a0) a1_ne_0_b_l0
2101 LSYM(e2t04a0) t0__t0_2a0
2105 LSYM(e_3t0) a1_ne_0_b_l0
2109 LSYM(e_4t0) a1_ne_0_b_l1
2112 LSYM(e_4t0a0) a1_ne_0_b_l0
2116 LSYM(e4t08a0) t0__t0_2a0
2120 LSYM(e_5t0) a1_ne_0_b_l0
2124 LSYM(e_8t0) a1_ne_0_b_l1
2127 LSYM(e_8t0a0) a1_ne_0_b_l0