alpha-mont.pl: gcc portability fix and make-rule.
[openssl.git] / crypto / bn / asm / pa-risc2W.s
1 ;
2 ; PA-RISC 64-bit implementation of bn_asm code
3 ;
4 ; This code is approximately 2x faster than the C version
5 ; for RSA/DSA.
6 ;
7 ; See http://devresource.hp.com/  for more details on the PA-RISC
8 ; architecture.  Also see the book "PA-RISC 2.0 Architecture"
9 ; by Gerry Kane for information on the instruction set architecture.
10 ;
11 ; Code written by Chris Ruemmler (with some help from the HP C
12 ; compiler).
13 ;
14 ; The code compiles with HP's assembler
15 ;
16
17         .level  2.0W
18         .space  $TEXT$
19         .subspa $CODE$,QUAD=0,ALIGN=8,ACCESS=0x2c,CODE_ONLY
20
21 ;
22 ; Global Register definitions used for the routines.
23 ;
24 ; Some information about HP's runtime architecture for 64-bits.
25 ;
26 ; "Caller save" means the calling function must save the register
27 ; if it wants the register to be preserved.
28 ; "Callee save" means if a function uses the register, it must save
29 ; the value before using it.
30 ;
31 ; For the floating point registers 
32 ;
33 ;    "caller save" registers: fr4-fr11, fr22-fr31
34 ;    "callee save" registers: fr12-fr21
35 ;    "special" registers: fr0-fr3 (status and exception registers)
36 ;
37 ; For the integer registers
38 ;     value zero             :  r0
39 ;     "caller save" registers: r1,r19-r26
40 ;     "callee save" registers: r3-r18
41 ;     return register        :  r2  (rp)
42 ;     return values          ; r28  (ret0,ret1)
43 ;     Stack pointer          ; r30  (sp) 
44 ;     global data pointer    ; r27  (dp)
45 ;     argument pointer       ; r29  (ap)
46 ;     millicode return ptr   ; r31  (also a caller save register)
47
48
49 ;
50 ; Arguments to the routines
51 ;
52 r_ptr       .reg %r26
53 a_ptr       .reg %r25
54 b_ptr       .reg %r24
55 num         .reg %r24
56 w           .reg %r23
57 n           .reg %r23
58
59
60 ;
61 ; Globals used in some routines
62 ;
63
64 top_overflow .reg %r29
65 high_mask    .reg %r22    ; value 0xffffffff80000000L
66
67
68 ;------------------------------------------------------------------------------
69 ;
70 ; bn_mul_add_words
71 ;
72 ;BN_ULONG bn_mul_add_words(BN_ULONG *r_ptr, BN_ULONG *a_ptr, 
73 ;                                                               int num, BN_ULONG w)
74 ;
75 ; arg0 = r_ptr
76 ; arg1 = a_ptr
77 ; arg2 = num
78 ; arg3 = w
79 ;
80 ; Local register definitions
81 ;
82
83 fm1          .reg %fr22
84 fm           .reg %fr23
85 ht_temp      .reg %fr24
86 ht_temp_1    .reg %fr25
87 lt_temp      .reg %fr26
88 lt_temp_1    .reg %fr27
89 fm1_1        .reg %fr28
90 fm_1         .reg %fr29
91
92 fw_h         .reg %fr7L
93 fw_l         .reg %fr7R
94 fw           .reg %fr7
95
96 fht_0        .reg %fr8L
97 flt_0        .reg %fr8R
98 t_float_0    .reg %fr8
99
100 fht_1        .reg %fr9L
101 flt_1        .reg %fr9R
102 t_float_1    .reg %fr9
103
104 tmp_0        .reg %r31
105 tmp_1        .reg %r21
106 m_0          .reg %r20 
107 m_1          .reg %r19 
108 ht_0         .reg %r1  
109 ht_1         .reg %r3
110 lt_0         .reg %r4
111 lt_1         .reg %r5
112 m1_0         .reg %r6 
113 m1_1         .reg %r7 
114 rp_val       .reg %r8
115 rp_val_1     .reg %r9
116
117 bn_mul_add_words
118         .export bn_mul_add_words,entry,NO_RELOCATION,LONG_RETURN
119         .proc
120         .callinfo frame=128
121     .entry
122         .align 64
123
124     STD     %r3,0(%sp)          ; save r3  
125     STD     %r4,8(%sp)          ; save r4  
126         NOP                         ; Needed to make the loop 16-byte aligned
127         NOP                         ; Needed to make the loop 16-byte aligned
128
129     STD     %r5,16(%sp)         ; save r5  
130     STD     %r6,24(%sp)         ; save r6  
131     STD     %r7,32(%sp)         ; save r7  
132     STD     %r8,40(%sp)         ; save r8  
133
134     STD     %r9,48(%sp)         ; save r9  
135     COPY    %r0,%ret0           ; return 0 by default
136     DEPDI,Z 1,31,1,top_overflow ; top_overflow = 1 << 32    
137         STD     w,56(%sp)           ; store w on stack
138
139     CMPIB,>= 0,num,bn_mul_add_words_exit  ; if (num <= 0) then exit
140         LDO     128(%sp),%sp       ; bump stack
141
142         ;
143         ; The loop is unrolled twice, so if there is only 1 number
144     ; then go straight to the cleanup code.
145         ;
146         CMPIB,= 1,num,bn_mul_add_words_single_top
147         FLDD    -72(%sp),fw     ; load up w into fp register fw (fw_h/fw_l)
148
149         ;
150         ; This loop is unrolled 2 times (64-byte aligned as well)
151         ;
152         ; PA-RISC 2.0 chips have two fully pipelined multipliers, thus
153     ; two 32-bit mutiplies can be issued per cycle.
154     ; 
155 bn_mul_add_words_unroll2
156
157     FLDD    0(a_ptr),t_float_0       ; load up 64-bit value (fr8L) ht(L)/lt(R)
158     FLDD    8(a_ptr),t_float_1       ; load up 64-bit value (fr8L) ht(L)/lt(R)
159     LDD     0(r_ptr),rp_val          ; rp[0]
160     LDD     8(r_ptr),rp_val_1        ; rp[1]
161
162     XMPYU   fht_0,fw_l,fm1           ; m1[0] = fht_0*fw_l
163     XMPYU   fht_1,fw_l,fm1_1         ; m1[1] = fht_1*fw_l
164     FSTD    fm1,-16(%sp)             ; -16(sp) = m1[0]
165     FSTD    fm1_1,-48(%sp)           ; -48(sp) = m1[1]
166
167     XMPYU   flt_0,fw_h,fm            ; m[0] = flt_0*fw_h
168     XMPYU   flt_1,fw_h,fm_1          ; m[1] = flt_1*fw_h
169     FSTD    fm,-8(%sp)               ; -8(sp) = m[0]
170     FSTD    fm_1,-40(%sp)            ; -40(sp) = m[1]
171
172     XMPYU   fht_0,fw_h,ht_temp       ; ht_temp   = fht_0*fw_h
173     XMPYU   fht_1,fw_h,ht_temp_1     ; ht_temp_1 = fht_1*fw_h
174     FSTD    ht_temp,-24(%sp)         ; -24(sp)   = ht_temp
175     FSTD    ht_temp_1,-56(%sp)       ; -56(sp)   = ht_temp_1
176
177     XMPYU   flt_0,fw_l,lt_temp       ; lt_temp = lt*fw_l
178     XMPYU   flt_1,fw_l,lt_temp_1     ; lt_temp = lt*fw_l
179     FSTD    lt_temp,-32(%sp)         ; -32(sp) = lt_temp 
180     FSTD    lt_temp_1,-64(%sp)       ; -64(sp) = lt_temp_1 
181
182     LDD     -8(%sp),m_0              ; m[0] 
183     LDD     -40(%sp),m_1             ; m[1]
184     LDD     -16(%sp),m1_0            ; m1[0]
185     LDD     -48(%sp),m1_1            ; m1[1]
186
187     LDD     -24(%sp),ht_0            ; ht[0]
188     LDD     -56(%sp),ht_1            ; ht[1]
189     ADD,L   m1_0,m_0,tmp_0           ; tmp_0 = m[0] + m1[0]; 
190     ADD,L   m1_1,m_1,tmp_1           ; tmp_1 = m[1] + m1[1]; 
191
192     LDD     -32(%sp),lt_0            
193     LDD     -64(%sp),lt_1            
194     CMPCLR,*>>= tmp_0,m1_0, %r0      ; if (m[0] < m1[0])
195     ADD,L   ht_0,top_overflow,ht_0   ; ht[0] += (1<<32)
196
197     CMPCLR,*>>= tmp_1,m1_1,%r0       ; if (m[1] < m1[1])
198     ADD,L   ht_1,top_overflow,ht_1   ; ht[1] += (1<<32)
199     EXTRD,U tmp_0,31,32,m_0          ; m[0]>>32  
200     DEPD,Z  tmp_0,31,32,m1_0         ; m1[0] = m[0]<<32 
201
202     EXTRD,U tmp_1,31,32,m_1          ; m[1]>>32  
203     DEPD,Z  tmp_1,31,32,m1_1         ; m1[1] = m[1]<<32 
204     ADD,L   ht_0,m_0,ht_0            ; ht[0]+= (m[0]>>32)
205     ADD,L   ht_1,m_1,ht_1            ; ht[1]+= (m[1]>>32)
206
207     ADD     lt_0,m1_0,lt_0           ; lt[0] = lt[0]+m1[0];
208         ADD,DC  ht_0,%r0,ht_0            ; ht[0]++
209     ADD     lt_1,m1_1,lt_1           ; lt[1] = lt[1]+m1[1];
210     ADD,DC  ht_1,%r0,ht_1            ; ht[1]++
211
212     ADD    %ret0,lt_0,lt_0           ; lt[0] = lt[0] + c;
213         ADD,DC  ht_0,%r0,ht_0            ; ht[0]++
214     ADD     lt_0,rp_val,lt_0         ; lt[0] = lt[0]+rp[0]
215     ADD,DC  ht_0,%r0,ht_0            ; ht[0]++
216
217         LDO    -2(num),num               ; num = num - 2;
218     ADD     ht_0,lt_1,lt_1           ; lt[1] = lt[1] + ht_0 (c);
219     ADD,DC  ht_1,%r0,ht_1            ; ht[1]++
220     STD     lt_0,0(r_ptr)            ; rp[0] = lt[0]
221
222     ADD     lt_1,rp_val_1,lt_1       ; lt[1] = lt[1]+rp[1]
223     ADD,DC  ht_1,%r0,%ret0           ; ht[1]++
224     LDO     16(a_ptr),a_ptr          ; a_ptr += 2
225
226     STD     lt_1,8(r_ptr)            ; rp[1] = lt[1]
227         CMPIB,<= 2,num,bn_mul_add_words_unroll2 ; go again if more to do
228     LDO     16(r_ptr),r_ptr          ; r_ptr += 2
229
230     CMPIB,=,N 0,num,bn_mul_add_words_exit ; are we done, or cleanup last one
231
232         ;
233         ; Top of loop aligned on 64-byte boundary
234         ;
235 bn_mul_add_words_single_top
236     FLDD    0(a_ptr),t_float_0        ; load up 64-bit value (fr8L) ht(L)/lt(R)
237     LDD     0(r_ptr),rp_val           ; rp[0]
238     LDO     8(a_ptr),a_ptr            ; a_ptr++
239     XMPYU   fht_0,fw_l,fm1            ; m1 = ht*fw_l
240     FSTD    fm1,-16(%sp)              ; -16(sp) = m1
241     XMPYU   flt_0,fw_h,fm             ; m = lt*fw_h
242     FSTD    fm,-8(%sp)                ; -8(sp) = m
243     XMPYU   fht_0,fw_h,ht_temp        ; ht_temp = ht*fw_h
244     FSTD    ht_temp,-24(%sp)          ; -24(sp) = ht
245     XMPYU   flt_0,fw_l,lt_temp        ; lt_temp = lt*fw_l
246     FSTD    lt_temp,-32(%sp)          ; -32(sp) = lt 
247
248     LDD     -8(%sp),m_0               
249     LDD    -16(%sp),m1_0              ; m1 = temp1 
250     ADD,L   m_0,m1_0,tmp_0            ; tmp_0 = m + m1; 
251     LDD     -24(%sp),ht_0             
252     LDD     -32(%sp),lt_0             
253
254     CMPCLR,*>>= tmp_0,m1_0,%r0        ; if (m < m1)
255     ADD,L   ht_0,top_overflow,ht_0    ; ht += (1<<32)
256
257     EXTRD,U tmp_0,31,32,m_0           ; m>>32  
258     DEPD,Z  tmp_0,31,32,m1_0          ; m1 = m<<32 
259
260     ADD,L   ht_0,m_0,ht_0             ; ht+= (m>>32)
261     ADD     lt_0,m1_0,tmp_0           ; tmp_0 = lt+m1;
262     ADD,DC  ht_0,%r0,ht_0             ; ht++
263     ADD     %ret0,tmp_0,lt_0          ; lt = lt + c;
264     ADD,DC  ht_0,%r0,ht_0             ; ht++
265     ADD     lt_0,rp_val,lt_0          ; lt = lt+rp[0]
266     ADD,DC  ht_0,%r0,%ret0            ; ht++
267     STD     lt_0,0(r_ptr)             ; rp[0] = lt
268
269 bn_mul_add_words_exit
270     .EXIT
271     LDD     -80(%sp),%r9              ; restore r9  
272     LDD     -88(%sp),%r8              ; restore r8  
273     LDD     -96(%sp),%r7              ; restore r7  
274     LDD     -104(%sp),%r6             ; restore r6  
275     LDD     -112(%sp),%r5             ; restore r5  
276     LDD     -120(%sp),%r4             ; restore r4  
277     BVE     (%rp)
278     LDD,MB  -128(%sp),%r3             ; restore r3
279         .PROCEND        ;in=23,24,25,26,29;out=28;
280
281 ;----------------------------------------------------------------------------
282 ;
283 ;BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
284 ;
285 ; arg0 = rp
286 ; arg1 = ap
287 ; arg2 = num
288 ; arg3 = w
289
290 bn_mul_words
291         .proc
292         .callinfo frame=128
293     .entry
294         .EXPORT bn_mul_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
295         .align 64
296
297     STD     %r3,0(%sp)          ; save r3  
298     STD     %r4,8(%sp)          ; save r4  
299     STD     %r5,16(%sp)         ; save r5  
300     STD     %r6,24(%sp)         ; save r6  
301
302     STD     %r7,32(%sp)         ; save r7  
303     COPY    %r0,%ret0           ; return 0 by default
304     DEPDI,Z 1,31,1,top_overflow ; top_overflow = 1 << 32    
305         STD     w,56(%sp)           ; w on stack
306
307     CMPIB,>= 0,num,bn_mul_words_exit
308         LDO     128(%sp),%sp       ; bump stack
309
310         ;
311         ; See if only 1 word to do, thus just do cleanup
312         ;
313         CMPIB,= 1,num,bn_mul_words_single_top
314         FLDD    -72(%sp),fw     ; load up w into fp register fw (fw_h/fw_l)
315
316         ;
317         ; This loop is unrolled 2 times (64-byte aligned as well)
318         ;
319         ; PA-RISC 2.0 chips have two fully pipelined multipliers, thus
320     ; two 32-bit mutiplies can be issued per cycle.
321     ; 
322 bn_mul_words_unroll2
323
324     FLDD    0(a_ptr),t_float_0        ; load up 64-bit value (fr8L) ht(L)/lt(R)
325     FLDD    8(a_ptr),t_float_1        ; load up 64-bit value (fr8L) ht(L)/lt(R)
326     XMPYU   fht_0,fw_l,fm1            ; m1[0] = fht_0*fw_l
327     XMPYU   fht_1,fw_l,fm1_1          ; m1[1] = ht*fw_l
328
329     FSTD    fm1,-16(%sp)              ; -16(sp) = m1
330     FSTD    fm1_1,-48(%sp)            ; -48(sp) = m1
331     XMPYU   flt_0,fw_h,fm             ; m = lt*fw_h
332     XMPYU   flt_1,fw_h,fm_1           ; m = lt*fw_h
333
334     FSTD    fm,-8(%sp)                ; -8(sp) = m
335     FSTD    fm_1,-40(%sp)             ; -40(sp) = m
336     XMPYU   fht_0,fw_h,ht_temp        ; ht_temp = fht_0*fw_h
337     XMPYU   fht_1,fw_h,ht_temp_1      ; ht_temp = ht*fw_h
338
339     FSTD    ht_temp,-24(%sp)          ; -24(sp) = ht
340     FSTD    ht_temp_1,-56(%sp)        ; -56(sp) = ht
341     XMPYU   flt_0,fw_l,lt_temp        ; lt_temp = lt*fw_l
342     XMPYU   flt_1,fw_l,lt_temp_1      ; lt_temp = lt*fw_l
343
344     FSTD    lt_temp,-32(%sp)          ; -32(sp) = lt 
345     FSTD    lt_temp_1,-64(%sp)        ; -64(sp) = lt 
346     LDD     -8(%sp),m_0               
347     LDD     -40(%sp),m_1              
348
349     LDD    -16(%sp),m1_0              
350     LDD    -48(%sp),m1_1              
351     LDD     -24(%sp),ht_0             
352     LDD     -56(%sp),ht_1             
353
354     ADD,L   m1_0,m_0,tmp_0            ; tmp_0 = m + m1; 
355     ADD,L   m1_1,m_1,tmp_1            ; tmp_1 = m + m1; 
356     LDD     -32(%sp),lt_0             
357     LDD     -64(%sp),lt_1             
358
359     CMPCLR,*>>= tmp_0,m1_0, %r0       ; if (m < m1)
360     ADD,L   ht_0,top_overflow,ht_0    ; ht += (1<<32)
361     CMPCLR,*>>= tmp_1,m1_1,%r0        ; if (m < m1)
362     ADD,L   ht_1,top_overflow,ht_1    ; ht += (1<<32)
363
364     EXTRD,U tmp_0,31,32,m_0           ; m>>32  
365     DEPD,Z  tmp_0,31,32,m1_0          ; m1 = m<<32 
366     EXTRD,U tmp_1,31,32,m_1           ; m>>32  
367     DEPD,Z  tmp_1,31,32,m1_1          ; m1 = m<<32 
368
369     ADD,L   ht_0,m_0,ht_0             ; ht+= (m>>32)
370     ADD,L   ht_1,m_1,ht_1             ; ht+= (m>>32)
371     ADD     lt_0,m1_0,lt_0            ; lt = lt+m1;
372         ADD,DC  ht_0,%r0,ht_0             ; ht++
373
374     ADD     lt_1,m1_1,lt_1            ; lt = lt+m1;
375     ADD,DC  ht_1,%r0,ht_1             ; ht++
376     ADD    %ret0,lt_0,lt_0            ; lt = lt + c (ret0);
377         ADD,DC  ht_0,%r0,ht_0             ; ht++
378
379     ADD     ht_0,lt_1,lt_1            ; lt = lt + c (ht_0)
380     ADD,DC  ht_1,%r0,ht_1             ; ht++
381     STD     lt_0,0(r_ptr)             ; rp[0] = lt
382     STD     lt_1,8(r_ptr)             ; rp[1] = lt
383
384         COPY    ht_1,%ret0                ; carry = ht
385         LDO    -2(num),num                ; num = num - 2;
386     LDO     16(a_ptr),a_ptr           ; ap += 2
387         CMPIB,<= 2,num,bn_mul_words_unroll2
388     LDO     16(r_ptr),r_ptr           ; rp++
389
390     CMPIB,=,N 0,num,bn_mul_words_exit ; are we done?
391
392         ;
393         ; Top of loop aligned on 64-byte boundary
394         ;
395 bn_mul_words_single_top
396     FLDD    0(a_ptr),t_float_0        ; load up 64-bit value (fr8L) ht(L)/lt(R)
397
398     XMPYU   fht_0,fw_l,fm1            ; m1 = ht*fw_l
399     FSTD    fm1,-16(%sp)              ; -16(sp) = m1
400     XMPYU   flt_0,fw_h,fm             ; m = lt*fw_h
401     FSTD    fm,-8(%sp)                ; -8(sp) = m
402     XMPYU   fht_0,fw_h,ht_temp        ; ht_temp = ht*fw_h
403     FSTD    ht_temp,-24(%sp)          ; -24(sp) = ht
404     XMPYU   flt_0,fw_l,lt_temp        ; lt_temp = lt*fw_l
405     FSTD    lt_temp,-32(%sp)          ; -32(sp) = lt 
406
407     LDD     -8(%sp),m_0               
408     LDD    -16(%sp),m1_0              
409     ADD,L   m_0,m1_0,tmp_0            ; tmp_0 = m + m1; 
410     LDD     -24(%sp),ht_0             
411     LDD     -32(%sp),lt_0             
412
413     CMPCLR,*>>= tmp_0,m1_0,%r0        ; if (m < m1)
414     ADD,L   ht_0,top_overflow,ht_0    ; ht += (1<<32)
415
416     EXTRD,U tmp_0,31,32,m_0           ; m>>32  
417     DEPD,Z  tmp_0,31,32,m1_0          ; m1 = m<<32 
418
419     ADD,L   ht_0,m_0,ht_0             ; ht+= (m>>32)
420     ADD     lt_0,m1_0,lt_0            ; lt= lt+m1;
421     ADD,DC  ht_0,%r0,ht_0             ; ht++
422
423     ADD     %ret0,lt_0,lt_0           ; lt = lt + c;
424     ADD,DC  ht_0,%r0,ht_0             ; ht++
425
426     COPY    ht_0,%ret0                ; copy carry
427     STD     lt_0,0(r_ptr)             ; rp[0] = lt
428
429 bn_mul_words_exit
430     .EXIT
431     LDD     -96(%sp),%r7              ; restore r7  
432     LDD     -104(%sp),%r6             ; restore r6  
433     LDD     -112(%sp),%r5             ; restore r5  
434     LDD     -120(%sp),%r4             ; restore r4  
435     BVE     (%rp)
436     LDD,MB  -128(%sp),%r3             ; restore r3
437         .PROCEND        ;in=23,24,25,26,29;out=28;
438
439 ;----------------------------------------------------------------------------
440 ;
441 ;void bn_sqr_words(BN_ULONG *rp, BN_ULONG *ap, int num)
442 ;
443 ; arg0 = rp
444 ; arg1 = ap
445 ; arg2 = num
446 ;
447
448 bn_sqr_words
449         .proc
450         .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE
451         .EXPORT bn_sqr_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
452     .entry
453         .align 64
454
455     STD     %r3,0(%sp)          ; save r3  
456     STD     %r4,8(%sp)          ; save r4  
457         NOP
458     STD     %r5,16(%sp)         ; save r5  
459
460     CMPIB,>= 0,num,bn_sqr_words_exit
461         LDO     128(%sp),%sp       ; bump stack
462
463         ;
464         ; If only 1, the goto straight to cleanup
465         ;
466         CMPIB,= 1,num,bn_sqr_words_single_top
467     DEPDI,Z -1,32,33,high_mask   ; Create Mask 0xffffffff80000000L
468
469         ;
470         ; This loop is unrolled 2 times (64-byte aligned as well)
471         ;
472
473 bn_sqr_words_unroll2
474     FLDD    0(a_ptr),t_float_0        ; a[0]
475     FLDD    8(a_ptr),t_float_1        ; a[1]
476     XMPYU   fht_0,flt_0,fm            ; m[0]
477     XMPYU   fht_1,flt_1,fm_1          ; m[1]
478
479     FSTD    fm,-24(%sp)               ; store m[0]
480     FSTD    fm_1,-56(%sp)             ; store m[1]
481     XMPYU   flt_0,flt_0,lt_temp       ; lt[0]
482     XMPYU   flt_1,flt_1,lt_temp_1     ; lt[1]
483
484     FSTD    lt_temp,-16(%sp)          ; store lt[0]
485     FSTD    lt_temp_1,-48(%sp)        ; store lt[1]
486     XMPYU   fht_0,fht_0,ht_temp       ; ht[0]
487     XMPYU   fht_1,fht_1,ht_temp_1     ; ht[1]
488
489     FSTD    ht_temp,-8(%sp)           ; store ht[0]
490     FSTD    ht_temp_1,-40(%sp)        ; store ht[1]
491     LDD     -24(%sp),m_0             
492     LDD     -56(%sp),m_1              
493
494     AND     m_0,high_mask,tmp_0       ; m[0] & Mask
495     AND     m_1,high_mask,tmp_1       ; m[1] & Mask
496     DEPD,Z  m_0,30,31,m_0             ; m[0] << 32+1
497     DEPD,Z  m_1,30,31,m_1             ; m[1] << 32+1
498
499     LDD     -16(%sp),lt_0        
500     LDD     -48(%sp),lt_1        
501     EXTRD,U tmp_0,32,33,tmp_0         ; tmp_0 = m[0]&Mask >> 32-1
502     EXTRD,U tmp_1,32,33,tmp_1         ; tmp_1 = m[1]&Mask >> 32-1
503
504     LDD     -8(%sp),ht_0            
505     LDD     -40(%sp),ht_1           
506     ADD,L   ht_0,tmp_0,ht_0           ; ht[0] += tmp_0
507     ADD,L   ht_1,tmp_1,ht_1           ; ht[1] += tmp_1
508
509     ADD     lt_0,m_0,lt_0             ; lt = lt+m
510     ADD,DC  ht_0,%r0,ht_0             ; ht[0]++
511     STD     lt_0,0(r_ptr)             ; rp[0] = lt[0]
512     STD     ht_0,8(r_ptr)             ; rp[1] = ht[1]
513
514     ADD     lt_1,m_1,lt_1             ; lt = lt+m
515     ADD,DC  ht_1,%r0,ht_1             ; ht[1]++
516     STD     lt_1,16(r_ptr)            ; rp[2] = lt[1]
517     STD     ht_1,24(r_ptr)            ; rp[3] = ht[1]
518
519         LDO    -2(num),num                ; num = num - 2;
520     LDO     16(a_ptr),a_ptr           ; ap += 2
521         CMPIB,<= 2,num,bn_sqr_words_unroll2
522     LDO     32(r_ptr),r_ptr           ; rp += 4
523
524     CMPIB,=,N 0,num,bn_sqr_words_exit ; are we done?
525
526         ;
527         ; Top of loop aligned on 64-byte boundary
528         ;
529 bn_sqr_words_single_top
530     FLDD    0(a_ptr),t_float_0        ; load up 64-bit value (fr8L) ht(L)/lt(R)
531
532     XMPYU   fht_0,flt_0,fm            ; m
533     FSTD    fm,-24(%sp)               ; store m
534
535     XMPYU   flt_0,flt_0,lt_temp       ; lt
536     FSTD    lt_temp,-16(%sp)          ; store lt
537
538     XMPYU   fht_0,fht_0,ht_temp       ; ht
539     FSTD    ht_temp,-8(%sp)           ; store ht
540
541     LDD     -24(%sp),m_0              ; load m
542     AND     m_0,high_mask,tmp_0       ; m & Mask
543     DEPD,Z  m_0,30,31,m_0             ; m << 32+1
544     LDD     -16(%sp),lt_0             ; lt
545
546     LDD     -8(%sp),ht_0              ; ht
547     EXTRD,U tmp_0,32,33,tmp_0         ; tmp_0 = m&Mask >> 32-1
548     ADD     m_0,lt_0,lt_0             ; lt = lt+m
549     ADD,L   ht_0,tmp_0,ht_0           ; ht += tmp_0
550     ADD,DC  ht_0,%r0,ht_0             ; ht++
551
552     STD     lt_0,0(r_ptr)             ; rp[0] = lt
553     STD     ht_0,8(r_ptr)             ; rp[1] = ht
554
555 bn_sqr_words_exit
556     .EXIT
557     LDD     -112(%sp),%r5       ; restore r5  
558     LDD     -120(%sp),%r4       ; restore r4  
559     BVE     (%rp)
560     LDD,MB  -128(%sp),%r3 
561         .PROCEND        ;in=23,24,25,26,29;out=28;
562
563
564 ;----------------------------------------------------------------------------
565 ;
566 ;BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
567 ;
568 ; arg0 = rp 
569 ; arg1 = ap
570 ; arg2 = bp 
571 ; arg3 = n
572
573 t  .reg %r22
574 b  .reg %r21
575 l  .reg %r20
576
577 bn_add_words
578         .proc
579     .entry
580         .callinfo
581         .EXPORT bn_add_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
582         .align 64
583
584     CMPIB,>= 0,n,bn_add_words_exit
585     COPY    %r0,%ret0           ; return 0 by default
586
587         ;
588         ; If 2 or more numbers do the loop
589         ;
590         CMPIB,= 1,n,bn_add_words_single_top
591         NOP
592
593         ;
594         ; This loop is unrolled 2 times (64-byte aligned as well)
595         ;
596 bn_add_words_unroll2
597         LDD     0(a_ptr),t
598         LDD     0(b_ptr),b
599         ADD     t,%ret0,t                    ; t = t+c;
600         ADD,DC  %r0,%r0,%ret0                ; set c to carry
601         ADD     t,b,l                        ; l = t + b[0]
602         ADD,DC  %ret0,%r0,%ret0              ; c+= carry
603         STD     l,0(r_ptr)
604
605         LDD     8(a_ptr),t
606         LDD     8(b_ptr),b
607         ADD     t,%ret0,t                     ; t = t+c;
608         ADD,DC  %r0,%r0,%ret0                 ; set c to carry
609         ADD     t,b,l                         ; l = t + b[0]
610         ADD,DC  %ret0,%r0,%ret0               ; c+= carry
611         STD     l,8(r_ptr)
612
613         LDO     -2(n),n
614         LDO     16(a_ptr),a_ptr
615         LDO     16(b_ptr),b_ptr
616
617         CMPIB,<= 2,n,bn_add_words_unroll2
618         LDO     16(r_ptr),r_ptr
619
620     CMPIB,=,N 0,n,bn_add_words_exit ; are we done?
621
622 bn_add_words_single_top
623         LDD     0(a_ptr),t
624         LDD     0(b_ptr),b
625
626         ADD     t,%ret0,t                 ; t = t+c;
627         ADD,DC  %r0,%r0,%ret0             ; set c to carry (could use CMPCLR??)
628         ADD     t,b,l                     ; l = t + b[0]
629         ADD,DC  %ret0,%r0,%ret0           ; c+= carry
630         STD     l,0(r_ptr)
631
632 bn_add_words_exit
633     .EXIT
634     BVE     (%rp)
635         NOP
636         .PROCEND        ;in=23,24,25,26,29;out=28;
637
638 ;----------------------------------------------------------------------------
639 ;
640 ;BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
641 ;
642 ; arg0 = rp 
643 ; arg1 = ap
644 ; arg2 = bp 
645 ; arg3 = n
646
647 t1       .reg %r22
648 t2       .reg %r21
649 sub_tmp1 .reg %r20
650 sub_tmp2 .reg %r19
651
652
653 bn_sub_words
654         .proc
655         .callinfo 
656         .EXPORT bn_sub_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
657     .entry
658         .align 64
659
660     CMPIB,>=  0,n,bn_sub_words_exit
661     COPY    %r0,%ret0           ; return 0 by default
662
663         ;
664         ; If 2 or more numbers do the loop
665         ;
666         CMPIB,= 1,n,bn_sub_words_single_top
667         NOP
668
669         ;
670         ; This loop is unrolled 2 times (64-byte aligned as well)
671         ;
672 bn_sub_words_unroll2
673         LDD     0(a_ptr),t1
674         LDD     0(b_ptr),t2
675         SUB     t1,t2,sub_tmp1           ; t3 = t1-t2; 
676         SUB     sub_tmp1,%ret0,sub_tmp1  ; t3 = t3- c; 
677
678         CMPCLR,*>> t1,t2,sub_tmp2        ; clear if t1 > t2
679         LDO      1(%r0),sub_tmp2
680         
681         CMPCLR,*= t1,t2,%r0
682         COPY    sub_tmp2,%ret0
683         STD     sub_tmp1,0(r_ptr)
684
685         LDD     8(a_ptr),t1
686         LDD     8(b_ptr),t2
687         SUB     t1,t2,sub_tmp1            ; t3 = t1-t2; 
688         SUB     sub_tmp1,%ret0,sub_tmp1   ; t3 = t3- c; 
689         CMPCLR,*>> t1,t2,sub_tmp2         ; clear if t1 > t2
690         LDO      1(%r0),sub_tmp2
691         
692         CMPCLR,*= t1,t2,%r0
693         COPY    sub_tmp2,%ret0
694         STD     sub_tmp1,8(r_ptr)
695
696         LDO     -2(n),n
697         LDO     16(a_ptr),a_ptr
698         LDO     16(b_ptr),b_ptr
699
700         CMPIB,<= 2,n,bn_sub_words_unroll2
701         LDO     16(r_ptr),r_ptr
702
703     CMPIB,=,N 0,n,bn_sub_words_exit ; are we done?
704
705 bn_sub_words_single_top
706         LDD     0(a_ptr),t1
707         LDD     0(b_ptr),t2
708         SUB     t1,t2,sub_tmp1            ; t3 = t1-t2; 
709         SUB     sub_tmp1,%ret0,sub_tmp1   ; t3 = t3- c; 
710         CMPCLR,*>> t1,t2,sub_tmp2         ; clear if t1 > t2
711         LDO      1(%r0),sub_tmp2
712         
713         CMPCLR,*= t1,t2,%r0
714         COPY    sub_tmp2,%ret0
715
716         STD     sub_tmp1,0(r_ptr)
717
718 bn_sub_words_exit
719     .EXIT
720     BVE     (%rp)
721         NOP
722         .PROCEND        ;in=23,24,25,26,29;out=28;
723
724 ;------------------------------------------------------------------------------
725 ;
726 ; unsigned long bn_div_words(unsigned long h, unsigned long l, unsigned long d)
727 ;
728 ; arg0 = h
729 ; arg1 = l
730 ; arg2 = d
731 ;
732 ; This is mainly just modified assembly from the compiler, thus the
733 ; lack of variable names.
734 ;
735 ;------------------------------------------------------------------------------
736 bn_div_words
737         .proc
738         .callinfo CALLER,FRAME=272,ENTRY_GR=%r10,SAVE_RP,ARGS_SAVED,ORDERING_AWARE
739         .EXPORT bn_div_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
740         .IMPORT BN_num_bits_word,CODE,NO_RELOCATION
741         .IMPORT __iob,DATA
742         .IMPORT fprintf,CODE,NO_RELOCATION
743         .IMPORT abort,CODE,NO_RELOCATION
744         .IMPORT $$div2U,MILLICODE
745     .entry
746     STD     %r2,-16(%r30)   
747     STD,MA  %r3,352(%r30)   
748     STD     %r4,-344(%r30)  
749     STD     %r5,-336(%r30)  
750     STD     %r6,-328(%r30)  
751     STD     %r7,-320(%r30)  
752     STD     %r8,-312(%r30)  
753     STD     %r9,-304(%r30)  
754     STD     %r10,-296(%r30)
755
756     STD     %r27,-288(%r30)             ; save gp
757
758     COPY    %r24,%r3           ; save d 
759     COPY    %r26,%r4           ; save h (high 64-bits)
760     LDO      -1(%r0),%ret0     ; return -1 by default   
761
762     CMPB,*=  %r0,%arg2,$D3     ; if (d == 0)
763     COPY    %r25,%r5           ; save l (low 64-bits)
764
765     LDO     -48(%r30),%r29     ; create ap 
766     .CALL   ;in=26,29;out=28;
767     B,L     BN_num_bits_word,%r2 
768     COPY    %r3,%r26        
769     LDD     -288(%r30),%r27    ; restore gp 
770     LDI     64,%r21 
771
772     CMPB,=  %r21,%ret0,$00000012   ;if (i == 64) (forward) 
773     COPY    %ret0,%r24             ; i   
774     MTSARCM %r24    
775     DEPDI,Z -1,%sar,1,%r29  
776     CMPB,*<<,N %r29,%r4,bn_div_err_case ; if (h > 1<<i) (forward) 
777
778 $00000012
779     SUBI    64,%r24,%r31                       ; i = 64 - i;
780     CMPCLR,*<< %r4,%r3,%r0                     ; if (h >= d)
781     SUB     %r4,%r3,%r4                        ; h -= d
782     CMPB,=  %r31,%r0,$0000001A                 ; if (i)
783     COPY    %r0,%r10                           ; ret = 0
784     MTSARCM %r31                               ; i to shift
785     DEPD,Z  %r3,%sar,64,%r3                    ; d <<= i;
786     SUBI    64,%r31,%r19                       ; 64 - i; redundent
787     MTSAR   %r19                               ; (64 -i) to shift
788     SHRPD   %r4,%r5,%sar,%r4                   ; l>> (64-i)
789     MTSARCM %r31                               ; i to shift
790     DEPD,Z  %r5,%sar,64,%r5                    ; l <<= i;
791
792 $0000001A
793     DEPDI,Z -1,31,32,%r19                      
794     EXTRD,U %r3,31,32,%r6                      ; dh=(d&0xfff)>>32
795     EXTRD,U %r3,63,32,%r8                      ; dl = d&0xffffff
796     LDO     2(%r0),%r9
797     STD    %r3,-280(%r30)                      ; "d" to stack
798
799 $0000001C
800     DEPDI,Z -1,63,32,%r29                      ; 
801     EXTRD,U %r4,31,32,%r31                     ; h >> 32
802     CMPB,*=,N  %r31,%r6,$D2                    ; if ((h>>32) != dh)(forward) div
803     COPY    %r4,%r26       
804     EXTRD,U %r4,31,32,%r25 
805     COPY    %r6,%r24      
806     .CALL   ;in=23,24,25,26;out=20,21,22,28,29; (MILLICALL)
807     B,L     $$div2U,%r2     
808     EXTRD,U %r6,31,32,%r23  
809     DEPD    %r28,31,32,%r29 
810 $D2
811     STD     %r29,-272(%r30)                   ; q
812     AND     %r5,%r19,%r24                   ; t & 0xffffffff00000000;
813     EXTRD,U %r24,31,32,%r24                 ; ??? 
814     FLDD    -272(%r30),%fr7                 ; q
815     FLDD    -280(%r30),%fr8                 ; d
816     XMPYU   %fr8L,%fr7L,%fr10  
817     FSTD    %fr10,-256(%r30)   
818     XMPYU   %fr8L,%fr7R,%fr22  
819     FSTD    %fr22,-264(%r30)   
820     XMPYU   %fr8R,%fr7L,%fr11 
821     XMPYU   %fr8R,%fr7R,%fr23
822     FSTD    %fr11,-232(%r30)
823     FSTD    %fr23,-240(%r30)
824     LDD     -256(%r30),%r28
825     DEPD,Z  %r28,31,32,%r2 
826     LDD     -264(%r30),%r20
827     ADD,L   %r20,%r2,%r31   
828     LDD     -232(%r30),%r22 
829     DEPD,Z  %r22,31,32,%r22 
830     LDD     -240(%r30),%r21 
831     B       $00000024       ; enter loop  
832     ADD,L   %r21,%r22,%r23 
833
834 $0000002A
835     LDO     -1(%r29),%r29   
836     SUB     %r23,%r8,%r23   
837 $00000024
838     SUB     %r4,%r31,%r25   
839     AND     %r25,%r19,%r26  
840     CMPB,*<>,N      %r0,%r26,$00000046  ; (forward)
841     DEPD,Z  %r25,31,32,%r20 
842     OR      %r20,%r24,%r21  
843     CMPB,*<<,N  %r21,%r23,$0000002A ;(backward) 
844     SUB     %r31,%r6,%r31   
845 ;-------------Break path---------------------
846
847 $00000046
848     DEPD,Z  %r23,31,32,%r25              ;tl
849     EXTRD,U %r23,31,32,%r26              ;t
850     AND     %r25,%r19,%r24               ;tl = (tl<<32)&0xfffffff0000000L
851     ADD,L   %r31,%r26,%r31               ;th += t; 
852     CMPCLR,*>>=     %r5,%r24,%r0         ;if (l<tl)
853     LDO     1(%r31),%r31                 ; th++;
854     CMPB,*<<=,N     %r31,%r4,$00000036   ;if (n < th) (forward)
855     LDO     -1(%r29),%r29                ;q--; 
856     ADD,L   %r4,%r3,%r4                  ;h += d;
857 $00000036
858     ADDIB,=,N       -1,%r9,$D1 ;if (--count == 0) break (forward) 
859     SUB     %r5,%r24,%r28                ; l -= tl;
860     SUB     %r4,%r31,%r24                ; h -= th;
861     SHRPD   %r24,%r28,32,%r4             ; h = ((h<<32)|(l>>32));
862     DEPD,Z  %r29,31,32,%r10              ; ret = q<<32
863     b      $0000001C
864     DEPD,Z  %r28,31,32,%r5               ; l = l << 32 
865
866 $D1
867     OR      %r10,%r29,%r28           ; ret |= q
868 $D3
869     LDD     -368(%r30),%r2  
870 $D0
871     LDD     -296(%r30),%r10 
872     LDD     -304(%r30),%r9  
873     LDD     -312(%r30),%r8  
874     LDD     -320(%r30),%r7  
875     LDD     -328(%r30),%r6  
876     LDD     -336(%r30),%r5  
877     LDD     -344(%r30),%r4  
878     BVE     (%r2)   
879         .EXIT
880     LDD,MB  -352(%r30),%r3 
881
882 bn_div_err_case
883     MFIA    %r6     
884     ADDIL   L'bn_div_words-bn_div_err_case,%r6,%r1 
885     LDO     R'bn_div_words-bn_div_err_case(%r1),%r6  
886     ADDIL   LT'__iob,%r27,%r1       
887     LDD     RT'__iob(%r1),%r26      
888     ADDIL   L'C$4-bn_div_words,%r6,%r1    
889     LDO     R'C$4-bn_div_words(%r1),%r25  
890     LDO     64(%r26),%r26   
891     .CALL           ;in=24,25,26,29;out=28;
892     B,L     fprintf,%r2    
893     LDO     -48(%r30),%r29 
894     LDD     -288(%r30),%r27
895     .CALL           ;in=29;
896     B,L     abort,%r2      
897     LDO     -48(%r30),%r29 
898     LDD     -288(%r30),%r27
899     B       $D0         
900     LDD     -368(%r30),%r2  
901         .PROCEND        ;in=24,25,26,29;out=28;
902
903 ;----------------------------------------------------------------------------
904 ;
905 ; Registers to hold 64-bit values to manipulate.  The "L" part
906 ; of the register corresponds to the upper 32-bits, while the "R"
907 ; part corresponds to the lower 32-bits
908
909 ; Note, that when using b6 and b7, the code must save these before
910 ; using them because they are callee save registers 
911
912 ;
913 ; Floating point registers to use to save values that
914 ; are manipulated.  These don't collide with ftemp1-6 and
915 ; are all caller save registers
916 ;
917 a0        .reg %fr22
918 a0L       .reg %fr22L
919 a0R       .reg %fr22R
920
921 a1        .reg %fr23
922 a1L       .reg %fr23L
923 a1R       .reg %fr23R
924
925 a2        .reg %fr24
926 a2L       .reg %fr24L
927 a2R       .reg %fr24R
928
929 a3        .reg %fr25
930 a3L       .reg %fr25L
931 a3R       .reg %fr25R
932
933 a4        .reg %fr26
934 a4L       .reg %fr26L
935 a4R       .reg %fr26R
936
937 a5        .reg %fr27
938 a5L       .reg %fr27L
939 a5R       .reg %fr27R
940
941 a6        .reg %fr28
942 a6L       .reg %fr28L
943 a6R       .reg %fr28R
944
945 a7        .reg %fr29
946 a7L       .reg %fr29L
947 a7R       .reg %fr29R
948
949 b0        .reg %fr30
950 b0L       .reg %fr30L
951 b0R       .reg %fr30R
952
953 b1        .reg %fr31
954 b1L       .reg %fr31L
955 b1R       .reg %fr31R
956
957 ;
958 ; Temporary floating point variables, these are all caller save
959 ; registers
960 ;
961 ftemp1    .reg %fr4
962 ftemp2    .reg %fr5
963 ftemp3    .reg %fr6
964 ftemp4    .reg %fr7
965
966 ;
967 ; The B set of registers when used.
968 ;
969
970 b2        .reg %fr8
971 b2L       .reg %fr8L
972 b2R       .reg %fr8R
973
974 b3        .reg %fr9
975 b3L       .reg %fr9L
976 b3R       .reg %fr9R
977
978 b4        .reg %fr10
979 b4L       .reg %fr10L
980 b4R       .reg %fr10R
981
982 b5        .reg %fr11
983 b5L       .reg %fr11L
984 b5R       .reg %fr11R
985
986 b6        .reg %fr12
987 b6L       .reg %fr12L
988 b6R       .reg %fr12R
989
990 b7        .reg %fr13
991 b7L       .reg %fr13L
992 b7R       .reg %fr13R
993
994 c1           .reg %r21   ; only reg
995 temp1        .reg %r20   ; only reg
996 temp2        .reg %r19   ; only reg
997 temp3        .reg %r31   ; only reg
998
999 m1           .reg %r28   
1000 c2           .reg %r23   
1001 high_one     .reg %r1
1002 ht           .reg %r6
1003 lt           .reg %r5
1004 m            .reg %r4
1005 c3           .reg %r3
1006
1007 SQR_ADD_C  .macro  A0L,A0R,C1,C2,C3
1008     XMPYU   A0L,A0R,ftemp1       ; m
1009     FSTD    ftemp1,-24(%sp)      ; store m
1010
1011     XMPYU   A0R,A0R,ftemp2       ; lt
1012     FSTD    ftemp2,-16(%sp)      ; store lt
1013
1014     XMPYU   A0L,A0L,ftemp3       ; ht
1015     FSTD    ftemp3,-8(%sp)       ; store ht
1016
1017     LDD     -24(%sp),m           ; load m
1018     AND     m,high_mask,temp2    ; m & Mask
1019     DEPD,Z  m,30,31,temp3        ; m << 32+1
1020     LDD     -16(%sp),lt          ; lt
1021
1022     LDD     -8(%sp),ht           ; ht
1023     EXTRD,U temp2,32,33,temp1    ; temp1 = m&Mask >> 32-1
1024     ADD     temp3,lt,lt          ; lt = lt+m
1025     ADD,L   ht,temp1,ht          ; ht += temp1
1026     ADD,DC  ht,%r0,ht            ; ht++
1027
1028     ADD     C1,lt,C1             ; c1=c1+lt
1029     ADD,DC  ht,%r0,ht            ; ht++
1030
1031     ADD     C2,ht,C2             ; c2=c2+ht
1032     ADD,DC  C3,%r0,C3            ; c3++
1033 .endm
1034
1035 SQR_ADD_C2 .macro  A0L,A0R,A1L,A1R,C1,C2,C3
1036     XMPYU   A0L,A1R,ftemp1          ; m1 = bl*ht
1037     FSTD    ftemp1,-16(%sp)         ;
1038     XMPYU   A0R,A1L,ftemp2          ; m = bh*lt
1039     FSTD    ftemp2,-8(%sp)          ;
1040     XMPYU   A0R,A1R,ftemp3          ; lt = bl*lt
1041     FSTD    ftemp3,-32(%sp)
1042     XMPYU   A0L,A1L,ftemp4          ; ht = bh*ht
1043     FSTD    ftemp4,-24(%sp)         ;
1044
1045     LDD     -8(%sp),m               ; r21 = m
1046     LDD     -16(%sp),m1             ; r19 = m1
1047     ADD,L   m,m1,m                  ; m+m1
1048
1049     DEPD,Z  m,31,32,temp3           ; (m+m1<<32)
1050     LDD     -24(%sp),ht             ; r24 = ht
1051
1052     CMPCLR,*>>= m,m1,%r0            ; if (m < m1)
1053     ADD,L   ht,high_one,ht          ; ht+=high_one
1054
1055     EXTRD,U m,31,32,temp1           ; m >> 32
1056     LDD     -32(%sp),lt             ; lt
1057     ADD,L   ht,temp1,ht             ; ht+= m>>32
1058     ADD     lt,temp3,lt             ; lt = lt+m1
1059     ADD,DC  ht,%r0,ht               ; ht++
1060
1061     ADD     ht,ht,ht                ; ht=ht+ht;
1062     ADD,DC  C3,%r0,C3               ; add in carry (c3++)
1063
1064     ADD     lt,lt,lt                ; lt=lt+lt;
1065     ADD,DC  ht,%r0,ht               ; add in carry (ht++)
1066
1067     ADD     C1,lt,C1                ; c1=c1+lt
1068     ADD,DC,*NUV ht,%r0,ht           ; add in carry (ht++)
1069     LDO     1(C3),C3              ; bump c3 if overflow,nullify otherwise
1070
1071     ADD     C2,ht,C2                ; c2 = c2 + ht
1072     ADD,DC  C3,%r0,C3             ; add in carry (c3++)
1073 .endm
1074
1075 ;
1076 ;void bn_sqr_comba8(BN_ULONG *r, BN_ULONG *a)
1077 ; arg0 = r_ptr
1078 ; arg1 = a_ptr
1079 ;
1080
1081 bn_sqr_comba8
1082         .PROC
1083         .CALLINFO FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE
1084         .EXPORT bn_sqr_comba8,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
1085     .ENTRY
1086         .align 64
1087
1088     STD     %r3,0(%sp)          ; save r3
1089     STD     %r4,8(%sp)          ; save r4
1090     STD     %r5,16(%sp)         ; save r5
1091     STD     %r6,24(%sp)         ; save r6
1092
1093         ;
1094         ; Zero out carries
1095         ;
1096         COPY     %r0,c1
1097         COPY     %r0,c2
1098         COPY     %r0,c3
1099
1100         LDO      128(%sp),%sp       ; bump stack
1101     DEPDI,Z -1,32,33,high_mask   ; Create Mask 0xffffffff80000000L
1102     DEPDI,Z  1,31,1,high_one     ; Create Value  1 << 32
1103
1104         ;
1105         ; Load up all of the values we are going to use
1106         ;
1107     FLDD     0(a_ptr),a0       
1108     FLDD     8(a_ptr),a1       
1109     FLDD    16(a_ptr),a2       
1110     FLDD    24(a_ptr),a3       
1111     FLDD    32(a_ptr),a4       
1112     FLDD    40(a_ptr),a5       
1113     FLDD    48(a_ptr),a6       
1114     FLDD    56(a_ptr),a7       
1115
1116         SQR_ADD_C a0L,a0R,c1,c2,c3
1117         STD     c1,0(r_ptr)          ; r[0] = c1;
1118         COPY    %r0,c1
1119
1120         SQR_ADD_C2 a1L,a1R,a0L,a0R,c2,c3,c1
1121         STD     c2,8(r_ptr)          ; r[1] = c2;
1122         COPY    %r0,c2
1123
1124         SQR_ADD_C a1L,a1R,c3,c1,c2
1125         SQR_ADD_C2 a2L,a2R,a0L,a0R,c3,c1,c2
1126         STD     c3,16(r_ptr)            ; r[2] = c3;
1127         COPY    %r0,c3
1128
1129         SQR_ADD_C2 a3L,a3R,a0L,a0R,c1,c2,c3
1130         SQR_ADD_C2 a2L,a2R,a1L,a1R,c1,c2,c3
1131         STD     c1,24(r_ptr)           ; r[3] = c1;
1132         COPY    %r0,c1
1133
1134         SQR_ADD_C a2L,a2R,c2,c3,c1
1135         SQR_ADD_C2 a3L,a3R,a1L,a1R,c2,c3,c1
1136         SQR_ADD_C2 a4L,a4R,a0L,a0R,c2,c3,c1
1137         STD     c2,32(r_ptr)          ; r[4] = c2;
1138         COPY    %r0,c2
1139
1140         SQR_ADD_C2 a5L,a5R,a0L,a0R,c3,c1,c2
1141         SQR_ADD_C2 a4L,a4R,a1L,a1R,c3,c1,c2
1142         SQR_ADD_C2 a3L,a3R,a2L,a2R,c3,c1,c2
1143         STD     c3,40(r_ptr)          ; r[5] = c3;
1144         COPY    %r0,c3
1145
1146         SQR_ADD_C a3L,a3R,c1,c2,c3
1147         SQR_ADD_C2 a4L,a4R,a2L,a2R,c1,c2,c3
1148         SQR_ADD_C2 a5L,a5R,a1L,a1R,c1,c2,c3
1149         SQR_ADD_C2 a6L,a6R,a0L,a0R,c1,c2,c3
1150         STD     c1,48(r_ptr)          ; r[6] = c1;
1151         COPY    %r0,c1
1152
1153         SQR_ADD_C2 a7L,a7R,a0L,a0R,c2,c3,c1
1154         SQR_ADD_C2 a6L,a6R,a1L,a1R,c2,c3,c1
1155         SQR_ADD_C2 a5L,a5R,a2L,a2R,c2,c3,c1
1156         SQR_ADD_C2 a4L,a4R,a3L,a3R,c2,c3,c1
1157         STD     c2,56(r_ptr)          ; r[7] = c2;
1158         COPY    %r0,c2
1159
1160         SQR_ADD_C a4L,a4R,c3,c1,c2
1161         SQR_ADD_C2 a5L,a5R,a3L,a3R,c3,c1,c2
1162         SQR_ADD_C2 a6L,a6R,a2L,a2R,c3,c1,c2
1163         SQR_ADD_C2 a7L,a7R,a1L,a1R,c3,c1,c2
1164         STD     c3,64(r_ptr)          ; r[8] = c3;
1165         COPY    %r0,c3
1166
1167         SQR_ADD_C2 a7L,a7R,a2L,a2R,c1,c2,c3
1168         SQR_ADD_C2 a6L,a6R,a3L,a3R,c1,c2,c3
1169         SQR_ADD_C2 a5L,a5R,a4L,a4R,c1,c2,c3
1170         STD     c1,72(r_ptr)          ; r[9] = c1;
1171         COPY    %r0,c1
1172
1173         SQR_ADD_C a5L,a5R,c2,c3,c1
1174         SQR_ADD_C2 a6L,a6R,a4L,a4R,c2,c3,c1
1175         SQR_ADD_C2 a7L,a7R,a3L,a3R,c2,c3,c1
1176         STD     c2,80(r_ptr)          ; r[10] = c2;
1177         COPY    %r0,c2
1178
1179         SQR_ADD_C2 a7L,a7R,a4L,a4R,c3,c1,c2
1180         SQR_ADD_C2 a6L,a6R,a5L,a5R,c3,c1,c2
1181         STD     c3,88(r_ptr)          ; r[11] = c3;
1182         COPY    %r0,c3
1183         
1184         SQR_ADD_C a6L,a6R,c1,c2,c3
1185         SQR_ADD_C2 a7L,a7R,a5L,a5R,c1,c2,c3
1186         STD     c1,96(r_ptr)          ; r[12] = c1;
1187         COPY    %r0,c1
1188
1189         SQR_ADD_C2 a7L,a7R,a6L,a6R,c2,c3,c1
1190         STD     c2,104(r_ptr)         ; r[13] = c2;
1191         COPY    %r0,c2
1192
1193         SQR_ADD_C a7L,a7R,c3,c1,c2
1194         STD     c3, 112(r_ptr)       ; r[14] = c3
1195         STD     c1, 120(r_ptr)       ; r[15] = c1
1196
1197     .EXIT
1198     LDD     -104(%sp),%r6        ; restore r6
1199     LDD     -112(%sp),%r5        ; restore r5
1200     LDD     -120(%sp),%r4        ; restore r4
1201     BVE     (%rp)
1202     LDD,MB  -128(%sp),%r3
1203
1204         .PROCEND        
1205
1206 ;-----------------------------------------------------------------------------
1207 ;
1208 ;void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a)
1209 ; arg0 = r_ptr
1210 ; arg1 = a_ptr
1211 ;
1212
1213 bn_sqr_comba4
1214         .proc
1215         .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE
1216         .EXPORT bn_sqr_comba4,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
1217     .entry
1218         .align 64
1219     STD     %r3,0(%sp)          ; save r3
1220     STD     %r4,8(%sp)          ; save r4
1221     STD     %r5,16(%sp)         ; save r5
1222     STD     %r6,24(%sp)         ; save r6
1223
1224         ;
1225         ; Zero out carries
1226         ;
1227         COPY     %r0,c1
1228         COPY     %r0,c2
1229         COPY     %r0,c3
1230
1231         LDO      128(%sp),%sp       ; bump stack
1232     DEPDI,Z -1,32,33,high_mask   ; Create Mask 0xffffffff80000000L
1233     DEPDI,Z  1,31,1,high_one     ; Create Value  1 << 32
1234
1235         ;
1236         ; Load up all of the values we are going to use
1237         ;
1238     FLDD     0(a_ptr),a0       
1239     FLDD     8(a_ptr),a1       
1240     FLDD    16(a_ptr),a2       
1241     FLDD    24(a_ptr),a3       
1242     FLDD    32(a_ptr),a4       
1243     FLDD    40(a_ptr),a5       
1244     FLDD    48(a_ptr),a6       
1245     FLDD    56(a_ptr),a7       
1246
1247         SQR_ADD_C a0L,a0R,c1,c2,c3
1248
1249         STD     c1,0(r_ptr)          ; r[0] = c1;
1250         COPY    %r0,c1
1251
1252         SQR_ADD_C2 a1L,a1R,a0L,a0R,c2,c3,c1
1253
1254         STD     c2,8(r_ptr)          ; r[1] = c2;
1255         COPY    %r0,c2
1256
1257         SQR_ADD_C a1L,a1R,c3,c1,c2
1258         SQR_ADD_C2 a2L,a2R,a0L,a0R,c3,c1,c2
1259
1260         STD     c3,16(r_ptr)            ; r[2] = c3;
1261         COPY    %r0,c3
1262
1263         SQR_ADD_C2 a3L,a3R,a0L,a0R,c1,c2,c3
1264         SQR_ADD_C2 a2L,a2R,a1L,a1R,c1,c2,c3
1265
1266         STD     c1,24(r_ptr)           ; r[3] = c1;
1267         COPY    %r0,c1
1268
1269         SQR_ADD_C a2L,a2R,c2,c3,c1
1270         SQR_ADD_C2 a3L,a3R,a1L,a1R,c2,c3,c1
1271
1272         STD     c2,32(r_ptr)           ; r[4] = c2;
1273         COPY    %r0,c2
1274
1275         SQR_ADD_C2 a3L,a3R,a2L,a2R,c3,c1,c2
1276         STD     c3,40(r_ptr)           ; r[5] = c3;
1277         COPY    %r0,c3
1278
1279         SQR_ADD_C a3L,a3R,c1,c2,c3
1280         STD     c1,48(r_ptr)           ; r[6] = c1;
1281         STD     c2,56(r_ptr)           ; r[7] = c2;
1282
1283     .EXIT
1284     LDD     -104(%sp),%r6        ; restore r6
1285     LDD     -112(%sp),%r5        ; restore r5
1286     LDD     -120(%sp),%r4        ; restore r4
1287     BVE     (%rp)
1288     LDD,MB  -128(%sp),%r3
1289
1290         .PROCEND        
1291
1292
1293 ;---------------------------------------------------------------------------
1294
1295 MUL_ADD_C  .macro  A0L,A0R,B0L,B0R,C1,C2,C3
1296     XMPYU   A0L,B0R,ftemp1        ; m1 = bl*ht
1297     FSTD    ftemp1,-16(%sp)       ;
1298     XMPYU   A0R,B0L,ftemp2        ; m = bh*lt
1299     FSTD    ftemp2,-8(%sp)        ;
1300     XMPYU   A0R,B0R,ftemp3        ; lt = bl*lt
1301     FSTD    ftemp3,-32(%sp)
1302     XMPYU   A0L,B0L,ftemp4        ; ht = bh*ht
1303     FSTD    ftemp4,-24(%sp)       ;
1304
1305     LDD     -8(%sp),m             ; r21 = m
1306     LDD     -16(%sp),m1           ; r19 = m1
1307     ADD,L   m,m1,m                ; m+m1
1308
1309     DEPD,Z  m,31,32,temp3         ; (m+m1<<32)
1310     LDD     -24(%sp),ht           ; r24 = ht
1311
1312     CMPCLR,*>>= m,m1,%r0          ; if (m < m1)
1313     ADD,L   ht,high_one,ht        ; ht+=high_one
1314
1315     EXTRD,U m,31,32,temp1         ; m >> 32
1316     LDD     -32(%sp),lt           ; lt
1317     ADD,L   ht,temp1,ht           ; ht+= m>>32
1318     ADD     lt,temp3,lt           ; lt = lt+m1
1319     ADD,DC  ht,%r0,ht             ; ht++
1320
1321     ADD     C1,lt,C1              ; c1=c1+lt
1322     ADD,DC  ht,%r0,ht             ; bump c3 if overflow,nullify otherwise
1323
1324     ADD     C2,ht,C2              ; c2 = c2 + ht
1325     ADD,DC  C3,%r0,C3             ; add in carry (c3++)
1326 .endm
1327
1328
1329 ;
1330 ;void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
1331 ; arg0 = r_ptr
1332 ; arg1 = a_ptr
1333 ; arg2 = b_ptr
1334 ;
1335
1336 bn_mul_comba8
1337         .proc
1338         .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE
1339         .EXPORT bn_mul_comba8,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
1340     .entry
1341         .align 64
1342
1343     STD     %r3,0(%sp)          ; save r3
1344     STD     %r4,8(%sp)          ; save r4
1345     STD     %r5,16(%sp)         ; save r5
1346     STD     %r6,24(%sp)         ; save r6
1347     FSTD    %fr12,32(%sp)       ; save r6
1348     FSTD    %fr13,40(%sp)       ; save r7
1349
1350         ;
1351         ; Zero out carries
1352         ;
1353         COPY     %r0,c1
1354         COPY     %r0,c2
1355         COPY     %r0,c3
1356
1357         LDO      128(%sp),%sp       ; bump stack
1358     DEPDI,Z  1,31,1,high_one     ; Create Value  1 << 32
1359
1360         ;
1361         ; Load up all of the values we are going to use
1362         ;
1363     FLDD      0(a_ptr),a0       
1364     FLDD      8(a_ptr),a1       
1365     FLDD     16(a_ptr),a2       
1366     FLDD     24(a_ptr),a3       
1367     FLDD     32(a_ptr),a4       
1368     FLDD     40(a_ptr),a5       
1369     FLDD     48(a_ptr),a6       
1370     FLDD     56(a_ptr),a7       
1371
1372     FLDD      0(b_ptr),b0       
1373     FLDD      8(b_ptr),b1       
1374     FLDD     16(b_ptr),b2       
1375     FLDD     24(b_ptr),b3       
1376     FLDD     32(b_ptr),b4       
1377     FLDD     40(b_ptr),b5       
1378     FLDD     48(b_ptr),b6       
1379     FLDD     56(b_ptr),b7       
1380
1381         MUL_ADD_C a0L,a0R,b0L,b0R,c1,c2,c3
1382         STD       c1,0(r_ptr)
1383         COPY      %r0,c1
1384
1385         MUL_ADD_C a0L,a0R,b1L,b1R,c2,c3,c1
1386         MUL_ADD_C a1L,a1R,b0L,b0R,c2,c3,c1
1387         STD       c2,8(r_ptr)
1388         COPY      %r0,c2
1389
1390         MUL_ADD_C a2L,a2R,b0L,b0R,c3,c1,c2
1391         MUL_ADD_C a1L,a1R,b1L,b1R,c3,c1,c2
1392         MUL_ADD_C a0L,a0R,b2L,b2R,c3,c1,c2
1393         STD       c3,16(r_ptr)
1394         COPY      %r0,c3
1395
1396         MUL_ADD_C a0L,a0R,b3L,b3R,c1,c2,c3
1397         MUL_ADD_C a1L,a1R,b2L,b2R,c1,c2,c3
1398         MUL_ADD_C a2L,a2R,b1L,b1R,c1,c2,c3
1399         MUL_ADD_C a3L,a3R,b0L,b0R,c1,c2,c3
1400         STD       c1,24(r_ptr)
1401         COPY      %r0,c1
1402
1403         MUL_ADD_C a4L,a4R,b0L,b0R,c2,c3,c1
1404         MUL_ADD_C a3L,a3R,b1L,b1R,c2,c3,c1
1405         MUL_ADD_C a2L,a2R,b2L,b2R,c2,c3,c1
1406         MUL_ADD_C a1L,a1R,b3L,b3R,c2,c3,c1
1407         MUL_ADD_C a0L,a0R,b4L,b4R,c2,c3,c1
1408         STD       c2,32(r_ptr)
1409         COPY      %r0,c2
1410
1411         MUL_ADD_C a0L,a0R,b5L,b5R,c3,c1,c2
1412         MUL_ADD_C a1L,a1R,b4L,b4R,c3,c1,c2
1413         MUL_ADD_C a2L,a2R,b3L,b3R,c3,c1,c2
1414         MUL_ADD_C a3L,a3R,b2L,b2R,c3,c1,c2
1415         MUL_ADD_C a4L,a4R,b1L,b1R,c3,c1,c2
1416         MUL_ADD_C a5L,a5R,b0L,b0R,c3,c1,c2
1417         STD       c3,40(r_ptr)
1418         COPY      %r0,c3
1419
1420         MUL_ADD_C a6L,a6R,b0L,b0R,c1,c2,c3
1421         MUL_ADD_C a5L,a5R,b1L,b1R,c1,c2,c3
1422         MUL_ADD_C a4L,a4R,b2L,b2R,c1,c2,c3
1423         MUL_ADD_C a3L,a3R,b3L,b3R,c1,c2,c3
1424         MUL_ADD_C a2L,a2R,b4L,b4R,c1,c2,c3
1425         MUL_ADD_C a1L,a1R,b5L,b5R,c1,c2,c3
1426         MUL_ADD_C a0L,a0R,b6L,b6R,c1,c2,c3
1427         STD       c1,48(r_ptr)
1428         COPY      %r0,c1
1429         
1430         MUL_ADD_C a0L,a0R,b7L,b7R,c2,c3,c1
1431         MUL_ADD_C a1L,a1R,b6L,b6R,c2,c3,c1
1432         MUL_ADD_C a2L,a2R,b5L,b5R,c2,c3,c1
1433         MUL_ADD_C a3L,a3R,b4L,b4R,c2,c3,c1
1434         MUL_ADD_C a4L,a4R,b3L,b3R,c2,c3,c1
1435         MUL_ADD_C a5L,a5R,b2L,b2R,c2,c3,c1
1436         MUL_ADD_C a6L,a6R,b1L,b1R,c2,c3,c1
1437         MUL_ADD_C a7L,a7R,b0L,b0R,c2,c3,c1
1438         STD       c2,56(r_ptr)
1439         COPY      %r0,c2
1440
1441         MUL_ADD_C a7L,a7R,b1L,b1R,c3,c1,c2
1442         MUL_ADD_C a6L,a6R,b2L,b2R,c3,c1,c2
1443         MUL_ADD_C a5L,a5R,b3L,b3R,c3,c1,c2
1444         MUL_ADD_C a4L,a4R,b4L,b4R,c3,c1,c2
1445         MUL_ADD_C a3L,a3R,b5L,b5R,c3,c1,c2
1446         MUL_ADD_C a2L,a2R,b6L,b6R,c3,c1,c2
1447         MUL_ADD_C a1L,a1R,b7L,b7R,c3,c1,c2
1448         STD       c3,64(r_ptr)
1449         COPY      %r0,c3
1450
1451         MUL_ADD_C a2L,a2R,b7L,b7R,c1,c2,c3
1452         MUL_ADD_C a3L,a3R,b6L,b6R,c1,c2,c3
1453         MUL_ADD_C a4L,a4R,b5L,b5R,c1,c2,c3
1454         MUL_ADD_C a5L,a5R,b4L,b4R,c1,c2,c3
1455         MUL_ADD_C a6L,a6R,b3L,b3R,c1,c2,c3
1456         MUL_ADD_C a7L,a7R,b2L,b2R,c1,c2,c3
1457         STD       c1,72(r_ptr)
1458         COPY      %r0,c1
1459
1460         MUL_ADD_C a7L,a7R,b3L,b3R,c2,c3,c1
1461         MUL_ADD_C a6L,a6R,b4L,b4R,c2,c3,c1
1462         MUL_ADD_C a5L,a5R,b5L,b5R,c2,c3,c1
1463         MUL_ADD_C a4L,a4R,b6L,b6R,c2,c3,c1
1464         MUL_ADD_C a3L,a3R,b7L,b7R,c2,c3,c1
1465         STD       c2,80(r_ptr)
1466         COPY      %r0,c2
1467
1468         MUL_ADD_C a4L,a4R,b7L,b7R,c3,c1,c2
1469         MUL_ADD_C a5L,a5R,b6L,b6R,c3,c1,c2
1470         MUL_ADD_C a6L,a6R,b5L,b5R,c3,c1,c2
1471         MUL_ADD_C a7L,a7R,b4L,b4R,c3,c1,c2
1472         STD       c3,88(r_ptr)
1473         COPY      %r0,c3
1474
1475         MUL_ADD_C a7L,a7R,b5L,b5R,c1,c2,c3
1476         MUL_ADD_C a6L,a6R,b6L,b6R,c1,c2,c3
1477         MUL_ADD_C a5L,a5R,b7L,b7R,c1,c2,c3
1478         STD       c1,96(r_ptr)
1479         COPY      %r0,c1
1480
1481         MUL_ADD_C a6L,a6R,b7L,b7R,c2,c3,c1
1482         MUL_ADD_C a7L,a7R,b6L,b6R,c2,c3,c1
1483         STD       c2,104(r_ptr)
1484         COPY      %r0,c2
1485
1486         MUL_ADD_C a7L,a7R,b7L,b7R,c3,c1,c2
1487         STD       c3,112(r_ptr)
1488         STD       c1,120(r_ptr)
1489
1490     .EXIT
1491     FLDD    -88(%sp),%fr13 
1492     FLDD    -96(%sp),%fr12 
1493     LDD     -104(%sp),%r6        ; restore r6
1494     LDD     -112(%sp),%r5        ; restore r5
1495     LDD     -120(%sp),%r4        ; restore r4
1496     BVE     (%rp)
1497     LDD,MB  -128(%sp),%r3
1498
1499         .PROCEND        
1500
1501 ;-----------------------------------------------------------------------------
1502 ;
1503 ;void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
1504 ; arg0 = r_ptr
1505 ; arg1 = a_ptr
1506 ; arg2 = b_ptr
1507 ;
1508
1509 bn_mul_comba4
1510         .proc
1511         .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE
1512         .EXPORT bn_mul_comba4,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN
1513     .entry
1514         .align 64
1515
1516     STD     %r3,0(%sp)          ; save r3
1517     STD     %r4,8(%sp)          ; save r4
1518     STD     %r5,16(%sp)         ; save r5
1519     STD     %r6,24(%sp)         ; save r6
1520     FSTD    %fr12,32(%sp)       ; save r6
1521     FSTD    %fr13,40(%sp)       ; save r7
1522
1523         ;
1524         ; Zero out carries
1525         ;
1526         COPY     %r0,c1
1527         COPY     %r0,c2
1528         COPY     %r0,c3
1529
1530         LDO      128(%sp),%sp       ; bump stack
1531     DEPDI,Z  1,31,1,high_one     ; Create Value  1 << 32
1532
1533         ;
1534         ; Load up all of the values we are going to use
1535         ;
1536     FLDD      0(a_ptr),a0       
1537     FLDD      8(a_ptr),a1       
1538     FLDD     16(a_ptr),a2       
1539     FLDD     24(a_ptr),a3       
1540
1541     FLDD      0(b_ptr),b0       
1542     FLDD      8(b_ptr),b1       
1543     FLDD     16(b_ptr),b2       
1544     FLDD     24(b_ptr),b3       
1545
1546         MUL_ADD_C a0L,a0R,b0L,b0R,c1,c2,c3
1547         STD       c1,0(r_ptr)
1548         COPY      %r0,c1
1549
1550         MUL_ADD_C a0L,a0R,b1L,b1R,c2,c3,c1
1551         MUL_ADD_C a1L,a1R,b0L,b0R,c2,c3,c1
1552         STD       c2,8(r_ptr)
1553         COPY      %r0,c2
1554
1555         MUL_ADD_C a2L,a2R,b0L,b0R,c3,c1,c2
1556         MUL_ADD_C a1L,a1R,b1L,b1R,c3,c1,c2
1557         MUL_ADD_C a0L,a0R,b2L,b2R,c3,c1,c2
1558         STD       c3,16(r_ptr)
1559         COPY      %r0,c3
1560
1561         MUL_ADD_C a0L,a0R,b3L,b3R,c1,c2,c3
1562         MUL_ADD_C a1L,a1R,b2L,b2R,c1,c2,c3
1563         MUL_ADD_C a2L,a2R,b1L,b1R,c1,c2,c3
1564         MUL_ADD_C a3L,a3R,b0L,b0R,c1,c2,c3
1565         STD       c1,24(r_ptr)
1566         COPY      %r0,c1
1567
1568         MUL_ADD_C a3L,a3R,b1L,b1R,c2,c3,c1
1569         MUL_ADD_C a2L,a2R,b2L,b2R,c2,c3,c1
1570         MUL_ADD_C a1L,a1R,b3L,b3R,c2,c3,c1
1571         STD       c2,32(r_ptr)
1572         COPY      %r0,c2
1573
1574         MUL_ADD_C a2L,a2R,b3L,b3R,c3,c1,c2
1575         MUL_ADD_C a3L,a3R,b2L,b2R,c3,c1,c2
1576         STD       c3,40(r_ptr)
1577         COPY      %r0,c3
1578
1579         MUL_ADD_C a3L,a3R,b3L,b3R,c1,c2,c3
1580         STD       c1,48(r_ptr)
1581         STD       c2,56(r_ptr)
1582
1583     .EXIT
1584     FLDD    -88(%sp),%fr13 
1585     FLDD    -96(%sp),%fr12 
1586     LDD     -104(%sp),%r6        ; restore r6
1587     LDD     -112(%sp),%r5        ; restore r5
1588     LDD     -120(%sp),%r4        ; restore r4
1589     BVE     (%rp)
1590     LDD,MB  -128(%sp),%r3
1591
1592         .PROCEND        
1593
1594
1595         .SPACE  $TEXT$
1596         .SUBSPA $CODE$
1597         .SPACE  $PRIVATE$,SORT=16
1598         .IMPORT $global$,DATA
1599         .SPACE  $TEXT$
1600         .SUBSPA $CODE$
1601         .SUBSPA $LIT$,ACCESS=0x2c
1602 C$4
1603         .ALIGN  8
1604         .STRINGZ        "Division would overflow (%d)\n"
1605         .END