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