Update of /project/movitz/cvsroot/movitz/losp/muerte In directory common-lisp.net:/tmp/cvs-serv17537

Modified Files: integers.lisp Log Message: Changed assembly stubs to use :offset assembly-macro.

Date: Sat Jul 17 14:36:34 2004 Author: ffjeld

Index: movitz/losp/muerte/integers.lisp diff -u movitz/losp/muerte/integers.lisp:1.73 movitz/losp/muerte/integers.lisp:1.74 --- movitz/losp/muerte/integers.lisp:1.73 Sat Jul 17 12:30:20 2004 +++ movitz/losp/muerte/integers.lisp Sat Jul 17 14:36:34 2004 @@ -9,7 +9,7 @@ ;;;; Created at: Wed Nov 8 18:44:57 2000 ;;;; Distribution: See the accompanying file COPYING. ;;;; -;;;; $Id: integers.lisp,v 1.73 2004/07/17 19:30:20 ffjeld Exp $ +;;;; $Id: integers.lisp,v 1.74 2004/07/17 21:36:34 ffjeld Exp $ ;;;; ;;;;------------------------------------------------------------------

@@ -65,7 +65,7 @@ (:cmpb ,(movitz:tag :bignum) :cl) (:jne 'n2-not-bignum)

- (:cmpb :ch (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::sign))) + (:cmpb :ch (:eax (:offset movitz-bignum sign))) (:jne '(:sub-program (different-signs) ;; Comparing the sign-bytes sets up EFLAGS correctly! (:ret))) @@ -74,7 +74,7 @@ ;; Both n1 and n2 are positive bignums.

(:shrl 16 :ecx) - (:cmpw :cx (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::length))) + (:cmpw :cx (:eax (:offset movitz-bignum length))) (:jne '(:sub-program (positive-different-sizes) (:ret)))

@@ -83,25 +83,21 @@ positive-compare-loop (:subl ,movitz:+movitz-fixnum-factor+ :edx) (:jz 'positive-compare-lsb) - (:movl (:ebx :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) - :ecx) - (:cmpl :ecx - (:eax :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) + (:cmpl :ecx (:eax :edx (:offset movitz-bignum bigit0))) (:je 'positive-compare-loop) positive-compare-lsb ;; Now we have to make the compare act as unsigned, which is why ;; we compare zero-extended 16-bit quantities. - (:movzxw (:ebx :edx ,(+ 2 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) - :ecx) ; First compare upper 16 bits. + (:movzxw (:ebx :edx (:offset movitz-bignum bigit0 2)) :ecx) ; First compare upper 16 bits. (:locally (:movl :ecx (:edi (:edi-offset scratch0)))) - (:movzxw (:eax :edx ,(+ 2 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) - :ecx) + (:movzxw (:eax :edx (:offset movitz-bignum bigit0 2)) :ecx) (:locally (:cmpl (:edi (:edi-offset scratch0)) :ecx)) (:jne 'upper-16-decisive) - (:movzxw (:ebx :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movzxw (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) ; Then compare lower 16 bits. (:locally (:movl :ecx (:edi (:edi-offset scratch0)))) - (:movzxw (:eax :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movzxw (:eax :edx (:offset movitz-bignum bigit0)) :ecx) ; Then compare lower 16 bits. (:locally (:cmpl (:edi (:edi-offset scratch0)) :ecx)) upper-16-decisive @@ -111,7 +107,7 @@ ;; Moth n1 and n2 are negative bignums.

(:shrl 16 :ecx) - (:cmpw (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::length)) :cx) + (:cmpw (:eax (:offset movitz-bignum length)) :cx) (:jne '(:sub-program (negative-different-sizes) (:ret)))

@@ -120,26 +116,23 @@ negative-compare-loop (:subl ,movitz:+movitz-fixnum-factor+ :edx) (:jz 'negative-compare-lsb) - (:movl (:eax :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) - :ecx) - (:cmpl :ecx - (:ebx :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl (:eax :edx (:offset movitz-bignum bigit0)) :ecx) + (:cmpl :ecx (:ebx :edx (:offset movitz-bignum bigit0))) (:je 'negative-compare-loop) (:ret) negative-compare-lsb ; it's down to the LSB bigits. ;; Now we have to make the compare act as unsigned, which is why ;; we compare zero-extended 16-bit quantities. - (:movzxw (:ebx :edx ,(+ 2 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movzxw (:ebx :edx (:offset movitz-bignum bigit0 2)) :ecx) ; First compare upper 16 bits. (:locally (:movl :ecx (:edi (:edi-offset scratch0)))) - (:movzxw (:eax :edx ,(+ 2 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) - :ecx) + (:movzxw (:eax :edx (:offset movitz-bignum bigit0)) :ecx) (:locally (:cmpl :ecx (:edi (:edi-offset scratch0)))) (:jne 'negative-upper-16-decisive) - (:movzxw (:ebx :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movzxw (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) ; Then compare lower 16 bits. (:locally (:movl :ecx (:edi (:edi-offset scratch0)))) - (:movzxw (:eax :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movzxw (:eax :edx (:offset movitz-bignum bigit0)) :ecx) ; Then compare lower 16 bits. (:locally (:cmpl :ecx (:edi (:edi-offset scratch0)))) negative-upper-16-decisive @@ -171,10 +164,8 @@ compare-loop (:subl ,movitz:+movitz-fixnum-factor+ :edx) (:jz 'done) - (:movl (:eax :edx ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) - :ecx) - (:cmpl :ecx - (:ebx :edx ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)))) + (:movl (:eax :edx (:offset movitz-bignum bigit0 -4)) :ecx) + (:cmpl :ecx (:ebx :edx (:offset movitz-bignum bigit0 -4))) (:je 'compare-loop) done (:ret)))) @@ -459,18 +450,18 @@ (:compile-two-forms (:eax :ebx) y x) (:testl :ebx :ebx) (:jz 'pfix-pbig-done) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:cmpl ,movitz:+movitz-fixnum-factor+ :ecx) (:jne 'not-size1) (:compile-form (:result-mode :ecx) x) (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) - (:addl (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) :ecx) + (:addl (:eax (:offset movitz-bignum bigit0)) :ecx) (:jc 'retry-not-size1) (:call-local-pf box-u32-ecx) (:jmp 'pfix-pbig-done) retry-not-size1 (:compile-form (:result-mode :eax) y) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) not-size1 (:declare-label-set retry-jumper (retry-not-size1)) (:locally (:movl :esp (:edi (:edi-offset atomically-esp)))) @@ -481,7 +472,7 @@ :eax) ; Number of words (:call-local-pf get-cons-pointer) (:load-lexical (:lexical-binding y) :ebx) ; bignum - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :edx) (:movl 0 (:eax :edx ,movitz:+other-type-offset+)) ; MSB @@ -494,18 +485,16 @@ (:load-lexical (:lexical-binding x) :ecx) (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) (:xorl :ebx :ebx) - (:addl :ecx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:addl :ecx (:eax (:offset movitz-bignum bigit0))) (:jnc 'add-bignum-done) add-bignum-loop (:addl 4 :ebx) - (:addl 1 (:eax :ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:addl 1 (:eax :ebx (:offset movitz-bignum bigit0))) (:jc 'add-bignum-loop) add-bignum-done - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) - :ecx) - (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) - :ecx) - (:cmpl 0 (:eax :ecx ,(+ -4 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) + (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :ecx) + (:cmpl 0 (:eax :ecx (:offset movitz-bignum bigit0 -4))) (:je 'no-expansion) (:addl #x40000 (:eax ,movitz:+other-type-offset+)) (:addl ,movitz:+movitz-fixnum-factor+ :ecx) @@ -526,17 +515,17 @@ no-expansion pfix-pbig-done)) (:compile-two-forms (:eax :ebx) y x) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:cmpl 4 :ecx) (:jne 'not-size1) (:compile-form (:result-mode :ecx) x) (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) - (:addl (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) :ecx) + (:addl (:eax (:offset movitz-bignum bigit0)) :ecx) (:call-local-pf box-u32-ecx) (:jmp 'pfix-pbig-done) retry-not-size1 (:compile-form (:result-mode :eax) y) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) not-size1 (:declare-label-set retry-jumper (retry-not-size1)) (:locally (:movl :esp (:edi (:edi-offset atomically-esp)))) @@ -547,7 +536,7 @@ :eax) ; Number of words (:call-local-pf get-cons-pointer) (:load-lexical (:lexical-binding y) :ebx) ; bignum - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :edx) copy-bignum-loop @@ -560,18 +549,18 @@ (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) (:xorl :ebx :ebx) ; counter (:negl :ecx) - (:subl :ecx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:subl :ecx (:eax (:offset movitz-bignum bigit0))) (:jnc 'add-bignum-done) add-bignum-loop (:addl 4 :ebx) - (:subl 1 (:eax :ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:subl 1 (:eax :ebx (:offset movitz-bignum bigit0))) (:jc 'add-bignum-loop) add-bignum-done - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :ecx) ; result bignum word-size - (:cmpl 0 (:eax :ecx ,(+ -8 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:cmpl 0 (:eax :ecx (:offset movitz-bignum bigit0 -8))) (:jne 'no-expansion) (:subl #x40000 (:eax ,movitz:+other-type-offset+)) (:subl ,movitz:+movitz-fixnum-factor+ :ecx) @@ -595,17 +584,17 @@ (:compile-two-forms (:eax :ebx) y x) (:testl :ebx :ebx) (:jz 'pfix-pbig-done) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:cmpl ,movitz:+movitz-fixnum-factor+ :ecx) (:jne 'not-size1) - (:movl (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) :ecx) - (:addl (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) :ecx) + (:movl (:ebx (:offset movitz-bignum bigit0)) :ecx) + (:addl (:eax (:offset movitz-bignum bigit0)) :ecx) (:jc 'retry-not-size1) (:call-local-pf box-u32-ecx) (:jmp 'pfix-pbig-done) retry-not-size1 (:compile-form (:result-mode :eax) y) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) not-size1 (:declare-label-set retry-jumper (retry-not-size1)) (:locally (:movl :esp (:edi (:edi-offset atomically-esp)))) @@ -616,7 +605,7 @@ :eax) ; Number of words (:call-local-pf get-cons-pointer) (:load-lexical (:lexical-binding y) :ebx) ; bignum - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) :ecx) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :edx) (:movl 0 (:eax :edx ,movitz:+other-type-offset+)) ; MSB @@ -630,37 +619,37 @@ (:xorl :edx :edx) ; counter (:xorl :ecx :ecx) ; Carry add-bignum-loop - (:cmpw :dx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:ebx (:offset movitz-bignum length))) (:jbe '(:sub-program (zero-padding-loop) - (:addl :ecx (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum - 'movitz::bigit0))) + (:addl :ecx (:eax :edx (:offset movitz-bignum + bigit0))) (:sbbl :ecx :ecx) (:negl :ecx) ; ECX = Add's Carry. (:addl 4 :edx) - (:cmpw :dx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:eax (:offset movitz-bignum length))) (:jae 'zero-padding-loop) (:jmp 'add-bignum-done))) - (:addl (:ebx :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) + (:addl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) (:jc '(:sub-program (term1-carry) ;; The digit + carry carried over, ECX = 0 (:addl 1 :ecx) (:addl 4 :edx) - (:cmpw :dx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:eax (:offset movitz-bignum length))) (:jae 'add-bignum-loop) (:jmp 'add-bignum-done))) - (:addl :ecx (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:addl :ecx (:eax :edx (:offset movitz-bignum bigit0))) (:sbbl :ecx :ecx) (:negl :ecx) ; ECX = Add's Carry. (:addl 4 :edx) - (:cmpw :dx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:eax (:offset movitz-bignum length))) (:jae 'add-bignum-loop) add-bignum-done - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :ecx) - (:cmpl 0 (:eax :ecx ,(+ -4 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:cmpl 0 (:eax :ecx (:offset movitz-bignum bigit0 -4))) (:je 'no-expansion) (:addl #x40000 (:eax ,movitz:+other-type-offset+)) (:addl ,movitz:+movitz-fixnum-factor+ :ecx) @@ -712,8 +701,7 @@ (:jne 'not-a-number) (:cmpl ,(dpb 4 (byte 16 16) (movitz:tag :bignum 0)) :ecx) (:jne 'not-most-negative-fixnum) - (:cmpl ,(- most-negative-fixnum) - (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:cmpl ,(- most-negative-fixnum) (:eax (:offset movitz-bignum bigit0))) (:jne 'not-most-negative-fixnum) (:movl ,(ldb (byte 32 0) (* most-negative-fixnum movitz::+movitz-fixnum-factor+)) @@ -722,7 +710,7 @@ not-most-negative-fixnum (:compile-form (:result-mode :eax) (copy-bignum x)) - (:notb (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::sign))) + (:notb (:eax (:offset movitz-bignum sign))) (:jmp 'fix-ok))) (:negl :eax) (:jo '(:sub-program (fix-overflow) @@ -762,28 +750,26 @@ (:xorl :edx :edx) ; counter (:xorl :ecx :ecx) ; carry sub-loop - (:addl (:ebx :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) + (:addl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) (:jc '(:sub-program (carry-overflow) ;; Just propagate carry (:addl 1 :ecx) (:addl 4 :edx) - (:cmpw :dx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:ebx (:offset movitz-bignum length))) (:jne 'sub-loop) (:jmp 'bignum-sub-done))) - (:subl :ecx - (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:subl :ecx (:eax :edx (:offset movitz-bignum bigit0))) (:sbbl :ecx :ecx) (:negl :ecx) (:addl 4 :edx) - (:cmpw :dx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:ebx (:offset movitz-bignum length))) (:jne 'sub-loop) - (:subl :ecx - (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:subl :ecx (:eax :edx (:offset movitz-bignum bigit0))) (:jnc 'bignum-sub-done) propagate-carry (:addl 4 :edx) - (:subl 1 (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:subl 1 (:eax :edx (:offset movitz-bignum bigit0))) (:jc 'propagate-carry) bignum-sub-done ))))) @@ -950,11 +936,11 @@ ((do-it () `(with-inline-assembly (:returns :eax) (:compile-form (:result-mode :ebx) integer) - (:movzxw (:ebx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,(* -1 movitz:+movitz-fixnum-factor+)) :eax) ; bigits-1 - (:bsrl (:ebx (:ecx 1) ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:bsrl (:ebx (:ecx 1) (:offset movitz-bignum bigit0 -4)) :ecx) (:shll 5 :eax) ; bits = bigits*32 + (bit-index+1) (:leal ((:ecx ,movitz:+movitz-fixnum-factor+) :eax @@ -998,21 +984,21 @@ (byte 16 16) (movitz:tag :bignum 0)) (:eax ,movitz:+other-type-offset+)) (:load-lexical (:lexical-binding d0) :ecx) - (:movl :ecx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:movl :ecx (:eax (:offset movitz-bignum bigit0))) (:load-lexical (:lexical-binding d1) :ecx) (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) (:shrdl ,movitz:+movitz-fixnum-shift+ :ecx - (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:eax (:offset movitz-bignum bigit0))) (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) - (:movl :ecx (:eax ,(+ 4 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:movl :ecx (:eax (:offset movitz-bignum bigit0 4))) (:jns 'fixnum-done) ;; if result was negative, we must negate bignum - (:notl (:eax ,(+ 4 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) - (:negl (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:notl (:eax (:offset movitz-bignum bigit0 4))) + (:negl (:eax (:offset movitz-bignum bigit0))) (:cmc) - (:adcl 0 (:eax ,(+ 4 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:adcl 0 (:eax (:offset movitz-bignum bigit0 4))) (:xorl #xff00 (:eax ,movitz:+other-type-offset+)) (:jmp 'fixnum-done) @@ -1053,7 +1039,7 @@ (:edi (:edi-offset atomically-status)))) (:compile-form (:result-mode :eax) y) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,(* 2 movitz:+movitz-fixnum-factor+)) :eax) @@ -1074,28 +1060,23 @@ (:negl :esi) ; can't overflow multiply-loop (:movl :edx (:ebx (:ecx 1) ; new - ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:offset movitz-bignum bigit0))) (:compile-form (:result-mode :ebx) y) - (:movl (:ebx (:ecx 1) ; old - ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) + (:movl (:ebx (:ecx 1) (:offset movitz-bignum bigit0)) :eax) (:mull :esi :eax :edx) (:compile-form (:result-mode :ebx) r) - (:addl :eax - (:ebx (:ecx 1) - ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:addl :eax (:ebx :ecx (:offset movitz-bignum bigit0))) (:adcl 0 :edx) (:addl 4 :ecx) - (:cmpw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :cx (:ebx (:offset movitz-bignum length))) (:ja 'multiply-loop) (:testl :edx :edx) (:jz 'no-carry-expansion) - (:movl :edx - (:ebx (:ecx 1) - ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:movl :edx (:ebx :ecx (:offset movitz-bignum bigit0))) (:addl 4 :ecx) - (:movw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:movw :cx (:ebx (:offset movitz-bignum length))) no-carry-expansion (:movl (:ebp -4) :esi) (:movl :ebx :eax) @@ -1167,12 +1148,12 @@ (with-inline-assembly (:returns :multiple-values) (:compile-form (:result-mode :ebx) number) (:cmpw ,movitz:+movitz-fixnum-factor+ - (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:ebx (:offset movitz-bignum length))) (:jne 'not-size1) (:compile-form (:result-mode :ecx) divisor) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) (:std) - (:movl (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) :eax) + (:movl (:ebx (:offset movitz-bignum bigit0)) :eax) (:xorl :edx :edx) (:divl :ecx :eax :edx) (:movl :eax :ecx) @@ -1185,7 +1166,7 @@ (:jmp 'done) not-size1 (:compile-form (:result-mode :ebx) number) - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:declare-label-set retry-jumper (not-size1)) @@ -1212,13 +1193,11 @@

divide-loop (:load-lexical (:lexical-binding number) :ebx) - (:movl (:ebx #.(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0) - -4 (:ecx 1)) + (:movl (:ebx :ecx (:offset movitz-bignum bigit0 -4)) :eax) (:divl :esi :eax :edx) (:load-lexical (:lexical-binding r) :ebx) - (:movl :eax (:ebx #.(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0) - -4 (:ecx 1))) + (:movl :eax (:ebx :ecx (:offset movitz-bignum bigit0 -4))) (:subl 4 :ecx) (:jnz 'divide-loop) (:movl :edi :eax) ; safe value @@ -1228,21 +1207,21 @@ (:movl :ebx :eax) (:movl :edx :ebx)

- (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) :ecx) - (:cmpl 0 (:eax :ecx ,(+ -8 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:cmpl 0 (:eax :ecx (:offset movitz-bignum bigit0 -8))) (:jne 'no-more-shrinkage) - (:subw 4 (:eax #.(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:subw 4 (:eax (:offset movitz-bignum length))) (:subl ,movitz:+movitz-fixnum-factor+ :ecx) (:cmpl ,(* 2 movitz:+movitz-fixnum-factor+) :ecx) (:jne 'no-more-shrinkage) (:cmpl ,movitz:+movitz-most-positive-fixnum+ - (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:eax (:offset movitz-bignum bigit0))) (:jnc 'no-more-shrinkage) - (:movl (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) + (:movl (:eax (:offset movitz-bignum bigit0)) :ecx) (:leal ((:ecx ,movitz:+movitz-fixnum-factor+)) :eax) (:jmp 'fixnum-result) ; don't commit the bignum @@ -1396,7 +1375,7 @@ (with-inline-assembly (:returns :boolean-cf=1) (:compile-two-forms (:ecx :ebx) index integer) (:shrl ,movitz::+movitz-fixnum-shift+ :ecx) - (:btl :ecx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))))))) + (:btl :ecx (:ebx (:offset movitz-bignum bigit0)))))))) (do-it)))

(defun logand (&rest integers) @@ -1430,14 +1409,14 @@ (%bignum-canonicalize (with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ebx) (copy-bignum x) y) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) -4) :edx) pb-pb-and-loop - (:movl (:ebx :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) + (:movl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) (:andl :ecx - (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:eax :edx (:offset movitz-bignum bigit0))) (:subl 4 :edx) (:jnc 'pb-pb-and-loop))))) ))) @@ -1468,21 +1447,19 @@ (:compile-two-forms (:eax :ecx) (copy-bignum integer2) integer1) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) (:notl :ecx) - (:andl :ecx - (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))))) + (:andl :ecx (:eax (:offset movitz-bignum bigit0)))))) ((positive-bignum positive-bignum) (%bignum-canonicalize (with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ebx) (copy-bignum integer2) integer1) - (:movzxw (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:eax (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) -4) :edx) pb-pb-andc1-loop - (:movl (:ebx :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)) + (:movl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) (:notl :ecx) - (:andl :ecx - (:eax :edx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0))) + (:andl :ecx (:eax :edx (:offset movitz-bignum bigit0))) (:subl 4 :edx) (:jnc 'pb-pb-andc1-loop))))))) (do-it))) @@ -1507,7 +1484,7 @@ (with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ecx) r x) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) - (:orl :ecx (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))))))) + (:orl :ecx (:eax (:offset movitz-bignum bigit0))))))) (do-it))) ((positive-bignum positive-fixnum) (macrolet @@ -1516,7 +1493,7 @@ (with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ecx) r y) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) - (:orl :ecx (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))))))) + (:orl :ecx (:eax (:offset movitz-bignum bigit0))))))) (do-it))) ((positive-bignum positive-bignum) (if (< (%bignum-bigits x) (%bignum-bigits y)) @@ -1526,15 +1503,15 @@ ((do-it () `(with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ebx) r y) - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1) ,(* -1 movitz:+movitz-fixnum-factor+)) :edx) ; EDX is loop counter or-loop - (:movl (:ebx :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) (:orl :ecx - (:eax :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:eax :edx (:offset movitz-bignum bigit0))) (:subl 4 :edx) (:jnc 'or-loop)))) (do-it))))))) @@ -1561,8 +1538,7 @@ `(with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ecx) (copy-bignum y) x) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) - (:xorl :ecx - (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)))))) + (:xorl :ecx (:eax (:offset movitz-bignum bigit0)))))) (do-it))) ((positive-bignum positive-fixnum) (macrolet @@ -1570,8 +1546,7 @@ `(with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ecx) (copy-bignum x) y) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) - (:xorl :ecx - (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)))))) + (:xorl :ecx (:eax (:offset movitz-bignum bigit0)))))) (do-it))) ((positive-bignum positive-bignum) (if (< (%bignum-bigits x) (%bignum-bigits y)) @@ -1582,15 +1557,14 @@ `(%bignum-canonicalize (with-inline-assembly (:returns :eax) (:compile-two-forms (:eax :ebx) r y) - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:leal ((:ecx 1),(* -1 movitz:+movitz-fixnum-factor+)) :edx) ; EDX is loop counter xor-loop - (:movl (:ebx :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movl (:ebx :edx (:offset movitz-bignum bigit0)) :ecx) - (:xorl :ecx - (:eax :edx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:xorl :ecx (:eax :edx (:offset movitz-bignum bigit0))) (:subl 4 :edx) (:jnc 'xor-loop) )))) @@ -1666,15 +1640,14 @@ ;; Have fresh bignum in EAX, now fill it with ones. (:xorl :ecx :ecx) ; counter fill-ones-loop - (:movl #xffffffff - (:eax (:ecx 1) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl #xffffffff (:eax :ecx (:offset movitz-bignum bigit0))) (:addl 4 :ecx) - (:cmpw :cx (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::length))) + (:cmpw :cx (:eax (:offset movitz-bignum length))) (:jne 'fill-ones-loop) (:popl :ecx) ; The LSB bigit. (:sarl ,movitz:+movitz-fixnum-shift+ :ecx) - (:movl :ecx (:eax ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl :ecx (:eax (:offset movitz-bignum bigit0))) (:movl :eax :ebx) ;; Compute MSB bigit mask in EDX (:compile-form (:result-mode :ecx) size) @@ -1687,10 +1660,10 @@ (:shll :cl :edx) fixnum-mask-ok (:subl 1 :edx) - (:movzxw (:ebx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) (:andl :edx ; And EDX with the MSB bigit. - (:ebx (:ecx 1) ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)))) + (:ebx :ecx (:offset movitz-bignum bigit0 -4))) (:movl :edi :edx) (:movl :edi :eax) (:cld) ; =================> CLD @@ -1723,17 +1696,17 @@ (:addl 4 :ecx) (:cmpl #x4000 :ecx) (:jae 'position-outside-integer) - (:cmpw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :cx (:ebx (:offset movitz-bignum length))) (:jc '(:sub-program (position-outside-integer) - (:movsxb (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::sign)) :ecx) + (:movsxb (:ebx (:offset movitz-bignum sign)) :ecx) (:leal ((:ecx ,movitz:+movitz-fixnum-factor+)) :eax) (:jmp 'done-u32))) (:std) - (:movl (:ebx (:ecx 1) ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl (:ebx :ecx (:offset movitz-bignum bigit0 -4)) :eax) (:movl 0 :edx) ; If position was in last bigit.. (don't touch EFLAGS) (:je 'no-top-bigit) ; ..we must zero-extend rather than read top bigit. - (:movl (:ebx (:ecx 1) ,(+ 0 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl (:ebx :ecx (:offset movitz-bignum bigit0)) :edx) ; Read top bigit into EDX no-top-bigit (:testl #xff00 (:ebx ,movitz:+other-type-offset+)) @@ -1765,7 +1738,7 @@ (byte 16 16) (movitz:tag :bignum 0)) (:ebx ,movitz:+other-type-offset+)) (:jne 'cant-return-same) - (:cmpl :ecx (:ebx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:cmpl :ecx (:ebx (:offset movitz-bignum bigit0))) (:jne 'cant-return-same) (:movl :ebx :eax) (:jmp 'done-u32) @@ -1783,9 +1756,9 @@ (:shrl 5 :ecx) ; compute fixnum bigit-number in ecx (:cmpl #x4000 :ecx) (:jnc 'position-outside-integer) - (:cmpw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :cx (:ebx (:offset movitz-bignum length))) (:jbe '(:sub-program (position-outside-integer) - (:movsxb (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::sign)) :ecx) + (:movsxb (:ebx (:offset movitz-bignum sign)) :ecx) (:leal ((:ecx ,movitz:+movitz-fixnum-factor+)) :eax) (:jmp 'done-u32))) @@ -1795,7 +1768,7 @@ (:into) ; just to make sure (:shrl 5 :ecx) ; compute msb bigit index/fixnum in ecx (:addl 4 :ecx) - (:cmpw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :cx (:ebx (:offset movitz-bignum length))) (je '(:sub-program (equal-size-maybe-return-same) (:testl :edx :edx) ; Can only return same if (zerop position). (:jnz 'adjust-size) @@ -1807,10 +1780,9 @@ ;; we know EDX=0, now generate mask in EDX (:addl 1 :edx) (:shll :cl :edx) - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) - (:cmpl :edx (:ebx (:ecx 1) - ,(+ -4 (bt:slot-offset 'movitz::movitz-bignum 'movitz::bigit0)))) + (:cmpl :edx (:ebx :ecx (:offset movitz-bignum bigit0 -4))) (:movl 0 :edx) ; Safe value, and correct if we need to go to adjust-size. (:cld) ; =================> (:jnc 'adjust-size) ; nope, we have to generate a new bignum. @@ -1827,7 +1799,7 @@ adjust-size ;; The bytespec is (partially) outside source-integer, so we make the ;; size smaller before proceeding. new-size = (- source-int-length position) - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) ; length of source-integer (:shll 5 :ecx) ; fixnum bit-position (:xorl :eax :eax) ; In case the new size is zero. @@ -1868,37 +1840,36 @@ ;; Edge case: When size(old)=size(new), the tail-tmp must be zero. ;; We check here, setting the tail-tmp to a mask for and-ing below. - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) ; length of source-integer ;; Initialize tail-tmp to #xffffffff, meaning copy from source-integer. - (:movl #xffffffff - (:ebx (:ecx 1) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) - (:cmpw :cx (:eax ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:movl #xffffffff (:ebx :ecx (:offset movitz-bignum bigit0))) + (:cmpw :cx (:eax (:offset movitz-bignum length))) (:jc '(:sub-program (result-too-big-shouldnt-happen) (:break))) (:jne 'tail-tmp-ok) ;; Sizes was equal, so set tail-tmp to zero. - (:movl 0 (:ebx (:ecx 1) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl 0 (:ebx :ecx (:offset movitz-bignum bigit0))) tail-tmp-ok ;; Now copy the relevant part of the integer (:std) (:compile-form (:result-mode :ecx) position) (:sarl ,(+ 5 movitz:+movitz-fixnum-shift+) :ecx) ; compute bigit-number in ecx ;; We can use primitive pointers because we're both inside atomically and std. - (:leal (:eax (:ecx 4) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:leal (:eax (:ecx 4) (:offset movitz-bignum bigit0)) :eax) ; Use EAX as primitive pointer into source (:xorl :ecx :ecx) ; counter copy-integer (:movl (:eax) :edx) (:addl 4 :eax) - (:movl :edx (:ebx (:ecx 1) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl :edx (:ebx :ecx (:offset movitz-bignum bigit0))) (:addl 4 :ecx) - (:cmpw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :cx (:ebx (:offset movitz-bignum length))) (:jne 'copy-integer) ;; Copy one more than the length, namely the tmp at the end. ;; Tail-tmp was initialized to a bit-mask above. (:movl (:eax) :edx) - (:andl :edx (:ebx (:ecx 1) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:andl :edx (:ebx :ecx (:offset movitz-bignum bigit0))) ;; Copy done, now shift (:compile-form (:result-mode :ecx) position) (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) @@ -1906,16 +1877,16 @@ (:jz 'shift-done) ; if (zerop (mod position 32)), no shift needed. (:xorl :edx :edx) ; counter shift-loop - (:movl (:ebx (:edx 1) ,(+ 4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:movl (:ebx :edx (:offset movitz-bignum bigit0 4)) :eax) ; Next bigit into eax (:shrdl :cl :eax ; Now shift bigit, with msbs from eax. - (:ebx (:edx 1) ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:ebx :edx (:offset movitz-bignum bigit0))) (:addl 4 :edx) - (:cmpw :dx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:cmpw :dx (:ebx (:offset movitz-bignum length))) (:jne 'shift-loop) shift-done ;; Now we must mask MSB bigit. - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :edx) (:popl :ecx) ; (new) bytespec size (:shrl ,movitz:+movitz-fixnum-shift+ :ecx) @@ -1924,18 +1895,16 @@ (:movl 1 :eax) ; Generate mask in EAX (:shll :cl :eax) (:subl 1 :eax) - (:andl :eax - (:ebx (:edx 1) ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)))) + (:andl :eax (:ebx :edx (:offset movitz-bignum bigit0 -4))) mask-done ;; (:movl :edi :edx) ; safe EDX (:movl :edi :eax) ; safe EAX (:cld) ;; Now we must zero-truncate the result bignum in EBX. - (:movzxw (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length)) + (:movzxw (:ebx (:offset movitz-bignum length)) :ecx) zero-truncate-loop - (:cmpl 0 (:ebx (:ecx 1) - ,(+ -4 (bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)))) + (:cmpl 0 (:ebx :ecx (:offset movitz-bignum bigit0 -4))) (:jne 'zero-truncate-done) (:subl 4 :ecx) (:jnz 'zero-truncate-loop) @@ -1946,16 +1915,16 @@ (:cmpl 4 :ecx) ; If result size is 1, the result might have.. (:jne 'complete-bignum-allocation) ; ..collapsed to a fixnum. (:cmpl ,movitz:+movitz-most-positive-fixnum+ - (:ebx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0))) + (:ebx (:offset movitz-bignum bigit0))) (:ja 'complete-bignum-allocation) - (:movl (:ebx ,(bt:slot-offset 'movitz:movitz-bignum 'movitz::bigit0)) + (:movl (:ebx (:offset movitz-bignum bigit0)) :ecx) (:leal ((:ecx ,movitz:+movitz-fixnum-factor+)) :eax) (:jmp 'return-fixnum) complete-bignum-allocation - (:movw :cx (:ebx ,(bt:slot-offset 'movitz::movitz-bignum 'movitz::length))) + (:movw :cx (:ebx (:offset movitz-bignum length))) (:movl :ebx :eax) - (:leal ((:ecx 1) ,movitz:+movitz-fixnum-factor+) + (:leal (:ecx ,movitz:+movitz-fixnum-factor+) :ecx) (:call-local-pf cons-commit) return-fixnum