OSDN Git Service

* config/pa/fptr.c: Update license header.
[pf3gnuchains/gcc-fork.git] / gcc / config / pa / milli64.S
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>.
4
5    Copyright 2001, 2002, 2003, 2007 Free Software Foundation, Inc.
6
7 This file is part of GCC.
8
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 2, or (at your option) any later
12 version.
13
14 In addition to the permissions in the GNU General Public License, the
15 Free Software Foundation gives you unlimited permission to link the
16 compiled version of this file into combinations with other programs,
17 and to distribute those combinations without any restriction coming
18 from the use of this file.  (The General Public License restrictions
19 do apply in other respects; for example, they cover modification of
20 the file, and distribution when not linked into a combine
21 executable.)
22
23 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
24 WARRANTY; without even the implied warranty of MERCHANTABILITY or
25 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
26 for more details.
27
28 You should have received a copy of the GNU General Public License
29 along with GCC; see the file COPYING.  If not, write to the Free
30 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
31 02110-1301, USA.  */
32
33 #ifdef pa64
34         .level  2.0w
35 #endif
36
37 /* Hardware General Registers.  */
38 r0:     .reg    %r0
39 r1:     .reg    %r1
40 r2:     .reg    %r2
41 r3:     .reg    %r3
42 r4:     .reg    %r4
43 r5:     .reg    %r5
44 r6:     .reg    %r6
45 r7:     .reg    %r7
46 r8:     .reg    %r8
47 r9:     .reg    %r9
48 r10:    .reg    %r10
49 r11:    .reg    %r11
50 r12:    .reg    %r12
51 r13:    .reg    %r13
52 r14:    .reg    %r14
53 r15:    .reg    %r15
54 r16:    .reg    %r16
55 r17:    .reg    %r17
56 r18:    .reg    %r18
57 r19:    .reg    %r19
58 r20:    .reg    %r20
59 r21:    .reg    %r21
60 r22:    .reg    %r22
61 r23:    .reg    %r23
62 r24:    .reg    %r24
63 r25:    .reg    %r25
64 r26:    .reg    %r26
65 r27:    .reg    %r27
66 r28:    .reg    %r28
67 r29:    .reg    %r29
68 r30:    .reg    %r30
69 r31:    .reg    %r31
70
71 /* Hardware Space Registers.  */
72 sr0:    .reg    %sr0
73 sr1:    .reg    %sr1
74 sr2:    .reg    %sr2
75 sr3:    .reg    %sr3
76 sr4:    .reg    %sr4
77 sr5:    .reg    %sr5
78 sr6:    .reg    %sr6
79 sr7:    .reg    %sr7
80
81 /* Hardware Floating Point Registers.  */
82 fr0:    .reg    %fr0
83 fr1:    .reg    %fr1
84 fr2:    .reg    %fr2
85 fr3:    .reg    %fr3
86 fr4:    .reg    %fr4
87 fr5:    .reg    %fr5
88 fr6:    .reg    %fr6
89 fr7:    .reg    %fr7
90 fr8:    .reg    %fr8
91 fr9:    .reg    %fr9
92 fr10:   .reg    %fr10
93 fr11:   .reg    %fr11
94 fr12:   .reg    %fr12
95 fr13:   .reg    %fr13
96 fr14:   .reg    %fr14
97 fr15:   .reg    %fr15
98
99 /* Hardware Control Registers.  */
100 cr11:   .reg    %cr11
101 sar:    .reg    %cr11   /* Shift Amount Register */
102
103 /* Software Architecture General Registers.  */
104 rp:     .reg    r2      /* return pointer */
105 #ifdef pa64
106 mrp:    .reg    r2      /* millicode return pointer */
107 #else
108 mrp:    .reg    r31     /* millicode return pointer */
109 #endif
110 ret0:   .reg    r28     /* return value */
111 ret1:   .reg    r29     /* return value (high part of double) */
112 sp:     .reg    r30     /* stack pointer */
113 dp:     .reg    r27     /* data pointer */
114 arg0:   .reg    r26     /* argument */
115 arg1:   .reg    r25     /* argument or high part of double argument */
116 arg2:   .reg    r24     /* argument */
117 arg3:   .reg    r23     /* argument or high part of double argument */
118
119 /* Software Architecture Space Registers.  */
120 /*              sr0     ; return link from BLE */
121 sret:   .reg    sr1     /* return value */
122 sarg:   .reg    sr1     /* argument */
123 /*              sr4     ; PC SPACE tracker */
124 /*              sr5     ; process private data */
125
126 /* Frame Offsets (millicode convention!)  Used when calling other
127    millicode routines.  Stack unwinding is dependent upon these
128    definitions.  */
129 r31_slot:       .equ    -20     /* "current RP" slot */
130 sr0_slot:       .equ    -16     /* "static link" slot */
131 #if defined(pa64)
132 mrp_slot:       .equ    -16     /* "current RP" slot */
133 psp_slot:       .equ    -8      /* "previous SP" slot */
134 #else
135 mrp_slot:       .equ    -20     /* "current RP" slot (replacing "r31_slot") */
136 #endif
137
138
139 #define DEFINE(name,value)name: .EQU    value
140 #define RDEFINE(name,value)name:        .REG    value
141 #ifdef milliext
142 #define MILLI_BE(lbl)   BE    lbl(sr7,r0)
143 #define MILLI_BEN(lbl)  BE,n  lbl(sr7,r0)
144 #define MILLI_BLE(lbl)  BLE   lbl(sr7,r0)
145 #define MILLI_BLEN(lbl) BLE,n lbl(sr7,r0)
146 #define MILLIRETN       BE,n  0(sr0,mrp)
147 #define MILLIRET        BE    0(sr0,mrp)
148 #define MILLI_RETN      BE,n  0(sr0,mrp)
149 #define MILLI_RET       BE    0(sr0,mrp)
150 #else
151 #define MILLI_BE(lbl)   B     lbl
152 #define MILLI_BEN(lbl)  B,n   lbl
153 #define MILLI_BLE(lbl)  BL    lbl,mrp
154 #define MILLI_BLEN(lbl) BL,n  lbl,mrp
155 #define MILLIRETN       BV,n  0(mrp)
156 #define MILLIRET        BV    0(mrp)
157 #define MILLI_RETN      BV,n  0(mrp)
158 #define MILLI_RET       BV    0(mrp)
159 #endif
160
161 #ifdef __STDC__
162 #define CAT(a,b)        a##b
163 #else
164 #define CAT(a,b)        a/**/b
165 #endif
166
167 #ifdef ELF
168 #define SUBSPA_MILLI     .section .text
169 #define SUBSPA_MILLI_DIV .section .text.div,"ax",@progbits! .align 16
170 #define SUBSPA_MILLI_MUL .section .text.mul,"ax",@progbits! .align 16
171 #define ATTR_MILLI
172 #define SUBSPA_DATA      .section .data
173 #define ATTR_DATA
174 #define GLOBAL           $global$
175 #define GSYM(sym)        !sym:
176 #define LSYM(sym)        !CAT(.L,sym:)
177 #define LREF(sym)        CAT(.L,sym)
178
179 #else
180
181 #ifdef coff
182 /* This used to be .milli but since link32 places different named
183    sections in different segments millicode ends up a long ways away
184    from .text (1meg?).  This way they will be a lot closer.
185
186    The SUBSPA_MILLI_* specify locality sets for certain millicode
187    modules in order to ensure that modules that call one another are
188    placed close together. Without locality sets this is unlikely to
189    happen because of the Dynamite linker library search algorithm. We
190    want these modules close together so that short calls always reach
191    (we don't want to require long calls or use long call stubs).  */
192
193 #define SUBSPA_MILLI     .subspa .text
194 #define SUBSPA_MILLI_DIV .subspa .text$dv,align=16
195 #define SUBSPA_MILLI_MUL .subspa .text$mu,align=16
196 #define ATTR_MILLI       .attr code,read,execute
197 #define SUBSPA_DATA      .subspa .data
198 #define ATTR_DATA        .attr init_data,read,write
199 #define GLOBAL           _gp
200 #else
201 #define SUBSPA_MILLI     .subspa $MILLICODE$,QUAD=0,ALIGN=4,ACCESS=0x2c,SORT=8
202 #define SUBSPA_MILLI_DIV SUBSPA_MILLI
203 #define SUBSPA_MILLI_MUL SUBSPA_MILLI
204 #define ATTR_MILLI
205 #define SUBSPA_DATA      .subspa $BSS$,quad=1,align=8,access=0x1f,sort=80,zero
206 #define ATTR_DATA
207 #define GLOBAL           $global$
208 #endif
209 #define SPACE_DATA       .space $PRIVATE$,spnum=1,sort=16
210
211 #define GSYM(sym)        !sym
212 #define LSYM(sym)        !CAT(L$,sym)
213 #define LREF(sym)        CAT(L$,sym)
214 #endif
215
216 #ifdef L_dyncall
217         SUBSPA_MILLI
218         ATTR_DATA
219 GSYM($$dyncall)
220         .export $$dyncall,millicode
221         .proc
222         .callinfo       millicode
223         .entry
224         bb,>=,n %r22,30,LREF(1)         ; branch if not plabel address
225         depi    0,31,2,%r22             ; clear the two least significant bits
226         ldw     4(%r22),%r19            ; load new LTP value
227         ldw     0(%r22),%r22            ; load address of target
228 LSYM(1)
229 #ifdef LINUX
230         bv      %r0(%r22)               ; branch to the real target
231 #else
232         ldsid   (%sr0,%r22),%r1         ; get the "space ident" selected by r22
233         mtsp    %r1,%sr0                ; move that space identifier into sr0
234         be      0(%sr0,%r22)            ; branch to the real target
235 #endif
236         stw     %r2,-24(%r30)           ; save return address into frame marker
237         .exit
238         .procend
239 #endif
240
241 #ifdef L_divI
242 /* ROUTINES:    $$divI, $$divoI
243
244    Single precision divide for signed binary integers.
245
246    The quotient is truncated towards zero.
247    The sign of the quotient is the XOR of the signs of the dividend and
248    divisor.
249    Divide by zero is trapped.
250    Divide of -2**31 by -1 is trapped for $$divoI but not for $$divI.
251
252    INPUT REGISTERS:
253    .    arg0 == dividend
254    .    arg1 == divisor
255    .    mrp  == return pc
256    .    sr0  == return space when called externally
257
258    OUTPUT REGISTERS:
259    .    arg0 =  undefined
260    .    arg1 =  undefined
261    .    ret1 =  quotient
262
263    OTHER REGISTERS AFFECTED:
264    .    r1   =  undefined
265
266    SIDE EFFECTS:
267    .    Causes a trap under the following conditions:
268    .            divisor is zero  (traps with ADDIT,=  0,25,0)
269    .            dividend==-2**31  and divisor==-1 and routine is $$divoI
270    .                             (traps with ADDO  26,25,0)
271    .    Changes memory at the following places:
272    .            NONE
273
274    PERMISSIBLE CONTEXT:
275    .    Unwindable.
276    .    Suitable for internal or external millicode.
277    .    Assumes the special millicode register conventions.
278
279    DISCUSSION:
280    .    Branchs to other millicode routines using BE
281    .            $$div_# for # being 2,3,4,5,6,7,8,9,10,12,14,15
282    .
283    .    For selected divisors, calls a divide by constant routine written by
284    .    Karl Pettis.  Eligible divisors are 1..15 excluding 11 and 13.
285    .
286    .    The only overflow case is -2**31 divided by -1.
287    .    Both routines return -2**31 but only $$divoI traps.  */
288
289 RDEFINE(temp,r1)
290 RDEFINE(retreg,ret1)    /*  r29 */
291 RDEFINE(temp1,arg0)
292         SUBSPA_MILLI_DIV
293         ATTR_MILLI
294         .import $$divI_2,millicode
295         .import $$divI_3,millicode
296         .import $$divI_4,millicode
297         .import $$divI_5,millicode
298         .import $$divI_6,millicode
299         .import $$divI_7,millicode
300         .import $$divI_8,millicode
301         .import $$divI_9,millicode
302         .import $$divI_10,millicode
303         .import $$divI_12,millicode
304         .import $$divI_14,millicode
305         .import $$divI_15,millicode
306         .export $$divI,millicode
307         .export $$divoI,millicode
308         .proc
309         .callinfo       millicode
310         .entry
311 GSYM($$divoI)
312         comib,=,n  -1,arg1,LREF(negative1)      /*  when divisor == -1 */
313 GSYM($$divI)
314         ldo     -1(arg1),temp           /*  is there at most one bit set ? */
315         and,<>  arg1,temp,r0            /*  if not, don't use power of 2 divide */
316         addi,>  0,arg1,r0               /*  if divisor > 0, use power of 2 divide */
317         b,n     LREF(neg_denom)
318 LSYM(pow2)
319         addi,>= 0,arg0,retreg           /*  if numerator is negative, add the */
320         add     arg0,temp,retreg        /*  (denominaotr -1) to correct for shifts */
321         extru,= arg1,15,16,temp         /*  test denominator with 0xffff0000 */
322         extrs   retreg,15,16,retreg     /*  retreg = retreg >> 16 */
323         or      arg1,temp,arg1          /*  arg1 = arg1 | (arg1 >> 16) */
324         ldi     0xcc,temp1              /*  setup 0xcc in temp1 */
325         extru,= arg1,23,8,temp          /*  test denominator with 0xff00 */
326         extrs   retreg,23,24,retreg     /*  retreg = retreg >> 8 */
327         or      arg1,temp,arg1          /*  arg1 = arg1 | (arg1 >> 8) */
328         ldi     0xaa,temp               /*  setup 0xaa in temp */
329         extru,= arg1,27,4,r0            /*  test denominator with 0xf0 */
330         extrs   retreg,27,28,retreg     /*  retreg = retreg >> 4 */
331         and,=   arg1,temp1,r0           /*  test denominator with 0xcc */
332         extrs   retreg,29,30,retreg     /*  retreg = retreg >> 2 */
333         and,=   arg1,temp,r0            /*  test denominator with 0xaa */
334         extrs   retreg,30,31,retreg     /*  retreg = retreg >> 1 */
335         MILLIRETN
336 LSYM(neg_denom)
337         addi,<  0,arg1,r0               /*  if arg1 >= 0, it's not power of 2 */
338         b,n     LREF(regular_seq)
339         sub     r0,arg1,temp            /*  make denominator positive */
340         comb,=,n  arg1,temp,LREF(regular_seq)   /*  test against 0x80000000 and 0 */
341         ldo     -1(temp),retreg         /*  is there at most one bit set ? */
342         and,=   temp,retreg,r0          /*  if so, the denominator is power of 2 */
343         b,n     LREF(regular_seq)
344         sub     r0,arg0,retreg          /*  negate numerator */
345         comb,=,n arg0,retreg,LREF(regular_seq) /*  test against 0x80000000 */
346         copy    retreg,arg0             /*  set up arg0, arg1 and temp  */
347         copy    temp,arg1               /*  before branching to pow2 */
348         b       LREF(pow2)
349         ldo     -1(arg1),temp
350 LSYM(regular_seq)
351         comib,>>=,n 15,arg1,LREF(small_divisor)
352         add,>=  0,arg0,retreg           /*  move dividend, if retreg < 0, */
353 LSYM(normal)
354         subi    0,retreg,retreg         /*    make it positive */
355         sub     0,arg1,temp             /*  clear carry,  */
356                                         /*    negate the divisor */
357         ds      0,temp,0                /*  set V-bit to the comple- */
358                                         /*    ment of the divisor sign */
359         add     retreg,retreg,retreg    /*  shift msb bit into carry */
360         ds      r0,arg1,temp            /*  1st divide step, if no carry */
361         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
362         ds      temp,arg1,temp          /*  2nd divide step */
363         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
364         ds      temp,arg1,temp          /*  3rd divide step */
365         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
366         ds      temp,arg1,temp          /*  4th divide step */
367         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
368         ds      temp,arg1,temp          /*  5th divide step */
369         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
370         ds      temp,arg1,temp          /*  6th divide step */
371         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
372         ds      temp,arg1,temp          /*  7th divide step */
373         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
374         ds      temp,arg1,temp          /*  8th divide step */
375         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
376         ds      temp,arg1,temp          /*  9th divide step */
377         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
378         ds      temp,arg1,temp          /*  10th divide step */
379         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
380         ds      temp,arg1,temp          /*  11th divide step */
381         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
382         ds      temp,arg1,temp          /*  12th divide step */
383         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
384         ds      temp,arg1,temp          /*  13th divide step */
385         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
386         ds      temp,arg1,temp          /*  14th divide step */
387         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
388         ds      temp,arg1,temp          /*  15th divide step */
389         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
390         ds      temp,arg1,temp          /*  16th divide step */
391         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
392         ds      temp,arg1,temp          /*  17th divide step */
393         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
394         ds      temp,arg1,temp          /*  18th divide step */
395         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
396         ds      temp,arg1,temp          /*  19th divide step */
397         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
398         ds      temp,arg1,temp          /*  20th divide step */
399         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
400         ds      temp,arg1,temp          /*  21st divide step */
401         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
402         ds      temp,arg1,temp          /*  22nd divide step */
403         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
404         ds      temp,arg1,temp          /*  23rd divide step */
405         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
406         ds      temp,arg1,temp          /*  24th divide step */
407         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
408         ds      temp,arg1,temp          /*  25th divide step */
409         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
410         ds      temp,arg1,temp          /*  26th divide step */
411         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
412         ds      temp,arg1,temp          /*  27th divide step */
413         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
414         ds      temp,arg1,temp          /*  28th divide step */
415         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
416         ds      temp,arg1,temp          /*  29th divide step */
417         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
418         ds      temp,arg1,temp          /*  30th divide step */
419         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
420         ds      temp,arg1,temp          /*  31st divide step */
421         addc    retreg,retreg,retreg    /*  shift retreg with/into carry */
422         ds      temp,arg1,temp          /*  32nd divide step, */
423         addc    retreg,retreg,retreg    /*  shift last retreg bit into retreg */
424         xor,>=  arg0,arg1,0             /*  get correct sign of quotient */
425           sub   0,retreg,retreg         /*    based on operand signs */
426         MILLIRETN
427         nop
428
429 LSYM(small_divisor)
430
431 #if defined(pa64)
432 /*  Clear the upper 32 bits of the arg1 register.  We are working with  */
433 /*  small divisors (and 32-bit integers)   We must not be mislead  */
434 /*  by "1" bits left in the upper 32 bits.  */
435         depd %r0,31,32,%r25
436 #endif
437         blr,n   arg1,r0
438         nop
439 /*  table for divisor == 0,1, ... ,15 */
440         addit,= 0,arg1,r0       /*  trap if divisor == 0 */
441         nop
442         MILLIRET                /*  divisor == 1 */
443         copy    arg0,retreg
444         MILLI_BEN($$divI_2)     /*  divisor == 2 */
445         nop
446         MILLI_BEN($$divI_3)     /*  divisor == 3 */
447         nop
448         MILLI_BEN($$divI_4)     /*  divisor == 4 */
449         nop
450         MILLI_BEN($$divI_5)     /*  divisor == 5 */
451         nop
452         MILLI_BEN($$divI_6)     /*  divisor == 6 */
453         nop
454         MILLI_BEN($$divI_7)     /*  divisor == 7 */
455         nop
456         MILLI_BEN($$divI_8)     /*  divisor == 8 */
457         nop
458         MILLI_BEN($$divI_9)     /*  divisor == 9 */
459         nop
460         MILLI_BEN($$divI_10)    /*  divisor == 10 */
461         nop
462         b       LREF(normal)            /*  divisor == 11 */
463         add,>=  0,arg0,retreg
464         MILLI_BEN($$divI_12)    /*  divisor == 12 */
465         nop
466         b       LREF(normal)            /*  divisor == 13 */
467         add,>=  0,arg0,retreg
468         MILLI_BEN($$divI_14)    /*  divisor == 14 */
469         nop
470         MILLI_BEN($$divI_15)    /*  divisor == 15 */
471         nop
472
473 LSYM(negative1)
474         sub     0,arg0,retreg   /*  result is negation of dividend */
475         MILLIRET
476         addo    arg0,arg1,r0    /*  trap iff dividend==0x80000000 && divisor==-1 */
477         .exit
478         .procend
479         .end
480 #endif
481
482 #ifdef L_divU
483 /* ROUTINE:     $$divU
484    .
485    .    Single precision divide for unsigned integers.
486    .
487    .    Quotient is truncated towards zero.
488    .    Traps on divide by zero.
489
490    INPUT REGISTERS:
491    .    arg0 == dividend
492    .    arg1 == divisor
493    .    mrp  == return pc
494    .    sr0  == return space when called externally
495
496    OUTPUT REGISTERS:
497    .    arg0 =  undefined
498    .    arg1 =  undefined
499    .    ret1 =  quotient
500
501    OTHER REGISTERS AFFECTED:
502    .    r1   =  undefined
503
504    SIDE EFFECTS:
505    .    Causes a trap under the following conditions:
506    .            divisor is zero
507    .    Changes memory at the following places:
508    .            NONE
509
510    PERMISSIBLE CONTEXT:
511    .    Unwindable.
512    .    Does not create a stack frame.
513    .    Suitable for internal or external millicode.
514    .    Assumes the special millicode register conventions.
515
516    DISCUSSION:
517    .    Branchs to other millicode routines using BE:
518    .            $$divU_# for 3,5,6,7,9,10,12,14,15
519    .
520    .    For selected small divisors calls the special divide by constant
521    .    routines written by Karl Pettis.  These are: 3,5,6,7,9,10,12,14,15.  */
522
523 RDEFINE(temp,r1)
524 RDEFINE(retreg,ret1)    /* r29 */
525 RDEFINE(temp1,arg0)
526         SUBSPA_MILLI_DIV
527         ATTR_MILLI
528         .export $$divU,millicode
529         .import $$divU_3,millicode
530         .import $$divU_5,millicode
531         .import $$divU_6,millicode
532         .import $$divU_7,millicode
533         .import $$divU_9,millicode
534         .import $$divU_10,millicode
535         .import $$divU_12,millicode
536         .import $$divU_14,millicode
537         .import $$divU_15,millicode
538         .proc
539         .callinfo       millicode
540         .entry
541 GSYM($$divU)
542 /* The subtract is not nullified since it does no harm and can be used
543    by the two cases that branch back to "normal".  */
544         ldo     -1(arg1),temp           /* is there at most one bit set ? */
545         and,=   arg1,temp,r0            /* if so, denominator is power of 2 */
546         b       LREF(regular_seq)
547         addit,= 0,arg1,0                /* trap for zero dvr */
548         copy    arg0,retreg
549         extru,= arg1,15,16,temp         /* test denominator with 0xffff0000 */
550         extru   retreg,15,16,retreg     /* retreg = retreg >> 16 */
551         or      arg1,temp,arg1          /* arg1 = arg1 | (arg1 >> 16) */
552         ldi     0xcc,temp1              /* setup 0xcc in temp1 */
553         extru,= arg1,23,8,temp          /* test denominator with 0xff00 */
554         extru   retreg,23,24,retreg     /* retreg = retreg >> 8 */
555         or      arg1,temp,arg1          /* arg1 = arg1 | (arg1 >> 8) */
556         ldi     0xaa,temp               /* setup 0xaa in temp */
557         extru,= arg1,27,4,r0            /* test denominator with 0xf0 */
558         extru   retreg,27,28,retreg     /* retreg = retreg >> 4 */
559         and,=   arg1,temp1,r0           /* test denominator with 0xcc */
560         extru   retreg,29,30,retreg     /* retreg = retreg >> 2 */
561         and,=   arg1,temp,r0            /* test denominator with 0xaa */
562         extru   retreg,30,31,retreg     /* retreg = retreg >> 1 */
563         MILLIRETN
564         nop     
565 LSYM(regular_seq)
566         comib,>=  15,arg1,LREF(special_divisor)
567         subi    0,arg1,temp             /* clear carry, negate the divisor */
568         ds      r0,temp,r0              /* set V-bit to 1 */
569 LSYM(normal)
570         add     arg0,arg0,retreg        /* shift msb bit into carry */
571         ds      r0,arg1,temp            /* 1st divide step, if no carry */
572         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
573         ds      temp,arg1,temp          /* 2nd divide step */
574         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
575         ds      temp,arg1,temp          /* 3rd divide step */
576         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
577         ds      temp,arg1,temp          /* 4th divide step */
578         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
579         ds      temp,arg1,temp          /* 5th divide step */
580         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
581         ds      temp,arg1,temp          /* 6th divide step */
582         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
583         ds      temp,arg1,temp          /* 7th divide step */
584         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
585         ds      temp,arg1,temp          /* 8th divide step */
586         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
587         ds      temp,arg1,temp          /* 9th divide step */
588         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
589         ds      temp,arg1,temp          /* 10th divide step */
590         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
591         ds      temp,arg1,temp          /* 11th divide step */
592         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
593         ds      temp,arg1,temp          /* 12th divide step */
594         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
595         ds      temp,arg1,temp          /* 13th divide step */
596         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
597         ds      temp,arg1,temp          /* 14th divide step */
598         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
599         ds      temp,arg1,temp          /* 15th divide step */
600         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
601         ds      temp,arg1,temp          /* 16th divide step */
602         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
603         ds      temp,arg1,temp          /* 17th divide step */
604         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
605         ds      temp,arg1,temp          /* 18th divide step */
606         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
607         ds      temp,arg1,temp          /* 19th divide step */
608         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
609         ds      temp,arg1,temp          /* 20th divide step */
610         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
611         ds      temp,arg1,temp          /* 21st divide step */
612         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
613         ds      temp,arg1,temp          /* 22nd divide step */
614         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
615         ds      temp,arg1,temp          /* 23rd divide step */
616         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
617         ds      temp,arg1,temp          /* 24th divide step */
618         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
619         ds      temp,arg1,temp          /* 25th divide step */
620         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
621         ds      temp,arg1,temp          /* 26th divide step */
622         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
623         ds      temp,arg1,temp          /* 27th divide step */
624         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
625         ds      temp,arg1,temp          /* 28th divide step */
626         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
627         ds      temp,arg1,temp          /* 29th divide step */
628         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
629         ds      temp,arg1,temp          /* 30th divide step */
630         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
631         ds      temp,arg1,temp          /* 31st divide step */
632         addc    retreg,retreg,retreg    /* shift retreg with/into carry */
633         ds      temp,arg1,temp          /* 32nd divide step, */
634         MILLIRET
635         addc    retreg,retreg,retreg    /* shift last retreg bit into retreg */
636
637 /* Handle the cases where divisor is a small constant or has high bit on.  */
638 LSYM(special_divisor)
639 /*      blr     arg1,r0 */
640 /*      comib,>,n  0,arg1,LREF(big_divisor) ; nullify previous instruction */
641
642 /* Pratap 8/13/90. The 815 Stirling chip set has a bug that prevents us from
643    generating such a blr, comib sequence. A problem in nullification. So I
644    rewrote this code.  */
645
646 #if defined(pa64)
647 /* Clear the upper 32 bits of the arg1 register.  We are working with
648    small divisors (and 32-bit unsigned integers)   We must not be mislead
649    by "1" bits left in the upper 32 bits.  */
650         depd %r0,31,32,%r25
651 #endif
652         comib,> 0,arg1,LREF(big_divisor)
653         nop
654         blr     arg1,r0
655         nop
656
657 LSYM(zero_divisor)      /* this label is here to provide external visibility */
658         addit,= 0,arg1,0                /* trap for zero dvr */
659         nop
660         MILLIRET                        /* divisor == 1 */
661         copy    arg0,retreg
662         MILLIRET                        /* divisor == 2 */
663         extru   arg0,30,31,retreg
664         MILLI_BEN($$divU_3)             /* divisor == 3 */
665         nop
666         MILLIRET                        /* divisor == 4 */
667         extru   arg0,29,30,retreg
668         MILLI_BEN($$divU_5)             /* divisor == 5 */
669         nop
670         MILLI_BEN($$divU_6)             /* divisor == 6 */
671         nop
672         MILLI_BEN($$divU_7)             /* divisor == 7 */
673         nop
674         MILLIRET                        /* divisor == 8 */
675         extru   arg0,28,29,retreg
676         MILLI_BEN($$divU_9)             /* divisor == 9 */
677         nop
678         MILLI_BEN($$divU_10)            /* divisor == 10 */
679         nop
680         b       LREF(normal)            /* divisor == 11 */
681         ds      r0,temp,r0              /* set V-bit to 1 */
682         MILLI_BEN($$divU_12)            /* divisor == 12 */
683         nop
684         b       LREF(normal)            /* divisor == 13 */
685         ds      r0,temp,r0              /* set V-bit to 1 */
686         MILLI_BEN($$divU_14)            /* divisor == 14 */
687         nop
688         MILLI_BEN($$divU_15)            /* divisor == 15 */
689         nop
690
691 /* Handle the case where the high bit is on in the divisor.
692    Compute:     if( dividend>=divisor) quotient=1; else quotient=0;
693    Note:        dividend>==divisor iff dividend-divisor does not borrow
694    and          not borrow iff carry.  */
695 LSYM(big_divisor)
696         sub     arg0,arg1,r0
697         MILLIRET
698         addc    r0,r0,retreg
699         .exit
700         .procend
701         .end
702 #endif
703
704 #ifdef L_remI
705 /* ROUTINE:     $$remI
706
707    DESCRIPTION:
708    .    $$remI returns the remainder of the division of two signed 32-bit
709    .    integers.  The sign of the remainder is the same as the sign of
710    .    the dividend.
711
712
713    INPUT REGISTERS:
714    .    arg0 == dividend
715    .    arg1 == divisor
716    .    mrp  == return pc
717    .    sr0  == return space when called externally
718
719    OUTPUT REGISTERS:
720    .    arg0 = destroyed
721    .    arg1 = destroyed
722    .    ret1 = remainder
723
724    OTHER REGISTERS AFFECTED:
725    .    r1   = undefined
726
727    SIDE EFFECTS:
728    .    Causes a trap under the following conditions:  DIVIDE BY ZERO
729    .    Changes memory at the following places:  NONE
730
731    PERMISSIBLE CONTEXT:
732    .    Unwindable
733    .    Does not create a stack frame
734    .    Is usable for internal or external microcode
735
736    DISCUSSION:
737    .    Calls other millicode routines via mrp:  NONE
738    .    Calls other millicode routines:  NONE  */
739
740 RDEFINE(tmp,r1)
741 RDEFINE(retreg,ret1)
742
743         SUBSPA_MILLI
744         ATTR_MILLI
745         .proc
746         .callinfo millicode
747         .entry
748 GSYM($$remI)
749 GSYM($$remoI)
750         .export $$remI,MILLICODE
751         .export $$remoI,MILLICODE
752         ldo             -1(arg1),tmp            /*  is there at most one bit set ? */
753         and,<>          arg1,tmp,r0             /*  if not, don't use power of 2 */
754         addi,>          0,arg1,r0               /*  if denominator > 0, use power */
755                                                 /*  of 2 */
756         b,n             LREF(neg_denom)
757 LSYM(pow2)
758         comb,>,n        0,arg0,LREF(neg_num)    /*  is numerator < 0 ? */
759         and             arg0,tmp,retreg         /*  get the result */
760         MILLIRETN
761 LSYM(neg_num)
762         subi            0,arg0,arg0             /*  negate numerator */
763         and             arg0,tmp,retreg         /*  get the result */
764         subi            0,retreg,retreg         /*  negate result */
765         MILLIRETN
766 LSYM(neg_denom)
767         addi,<          0,arg1,r0               /*  if arg1 >= 0, it's not power */
768                                                 /*  of 2 */
769         b,n             LREF(regular_seq)
770         sub             r0,arg1,tmp             /*  make denominator positive */
771         comb,=,n        arg1,tmp,LREF(regular_seq) /*  test against 0x80000000 and 0 */
772         ldo             -1(tmp),retreg          /*  is there at most one bit set ? */
773         and,=           tmp,retreg,r0           /*  if not, go to regular_seq */
774         b,n             LREF(regular_seq)
775         comb,>,n        0,arg0,LREF(neg_num_2)  /*  if arg0 < 0, negate it  */
776         and             arg0,retreg,retreg
777         MILLIRETN
778 LSYM(neg_num_2)
779         subi            0,arg0,tmp              /*  test against 0x80000000 */
780         and             tmp,retreg,retreg
781         subi            0,retreg,retreg
782         MILLIRETN
783 LSYM(regular_seq)
784         addit,=         0,arg1,0                /*  trap if div by zero */
785         add,>=          0,arg0,retreg           /*  move dividend, if retreg < 0, */
786         sub             0,retreg,retreg         /*    make it positive */
787         sub             0,arg1, tmp             /*  clear carry,  */
788                                                 /*    negate the divisor */
789         ds              0, tmp,0                /*  set V-bit to the comple- */
790                                                 /*    ment of the divisor sign */
791         or              0,0, tmp                /*  clear  tmp */
792         add             retreg,retreg,retreg    /*  shift msb bit into carry */
793         ds               tmp,arg1, tmp          /*  1st divide step, if no carry */
794                                                 /*    out, msb of quotient = 0 */
795         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
796 LSYM(t1)
797         ds               tmp,arg1, tmp          /*  2nd divide step */
798         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
799         ds               tmp,arg1, tmp          /*  3rd divide step */
800         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
801         ds               tmp,arg1, tmp          /*  4th divide step */
802         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
803         ds               tmp,arg1, tmp          /*  5th divide step */
804         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
805         ds               tmp,arg1, tmp          /*  6th divide step */
806         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
807         ds               tmp,arg1, tmp          /*  7th divide step */
808         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
809         ds               tmp,arg1, tmp          /*  8th divide step */
810         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
811         ds               tmp,arg1, tmp          /*  9th divide step */
812         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
813         ds               tmp,arg1, tmp          /*  10th divide step */
814         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
815         ds               tmp,arg1, tmp          /*  11th divide step */
816         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
817         ds               tmp,arg1, tmp          /*  12th divide step */
818         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
819         ds               tmp,arg1, tmp          /*  13th divide step */
820         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
821         ds               tmp,arg1, tmp          /*  14th divide step */
822         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
823         ds               tmp,arg1, tmp          /*  15th divide step */
824         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
825         ds               tmp,arg1, tmp          /*  16th divide step */
826         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
827         ds               tmp,arg1, tmp          /*  17th divide step */
828         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
829         ds               tmp,arg1, tmp          /*  18th divide step */
830         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
831         ds               tmp,arg1, tmp          /*  19th divide step */
832         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
833         ds               tmp,arg1, tmp          /*  20th divide step */
834         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
835         ds               tmp,arg1, tmp          /*  21st divide step */
836         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
837         ds               tmp,arg1, tmp          /*  22nd divide step */
838         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
839         ds               tmp,arg1, tmp          /*  23rd divide step */
840         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
841         ds               tmp,arg1, tmp          /*  24th divide step */
842         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
843         ds               tmp,arg1, tmp          /*  25th divide step */
844         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
845         ds               tmp,arg1, tmp          /*  26th divide step */
846         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
847         ds               tmp,arg1, tmp          /*  27th divide step */
848         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
849         ds               tmp,arg1, tmp          /*  28th divide step */
850         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
851         ds               tmp,arg1, tmp          /*  29th divide step */
852         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
853         ds               tmp,arg1, tmp          /*  30th divide step */
854         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
855         ds               tmp,arg1, tmp          /*  31st divide step */
856         addc            retreg,retreg,retreg    /*  shift retreg with/into carry */
857         ds               tmp,arg1, tmp          /*  32nd divide step, */
858         addc            retreg,retreg,retreg    /*  shift last bit into retreg */
859         movb,>=,n        tmp,retreg,LREF(finish) /*  branch if pos.  tmp */
860         add,<           arg1,0,0                /*  if arg1 > 0, add arg1 */
861         add,tr           tmp,arg1,retreg        /*    for correcting remainder tmp */
862         sub              tmp,arg1,retreg        /*  else add absolute value arg1 */
863 LSYM(finish)
864         add,>=          arg0,0,0                /*  set sign of remainder */
865         sub             0,retreg,retreg         /*    to sign of dividend */
866         MILLIRET
867         nop
868         .exit
869         .procend
870 #ifdef milliext
871         .origin 0x00000200
872 #endif
873         .end
874 #endif
875
876 #ifdef L_remU
877 /* ROUTINE:     $$remU
878    .    Single precision divide for remainder with unsigned binary integers.
879    .
880    .    The remainder must be dividend-(dividend/divisor)*divisor.
881    .    Divide by zero is trapped.
882
883    INPUT REGISTERS:
884    .    arg0 == dividend
885    .    arg1 == divisor
886    .    mrp  == return pc
887    .    sr0  == return space when called externally
888
889    OUTPUT REGISTERS:
890    .    arg0 =  undefined
891    .    arg1 =  undefined
892    .    ret1 =  remainder
893
894    OTHER REGISTERS AFFECTED:
895    .    r1   =  undefined
896
897    SIDE EFFECTS:
898    .    Causes a trap under the following conditions:  DIVIDE BY ZERO
899    .    Changes memory at the following places:  NONE
900
901    PERMISSIBLE CONTEXT:
902    .    Unwindable.
903    .    Does not create a stack frame.
904    .    Suitable for internal or external millicode.
905    .    Assumes the special millicode register conventions.
906
907    DISCUSSION:
908    .    Calls other millicode routines using mrp: NONE
909    .    Calls other millicode routines: NONE  */
910
911
912 RDEFINE(temp,r1)
913 RDEFINE(rmndr,ret1)     /*  r29 */
914         SUBSPA_MILLI
915         ATTR_MILLI
916         .export $$remU,millicode
917         .proc
918         .callinfo       millicode
919         .entry
920 GSYM($$remU)
921         ldo     -1(arg1),temp           /*  is there at most one bit set ? */
922         and,=   arg1,temp,r0            /*  if not, don't use power of 2 */
923         b       LREF(regular_seq)
924         addit,= 0,arg1,r0               /*  trap on div by zero */
925         and     arg0,temp,rmndr         /*  get the result for power of 2 */
926         MILLIRETN
927 LSYM(regular_seq)
928         comib,>=,n  0,arg1,LREF(special_case)
929         subi    0,arg1,rmndr            /*  clear carry, negate the divisor */
930         ds      r0,rmndr,r0             /*  set V-bit to 1 */
931         add     arg0,arg0,temp          /*  shift msb bit into carry */
932         ds      r0,arg1,rmndr           /*  1st divide step, if no carry */
933         addc    temp,temp,temp          /*  shift temp with/into carry */
934         ds      rmndr,arg1,rmndr                /*  2nd divide step */
935         addc    temp,temp,temp          /*  shift temp with/into carry */
936         ds      rmndr,arg1,rmndr                /*  3rd divide step */
937         addc    temp,temp,temp          /*  shift temp with/into carry */
938         ds      rmndr,arg1,rmndr                /*  4th divide step */
939         addc    temp,temp,temp          /*  shift temp with/into carry */
940         ds      rmndr,arg1,rmndr                /*  5th divide step */
941         addc    temp,temp,temp          /*  shift temp with/into carry */
942         ds      rmndr,arg1,rmndr                /*  6th divide step */
943         addc    temp,temp,temp          /*  shift temp with/into carry */
944         ds      rmndr,arg1,rmndr                /*  7th divide step */
945         addc    temp,temp,temp          /*  shift temp with/into carry */
946         ds      rmndr,arg1,rmndr                /*  8th divide step */
947         addc    temp,temp,temp          /*  shift temp with/into carry */
948         ds      rmndr,arg1,rmndr                /*  9th divide step */
949         addc    temp,temp,temp          /*  shift temp with/into carry */
950         ds      rmndr,arg1,rmndr                /*  10th divide step */
951         addc    temp,temp,temp          /*  shift temp with/into carry */
952         ds      rmndr,arg1,rmndr                /*  11th divide step */
953         addc    temp,temp,temp          /*  shift temp with/into carry */
954         ds      rmndr,arg1,rmndr                /*  12th divide step */
955         addc    temp,temp,temp          /*  shift temp with/into carry */
956         ds      rmndr,arg1,rmndr                /*  13th divide step */
957         addc    temp,temp,temp          /*  shift temp with/into carry */
958         ds      rmndr,arg1,rmndr                /*  14th divide step */
959         addc    temp,temp,temp          /*  shift temp with/into carry */
960         ds      rmndr,arg1,rmndr                /*  15th divide step */
961         addc    temp,temp,temp          /*  shift temp with/into carry */
962         ds      rmndr,arg1,rmndr                /*  16th divide step */
963         addc    temp,temp,temp          /*  shift temp with/into carry */
964         ds      rmndr,arg1,rmndr                /*  17th divide step */
965         addc    temp,temp,temp          /*  shift temp with/into carry */
966         ds      rmndr,arg1,rmndr                /*  18th divide step */
967         addc    temp,temp,temp          /*  shift temp with/into carry */
968         ds      rmndr,arg1,rmndr                /*  19th divide step */
969         addc    temp,temp,temp          /*  shift temp with/into carry */
970         ds      rmndr,arg1,rmndr                /*  20th divide step */
971         addc    temp,temp,temp          /*  shift temp with/into carry */
972         ds      rmndr,arg1,rmndr                /*  21st divide step */
973         addc    temp,temp,temp          /*  shift temp with/into carry */
974         ds      rmndr,arg1,rmndr                /*  22nd divide step */
975         addc    temp,temp,temp          /*  shift temp with/into carry */
976         ds      rmndr,arg1,rmndr                /*  23rd divide step */
977         addc    temp,temp,temp          /*  shift temp with/into carry */
978         ds      rmndr,arg1,rmndr                /*  24th divide step */
979         addc    temp,temp,temp          /*  shift temp with/into carry */
980         ds      rmndr,arg1,rmndr                /*  25th divide step */
981         addc    temp,temp,temp          /*  shift temp with/into carry */
982         ds      rmndr,arg1,rmndr                /*  26th divide step */
983         addc    temp,temp,temp          /*  shift temp with/into carry */
984         ds      rmndr,arg1,rmndr                /*  27th divide step */
985         addc    temp,temp,temp          /*  shift temp with/into carry */
986         ds      rmndr,arg1,rmndr                /*  28th divide step */
987         addc    temp,temp,temp          /*  shift temp with/into carry */
988         ds      rmndr,arg1,rmndr                /*  29th divide step */
989         addc    temp,temp,temp          /*  shift temp with/into carry */
990         ds      rmndr,arg1,rmndr                /*  30th divide step */
991         addc    temp,temp,temp          /*  shift temp with/into carry */
992         ds      rmndr,arg1,rmndr                /*  31st divide step */
993         addc    temp,temp,temp          /*  shift temp with/into carry */
994         ds      rmndr,arg1,rmndr                /*  32nd divide step, */
995         comiclr,<= 0,rmndr,r0
996           add   rmndr,arg1,rmndr        /*  correction */
997         MILLIRETN
998         nop
999
1000 /* Putting >= on the last DS and deleting COMICLR does not work!  */
1001 LSYM(special_case)
1002         sub,>>= arg0,arg1,rmndr
1003           copy  arg0,rmndr
1004         MILLIRETN
1005         nop
1006         .exit
1007         .procend
1008         .end
1009 #endif
1010
1011 #ifdef L_div_const
1012 /* ROUTINE:     $$divI_2
1013    .            $$divI_3        $$divU_3
1014    .            $$divI_4
1015    .            $$divI_5        $$divU_5
1016    .            $$divI_6        $$divU_6
1017    .            $$divI_7        $$divU_7
1018    .            $$divI_8
1019    .            $$divI_9        $$divU_9
1020    .            $$divI_10       $$divU_10
1021    .
1022    .            $$divI_12       $$divU_12
1023    .
1024    .            $$divI_14       $$divU_14
1025    .            $$divI_15       $$divU_15
1026    .            $$divI_16
1027    .            $$divI_17       $$divU_17
1028    .
1029    .    Divide by selected constants for single precision binary integers.
1030
1031    INPUT REGISTERS:
1032    .    arg0 == dividend
1033    .    mrp  == return pc
1034    .    sr0  == return space when called externally
1035
1036    OUTPUT REGISTERS:
1037    .    arg0 =  undefined
1038    .    arg1 =  undefined
1039    .    ret1 =  quotient
1040
1041    OTHER REGISTERS AFFECTED:
1042    .    r1   =  undefined
1043
1044    SIDE EFFECTS:
1045    .    Causes a trap under the following conditions: NONE
1046    .    Changes memory at the following places:  NONE
1047
1048    PERMISSIBLE CONTEXT:
1049    .    Unwindable.
1050    .    Does not create a stack frame.
1051    .    Suitable for internal or external millicode.
1052    .    Assumes the special millicode register conventions.
1053
1054    DISCUSSION:
1055    .    Calls other millicode routines using mrp:  NONE
1056    .    Calls other millicode routines:  NONE  */
1057
1058
1059 /* TRUNCATED DIVISION BY SMALL INTEGERS
1060
1061    We are interested in q(x) = floor(x/y), where x >= 0 and y > 0
1062    (with y fixed).
1063
1064    Let a = floor(z/y), for some choice of z.  Note that z will be
1065    chosen so that division by z is cheap.
1066
1067    Let r be the remainder(z/y).  In other words, r = z - ay.
1068
1069    Now, our method is to choose a value for b such that
1070
1071    q'(x) = floor((ax+b)/z)
1072
1073    is equal to q(x) over as large a range of x as possible.  If the
1074    two are equal over a sufficiently large range, and if it is easy to
1075    form the product (ax), and it is easy to divide by z, then we can
1076    perform the division much faster than the general division algorithm.
1077
1078    So, we want the following to be true:
1079
1080    .    For x in the following range:
1081    .
1082    .        ky <= x < (k+1)y
1083    .
1084    .    implies that
1085    .
1086    .        k <= (ax+b)/z < (k+1)
1087
1088    We want to determine b such that this is true for all k in the
1089    range {0..K} for some maximum K.
1090
1091    Since (ax+b) is an increasing function of x, we can take each
1092    bound separately to determine the "best" value for b.
1093
1094    (ax+b)/z < (k+1)            implies
1095
1096    (a((k+1)y-1)+b < (k+1)z     implies
1097
1098    b < a + (k+1)(z-ay)         implies
1099
1100    b < a + (k+1)r
1101
1102    This needs to be true for all k in the range {0..K}.  In
1103    particular, it is true for k = 0 and this leads to a maximum
1104    acceptable value for b.
1105
1106    b < a+r   or   b <= a+r-1
1107
1108    Taking the other bound, we have
1109
1110    k <= (ax+b)/z               implies
1111
1112    k <= (aky+b)/z              implies
1113
1114    k(z-ay) <= b                implies
1115
1116    kr <= b
1117
1118    Clearly, the largest range for k will be achieved by maximizing b,
1119    when r is not zero.  When r is zero, then the simplest choice for b
1120    is 0.  When r is not 0, set
1121
1122    .    b = a+r-1
1123
1124    Now, by construction, q'(x) = floor((ax+b)/z) = q(x) = floor(x/y)
1125    for all x in the range:
1126
1127    .    0 <= x < (K+1)y
1128
1129    We need to determine what K is.  Of our two bounds,
1130
1131    .    b < a+(k+1)r    is satisfied for all k >= 0, by construction.
1132
1133    The other bound is
1134
1135    .    kr <= b
1136
1137    This is always true if r = 0.  If r is not 0 (the usual case), then
1138    K = floor((a+r-1)/r), is the maximum value for k.
1139
1140    Therefore, the formula q'(x) = floor((ax+b)/z) yields the correct
1141    answer for q(x) = floor(x/y) when x is in the range
1142
1143    (0,(K+1)y-1)        K = floor((a+r-1)/r)
1144
1145    To be most useful, we want (K+1)y-1 = (max x) >= 2**32-1 so that
1146    the formula for q'(x) yields the correct value of q(x) for all x
1147    representable by a single word in HPPA.
1148
1149    We are also constrained in that computing the product (ax), adding
1150    b, and dividing by z must all be done quickly, otherwise we will be
1151    better off going through the general algorithm using the DS
1152    instruction, which uses approximately 70 cycles.
1153
1154    For each y, there is a choice of z which satisfies the constraints
1155    for (K+1)y >= 2**32.  We may not, however, be able to satisfy the
1156    timing constraints for arbitrary y.  It seems that z being equal to
1157    a power of 2 or a power of 2 minus 1 is as good as we can do, since
1158    it minimizes the time to do division by z.  We want the choice of z
1159    to also result in a value for (a) that minimizes the computation of
1160    the product (ax).  This is best achieved if (a) has a regular bit
1161    pattern (so the multiplication can be done with shifts and adds).
1162    The value of (a) also needs to be less than 2**32 so the product is
1163    always guaranteed to fit in 2 words.
1164
1165    In actual practice, the following should be done:
1166
1167    1) For negative x, you should take the absolute value and remember
1168    .  the fact so that the result can be negated.  This obviously does
1169    .  not apply in the unsigned case.
1170    2) For even y, you should factor out the power of 2 that divides y
1171    .  and divide x by it.  You can then proceed by dividing by the
1172    .  odd factor of y.
1173
1174    Here is a table of some odd values of y, and corresponding choices
1175    for z which are "good".
1176
1177     y     z       r      a (hex)     max x (hex)
1178
1179     3   2**32     1     55555555      100000001
1180     5   2**32     1     33333333      100000003
1181     7  2**24-1    0       249249     (infinite)
1182     9  2**24-1    0       1c71c7     (infinite)
1183    11  2**20-1    0        1745d     (infinite)
1184    13  2**24-1    0       13b13b     (infinite)
1185    15   2**32     1     11111111      10000000d
1186    17   2**32     1      f0f0f0f      10000000f
1187
1188    If r is 1, then b = a+r-1 = a.  This simplifies the computation
1189    of (ax+b), since you can compute (x+1)(a) instead.  If r is 0,
1190    then b = 0 is ok to use which simplifies (ax+b).
1191
1192    The bit patterns for 55555555, 33333333, and 11111111 are obviously
1193    very regular.  The bit patterns for the other values of a above are:
1194
1195     y      (hex)          (binary)
1196
1197     7     249249  001001001001001001001001  << regular >>
1198     9     1c71c7  000111000111000111000111  << regular >>
1199    11      1745d  000000010111010001011101  << irregular >>
1200    13     13b13b  000100111011000100111011  << irregular >>
1201
1202    The bit patterns for (a) corresponding to (y) of 11 and 13 may be
1203    too irregular to warrant using this method.
1204
1205    When z is a power of 2 minus 1, then the division by z is slightly
1206    more complicated, involving an iterative solution.
1207
1208    The code presented here solves division by 1 through 17, except for
1209    11 and 13. There are algorithms for both signed and unsigned
1210    quantities given.
1211
1212    TIMINGS (cycles)
1213
1214    divisor  positive  negative  unsigned
1215
1216    .   1        2          2         2
1217    .   2        4          4         2
1218    .   3       19         21        19
1219    .   4        4          4         2
1220    .   5       18         22        19
1221    .   6       19         22        19
1222    .   8        4          4         2
1223    .  10       18         19        17
1224    .  12       18         20        18
1225    .  15       16         18        16
1226    .  16        4          4         2
1227    .  17       16         18        16
1228
1229    Now, the algorithm for 7, 9, and 14 is an iterative one.  That is,
1230    a loop body is executed until the tentative quotient is 0.  The
1231    number of times the loop body is executed varies depending on the
1232    dividend, but is never more than two times.  If the dividend is
1233    less than the divisor, then the loop body is not executed at all.
1234    Each iteration adds 4 cycles to the timings.
1235
1236    divisor  positive  negative  unsigned
1237
1238    .   7       19+4n     20+4n     20+4n    n = number of iterations
1239    .   9       21+4n     22+4n     21+4n
1240    .  14       21+4n     22+4n     20+4n
1241
1242    To give an idea of how the number of iterations varies, here is a
1243    table of dividend versus number of iterations when dividing by 7.
1244
1245    smallest      largest       required
1246    dividend     dividend      iterations
1247
1248    .    0            6              0
1249    .    7        0x6ffffff          1
1250    0x1000006    0xffffffff          2
1251
1252    There is some overlap in the range of numbers requiring 1 and 2
1253    iterations.  */
1254
1255 RDEFINE(t2,r1)
1256 RDEFINE(x2,arg0)        /*  r26 */
1257 RDEFINE(t1,arg1)        /*  r25 */
1258 RDEFINE(x1,ret1)        /*  r29 */
1259
1260         SUBSPA_MILLI_DIV
1261         ATTR_MILLI
1262
1263         .proc
1264         .callinfo       millicode
1265         .entry
1266 /* NONE of these routines require a stack frame
1267    ALL of these routines are unwindable from millicode  */
1268
1269 GSYM($$divide_by_constant)
1270         .export $$divide_by_constant,millicode
1271 /*  Provides a "nice" label for the code covered by the unwind descriptor
1272     for things like gprof.  */
1273
1274 /* DIVISION BY 2 (shift by 1) */
1275 GSYM($$divI_2)
1276         .export         $$divI_2,millicode
1277         comclr,>=       arg0,0,0
1278         addi            1,arg0,arg0
1279         MILLIRET
1280         extrs           arg0,30,31,ret1
1281
1282
1283 /* DIVISION BY 4 (shift by 2) */
1284 GSYM($$divI_4)
1285         .export         $$divI_4,millicode
1286         comclr,>=       arg0,0,0
1287         addi            3,arg0,arg0
1288         MILLIRET
1289         extrs           arg0,29,30,ret1
1290
1291
1292 /* DIVISION BY 8 (shift by 3) */
1293 GSYM($$divI_8)
1294         .export         $$divI_8,millicode
1295         comclr,>=       arg0,0,0
1296         addi            7,arg0,arg0
1297         MILLIRET
1298         extrs           arg0,28,29,ret1
1299
1300 /* DIVISION BY 16 (shift by 4) */
1301 GSYM($$divI_16)
1302         .export         $$divI_16,millicode
1303         comclr,>=       arg0,0,0
1304         addi            15,arg0,arg0
1305         MILLIRET
1306         extrs           arg0,27,28,ret1
1307
1308 /****************************************************************************
1309 *
1310 *       DIVISION BY DIVISORS OF FFFFFFFF, and powers of 2 times these
1311 *
1312 *       includes 3,5,15,17 and also 6,10,12
1313 *
1314 ****************************************************************************/
1315
1316 /* DIVISION BY 3 (use z = 2**32; a = 55555555) */
1317
1318 GSYM($$divI_3)
1319         .export         $$divI_3,millicode
1320         comb,<,N        x2,0,LREF(neg3)
1321
1322         addi            1,x2,x2         /* this cannot overflow */
1323         extru           x2,1,2,x1       /* multiply by 5 to get started */
1324         sh2add          x2,x2,x2
1325         b               LREF(pos)
1326         addc            x1,0,x1
1327
1328 LSYM(neg3)
1329         subi            1,x2,x2         /* this cannot overflow */
1330         extru           x2,1,2,x1       /* multiply by 5 to get started */
1331         sh2add          x2,x2,x2
1332         b               LREF(neg)
1333         addc            x1,0,x1
1334
1335 GSYM($$divU_3)
1336         .export         $$divU_3,millicode
1337         addi            1,x2,x2         /* this CAN overflow */
1338         addc            0,0,x1
1339         shd             x1,x2,30,t1     /* multiply by 5 to get started */
1340         sh2add          x2,x2,x2
1341         b               LREF(pos)
1342         addc            x1,t1,x1
1343
1344 /* DIVISION BY 5 (use z = 2**32; a = 33333333) */
1345
1346 GSYM($$divI_5)
1347         .export         $$divI_5,millicode
1348         comb,<,N        x2,0,LREF(neg5)
1349
1350         addi            3,x2,t1         /* this cannot overflow */
1351         sh1add          x2,t1,x2        /* multiply by 3 to get started */
1352         b               LREF(pos)
1353         addc            0,0,x1
1354
1355 LSYM(neg5)
1356         sub             0,x2,x2         /* negate x2                    */
1357         addi            1,x2,x2         /* this cannot overflow */
1358         shd             0,x2,31,x1      /* get top bit (can be 1)       */
1359         sh1add          x2,x2,x2        /* multiply by 3 to get started */
1360         b               LREF(neg)
1361         addc            x1,0,x1
1362
1363 GSYM($$divU_5)
1364         .export         $$divU_5,millicode
1365         addi            1,x2,x2         /* this CAN overflow */
1366         addc            0,0,x1
1367         shd             x1,x2,31,t1     /* multiply by 3 to get started */
1368         sh1add          x2,x2,x2
1369         b               LREF(pos)
1370         addc            t1,x1,x1
1371
1372 /* DIVISION BY  6 (shift to divide by 2 then divide by 3) */
1373 GSYM($$divI_6)
1374         .export         $$divI_6,millicode
1375         comb,<,N        x2,0,LREF(neg6)
1376         extru           x2,30,31,x2     /* divide by 2                  */
1377         addi            5,x2,t1         /* compute 5*(x2+1) = 5*x2+5    */
1378         sh2add          x2,t1,x2        /* multiply by 5 to get started */
1379         b               LREF(pos)
1380         addc            0,0,x1
1381
1382 LSYM(neg6)
1383         subi            2,x2,x2         /* negate, divide by 2, and add 1 */
1384                                         /* negation and adding 1 are done */
1385                                         /* at the same time by the SUBI   */
1386         extru           x2,30,31,x2
1387         shd             0,x2,30,x1
1388         sh2add          x2,x2,x2        /* multiply by 5 to get started */
1389         b               LREF(neg)
1390         addc            x1,0,x1
1391
1392 GSYM($$divU_6)
1393         .export         $$divU_6,millicode
1394         extru           x2,30,31,x2     /* divide by 2 */
1395         addi            1,x2,x2         /* cannot carry */
1396         shd             0,x2,30,x1      /* multiply by 5 to get started */
1397         sh2add          x2,x2,x2
1398         b               LREF(pos)
1399         addc            x1,0,x1
1400
1401 /* DIVISION BY 10 (shift to divide by 2 then divide by 5) */
1402 GSYM($$divU_10)
1403         .export         $$divU_10,millicode
1404         extru           x2,30,31,x2     /* divide by 2 */
1405         addi            3,x2,t1         /* compute 3*(x2+1) = (3*x2)+3  */
1406         sh1add          x2,t1,x2        /* multiply by 3 to get started */
1407         addc            0,0,x1
1408 LSYM(pos)
1409         shd             x1,x2,28,t1     /* multiply by 0x11 */
1410         shd             x2,0,28,t2
1411         add             x2,t2,x2
1412         addc            x1,t1,x1
1413 LSYM(pos_for_17)
1414         shd             x1,x2,24,t1     /* multiply by 0x101 */
1415         shd             x2,0,24,t2
1416         add             x2,t2,x2
1417         addc            x1,t1,x1
1418
1419         shd             x1,x2,16,t1     /* multiply by 0x10001 */
1420         shd             x2,0,16,t2
1421         add             x2,t2,x2
1422         MILLIRET
1423         addc            x1,t1,x1
1424
1425 GSYM($$divI_10)
1426         .export         $$divI_10,millicode
1427         comb,<          x2,0,LREF(neg10)
1428         copy            0,x1
1429         extru           x2,30,31,x2     /* divide by 2 */
1430         addib,TR        1,x2,LREF(pos)  /* add 1 (cannot overflow)     */
1431         sh1add          x2,x2,x2        /* multiply by 3 to get started */
1432
1433 LSYM(neg10)
1434         subi            2,x2,x2         /* negate, divide by 2, and add 1 */
1435                                         /* negation and adding 1 are done */
1436                                         /* at the same time by the SUBI   */
1437         extru           x2,30,31,x2
1438         sh1add          x2,x2,x2        /* multiply by 3 to get started */
1439 LSYM(neg)
1440         shd             x1,x2,28,t1     /* multiply by 0x11 */
1441         shd             x2,0,28,t2
1442         add             x2,t2,x2
1443         addc            x1,t1,x1
1444 LSYM(neg_for_17)
1445         shd             x1,x2,24,t1     /* multiply by 0x101 */
1446         shd             x2,0,24,t2
1447         add             x2,t2,x2
1448         addc            x1,t1,x1
1449
1450         shd             x1,x2,16,t1     /* multiply by 0x10001 */
1451         shd             x2,0,16,t2
1452         add             x2,t2,x2
1453         addc            x1,t1,x1
1454         MILLIRET
1455         sub             0,x1,x1
1456
1457 /* DIVISION BY 12 (shift to divide by 4 then divide by 3) */
1458 GSYM($$divI_12)
1459         .export         $$divI_12,millicode
1460         comb,<          x2,0,LREF(neg12)
1461         copy            0,x1
1462         extru           x2,29,30,x2     /* divide by 4                  */
1463         addib,tr        1,x2,LREF(pos)  /* compute 5*(x2+1) = 5*x2+5    */
1464         sh2add          x2,x2,x2        /* multiply by 5 to get started */
1465
1466 LSYM(neg12)
1467         subi            4,x2,x2         /* negate, divide by 4, and add 1 */
1468                                         /* negation and adding 1 are done */
1469                                         /* at the same time by the SUBI   */
1470         extru           x2,29,30,x2
1471         b               LREF(neg)
1472         sh2add          x2,x2,x2        /* multiply by 5 to get started */
1473
1474 GSYM($$divU_12)
1475         .export         $$divU_12,millicode
1476         extru           x2,29,30,x2     /* divide by 4   */
1477         addi            5,x2,t1         /* cannot carry */
1478         sh2add          x2,t1,x2        /* multiply by 5 to get started */
1479         b               LREF(pos)
1480         addc            0,0,x1
1481
1482 /* DIVISION BY 15 (use z = 2**32; a = 11111111) */
1483 GSYM($$divI_15)
1484         .export         $$divI_15,millicode
1485         comb,<          x2,0,LREF(neg15)
1486         copy            0,x1
1487         addib,tr        1,x2,LREF(pos)+4
1488         shd             x1,x2,28,t1
1489
1490 LSYM(neg15)
1491         b               LREF(neg)
1492         subi            1,x2,x2
1493
1494 GSYM($$divU_15)
1495         .export         $$divU_15,millicode
1496         addi            1,x2,x2         /* this CAN overflow */
1497         b               LREF(pos)
1498         addc            0,0,x1
1499
1500 /* DIVISION BY 17 (use z = 2**32; a =  f0f0f0f) */
1501 GSYM($$divI_17)
1502         .export         $$divI_17,millicode
1503         comb,<,n        x2,0,LREF(neg17)
1504         addi            1,x2,x2         /* this cannot overflow */
1505         shd             0,x2,28,t1      /* multiply by 0xf to get started */
1506         shd             x2,0,28,t2
1507         sub             t2,x2,x2
1508         b               LREF(pos_for_17)
1509         subb            t1,0,x1
1510
1511 LSYM(neg17)
1512         subi            1,x2,x2         /* this cannot overflow */
1513         shd             0,x2,28,t1      /* multiply by 0xf to get started */
1514         shd             x2,0,28,t2
1515         sub             t2,x2,x2
1516         b               LREF(neg_for_17)
1517         subb            t1,0,x1
1518
1519 GSYM($$divU_17)
1520         .export         $$divU_17,millicode
1521         addi            1,x2,x2         /* this CAN overflow */
1522         addc            0,0,x1
1523         shd             x1,x2,28,t1     /* multiply by 0xf to get started */
1524 LSYM(u17)
1525         shd             x2,0,28,t2
1526         sub             t2,x2,x2
1527         b               LREF(pos_for_17)
1528         subb            t1,x1,x1
1529
1530
1531 /* DIVISION BY DIVISORS OF FFFFFF, and powers of 2 times these
1532    includes 7,9 and also 14
1533
1534
1535    z = 2**24-1
1536    r = z mod x = 0
1537
1538    so choose b = 0
1539
1540    Also, in order to divide by z = 2**24-1, we approximate by dividing
1541    by (z+1) = 2**24 (which is easy), and then correcting.
1542
1543    (ax) = (z+1)q' + r
1544    .    = zq' + (q'+r)
1545
1546    So to compute (ax)/z, compute q' = (ax)/(z+1) and r = (ax) mod (z+1)
1547    Then the true remainder of (ax)/z is (q'+r).  Repeat the process
1548    with this new remainder, adding the tentative quotients together,
1549    until a tentative quotient is 0 (and then we are done).  There is
1550    one last correction to be done.  It is possible that (q'+r) = z.
1551    If so, then (q'+r)/(z+1) = 0 and it looks like we are done.  But,
1552    in fact, we need to add 1 more to the quotient.  Now, it turns
1553    out that this happens if and only if the original value x is
1554    an exact multiple of y.  So, to avoid a three instruction test at
1555    the end, instead use 1 instruction to add 1 to x at the beginning.  */
1556
1557 /* DIVISION BY 7 (use z = 2**24-1; a = 249249) */
1558 GSYM($$divI_7)
1559         .export         $$divI_7,millicode
1560         comb,<,n        x2,0,LREF(neg7)
1561 LSYM(7)
1562         addi            1,x2,x2         /* cannot overflow */
1563         shd             0,x2,29,x1
1564         sh3add          x2,x2,x2
1565         addc            x1,0,x1
1566 LSYM(pos7)
1567         shd             x1,x2,26,t1
1568         shd             x2,0,26,t2
1569         add             x2,t2,x2
1570         addc            x1,t1,x1
1571
1572         shd             x1,x2,20,t1
1573         shd             x2,0,20,t2
1574         add             x2,t2,x2
1575         addc            x1,t1,t1
1576
1577         /* computed <t1,x2>.  Now divide it by (2**24 - 1)      */
1578
1579         copy            0,x1
1580         shd,=           t1,x2,24,t1     /* tentative quotient  */
1581 LSYM(1)
1582         addb,tr         t1,x1,LREF(2)   /* add to previous quotient   */
1583         extru           x2,31,24,x2     /* new remainder (unadjusted) */
1584
1585         MILLIRETN
1586
1587 LSYM(2)
1588         addb,tr         t1,x2,LREF(1)   /* adjust remainder */
1589         extru,=         x2,7,8,t1       /* new quotient     */
1590
1591 LSYM(neg7)
1592         subi            1,x2,x2         /* negate x2 and add 1 */
1593 LSYM(8)
1594         shd             0,x2,29,x1
1595         sh3add          x2,x2,x2
1596         addc            x1,0,x1
1597
1598 LSYM(neg7_shift)
1599         shd             x1,x2,26,t1
1600         shd             x2,0,26,t2
1601         add             x2,t2,x2
1602         addc            x1,t1,x1
1603
1604         shd             x1,x2,20,t1
1605         shd             x2,0,20,t2
1606         add             x2,t2,x2
1607         addc            x1,t1,t1
1608
1609         /* computed <t1,x2>.  Now divide it by (2**24 - 1)      */
1610
1611         copy            0,x1
1612         shd,=           t1,x2,24,t1     /* tentative quotient  */
1613 LSYM(3)
1614         addb,tr         t1,x1,LREF(4)   /* add to previous quotient   */
1615         extru           x2,31,24,x2     /* new remainder (unadjusted) */
1616
1617         MILLIRET
1618         sub             0,x1,x1         /* negate result    */
1619
1620 LSYM(4)
1621         addb,tr         t1,x2,LREF(3)   /* adjust remainder */
1622         extru,=         x2,7,8,t1       /* new quotient     */
1623
1624 GSYM($$divU_7)
1625         .export         $$divU_7,millicode
1626         addi            1,x2,x2         /* can carry */
1627         addc            0,0,x1
1628         shd             x1,x2,29,t1
1629         sh3add          x2,x2,x2
1630         b               LREF(pos7)
1631         addc            t1,x1,x1
1632
1633 /* DIVISION BY 9 (use z = 2**24-1; a = 1c71c7) */
1634 GSYM($$divI_9)
1635         .export         $$divI_9,millicode
1636         comb,<,n        x2,0,LREF(neg9)
1637         addi            1,x2,x2         /* cannot overflow */
1638         shd             0,x2,29,t1
1639         shd             x2,0,29,t2
1640         sub             t2,x2,x2
1641         b               LREF(pos7)
1642         subb            t1,0,x1
1643
1644 LSYM(neg9)
1645         subi            1,x2,x2         /* negate and add 1 */
1646         shd             0,x2,29,t1
1647         shd             x2,0,29,t2
1648         sub             t2,x2,x2
1649         b               LREF(neg7_shift)
1650         subb            t1,0,x1
1651
1652 GSYM($$divU_9)
1653         .export         $$divU_9,millicode
1654         addi            1,x2,x2         /* can carry */
1655         addc            0,0,x1
1656         shd             x1,x2,29,t1
1657         shd             x2,0,29,t2
1658         sub             t2,x2,x2
1659         b               LREF(pos7)
1660         subb            t1,x1,x1
1661
1662 /* DIVISION BY 14 (shift to divide by 2 then divide by 7) */
1663 GSYM($$divI_14)
1664         .export         $$divI_14,millicode
1665         comb,<,n        x2,0,LREF(neg14)
1666 GSYM($$divU_14)
1667         .export         $$divU_14,millicode
1668         b               LREF(7)         /* go to 7 case */
1669         extru           x2,30,31,x2     /* divide by 2  */
1670
1671 LSYM(neg14)
1672         subi            2,x2,x2         /* negate (and add 2) */
1673         b               LREF(8)
1674         extru           x2,30,31,x2     /* divide by 2        */
1675         .exit
1676         .procend
1677         .end
1678 #endif
1679
1680 #ifdef L_mulI
1681 /* VERSION "@(#)$$mulI $ Revision: 12.4 $ $ Date: 94/03/17 17:18:51 $" */
1682 /******************************************************************************
1683 This routine is used on PA2.0 processors when gcc -mno-fpregs is used
1684
1685 ROUTINE:        $$mulI
1686
1687
1688 DESCRIPTION:    
1689
1690         $$mulI multiplies two single word integers, giving a single 
1691         word result.  
1692
1693
1694 INPUT REGISTERS:
1695
1696         arg0 = Operand 1
1697         arg1 = Operand 2
1698         r31  == return pc
1699         sr0  == return space when called externally 
1700
1701
1702 OUTPUT REGISTERS:
1703
1704         arg0 = undefined
1705         arg1 = undefined
1706         ret1 = result 
1707
1708 OTHER REGISTERS AFFECTED:
1709
1710         r1   = undefined
1711
1712 SIDE EFFECTS:
1713
1714         Causes a trap under the following conditions:  NONE
1715         Changes memory at the following places:  NONE
1716
1717 PERMISSIBLE CONTEXT:
1718
1719         Unwindable
1720         Does not create a stack frame
1721         Is usable for internal or external microcode
1722
1723 DISCUSSION:
1724
1725         Calls other millicode routines via mrp:  NONE
1726         Calls other millicode routines:  NONE
1727
1728 ***************************************************************************/
1729
1730
1731 #define a0      %arg0
1732 #define a1      %arg1
1733 #define t0      %r1
1734 #define r       %ret1
1735
1736 #define a0__128a0       zdep    a0,24,25,a0
1737 #define a0__256a0       zdep    a0,23,24,a0
1738 #define a1_ne_0_b_l0    comb,<> a1,0,LREF(l0)
1739 #define a1_ne_0_b_l1    comb,<> a1,0,LREF(l1)
1740 #define a1_ne_0_b_l2    comb,<> a1,0,LREF(l2)
1741 #define b_n_ret_t0      b,n     LREF(ret_t0)
1742 #define b_e_shift       b       LREF(e_shift)
1743 #define b_e_t0ma0       b       LREF(e_t0ma0)
1744 #define b_e_t0          b       LREF(e_t0)
1745 #define b_e_t0a0        b       LREF(e_t0a0)
1746 #define b_e_t02a0       b       LREF(e_t02a0)
1747 #define b_e_t04a0       b       LREF(e_t04a0)
1748 #define b_e_2t0         b       LREF(e_2t0)
1749 #define b_e_2t0a0       b       LREF(e_2t0a0)
1750 #define b_e_2t04a0      b       LREF(e2t04a0)
1751 #define b_e_3t0         b       LREF(e_3t0)
1752 #define b_e_4t0         b       LREF(e_4t0)
1753 #define b_e_4t0a0       b       LREF(e_4t0a0)
1754 #define b_e_4t08a0      b       LREF(e4t08a0)
1755 #define b_e_5t0         b       LREF(e_5t0)
1756 #define b_e_8t0         b       LREF(e_8t0)
1757 #define b_e_8t0a0       b       LREF(e_8t0a0)
1758 #define r__r_a0         add     r,a0,r
1759 #define r__r_2a0        sh1add  a0,r,r
1760 #define r__r_4a0        sh2add  a0,r,r
1761 #define r__r_8a0        sh3add  a0,r,r
1762 #define r__r_t0         add     r,t0,r
1763 #define r__r_2t0        sh1add  t0,r,r
1764 #define r__r_4t0        sh2add  t0,r,r
1765 #define r__r_8t0        sh3add  t0,r,r
1766 #define t0__3a0         sh1add  a0,a0,t0
1767 #define t0__4a0         sh2add  a0,0,t0
1768 #define t0__5a0         sh2add  a0,a0,t0
1769 #define t0__8a0         sh3add  a0,0,t0
1770 #define t0__9a0         sh3add  a0,a0,t0
1771 #define t0__16a0        zdep    a0,27,28,t0
1772 #define t0__32a0        zdep    a0,26,27,t0
1773 #define t0__64a0        zdep    a0,25,26,t0
1774 #define t0__128a0       zdep    a0,24,25,t0
1775 #define t0__t0ma0       sub     t0,a0,t0
1776 #define t0__t0_a0       add     t0,a0,t0
1777 #define t0__t0_2a0      sh1add  a0,t0,t0
1778 #define t0__t0_4a0      sh2add  a0,t0,t0
1779 #define t0__t0_8a0      sh3add  a0,t0,t0
1780 #define t0__2t0_a0      sh1add  t0,a0,t0
1781 #define t0__3t0         sh1add  t0,t0,t0
1782 #define t0__4t0         sh2add  t0,0,t0
1783 #define t0__4t0_a0      sh2add  t0,a0,t0
1784 #define t0__5t0         sh2add  t0,t0,t0
1785 #define t0__8t0         sh3add  t0,0,t0
1786 #define t0__8t0_a0      sh3add  t0,a0,t0
1787 #define t0__9t0         sh3add  t0,t0,t0
1788 #define t0__16t0        zdep    t0,27,28,t0
1789 #define t0__32t0        zdep    t0,26,27,t0
1790 #define t0__256a0       zdep    a0,23,24,t0
1791
1792
1793         SUBSPA_MILLI
1794         ATTR_MILLI
1795         .align 16
1796         .proc
1797         .callinfo millicode
1798         .export $$mulI,millicode
1799 GSYM($$mulI)    
1800         combt,<<=       a1,a0,LREF(l4)  /* swap args if unsigned a1>a0 */
1801         copy            0,r             /* zero out the result */
1802         xor             a0,a1,a0        /* swap a0 & a1 using the */
1803         xor             a0,a1,a1        /*  old xor trick */
1804         xor             a0,a1,a0
1805 LSYM(l4)
1806         combt,<=        0,a0,LREF(l3)           /* if a0>=0 then proceed like unsigned */
1807         zdep            a1,30,8,t0      /* t0 = (a1&0xff)<<1 ********* */
1808         sub,>           0,a1,t0         /* otherwise negate both and */
1809         combt,<=,n      a0,t0,LREF(l2)  /*  swap back if |a0|<|a1| */
1810         sub             0,a0,a1
1811         movb,tr,n       t0,a0,LREF(l2)  /* 10th inst.  */
1812
1813 LSYM(l0)        r__r_t0                         /* add in this partial product */
1814 LSYM(l1)        a0__256a0                       /* a0 <<= 8 ****************** */
1815 LSYM(l2)        zdep            a1,30,8,t0      /* t0 = (a1&0xff)<<1 ********* */
1816 LSYM(l3)        blr             t0,0            /* case on these 8 bits ****** */
1817                 extru           a1,23,24,a1     /* a1 >>= 8 ****************** */
1818
1819 /*16 insts before this.  */
1820 /*                        a0 <<= 8 ************************** */
1821 LSYM(x0)        a1_ne_0_b_l2    ! a0__256a0     ! MILLIRETN     ! nop
1822 LSYM(x1)        a1_ne_0_b_l1    ! r__r_a0       ! MILLIRETN     ! nop
1823 LSYM(x2)        a1_ne_0_b_l1    ! r__r_2a0      ! MILLIRETN     ! nop
1824 LSYM(x3)        a1_ne_0_b_l0    ! t0__3a0       ! MILLIRET      ! r__r_t0
1825 LSYM(x4)        a1_ne_0_b_l1    ! r__r_4a0      ! MILLIRETN     ! nop
1826 LSYM(x5)        a1_ne_0_b_l0    ! t0__5a0       ! MILLIRET      ! r__r_t0
1827 LSYM(x6)        t0__3a0         ! a1_ne_0_b_l1  ! r__r_2t0      ! MILLIRETN
1828 LSYM(x7)        t0__3a0         ! a1_ne_0_b_l0  ! r__r_4a0      ! b_n_ret_t0
1829 LSYM(x8)        a1_ne_0_b_l1    ! r__r_8a0      ! MILLIRETN     ! nop
1830 LSYM(x9)        a1_ne_0_b_l0    ! t0__9a0       ! MILLIRET      ! r__r_t0
1831 LSYM(x10)       t0__5a0         ! a1_ne_0_b_l1  ! r__r_2t0      ! MILLIRETN
1832 LSYM(x11)       t0__3a0         ! a1_ne_0_b_l0  ! r__r_8a0      ! b_n_ret_t0
1833 LSYM(x12)       t0__3a0         ! a1_ne_0_b_l1  ! r__r_4t0      ! MILLIRETN
1834 LSYM(x13)       t0__5a0         ! a1_ne_0_b_l0  ! r__r_8a0      ! b_n_ret_t0
1835 LSYM(x14)       t0__3a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_2t0
1836 LSYM(x15)       t0__5a0         ! a1_ne_0_b_l0  ! t0__3t0       ! b_n_ret_t0
1837 LSYM(x16)       t0__16a0        ! a1_ne_0_b_l1  ! r__r_t0       ! MILLIRETN
1838 LSYM(x17)       t0__9a0         ! a1_ne_0_b_l0  ! t0__t0_8a0    ! b_n_ret_t0
1839 LSYM(x18)       t0__9a0         ! a1_ne_0_b_l1  ! r__r_2t0      ! MILLIRETN
1840 LSYM(x19)       t0__9a0         ! a1_ne_0_b_l0  ! t0__2t0_a0    ! b_n_ret_t0
1841 LSYM(x20)       t0__5a0         ! a1_ne_0_b_l1  ! r__r_4t0      ! MILLIRETN
1842 LSYM(x21)       t0__5a0         ! a1_ne_0_b_l0  ! t0__4t0_a0    ! b_n_ret_t0
1843 LSYM(x22)       t0__5a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_2t0
1844 LSYM(x23)       t0__5a0         ! t0__2t0_a0    ! b_e_t0        ! t0__2t0_a0
1845 LSYM(x24)       t0__3a0         ! a1_ne_0_b_l1  ! r__r_8t0      ! MILLIRETN
1846 LSYM(x25)       t0__5a0         ! a1_ne_0_b_l0  ! t0__5t0       ! b_n_ret_t0
1847 LSYM(x26)       t0__3a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_2t0
1848 LSYM(x27)       t0__3a0         ! a1_ne_0_b_l0  ! t0__9t0       ! b_n_ret_t0
1849 LSYM(x28)       t0__3a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_4t0
1850 LSYM(x29)       t0__3a0         ! t0__2t0_a0    ! b_e_t0        ! t0__4t0_a0
1851 LSYM(x30)       t0__5a0         ! t0__3t0       ! b_e_shift     ! r__r_2t0
1852 LSYM(x31)       t0__32a0        ! a1_ne_0_b_l0  ! t0__t0ma0     ! b_n_ret_t0
1853 LSYM(x32)       t0__32a0        ! a1_ne_0_b_l1  ! r__r_t0       ! MILLIRETN
1854 LSYM(x33)       t0__8a0         ! a1_ne_0_b_l0  ! t0__4t0_a0    ! b_n_ret_t0
1855 LSYM(x34)       t0__16a0        ! t0__t0_a0     ! b_e_shift     ! r__r_2t0
1856 LSYM(x35)       t0__9a0         ! t0__3t0       ! b_e_t0        ! t0__t0_8a0
1857 LSYM(x36)       t0__9a0         ! a1_ne_0_b_l1  ! r__r_4t0      ! MILLIRETN
1858 LSYM(x37)       t0__9a0         ! a1_ne_0_b_l0  ! t0__4t0_a0    ! b_n_ret_t0
1859 LSYM(x38)       t0__9a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_2t0
1860 LSYM(x39)       t0__9a0         ! t0__2t0_a0    ! b_e_t0        ! t0__2t0_a0
1861 LSYM(x40)       t0__5a0         ! a1_ne_0_b_l1  ! r__r_8t0      ! MILLIRETN
1862 LSYM(x41)       t0__5a0         ! a1_ne_0_b_l0  ! t0__8t0_a0    ! b_n_ret_t0
1863 LSYM(x42)       t0__5a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_2t0
1864 LSYM(x43)       t0__5a0         ! t0__4t0_a0    ! b_e_t0        ! t0__2t0_a0
1865 LSYM(x44)       t0__5a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_4t0
1866 LSYM(x45)       t0__9a0         ! a1_ne_0_b_l0  ! t0__5t0       ! b_n_ret_t0
1867 LSYM(x46)       t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__t0_a0
1868 LSYM(x47)       t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__t0_2a0
1869 LSYM(x48)       t0__3a0         ! a1_ne_0_b_l0  ! t0__16t0      ! b_n_ret_t0
1870 LSYM(x49)       t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__t0_4a0
1871 LSYM(x50)       t0__5a0         ! t0__5t0       ! b_e_shift     ! r__r_2t0
1872 LSYM(x51)       t0__9a0         ! t0__t0_8a0    ! b_e_t0        ! t0__3t0
1873 LSYM(x52)       t0__3a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_4t0
1874 LSYM(x53)       t0__3a0         ! t0__4t0_a0    ! b_e_t0        ! t0__4t0_a0
1875 LSYM(x54)       t0__9a0         ! t0__3t0       ! b_e_shift     ! r__r_2t0
1876 LSYM(x55)       t0__9a0         ! t0__3t0       ! b_e_t0        ! t0__2t0_a0
1877 LSYM(x56)       t0__3a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_8t0
1878 LSYM(x57)       t0__9a0         ! t0__2t0_a0    ! b_e_t0        ! t0__3t0
1879 LSYM(x58)       t0__3a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__4t0_a0
1880 LSYM(x59)       t0__9a0         ! t0__2t0_a0    ! b_e_t02a0     ! t0__3t0
1881 LSYM(x60)       t0__5a0         ! t0__3t0       ! b_e_shift     ! r__r_4t0
1882 LSYM(x61)       t0__5a0         ! t0__3t0       ! b_e_t0        ! t0__4t0_a0
1883 LSYM(x62)       t0__32a0        ! t0__t0ma0     ! b_e_shift     ! r__r_2t0
1884 LSYM(x63)       t0__64a0        ! a1_ne_0_b_l0  ! t0__t0ma0     ! b_n_ret_t0
1885 LSYM(x64)       t0__64a0        ! a1_ne_0_b_l1  ! r__r_t0       ! MILLIRETN
1886 LSYM(x65)       t0__8a0         ! a1_ne_0_b_l0  ! t0__8t0_a0    ! b_n_ret_t0
1887 LSYM(x66)       t0__32a0        ! t0__t0_a0     ! b_e_shift     ! r__r_2t0
1888 LSYM(x67)       t0__8a0         ! t0__4t0_a0    ! b_e_t0        ! t0__2t0_a0
1889 LSYM(x68)       t0__8a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_4t0
1890 LSYM(x69)       t0__8a0         ! t0__2t0_a0    ! b_e_t0        ! t0__4t0_a0
1891 LSYM(x70)       t0__64a0        ! t0__t0_4a0    ! b_e_t0        ! t0__t0_2a0
1892 LSYM(x71)       t0__9a0         ! t0__8t0       ! b_e_t0        ! t0__t0ma0
1893 LSYM(x72)       t0__9a0         ! a1_ne_0_b_l1  ! r__r_8t0      ! MILLIRETN
1894 LSYM(x73)       t0__9a0         ! t0__8t0_a0    ! b_e_shift     ! r__r_t0
1895 LSYM(x74)       t0__9a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_2t0
1896 LSYM(x75)       t0__9a0         ! t0__4t0_a0    ! b_e_t0        ! t0__2t0_a0
1897 LSYM(x76)       t0__9a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_4t0
1898 LSYM(x77)       t0__9a0         ! t0__2t0_a0    ! b_e_t0        ! t0__4t0_a0
1899 LSYM(x78)       t0__9a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__2t0_a0
1900 LSYM(x79)       t0__16a0        ! t0__5t0       ! b_e_t0        ! t0__t0ma0
1901 LSYM(x80)       t0__16a0        ! t0__5t0       ! b_e_shift     ! r__r_t0
1902 LSYM(x81)       t0__9a0         ! t0__9t0       ! b_e_shift     ! r__r_t0
1903 LSYM(x82)       t0__5a0         ! t0__8t0_a0    ! b_e_shift     ! r__r_2t0
1904 LSYM(x83)       t0__5a0         ! t0__8t0_a0    ! b_e_t0        ! t0__2t0_a0
1905 LSYM(x84)       t0__5a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_4t0
1906 LSYM(x85)       t0__8a0         ! t0__2t0_a0    ! b_e_t0        ! t0__5t0
1907 LSYM(x86)       t0__5a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__2t0_a0
1908 LSYM(x87)       t0__9a0         ! t0__9t0       ! b_e_t02a0     ! t0__t0_4a0
1909 LSYM(x88)       t0__5a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_8t0
1910 LSYM(x89)       t0__5a0         ! t0__2t0_a0    ! b_e_t0        ! t0__8t0_a0
1911 LSYM(x90)       t0__9a0         ! t0__5t0       ! b_e_shift     ! r__r_2t0
1912 LSYM(x91)       t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__2t0_a0
1913 LSYM(x92)       t0__5a0         ! t0__2t0_a0    ! b_e_4t0       ! t0__2t0_a0
1914 LSYM(x93)       t0__32a0        ! t0__t0ma0     ! b_e_t0        ! t0__3t0
1915 LSYM(x94)       t0__9a0         ! t0__5t0       ! b_e_2t0       ! t0__t0_2a0
1916 LSYM(x95)       t0__9a0         ! t0__2t0_a0    ! b_e_t0        ! t0__5t0
1917 LSYM(x96)       t0__8a0         ! t0__3t0       ! b_e_shift     ! r__r_4t0
1918 LSYM(x97)       t0__8a0         ! t0__3t0       ! b_e_t0        ! t0__4t0_a0
1919 LSYM(x98)       t0__32a0        ! t0__3t0       ! b_e_t0        ! t0__t0_2a0
1920 LSYM(x99)       t0__8a0         ! t0__4t0_a0    ! b_e_t0        ! t0__3t0
1921 LSYM(x100)      t0__5a0         ! t0__5t0       ! b_e_shift     ! r__r_4t0
1922 LSYM(x101)      t0__5a0         ! t0__5t0       ! b_e_t0        ! t0__4t0_a0
1923 LSYM(x102)      t0__32a0        ! t0__t0_2a0    ! b_e_t0        ! t0__3t0
1924 LSYM(x103)      t0__5a0         ! t0__5t0       ! b_e_t02a0     ! t0__4t0_a0
1925 LSYM(x104)      t0__3a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_8t0
1926 LSYM(x105)      t0__5a0         ! t0__4t0_a0    ! b_e_t0        ! t0__5t0
1927 LSYM(x106)      t0__3a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__4t0_a0
1928 LSYM(x107)      t0__9a0         ! t0__t0_4a0    ! b_e_t02a0     ! t0__8t0_a0
1929 LSYM(x108)      t0__9a0         ! t0__3t0       ! b_e_shift     ! r__r_4t0
1930 LSYM(x109)      t0__9a0         ! t0__3t0       ! b_e_t0        ! t0__4t0_a0
1931 LSYM(x110)      t0__9a0         ! t0__3t0       ! b_e_2t0       ! t0__2t0_a0
1932 LSYM(x111)      t0__9a0         ! t0__4t0_a0    ! b_e_t0        ! t0__3t0
1933 LSYM(x112)      t0__3a0         ! t0__2t0_a0    ! b_e_t0        ! t0__16t0
1934 LSYM(x113)      t0__9a0         ! t0__4t0_a0    ! b_e_t02a0     ! t0__3t0
1935 LSYM(x114)      t0__9a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__3t0
1936 LSYM(x115)      t0__9a0         ! t0__2t0_a0    ! b_e_2t0a0     ! t0__3t0
1937 LSYM(x116)      t0__3a0         ! t0__2t0_a0    ! b_e_4t0       ! t0__4t0_a0
1938 LSYM(x117)      t0__3a0         ! t0__4t0_a0    ! b_e_t0        ! t0__9t0
1939 LSYM(x118)      t0__3a0         ! t0__4t0_a0    ! b_e_t0a0      ! t0__9t0
1940 LSYM(x119)      t0__3a0         ! t0__4t0_a0    ! b_e_t02a0     ! t0__9t0
1941 LSYM(x120)      t0__5a0         ! t0__3t0       ! b_e_shift     ! r__r_8t0
1942 LSYM(x121)      t0__5a0         ! t0__3t0       ! b_e_t0        ! t0__8t0_a0
1943 LSYM(x122)      t0__5a0         ! t0__3t0       ! b_e_2t0       ! t0__4t0_a0
1944 LSYM(x123)      t0__5a0         ! t0__8t0_a0    ! b_e_t0        ! t0__3t0
1945 LSYM(x124)      t0__32a0        ! t0__t0ma0     ! b_e_shift     ! r__r_4t0
1946 LSYM(x125)      t0__5a0         ! t0__5t0       ! b_e_t0        ! t0__5t0
1947 LSYM(x126)      t0__64a0        ! t0__t0ma0     ! b_e_shift     ! r__r_2t0
1948 LSYM(x127)      t0__128a0       ! a1_ne_0_b_l0  ! t0__t0ma0     ! b_n_ret_t0
1949 LSYM(x128)      t0__128a0       ! a1_ne_0_b_l1  ! r__r_t0       ! MILLIRETN
1950 LSYM(x129)      t0__128a0       ! a1_ne_0_b_l0  ! t0__t0_a0     ! b_n_ret_t0
1951 LSYM(x130)      t0__64a0        ! t0__t0_a0     ! b_e_shift     ! r__r_2t0
1952 LSYM(x131)      t0__8a0         ! t0__8t0_a0    ! b_e_t0        ! t0__2t0_a0
1953 LSYM(x132)      t0__8a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_4t0
1954 LSYM(x133)      t0__8a0         ! t0__4t0_a0    ! b_e_t0        ! t0__4t0_a0
1955 LSYM(x134)      t0__8a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__2t0_a0
1956 LSYM(x135)      t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__3t0
1957 LSYM(x136)      t0__8a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_8t0
1958 LSYM(x137)      t0__8a0         ! t0__2t0_a0    ! b_e_t0        ! t0__8t0_a0
1959 LSYM(x138)      t0__8a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__4t0_a0
1960 LSYM(x139)      t0__8a0         ! t0__2t0_a0    ! b_e_2t0a0     ! t0__4t0_a0
1961 LSYM(x140)      t0__3a0         ! t0__2t0_a0    ! b_e_4t0       ! t0__5t0
1962 LSYM(x141)      t0__8a0         ! t0__2t0_a0    ! b_e_4t0a0     ! t0__2t0_a0
1963 LSYM(x142)      t0__9a0         ! t0__8t0       ! b_e_2t0       ! t0__t0ma0
1964 LSYM(x143)      t0__16a0        ! t0__9t0       ! b_e_t0        ! t0__t0ma0
1965 LSYM(x144)      t0__9a0         ! t0__8t0       ! b_e_shift     ! r__r_2t0
1966 LSYM(x145)      t0__9a0         ! t0__8t0       ! b_e_t0        ! t0__2t0_a0
1967 LSYM(x146)      t0__9a0         ! t0__8t0_a0    ! b_e_shift     ! r__r_2t0
1968 LSYM(x147)      t0__9a0         ! t0__8t0_a0    ! b_e_t0        ! t0__2t0_a0
1969 LSYM(x148)      t0__9a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_4t0
1970 LSYM(x149)      t0__9a0         ! t0__4t0_a0    ! b_e_t0        ! t0__4t0_a0
1971 LSYM(x150)      t0__9a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__2t0_a0
1972 LSYM(x151)      t0__9a0         ! t0__4t0_a0    ! b_e_2t0a0     ! t0__2t0_a0
1973 LSYM(x152)      t0__9a0         ! t0__2t0_a0    ! b_e_shift     ! r__r_8t0
1974 LSYM(x153)      t0__9a0         ! t0__2t0_a0    ! b_e_t0        ! t0__8t0_a0
1975 LSYM(x154)      t0__9a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__4t0_a0
1976 LSYM(x155)      t0__32a0        ! t0__t0ma0     ! b_e_t0        ! t0__5t0
1977 LSYM(x156)      t0__9a0         ! t0__2t0_a0    ! b_e_4t0       ! t0__2t0_a0
1978 LSYM(x157)      t0__32a0        ! t0__t0ma0     ! b_e_t02a0     ! t0__5t0
1979 LSYM(x158)      t0__16a0        ! t0__5t0       ! b_e_2t0       ! t0__t0ma0
1980 LSYM(x159)      t0__32a0        ! t0__5t0       ! b_e_t0        ! t0__t0ma0
1981 LSYM(x160)      t0__5a0         ! t0__4t0       ! b_e_shift     ! r__r_8t0
1982 LSYM(x161)      t0__8a0         ! t0__5t0       ! b_e_t0        ! t0__4t0_a0
1983 LSYM(x162)      t0__9a0         ! t0__9t0       ! b_e_shift     ! r__r_2t0
1984 LSYM(x163)      t0__9a0         ! t0__9t0       ! b_e_t0        ! t0__2t0_a0
1985 LSYM(x164)      t0__5a0         ! t0__8t0_a0    ! b_e_shift     ! r__r_4t0
1986 LSYM(x165)      t0__8a0         ! t0__4t0_a0    ! b_e_t0        ! t0__5t0
1987 LSYM(x166)      t0__5a0         ! t0__8t0_a0    ! b_e_2t0       ! t0__2t0_a0
1988 LSYM(x167)      t0__5a0         ! t0__8t0_a0    ! b_e_2t0a0     ! t0__2t0_a0
1989 LSYM(x168)      t0__5a0         ! t0__4t0_a0    ! b_e_shift     ! r__r_8t0
1990 LSYM(x169)      t0__5a0         ! t0__4t0_a0    ! b_e_t0        ! t0__8t0_a0
1991 LSYM(x170)      t0__32a0        ! t0__t0_2a0    ! b_e_t0        ! t0__5t0
1992 LSYM(x171)      t0__9a0         ! t0__2t0_a0    ! b_e_t0        ! t0__9t0
1993 LSYM(x172)      t0__5a0         ! t0__4t0_a0    ! b_e_4t0       ! t0__2t0_a0
1994 LSYM(x173)      t0__9a0         ! t0__2t0_a0    ! b_e_t02a0     ! t0__9t0
1995 LSYM(x174)      t0__32a0        ! t0__t0_2a0    ! b_e_t04a0     ! t0__5t0
1996 LSYM(x175)      t0__8a0         ! t0__2t0_a0    ! b_e_5t0       ! t0__2t0_a0
1997 LSYM(x176)      t0__5a0         ! t0__4t0_a0    ! b_e_8t0       ! t0__t0_a0
1998 LSYM(x177)      t0__5a0         ! t0__4t0_a0    ! b_e_8t0a0     ! t0__t0_a0
1999 LSYM(x178)      t0__5a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__8t0_a0
2000 LSYM(x179)      t0__5a0         ! t0__2t0_a0    ! b_e_2t0a0     ! t0__8t0_a0
2001 LSYM(x180)      t0__9a0         ! t0__5t0       ! b_e_shift     ! r__r_4t0
2002 LSYM(x181)      t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__4t0_a0
2003 LSYM(x182)      t0__9a0         ! t0__5t0       ! b_e_2t0       ! t0__2t0_a0
2004 LSYM(x183)      t0__9a0         ! t0__5t0       ! b_e_2t0a0     ! t0__2t0_a0
2005 LSYM(x184)      t0__5a0         ! t0__9t0       ! b_e_4t0       ! t0__t0_a0
2006 LSYM(x185)      t0__9a0         ! t0__4t0_a0    ! b_e_t0        ! t0__5t0
2007 LSYM(x186)      t0__32a0        ! t0__t0ma0     ! b_e_2t0       ! t0__3t0
2008 LSYM(x187)      t0__9a0         ! t0__4t0_a0    ! b_e_t02a0     ! t0__5t0
2009 LSYM(x188)      t0__9a0         ! t0__5t0       ! b_e_4t0       ! t0__t0_2a0
2010 LSYM(x189)      t0__5a0         ! t0__4t0_a0    ! b_e_t0        ! t0__9t0
2011 LSYM(x190)      t0__9a0         ! t0__2t0_a0    ! b_e_2t0       ! t0__5t0
2012 LSYM(x191)      t0__64a0        ! t0__3t0       ! b_e_t0        ! t0__t0ma0
2013 LSYM(x192)      t0__8a0         ! t0__3t0       ! b_e_shift     ! r__r_8t0
2014 LSYM(x193)      t0__8a0         ! t0__3t0       ! b_e_t0        ! t0__8t0_a0
2015 LSYM(x194)      t0__8a0         ! t0__3t0       ! b_e_2t0       ! t0__4t0_a0
2016 LSYM(x195)      t0__8a0         ! t0__8t0_a0    ! b_e_t0        ! t0__3t0
2017 LSYM(x196)      t0__8a0         ! t0__3t0       ! b_e_4t0       ! t0__2t0_a0
2018 LSYM(x197)      t0__8a0         ! t0__3t0       ! b_e_4t0a0     ! t0__2t0_a0
2019 LSYM(x198)      t0__64a0        ! t0__t0_2a0    ! b_e_t0        ! t0__3t0
2020 LSYM(x199)      t0__8a0         ! t0__4t0_a0    ! b_e_2t0a0     ! t0__3t0
2021 LSYM(x200)      t0__5a0         ! t0__5t0       ! b_e_shift     ! r__r_8t0
2022 LSYM(x201)      t0__5a0         ! t0__5t0       ! b_e_t0        ! t0__8t0_a0
2023 LSYM(x202)      t0__5a0         ! t0__5t0       ! b_e_2t0       ! t0__4t0_a0
2024 LSYM(x203)      t0__5a0         ! t0__5t0       ! b_e_2t0a0     ! t0__4t0_a0
2025 LSYM(x204)      t0__8a0         ! t0__2t0_a0    ! b_e_4t0       ! t0__3t0
2026 LSYM(x205)      t0__5a0         ! t0__8t0_a0    ! b_e_t0        ! t0__5t0
2027 LSYM(x206)      t0__64a0        ! t0__t0_4a0    ! b_e_t02a0     ! t0__3t0
2028 LSYM(x207)      t0__8a0         ! t0__2t0_a0    ! b_e_3t0       ! t0__4t0_a0
2029 LSYM(x208)      t0__5a0         ! t0__5t0       ! b_e_8t0       ! t0__t0_a0
2030 LSYM(x209)      t0__5a0         ! t0__5t0       ! b_e_8t0a0     ! t0__t0_a0
2031 LSYM(x210)      t0__5a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__5t0
2032 LSYM(x211)      t0__5a0         ! t0__4t0_a0    ! b_e_2t0a0     ! t0__5t0
2033 LSYM(x212)      t0__3a0         ! t0__4t0_a0    ! b_e_4t0       ! t0__4t0_a0
2034 LSYM(x213)      t0__3a0         ! t0__4t0_a0    ! b_e_4t0a0     ! t0__4t0_a0
2035 LSYM(x214)      t0__9a0         ! t0__t0_4a0    ! b_e_2t04a0    ! t0__8t0_a0
2036 LSYM(x215)      t0__5a0         ! t0__4t0_a0    ! b_e_5t0       ! t0__2t0_a0
2037 LSYM(x216)      t0__9a0         ! t0__3t0       ! b_e_shift     ! r__r_8t0
2038 LSYM(x217)      t0__9a0         ! t0__3t0       ! b_e_t0        ! t0__8t0_a0
2039 LSYM(x218)      t0__9a0         ! t0__3t0       ! b_e_2t0       ! t0__4t0_a0
2040 LSYM(x219)      t0__9a0         ! t0__8t0_a0    ! b_e_t0        ! t0__3t0
2041 LSYM(x220)      t0__3a0         ! t0__9t0       ! b_e_4t0       ! t0__2t0_a0
2042 LSYM(x221)      t0__3a0         ! t0__9t0       ! b_e_4t0a0     ! t0__2t0_a0
2043 LSYM(x222)      t0__9a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__3t0
2044 LSYM(x223)      t0__9a0         ! t0__4t0_a0    ! b_e_2t0a0     ! t0__3t0
2045 LSYM(x224)      t0__9a0         ! t0__3t0       ! b_e_8t0       ! t0__t0_a0
2046 LSYM(x225)      t0__9a0         ! t0__5t0       ! b_e_t0        ! t0__5t0
2047 LSYM(x226)      t0__3a0         ! t0__2t0_a0    ! b_e_t02a0     ! t0__32t0
2048 LSYM(x227)      t0__9a0         ! t0__5t0       ! b_e_t02a0     ! t0__5t0
2049 LSYM(x228)      t0__9a0         ! t0__2t0_a0    ! b_e_4t0       ! t0__3t0
2050 LSYM(x229)      t0__9a0         ! t0__2t0_a0    ! b_e_4t0a0     ! t0__3t0
2051 LSYM(x230)      t0__9a0         ! t0__5t0       ! b_e_5t0       ! t0__t0_a0
2052 LSYM(x231)      t0__9a0         ! t0__2t0_a0    ! b_e_3t0       ! t0__4t0_a0
2053 LSYM(x232)      t0__3a0         ! t0__2t0_a0    ! b_e_8t0       ! t0__4t0_a0
2054 LSYM(x233)      t0__3a0         ! t0__2t0_a0    ! b_e_8t0a0     ! t0__4t0_a0
2055 LSYM(x234)      t0__3a0         ! t0__4t0_a0    ! b_e_2t0       ! t0__9t0
2056 LSYM(x235)      t0__3a0         ! t0__4t0_a0    ! b_e_2t0a0     ! t0__9t0
2057 LSYM(x236)      t0__9a0         ! t0__2t0_a0    ! b_e_4t08a0    ! t0__3t0
2058 LSYM(x237)      t0__16a0        ! t0__5t0       ! b_e_3t0       ! t0__t0ma0
2059 LSYM(x238)      t0__3a0         ! t0__4t0_a0    ! b_e_2t04a0    ! t0__9t0
2060 LSYM(x239)      t0__16a0        ! t0__5t0       ! b_e_t0ma0     ! t0__3t0
2061 LSYM(x240)      t0__9a0         ! t0__t0_a0     ! b_e_8t0       ! t0__3t0
2062 LSYM(x241)      t0__9a0         ! t0__t0_a0     ! b_e_8t0a0     ! t0__3t0
2063 LSYM(x242)      t0__5a0         ! t0__3t0       ! b_e_2t0       ! t0__8t0_a0
2064 LSYM(x243)      t0__9a0         ! t0__9t0       ! b_e_t0        ! t0__3t0
2065 LSYM(x244)      t0__5a0         ! t0__3t0       ! b_e_4t0       ! t0__4t0_a0
2066 LSYM(x245)      t0__8a0         ! t0__3t0       ! b_e_5t0       ! t0__2t0_a0
2067 LSYM(x246)      t0__5a0         ! t0__8t0_a0    ! b_e_2t0       ! t0__3t0
2068 LSYM(x247)      t0__5a0         ! t0__8t0_a0    ! b_e_2t0a0     ! t0__3t0
2069 LSYM(x248)      t0__32a0        ! t0__t0ma0     ! b_e_shift     ! r__r_8t0
2070 LSYM(x249)      t0__32a0        ! t0__t0ma0     ! b_e_t0        ! t0__8t0_a0
2071 LSYM(x250)      t0__5a0         ! t0__5t0       ! b_e_2t0       ! t0__5t0
2072 LSYM(x251)      t0__5a0         ! t0__5t0       ! b_e_2t0a0     ! t0__5t0
2073 LSYM(x252)      t0__64a0        ! t0__t0ma0     ! b_e_shift     ! r__r_4t0
2074 LSYM(x253)      t0__64a0        ! t0__t0ma0     ! b_e_t0        ! t0__4t0_a0
2075 LSYM(x254)      t0__128a0       ! t0__t0ma0     ! b_e_shift     ! r__r_2t0
2076 LSYM(x255)      t0__256a0       ! a1_ne_0_b_l0  ! t0__t0ma0     ! b_n_ret_t0
2077 /*1040 insts before this.  */
2078 LSYM(ret_t0)    MILLIRET
2079 LSYM(e_t0)      r__r_t0
2080 LSYM(e_shift)   a1_ne_0_b_l2
2081         a0__256a0       /* a0 <<= 8 *********** */
2082         MILLIRETN
2083 LSYM(e_t0ma0)   a1_ne_0_b_l0
2084         t0__t0ma0
2085         MILLIRET
2086         r__r_t0
2087 LSYM(e_t0a0)    a1_ne_0_b_l0
2088         t0__t0_a0
2089         MILLIRET
2090         r__r_t0
2091 LSYM(e_t02a0)   a1_ne_0_b_l0
2092         t0__t0_2a0
2093         MILLIRET
2094         r__r_t0
2095 LSYM(e_t04a0)   a1_ne_0_b_l0
2096         t0__t0_4a0
2097         MILLIRET
2098         r__r_t0
2099 LSYM(e_2t0)     a1_ne_0_b_l1
2100         r__r_2t0
2101         MILLIRETN
2102 LSYM(e_2t0a0)   a1_ne_0_b_l0
2103         t0__2t0_a0
2104         MILLIRET
2105         r__r_t0
2106 LSYM(e2t04a0)   t0__t0_2a0
2107         a1_ne_0_b_l1
2108         r__r_2t0
2109         MILLIRETN
2110 LSYM(e_3t0)     a1_ne_0_b_l0
2111         t0__3t0
2112         MILLIRET
2113         r__r_t0
2114 LSYM(e_4t0)     a1_ne_0_b_l1
2115         r__r_4t0
2116         MILLIRETN
2117 LSYM(e_4t0a0)   a1_ne_0_b_l0
2118         t0__4t0_a0
2119         MILLIRET
2120         r__r_t0
2121 LSYM(e4t08a0)   t0__t0_2a0
2122         a1_ne_0_b_l1
2123         r__r_4t0
2124         MILLIRETN
2125 LSYM(e_5t0)     a1_ne_0_b_l0
2126         t0__5t0
2127         MILLIRET
2128         r__r_t0
2129 LSYM(e_8t0)     a1_ne_0_b_l1
2130         r__r_8t0
2131         MILLIRETN
2132 LSYM(e_8t0a0)   a1_ne_0_b_l0
2133         t0__8t0_a0
2134         MILLIRET
2135         r__r_t0
2136
2137         .procend
2138         .end
2139 #endif