X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fx86%2Fcall.lisp;h=1b7d900a3e9154444c5e53dc1e27bb78afa17a12;hb=a6b91f356da1b5ae2987f79db9bd137970512959;hp=2af370203f10d0b5c06a0471b7343629b300596b;hpb=34dd23563d2f5cf05c72b971da0d0b065a09bf2a;p=sbcl.git diff --git a/src/compiler/x86/call.lisp b/src/compiler/x86/call.lisp index 2af3702..1b7d900 100644 --- a/src/compiler/x86/call.lisp +++ b/src/compiler/x86/call.lisp @@ -19,7 +19,7 @@ (declare (type unsigned-byte n)) (if (< n register-arg-count) (make-wired-tn *backend-t-primitive-type* descriptor-reg-sc-number - (nth n *register-arg-offsets*)) + (nth n *register-arg-offsets*)) (make-wired-tn *backend-t-primitive-type* control-stack-sc-number n))) ;;; Make a passing location TN for a local call return PC. @@ -29,10 +29,10 @@ (!def-vm-support-routine make-return-pc-passing-location (standard) (declare (ignore standard)) (make-wired-tn (primitive-type-or-lose 'system-area-pointer) - sap-stack-sc-number return-pc-save-offset)) + sap-stack-sc-number return-pc-save-offset)) -;;; Similar to Make-Return-PC-Passing-Location, but makes a location -;;; to pass Old-FP in. +;;; This is similar to MAKE-RETURN-PC-PASSING-LOCATION, but makes a +;;; location to pass OLD-FP in. ;;; ;;; This is wired in both the standard and the local-call conventions, ;;; because we want to be able to assume it's always there. Besides, @@ -41,25 +41,24 @@ (!def-vm-support-routine make-old-fp-passing-location (standard) (declare (ignore standard)) (make-wired-tn *fixnum-primitive-type* control-stack-sc-number - ocfp-save-offset)) + ocfp-save-offset)) -;;; Make the TNs used to hold Old-FP and Return-PC within the current +;;; Make the TNs used to hold OLD-FP and RETURN-PC within the current ;;; function. We treat these specially so that the debugger can find ;;; them at a known location. ;;; ;;; Without using a save-tn - which does not make much sense if it is -;;; wire to the stack? -(!def-vm-support-routine make-old-fp-save-location (env) +;;; wired to the stack? +(!def-vm-support-routine make-old-fp-save-location (physenv) (physenv-debug-live-tn (make-wired-tn *fixnum-primitive-type* - control-stack-sc-number - ocfp-save-offset) - env)) - -(!def-vm-support-routine make-return-pc-save-location (env) + control-stack-sc-number + ocfp-save-offset) + physenv)) +(!def-vm-support-routine make-return-pc-save-location (physenv) (physenv-debug-live-tn (make-wired-tn (primitive-type-or-lose 'system-area-pointer) - sap-stack-sc-number return-pc-save-offset) - env)) + sap-stack-sc-number return-pc-save-offset) + physenv)) ;;; Make a TN for the standard argument count passing location. We only ;;; need to make the standard location, since a count is never passed when we @@ -82,7 +81,7 @@ ;;; continuation within a function. (!def-vm-support-routine make-unknown-values-locations () (list (make-stack-pointer-tn) - (make-normal-tn *fixnum-primitive-type*))) + (make-normal-tn *fixnum-primitive-type*))) ;;; This function is called by the ENTRY-ANALYZE phase, allowing ;;; VM-dependent initialization of the IR2-COMPONENT structure. We @@ -102,7 +101,7 @@ ;; we'll just live with this ugliness. -- WHN 2002-01-02 (dotimes (i (1+ code-constants-offset)) (vector-push-extend nil - (ir2-component-constants (component-info component)))) + (ir2-component-constants (component-info component)))) (values)) ;;;; frame hackery @@ -134,7 +133,7 @@ ;; The start of the actual code. ;; Save the return-pc. - (popw ebp-tn (- (1+ return-pc-save-offset))) + (popw ebp-tn (frame-word-offset return-pc-save-offset)) ;; If copy-more-arg follows it will allocate the correct stack ;; size. The stack is not allocated first here as this may expose @@ -142,9 +141,9 @@ (unless copy-more-arg-follows ;; The args fit within the frame so just allocate the frame. (inst lea esp-tn - (make-ea :dword :base ebp-tn - :disp (- (* n-word-bytes - (max 3 (sb-allocated-size 'stack))))))) + (make-ea :dword :base ebp-tn + :disp (- (* n-word-bytes + (max 3 (sb-allocated-size 'stack))))))) (trace-table-entry trace-table-normal))) @@ -153,7 +152,7 @@ ;;; callee (who has the same size stack as us). (define-vop (allocate-frame) (:results (res :scs (any-reg control-stack)) - (nfp)) + (nfp)) (:info callee) (:ignore nfp callee) (:generator 2 @@ -172,12 +171,12 @@ (inst sub esp-tn (* (max nargs 3) n-word-bytes)))) ;;; Emit code needed at the return-point from an unknown-values call -;;; for a fixed number of values. Values is the head of the TN-Ref +;;; for a fixed number of values. Values is the head of the TN-REF ;;; list for the locations that the values are to be received into. ;;; Nvals is the number of values that are to be received (should ;;; equal the length of Values). ;;; -;;; Move-Temp is a Descriptor-Reg TN used as a temporary. +;;; MOVE-TEMP is a DESCRIPTOR-REG TN used as a temporary. ;;; ;;; This code exploits the fact that in the unknown-values convention, ;;; a single value return returns at the return PC + 2, whereas a @@ -197,25 +196,32 @@ ;;; returned, regardless of the number of values desired. (defun default-unknown-values (vop values nvals) (declare (type (or tn-ref null) values) - (type unsigned-byte nvals)) + (type unsigned-byte nvals)) (cond ((<= nvals 1) (note-this-location vop :single-value-return) - (inst mov esp-tn ebx-tn)) + (let ((single-value (gen-label))) + (cond + ((member :cmov *backend-subfeatures*) + (inst cmov :c esp-tn ebx-tn)) + (t + (inst jmp :nc single-value) + (inst mov esp-tn ebx-tn) + (emit-label single-value))))) ((<= nvals register-arg-count) (let ((regs-defaulted (gen-label))) (note-this-location vop :unknown-return) - (inst jmp-short regs-defaulted) + (inst jmp :c regs-defaulted) ;; Default the unsuppled registers. (let* ((2nd-tn-ref (tn-ref-across values)) - (2nd-tn (tn-ref-tn 2nd-tn-ref))) - (inst mov 2nd-tn nil-value) - (when (> nvals 2) - (loop - for tn-ref = (tn-ref-across 2nd-tn-ref) - then (tn-ref-across tn-ref) - for count from 2 below register-arg-count - do (inst mov (tn-ref-tn tn-ref) 2nd-tn)))) + (2nd-tn (tn-ref-tn 2nd-tn-ref))) + (inst mov 2nd-tn nil-value) + (when (> nvals 2) + (loop + for tn-ref = (tn-ref-across 2nd-tn-ref) + then (tn-ref-across tn-ref) + for count from 2 below register-arg-count + do (inst mov (tn-ref-tn tn-ref) 2nd-tn)))) (inst mov ebx-tn esp-tn) (emit-label regs-defaulted) (inst mov esp-tn ebx-tn))) @@ -225,18 +231,18 @@ ;; NVALS=6 that is 73/89 bytes, and for NVALS=7 that is 87/107 ;; bytes which is likely better than using the blt below. (let ((regs-defaulted (gen-label)) - (defaulting-done (gen-label)) - (default-stack-slots (gen-label))) + (defaulting-done (gen-label)) + (default-stack-slots (gen-label))) (note-this-location vop :unknown-return) ;; Branch off to the MV case. - (inst jmp-short regs-defaulted) + (inst jmp :c regs-defaulted) ;; Do the single value case. ;; Default the register args (inst mov eax-tn nil-value) (do ((i 1 (1+ i)) - (val (tn-ref-across values) (tn-ref-across val))) - ((= i (min nvals register-arg-count))) - (inst mov (tn-ref-tn val) eax-tn)) + (val (tn-ref-across values) (tn-ref-across val))) + ((= i (min nvals register-arg-count))) + (inst mov (tn-ref-tn val) eax-tn)) ;; Fake other registers so it looks like we returned with all the ;; registers filled in. @@ -249,45 +255,45 @@ (inst mov eax-tn nil-value) (storew edx-tn ebx-tn -1) (collect ((defaults)) - (do ((i register-arg-count (1+ i)) - (val (do ((i 0 (1+ i)) - (val values (tn-ref-across val))) - ((= i register-arg-count) val)) - (tn-ref-across val))) - ((null val)) - (let ((default-lab (gen-label)) - (tn (tn-ref-tn val))) - (defaults (cons default-lab tn)) - - (inst cmp ecx-tn (fixnumize i)) - (inst jmp :be default-lab) - (loadw edx-tn ebx-tn (- (1+ i))) - (inst mov tn edx-tn))) - - (emit-label defaulting-done) - (loadw edx-tn ebx-tn -1) - (move esp-tn ebx-tn) - - (let ((defaults (defaults))) - (when defaults - (assemble (*elsewhere*) - (trace-table-entry trace-table-fun-prologue) - (emit-label default-stack-slots) - (dolist (default defaults) - (emit-label (car default)) - (inst mov (cdr default) eax-tn)) - (inst jmp defaulting-done) - (trace-table-entry trace-table-normal))))))) + (do ((i register-arg-count (1+ i)) + (val (do ((i 0 (1+ i)) + (val values (tn-ref-across val))) + ((= i register-arg-count) val)) + (tn-ref-across val))) + ((null val)) + (let ((default-lab (gen-label)) + (tn (tn-ref-tn val))) + (defaults (cons default-lab tn)) + + (inst cmp ecx-tn (fixnumize i)) + (inst jmp :be default-lab) + (loadw edx-tn ebx-tn (frame-word-offset i)) + (inst mov tn edx-tn))) + + (emit-label defaulting-done) + (loadw edx-tn ebx-tn -1) + (move esp-tn ebx-tn) + + (let ((defaults (defaults))) + (when defaults + (assemble (*elsewhere*) + (trace-table-entry trace-table-fun-prologue) + (emit-label default-stack-slots) + (dolist (default defaults) + (emit-label (car default)) + (inst mov (cdr default) eax-tn)) + (inst jmp defaulting-done) + (trace-table-entry trace-table-normal))))))) (t ;; 91 bytes for this branch. (let ((regs-defaulted (gen-label)) - (restore-edi (gen-label)) - (no-stack-args (gen-label)) - (default-stack-vals (gen-label)) - (count-okay (gen-label))) + (restore-edi (gen-label)) + (no-stack-args (gen-label)) + (default-stack-vals (gen-label)) + (count-okay (gen-label))) (note-this-location vop :unknown-return) ;; Branch off to the MV case. - (inst jmp-short regs-defaulted) + (inst jmp :c regs-defaulted) ;; Default the register args, and set up the stack as if we ;; entered the MV return point. @@ -299,8 +305,8 @@ ;; Compute a pointer to where to put the [defaulted] stack values. (emit-label no-stack-args) (inst lea edi-tn - (make-ea :dword :base ebp-tn - :disp (* (- (1+ register-arg-count)) n-word-bytes))) + (make-ea :dword :base ebp-tn + :disp (frame-byte-offset register-arg-count))) ;; Load EAX with NIL so we can quickly store it, and set up ;; stuff for the loop. (inst mov eax-tn nil-value) @@ -313,7 +319,7 @@ ;; and then default the remaining stack arguments. (emit-label regs-defaulted) ;; Save EDI. - (storew edi-tn ebx-tn (- (1+ 1))) + (storew edi-tn ebx-tn (frame-word-offset 1)) ;; Compute the number of stack arguments, and if it's zero or ;; less, don't copy any stack arguments. (inst sub ecx-tn (fixnumize register-arg-count)) @@ -328,27 +334,27 @@ (inst mov eax-tn ecx-tn) ;; Compute a pointer to where the stack args go. (inst lea edi-tn - (make-ea :dword :base ebp-tn - :disp (* (- (1+ register-arg-count)) n-word-bytes))) + (make-ea :dword :base ebp-tn + :disp (frame-byte-offset register-arg-count))) ;; Save ESI, and compute a pointer to where the args come from. - (storew esi-tn ebx-tn (- (1+ 2))) + (storew esi-tn ebx-tn (frame-word-offset 2)) (inst lea esi-tn - (make-ea :dword :base ebx-tn - :disp (* (- (1+ register-arg-count)) n-word-bytes))) + (make-ea :dword :base ebx-tn + :disp (frame-byte-offset register-arg-count))) ;; Do the copy. - (inst shr ecx-tn word-shift) ; make word count + (inst shr ecx-tn word-shift) ; make word count (inst std) (inst rep) (inst movs :dword) ;; Restore ESI. - (loadw esi-tn ebx-tn (- (1+ 2))) + (loadw esi-tn ebx-tn (frame-word-offset 2)) ;; Now we have to default the remaining args. Find out how many. (inst sub eax-tn (fixnumize (- nvals register-arg-count))) (inst neg eax-tn) ;; If none, then just blow out of here. (inst jmp :le restore-edi) (inst mov ecx-tn eax-tn) - (inst shr ecx-tn word-shift) ; word count + (inst shr ecx-tn word-shift) ; word count ;; Load EAX with NIL for fast storing. (inst mov eax-tn nil-value) ;; Do the store. @@ -357,8 +363,9 @@ (inst stos eax-tn) ;; Restore EDI, and reset the stack. (emit-label restore-edi) - (loadw edi-tn ebx-tn (- (1+ 1))) - (inst mov esp-tn ebx-tn)))) + (loadw edi-tn ebx-tn (frame-word-offset 1)) + (inst mov esp-tn ebx-tn) + (inst cld)))) (values)) ;;;; unknown values receiving @@ -383,11 +390,14 @@ (defun receive-unknown-values (args nargs start count) (declare (type tn args nargs start count)) (let ((variable-values (gen-label)) - (done (gen-label))) - (inst jmp-short variable-values) - - (inst mov start esp-tn) - (inst push (first *register-arg-tns*)) + (done (gen-label))) + (inst jmp :c variable-values) + + (cond ((location= start (first *register-arg-tns*)) + (inst push (first *register-arg-tns*)) + (inst lea start (make-ea :dword :base esp-tn :disp 4))) + (t (inst mov start esp-tn) + (inst push (first *register-arg-tns*)))) (inst mov count (fixnumize 1)) (inst jmp done) @@ -409,13 +419,13 @@ ;;; handles is allocation of the result temporaries. (define-vop (unknown-values-receiver) (:temporary (:sc descriptor-reg :offset ebx-offset - :from :eval :to (:result 0)) - values-start) + :from :eval :to (:result 0)) + values-start) (:temporary (:sc any-reg :offset ecx-offset - :from :eval :to (:result 1)) - nvals) + :from :eval :to (:result 1)) + nvals) (:results (start :scs (any-reg control-stack)) - (count :scs (any-reg control-stack)))) + (count :scs (any-reg control-stack)))) ;;;; local call with unknown values convention return @@ -440,8 +450,8 @@ ;;; function. (define-vop (call-local) (:args (fp) - (nfp) - (args :more t)) + (nfp) + (args :more t)) (:results (values :more t)) (:save-p t) (:move-args :local-call) @@ -455,18 +465,18 @@ (let ((ret-tn (callee-return-pc-tn callee))) #+nil (format t "*call-local ~S; tn-kind ~S; tn-save-tn ~S; its tn-kind ~S~%" - ret-tn (sb!c::tn-kind ret-tn) (sb!c::tn-save-tn ret-tn) - (sb!c::tn-kind (sb!c::tn-save-tn ret-tn))) + ret-tn (sb!c::tn-kind ret-tn) (sb!c::tn-save-tn ret-tn) + (sb!c::tn-kind (sb!c::tn-save-tn ret-tn))) ;; Is the return-pc on the stack or in a register? (sc-case ret-tn - ((sap-stack) - #+nil (format t "*call-local: ret-tn on stack; offset=~S~%" - (tn-offset ret-tn)) - (storew (make-fixup nil :code-object return) - ebp-tn (- (1+ (tn-offset ret-tn))))) - ((sap-reg) - (inst lea ret-tn (make-fixup nil :code-object return))))) + ((sap-stack) + #+nil (format t "*call-local: ret-tn on stack; offset=~S~%" + (tn-offset ret-tn)) + (storew (make-fixup nil :code-object return) + ebp-tn (frame-word-offset (tn-offset ret-tn)))) + ((sap-reg) + (inst lea ret-tn (make-fixup nil :code-object return))))) (note-this-location vop :call-site) (inst jmp target) @@ -479,8 +489,8 @@ ;;; glob and the number of values received. (define-vop (multiple-call-local unknown-values-receiver) (:args (fp) - (nfp) - (args :more t)) + (nfp) + (args :more t)) (:save-p t) (:move-args :local-call) (:info save callee target) @@ -493,20 +503,20 @@ (let ((ret-tn (callee-return-pc-tn callee))) #+nil (format t "*multiple-call-local ~S; tn-kind ~S; tn-save-tn ~S; its tn-kind ~S~%" - ret-tn (sb!c::tn-kind ret-tn) (sb!c::tn-save-tn ret-tn) - (sb!c::tn-kind (sb!c::tn-save-tn ret-tn))) + ret-tn (sb!c::tn-kind ret-tn) (sb!c::tn-save-tn ret-tn) + (sb!c::tn-kind (sb!c::tn-save-tn ret-tn))) ;; Is the return-pc on the stack or in a register? (sc-case ret-tn - ((sap-stack) - #+nil (format t "*multiple-call-local: ret-tn on stack; offset=~S~%" - (tn-offset ret-tn)) - ;; Stack - (storew (make-fixup nil :code-object return) - ebp-tn (- (1+ (tn-offset ret-tn))))) - ((sap-reg) - ;; Register - (inst lea ret-tn (make-fixup nil :code-object return))))) + ((sap-stack) + #+nil (format t "*multiple-call-local: ret-tn on stack; offset=~S~%" + (tn-offset ret-tn)) + ;; Stack + (storew (make-fixup nil :code-object return) + ebp-tn (frame-word-offset (tn-offset ret-tn)))) + ((sap-reg) + ;; Register + (inst lea ret-tn (make-fixup nil :code-object return))))) (note-this-location vop :call-site) (inst jmp target) @@ -525,8 +535,8 @@ ;;; we use MAYBE-LOAD-STACK-TN. (define-vop (known-call-local) (:args (fp) - (nfp) - (args :more t)) + (nfp) + (args :more t)) (:results (res :more t)) (:move-args :local-call) (:save-p t) @@ -541,20 +551,20 @@ #+nil (format t "*known-call-local ~S; tn-kind ~S; tn-save-tn ~S; its tn-kind ~S~%" - ret-tn (sb!c::tn-kind ret-tn) (sb!c::tn-save-tn ret-tn) - (sb!c::tn-kind (sb!c::tn-save-tn ret-tn))) + ret-tn (sb!c::tn-kind ret-tn) (sb!c::tn-save-tn ret-tn) + (sb!c::tn-kind (sb!c::tn-save-tn ret-tn))) ;; Is the return-pc on the stack or in a register? (sc-case ret-tn - ((sap-stack) - #+nil (format t "*known-call-local: ret-tn on stack; offset=~S~%" - (tn-offset ret-tn)) - ;; Stack - (storew (make-fixup nil :code-object return) - ebp-tn (- (1+ (tn-offset ret-tn))))) - ((sap-reg) - ;; Register - (inst lea ret-tn (make-fixup nil :code-object return))))) + ((sap-stack) + #+nil (format t "*known-call-local: ret-tn on stack; offset=~S~%" + (tn-offset ret-tn)) + ;; Stack + (storew (make-fixup nil :code-object return) + ebp-tn (frame-word-offset (tn-offset ret-tn)))) + ((sap-reg) + ;; Register + (inst lea ret-tn (make-fixup nil :code-object return))))) (note-this-location vop :call-site) (inst jmp target) @@ -572,8 +582,8 @@ #+nil (define-vop (known-return) (:args (old-fp) - (return-pc :scs (any-reg immediate-stack) :target rpc) - (vals :more t)) + (return-pc :scs (any-reg immediate-stack) :target rpc) + (vals :more t)) (:move-args :known-return) (:info val-locs) (:temporary (:sc unsigned-reg :from (:argument 1)) rpc) @@ -606,8 +616,8 @@ ;;; The return-pc may be in a register or on the stack in any slot. (define-vop (known-return) (:args (old-fp) - (return-pc) - (vals :more t)) + (return-pc) + (vals :more t)) (:move-args :known-return) (:info val-locs) (:ignore val-locs vals) @@ -616,42 +626,42 @@ (trace-table-entry trace-table-fun-epilogue) #+nil (format t "*known-return: old-fp ~S, tn-kind ~S; ~S ~S~%" - old-fp (sb!c::tn-kind old-fp) (sb!c::tn-save-tn old-fp) - (sb!c::tn-kind (sb!c::tn-save-tn old-fp))) + old-fp (sb!c::tn-kind old-fp) (sb!c::tn-save-tn old-fp) + (sb!c::tn-kind (sb!c::tn-save-tn old-fp))) #+nil (format t "*known-return: return-pc ~S, tn-kind ~S; ~S ~S~%" - return-pc (sb!c::tn-kind return-pc) - (sb!c::tn-save-tn return-pc) - (sb!c::tn-kind (sb!c::tn-save-tn return-pc))) + return-pc (sb!c::tn-kind return-pc) + (sb!c::tn-save-tn return-pc) + (sb!c::tn-kind (sb!c::tn-save-tn return-pc))) ;; return-pc may be either in a register or on the stack. (sc-case return-pc ((sap-reg) (sc-case old-fp - ((control-stack) - - #+nil (format t "*known-return: old-fp ~S on stack; offset=~S~%" - old-fp (tn-offset old-fp)) - - (cond ((zerop (tn-offset old-fp)) - ;; Zot all of the stack except for the old-fp. - (inst lea esp-tn (make-ea :dword :base ebp-tn - :disp (- (* (1+ ocfp-save-offset) - n-word-bytes)))) - ;; Restore the old fp from its save location on the stack, - ;; and zot the stack. - (inst pop ebp-tn)) - - (t - (cerror "Continue any-way" - "VOP return-local doesn't work if old-fp (in slot %s) is not in slot 0" - (tn-offset old-fp))))) - - ((any-reg descriptor-reg) - ;; Zot all the stack. - (move esp-tn ebp-tn) - ;; Restore the old-fp. - (move ebp-tn old-fp))) + ((control-stack) + + #+nil (format t "*known-return: old-fp ~S on stack; offset=~S~%" + old-fp (tn-offset old-fp)) + + (cond ((zerop (tn-offset old-fp)) + ;; Zot all of the stack except for the old-fp. + (inst lea esp-tn (make-ea :dword :base ebp-tn + :disp (frame-byte-offset ocfp-save-offset))) + ;; Restore the old fp from its save location on the stack, + ;; and zot the stack. + (inst pop ebp-tn)) + + (t + (cerror "Continue anyway" + "VOP return-local doesn't work if old-fp (in slot ~ + ~S) is not in slot 0" + (tn-offset old-fp))))) + + ((any-reg descriptor-reg) + ;; Zot all the stack. + (move esp-tn ebp-tn) + ;; Restore the old-fp. + (move ebp-tn old-fp))) ;; Return; return-pc is in a register. (inst jmp return-pc)) @@ -659,12 +669,12 @@ ((sap-stack) #+nil (format t "*known-return: return-pc ~S on stack; offset=~S~%" - return-pc (tn-offset return-pc)) + return-pc (tn-offset return-pc)) ;; Zot all of the stack except for the old-fp and return-pc. (inst lea esp-tn - (make-ea :dword :base ebp-tn - :disp (- (* (1+ (tn-offset return-pc)) n-word-bytes)))) + (make-ea :dword :base ebp-tn + :disp (frame-byte-offset (tn-offset return-pc)))) ;; Restore the old fp. old-fp may be either on the stack in its ;; save location or in a register, in either case this restores it. (move ebp-tn old-fp) @@ -714,187 +724,192 @@ ;;; passed as a more arg, but there is no new-FP, since the arguments ;;; have been set up in the current frame. (macrolet ((define-full-call (name named return variable) - (aver (not (and variable (eq return :tail)))) - `(define-vop (,name - ,@(when (eq return :unknown) - '(unknown-values-receiver))) - (:args - ,@(unless (eq return :tail) - '((new-fp :scs (any-reg) :to (:argument 1)))) - - (fun :scs (descriptor-reg control-stack) - :target eax :to (:argument 0)) - - ,@(when (eq return :tail) - '((old-fp) - (return-pc))) - - ,@(unless variable '((args :more t :scs (descriptor-reg))))) - - ,@(when (eq return :fixed) - '((:results (values :more t)))) - - (:save-p ,(if (eq return :tail) :compute-only t)) - - ,@(unless (or (eq return :tail) variable) - '((:move-args :full-call))) - - (:vop-var vop) - (:info - ,@(unless (or variable (eq return :tail)) '(arg-locs)) - ,@(unless variable '(nargs)) - ,@(when (eq return :fixed) '(nvals))) - - (:ignore - ,@(unless (or variable (eq return :tail)) '(arg-locs)) - ,@(unless variable '(args))) - - ;; We pass either the fdefn object (for named call) or - ;; the actual function object (for unnamed call) in - ;; EAX. With named call, closure-tramp will replace it - ;; with the real function and invoke the real function - ;; for closures. Non-closures do not need this value, - ;; so don't care what shows up in it. - (:temporary - (:sc descriptor-reg - :offset eax-offset - :from (:argument 0) - :to :eval) - eax) - - ;; We pass the number of arguments in ECX. - (:temporary (:sc unsigned-reg :offset ecx-offset :to :eval) ecx) - - ;; With variable call, we have to load the - ;; register-args out of the (new) stack frame before - ;; doing the call. Therefore, we have to tell the - ;; lifetime stuff that we need to use them. - ,@(when variable - (mapcar (lambda (name offset) - `(:temporary (:sc descriptor-reg - :offset ,offset - :from (:argument 0) - :to :eval) - ,name)) - *register-arg-names* *register-arg-offsets*)) - - ,@(when (eq return :tail) - '((:temporary (:sc unsigned-reg - :from (:argument 1) - :to (:argument 2)) - old-fp-tmp))) - - (:generator ,(+ (if named 5 0) - (if variable 19 1) - (if (eq return :tail) 0 10) - 15 - (if (eq return :unknown) 25 0)) - (trace-table-entry trace-table-call-site) - - ;; This has to be done before the frame pointer is - ;; changed! EAX stores the 'lexical environment' needed - ;; for closures. - (move eax fun) - - - ,@(if variable - ;; For variable call, compute the number of - ;; arguments and move some of the arguments to - ;; registers. - (collect ((noise)) - ;; Compute the number of arguments. - (noise '(inst mov ecx new-fp)) - (noise '(inst sub ecx esp-tn)) - ;; Move the necessary args to registers, - ;; this moves them all even if they are - ;; not all needed. - (loop - for name in *register-arg-names* - for index downfrom -1 - do (noise `(loadw ,name new-fp ,index))) - (noise)) - '((if (zerop nargs) - (inst xor ecx ecx) - (inst mov ecx (fixnumize nargs))))) - ,@(cond ((eq return :tail) - '(;; Python has figured out what frame we should - ;; return to so might as well use that clue. - ;; This seems really important to the - ;; implementation of things like - ;; (without-interrupts ...) - ;; - ;; dtc; Could be doing a tail call from a - ;; known-local-call etc in which the old-fp - ;; or ret-pc are in regs or in non-standard - ;; places. If the passing location were - ;; wired to the stack in standard locations - ;; then these moves will be un-necessary; - ;; this is probably best for the x86. - (sc-case old-fp - ((control-stack) - (unless (= ocfp-save-offset - (tn-offset old-fp)) - ;; FIXME: FORMAT T for stale - ;; diagnostic output (several of - ;; them around here), ick - (format t "** tail-call old-fp not S0~%") - (move old-fp-tmp old-fp) - (storew old-fp-tmp - ebp-tn - (- (1+ ocfp-save-offset))))) - ((any-reg descriptor-reg) - (format t "** tail-call old-fp in reg not S0~%") - (storew old-fp - ebp-tn - (- (1+ ocfp-save-offset))))) - - ;; For tail call, we have to push the - ;; return-pc so that it looks like we CALLed - ;; despite the fact that we are going to JMP. - (inst push return-pc) - )) - (t - ;; For non-tail call, we have to save our - ;; frame pointer and install the new frame - ;; pointer. We can't load stack tns after this - ;; point. - `(;; Python doesn't seem to allocate a frame - ;; here which doesn't leave room for the - ;; ofp/ret stuff. - - ;; The variable args are on the stack and - ;; become the frame, but there may be <3 - ;; args and 3 stack slots are assumed - ;; allocate on the call. So need to ensure - ;; there are at least 3 slots. This hack - ;; just adds 3 more. - ,(if variable - '(inst sub esp-tn (fixnumize 3))) - - ;; Save the fp - (storew ebp-tn new-fp (- (1+ ocfp-save-offset))) - - (move ebp-tn new-fp) ; NB - now on new stack frame. - ))) - - (note-this-location vop :call-site) - - (inst ,(if (eq return :tail) 'jmp 'call) - (make-ea :dword :base eax - :disp ,(if named - '(- (* fdefn-raw-addr-slot - n-word-bytes) - other-pointer-lowtag) - '(- (* closure-fun-slot n-word-bytes) - fun-pointer-lowtag)))) - ,@(ecase return - (:fixed - '((default-unknown-values vop values nvals))) - (:unknown - '((note-this-location vop :unknown-return) - (receive-unknown-values values-start nvals start count))) - (:tail)) - (trace-table-entry trace-table-normal))))) + (aver (not (and variable (eq return :tail)))) + `(define-vop (,name + ,@(when (eq return :unknown) + '(unknown-values-receiver))) + (:args + ,@(unless (eq return :tail) + '((new-fp :scs (any-reg) :to (:argument 1)))) + + (fun :scs (descriptor-reg control-stack) + :target eax :to (:argument 0)) + + ,@(when (eq return :tail) + '((old-fp) + (return-pc))) + + ,@(unless variable '((args :more t :scs (descriptor-reg))))) + + ,@(when (eq return :fixed) + '((:results (values :more t)))) + + (:save-p ,(if (eq return :tail) :compute-only t)) + + ,@(unless (or (eq return :tail) variable) + '((:move-args :full-call))) + + (:vop-var vop) + (:info + ,@(unless (or variable (eq return :tail)) '(arg-locs)) + ,@(unless variable '(nargs)) + ,@(when (eq return :fixed) '(nvals)) + step-instrumenting) + + (:ignore + ,@(unless (or variable (eq return :tail)) '(arg-locs)) + ,@(unless variable '(args))) + + ;; We pass either the fdefn object (for named call) or + ;; the actual function object (for unnamed call) in + ;; EAX. With named call, closure-tramp will replace it + ;; with the real function and invoke the real function + ;; for closures. Non-closures do not need this value, + ;; so don't care what shows up in it. + (:temporary + (:sc descriptor-reg + :offset eax-offset + :from (:argument 0) + :to :eval) + eax) + + ;; We pass the number of arguments in ECX. + (:temporary (:sc unsigned-reg :offset ecx-offset :to :eval) ecx) + + ;; With variable call, we have to load the + ;; register-args out of the (new) stack frame before + ;; doing the call. Therefore, we have to tell the + ;; lifetime stuff that we need to use them. + ,@(when variable + (mapcar (lambda (name offset) + `(:temporary (:sc descriptor-reg + :offset ,offset + :from (:argument 0) + :to :eval) + ,name)) + *register-arg-names* *register-arg-offsets*)) + + ,@(when (eq return :tail) + '((:temporary (:sc unsigned-reg + :from (:argument 1) + :to (:argument 2)) + old-fp-tmp))) + + (:generator ,(+ (if named 5 0) + (if variable 19 1) + (if (eq return :tail) 0 10) + 15 + (if (eq return :unknown) 25 0)) + (trace-table-entry trace-table-call-site) + + ;; This has to be done before the frame pointer is + ;; changed! EAX stores the 'lexical environment' needed + ;; for closures. + (move eax fun) + + + ,@(if variable + ;; For variable call, compute the number of + ;; arguments and move some of the arguments to + ;; registers. + (collect ((noise)) + ;; Compute the number of arguments. + (noise '(inst mov ecx new-fp)) + (noise '(inst sub ecx esp-tn)) + ;; Move the necessary args to registers, + ;; this moves them all even if they are + ;; not all needed. + (loop + for name in *register-arg-names* + for index downfrom -1 + do (noise `(loadw ,name new-fp ,index))) + (noise)) + '((if (zerop nargs) + (inst xor ecx ecx) + (inst mov ecx (fixnumize nargs))))) + ,@(cond ((eq return :tail) + '(;; Python has figured out what frame we should + ;; return to so might as well use that clue. + ;; This seems really important to the + ;; implementation of things like + ;; (without-interrupts ...) + ;; + ;; dtc; Could be doing a tail call from a + ;; known-local-call etc in which the old-fp + ;; or ret-pc are in regs or in non-standard + ;; places. If the passing location were + ;; wired to the stack in standard locations + ;; then these moves will be un-necessary; + ;; this is probably best for the x86. + (sc-case old-fp + ((control-stack) + (unless (= ocfp-save-offset + (tn-offset old-fp)) + ;; FIXME: FORMAT T for stale + ;; diagnostic output (several of + ;; them around here), ick + (format t "** tail-call old-fp not S0~%") + (move old-fp-tmp old-fp) + (storew old-fp-tmp + ebp-tn + (frame-word-offset ocfp-save-offset)))) + ((any-reg descriptor-reg) + (format t "** tail-call old-fp in reg not S0~%") + (storew old-fp + ebp-tn + (frame-word-offset ocfp-save-offset)))) + + ;; For tail call, we have to push the + ;; return-pc so that it looks like we CALLed + ;; despite the fact that we are going to JMP. + (inst push return-pc) + )) + (t + ;; For non-tail call, we have to save our + ;; frame pointer and install the new frame + ;; pointer. We can't load stack tns after this + ;; point. + `(;; Python doesn't seem to allocate a frame + ;; here which doesn't leave room for the + ;; ofp/ret stuff. + + ;; The variable args are on the stack and + ;; become the frame, but there may be <3 + ;; args and 3 stack slots are assumed + ;; allocate on the call. So need to ensure + ;; there are at least 3 slots. This hack + ;; just adds 3 more. + ,(if variable + '(inst sub esp-tn (fixnumize 3))) + + ;; Save the fp + (storew ebp-tn new-fp (frame-word-offset ocfp-save-offset)) + + (move ebp-tn new-fp) ; NB - now on new stack frame. + ))) + + (when step-instrumenting + (emit-single-step-test) + (inst jmp :eq DONE) + (inst break single-step-around-trap)) + DONE + + (note-this-location vop :call-site) + + (inst ,(if (eq return :tail) 'jmp 'call) + ,(if named + '(make-ea-for-object-slot eax fdefn-raw-addr-slot + other-pointer-lowtag) + '(make-ea-for-object-slot eax closure-fun-slot + fun-pointer-lowtag))) + ,@(ecase return + (:fixed + '((default-unknown-values vop values nvals))) + (:unknown + '((note-this-location vop :unknown-return) + (receive-unknown-values values-start nvals start count))) + (:tail)) + (trace-table-entry trace-table-normal))))) (define-full-call call nil :fixed nil) (define-full-call call-named t :fixed nil) @@ -911,9 +926,9 @@ ;;; routine. We just set things up so that it can find what it needs. (define-vop (tail-call-variable) (:args (args :scs (any-reg control-stack) :target esi) - (function :scs (descriptor-reg control-stack) :target eax) - (old-fp) - (ret-addr)) + (function :scs (descriptor-reg control-stack) :target eax) + (old-fp) + (ret-addr)) (:temporary (:sc unsigned-reg :offset esi-offset :from (:argument 0)) esi) (:temporary (:sc unsigned-reg :offset eax-offset :from (:argument 1)) eax) ; (:ignore ret-addr old-fp) @@ -925,11 +940,11 @@ ;; The following assumes that the return-pc and old-fp are on the ;; stack in their standard save locations - Check this. (unless (and (sc-is old-fp control-stack) - (= (tn-offset old-fp) ocfp-save-offset)) - (error "tail-call-variable: ocfp not on stack in standard save location?")) + (= (tn-offset old-fp) ocfp-save-offset)) + (error "tail-call-variable: ocfp not on stack in standard save location?")) (unless (and (sc-is ret-addr sap-stack) - (= (tn-offset ret-addr) return-pc-save-offset)) - (error "tail-call-variable: ret-addr not on stack in standard save location?")) + (= (tn-offset ret-addr) return-pc-save-offset)) + (error "tail-call-variable: ret-addr not on stack in standard save location?")) ;; And jump to the assembly routine. @@ -946,25 +961,67 @@ ;;; ;;; pfw--get wired-tn conflicts sometimes if register sc specd for args ;;; having problems targeting args to regs -- using temps instead. +;;; +;;; First off, modifying the return-pc defeats the branch-prediction +;;; optimizations on modern CPUs quite handily. Second, we can do all +;;; this without needing a temp register. Fixed the latter, at least. +;;; -- AB 2006/Feb/04 (define-vop (return-single) (:args (old-fp) - (return-pc) - (value)) - (:temporary (:sc unsigned-reg) ofp) - (:temporary (:sc unsigned-reg) ret) + (return-pc) + (value)) (:ignore value) (:generator 6 (trace-table-entry trace-table-fun-epilogue) - (move ret return-pc) - ;; Clear the control stack - (move ofp old-fp) - ;; Adjust the return address for the single value return. - (inst add ret 2) - ;; Restore the frame pointer. - (move esp-tn ebp-tn) - (move ebp-tn ofp) - ;; Out of here. - (inst jmp ret))) + ;; Code structure lifted from known-return. + (sc-case return-pc + ((sap-reg) + ;; return PC in register for some reason (local call?) + ;; we jmp to the return pc after fixing the stack and frame. + (sc-case old-fp + ((control-stack) + ;; ofp on stack must be in slot 0 (the traditional storage place). + ;; Drop the stack above it and pop it off. + (cond ((zerop (tn-offset old-fp)) + (inst lea esp-tn (make-ea :dword :base ebp-tn + :disp (frame-byte-offset ocfp-save-offset))) + (inst pop ebp-tn)) + (t + ;; Should this ever happen, we do the same as above, but + ;; using (tn-offset old-fp) instead of ocfp-save-offset + ;; (which is 0 anyway, see src/compiler/x86/vm.lisp) and + ;; then lea esp again against itself with a displacement + ;; of (* (tn-offset old-fp) n-word-bytes) to clear the + ;; rest of the stack. + (cerror "Continue anyway" + "VOP return-single doesn't work if old-fp (in slot ~S) is not in slot 0" (tn-offset old-fp))))) + ((any-reg descriptor-reg) + ;; ofp in reg, drop the stack and load the real fp. + (move esp-tn ebp-tn) + (move ebp-tn old-fp))) + + ;; Set single-value-return flag + (inst clc) + ;; And return + (inst jmp return-pc)) + + ((sap-stack) + ;; Note that this will only work right if, when old-fp is on + ;; the stack, it has a lower tn-offset than return-pc. One of + ;; the comments in known-return indicate that this is the case + ;; (in that it will be in its save location), but we may wish + ;; to assert that (in either the weaker or stronger forms). + ;; Should this ever not be the case, we should load old-fp + ;; into a temp reg while we fix the stack. + ;; Drop stack above return-pc + (inst lea esp-tn (make-ea :dword :base ebp-tn + :disp (frame-byte-offset (tn-offset return-pc)))) + ;; Set single-value return flag + (inst clc) + ;; Restore the old frame pointer + (move ebp-tn old-fp) + ;; And return, dropping the rest of the stack as we go. + (inst ret (* (tn-offset return-pc) n-word-bytes)))))) ;;; Do unknown-values return of a fixed (other than 1) number of ;;; values. The VALUES are required to be set up in the standard @@ -975,8 +1032,8 @@ ;;; the values, and jump directly to return-pc. (define-vop (return) (:args (old-fp) - (return-pc :to (:eval 1)) - (values :more t)) + (return-pc :to (:eval 1)) + (values :more t)) (:ignore values) (:info nvals) @@ -989,46 +1046,47 @@ ;; registers so that we can default the argument registers without ;; trashing return-pc. (:temporary (:sc unsigned-reg :offset (first *register-arg-offsets*) - :from :eval) a0) + :from :eval) a0) (:temporary (:sc unsigned-reg :offset (second *register-arg-offsets*) - :from :eval) a1) + :from :eval) a1) (:temporary (:sc unsigned-reg :offset (third *register-arg-offsets*) - :from :eval) a2) + :from :eval) a2) (:generator 6 (trace-table-entry trace-table-fun-epilogue) ;; Establish the values pointer and values count. (move ebx ebp-tn) (if (zerop nvals) - (inst xor ecx ecx) ; smaller + (inst xor ecx ecx) ; smaller (inst mov ecx (fixnumize nvals))) ;; Restore the frame pointer. (move ebp-tn old-fp) ;; Clear as much of the stack as possible, but not past the return ;; address. (inst lea esp-tn (make-ea :dword :base ebx - :disp (- (* (max nvals 2) n-word-bytes)))) + :disp (- (* (max nvals 2) n-word-bytes)))) ;; Pre-default any argument register that need it. (when (< nvals register-arg-count) (let* ((arg-tns (nthcdr nvals (list a0 a1 a2))) - (first (first arg-tns))) - (inst mov first nil-value) - (dolist (tn (cdr arg-tns)) - (inst mov tn first)))) + (first (first arg-tns))) + (inst mov first nil-value) + (dolist (tn (cdr arg-tns)) + (inst mov tn first)))) + ;; Set multi-value return flag. + (inst stc) ;; And away we go. Except that return-pc is still on the ;; stack and we've changed the stack pointer. So we have to ;; tell it to index off of EBX instead of EBP. (cond ((zerop nvals) - ;; Return popping the return address and the OCFP. - (inst ret n-word-bytes)) - ((= nvals 1) - ;; Return popping the return, leaving 1 slot. Can this - ;; happen, or is a single value return handled elsewhere? - (inst ret)) - (t - (inst jmp (make-ea :dword :base ebx - :disp (- (* (1+ (tn-offset return-pc)) - n-word-bytes)))))) + ;; Return popping the return address and the OCFP. + (inst ret n-word-bytes)) + ((= nvals 1) + ;; Return popping the return, leaving 1 slot. Can this + ;; happen, or is a single value return handled elsewhere? + (inst ret)) + (t + (inst jmp (make-ea :dword :base ebx + :disp (frame-byte-offset (tn-offset return-pc)))))) (trace-table-entry trace-table-normal))) @@ -1045,16 +1103,16 @@ ;;; ESI -- pointer to where to find the values. (define-vop (return-multiple) (:args (old-fp :to (:eval 1) :target old-fp-temp) - (return-pc :target eax) - (vals :scs (any-reg) :target esi) - (nvals :scs (any-reg) :target ecx)) + (return-pc :target eax) + (vals :scs (any-reg) :target esi) + (nvals :scs (any-reg) :target ecx)) (:temporary (:sc unsigned-reg :offset eax-offset :from (:argument 1)) eax) (:temporary (:sc unsigned-reg :offset esi-offset :from (:argument 2)) esi) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 3)) ecx) (:temporary (:sc unsigned-reg :offset ebx-offset :from (:eval 0)) ebx) (:temporary (:sc descriptor-reg :offset (first *register-arg-offsets*) - :from (:eval 0)) a0) + :from (:eval 0)) a0) (:temporary (:sc unsigned-reg :from (:eval 1)) old-fp-temp) (:node-var node) @@ -1065,23 +1123,23 @@ (unless (policy node (> space speed)) ;; Check for the single case. (let ((not-single (gen-label))) - (inst cmp nvals (fixnumize 1)) - (inst jmp :ne not-single) - - ;; Return with one value. - (loadw a0 vals -1) - ;; Clear the stack. We load old-fp into a register before clearing - ;; the stack. - (move old-fp-temp old-fp) - (move esp-tn ebp-tn) - (move ebp-tn old-fp-temp) - ;; Fix the return-pc to point at the single-value entry point. - (inst add eax 2) - ;; Out of here. - (inst jmp eax) - - ;; Nope, not the single case. Jump to the assembly routine. - (emit-label not-single))) + (inst cmp nvals (fixnumize 1)) + (inst jmp :ne not-single) + + ;; Return with one value. + (loadw a0 vals -1) + ;; Clear the stack. We load old-fp into a register before clearing + ;; the stack. + (move old-fp-temp old-fp) + (move esp-tn ebp-tn) + (move ebp-tn old-fp-temp) + ;; Set the single-value return flag. + (inst clc) + ;; Out of here. + (inst jmp eax) + + ;; Nope, not the single case. Jump to the assembly routine. + (emit-label not-single))) (move esi vals) (move ecx nvals) (move ebx ebp-tn) @@ -1133,18 +1191,18 @@ (:generator 20 ;; Avoid the copy if there are no more args. (cond ((zerop fixed) - (inst jecxz just-alloc-frame)) - (t - (inst cmp ecx-tn (fixnumize fixed)) - (inst jmp :be just-alloc-frame))) + (inst jecxz just-alloc-frame)) + (t + (inst cmp ecx-tn (fixnumize fixed)) + (inst jmp :be just-alloc-frame))) ;; Allocate the space on the stack. ;; stack = ebp - (max 3 frame-size) - (nargs - fixed) (inst lea ebx-tn - (make-ea :dword :base ebp-tn - :disp (- (fixnumize fixed) - (* n-word-bytes - (max 3 (sb-allocated-size 'stack)))))) + (make-ea :dword :base ebp-tn + :disp (- (fixnumize fixed) + (* n-word-bytes + (max 3 (sb-allocated-size 'stack)))))) (inst sub ebx-tn ecx-tn) ; Got the new stack in ebx (inst mov esp-tn ebx-tn) @@ -1154,37 +1212,46 @@ (inst mov ebx-tn ecx-tn) (cond ((< fixed register-arg-count) - ;; We must stop when we run out of stack args, not when we - ;; run out of more args. - ;; Number to copy = nargs-3 - (inst sub ecx-tn (fixnumize register-arg-count)) - ;; Everything of interest in registers. - (inst jmp :be do-regs)) - (t - ;; Number to copy = nargs-fixed - (inst sub ecx-tn (fixnumize fixed)))) + ;; We must stop when we run out of stack args, not when we + ;; run out of more args. + ;; Number to copy = nargs-3 + (inst sub ecx-tn (fixnumize register-arg-count)) + ;; Everything of interest in registers. + (inst jmp :be do-regs)) + (t + ;; Number to copy = nargs-fixed + (inst sub ecx-tn (fixnumize fixed)))) ;; Save edi and esi register args. (inst push edi-tn) (inst push esi-tn) + (inst push ebx-tn) ;; Okay, we have pushed the register args. We can trash them ;; now. - ;; Initialize dst to be end of stack; skiping the values pushed - ;; above. - (inst lea edi-tn (make-ea :dword :base esp-tn :disp 8)) - ;; Initialize src to be end of args. (inst mov esi-tn ebp-tn) (inst sub esi-tn ebx-tn) - (inst shr ecx-tn word-shift) ; make word count - ;; And copy the args. - (inst cld) ; auto-inc ESI and EDI. - (inst rep) - (inst movs :dword) + ;; We need to copy from downwards up to avoid overwriting some of + ;; the yet uncopied args. So we need to use EBX as the copy index + ;; and ECX as the loop counter, rather than using ECX for both. + (inst xor ebx-tn ebx-tn) + + ;; We used to use REP MOVS here, but on modern x86 it performs + ;; much worse than an explicit loop for small blocks. + COPY-LOOP + (inst mov edi-tn (make-ea :dword :base esi-tn :index ebx-tn)) + ;; The :DISP is to account for the registers saved on the stack + (inst mov (make-ea :dword :base esp-tn :disp (* 3 n-word-bytes) + :index ebx-tn) + edi-tn) + (inst add ebx-tn n-word-bytes) + (inst sub ecx-tn n-word-bytes) + (inst jmp :nz COPY-LOOP) ;; So now we need to restore EDI and ESI. + (inst pop ebx-tn) (inst pop esi-tn) (inst pop edi-tn) @@ -1195,73 +1262,79 @@ ;; Here: nargs>=1 && nargs>fixed (when (< fixed register-arg-count) - ;; Now we have to deposit any more args that showed up in - ;; registers. - (do ((i fixed)) - ( nil ) - ;; Store it relative to ebp - (inst mov (make-ea :dword :base ebp-tn - :disp (- (* 4 - (+ 1 (- i fixed) - (max 3 (sb-allocated-size 'stack)))))) - (nth i *register-arg-tns*)) - - (incf i) - (when (>= i register-arg-count) - (return)) - - ;; Don't deposit any more than there are. - (if (zerop i) - (inst test ecx-tn ecx-tn) - (inst cmp ecx-tn (fixnumize i))) - (inst jmp :eq done))) + ;; Now we have to deposit any more args that showed up in + ;; registers. + (do ((i fixed)) + ( nil ) + ;; Store it relative to ebp + (inst mov (make-ea :dword :base ebp-tn + :disp (- (* 4 + (+ 1 (- i fixed) + (max 3 (sb-allocated-size 'stack)))))) + (nth i *register-arg-tns*)) + + (incf i) + (when (>= i register-arg-count) + (return)) + + ;; Don't deposit any more than there are. + (if (zerop i) + (inst test ecx-tn ecx-tn) + (inst cmp ecx-tn (fixnumize i))) + (inst jmp :eq done))) (inst jmp done) JUST-ALLOC-FRAME (inst lea esp-tn - (make-ea :dword :base ebp-tn - :disp (- (* n-word-bytes - (max 3 (sb-allocated-size 'stack)))))) + (make-ea :dword :base ebp-tn + :disp (- (* n-word-bytes + (max 3 (sb-allocated-size 'stack)))))) DONE)) -;;; &MORE args are stored contiguously on the stack, starting -;;; immediately at the context pointer. The context pointer is not -;;; typed, so the lowtag is 0. -(define-vop (more-arg) - (:translate %more-arg) +(define-vop (more-kw-arg) + (:translate sb!c::%more-kw-arg) (:policy :fast-safe) - (:args (object :scs (descriptor-reg) :to :result) - (index :scs (any-reg) :target temp)) + (:args (object :scs (descriptor-reg) :to (:result 1)) + (index :scs (any-reg immediate) :to (:result 1) :target keyword)) (:arg-types * tagged-num) - (:temporary (:sc unsigned-reg :from (:argument 1) :to :result) temp) - (:results (value :scs (any-reg descriptor-reg))) - (:result-types *) - (:generator 5 - (move temp index) - (inst neg temp) - (inst mov value (make-ea :dword :base object :index temp)))) + (:results (value :scs (descriptor-reg any-reg)) + (keyword :scs (descriptor-reg any-reg))) + (:result-types * *) + (:generator 4 + (sc-case index + (immediate + (inst mov value (make-ea :dword :base object :disp (tn-value index))) + (inst mov keyword (make-ea :dword :base object + :disp (+ (tn-value index) n-word-bytes)))) + (t + (inst mov value (make-ea :dword :base object :index index)) + (inst mov keyword (make-ea :dword :base object :index index + :disp n-word-bytes)))))) -(define-vop (more-arg-c) - (:translate %more-arg) +(define-vop (more-arg) + (:translate sb!c::%more-arg) (:policy :fast-safe) - (:args (object :scs (descriptor-reg))) - (:info index) - (:arg-types * (:constant (signed-byte 30))) - (:results (value :scs (any-reg descriptor-reg))) + (:args (object :scs (descriptor-reg) :to (:result 1)) + (index :scs (any-reg) :to (:result 1) :target value)) + (:arg-types * tagged-num) + (:results (value :scs (descriptor-reg any-reg))) (:result-types *) (:generator 4 - (inst mov value - (make-ea :dword :base object :disp (- (* index n-word-bytes)))))) - + (move value index) + (inst neg value) + (inst mov value (make-ea :dword :base object :index value)))) ;;; Turn more arg (context, count) into a list. +(defoptimizer (%listify-rest-args stack-allocate-result) ((&rest args)) + t) + (define-vop (listify-rest-args) (:translate %listify-rest-args) (:policy :safe) (:args (context :scs (descriptor-reg) :target src) - (count :scs (any-reg) :target ecx)) + (count :scs (any-reg) :target ecx)) (:arg-types * tagged-num) (:temporary (:sc unsigned-reg :offset esi-offset :from (:argument 0)) src) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 1)) ecx) @@ -1271,19 +1344,18 @@ (:node-var node) (:generator 20 (let ((enter (gen-label)) - (loop (gen-label)) - (done (gen-label))) + (loop (gen-label)) + (done (gen-label)) + (stack-allocate-p (node-stack-allocate-p node))) (move src context) (move ecx count) ;; Check to see whether there are no args, and just return NIL if so. (inst mov result nil-value) (inst jecxz done) - (inst lea dst (make-ea :dword :index ecx :scale 2)) - (pseudo-atomic - (allocation dst dst node) + (inst lea dst (make-ea :dword :base ecx :index ecx)) + (maybe-pseudo-atomic stack-allocate-p + (allocation dst dst node stack-allocate-p) (inst lea dst (make-ea :byte :base dst :disp list-pointer-lowtag)) - ;; Convert the count into a raw value, so that we can use the - ;; LOOP instruction. (inst shr ecx 2) ;; Set decrement mode (successive args at lower addresses) (inst std) @@ -1302,9 +1374,11 @@ (inst lods eax) (storew eax dst 0 list-pointer-lowtag) ;; Go back for more. - (inst loop loop) + (inst sub ecx 1) + (inst jmp :nz loop) ;; NIL out the last cons. - (storew nil-value dst 1 list-pointer-lowtag)) + (storew nil-value dst 1 list-pointer-lowtag) + (inst cld)) (emit-label done)))) ;;; Return the location and size of the &MORE arg glob created by @@ -1324,7 +1398,7 @@ (:arg-types positive-fixnum (:constant fixnum)) (:info fixed) (:results (context :scs (descriptor-reg)) - (count :scs (any-reg))) + (count :scs (any-reg))) (:result-types t tagged-num) (:note "more-arg-context") (:generator 5 @@ -1332,8 +1406,8 @@ ;; SP at this point points at the last arg pushed. ;; Point to the first more-arg, not above it. (inst lea context (make-ea :dword :base esp-tn - :index count :scale 1 - :disp (- (+ (fixnumize fixed) 4)))) + :index count :scale 1 + :disp (- (+ (fixnumize fixed) 4)))) (unless (zerop fixed) (inst sub count (fixnumize fixed))))) @@ -1348,25 +1422,25 @@ (:save-p :compute-only) (:generator 3 (let ((err-lab - (generate-error-code vop invalid-arg-count-error nargs))) + (generate-error-code vop 'invalid-arg-count-error nargs))) (if (zerop count) - (inst test nargs nargs) ; smaller instruction - (inst cmp nargs (fixnumize count))) + (inst test nargs nargs) ; smaller instruction + (inst cmp nargs (fixnumize count))) (inst jmp :ne err-lab)))) ;;; Various other error signallers. (macrolet ((def (name error translate &rest args) - `(define-vop (,name) - ,@(when translate - `((:policy :fast-safe) - (:translate ,translate))) - (:args ,@(mapcar (lambda (arg) - `(,arg :scs (any-reg descriptor-reg))) - args)) - (:vop-var vop) - (:save-p :compute-only) - (:generator 1000 - (error-call vop ,error ,@args))))) + `(define-vop (,name) + ,@(when translate + `((:policy :fast-safe) + (:translate ,translate))) + (:args ,@(mapcar (lambda (arg) + `(,arg :scs (any-reg descriptor-reg))) + args)) + (:vop-var vop) + (:save-p :compute-only) + (:generator 1000 + (error-call vop ',error ,@args))))) (def arg-count-error invalid-arg-count-error sb!c::%arg-count-error nargs) (def type-check-error object-not-type-error sb!c::%type-check-error @@ -1378,3 +1452,33 @@ (def unknown-key-arg-error unknown-key-arg-error sb!c::%unknown-key-arg-error key) (def nil-fun-returned-error nil-fun-returned-error nil fun)) + +;;; Single-stepping + +(defun emit-single-step-test () + ;; We use different ways of representing whether stepping is on on + ;; +SB-THREAD / -SB-THREAD: on +SB-THREAD, we use a slot in the + ;; thread structure. On -SB-THREAD we use the value of a static + ;; symbol. Things are done this way, since reading a thread-local + ;; slot from a symbol would require an extra register on +SB-THREAD, + ;; and reading a slot from a thread structure would require an extra + ;; register on -SB-THREAD. + #!+sb-thread + (progn + (inst fs-segment-prefix) + (inst cmp (make-ea :dword + :disp (* thread-stepping-slot n-word-bytes)) + nil-value)) + #!-sb-thread + (inst cmp (make-ea-for-symbol-value sb!impl::*stepping*) + nil-value)) + +(define-vop (step-instrument-before-vop) + (:policy :fast-safe) + (:vop-var vop) + (:generator 3 + (emit-single-step-test) + (inst jmp :eq DONE) + (inst break single-step-before-trap) + DONE + (note-this-location vop :step-before-vop)))