source: branches/arm/level-0/ARM/arm-bignum.lisp @ 13903

Last change on this file since 13903 was 13903, checked in by gb, 10 years ago

arm-asm.lisp: had cs and cc condition names backwards. (not used very
often, I guess.) umull and umulls had the wrong opcode.

arm-bignum.lisp: %ADD-WITH-CARRY needs to use adcs to propagate carry out.
Define %SUBTRACT-WITH-BORROW, fix %NORMALIZE-BIGNUM-2.

arm-float: implement, fix some things.

arm-numbers: steal %FIXNUM-GCD from Wikipedia.

l0-array.lisp: *IMMHEADER-ARRAY-TYPES*, *NODEHEADER-ARRAY-TYPES* for ARM.

arm-trap-support.lisp: started.

ffi-linuxarm.lisp: more plausible callback support.

ARM stuff for MACHINE-TYPE, HEAP-UTILIZATION.

arm-exceptions.c: callback glue functions return Boolean.

arm-exceptions.h: typos in opcode test macros.

arm-spentry.s: .SPeabi_callback.

File size: 33.0 KB
Line 
1;;-*- Mode: Lisp; Package: CCL -*-
2;;;
3;;;   Copyright (C) 2010 Clozure Associates
4
5;;;   This file is part of Clozure CL. 
6;;;
7;;;   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public
8;;;   License , known as the LLGPL and distributed with Clozure CL as the
9;;;   file "LICENSE".  The LLGPL consists of a preamble and the LGPL,
10;;;   which is distributed with Clozure CL as the file "LGPL".  Where these
11;;;   conflict, the preamble takes precedence. 
12;;;
13;;;   Clozure CL is referenced in the preamble as the "LIBRARY."
14;;;
15;;;   The LLGPL is also available online at
16;;;   http://opensource.franz.com/preamble.html
17
18
19(in-package "CCL")
20
21(eval-when (:compile-toplevel :execute)
22  (require "ARM-ARCH")
23  (require "ARM-LAPMACROS"))
24
25;;; %BIGNUM-REF needs to access bignums as obviously as possible, and it needs
26;;; to be able to return 32 bits somewhere no one looks for real objects.
27;;;
28;;; The easiest thing to do is to store the 32 raw bits in two fixnums
29;;; and return multiple values.
30(defarmlapfunction %bignum-ref ((bignum arg_y) (i arg_z))
31  (vref32 imm0 bignum i imm1)
32  (digit-h temp0 imm0)
33  (digit-l temp1 imm0)
34  (vpush1 temp0)
35  (vpush1 temp1)
36  (add temp0 vsp (:$ 8))                 
37  (set-nargs 2)                         
38  (ba .SPvalues))
39
40
41;;; Set the 0th element of DEST (a bignum or some other 32-bit ivector)
42;;; to the Ith element of the bignum SRC.
43(defarmlapfunction %ref-digit ((bignum arg_x) (i arg_y) (dest arg_z))
44  (add imm1 i (:$ arm::misc-data-offset))
45  (ldr imm0 (:@ bignum imm1))
46  (str imm0 (:@ dest (:$ arm::misc-data-offset)))
47  (bx lr))
48
49;;; BIGNUM[I] := DIGIT[0]
50(defarmlapfunction %set-digit ((bignum arg_x) (i arg_y) (digit arg_z))
51  (add imm1 i (:$ arm::misc-data-offset))
52  (ldr imm0 (:@ digit (:$ arm::misc-data-offset)))
53  (str imm0 (:@ bignum imm1))
54  (bx lr))
55
56
57
58
59
60;;; Return the sign of bignum (0 or -1) as a fixnum
61(defarmlapfunction %bignum-sign ((bignum arg_z))
62  (vector-length imm0 bignum imm0)
63  (add imm0 imm0 (:$ (- arm::misc-data-offset 4))) ; Reference last (most significant) digit
64  (ldr imm0 (:@ bignum imm0))
65  (mov imm0 (:asr imm0 (:$ 31)))        ;propagate sign bit
66  (box-fixnum arg_z imm0)
67  (bx lr))
68
69;;; Count the sign bits in the most significant digit of bignum;
70;;; return fixnum count.
71(defarmlapfunction %bignum-sign-bits ((bignum arg_z))
72  (vector-length imm0 bignum imm0)
73  (add imm0 imm0 (:$ (- arm::misc-data-offset 4))) ; Reference last (most significant) digit
74  (ldr imm0 (:@ bignum imm0))
75  (cmp imm0 (:$ 0))
76  (mvnlt imm0 imm0)
77  (clz imm0 imm0)
78  (box-fixnum arg_z imm0)
79  (bx lr))
80
81(defarmlapfunction %digit-0-or-plusp ((bignum arg_y) (idx arg_z))
82  (add imm0 idx (:$ arm::misc-data-offset))
83  (ldr imm0 (:@ bignum imm0))
84  (mov arg_z 'nil)
85  (cmp imm0 (:$ 0))
86  (addge arg_z arg_z (:$ arm::t-offset))
87  (bx lr))
88
89;;; For oddp, evenp
90(defarmlapfunction %bignum-oddp ((bignum arg_z))
91  (ldr imm0 (:@ bignum (:$ arm::misc-data-offset)))
92  (mov arg_z 'nil)
93  (tst imm0 (:$ 1))
94  (addne arg_z arg_z (:$ arm::t-offset))
95  (bx lr))
96 
97(defarmlapfunction bignum-plusp ((bignum arg_z))
98  (vector-length imm0 bignum imm0)
99  (add imm0 imm0 (:$ (- arm::misc-data-offset 4))) ; Reference last (most significant) digit
100  (ldr imm0 (:@ bignum imm0))
101  (mov arg_z 'nil)
102  (cmp imm0 (:$ 0))
103  (addge arg_z arg_z (:$ arm::t-offset))
104  (bx lr))
105
106(defarmlapfunction %fixnum-to-bignum-set ((bignum arg_y) (fixnum arg_z))
107  (unbox-fixnum imm0 fixnum)
108  (str imm0 (:@ bignum  (:$ arm::misc-data-offset)))
109  (bx lr))
110
111(defarmlapfunction bignum-minusp ((bignum arg_z))
112  (vector-length imm0 bignum imm0)
113  (add imm0 imm0 (:$ (- arm::misc-data-offset 4))) ; Reference last (most significant) digit
114  (ldr imm0 (:@ bignum imm0))
115  (mov arg_z 'nil)
116  (cmp imm0 (:$ 0))
117  (addlt arg_z arg_z (:$ arm::t-offset))
118  (bx lr))
119
120
121;;; Add the digits A[I] and B[J], and the incoming carry C (a fixnum).
122;;; Store the result in R[K], and return the outgoing carry.
123;;; If I is NIL, A is a fixnum.  If J is NIL, B is a fixnum.
124
125(defarmlapfunction %add-with-carry ((r 12) (k 8) (c 4) (a 0) (i arg_x) (b arg_y) (j arg_z))
126  (cmp i 'nil)
127  (ldr temp0 (:@ vsp (:$ a)))
128  (moveq imm1 (:asr temp0 (:$ arm::fixnumshift)))
129  (addne imm1 i (:$ arm::misc-data-offset))
130  (ldrne imm1 (:@ temp0 imm1))
131  (cmp j 'nil)
132  (moveq imm2 (:asr b (:$ arm::fixnumshift)))
133  (addne imm2 j (:$ arm::misc-data-offset))
134  (ldrne imm2 (:@ b imm2))
135  (ldr temp0 (:@ vsp (:$ c)))
136  (unbox-fixnum imm0 temp0)
137  (subs imm0 imm0 (:$ 1))
138  (ldr temp1 (:@ vsp (:$ r)))
139  (ldr temp0 (:@ vsp (:$ k)))
140  (add vsp vsp (:$ 16)) 
141  (adcs imm0 imm1 imm2)
142  (add imm2 temp0 (:$ arm::misc-data-offset))
143  (str imm0 (:@ temp1 imm2))
144  (mov imm0 (:$ 0))
145  (adc imm0 imm0 (:$ 0))
146  (box-fixnum arg_z imm0)
147  (bx lr))
148
149; this is silly
150(defarmlapfunction %add-the-carry ((b-h arg_x) (b-l arg_y) (carry-in arg_z))
151  (let ((a imm0)
152        (b imm1)
153        (c imm2))   
154    (compose-digit b b-h b-l)
155    (unbox-fixnum c carry-in)
156    (add b c b)
157    (digit-h temp0 b)
158    (digit-l temp1 b)
159    (vpush1 temp0)
160    (vpush1 temp1)
161    (add temp0 vsp '2)
162    (set-nargs 2)
163    (ba .SPvalues)))
164
165
166
167
168   
169;;; Store the result of A[I] - B[J] - borrow into R[K], returning the borrow.
170;;; If I is NIL, A is a fixnum; likewise for J and B.
171(defarmlapfunction %subtract-with-borrow ((r 12) (k 8) (borrow 4) (a 0) (i arg_x) (b arg_y) (j arg_z))
172  (cmp i 'nil)
173  (ldr temp0 (:@ vsp (:$ a)))
174  (moveq imm1 (:asr temp0 (:$ arm::fixnumshift)))
175  (addne imm1 i (:$ arm::misc-data-offset))
176  (ldrne imm1 (:@ temp0 imm1))
177  (cmp j 'nil)
178  (moveq imm2 (:asr b (:$ arm::fixnumshift)))
179  (addne imm2 j (:$ arm::misc-data-offset))
180  (ldrne imm2 (:@ b imm2))
181  (ldr temp0 (:@ vsp (:$ borrow)))
182  (unbox-fixnum imm0 temp0)
183  (subs imm0 imm0 (:$ -1))
184  (ldr temp0 (:@ vsp (:$ r)))
185  (ldr temp1 (:@ vsp (:$ k)))
186  (add vsp vsp (:$ 16)) 
187  (sbcs imm0 imm2 imm1)
188  (add imm1 temp1 (:$ arm::misc-data-offset))
189  (str imm0 (:@ temp0 imm1))
190  (adc imm0 imm0 (:$ 0))
191  (box-fixnum arg_z imm0)
192  (bx lr))
193
194;; multiply i'th digit of x by y and add to result starting at digit i
195
196(defarmlapfunction %multiply-and-add-harder-loop-2
197    ((x-ptr 4) (y-ptr 0) (resptr arg_x)(residx arg_y) (count arg_z)) 
198  (let ((x imm0)
199        (y imm1)
200        (prod-h imm2)
201        (prod-l rcontext)
202        (xptr temp2)
203        (yidx temp1)
204        (yptr temp0))
205    (ldr xptr (:@ vsp (:$ x-ptr)))
206    (mov residx (:lsl residx (:$ 2)))
207    (add residx residx (:$ (ash arm::misc-data-offset 2)))
208    (ldr x (:@ xptr (:asr residx (:$ 2))))
209    (ldr yptr (:@ vsp (:$ y-ptr)))
210    (vpush1 rcontext)
211    (mov yidx (:$ (ash arm::misc-data-offset 2))) ; init yidx 0
212    (movs prod-h (:$ 0)) ; init carry 0, mumble 0
213    @loop
214    (ldr y (:@ yptr (:asr yidx (:$ 2))))
215    (mul prod-l x y)
216    (adds prod-l prod-l prod-h)
217    (umull x prod-h x y)
218    (adc prod-h prod-h (:$ 0))
219    (ldr y (:@ resptr (:asr residx (:$ 2))))
220    (adds prod-l prod-l y)
221    (adc prod-h prod-h (:$ 0))
222    (subs count count '1)
223    (str prod-l (:@ resptr (:asr residx (:$ 2))))   
224    (add residx residx '4)              ;sic
225    (add yidx yidx '4)                  ;even sicer
226    (bgt @loop)
227    (str prod-h (:@ resptr (:asr residx (:$ 2))))
228    (vpop1 rcontext)
229    (add vsp vsp (:$ 8))     
230    (bx lr)))
231
232
233
234;;; Multiply X[I] by the unboxed value of the (non-negative) fixnum Y;
235;;; add the incoming carry from CARRY[0] to the 64-bit product.  Store
236;;; the low word of the 64-bit sum in R[0] and the high word in
237;;; CARRY[0].
238
239(defarmlapfunction %multiply-and-add ((r 4) (carry 0) (x arg_y) (i arg_x) (y arg_z))
240  (unbox-fixnum imm0 arg_z)
241  (add imm1 i (:$ arm::misc-data-offset))
242  (ldr imm1 (:@ x imm1))
243  (umull imm1 imm2 imm0 imm1)
244  (ldr temp0 (:@ vsp (:$ carry)))
245  (ldr imm0 (:@ temp0 (:$ arm::misc-data-offset)))
246  (adds imm1 imm1 imm0)
247  (adc imm2 imm2 (:$ 0))
248  (str imm2 (:@ temp0  (:$ arm::misc-data-offset)))
249  (ldr arg_z (:@ vsp (:$ r)))
250  (add vsp vsp (:$ 8))   
251  (str imm1 (:@ arg_z  (:$ arm::misc-data-offset)))
252  (bx lr))
253 
254
255
256(defarmlapfunction %bignum-ref-hi ((bignum arg_y) (i arg_z))
257  (add imm1 i (:$ (+ 2 arm::misc-data-offset)))
258  (ldrh imm0 (:@ bignum imm1))
259  (box-fixnum arg_z imm0)
260  (bx lr))
261
262
263(defarmlapfunction %bignum-set ((bignum 0) (i arg_x) (high arg_y) (low arg_z))
264  (compose-digit imm0 high low)
265  (ldr arg_z (:@ vsp (:$ bignum)))
266  (vset32 imm0 arg_z i imm1)
267  (add vsp vsp (:$ 4))
268  (bx lr))
269
270
271
272
273; this is silly
274#+notyet
275(defarmlapfunction %add-the-carry ((b-h arg_x) (b-l arg_y) (carry-in arg_z))
276  (let ((a imm0)
277        (b imm1)
278        (temp imm2)
279        (c imm3))   
280    (compose-digit b b-h b-l)
281    (unbox-fixnum c carry-in)
282    (add b c b)
283    (digit-h temp0 b)
284    (digit-l temp1 b)
285    (vpush temp0)
286    (vpush temp1)
287    (add temp0 vsp (:$ 8))
288    (set-nargs 2)
289    (ba .SPvalues)))
290
291
292
293
294;;; %SUBTRACT-WITH-BORROW -- Internal.
295;;;
296;;; This should be in assembler, and should not cons intermediate results.  It
297;;; returns a 32bit digit and a borrow resulting from subtracting b from a, and
298;;; subtracting a possible incoming borrow.
299;;;
300;;; We really do:  a - b - 1 + borrow, where borrow is either 0 or 1.
301;;;
302
303#+notyet
304(defarmlapfunction %subtract-with-borrow-1 ((a-h 4) (a-l 0) (b-h arg_x) (b-l
305arg_y) (borrow-in arg_z))
306  (let ((a imm0)
307        (b imm1)
308        (temp imm2)
309        (c imm3))
310    (ldr temp0 vsp (:$ a-h))
311    (ldr temp1 vsp (:$ a-l))
312    (compose-digit a temp0 temp1)
313    (compose-digit b b-h b-l)
314    (unbox-fixnum c borrow-in)
315    (li temp -1)
316    (addc temp c temp)
317    (subfe a b a)
318    (addze c rzero)
319    (box-fixnum c c)
320    (digit-h temp0 a)
321    (digit-l temp1 a)
322    (vpush temp0)
323    (vpush temp1)
324    (vpush c)
325    (add temp0 vsp (:$ 20))
326    (set-nargs 3)
327    (ba .SPvalues)))
328
329
330#+notyet
331(defarmlapfunction %subtract-one ((a-h arg_y)(a-l arg_z))
332  (let ((a imm0))
333    (compose-digit a a-h a-l)
334    (subi a a 1)
335    (digit-h temp0 a)
336    (vpush temp0)
337    (digit-l temp0 a)
338    (vpush temp0)
339    (add temp0 vsp (:$ 8))
340    (set-nargs 2)
341    (ba .spvalues)))
342
343
344
345
346;;; %MULTIPLY-AND-ADD  --  Internal.
347;;;
348;;; This multiplies x-digit and y-digit, producing high and low digits
349;;; manifesting the result.  Then it adds the low digit, res-digit, and
350;;; carry-in-digit.  Any carries (note, you still have to add two digits at a
351;;; time possibly producing two carries) from adding these three digits get
352;;; added to the high digit from the multiply, producing the next carry digit.
353;;; Res-digit is optional since two uses of this primitive multiplies a single
354;;; digit bignum by a multiple digit bignum, and in this situation there is no
355;;; need for a result buffer accumulating partial results which is where the
356;;; res-digit comes from.
357;;; [slh] I assume that the returned carry "digit" can only be 0, 1 or 2
358
359
360#+notyet
361(defarmlapfunction %multiply-and-add-1 ((x-high 8)
362                                        (x-low 4)
363                                        (y-high 0)
364                                        (y-low arg_x)
365                                        (carry-in-high arg_y)
366                                        (carry-in-low arg_z))
367  (let ((x imm0)
368        (y imm1)
369        (carry-in imm2)
370        (lo imm3)
371        (hi imm4))
372    (compose-digit carry-in carry-in-high carry-in-low)
373    (vpop temp0)
374    (compose-digit y temp0 y-low)
375    (vpop temp0)
376    (vpop temp1)
377    (compose-digit x temp1 temp0)
378    (mullw lo x y)
379    (mulhwu hi x y)
380    (addc lo lo carry-in)
381    (addze hi hi)
382    (digit-h temp0 hi)
383    (digit-l temp1 hi)
384    (digit-h temp2 lo)
385    (digit-l temp3 lo)
386    (vpush temp0)
387    (vpush temp1)
388    (vpush temp2)
389    (vpush temp3)
390    (set-nargs 4)
391    (add temp0 vsp (:$ 16))
392    (ba .SPvalues)))
393
394
395(defarmlapfunction %logcount-complement ((bignum arg_y) (idx arg_z))
396  (let ((arg imm0)
397        (shift imm1)
398        (temp imm2))
399    (add arg idx (:$ arm::misc-data-offset))
400    (ldr arg (:@ bignum arg))
401    (mvns shift arg)
402    (mov arg_z '0)
403    (bxeq lr)
404    @loop
405    (add temp shift (:$ -1))
406    (ands shift shift temp)
407    (add arg_z arg_z (:$ '1))
408    (bne @loop)
409    (bx lr)))
410
411(defarmlapfunction %logcount ((bignum arg_y) (idx arg_z))
412  (let ((arg imm0)
413        (shift imm1)
414        (temp imm2))
415    (add arg idx (:$ arm::misc-data-offset))
416    (ldr arg (:@ bignum arg))
417    (movs shift arg)
418    (mov arg_z '0)
419    (bxeq lr)
420    @loop
421    (add temp shift (:$ -1))
422    (ands shift shift temp)
423    (add arg_z arg_z '1)
424    (bne @loop)
425    (bx lr)))
426
427; return res
428#+notyet
429(defarmlapfunction bignum-add-loop-2 ((aptr arg_x)(bptr arg_y) (result arg_z))
430  (let ((idx imm0)
431        (count imm1)
432        (x imm2)
433        (y imm3)       
434        (len-a temp0)
435        (len-b temp1)
436        (tem temp2))
437    (li idx arm::misc-data-offset)   
438    (ldr imm4 aptr (:$ arm::misc-header-offset))
439    (header-length len-a imm4)
440    (ldr imm4 bptr (:$ arm::misc-header-offset))
441    (header-length len-b imm4)
442    ; make a be shorter one
443    (cmpw len-a len-b)
444    (li count 0)
445    ; initialize carry 0
446    (addc x rzero rzero)
447    (ble @loop)
448    ; b shorter - swap em
449    (mr tem len-a)
450    (mr len-a len-b)
451    (mr len-b tem)
452    (mr tem aptr)
453    (mr aptr bptr)
454    (mr bptr tem)   
455    @loop
456    (ldr y (:@ aptr idx))
457    (ldr x (:@ bptr idx))   
458    (addi count count '1)
459    (cmpw count len-a)
460    (adde x x y)
461    (str x (:@ result idx))
462    (addi idx idx '1)
463    (blt @loop)
464    ; now propagate carry thru longer (b) using sign of shorter   
465    ;(SUBI imm4 idx '1) ; y has hi order word of a
466    ;(ldr y (:@ aptr imm4))
467    (cmpw len-a len-b)
468    (adde imm4 rzero rzero) ; get carry
469    (srawi y y 31)  ; p.o.s clobbers carry
470    (addic imm4 imm4 -1)  ; restore carry
471    (beq @l3)  ; unless equal
472    @loop2
473    (ldr x (:@ bptr idx))
474    (adde x x y)
475    (str x (:@ result idx))
476    (addi count count '1)
477    (cmpw count len-b)
478    (addi idx idx '1)
479    (blt @loop2)
480    ; y has sign of shorter - get sign of longer to x
481    @l3
482    (subi imm4 idx '1)
483    (ldr x (:@ bptr imm4))
484    (adde imm4 rzero rzero) ; get carry
485    (srawi x x 31)  ; clobbers carry
486    (addic imm4 imm4 -1)
487    (adde x x y)
488    (str x (:@ result idx))
489    (bx lr)))
490
491;; same as above but with initial a index and finishes
492#+notyet
493(defarmlapfunction bignum-add-loop-+ ((init-a 0)(aptr arg_x)(bptr arg_y)(length arg_z))
494  (let ((idx imm0)       
495        (count imm1)
496        (x imm2)
497        (y imm3)
498        (aidx imm4))
499    (li idx arm::misc-data-offset)
500    (ldr aidx vsp (:$ init-a))
501    (addi aidx aidx arm::misc-data-offset)
502    (li count 0)
503    ; initialize carry 0
504    (addc x rzero rzero)
505    @loop
506    (ldr x (:@ aptr aidx))
507    (ldr y (:@ bptr idx))
508    (adde x x y)
509    (str x (:@ aptr aidx))
510    (addi count count '1)
511    (cmpw count length)
512    (addi idx idx '1)
513    (addi aidx aidx '1)
514    (blt @loop)
515    (ldr x (:@ aptr aidx))  ; add carry into next one
516    (adde x x  rzero)
517    (str x (:@ aptr aidx))
518    (add vsp vsp (:$ 4))
519    (bx lr)))
520
521
522#+notyet
523(defarmlapfunction bignum-negate-loop-really ((big arg_x) (len arg_y) (result arg_z))
524  (let ((idx imm0)
525        (one imm1)
526        (x imm2))
527    (li idx arm::misc-data-offset)
528    (li one '1)
529    ; initialize carry 1
530    (li x -1)
531    (addic x x 1)
532    @loop       
533    ;(addi count count '1)   
534    ;(cmpw count len)
535    (subf. len one len)
536    (ldr x (:@ big idx))
537    (not x x)
538    (adde x x rzero)
539    (str x (:@ result idx))   
540    (addi idx idx '1)
541    (bgt @loop)
542    ; return carry
543    (li x 0)
544    (adde x x  rzero)
545    (box-fixnum arg_z x)
546    (bx lr)))
547
548#+notyet
549(defarmlapfunction bignum-negate-to-pointer ((big arg_x) (len arg_y) (result arg_z))
550  (let ((idx imm0)
551        (one imm1)
552        (x imm2)
553        (oidx imm3)
554        (ptr imm4))
555    (li idx arm::misc-data-offset)
556    (li oidx 0)
557    (macptr-ptr ptr result)
558    (li one '1)
559    ; initialize carry 1
560    (li x -1)
561    (addic x x 1)
562    @loop       
563    ;(addi count count '1)   
564    ;(cmpw count len)
565    (subf. len one len)
566    (ldr x (:@ big idx))
567    (not x x)
568    (adde x x rzero)
569    (str x (:@ ptr oidx))   
570    (addi idx idx '1)
571    (addi oidx oidx 4)
572    (bgt @loop)
573    ; return carry
574    (li x 0)
575    (adde x x  rzero)
576    (box-fixnum arg_z x)
577    (bx lr)))
578
579;; she do tolerate len = jidx
580#+notyet
581(defarmlapfunction bignum-shift-left-loop ((nbits 4)(result 0) (bignum arg_x) (len arg_y) (jidx arg_z))
582  (let ((y imm0)
583        (idx imm1)
584        (bits imm2)
585        (rbits imm3)
586        (x imm4)
587        (iidx temp0)
588        (resptr temp1))
589    (li iidx 0)
590    (ldr bits vsp (:$ nbits))
591    (ldr resptr vsp (:$ result))
592    (unbox-fixnum bits bits)
593    (subfic rbits bits 32)   
594    ;(dbg)
595    (ldr imm4 bignum (:$ arm::misc-data-offset))
596    (slw imm4 imm4 bits)
597    (add y jidx (:$ (+ arm::misc-data-offset -4))) 
598    (str imm4 (:@ y resptr)) 
599     
600    (cmpw len jidx)
601    (beq @done)
602    @loop
603    (addi idx iidx arm::misc-data-offset)
604    (ldr x (:@ bignum idx))
605    (srw x x rbits)
606    (addi idx idx '1)
607    (ldr y (:@ bignum idx))
608    (slw y y bits)
609    (or x x y)
610    (addi idx jidx arm::misc-data-offset)
611    (str x (:@ resptr idx))
612    (addi jidx jidx '1)   
613    (cmpw jidx len)
614    (addi iidx iidx '1)
615    (blt @loop)   
616    @done
617    ; do first - lo order
618       
619    ; do last - hi order   
620    (addi idx iidx arm::misc-data-offset)
621    ;(dbg t)
622    (ldr y (:@ bignum idx))
623    (sraw y y rbits)
624    (addi idx len arm::misc-data-offset)
625    (str y (:@ resptr idx))
626    (add vsp vsp (:$ 8))
627    (bx lr)))
628
629
630#+notyet
631(defarmlapfunction bignum-shift-right-loop-1 ((nbits 4)(result 0) (bignum arg_x) (len arg_y) (iidx arg_z))
632  (let ((y imm0)
633        (idx imm1)
634        (bits imm2)
635        (rbits imm3)
636        (x imm4)
637        (jidx temp0)
638        (resptr temp1))
639    (li jidx 0)
640    (ldr bits vsp (:$ nbits))
641    (ldr resptr vsp (:$ result))
642    (unbox-fixnum bits bits)
643    (cmpw jidx len)
644    (subfic rbits bits 32)   
645    (bge @done)
646    @loop
647    (addi idx iidx arm::misc-data-offset)
648    (ldr x (:@ bignum idx))
649    (srw x x bits)
650    (addi idx idx '1)
651    (ldr y (:@ bignum idx))
652    (slw y y rbits)
653    (or x x y)
654    (addi idx jidx arm::misc-data-offset)
655    (str x (:@ resptr idx))
656    (addi jidx jidx '1)   
657    (cmpw jidx len)
658    (addi iidx iidx '1)
659    (blt @loop)
660    @done
661    (addi idx iidx arm::misc-data-offset)
662    (ldr x (:@ bignum idx))
663    (sraw x x bits)
664    (addi idx jidx arm::misc-data-offset)
665    (str x (:@ resptr idx))
666    (add vsp vsp (:$ 8))
667    (bx lr)))
668
669
670(defarmlapfunction %compare-digits ((a arg_x) (b arg_y) (idx arg_z))
671  (add imm0 idx (:$ arm::misc-data-offset))
672  (ldr imm1 (:@ a imm0))
673  (ldr imm0 (:@ b imm0))
674  (cmp imm1 imm0)
675  (moveq arg_z '0)
676  (movhi arg_z '1)
677  (movlo arg_z '-1)
678  (bx lr))
679
680
681 
682;; returns number of bits in digit-hi,digit-lo that are sign bits
683;; 32 - digits-sign-bits is integer-length
684
685(defarmlapfunction %digits-sign-bits ((hi arg_y) (lo arg_z))
686  (compose-digit imm1 hi lo)
687  (cmp imm1 (:$ 0))
688  (mvnlt imm1 imm1)
689  (clz imm1 imm1)
690  (box-fixnum arg_z imm1)
691  (bx lr))
692
693(defarmlapfunction bignum-logtest-loop ((count arg_x) (b1 arg_y) (b2 arg_z)) 
694  (mov imm1 (:$ arm::misc-data-offset))
695  @loop
696  (ldr imm2 (:@ b1 imm1))
697  (ldr imm0 (:@ b2 imm1))
698  (ands imm2 imm0 imm2) 
699  (add imm1 imm1 (:$ 4))
700  (bne @true)
701  (subs count count (:$ 4))
702  (bgt  @loop)
703  (mov arg_z (:$ arm::nil-value))
704  (bx lr)
705  @true
706  (mov arg_z (:$ arm::nil-value))
707  (add arg_z arg_z (:$ arm::t-offset))
708  (bx lr))
709
710;;; dest[idx] <- (lognot src[idx])
711(defarmlapfunction %bignum-lognot ((idx arg_x) (src arg_y) (dest arg_z))
712  (add imm1 idx (:$ arm::misc-data-offset))
713  (ldr imm0 (:@ src imm1))
714  (mvn imm0 imm0)
715  (str imm0 (:@ dest imm1))
716  (bx lr))
717
718;;; dest[idx] <- (logand x[idx] y[idx])
719(defarmlapfunction %bignum-logand ((idx 0) (x arg_x) (y arg_y) (dest arg_z))
720  (vpop1 temp0)
721  (add imm1 temp0 (:$ arm::misc-data-offset))
722  (ldr imm0 (:@ x imm1))
723  (ldr imm2 (:@ y imm1))
724  (and imm0 imm0 imm2)
725  (str imm0 (:@ dest imm1))
726  (bx lr))
727
728;;; dest[idx] <- (logandc2 x[idx] y[idx])
729(defarmlapfunction %bignum-logandc2 ((idx 0) (x arg_x) (y arg_y) (dest arg_z))
730  (vpop1 temp0)
731  (add imm1 temp0 (:$ arm::misc-data-offset))
732  (ldr imm0 (:@ x imm1))
733  (ldr imm2 (:@ y imm1))
734  (bic imm0 imm0 imm2)
735  (str imm0 (:@ dest imm1))
736  (bx lr))
737
738;;; dest[idx] <- (logandc1 x[idx] y[idx])
739(defarmlapfunction %bignum-logandc1 ((idx 0) (x arg_x) (y arg_y) (dest arg_z))
740  (vpop1 temp0)
741  (add imm1 temp0 (:$ arm::misc-data-offset))
742  (ldr imm0 (:@ x imm1))
743  (ldr imm2 (:@ y imm1))
744  (bic imm0 imm2 imm0)
745  (str imm0 (:@ dest imm1))
746  (bx lr))
747
748
749
750(defarmlapfunction digit-lognot-move ((index arg_x) (source arg_y) (dest arg_z))
751  (let ((scaled-index imm1))
752    (vref32 imm0 source index scaled-index) ; imm1 has c(index) + data-offset
753    (mvn imm0 imm0)
754    (str imm0 (:@ dest scaled-index))
755    (bx lr)))
756
757(defarmlapfunction macptr->fixnum ((ptr arg_z))
758  (macptr-ptr arg_z ptr)
759  (bx lr))
760
761; if dest not nil store unboxed result in dest(0), else return boxed result
762(defarmlapfunction fix-digit-logandc2 ((fix arg_x) (big arg_y) (dest arg_z)) ; index 0
763  (let ((w1 imm0)
764        (w2 imm1))
765    (unbox-fixnum  w1 fix)
766    (ldr w2 (:@ big (:$ arm::misc-data-offset)))
767    (cmp dest 'nil)
768    (bic w1 w1 w2)
769    (bne @store)
770    (box-fixnum arg_z w1)
771    (bx lr)
772    @store
773    (str w1 (:@ dest  (:$ arm::misc-data-offset)))
774    (bx lr)))
775
776
777
778(defarmlapfunction fix-digit-logand ((fix arg_x) (big arg_y) (dest arg_z)) ; index 0
779  (let ((w1 imm0)
780        (w2 imm1))
781    (unbox-fixnum  w1 fix)
782    (ldr w2 (:@ big (:$ arm::misc-data-offset)))
783    (cmp dest 'nil)
784    (and w1 w1 w2)
785    (bne @store)
786    (box-fixnum arg_z w1)
787    (bx lr)
788    @store
789    (str w1 (:@ dest  (:$ arm::misc-data-offset)))
790    (bx lr)))
791
792
793
794(defarmlapfunction fix-digit-logandc1 ((fix arg_x) (big arg_y) (dest arg_z)) ; index 0
795  (let ((w1 imm0)
796        (w2 imm1))
797    (unbox-fixnum  w1 fix)
798    (ldr w2 (:@ big (:$ arm::misc-data-offset)))
799    (cmp dest 'nil)
800    (bic w1 w2 w1)
801    (bne @store)
802    (box-fixnum arg_z w1)
803    (bx lr)
804    @store
805    (str w1 (:@ dest  (:$ arm::misc-data-offset)))
806    (bx lr)))
807
808;;; dest[idx] <- (logior x[idx] y[idx])
809(defarmlapfunction %bignum-logior ((idx 0) (x arg_x) (y arg_y) (dest arg_z))
810  (vpop1 temp0)
811  (add imm1 temp0 (:$ arm::misc-data-offset))
812  (ldr imm0 (:@ x imm1))
813  (ldr imm2 (:@ y imm1))
814  (orr imm0 imm0 imm2)
815  (str imm0 (:@ dest imm1))
816  (bx lr))
817
818;;; dest[idx] <- (logxor x[idx] y[idx])
819(defarmlapfunction %bignum-logxor ((idx 0) (x arg_x) (y arg_y) (dest arg_z))
820  (vpop1 temp0)
821  (add imm1 temp0 (:$ arm::misc-data-offset))
822  (ldr imm0 (:@ x imm1))
823  (ldr imm2 (:@ y imm1))
824  (eor imm0 imm0 imm2)
825  (str imm0 (:@ dest imm1))
826  (bx lr))
827
828
829
830(defarmlapfunction bignum-xor-loop ((count 0) (b1 arg_x) (b2 arg_y) (dest arg_z))
831  (ldr temp0 (:@ vsp (:$ count)))
832  (mov imm1 (:$ arm::misc-data-offset))
833  @loop
834  (ldr imm2 (:@ b1 imm1))
835  (ldr imm0 (:@ b2 imm1))
836  (eor imm2 imm0 imm2)
837  (subs temp0 temp0 (:$ 4))
838  (str imm2 (:@ dest imm1))
839  (add imm1 imm1 (:$ 4))
840  (bgt @loop)
841  @out
842  (add vsp vsp (:$ 4))
843  (bx lr))
844
845#+nomore
846(defarmlapfunction try-guess-loop-1 ((guess-h 8)(guess-l 4)(len-y 0)
847                                     (xidx arg_x) (xptr arg_y) (yptr arg_z))
848  (let ((guess imm0)
849        (carry imm1)
850        (y imm2)
851        (x imm2)
852        (prod-l imm3)
853        (prod-h imm4)
854        (tem imm4)
855        (yidx temp0)
856        (end-y temp1)
857        (carry-bit temp2))
858    (ldr x vsp (:$ guess-h))
859    (ldr tem vsp (:$ guess-l))
860    (compose-digit guess x tem)
861    (ldr end-y vsp (:$ len-y))
862    (li yidx 0)
863    (li carry 0) 
864    (li carry-bit '1)
865    @loop
866    ; multiply guess by ydigit, add carry to lo, hi is new carry
867    ; then get an xdigit subtract prod-lo from it and store result in x (remember carry)
868    (addi tem yidx arm::misc-data-offset)   ; get yidx
869    (ldr y (:@ yptr tem))
870    (mullw prod-l guess y)
871    (mulhwu prod-h guess y)   
872    (addc prod-l prod-l carry) 
873    (adde carry prod-h rzero)
874    ; get back saved carry
875    (li tem '-1)
876    (addc tem carry-bit tem)
877    (addi tem xidx arm::misc-data-offset)
878    (ldr x (:@ xptr tem))   
879    (subfe x prod-l x)       
880    (str x (:@ xptr tem))
881    ; save carry
882    (adde prod-l rzero rzero)
883    (box-fixnum carry-bit prod-l)
884    (addi yidx yidx '1)
885    (cmpw yidx end-y)
886    (addi xidx xidx '1)
887    (blt @loop)
888    ; finally subtract carry from last x digit
889    @done
890    (li prod-l '-1)  ; get back saved carry again - box clobbered it?
891    (addc prod-l carry-bit prod-l)
892    (addi tem xidx arm::misc-data-offset) ; maybe still there - nope
893    (ldr x (:@ xptr tem))
894    (subfe x carry x)
895    (str x (:@ xptr tem))
896    (add vsp vsp (:$ 12))
897    (bx lr)))
898
899;; x0 is at index, x1 at index-1, x2 at index-2
900;; y1 is at index, y2 at index-1
901;; this doesnt help much
902#+notyet
903(defarmlapfunction truncate-guess-loop ((guess-h 8)(guess-l 4)(x 0)
904                                        (xidx arg_x)(yptr arg_y) (yidx arg_z))
905  (let ((guess imm0)
906        (y1 imm1)
907        (y2 imm1)
908        (gy1-lo imm2) ; look out below
909        (gy1-hi imm2)
910        (gy2-lo imm2)
911        (gy2-hi imm2)
912        (xptr temp0)
913        (m imm3)
914        (tem imm4)
915        (y1-idx 28)
916        (y2-idx 24)
917        (x0-idx 20)
918        (x1-idx 16)
919        (x2-idx 12))
920    (stru -32  (:$ tsp)) tsp
921    (str tsp tsp  (:$ 4))
922    (ldr y1 vsp (:$ guess-h))
923    (ldr tem vsp (:$ guess-l))
924    (compose-digit guess y1 tem)
925    (addi tem yidx arm::misc-data-offset)
926    (ldr y1 (:@ yptr tem))
927    (str y1 tsp  (:$ y1-idx))
928    (subi tem tem 4)
929    (ldr y2 (:@ yptr tem))
930    (str y2 tsp  (:$ y2-idx))
931    (ldr xptr vsp (:$ x))
932    (addi tem xidx arm::misc-data-offset)
933    (ldr y1 (:@ xptr tem)) ; its x0
934    (str y1 tsp  (:$ x0-idx))
935    (subi tem tem 4)
936    (ldr y1 (:@ xptr tem))
937    (str y1 tsp  (:$ x1-idx))
938    (subi tem tem 4)
939    (ldr y1 (:@ xptr tem))
940    (str y1 tsp  (:$ x2-idx))
941    @loop
942    (ldr y1 tsp (:$ y1-idx))     ; get y1
943    (mullw gy1-lo guess y1)
944    (ldr m tsp (:$ x1-idx))      ; get x1
945    (subc m m gy1-lo)      ; x1 - gy1-lo => m
946    (mulhwu gy1-hi guess y1)
947    (ldr tem tsp (:$ x0-idx))    ; get x0
948    (subfe. tem gy1-hi tem)      ; - val not used just cr
949    (ldr y2 tsp (:$ y2-idx))     ; get y2
950    (mulhwu gy2-hi guess y2)   ; does it pay to do this now even tho may not need?
951    (bne @done)
952    (cmpl :cr0 gy2-hi m)       ; if > or = and foo then more - L means logical means unsigned
953    (blt @done)           ; if < done
954    (bne @more)           ; if = test lo
955    (mullw gy2-lo guess y2)
956    (ldr tem tsp (:$ x2-idx)) ; get x2
957    (cmpl :cr0 gy2-lo tem)
958    (ble @done)
959    @more
960    (subi guess guess 1)
961    (b @loop)
962    @done
963    (digit-h temp0 guess)
964    (vpush temp0)
965    (digit-l temp0 guess)
966    (vpush temp0)
967    (add temp0 vsp (:$ 20))
968    (ldr tsp tsp (:$ 0))
969    (set-nargs 2)
970    (ba .spvalues)))
971
972(defarmlapfunction normalize-bignum-loop ((sign arg_x)(res arg_y)(len arg_z))
973  (let ((idx imm0)
974        (usign imm1)
975        (val imm2))     
976    (unbox-fixnum usign sign)
977    (cmp len '0)
978    (add idx len (:$ (- arm::misc-data-offset 4))  )
979    (bxeq lr) ; huh - can this ever happen?
980    @loop
981    (ldr val (:@ res idx))
982    (cmp  val usign)   
983    (sub idx idx '1)
984    (bne @neq)   
985    (subs len len '1)
986    (bgt @loop)
987    ; fall through - its all sign - return 1
988    (mov arg_z '1)
989    (bx lr)
990    @neq
991    (and usign usign (:$ #x80000000))
992    (and val val (:$ #x80000000))
993    (cmp usign val)  ; is hi bit = sign, if so then done   
994    (addne len len '1) ; if not, need 1 more
995    (bx lr)))
996
997(defarmlapfunction %normalize-bignum-2 ((fixp arg_y)(res arg_z))
998  (let ((idx imm0)
999        (usign imm1)
1000        (val imm2)
1001        (len arg_x)
1002        (oldlen temp0))
1003    (vector-length len res imm0)
1004    (cmp len (:$ 0))
1005    (mov oldlen len)
1006    (add idx len (:$ (- arm::misc-data-offset 4))  )
1007    (bxeq lr) ; huh - can this ever happen?
1008    (ldr val (:@ res idx)) ; high order word
1009    (mov usign (:asr val (:$ 31))) ; get sign
1010    @loop
1011    (ldr val (:@ res idx))
1012    (cmp  val usign)   
1013    (sub idx idx '1)
1014    (bne @neq)   
1015    (subs len len '1)
1016    (bgt @loop)
1017    ; fall through - its all sign - return 1
1018    (mov len '1)
1019    (and usign usign (:$ #x80000000))
1020    (b @more)
1021    @neq
1022    (and usign usign (:$ #x80000000))
1023    (and val val (:$ #x80000000))
1024    (cmp usign val)  ; is hi bit = sign, if so then done   
1025    (beq @more)
1026    (add len len '1) ; if not, need 1 more
1027    (b @big)
1028    @more
1029    (cmp  fixp 'nil)
1030    (beq @big)                          ; dont return fixnum
1031    (cmp len '1)
1032    (bgt @big)
1033    ;; stuff for maybe fixnum
1034    ;(dbg t)
1035    (ldr val (:@ res (:$ arm::misc-data-offset)))
1036    (box-fixnum temp1 val)
1037    (cmp val (:asr temp1 (:$ arm::fixnumshift)))
1038    (moveq arg_z temp1)
1039    (bxeq lr)
1040    @big
1041    (cmp oldlen len)
1042    (bxeq lr) ; same length - done
1043    (mov imm2 (:$ arm::subtag-bignum))
1044    (cmp usign (:$ 0))
1045    (orr imm2 imm2 (:lsl len (:$ (- arm::num-subtag-bits arm::fixnumshift))))
1046    ;; 0 to tail if negative
1047    (beq @set-header) 
1048    ;; zero from len inclusive to oldlen exclusive
1049    (mov imm1 (:$ 0))
1050    (add idx len (:$ arm::misc-data-offset))
1051    @loop2
1052    (str imm1 (:@ idx res))
1053    (add len len '1)
1054    (cmp len oldlen)
1055    (add idx idx '1)
1056    (blt @loop2)
1057    @set-header
1058    (str imm2 (:@ res (:$ arm::misc-header-offset)))
1059    (bx lr)))
1060
1061(defarmlapfunction %count-digit-leading-zeros ((high arg_y) (low arg_z))
1062  (compose-digit imm0 high low)
1063  (clz imm0 imm0)
1064  (box-fixnum arg_z imm0)
1065  (bx lr))
1066
1067(defarmlapfunction %count-digit-trailing-zeros ((high arg_y) (low arg_z))
1068  (compose-digit imm0 high low)
1069  (rsb  imm1 imm0 (:$ 0))
1070  (and imm0 imm0 imm1)
1071  (clz imm0 imm0)
1072  (rsb imm0 imm0 (:$ 31))
1073  (box-fixnum arg_z imm0)
1074  (bx lr))
1075
1076
1077(defarmlapfunction %bignum-count-trailing-zero-bits ((bignum arg_z))
1078  (let ((ndigits arg_x)
1079        (nbits arg_y)
1080        (digit imm0)
1081        (ptr imm1))
1082    (mov ptr (:$ arm::misc-data-offset))
1083    (mov ndigits '-32)
1084    @next
1085    (ldr digit (:@ bignum ptr))
1086    (cmp digit (:$ 0))
1087    (add ptr ptr (:$ 4))
1088    (add ndigits ndigits '32)
1089    (beq @next)
1090    (rsb ptr digit (:$ 0))
1091    (and digit digit ptr)
1092    (clz digit digit)
1093    (rsb digit digit (:$ 31))
1094    (box-fixnum nbits digit)
1095    (add arg_z nbits ndigits)
1096    (bx lr)))
1097
1098
1099(defarmlapfunction %bignum-trim-leading-zeros ((bignum arg_x)
1100                                               (start arg_y)
1101                                               (len arg_z))
1102  (add imm1 start len)
1103  (add imm1 imm1 (:$ (- arm::misc-data-offset 4)))
1104  @loop
1105  (ldr imm0 (:@ bignum imm1))
1106  (cmp imm0 (:$ 0))
1107  (add imm1 imm1 (:$ -4))
1108  (bxne lr)
1109  (subs len len '-1)
1110  (bne @loop)
1111  (bx lr))
1112 
1113;;; Set length of bignum to new-len (zeroing out any trailing words between
1114;;; the old length and the new.
1115(defarmlapfunction %shrink-bignum ((new-len arg_y) (bignum arg_z))
1116  (let ((old-len temp0)
1117        (rzero temp1)
1118        (old-idx imm0)
1119        (new-idx imm2)
1120        (header imm1))
1121    (getvheader header bignum)
1122    (header-length old-len header)
1123    (mov rzero (:$ 0))
1124    (cmp old-len new-len)
1125    (add old-idx old-len (:$ arm::misc-data-offset))
1126    (add new-idx new-len (:$ arm::misc-data-offset))
1127    (bxeq lr)
1128    @loop
1129    (sub old-idx old-idx (:$ 4))
1130    (cmp old-idx new-idx)
1131    (str rzero (:@ bignum old-idx))
1132    (bne @loop)
1133    (mov header (:lsl new-len (:$ (- arm::num-subtag-bits arm::fixnumshift))))
1134    (orr header header (:$ arm::subtag-bignum))
1135    (str header (:@ bignum  (:$ arm::misc-header-offset)))
1136    (bx lr)))
1137
1138;;; Divide bignum x by single digit y (passed as two halves).
1139;;; The quotient in stored in q, and the remainder is returned
1140;;; in two halves.  (cf. Knuth, 4.3.1, exercise 16)
1141(defarmlapfunction %floor-loop-quo ((x 0) (res arg_x) (yhi arg_y) (ylo arg_z))
1142  (let ((bignum temp0)
1143        (len temp2))                    ;not nfn here.
1144    (ldr bignum (:@ vsp (:$ x)))
1145    (add imm1 vsp (:$ arm::node-size))
1146    (build-lisp-frame imm0 imm1)
1147    (vector-length len bignum imm0)
1148    (mov imm2 (:$ 0))
1149    (b @next)
1150    @loop
1151    (add imm0 len (:$ arm::misc-data-offset))
1152    (ldr imm0 (:@ bignum imm0))
1153    (mov imm1 imm2)
1154    (compose-digit imm2 yhi ylo)
1155    (bl .SPudiv64by32)
1156    (add imm1 len (:$ arm::misc-data-offset))
1157    (str imm0 (:@ res imm1))
1158    @next
1159    (subs len len '1)
1160    (bge @loop)
1161    (digit-h yhi imm2)
1162    (digit-l ylo imm2)
1163    (vpush1 yhi)
1164    (vpush1 ylo)
1165    (set-nargs 2)
1166    (ba .SPnvalret)))
1167   
1168   
1169(defarmlapfunction bignum-negate-loop-really ((big arg_x) (len arg_y) (result arg_z))
1170  (let ((idx imm0)
1171        (x imm1)
1172        (carry imm2))
1173    (mov idx (:$ arm::misc-data-offset))
1174    ;; initialize carry 1
1175    (mov carry (:$ 1))
1176    @loop       
1177    (ldr x (:@ big idx))
1178    (mvn x x)
1179    (adds x x carry)
1180    (str x (:@ result idx))
1181    (movcc carry (:$ 0))
1182    (movcs carry (:$ 1))
1183    (subs len len '1)
1184    (add idx idx '1)
1185    (bgt @loop)
1186    ; return carry
1187    (box-fixnum arg_z carry)
1188    (bx lr)))
1189
1190(defarmlapfunction bignum-shift-left-loop ((nbits 4)(result 0) (bignum arg_x) (len arg_y) (j arg_z))
1191  (let ((y imm0)
1192        (x imm1)
1193        (shift imm2)       
1194        (i temp0)
1195        (resptr temp2))
1196    (vpop1 resptr)
1197    (mov i (:$ (ash arm::misc-data-offset 2)))
1198    (vpop1 shift)
1199    (ldr x (:@ bignum (:$ arm::misc-data-offset)))
1200    (unbox-fixnum shift shift)
1201    (mov x (:lsl x shift))
1202    (add y j (:$ (+ arm::misc-data-offset -4)))
1203    (str x (:@ resptr y))
1204    (cmp len j)
1205    (beq @done)
1206    @loop
1207    (ldr x (:@ bignum (:asr i (:$ 2))))
1208    (rsb shift shift (:$ 32))
1209    (mov x (:asr x shift))
1210    (add i i '4)                    ;sic
1211    (ldr y (:@ bignum (:asr i (:$ 2))))
1212    (rsb shift shift (:$ 32))
1213    (orr y x (:lsl y shift))
1214    (add x j (:$ arm::misc-data-offset))
1215    (str y (:@ resptr x))
1216    (add j j '1)   
1217    (cmp j len)
1218    (add i i '4)
1219    (blt @loop)   
1220    @done
1221    ; do first - lo order
1222       
1223    ; do last - hi order   
1224    ;(dbg t)
1225    (ldr y (:@ bignum (:asr i (:$ 2))))
1226    (mov y (:asr y shift))
1227    (add x len (:$ arm::misc-data-offset))
1228    (str y (:@ resptr x))   
1229    (bx lr)))
1230
1231; End of arm-bignum.lisp
Note: See TracBrowser for help on using the repository browser.