X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fx86-64%2Farith.lisp;h=d0436d5d99b948b32fc01269d19f0ee562346d6e;hb=5cf3c4259d529e180d75d4d140f344e600d2b06b;hp=be2b9e6ab425bdf92142d7d1f84f7652ed418cb8;hpb=5cc68148d1a5f9bacf4eb12e396b680d992fc2c2;p=sbcl.git diff --git a/src/compiler/x86-64/arith.lisp b/src/compiler/x86-64/arith.lisp index be2b9e6..d0436d5 100644 --- a/src/compiler/x86-64/arith.lisp +++ b/src/compiler/x86-64/arith.lisp @@ -1,4 +1,4 @@ -;;;; the VM definition of arithmetic VOPs for the x86 +;;;; the VM definition of arithmetic VOPs for the x86-64 ;;;; This software is part of the SBCL system. See the README file for ;;;; more information. @@ -28,7 +28,7 @@ (define-vop (signed-unop fast-safe-arith-op) (:args (x :scs (signed-reg) :target res)) (:results (res :scs (signed-reg))) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:arg-types signed-num) (:result-types signed-num)) @@ -46,13 +46,13 @@ (define-vop (fast-lognot/fixnum fixnum-unop) (:translate lognot) - (:generator 2 + (:generator 1 (move res x) (inst xor res (fixnumize -1)))) (define-vop (fast-lognot/signed signed-unop) (:translate lognot) - (:generator 1 + (:generator 2 (move res x) (inst not res))) @@ -62,58 +62,58 @@ (define-vop (fast-fixnum-binop fast-safe-arith-op) (:args (x :target r :scs (any-reg) - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg) - (sc-is r control-stack) - (location= x r)))) - (y :scs (any-reg control-stack))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg) + (sc-is r control-stack) + (location= x r)))) + (y :scs (any-reg control-stack))) (:arg-types tagged-num tagged-num) (:results (r :scs (any-reg) :from (:argument 0) - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg) - (sc-is r control-stack) - (location= x r))))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg) + (sc-is r control-stack) + (location= x r))))) (:result-types tagged-num) (:note "inline fixnum arithmetic")) (define-vop (fast-unsigned-binop fast-safe-arith-op) (:args (x :target r :scs (unsigned-reg) - :load-if (not (and (sc-is x unsigned-stack) - (sc-is y unsigned-reg) - (sc-is r unsigned-stack) - (location= x r)))) - (y :scs (unsigned-reg unsigned-stack))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is y unsigned-reg) + (sc-is r unsigned-stack) + (location= x r)))) + (y :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num) (:results (r :scs (unsigned-reg) :from (:argument 0) - :load-if (not (and (sc-is x unsigned-stack) - (sc-is y unsigned-reg) - (sc-is r unsigned-stack) - (location= x r))))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is y unsigned-reg) + (sc-is r unsigned-stack) + (location= x r))))) (:result-types unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic")) + (:note "inline (unsigned-byte 64) arithmetic")) (define-vop (fast-signed-binop fast-safe-arith-op) (:args (x :target r :scs (signed-reg) - :load-if (not (and (sc-is x signed-stack) - (sc-is y signed-reg) - (sc-is r signed-stack) - (location= x r)))) - (y :scs (signed-reg signed-stack))) + :load-if (not (and (sc-is x signed-stack) + (sc-is y signed-reg) + (sc-is r signed-stack) + (location= x r)))) + (y :scs (signed-reg signed-stack))) (:arg-types signed-num signed-num) (:results (r :scs (signed-reg) :from (:argument 0) - :load-if (not (and (sc-is x signed-stack) - (sc-is y signed-reg) - (sc-is r signed-stack) - (location= x r))))) + :load-if (not (and (sc-is x signed-stack) + (sc-is y signed-reg) + (sc-is r signed-stack) + (location= x r))))) (:result-types signed-num) - (:note "inline (signed-byte 32) arithmetic")) + (:note "inline (signed-byte 64) arithmetic")) (define-vop (fast-fixnum-binop-c fast-safe-arith-op) (:args (x :target r :scs (any-reg control-stack))) (:info y) (:arg-types tagged-num (:constant (signed-byte 29))) (:results (r :scs (any-reg) - :load-if (not (location= x r)))) + :load-if (not (location= x r)))) (:result-types tagged-num) (:note "inline fixnum arithmetic")) @@ -124,61 +124,61 @@ (:info y) (:arg-types unsigned-num (:constant (unsigned-byte 31))) (:results (r :scs (unsigned-reg) - :load-if (not (location= x r)))) + :load-if (not (location= x r)))) (:result-types unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic")) + (:note "inline (unsigned-byte 64) arithmetic")) (define-vop (fast-signed-binop-c fast-safe-arith-op) (:args (x :target r :scs (signed-reg signed-stack))) (:info y) (:arg-types signed-num (:constant (signed-byte 32))) (:results (r :scs (signed-reg) - :load-if (not (location= x r)))) + :load-if (not (location= x r)))) (:result-types signed-num) - (:note "inline (signed-byte 32) arithmetic")) + (:note "inline (signed-byte 64) arithmetic")) (macrolet ((define-binop (translate untagged-penalty op) - `(progn - (define-vop (,(symbolicate "FAST-" translate "/FIXNUM=>FIXNUM") - fast-fixnum-binop) - (:translate ,translate) - (:generator 2 - (move r x) - (inst ,op r y))) - (define-vop (,(symbolicate 'fast- translate '-c/fixnum=>fixnum) - fast-fixnum-binop-c) - (:translate ,translate) - (:generator 1 - (move r x) - (inst ,op r (fixnumize y)))) - (define-vop (,(symbolicate "FAST-" translate "/SIGNED=>SIGNED") - fast-signed-binop) - (:translate ,translate) - (:generator ,(1+ untagged-penalty) - (move r x) - (inst ,op r y))) - (define-vop (,(symbolicate 'fast- translate '-c/signed=>signed) - fast-signed-binop-c) - (:translate ,translate) - (:generator ,untagged-penalty - (move r x) - (inst ,op r y))) - (define-vop (,(symbolicate "FAST-" - translate - "/UNSIGNED=>UNSIGNED") - fast-unsigned-binop) - (:translate ,translate) - (:generator ,(1+ untagged-penalty) - (move r x) - (inst ,op r y))) - (define-vop (,(symbolicate 'fast- - translate - '-c/unsigned=>unsigned) - fast-unsigned-binop-c) - (:translate ,translate) - (:generator ,untagged-penalty - (move r x) - (inst ,op r y)))))) + `(progn + (define-vop (,(symbolicate "FAST-" translate "/FIXNUM=>FIXNUM") + fast-fixnum-binop) + (:translate ,translate) + (:generator 2 + (move r x) + (inst ,op r y))) + (define-vop (,(symbolicate 'fast- translate '-c/fixnum=>fixnum) + fast-fixnum-binop-c) + (:translate ,translate) + (:generator 1 + (move r x) + (inst ,op r (fixnumize y)))) + (define-vop (,(symbolicate "FAST-" translate "/SIGNED=>SIGNED") + fast-signed-binop) + (:translate ,translate) + (:generator ,(1+ untagged-penalty) + (move r x) + (inst ,op r y))) + (define-vop (,(symbolicate 'fast- translate '-c/signed=>signed) + fast-signed-binop-c) + (:translate ,translate) + (:generator ,untagged-penalty + (move r x) + (inst ,op r y))) + (define-vop (,(symbolicate "FAST-" + translate + "/UNSIGNED=>UNSIGNED") + fast-unsigned-binop) + (:translate ,translate) + (:generator ,(1+ untagged-penalty) + (move r x) + (inst ,op r y))) + (define-vop (,(symbolicate 'fast- + translate + '-c/unsigned=>unsigned) + fast-unsigned-binop-c) + (:translate ,translate) + (:generator ,untagged-penalty + (move r x) + (inst ,op r y)))))) ;;(define-binop + 4 add) (define-binop - 4 sub) @@ -191,26 +191,26 @@ (define-vop (fast-+/fixnum=>fixnum fast-safe-arith-op) (:translate +) (:args (x :scs (any-reg) :target r - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg) - (sc-is r control-stack) - (location= x r)))) - (y :scs (any-reg control-stack))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg) + (sc-is r control-stack) + (location= x r)))) + (y :scs (any-reg control-stack))) (:arg-types tagged-num tagged-num) (:results (r :scs (any-reg) :from (:argument 0) - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg) - (sc-is r control-stack) - (location= x r))))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg) + (sc-is r control-stack) + (location= x r))))) (:result-types tagged-num) (:note "inline fixnum arithmetic") (:generator 2 (cond ((and (sc-is x any-reg) (sc-is y any-reg) (sc-is r any-reg) - (not (location= x r))) - (inst lea r (make-ea :qword :base x :index y :scale 1))) - (t - (move r x) - (inst add r y))))) + (not (location= x r))) + (inst lea r (make-ea :qword :base x :index y :scale 1))) + (t + (move r x) + (inst add r y))))) (define-vop (fast-+-c/fixnum=>fixnum fast-safe-arith-op) (:translate +) @@ -218,65 +218,65 @@ (:info y) (:arg-types tagged-num (:constant (signed-byte 29))) (:results (r :scs (any-reg) - :load-if (not (location= x r)))) + :load-if (not (location= x r)))) (:result-types tagged-num) (:note "inline fixnum arithmetic") (:generator 1 (cond ((and (sc-is x any-reg) (sc-is r any-reg) (not (location= x r))) - (inst lea r (make-ea :qword :base x :disp (fixnumize y)))) - (t - (move r x) - (inst add r (fixnumize y)))))) + (inst lea r (make-ea :qword :base x :disp (fixnumize y)))) + (t + (move r x) + (inst add r (fixnumize y)))))) (define-vop (fast-+/signed=>signed fast-safe-arith-op) (:translate +) (:args (x :scs (signed-reg) :target r - :load-if (not (and (sc-is x signed-stack) - (sc-is y signed-reg) - (sc-is r signed-stack) - (location= x r)))) - (y :scs (signed-reg signed-stack))) + :load-if (not (and (sc-is x signed-stack) + (sc-is y signed-reg) + (sc-is r signed-stack) + (location= x r)))) + (y :scs (signed-reg signed-stack))) (:arg-types signed-num signed-num) (:results (r :scs (signed-reg) :from (:argument 0) - :load-if (not (and (sc-is x signed-stack) - (sc-is y signed-reg) - (location= x r))))) + :load-if (not (and (sc-is x signed-stack) + (sc-is y signed-reg) + (location= x r))))) (:result-types signed-num) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:generator 5 (cond ((and (sc-is x signed-reg) (sc-is y signed-reg) (sc-is r signed-reg) - (not (location= x r))) - (inst lea r (make-ea :qword :base x :index y :scale 1))) - (t - (move r x) - (inst add r y))))) + (not (location= x r))) + (inst lea r (make-ea :qword :base x :index y :scale 1))) + (t + (move r x) + (inst add r y))))) ;;;; Special logand cases: (logand signed unsigned) => unsigned (define-vop (fast-logand/signed-unsigned=>unsigned - fast-logand/unsigned=>unsigned) + fast-logand/unsigned=>unsigned) (:args (x :target r :scs (signed-reg) - :load-if (not (and (sc-is x signed-stack) - (sc-is y unsigned-reg) - (sc-is r unsigned-stack) - (location= x r)))) - (y :scs (unsigned-reg unsigned-stack))) + :load-if (not (and (sc-is x signed-stack) + (sc-is y unsigned-reg) + (sc-is r unsigned-stack) + (location= x r)))) + (y :scs (unsigned-reg unsigned-stack))) (:arg-types signed-num unsigned-num)) (define-vop (fast-logand-c/signed-unsigned=>unsigned - fast-logand-c/unsigned=>unsigned) + fast-logand-c/unsigned=>unsigned) (:args (x :target r :scs (signed-reg signed-stack))) (:arg-types signed-num (:constant (unsigned-byte 31)))) (define-vop (fast-logand/unsigned-signed=>unsigned - fast-logand/unsigned=>unsigned) + fast-logand/unsigned=>unsigned) (:args (x :target r :scs (unsigned-reg) - :load-if (not (and (sc-is x unsigned-stack) - (sc-is y signed-reg) - (sc-is r unsigned-stack) - (location= x r)))) - (y :scs (signed-reg signed-stack))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is y signed-reg) + (sc-is r unsigned-stack) + (location= x r)))) + (y :scs (signed-reg signed-stack))) (:arg-types unsigned-num signed-num)) @@ -286,42 +286,42 @@ (:info y) (:arg-types signed-num (:constant (signed-byte 32))) (:results (r :scs (signed-reg) - :load-if (not (location= x r)))) + :load-if (not (location= x r)))) (:result-types signed-num) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:generator 4 (cond ((and (sc-is x signed-reg) (sc-is r signed-reg) - (not (location= x r))) - (inst lea r (make-ea :qword :base x :disp y))) - (t - (move r x) - (if (= y 1) - (inst inc r) - (inst add r y)))))) + (not (location= x r))) + (inst lea r (make-ea :qword :base x :disp y))) + (t + (move r x) + (if (= y 1) + (inst inc r) + (inst add r y)))))) (define-vop (fast-+/unsigned=>unsigned fast-safe-arith-op) (:translate +) (:args (x :scs (unsigned-reg) :target r - :load-if (not (and (sc-is x unsigned-stack) - (sc-is y unsigned-reg) - (sc-is r unsigned-stack) - (location= x r)))) - (y :scs (unsigned-reg unsigned-stack))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is y unsigned-reg) + (sc-is r unsigned-stack) + (location= x r)))) + (y :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num) (:results (r :scs (unsigned-reg) :from (:argument 0) - :load-if (not (and (sc-is x unsigned-stack) - (sc-is y unsigned-reg) - (sc-is r unsigned-stack) - (location= x r))))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is y unsigned-reg) + (sc-is r unsigned-stack) + (location= x r))))) (:result-types unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic") + (:note "inline (unsigned-byte 64) arithmetic") (:generator 5 (cond ((and (sc-is x unsigned-reg) (sc-is y unsigned-reg) - (sc-is r unsigned-reg) (not (location= x r))) - (inst lea r (make-ea :qword :base x :index y :scale 1))) - (t - (move r x) - (inst add r y))))) + (sc-is r unsigned-reg) (not (location= x r))) + (inst lea r (make-ea :qword :base x :index y :scale 1))) + (t + (move r x) + (inst add r y))))) (define-vop (fast-+-c/unsigned=>unsigned fast-safe-arith-op) (:translate +) @@ -329,18 +329,18 @@ (:info y) (:arg-types unsigned-num (:constant (unsigned-byte 31))) (:results (r :scs (unsigned-reg) - :load-if (not (location= x r)))) + :load-if (not (location= x r)))) (:result-types unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic") + (:note "inline (unsigned-byte 64) arithmetic") (:generator 4 (cond ((and (sc-is x unsigned-reg) (sc-is r unsigned-reg) - (not (location= x r))) - (inst lea r (make-ea :qword :base x :disp y))) - (t - (move r x) - (if (= y 1) - (inst inc r) - (inst add r y)))))) + (not (location= x r))) + (inst lea r (make-ea :qword :base x :disp y))) + (t + (move r x) + (if (= y 1) + (inst inc r) + (inst add r y)))))) ;;;; multiplication and division @@ -348,7 +348,7 @@ (:translate *) ;; We need different loading characteristics. (:args (x :scs (any-reg) :target r) - (y :scs (any-reg control-stack))) + (y :scs (any-reg control-stack))) (:arg-types tagged-num tagged-num) (:results (r :scs (any-reg) :from (:argument 0))) (:result-types tagged-num) @@ -363,7 +363,7 @@ ;; We need different loading characteristics. (:args (x :scs (any-reg control-stack))) (:info y) - (:arg-types tagged-num (:constant (signed-byte 29))) + (:arg-types tagged-num (:constant (signed-byte 29))) (:results (r :scs (any-reg))) (:result-types tagged-num) (:note "inline fixnum arithmetic") @@ -374,11 +374,11 @@ (:translate *) ;; We need different loading characteristics. (:args (x :scs (signed-reg) :target r) - (y :scs (signed-reg signed-stack))) + (y :scs (signed-reg signed-stack))) (:arg-types signed-num signed-num) (:results (r :scs (signed-reg) :from (:argument 0))) (:result-types signed-num) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:generator 5 (move r x) (inst imul r y))) @@ -391,58 +391,58 @@ (:arg-types signed-num (:constant (signed-byte 32))) (:results (r :scs (signed-reg))) (:result-types signed-num) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:generator 4 (inst imul r x y))) (define-vop (fast-*/unsigned=>unsigned fast-safe-arith-op) (:translate *) (:args (x :scs (unsigned-reg) :target eax) - (y :scs (unsigned-reg unsigned-stack))) + (y :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num) - (:temporary (:sc unsigned-reg :offset eax-offset :target result - :from (:argument 0) :to :result) eax) + (:temporary (:sc unsigned-reg :offset eax-offset :target r + :from (:argument 0) :to :result) eax) (:temporary (:sc unsigned-reg :offset edx-offset - :from :eval :to :result) edx) + :from :eval :to :result) edx) (:ignore edx) - (:results (result :scs (unsigned-reg))) + (:results (r :scs (unsigned-reg))) (:result-types unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic") + (:note "inline (unsigned-byte 64) arithmetic") (:vop-var vop) (:save-p :compute-only) (:generator 6 (move eax x) (inst mul eax y) - (move result eax))) + (move r eax))) (define-vop (fast-truncate/fixnum=>fixnum fast-safe-arith-op) (:translate truncate) (:args (x :scs (any-reg) :target eax) - (y :scs (any-reg control-stack))) + (y :scs (any-reg control-stack))) (:arg-types tagged-num tagged-num) (:temporary (:sc signed-reg :offset eax-offset :target quo - :from (:argument 0) :to (:result 0)) eax) + :from (:argument 0) :to (:result 0)) eax) (:temporary (:sc unsigned-reg :offset edx-offset :target rem - :from (:argument 0) :to (:result 1)) edx) + :from (:argument 0) :to (:result 1)) edx) (:results (quo :scs (any-reg)) - (rem :scs (any-reg))) + (rem :scs (any-reg))) (:result-types tagged-num tagged-num) (:note "inline fixnum arithmetic") (:vop-var vop) (:save-p :compute-only) (:generator 31 - (let ((zero (generate-error-code vop division-by-zero-error x y))) + (let ((zero (generate-error-code vop 'division-by-zero-error x y))) (if (sc-is y any-reg) - (inst test y y) ; smaller instruction - (inst cmp y 0)) + (inst test y y) ; smaller instruction + (inst cmp y 0)) (inst jmp :eq zero)) (move eax x) (inst cqo) (inst idiv eax y) (if (location= quo eax) - (inst shl eax 3) - (inst lea quo (make-ea :qword :index eax :scale 8))) + (inst shl eax 3) + (inst lea quo (make-ea :qword :index eax :scale 8))) (move rem edx))) (define-vop (fast-truncate-c/fixnum=>fixnum fast-safe-arith-op) @@ -451,12 +451,12 @@ (:info y) (:arg-types tagged-num (:constant (signed-byte 29))) (:temporary (:sc signed-reg :offset eax-offset :target quo - :from :argument :to (:result 0)) eax) + :from :argument :to (:result 0)) eax) (:temporary (:sc any-reg :offset edx-offset :target rem - :from :eval :to (:result 1)) edx) + :from :eval :to (:result 1)) edx) (:temporary (:sc any-reg :from :eval :to :result) y-arg) (:results (quo :scs (any-reg)) - (rem :scs (any-reg))) + (rem :scs (any-reg))) (:result-types tagged-num tagged-num) (:note "inline fixnum arithmetic") (:vop-var vop) @@ -467,30 +467,30 @@ (inst mov y-arg (fixnumize y)) (inst idiv eax y-arg) (if (location= quo eax) - (inst shl eax 3) - (inst lea quo (make-ea :qword :index eax :scale 8))) + (inst shl eax 3) + (inst lea quo (make-ea :qword :index eax :scale 8))) (move rem edx))) (define-vop (fast-truncate/unsigned=>unsigned fast-safe-arith-op) (:translate truncate) (:args (x :scs (unsigned-reg) :target eax) - (y :scs (unsigned-reg signed-stack))) + (y :scs (unsigned-reg signed-stack))) (:arg-types unsigned-num unsigned-num) (:temporary (:sc unsigned-reg :offset eax-offset :target quo - :from (:argument 0) :to (:result 0)) eax) + :from (:argument 0) :to (:result 0)) eax) (:temporary (:sc unsigned-reg :offset edx-offset :target rem - :from (:argument 0) :to (:result 1)) edx) + :from (:argument 0) :to (:result 1)) edx) (:results (quo :scs (unsigned-reg)) - (rem :scs (unsigned-reg))) + (rem :scs (unsigned-reg))) (:result-types unsigned-num unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic") + (:note "inline (unsigned-byte 64) arithmetic") (:vop-var vop) (:save-p :compute-only) (:generator 33 - (let ((zero (generate-error-code vop division-by-zero-error x y))) + (let ((zero (generate-error-code vop 'division-by-zero-error x y))) (if (sc-is y unsigned-reg) - (inst test y y) ; smaller instruction - (inst cmp y 0)) + (inst test y y) ; smaller instruction + (inst cmp y 0)) (inst jmp :eq zero)) (move eax x) (inst xor edx edx) @@ -504,14 +504,14 @@ (:info y) (:arg-types unsigned-num (:constant (unsigned-byte 31))) (:temporary (:sc unsigned-reg :offset eax-offset :target quo - :from :argument :to (:result 0)) eax) + :from :argument :to (:result 0)) eax) (:temporary (:sc unsigned-reg :offset edx-offset :target rem - :from :eval :to (:result 1)) edx) + :from :eval :to (:result 1)) edx) (:temporary (:sc unsigned-reg :from :eval :to :result) y-arg) (:results (quo :scs (unsigned-reg)) - (rem :scs (unsigned-reg))) + (rem :scs (unsigned-reg))) (:result-types unsigned-num unsigned-num) - (:note "inline (unsigned-byte 32) arithmetic") + (:note "inline (unsigned-byte 64) arithmetic") (:vop-var vop) (:save-p :compute-only) (:generator 32 @@ -525,23 +525,23 @@ (define-vop (fast-truncate/signed=>signed fast-safe-arith-op) (:translate truncate) (:args (x :scs (signed-reg) :target eax) - (y :scs (signed-reg signed-stack))) + (y :scs (signed-reg signed-stack))) (:arg-types signed-num signed-num) (:temporary (:sc signed-reg :offset eax-offset :target quo - :from (:argument 0) :to (:result 0)) eax) + :from (:argument 0) :to (:result 0)) eax) (:temporary (:sc signed-reg :offset edx-offset :target rem - :from (:argument 0) :to (:result 1)) edx) + :from (:argument 0) :to (:result 1)) edx) (:results (quo :scs (signed-reg)) - (rem :scs (signed-reg))) + (rem :scs (signed-reg))) (:result-types signed-num signed-num) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:vop-var vop) (:save-p :compute-only) (:generator 33 - (let ((zero (generate-error-code vop division-by-zero-error x y))) + (let ((zero (generate-error-code vop 'division-by-zero-error x y))) (if (sc-is y signed-reg) - (inst test y y) ; smaller instruction - (inst cmp y 0)) + (inst test y y) ; smaller instruction + (inst cmp y 0)) (inst jmp :eq zero)) (move eax x) (inst cqo) @@ -555,14 +555,14 @@ (:info y) (:arg-types signed-num (:constant (signed-byte 32))) (:temporary (:sc signed-reg :offset eax-offset :target quo - :from :argument :to (:result 0)) eax) + :from :argument :to (:result 0)) eax) (:temporary (:sc signed-reg :offset edx-offset :target rem - :from :eval :to (:result 1)) edx) + :from :eval :to (:result 1)) edx) (:temporary (:sc signed-reg :from :eval :to :result) y-arg) (:results (quo :scs (signed-reg)) - (rem :scs (signed-reg))) + (rem :scs (signed-reg))) (:result-types signed-num signed-num) - (:note "inline (signed-byte 32) arithmetic") + (:note "inline (signed-byte 64) arithmetic") (:vop-var vop) (:save-p :compute-only) (:generator 32 @@ -580,53 +580,54 @@ (:translate ash) (:policy :fast-safe) (:args (number :scs (any-reg) :target result - :load-if (not (and (sc-is number any-reg control-stack) - (sc-is result any-reg control-stack) - (location= number result))))) + :load-if (not (and (sc-is number any-reg control-stack) + (sc-is result any-reg control-stack) + (location= number result))))) (:info amount) (:arg-types tagged-num (:constant integer)) (:results (result :scs (any-reg) - :load-if (not (and (sc-is number control-stack) - (sc-is result control-stack) - (location= number result))))) + :load-if (not (and (sc-is number control-stack) + (sc-is result control-stack) + (location= number result))))) (:result-types tagged-num) (:note "inline ASH") (:generator 2 (cond ((and (= amount 1) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 2))) - ((and (= amount 2) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 4))) - ((and (= amount 3) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 8))) - (t - (move result number) - (cond ((plusp amount) - ;; We don't have to worry about overflow because of the - ;; result type restriction. - (inst shl result amount)) - (t - ;; Since the shift instructions take the shift amount - ;; modulo 64 we must special case amounts of 64 and more. - ;; Because fixnums have only 61 bits, the result is 0 or - ;; -1 for all amounts of 60 or more, so use this as the - ;; limit instead. - (inst sar result (min (- n-word-bits n-fixnum-tag-bits 1) - (- amount))) - (inst and result (lognot fixnum-tag-mask)))))))) + (inst lea result (make-ea :qword :base number :index number))) + ((and (= amount 2) (not (location= number result))) + (inst lea result (make-ea :qword :index number :scale 4))) + ((and (= amount 3) (not (location= number result))) + (inst lea result (make-ea :qword :index number :scale 8))) + (t + (move result number) + (cond ((< -64 amount 64) + ;; this code is used both in ASH and ASH-SMOD61, so + ;; be careful + (if (plusp amount) + (inst shl result amount) + (progn + (inst sar result (- amount)) + (inst and result (lognot fixnum-tag-mask))))) + ((plusp amount) + (if (sc-is result any-reg) + (inst xor result result) + (inst mov result 0))) + (t (inst sar result 63) + (inst and result (lognot fixnum-tag-mask)))))))) (define-vop (fast-ash-left/fixnum=>fixnum) (:translate ash) (:args (number :scs (any-reg) :target result - :load-if (not (and (sc-is number control-stack) - (sc-is result control-stack) - (location= number result)))) - (amount :scs (unsigned-reg) :target ecx)) + :load-if (not (and (sc-is number control-stack) + (sc-is result control-stack) + (location= number result)))) + (amount :scs (unsigned-reg) :target ecx)) (:arg-types tagged-num positive-fixnum) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 1)) ecx) (:results (result :scs (any-reg) :from (:argument 0) - :load-if (not (and (sc-is number control-stack) - (sc-is result control-stack) - (location= number result))))) + :load-if (not (and (sc-is number control-stack) + (sc-is result control-stack) + (location= number result))))) (:result-types tagged-num) (:policy :fast-safe) (:note "inline ASH") @@ -640,76 +641,76 @@ (:translate ash) (:policy :fast-safe) (:args (number :scs (signed-reg) :target result - :load-if (not (and (sc-is number signed-stack) - (sc-is result signed-stack) - (location= number result))))) + :load-if (not (and (sc-is number signed-stack) + (sc-is result signed-stack) + (location= number result))))) (:info amount) (:arg-types signed-num (:constant integer)) (:results (result :scs (signed-reg) - :load-if (not (and (sc-is number signed-stack) - (sc-is result signed-stack) - (location= number result))))) + :load-if (not (and (sc-is number signed-stack) + (sc-is result signed-stack) + (location= number result))))) (:result-types signed-num) (:note "inline ASH") (:generator 3 (cond ((and (= amount 1) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 2))) - ((and (= amount 2) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 4))) - ((and (= amount 3) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 8))) - (t - (move result number) - (cond ((plusp amount) (inst shl result amount)) - (t (inst sar result (min 63 (- amount))))))))) + (inst lea result (make-ea :qword :base number :index number))) + ((and (= amount 2) (not (location= number result))) + (inst lea result (make-ea :qword :index number :scale 4))) + ((and (= amount 3) (not (location= number result))) + (inst lea result (make-ea :qword :index number :scale 8))) + (t + (move result number) + (cond ((plusp amount) (inst shl result amount)) + (t (inst sar result (min 63 (- amount))))))))) (define-vop (fast-ash-c/unsigned=>unsigned) (:translate ash) (:policy :fast-safe) (:args (number :scs (unsigned-reg) :target result - :load-if (not (and (sc-is number unsigned-stack) - (sc-is result unsigned-stack) - (location= number result))))) + :load-if (not (and (sc-is number unsigned-stack) + (sc-is result unsigned-stack) + (location= number result))))) (:info amount) (:arg-types unsigned-num (:constant integer)) (:results (result :scs (unsigned-reg) - :load-if (not (and (sc-is number unsigned-stack) - (sc-is result unsigned-stack) - (location= number result))))) + :load-if (not (and (sc-is number unsigned-stack) + (sc-is result unsigned-stack) + (location= number result))))) (:result-types unsigned-num) (:note "inline ASH") (:generator 3 (cond ((and (= amount 1) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 2))) - ((and (= amount 2) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 4))) - ((and (= amount 3) (not (location= number result))) - (inst lea result (make-ea :qword :index number :scale 8))) - (t - (move result number) - (cond ((< -64 amount 64) ;; XXXX + (inst lea result (make-ea :qword :base number :index number))) + ((and (= amount 2) (not (location= number result))) + (inst lea result (make-ea :qword :index number :scale 4))) + ((and (= amount 3) (not (location= number result))) + (inst lea result (make-ea :qword :index number :scale 8))) + (t + (move result number) + (cond ((< -64 amount 64) ;; XXXX ;; this code is used both in ASH and ASH-MOD32, so ;; be careful (if (plusp amount) (inst shl result amount) (inst shr result (- amount)))) - (t (if (sc-is result unsigned-reg) - (inst xor result result) + (t (if (sc-is result unsigned-reg) + (zeroize result) (inst mov result 0)))))))) (define-vop (fast-ash-left/signed=>signed) (:translate ash) (:args (number :scs (signed-reg) :target result - :load-if (not (and (sc-is number signed-stack) - (sc-is result signed-stack) - (location= number result)))) - (amount :scs (unsigned-reg) :target ecx)) + :load-if (not (and (sc-is number signed-stack) + (sc-is result signed-stack) + (location= number result)))) + (amount :scs (unsigned-reg) :target ecx)) (:arg-types signed-num positive-fixnum) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 1)) ecx) (:results (result :scs (signed-reg) :from (:argument 0) - :load-if (not (and (sc-is number signed-stack) - (sc-is result signed-stack) - (location= number result))))) + :load-if (not (and (sc-is number signed-stack) + (sc-is result signed-stack) + (location= number result))))) (:result-types signed-num) (:policy :fast-safe) (:note "inline ASH") @@ -721,16 +722,16 @@ (define-vop (fast-ash-left/unsigned=>unsigned) (:translate ash) (:args (number :scs (unsigned-reg) :target result - :load-if (not (and (sc-is number unsigned-stack) - (sc-is result unsigned-stack) - (location= number result)))) - (amount :scs (unsigned-reg) :target ecx)) + :load-if (not (and (sc-is number unsigned-stack) + (sc-is result unsigned-stack) + (location= number result)))) + (amount :scs (unsigned-reg) :target ecx)) (:arg-types unsigned-num positive-fixnum) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 1)) ecx) (:results (result :scs (unsigned-reg) :from (:argument 0) - :load-if (not (and (sc-is number unsigned-stack) - (sc-is result unsigned-stack) - (location= number result))))) + :load-if (not (and (sc-is number unsigned-stack) + (sc-is result unsigned-stack) + (location= number result))))) (:result-types unsigned-num) (:policy :fast-safe) (:note "inline ASH") @@ -743,7 +744,7 @@ (:translate ash) (:policy :fast-safe) (:args (number :scs (signed-reg) :target result) - (amount :scs (signed-reg) :target ecx)) + (amount :scs (signed-reg) :target ecx)) (:arg-types signed-num signed-num) (:results (result :scs (signed-reg) :from (:argument 0))) (:result-types signed-num) @@ -753,14 +754,14 @@ (move result number) (move ecx amount) (inst or ecx ecx) - (inst jmp :ns positive) + (inst jmp :ns POSITIVE) (inst neg ecx) (inst cmp ecx 63) - (inst jmp :be okay) + (inst jmp :be OKAY) (inst mov ecx 63) OKAY (inst sar result :cl) - (inst jmp done) + (inst jmp DONE) POSITIVE ;; The result-type ensures us that this shift will not overflow. @@ -772,7 +773,7 @@ (:translate ash) (:policy :fast-safe) (:args (number :scs (unsigned-reg) :target result) - (amount :scs (signed-reg) :target ecx)) + (amount :scs (signed-reg) :target ecx)) (:arg-types unsigned-num signed-num) (:results (result :scs (unsigned-reg) :from (:argument 0))) (:result-types unsigned-num) @@ -782,15 +783,15 @@ (move result number) (move ecx amount) (inst or ecx ecx) - (inst jmp :ns positive) + (inst jmp :ns POSITIVE) (inst neg ecx) (inst cmp ecx 63) - (inst jmp :be okay) - (inst xor result result) - (inst jmp done) + (inst jmp :be OKAY) + (zeroize result) + (inst jmp DONE) OKAY (inst shr result :cl) - (inst jmp done) + (inst jmp DONE) POSITIVE ;; The result-type ensures us that this shift will not overflow. @@ -806,23 +807,23 @@ (defoptimizer (%lea derive-type) ((base index scale disp)) (when (and (constant-lvar-p scale) - (constant-lvar-p disp)) + (constant-lvar-p disp)) (let ((scale (lvar-value scale)) - (disp (lvar-value disp)) - (base-type (lvar-type base)) - (index-type (lvar-type index))) + (disp (lvar-value disp)) + (base-type (lvar-type base)) + (index-type (lvar-type index))) (when (and (numeric-type-p base-type) - (numeric-type-p index-type)) - (let ((base-lo (numeric-type-low base-type)) - (base-hi (numeric-type-high base-type)) - (index-lo (numeric-type-low index-type)) - (index-hi (numeric-type-high index-type))) - (make-numeric-type :class 'integer - :complexp :real - :low (when (and base-lo index-lo) - (+ base-lo (* index-lo scale) disp)) - :high (when (and base-hi index-hi) - (+ base-hi (* index-hi scale) disp)))))))) + (numeric-type-p index-type)) + (let ((base-lo (numeric-type-low base-type)) + (base-hi (numeric-type-high base-type)) + (index-lo (numeric-type-low index-type)) + (index-hi (numeric-type-high index-type))) + (make-numeric-type :class 'integer + :complexp :real + :low (when (and base-lo index-lo) + (+ base-lo (* index-lo scale) disp)) + :high (when (and base-hi index-hi) + (+ base-hi (* index-hi scale) disp)))))))) (defun %lea (base index scale disp) (+ base (* index scale) disp)) @@ -833,46 +834,46 @@ (:translate %lea) (:policy :fast-safe) (:args (base :scs (unsigned-reg)) - (index :scs (unsigned-reg))) + (index :scs (unsigned-reg))) (:info scale disp) (:arg-types unsigned-num unsigned-num - (:constant (member 1 2 4 8)) - (:constant (signed-byte 64))) + (:constant (member 1 2 4 8)) + (:constant (signed-byte 64))) (:results (r :scs (unsigned-reg))) (:result-types unsigned-num) (:generator 5 (inst lea r (make-ea :qword :base base :index index - :scale scale :disp disp)))) + :scale scale :disp disp)))) (define-vop (%lea/signed=>signed) (:translate %lea) (:policy :fast-safe) (:args (base :scs (signed-reg)) - (index :scs (signed-reg))) + (index :scs (signed-reg))) (:info scale disp) (:arg-types signed-num signed-num - (:constant (member 1 2 4 8)) - (:constant (signed-byte 64))) + (:constant (member 1 2 4 8)) + (:constant (signed-byte 64))) (:results (r :scs (signed-reg))) (:result-types signed-num) (:generator 4 (inst lea r (make-ea :qword :base base :index index - :scale scale :disp disp)))) + :scale scale :disp disp)))) (define-vop (%lea/fixnum=>fixnum) (:translate %lea) (:policy :fast-safe) (:args (base :scs (any-reg)) - (index :scs (any-reg))) + (index :scs (any-reg))) (:info scale disp) (:arg-types tagged-num tagged-num - (:constant (member 1 2 4 8)) - (:constant (signed-byte 64))) + (:constant (member 1 2 4 8)) + (:constant (signed-byte 64))) (:results (r :scs (any-reg))) (:result-types tagged-num) (:generator 3 (inst lea r (make-ea :qword :base base :index index - :scale scale :disp disp)))) + :scale scale :disp disp)))) ;;; FIXME: before making knowledge of this too public, it needs to be ;;; fixed so that it's actually _faster_ than the non-CMOV version; at @@ -882,7 +883,7 @@ (:translate ash) (:policy :fast-safe) (:args (number :scs (unsigned-reg) :target result) - (amount :scs (signed-reg) :target ecx)) + (amount :scs (signed-reg) :target ecx)) (:arg-types unsigned-num signed-num) (:results (result :scs (unsigned-reg) :from (:argument 0))) (:result-types unsigned-num) @@ -894,14 +895,14 @@ (move result number) (move ecx amount) (inst or ecx ecx) - (inst jmp :ns positive) + (inst jmp :ns POSITIVE) (inst neg ecx) - (inst xor zero zero) + (zeroize zero) (inst shr result :cl) (inst cmp ecx 63) (inst cmov :nbe result zero) - (inst jmp done) - + (inst jmp DONE) + POSITIVE ;; The result-type ensures us that this shift will not overflow. (inst shl result :cl) @@ -910,7 +911,7 @@ (define-vop (signed-byte-64-len) (:translate integer-length) - (:note "inline (signed-byte 32) integer-length") + (:note "inline (signed-byte 64) integer-length") (:policy :fast-safe) (:args (arg :scs (signed-reg) :target res)) (:arg-types signed-num) @@ -918,21 +919,23 @@ (:result-types unsigned-num) (:generator 28 (move res arg) - (inst cmp res 0) + (if (sc-is res unsigned-reg) + (inst test res res) + (inst cmp res 0)) (inst jmp :ge POS) (inst not res) POS (inst bsr res res) - (inst jmp :z zero) + (inst jmp :z ZERO) (inst inc res) - (inst jmp done) + (inst jmp DONE) ZERO - (inst xor res res) + (zeroize res) DONE)) (define-vop (unsigned-byte-64-len) (:translate integer-length) - (:note "inline (unsigned-byte 32) integer-length") + (:note "inline (unsigned-byte 64) integer-length") (:policy :fast-safe) (:args (arg :scs (unsigned-reg))) (:arg-types unsigned-num) @@ -940,93 +943,67 @@ (:result-types unsigned-num) (:generator 26 (inst bsr res arg) - (inst jmp :z zero) + (inst jmp :z ZERO) (inst inc res) - (inst jmp done) + (inst jmp DONE) ZERO - (inst xor res res) + (zeroize res) DONE)) - (define-vop (unsigned-byte-64-count) (:translate logcount) (:note "inline (unsigned-byte 64) logcount") (:policy :fast-safe) - (:args (arg :scs (unsigned-reg))) + (:args (arg :scs (unsigned-reg) :target result)) (:arg-types unsigned-num) (:results (result :scs (unsigned-reg))) (:result-types positive-fixnum) - (:temporary (:sc unsigned-reg :from (:argument 0)) temp) - (:temporary (:sc unsigned-reg :from (:argument 0)) t1) - (:generator 60 + (:temporary (:sc unsigned-reg) temp) + (:temporary (:sc unsigned-reg) mask) + (:generator 14 + ;; See the comments below for how the algorithm works. The tricks + ;; used can be found for example in AMD's software optimization + ;; guide or at "http://www.hackersdelight.org/HDcode/pop.cc" in the + ;; function "pop1", for 32-bit words. The extension to 64 bits is + ;; straightforward. + ;; Calculate 2-bit sums. Note that the value of a two-digit binary + ;; number is the sum of the right digit and twice the left digit. + ;; Thus we can calculate the sum of the two digits by shifting the + ;; left digit to the right position and doing a two-bit subtraction. + ;; This subtraction will never create a borrow and thus can be made + ;; on all 32 2-digit numbers at once. (move result arg) - (move t1 arg) - - (inst mov temp result) - (inst shr temp 1) - (inst and result #x55555555) ; note these masks will restrict the - (inst and temp #x55555555) ; count to the lower half of arg - (inst add result temp) - - (inst mov temp result) + (move temp arg) + (inst shr result 1) + (inst mov mask #x5555555555555555) + (inst and result mask) + (inst sub temp result) + ;; Calculate 4-bit sums by straightforward shift, mask and add. + ;; Note that we shift the source operand of the MOV and not its + ;; destination so that the SHR and the MOV can execute in the same + ;; clock cycle. + (inst mov result temp) (inst shr temp 2) - (inst and result #x33333333) - (inst and temp #x33333333) - (inst add result temp) - - (inst mov temp result) - (inst shr temp 4) - (inst and result #x0f0f0f0f) - (inst and temp #x0f0f0f0f) - (inst add result temp) - - (inst mov temp result) - (inst shr temp 8) - (inst and result #x00ff00ff) - (inst and temp #x00ff00ff) + (inst mov mask #x3333333333333333) + (inst and result mask) + (inst and temp mask) (inst add result temp) - + ;; Calculate 8-bit sums. Since each sum is at most 8, which fits + ;; into 4 bits, we can apply the mask after the addition, saving one + ;; instruction. (inst mov temp result) - (inst shr temp 16) - (inst and result #x0000ffff) - (inst and temp #x0000ffff) + (inst shr result 4) (inst add result temp) - - ;;; now do the upper half - (inst shr t1 32) - - (inst mov temp t1) - (inst shr temp 1) - (inst and t1 #x55555555) - (inst and temp #x55555555) - (inst add t1 temp) - - (inst mov temp t1) - (inst shr temp 2) - (inst and t1 #x33333333) - (inst and temp #x33333333) - (inst add t1 temp) - - (inst mov temp t1) - (inst shr temp 4) - (inst and t1 #x0f0f0f0f) - (inst and temp #x0f0f0f0f) - (inst add t1 temp) - - (inst mov temp t1) - (inst shr temp 8) - (inst and t1 #x00ff00ff) - (inst and temp #x00ff00ff) - (inst add t1 temp) - - (inst mov temp t1) - (inst shr temp 16) - (inst and t1 #x0000ffff) - (inst and temp #x0000ffff) - (inst add t1 temp) - (inst add result t1))) - - + (inst mov mask #x0f0f0f0f0f0f0f0f) + (inst and result mask) + ;; Add all 8 bytes at once by multiplying with #256r11111111. + ;; We need to calculate only the lower 8 bytes of the product. + ;; Of these the most significant byte contains the final result. + ;; Note that there can be no overflow from one byte to the next + ;; as the sum is at most 64 which needs only 7 bits. + (inst mov mask #x0101010101010101) + (inst imul result mask) + (inst shr result 56))) ;;;; binary conditional VOPs @@ -1042,9 +1019,9 @@ (define-vop (fast-conditional/fixnum fast-conditional) (:args (x :scs (any-reg) - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg)))) - (y :scs (any-reg control-stack))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg)))) + (y :scs (any-reg control-stack))) (:arg-types tagged-num tagged-num) (:note "inline fixnum comparison")) @@ -1055,11 +1032,11 @@ (define-vop (fast-conditional/signed fast-conditional) (:args (x :scs (signed-reg) - :load-if (not (and (sc-is x signed-stack) - (sc-is y signed-reg)))) - (y :scs (signed-reg signed-stack))) + :load-if (not (and (sc-is x signed-stack) + (sc-is y signed-reg)))) + (y :scs (signed-reg signed-stack))) (:arg-types signed-num signed-num) - (:note "inline (signed-byte 32) comparison")) + (:note "inline (signed-byte 64) comparison")) (define-vop (fast-conditional-c/signed fast-conditional/signed) (:args (x :scs (signed-reg signed-stack))) @@ -1068,11 +1045,11 @@ (define-vop (fast-conditional/unsigned fast-conditional) (:args (x :scs (unsigned-reg) - :load-if (not (and (sc-is x unsigned-stack) - (sc-is y unsigned-reg)))) - (y :scs (unsigned-reg unsigned-stack))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is y unsigned-reg)))) + (y :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num) - (:note "inline (unsigned-byte 32) comparison")) + (:note "inline (unsigned-byte 64) comparison")) (define-vop (fast-conditional-c/unsigned fast-conditional/unsigned) (:args (x :scs (unsigned-reg unsigned-stack))) @@ -1080,34 +1057,34 @@ (:info target not-p y)) (macrolet ((define-conditional-vop (tran cond unsigned not-cond not-unsigned) - `(progn - ,@(mapcar - (lambda (suffix cost signed) - `(define-vop (;; FIXME: These could be done more - ;; cleanly with SYMBOLICATE. - ,(intern (format nil "~:@(FAST-IF-~A~A~)" - tran suffix)) - ,(intern - (format nil "~:@(FAST-CONDITIONAL~A~)" - suffix))) - (:translate ,tran) - (:generator ,cost - (inst cmp x - ,(if (eq suffix '-c/fixnum) - '(fixnumize y) - 'y)) - (inst jmp (if not-p - ,(if signed - not-cond - not-unsigned) - ,(if signed - cond - unsigned)) - target)))) - '(/fixnum -c/fixnum /signed -c/signed /unsigned -c/unsigned) -; '(/fixnum /signed /unsigned) - '(4 3 6 5 6 5) - '(t t t t nil nil))))) + `(progn + ,@(mapcar + (lambda (suffix cost signed) + `(define-vop (;; FIXME: These could be done more + ;; cleanly with SYMBOLICATE. + ,(intern (format nil "~:@(FAST-IF-~A~A~)" + tran suffix)) + ,(intern + (format nil "~:@(FAST-CONDITIONAL~A~)" + suffix))) + (:translate ,tran) + (:generator ,cost + (inst cmp x + ,(if (eq suffix '-c/fixnum) + '(fixnumize y) + 'y)) + (inst jmp (if not-p + ,(if signed + not-cond + not-unsigned) + ,(if signed + cond + unsigned)) + target)))) + '(/fixnum -c/fixnum /signed -c/signed /unsigned -c/unsigned) +; '(/fixnum /signed /unsigned) + '(4 3 6 5 6 5) + '(t t t t nil nil))))) (define-conditional-vop < :l :b :ge :ae) (define-conditional-vop > :g :a :le :be)) @@ -1122,9 +1099,9 @@ (:translate eql) (:generator 5 (cond ((and (sc-is x signed-reg) (zerop y)) - (inst test x x)) ; smaller instruction - (t - (inst cmp x y))) + (inst test x x)) ; smaller instruction + (t + (inst cmp x y))) (inst jmp (if not-p :ne :e) target))) (define-vop (fast-if-eql/unsigned fast-conditional/unsigned) @@ -1137,9 +1114,9 @@ (:translate eql) (:generator 5 (cond ((and (sc-is x unsigned-reg) (zerop y)) - (inst test x x)) ; smaller instruction - (t - (inst cmp x y))) + (inst test x x)) ; smaller instruction + (t + (inst cmp x y))) (inst jmp (if not-p :ne :e) target))) ;;; EQL/FIXNUM is funny because the first arg can be of any type, not just a @@ -1153,9 +1130,9 @@ (define-vop (fast-eql/fixnum fast-conditional) (:args (x :scs (any-reg) - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg)))) - (y :scs (any-reg control-stack))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg)))) + (y :scs (any-reg control-stack))) (:arg-types tagged-num tagged-num) (:note "inline fixnum comparison") (:translate eql) @@ -1164,9 +1141,9 @@ (inst jmp (if not-p :ne :e) target))) (define-vop (generic-eql/fixnum fast-eql/fixnum) (:args (x :scs (any-reg descriptor-reg) - :load-if (not (and (sc-is x control-stack) - (sc-is y any-reg)))) - (y :scs (any-reg control-stack))) + :load-if (not (and (sc-is x control-stack) + (sc-is y any-reg)))) + (y :scs (any-reg control-stack))) (:arg-types * tagged-num) (:variant-cost 7)) @@ -1178,9 +1155,9 @@ (:translate eql) (:generator 2 (cond ((and (sc-is x any-reg) (zerop y)) - (inst test x x)) ; smaller instruction - (t - (inst cmp x (fixnumize y)))) + (inst test x x)) ; smaller instruction + (t + (inst cmp x (fixnumize y)))) (inst jmp (if not-p :ne :e) target))) (define-vop (generic-eql-c/fixnum fast-eql-c/fixnum) @@ -1193,8 +1170,8 @@ (define-vop (merge-bits) (:translate merge-bits) (:args (shift :scs (signed-reg unsigned-reg) :target ecx) - (prev :scs (unsigned-reg) :target result) - (next :scs (unsigned-reg))) + (prev :scs (unsigned-reg) :target result) + (next :scs (unsigned-reg))) (:arg-types tagged-num unsigned-num unsigned-num) (:temporary (:sc signed-reg :offset ecx-offset :from (:argument 0)) ecx) (:results (result :scs (unsigned-reg) :from (:argument 1))) @@ -1209,7 +1186,7 @@ (define-vop (shift-towards-someplace) (:policy :fast-safe) (:args (num :scs (unsigned-reg) :target r) - (amount :scs (signed-reg) :target ecx)) + (amount :scs (signed-reg) :target ecx)) (:arg-types unsigned-num tagged-num) (:temporary (:sc signed-reg :offset ecx-offset :from (:argument 1)) ecx) (:results (r :scs (unsigned-reg) :from (:argument 0))) @@ -1233,27 +1210,68 @@ ;;;; Modular functions +(defmacro define-mod-binop ((name prototype) function) + `(define-vop (,name ,prototype) + (:args (x :target r :scs (unsigned-reg signed-reg) + :load-if (not (and (or (sc-is x unsigned-stack) + (sc-is x signed-stack)) + (or (sc-is y unsigned-reg) + (sc-is y signed-reg)) + (or (sc-is r unsigned-stack) + (sc-is r signed-stack)) + (location= x r)))) + (y :scs (unsigned-reg signed-reg unsigned-stack signed-stack))) + (:arg-types untagged-num untagged-num) + (:results (r :scs (unsigned-reg signed-reg) :from (:argument 0) + :load-if (not (and (or (sc-is x unsigned-stack) + (sc-is x signed-stack)) + (or (sc-is y unsigned-reg) + (sc-is y unsigned-reg)) + (or (sc-is r unsigned-stack) + (sc-is r unsigned-stack)) + (location= x r))))) + (:result-types unsigned-num) + (:translate ,function))) +(defmacro define-mod-binop-c ((name prototype) function) + `(define-vop (,name ,prototype) + (:args (x :target r :scs (unsigned-reg signed-reg) + :load-if (not (and (or (sc-is x unsigned-stack) + (sc-is x signed-stack)) + (or (sc-is r unsigned-stack) + (sc-is r signed-stack)) + (location= x r))))) + (:info y) + (:arg-types untagged-num (:constant (or (unsigned-byte 31) (signed-byte 32)))) + (:results (r :scs (unsigned-reg signed-reg) :from (:argument 0) + :load-if (not (and (or (sc-is x unsigned-stack) + (sc-is x signed-stack)) + (or (sc-is r unsigned-stack) + (sc-is r unsigned-stack)) + (location= x r))))) + (:result-types unsigned-num) + (:translate ,function))) + (macrolet ((def (name -c-p) (let ((fun64 (intern (format nil "~S-MOD64" name))) (vopu (intern (format nil "FAST-~S/UNSIGNED=>UNSIGNED" name))) (vopcu (intern (format nil "FAST-~S-C/UNSIGNED=>UNSIGNED" name))) (vopf (intern (format nil "FAST-~S/FIXNUM=>FIXNUM" name))) (vopcf (intern (format nil "FAST-~S-C/FIXNUM=>FIXNUM" name))) - (vop64u (intern (format nil "FAST-~S-MOD64/UNSIGNED=>UNSIGNED" name))) + (vop64u (intern (format nil "FAST-~S-MOD64/WORD=>UNSIGNED" name))) (vop64f (intern (format nil "FAST-~S-MOD64/FIXNUM=>FIXNUM" name))) - (vop64cu (intern (format nil "FAST-~S-MOD64-C/UNSIGNED=>UNSIGNED" name))) + (vop64cu (intern (format nil "FAST-~S-MOD64-C/WORD=>UNSIGNED" name))) (vop64cf (intern (format nil "FAST-~S-MOD64-C/FIXNUM=>FIXNUM" name))) (sfun61 (intern (format nil "~S-SMOD61" name))) (svop61f (intern (format nil "FAST-~S-SMOD61/FIXNUM=>FIXNUM" name))) (svop61cf (intern (format nil "FAST-~S-SMOD61-C/FIXNUM=>FIXNUM" name)))) `(progn - (define-modular-fun ,fun64 (x y) ,name :unsigned 64) - (define-modular-fun ,sfun61 (x y) ,name :signed 61) - (define-vop (,vop64u ,vopu) (:translate ,fun64)) + (define-modular-fun ,fun64 (x y) ,name :untagged nil 64) + (define-modular-fun ,sfun61 (x y) ,name :tagged t 61) + (define-mod-binop (,vop64u ,vopu) ,fun64) (define-vop (,vop64f ,vopf) (:translate ,fun64)) (define-vop (,svop61f ,vopf) (:translate ,sfun61)) ,@(when -c-p - `((define-vop (,vop64cu ,vopcu) (:translate ,fun64)) + `((define-mod-binop-c (,vop64cu ,vopcu) ,fun64) (define-vop (,svop61cf ,vopcf) (:translate ,sfun61)))))))) (def + t) (def - t) @@ -1266,7 +1284,7 @@ (define-vop (fast-ash-left-mod64/unsigned=>unsigned fast-ash-left/unsigned=>unsigned)) (deftransform ash-left-mod64 ((integer count) - ((unsigned-byte 64) (unsigned-byte 6))) + ((unsigned-byte 64) (unsigned-byte 6))) (when (sb!c::constant-lvar-p count) (sb!c::give-up-ir1-transform)) '(%primitive fast-ash-left-mod64/unsigned=>unsigned integer count)) @@ -1291,19 +1309,19 @@ (signed-byte 61) (foldable flushable movable)) -(define-modular-fun-optimizer %lea ((base index scale disp) :unsigned :width width) +(define-modular-fun-optimizer %lea ((base index scale disp) :untagged nil :width width) (when (and (<= width 64) - (constant-lvar-p scale) - (constant-lvar-p disp)) - (cut-to-width base :unsigned width) - (cut-to-width index :unsigned width) + (constant-lvar-p scale) + (constant-lvar-p disp)) + (cut-to-width base :untagged width nil) + (cut-to-width index :untagged width nil) 'sb!vm::%lea-mod64)) -(define-modular-fun-optimizer %lea ((base index scale disp) :signed :width width) +(define-modular-fun-optimizer %lea ((base index scale disp) :tagged t :width width) (when (and (<= width 61) - (constant-lvar-p scale) - (constant-lvar-p disp)) - (cut-to-width base :signed width) - (cut-to-width index :signed width) + (constant-lvar-p scale) + (constant-lvar-p disp)) + (cut-to-width base :tagged width t) + (cut-to-width index :tagged width t) 'sb!vm::%lea-smod61)) #+sb-xc-host @@ -1316,7 +1334,7 @@ (progn (defun sb!vm::%lea-mod64 (base index scale disp) (let ((base (logand base #xffffffffffffffff)) - (index (logand index #xffffffffffffffff))) + (index (logand index #xffffffffffffffff))) ;; can't use modular version of %LEA, as we only have VOPs for ;; constant SCALE and DISP. (ldb (byte 64 0) (+ base (* index scale) disp)))) @@ -1330,45 +1348,31 @@ (in-package "SB!VM") (define-vop (%lea-mod64/unsigned=>unsigned - %lea/unsigned=>unsigned) + %lea/unsigned=>unsigned) (:translate %lea-mod64)) (define-vop (%lea-smod61/fixnum=>fixnum - %lea/fixnum=>fixnum) + %lea/fixnum=>fixnum) (:translate %lea-smod61)) ;;; logical operations -(define-modular-fun lognot-mod64 (x) lognot :unsigned 64) +(define-modular-fun lognot-mod64 (x) lognot :untagged nil 64) (define-vop (lognot-mod64/unsigned=>unsigned) (:translate lognot-mod64) (:args (x :scs (unsigned-reg unsigned-stack) :target r - :load-if (not (and (sc-is x unsigned-stack) - (sc-is r unsigned-stack) - (location= x r))))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is r unsigned-stack) + (location= x r))))) (:arg-types unsigned-num) (:results (r :scs (unsigned-reg) - :load-if (not (and (sc-is x unsigned-stack) - (sc-is r unsigned-stack) - (location= x r))))) + :load-if (not (and (sc-is x unsigned-stack) + (sc-is r unsigned-stack) + (location= x r))))) (:result-types unsigned-num) (:policy :fast-safe) (:generator 1 (move r x) (inst not r))) -(define-modular-fun logxor-mod64 (x y) logxor :unsigned 64) -(define-vop (fast-logxor-mod64/unsigned=>unsigned - fast-logxor/unsigned=>unsigned) - (:translate logxor-mod64)) -(define-vop (fast-logxor-mod64-c/unsigned=>unsigned - fast-logxor-c/unsigned=>unsigned) - (:translate logxor-mod64)) -(define-vop (fast-logxor-mod64/fixnum=>fixnum - fast-logxor/fixnum=>fixnum) - (:translate logxor-mod64)) -(define-vop (fast-logxor-mod64-c/fixnum=>fixnum - fast-logxor-c/fixnum=>fixnum) - (:translate logxor-mod64)) - (define-source-transform logeqv (&rest args) (if (oddp (length args)) `(logxor ,@args) @@ -1398,7 +1402,9 @@ (define-full-reffer bignum-ref * bignum-digits-offset other-pointer-lowtag (unsigned-reg) unsigned-num sb!bignum:%bignum-ref) - +(define-full-reffer+offset bignum--ref-with-offset * bignum-digits-offset + other-pointer-lowtag (unsigned-reg) unsigned-num + sb!bignum:%bignum-ref-with-offset) (define-full-setter bignum-set * bignum-digits-offset other-pointer-lowtag (unsigned-reg) unsigned-num sb!bignum:%bignum-set) @@ -1415,19 +1421,19 @@ ;;; For add and sub with carry the sc of carry argument is any-reg so -;;; the it may be passed as a fixnum or word and thus may be 0, 1, or -;;; 4. This is easy to deal with and may save a fixnum-word +;;; that it may be passed as a fixnum or word and thus may be 0, 1, or +;;; 8. This is easy to deal with and may save a fixnum-word ;;; conversion. (define-vop (add-w/carry) (:translate sb!bignum:%add-with-carry) (:policy :fast-safe) (:args (a :scs (unsigned-reg) :target result) - (b :scs (unsigned-reg unsigned-stack) :to :eval) - (c :scs (any-reg) :target temp)) + (b :scs (unsigned-reg unsigned-stack) :to :eval) + (c :scs (any-reg) :target temp)) (:arg-types unsigned-num unsigned-num positive-fixnum) (:temporary (:sc any-reg :from (:argument 2) :to :eval) temp) (:results (result :scs (unsigned-reg) :from (:argument 0)) - (carry :scs (unsigned-reg))) + (carry :scs (unsigned-reg))) (:result-types unsigned-num positive-fixnum) (:generator 4 (move result a) @@ -1437,40 +1443,39 @@ (inst mov carry 0) (inst adc carry carry))) -;;; Note: the borrow is the oppostite of the x86 convention - 1 for no -;;; borrow and 0 for a borrow. +;;; Note: the borrow is 1 for no borrow and 0 for a borrow, the opposite +;;; of the x86-64 convention. (define-vop (sub-w/borrow) (:translate sb!bignum:%subtract-with-borrow) (:policy :fast-safe) (:args (a :scs (unsigned-reg) :to :eval :target result) - (b :scs (unsigned-reg unsigned-stack) :to :result) - (c :scs (any-reg control-stack))) + (b :scs (unsigned-reg unsigned-stack) :to :result) + (c :scs (any-reg control-stack))) (:arg-types unsigned-num unsigned-num positive-fixnum) (:results (result :scs (unsigned-reg) :from :eval) - (borrow :scs (unsigned-reg))) + (borrow :scs (unsigned-reg))) (:result-types unsigned-num positive-fixnum) (:generator 5 (inst cmp c 1) ; Set the carry flag to 1 if c=0 else to 0 (move result a) (inst sbb result b) - (inst mov borrow 0) - (inst adc borrow borrow) - (inst xor borrow 1))) + (inst mov borrow 1) + (inst sbb borrow 0))) (define-vop (bignum-mult-and-add-3-arg) (:translate sb!bignum:%multiply-and-add) (:policy :fast-safe) (:args (x :scs (unsigned-reg) :target eax) - (y :scs (unsigned-reg unsigned-stack)) - (carry-in :scs (unsigned-reg unsigned-stack))) + (y :scs (unsigned-reg unsigned-stack)) + (carry-in :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num unsigned-num) (:temporary (:sc unsigned-reg :offset eax-offset :from (:argument 0) - :to (:result 1) :target lo) eax) + :to (:result 1) :target lo) eax) (:temporary (:sc unsigned-reg :offset edx-offset :from (:argument 1) - :to (:result 0) :target hi) edx) + :to (:result 0) :target hi) edx) (:results (hi :scs (unsigned-reg)) - (lo :scs (unsigned-reg))) + (lo :scs (unsigned-reg))) (:result-types unsigned-num unsigned-num) (:generator 20 (move eax x) @@ -1484,16 +1489,16 @@ (:translate sb!bignum:%multiply-and-add) (:policy :fast-safe) (:args (x :scs (unsigned-reg) :target eax) - (y :scs (unsigned-reg unsigned-stack)) - (prev :scs (unsigned-reg unsigned-stack)) - (carry-in :scs (unsigned-reg unsigned-stack))) + (y :scs (unsigned-reg unsigned-stack)) + (prev :scs (unsigned-reg unsigned-stack)) + (carry-in :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num unsigned-num unsigned-num) (:temporary (:sc unsigned-reg :offset eax-offset :from (:argument 0) - :to (:result 1) :target lo) eax) + :to (:result 1) :target lo) eax) (:temporary (:sc unsigned-reg :offset edx-offset :from (:argument 1) - :to (:result 0) :target hi) edx) + :to (:result 0) :target hi) edx) (:results (hi :scs (unsigned-reg)) - (lo :scs (unsigned-reg))) + (lo :scs (unsigned-reg))) (:result-types unsigned-num unsigned-num) (:generator 20 (move eax x) @@ -1510,14 +1515,14 @@ (:translate sb!bignum:%multiply) (:policy :fast-safe) (:args (x :scs (unsigned-reg) :target eax) - (y :scs (unsigned-reg unsigned-stack))) + (y :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num) (:temporary (:sc unsigned-reg :offset eax-offset :from (:argument 0) - :to (:result 1) :target lo) eax) + :to (:result 1) :target lo) eax) (:temporary (:sc unsigned-reg :offset edx-offset :from (:argument 1) - :to (:result 0) :target hi) edx) + :to (:result 0) :target hi) edx) (:results (hi :scs (unsigned-reg)) - (lo :scs (unsigned-reg))) + (lo :scs (unsigned-reg))) (:result-types unsigned-num unsigned-num) (:generator 20 (move eax x) @@ -1534,9 +1539,9 @@ (:args (fixnum :scs (any-reg control-stack) :target digit)) (:arg-types tagged-num) (:results (digit :scs (unsigned-reg) - :load-if (not (and (sc-is fixnum control-stack) - (sc-is digit unsigned-stack) - (location= fixnum digit))))) + :load-if (not (and (sc-is fixnum control-stack) + (sc-is digit unsigned-stack) + (location= fixnum digit))))) (:result-types unsigned-num) (:generator 1 (move digit fixnum) @@ -1546,15 +1551,15 @@ (:translate sb!bignum:%floor) (:policy :fast-safe) (:args (div-high :scs (unsigned-reg) :target edx) - (div-low :scs (unsigned-reg) :target eax) - (divisor :scs (unsigned-reg unsigned-stack))) + (div-low :scs (unsigned-reg) :target eax) + (divisor :scs (unsigned-reg unsigned-stack))) (:arg-types unsigned-num unsigned-num unsigned-num) (:temporary (:sc unsigned-reg :offset eax-offset :from (:argument 1) - :to (:result 0) :target quo) eax) + :to (:result 0) :target quo) eax) (:temporary (:sc unsigned-reg :offset edx-offset :from (:argument 0) - :to (:result 1) :target rem) edx) + :to (:result 1) :target rem) edx) (:results (quo :scs (unsigned-reg)) - (rem :scs (unsigned-reg))) + (rem :scs (unsigned-reg))) (:result-types unsigned-num unsigned-num) (:generator 300 (move edx div-high) @@ -1569,9 +1574,9 @@ (:args (digit :scs (unsigned-reg unsigned-stack) :target res)) (:arg-types unsigned-num) (:results (res :scs (any-reg signed-reg) - :load-if (not (and (sc-is digit unsigned-stack) - (sc-is res control-stack signed-stack) - (location= digit res))))) + :load-if (not (and (sc-is digit unsigned-stack) + (sc-is res control-stack signed-stack) + (location= digit res))))) (:result-types signed-num) (:generator 1 (move res digit) @@ -1582,18 +1587,32 @@ (:translate sb!bignum:%ashr) (:policy :fast-safe) (:args (digit :scs (unsigned-reg unsigned-stack) :target result) - (count :scs (unsigned-reg) :target ecx)) + (count :scs (unsigned-reg) :target ecx)) (:arg-types unsigned-num positive-fixnum) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 1)) ecx) (:results (result :scs (unsigned-reg) :from (:argument 0) - :load-if (not (and (sc-is result unsigned-stack) - (location= digit result))))) + :load-if (not (and (sc-is result unsigned-stack) + (location= digit result))))) (:result-types unsigned-num) - (:generator 1 + (:generator 2 (move result digit) (move ecx count) (inst sar result :cl))) +(define-vop (digit-ashr/c) + (:translate sb!bignum:%ashr) + (:policy :fast-safe) + (:args (digit :scs (unsigned-reg unsigned-stack) :target result)) + (:arg-types unsigned-num (:constant (integer 0 63))) + (:info count) + (:results (result :scs (unsigned-reg) :from (:argument 0) + :load-if (not (and (sc-is result unsigned-stack) + (location= digit result))))) + (:result-types unsigned-num) + (:generator 1 + (move result digit) + (inst sar result count))) + (define-vop (digit-lshr digit-ashr) (:translate sb!bignum:%digit-logical-shift-right) (:generator 1 @@ -1638,8 +1657,8 @@ (give-up-ir1-transform)))) (deftransform * ((x y) - ((unsigned-byte 64) (constant-arg (unsigned-byte 64))) - (unsigned-byte 64)) + ((unsigned-byte 64) (constant-arg (unsigned-byte 64))) + (unsigned-byte 64)) "recode as leas, shifts and adds" (let ((y (lvar-value y))) (*-transformer y))) @@ -1651,8 +1670,8 @@ (*-transformer y))) (deftransform * ((x y) - ((signed-byte 61) (constant-arg (unsigned-byte 64))) - (signed-byte 61)) + ((signed-byte 61) (constant-arg (unsigned-byte 64))) + (signed-byte 61)) "recode as leas, shifts and adds" (let ((y (lvar-value y))) (*-transformer y)))