X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fx86-64%2Fcall.lisp;h=4c4fdab84d4715e56d81f4d2ae3cd304dc16d911;hb=debae3c18d31b5222be4d5de8dcb2601336e24a4;hp=1e98a64f5c1a355335249396bd37213d9404797a;hpb=f78e2d271f540d68d35b4f41696ce746ff129ee3;p=sbcl.git diff --git a/src/compiler/x86-64/call.lisp b/src/compiler/x86-64/call.lisp index 1e98a64..4c4fdab 100644 --- a/src/compiler/x86-64/call.lisp +++ b/src/compiler/x86-64/call.lisp @@ -15,7 +15,7 @@ ;;; Return a wired TN describing the N'th full call argument passing ;;; location. -(!def-vm-support-routine standard-arg-location (n) +(defun standard-arg-location (n) (declare (type unsigned-byte n)) (if (< n register-arg-count) (make-wired-tn *backend-t-primitive-type* descriptor-reg-sc-number @@ -26,7 +26,7 @@ ;;; ;;; Always wire the return PC location to the stack in its standard ;;; location. -(!def-vm-support-routine make-return-pc-passing-location (standard) +(defun 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)) @@ -38,7 +38,7 @@ ;;; because we want to be able to assume it's always there. Besides, ;;; the x86 doesn't have enough registers to really make it profitable ;;; to pass it in a register. -(!def-vm-support-routine make-old-fp-passing-location (standard) +(defun make-old-fp-passing-location (standard) (declare (ignore standard)) (make-wired-tn *fixnum-primitive-type* control-stack-sc-number ocfp-save-offset)) @@ -49,12 +49,12 @@ ;;; ;;; Without using a save-tn - which does not make much sense if it is ;;; wired to the stack? -(!def-vm-support-routine make-old-fp-save-location (physenv) +(defun make-old-fp-save-location (physenv) (physenv-debug-live-tn (make-wired-tn *fixnum-primitive-type* control-stack-sc-number ocfp-save-offset) physenv)) -(!def-vm-support-routine make-return-pc-save-location (physenv) +(defun 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) @@ -63,23 +63,23 @@ ;;; 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 ;;; are using non-standard conventions. -(!def-vm-support-routine make-arg-count-location () +(defun make-arg-count-location () (make-wired-tn *fixnum-primitive-type* any-reg-sc-number rcx-offset)) ;;; Make a TN to hold the number-stack frame pointer. This is allocated ;;; once per component, and is component-live. -(!def-vm-support-routine make-nfp-tn () +(defun make-nfp-tn () (make-restricted-tn *fixnum-primitive-type* ignore-me-sc-number)) -(!def-vm-support-routine make-stack-pointer-tn () +(defun make-stack-pointer-tn () (make-normal-tn *fixnum-primitive-type*)) -(!def-vm-support-routine make-number-stack-pointer-tn () +(defun make-number-stack-pointer-tn () (make-restricted-tn *fixnum-primitive-type* ignore-me-sc-number)) ;;; Return a list of TNs that can be used to represent an unknown-values ;;; continuation within a function. -(!def-vm-support-routine make-unknown-values-locations () +(defun make-unknown-values-locations () (list (make-stack-pointer-tn) (make-normal-tn *fixnum-primitive-type*))) @@ -87,19 +87,9 @@ ;;; VM-dependent initialization of the IR2-COMPONENT structure. We ;;; push placeholder entries in the CONSTANTS to leave room for ;;; additional noise in the code object header. -(!def-vm-support-routine select-component-format (component) +(defun select-component-format (component) (declare (type component component)) - ;; The 1+ here is because for the x86 the first constant is a - ;; pointer to a list of fixups, or NIL if the code object has none. - ;; (If I understand correctly, the fixups are needed at GC copy - ;; time because the X86 code isn't relocatable.) - ;; - ;; KLUDGE: It'd be cleaner to have the fixups entry be a named - ;; element of the CODE (aka component) primitive object. However, - ;; it's currently a large, tricky, error-prone chore to change - ;; the layout of any primitive object, so for the foreseeable future - ;; we'll just live with this ugliness. -- WHN 2002-01-02 - (dotimes (i (1+ code-constants-offset)) + (dotimes (i code-constants-offset) (vector-push-extend nil (ir2-component-constants (component-info component)))) (values)) @@ -119,11 +109,104 @@ (:generator 1 nil)) +;;; Accessing a slot from an earlier stack frame is definite hackery. +(define-vop (ancestor-frame-ref) + (:args (frame-pointer :scs (descriptor-reg)) + (variable-home-tn :load-if nil)) + (:results (value :scs (descriptor-reg any-reg))) + (:policy :fast-safe) + (:generator 4 + (aver (sc-is variable-home-tn control-stack)) + (loadw value frame-pointer + (frame-word-offset (tn-offset variable-home-tn))))) +(define-vop (ancestor-frame-set) + (:args (frame-pointer :scs (descriptor-reg)) + (value :scs (descriptor-reg any-reg))) + (:results (variable-home-tn :load-if nil)) + (:policy :fast-safe) + (:generator 4 + (aver (sc-is variable-home-tn control-stack)) + (storew value frame-pointer + (frame-word-offset (tn-offset variable-home-tn))))) + +(macrolet ((define-frame-op + (suffix sc stack-sc instruction + &optional (ea + `(make-ea :qword + :base frame-pointer + :disp (frame-byte-offset + (tn-offset variable-home-tn))))) + (let ((reffer (symbolicate 'ancestor-frame-ref '/ suffix)) + (setter (symbolicate 'ancestor-frame-set '/ suffix))) + `(progn + (define-vop (,reffer ancestor-frame-ref) + (:results (value :scs (,sc))) + (:generator 4 + (aver (sc-is variable-home-tn ,stack-sc)) + (inst ,instruction value + ,ea))) + (define-vop (,setter ancestor-frame-set) + (:args (frame-pointer :scs (descriptor-reg)) + (value :scs (,sc))) + (:generator 4 + (aver (sc-is variable-home-tn ,stack-sc)) + (inst ,instruction ,ea value))))))) + (define-frame-op double-float double-reg double-stack movsd) + (define-frame-op single-float single-reg single-stack movss) + (define-frame-op complex-double-float complex-double-reg complex-double-stack + movupd (ea-for-cdf-data-stack variable-home-tn frame-pointer)) + (define-frame-op complex-single-float complex-single-reg complex-single-stack + movq (ea-for-csf-data-stack variable-home-tn frame-pointer)) + (define-frame-op signed-byte-64 signed-reg signed-stack mov) + (define-frame-op unsigned-byte-64 unsigned-reg unsigned-stack mov) + (define-frame-op system-area-pointer sap-reg sap-stack mov)) + +(defun primitive-type-indirect-cell-type (ptype) + (declare (type primitive-type ptype)) + (macrolet ((foo (&body data) + `(case (primitive-type-name ptype) + ,@(loop for (name stack-sc ref set) in data + collect + `(,name + (load-time-value + (list (primitive-type-or-lose ',name) + (sc-or-lose ',stack-sc) + (lambda (node block fp value res) + (sb!c::vop ,ref node block + fp value res)) + (lambda (node block fp new-val value) + (sb!c::vop ,set node block + fp new-val value))))))))) + (foo (double-float double-stack + ancestor-frame-ref/double-float + ancestor-frame-set/double-float) + (single-float single-stack + ancestor-frame-ref/single-float + ancestor-frame-set/single-float) + (complex-double-float complex-double-stack + ancestor-frame-ref/complex-double-float + ancestor-frame-set/complex-double-float) + (complex-single-float complex-single-stack + ancestor-frame-ref/complex-single-float + ancestor-frame-set/complex-single-float) + (signed-byte-64 signed-stack + ancestor-frame-ref/signed-byte-64 + ancestor-frame-set/signed-byte-64) + (unsigned-byte-64 unsigned-stack + ancestor-frame-ref/unsigned-byte-64 + ancestor-frame-set/unsigned-byte-64) + (unsigned-byte-63 unsigned-stack + ancestor-frame-ref/unsigned-byte-64 + ancestor-frame-set/unsigned-byte-64) + (system-area-pointer sap-stack + ancestor-frame-ref/system-area-pointer + ancestor-frame-set/system-area-pointer)))) + (define-vop (xep-allocate-frame) (:info start-lab copy-more-arg-follows) (:vop-var vop) (:generator 1 - (align n-lowtag-bits) + (emit-alignment n-lowtag-bits) (trace-table-entry trace-table-fun-prologue) (emit-label start-lab) ;; Skip space for the function header. @@ -133,7 +216,7 @@ ;; The start of the actual code. ;; Save the return-pc. - (popw rbp-tn (- (1+ return-pc-save-offset))) + (popw rbp-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 @@ -143,7 +226,8 @@ (inst lea rsp-tn (make-ea :qword :base rbp-tn :disp (- (* n-word-bytes - (max 3 (sb-allocated-size 'stack))))))) + (- (max 3 (sb-allocated-size 'stack)) + sp->fp-offset)))))) (trace-table-entry trace-table-normal))) @@ -151,12 +235,13 @@ ;;; or a multiple-call-local. All it does is allocate stack space for the ;;; callee (who has the same size stack as us). (define-vop (allocate-frame) - (:results (res :scs (any-reg control-stack)) + (:results (res :scs (any-reg)) (nfp)) (:info callee) (:ignore nfp callee) (:generator 2 - (move res rsp-tn) + (inst lea res (make-ea :qword :base rsp-tn + :disp (- (* sp->fp-offset n-word-bytes)))) (inst sub rsp-tn (* n-word-bytes (sb-allocated-size 'stack))))) ;;; Allocate a partial frame for passing stack arguments in a full @@ -165,9 +250,10 @@ ;;; before it can extend the stack. (define-vop (allocate-full-call-frame) (:info nargs) - (:results (res :scs (any-reg control-stack))) + (:results (res :scs (any-reg))) (:generator 2 - (move res rsp-tn) + (inst lea res (make-ea :qword :base rsp-tn + :disp (- (* sp->fp-offset n-word-bytes)))) (inst sub rsp-tn (* (max nargs 3) n-word-bytes)))) ;;; Emit code needed at the return-point from an unknown-values call @@ -176,12 +262,6 @@ ;;; 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. -;;; -;;; This code exploits the fact that in the unknown-values convention, -;;; a single value return returns at the return PC + 2, whereas a -;;; return of other than one value returns directly at the return PC. -;;; ;;; If 0 or 1 values are expected, then we just emit an instruction to ;;; reset the SP (which will only be executed when other than 1 value ;;; is returned.) @@ -194,173 +274,189 @@ ;;; there are stack values. ;;; -- Reset SP. This must be done whenever other than 1 value is ;;; returned, regardless of the number of values desired. -(defun default-unknown-values (vop values nvals) +(defun default-unknown-values (vop values nvals node) (declare (type (or tn-ref null) values) (type unsigned-byte nvals)) - (cond - ((<= nvals 1) - (note-this-location vop :single-value-return) - (let ((single-value (gen-label))) - (inst jmp :nc single-value) - (inst mov rsp-tn rbx-tn) - (emit-label single-value))) - ((<= nvals register-arg-count) - (let ((regs-defaulted (gen-label))) - (note-this-location vop :unknown-return) - (inst jmp :c regs-defaulted) - ;; Default the unsupplied 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)))) - (inst mov rbx-tn rsp-tn) - (emit-label regs-defaulted) - (inst mov rsp-tn rbx-tn))) - ((<= nvals 7) - ;; The number of bytes depends on the relative jump instructions. - ;; Best case is 31+(n-3)*14, worst case is 35+(n-3)*18. For - ;; 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))) - (note-this-location vop :unknown-return) - ;; Branch off to the MV case. - (inst jmp :c regs-defaulted) - ;; Do the single value case. - ;; Default the register args - (inst mov rax-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) rax-tn)) - - ;; Fake other registers so it looks like we returned with all the - ;; registers filled in. - (move rbx-tn rsp-tn) - (inst push rdx-tn) - (inst jmp default-stack-slots) - - (emit-label regs-defaulted) - - (inst mov rax-tn nil-value) - (storew rdx-tn rbx-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 rcx-tn (fixnumize i)) - (inst jmp :be default-lab) - (loadw rdx-tn rbx-tn (- (1+ i))) - (inst mov tn rdx-tn))) - - (emit-label defaulting-done) - (loadw rdx-tn rbx-tn -1) - (move rsp-tn rbx-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) rax-tn)) - (inst jmp defaulting-done) - (trace-table-entry trace-table-normal))))))) - (t - (let ((regs-defaulted (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 nop) - (inst jmp-short regs-defaulted) - - ;; Default the register args, and set up the stack as if we - ;; entered the MV return point. - (inst mov rbx-tn rsp-tn) - (inst push rdx-tn) - (inst mov rdi-tn nil-value) - (inst push rdi-tn) - (inst mov rsi-tn rdi-tn) - ;; Compute a pointer to where to put the [defaulted] stack values. - (emit-label no-stack-args) - (inst lea rdi-tn - (make-ea :qword :base rbp-tn - :disp (* (- (1+ register-arg-count)) n-word-bytes))) - ;; Load RAX with NIL so we can quickly store it, and set up - ;; stuff for the loop. - (inst mov rax-tn nil-value) - (inst std) - (inst mov rcx-tn (- nvals register-arg-count)) - ;; Jump into the default loop. - (inst jmp default-stack-vals) - - ;; The regs are defaulted. We need to copy any stack arguments, - ;; and then default the remaining stack arguments. - (emit-label regs-defaulted) - ;; Save EDI. - (storew rdi-tn rbx-tn (- (1+ 1))) - ;; Compute the number of stack arguments, and if it's zero or - ;; less, don't copy any stack arguments. - (inst sub rcx-tn (fixnumize register-arg-count)) - (inst jmp :le no-stack-args) - - ;; Throw away any unwanted args. - (inst cmp rcx-tn (fixnumize (- nvals register-arg-count))) - (inst jmp :be count-okay) - (inst mov rcx-tn (fixnumize (- nvals register-arg-count))) - (emit-label count-okay) - ;; Save the number of stack values. - (inst mov rax-tn rcx-tn) - ;; Compute a pointer to where the stack args go. - (inst lea rdi-tn - (make-ea :qword :base rbp-tn - :disp (* (- (1+ register-arg-count)) n-word-bytes))) - ;; Save ESI, and compute a pointer to where the args come from. - (storew rsi-tn rbx-tn (- (1+ 2))) - (inst lea rsi-tn - (make-ea :qword :base rbx-tn - :disp (* (- (1+ register-arg-count)) n-word-bytes))) - ;; Do the copy. - (inst shr rcx-tn word-shift) ; make word count - (inst std) - (inst rep) - (inst movs :qword) - ;; Restore RSI. - (loadw rsi-tn rbx-tn (- (1+ 2))) - ;; Now we have to default the remaining args. Find out how many. - (inst sub rax-tn (fixnumize (- nvals register-arg-count))) - (inst neg rax-tn) - ;; If none, then just blow out of here. - (inst jmp :le restore-edi) - (inst mov rcx-tn rax-tn) - (inst shr rcx-tn word-shift) ; word count - ;; Load RAX with NIL for fast storing. - (inst mov rax-tn nil-value) - ;; Do the store. - (emit-label default-stack-vals) - (inst rep) - (inst stos rax-tn) - ;; Restore EDI, and reset the stack. - (emit-label restore-edi) - (loadw rdi-tn rbx-tn (- (1+ 1))) - (inst mov rsp-tn rbx-tn)))) + (let ((type (sb!c::basic-combination-derived-type node))) + (cond + ((<= nvals 1) + (note-this-location vop :single-value-return) + (cond + ((<= (sb!kernel:values-type-max-value-count type) + register-arg-count) + (when (and (named-type-p type) + (eq nil (named-type-name type))) + ;; The function never returns, it may happen that the code + ;; ends right here leavig the :SINGLE-VALUE-RETURN note + ;; dangling. Let's emit a NOP. + (inst nop))) + ((not (sb!kernel:values-type-may-be-single-value-p type)) + (inst mov rsp-tn rbx-tn)) + (t + (inst cmov :c rsp-tn rbx-tn)))) + ((<= nvals register-arg-count) + (note-this-location vop :unknown-return) + (when (sb!kernel:values-type-may-be-single-value-p type) + (let ((regs-defaulted (gen-label))) + (inst jmp :c regs-defaulted) + ;; Default the unsupplied 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)))) + (inst mov rbx-tn rsp-tn) + (emit-label regs-defaulted))) + (when (< register-arg-count + (sb!kernel:values-type-max-value-count type)) + (inst mov rsp-tn rbx-tn))) + ((<= nvals 7) + ;; The number of bytes depends on the relative jump instructions. + ;; Best case is 31+(n-3)*14, worst case is 35+(n-3)*18. For + ;; 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))) + (note-this-location vop :unknown-return) + ;; Branch off to the MV case. + (inst jmp :c regs-defaulted) + ;; Do the single value case. + ;; Default the register args + (inst mov rax-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) rax-tn)) + ;; Fake other registers so it looks like we returned with all the + ;; registers filled in. + (move rbx-tn rsp-tn) + (inst jmp default-stack-slots) + (emit-label regs-defaulted) + (inst mov rax-tn nil-value) + (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)) + (first-stack-arg-p (= i register-arg-count))) + (defaults (cons default-lab + (cons tn first-stack-arg-p))) + (inst cmp rcx-tn (fixnumize i)) + (inst jmp :be default-lab) + (when first-stack-arg-p + ;; There are stack args so the frame of the callee is + ;; still there, save RDX in its first slot temporalily. + (storew rdx-tn rbx-tn (frame-word-offset sp->fp-offset))) + (loadw rdx-tn rbx-tn (frame-word-offset (+ sp->fp-offset i))) + (inst mov tn rdx-tn))) + (emit-label defaulting-done) + (loadw rdx-tn rbx-tn (frame-word-offset sp->fp-offset)) + (move rsp-tn rbx-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)) + (when (cddr default) + ;; We are setting the first stack argument to NIL. + ;; The callee's stack frame is dead, save RDX by + ;; pushing it to the stack, it will end up at same + ;; place as in the (STOREW RDX-TN RBX-TN -1) case + ;; above. + (inst push rdx-tn)) + (inst mov (second default) rax-tn)) + (inst jmp defaulting-done) + (trace-table-entry trace-table-normal))))))) + (t + (let ((regs-defaulted (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 :c regs-defaulted) + ;; Default the register args, and set up the stack as if we + ;; entered the MV return point. + (inst mov rbx-tn rsp-tn) + (inst mov rdi-tn nil-value) + (inst mov rsi-tn rdi-tn) + ;; Compute a pointer to where to put the [defaulted] stack values. + (emit-label no-stack-args) + (inst push rdx-tn) + (inst push rdi-tn) + (inst lea rdi-tn + (make-ea :qword :base rbp-tn + :disp (frame-byte-offset register-arg-count))) + ;; Load RAX with NIL so we can quickly store it, and set up + ;; stuff for the loop. + (inst mov rax-tn nil-value) + (inst std) + (inst mov rcx-tn (- nvals register-arg-count)) + ;; Jump into the default loop. + (inst jmp default-stack-vals) + ;; The regs are defaulted. We need to copy any stack arguments, + ;; and then default the remaining stack arguments. + (emit-label regs-defaulted) + ;; Compute the number of stack arguments, and if it's zero or + ;; less, don't copy any stack arguments. + (inst sub rcx-tn (fixnumize register-arg-count)) + (inst jmp :le no-stack-args) + ;; Save EDI. + (storew rdi-tn rbx-tn (frame-word-offset (+ sp->fp-offset 1))) + ;; Throw away any unwanted args. + (inst cmp rcx-tn (fixnumize (- nvals register-arg-count))) + (inst jmp :be count-okay) + (inst mov rcx-tn (fixnumize (- nvals register-arg-count))) + (emit-label count-okay) + ;; Save the number of stack values. + (inst mov rax-tn rcx-tn) + ;; Compute a pointer to where the stack args go. + (inst lea rdi-tn + (make-ea :qword :base rbp-tn + :disp (frame-byte-offset register-arg-count))) + ;; Save ESI, and compute a pointer to where the args come from. + (storew rsi-tn rbx-tn (frame-word-offset (+ sp->fp-offset 2))) + (inst lea rsi-tn + (make-ea :qword :base rbx-tn + :disp (frame-byte-offset + (+ sp->fp-offset register-arg-count)))) + ;; Do the copy. + (inst shr rcx-tn n-fixnum-tag-bits) ; make word count + (inst std) + (inst rep) + (inst movs :qword) + ;; Restore RSI. + (loadw rsi-tn rbx-tn (frame-word-offset (+ sp->fp-offset 2))) + ;; Now we have to default the remaining args. Find out how many. + (inst sub rax-tn (fixnumize (- nvals register-arg-count))) + (inst neg rax-tn) + ;; If none, then just blow out of here. + (inst jmp :le restore-edi) + (inst mov rcx-tn rax-tn) + (inst shr rcx-tn n-fixnum-tag-bits) ; word count + ;; Load RAX with NIL for fast storing. + (inst mov rax-tn nil-value) + ;; Do the store. + (emit-label default-stack-vals) + (inst rep) + (inst stos rax-tn) + ;; Restore EDI, and reset the stack. + (emit-label restore-edi) + (loadw rdi-tn rbx-tn (frame-word-offset (+ sp->fp-offset 1))) + (inst mov rsp-tn rbx-tn) + (inst cld))))) (values)) ;;;; unknown values receiving @@ -382,27 +478,45 @@ ;;; explicitly allocate these TNs, since their lifetimes overlap with ;;; the results start and count. (Also, it's nice to be able to target ;;; them.) -(defun receive-unknown-values (args nargs start count) +(defun receive-unknown-values (args nargs start count node) (declare (type tn args nargs start count)) - (let ((variable-values (gen-label)) + (let ((type (sb!c::basic-combination-derived-type node)) + (variable-values (gen-label)) + (stack-values (gen-label)) (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 :qword :base rsp-tn :disp 8))) - (t (inst mov start rsp-tn) - (inst push (first *register-arg-tns*)))) - (inst mov count (fixnumize 1)) - (inst jmp done) - - (emit-label variable-values) + (when (sb!kernel:values-type-may-be-single-value-p type) + (inst jmp :c variable-values) + (cond ((location= start (first *register-arg-tns*)) + (inst push (first *register-arg-tns*)) + (inst lea start (make-ea :qword :base rsp-tn :disp n-word-bytes))) + (t (inst mov start rsp-tn) + (inst push (first *register-arg-tns*)))) + (inst mov count (fixnumize 1)) + (inst jmp done) + (emit-label variable-values)) + ;; The stack frame is burnt and RETurned from if there are no + ;; stack values. In this case quickly reallocate sufficient space. + (when (<= (sb!kernel:values-type-min-value-count type) + register-arg-count) + (inst cmp nargs (fixnumize register-arg-count)) + (inst jmp :g stack-values) + #!+#.(cl:if (cl:= sb!vm:word-shift sb!vm:n-fixnum-tag-bits) '(and) '(or)) + (inst sub rsp-tn nargs) + #!-#.(cl:if (cl:= sb!vm:word-shift sb!vm:n-fixnum-tag-bits) '(and) '(or)) + (progn + ;; FIXME: This can't be efficient, but LEA (my first choice) + ;; doesn't do subtraction. + (inst shl nargs (- word-shift n-fixnum-tag-bits)) + (inst sub rsp-tn nargs) + (inst shr nargs (- word-shift n-fixnum-tag-bits))) + (emit-label stack-values)) ;; dtc: this writes the registers onto the stack even if they are ;; not needed, only the number specified in rcx are used and have ;; stack allocated to them. No harm is done. (loop for arg in *register-arg-tns* for i downfrom -1 + for j below (sb!kernel:values-type-max-value-count type) do (storew arg args i)) (move start args) (move count nargs) @@ -424,6 +538,36 @@ ;;;; local call with unknown values convention return +(defun check-ocfp-and-return-pc (old-fp return-pc) + #+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))) + #+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))) + (unless (and (sc-is old-fp control-stack) + (= (tn-offset old-fp) ocfp-save-offset)) + (error "ocfp not on stack in standard save location?")) + (unless (and (sc-is return-pc sap-stack) + (= (tn-offset return-pc) return-pc-save-offset)) + (error "return-pc not on stack in standard save location?"))) + +;;; The local call convention doesn't fit that well with x86-style +;;; calls. Emit a header for local calls to pop the return address +;;; in the right place. +(defun emit-block-header (start-label trampoline-label fall-thru-p alignp) + (when (and fall-thru-p trampoline-label) + (inst jmp start-label)) + (when trampoline-label + (emit-label trampoline-label) + (popw rbp-tn (frame-word-offset return-pc-save-offset))) + (when alignp + (emit-alignment n-lowtag-bits :long-nop)) + (emit-label start-label)) + ;;; Non-TR local call for a fixed number of values passed according to ;;; the unknown values convention. ;;; @@ -447,37 +591,19 @@ (:args (fp) (nfp) (args :more t)) - (:temporary (:sc unsigned-reg) return-label) (:results (values :more t)) (:save-p t) (:move-args :local-call) (:info arg-locs callee target nvals) (:vop-var vop) - (:ignore nfp arg-locs args #+nil callee) + (:ignore nfp arg-locs args callee) + (:node-var node) (:generator 5 (trace-table-entry trace-table-call-site) (move rbp-tn fp) - - (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))) - - ;; 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)) - (inst lea return-label (make-fixup nil :code-object RETURN)) - (storew return-label rbp-tn (- (1+ (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) - RETURN - (default-unknown-values vop values nvals) + (inst call target) + (default-unknown-values vop values nvals node) (trace-table-entry trace-table-normal))) ;;; Non-TR local call for a variable number of return values passed according @@ -487,39 +613,19 @@ (:args (fp) (nfp) (args :more t)) - (:temporary (:sc unsigned-reg) return-label) (:save-p t) (:move-args :local-call) (:info save callee target) - (:ignore args save nfp #+nil callee) + (:ignore args save nfp callee) (:vop-var vop) + (:node-var node) (:generator 20 (trace-table-entry trace-table-call-site) (move rbp-tn fp) - - (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))) - - ;; 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 - (inst lea return-label (make-fixup nil :code-object RETURN)) - (storew return-label rbp-tn (- (1+ (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) - RETURN + (inst call target) (note-this-location vop :unknown-return) - (receive-unknown-values values-start nvals start count) + (receive-unknown-values values-start nvals start count node) (trace-table-entry trace-table-normal))) ;;;; local call with known values return @@ -534,84 +640,24 @@ (:args (fp) (nfp) (args :more t)) - (:temporary (:sc unsigned-reg) return-label) (:results (res :more t)) (:move-args :local-call) (:save-p t) (:info save callee target) - (:ignore args res save nfp #+nil callee) + (:ignore args res save nfp callee) (:vop-var vop) (:generator 5 (trace-table-entry trace-table-call-site) (move rbp-tn fp) - - (let ((ret-tn (callee-return-pc-tn callee))) - - #+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))) - - ;; 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 - (inst lea return-label (make-fixup nil :code-object RETURN)) - (storew return-label rbp-tn (- (1+ (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) - RETURN + (inst call target) (note-this-location vop :known-return) (trace-table-entry trace-table-normal))) -;;; Return from known values call. We receive the return locations as -;;; arguments to terminate their lifetimes in the returning function. We -;;; restore FP and CSP and jump to the Return-PC. -;;; -;;; We can assume we know exactly where old-fp and return-pc are because -;;; make-old-fp-save-location and make-return-pc-save-location always -;;; return the same place. -#+nil -(define-vop (known-return) - (:args (old-fp) - (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) - (:ignore val-locs vals) - (:vop-var vop) - (:generator 6 - (trace-table-entry trace-table-fun-epilogue) - ;; Save the return-pc in a register 'cause the frame-pointer is - ;; going away. Note this not in the usual stack location so we - ;; can't use RET - (move rpc return-pc) - ;; Restore the stack. - (move rsp-tn rbp-tn) - ;; Restore the old fp. We know OLD-FP is going to be in its stack - ;; save slot, which is a different frame that than this one, - ;; so we don't have to worry about having just cleared - ;; most of the stack. - (move rbp-tn old-fp) - (inst jmp rpc) - (trace-table-entry trace-table-normal))) - ;;; From Douglas Crosher ;;; Return from known values call. We receive the return locations as ;;; arguments to terminate their lifetimes in the returning function. We ;;; restore FP and CSP and jump to the Return-PC. -;;; -;;; The old-fp may be either in a register or on the stack in its -;;; standard save locations - slot 0. -;;; -;;; The return-pc may be in a register or on the stack in any slot. (define-vop (known-return) (:args (old-fp) (return-pc) @@ -621,43 +667,12 @@ (:ignore val-locs vals) (:vop-var vop) (:generator 6 + (check-ocfp-and-return-pc old-fp return-pc) (trace-table-entry trace-table-fun-epilogue) - ;; return-pc may be either in a register or on the stack. - (sc-case return-pc - ((sap-reg) - (sc-case old-fp - ((control-stack) - (cond ((zerop (tn-offset old-fp)) - ;; Zot all of the stack except for the old-fp. - (inst lea rsp-tn (make-ea :qword :base rbp-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 rbp-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 rsp-tn rbp-tn) - ;; Restore the old-fp. - (move rbp-tn old-fp))) - - ;; Return; return-pc is in a register. - (inst jmp return-pc)) - - ((sap-stack) - (inst lea rsp-tn - (make-ea :qword :base rbp-tn - :disp (- (* (1+ (tn-offset return-pc)) n-word-bytes)))) - (move rbp-tn old-fp) - (inst ret (* (tn-offset return-pc) n-word-bytes)))) - + ;; Zot all of the stack except for the old-fp and return-pc. + (inst mov rsp-tn rbp-tn) + (inst pop rbp-tn) + (inst ret) (trace-table-entry trace-table-normal))) ;;;; full call @@ -728,7 +743,8 @@ (:info ,@(unless (or variable (eq return :tail)) '(arg-locs)) ,@(unless variable '(nargs)) - ,@(when (eq return :fixed) '(nvals))) + ,@(when (eq return :fixed) '(nvals)) + step-instrumenting) (:ignore ,@(unless (or variable (eq return :tail)) '(arg-locs)) @@ -768,6 +784,8 @@ :from (:argument 1) :to (:argument 2)) old-fp-tmp))) + ,@(unless (eq return :tail) + '((:node-var node))) (:generator ,(+ (if named 5 0) (if variable 19 1) @@ -790,6 +808,9 @@ ;; Compute the number of arguments. (noise '(inst mov rcx new-fp)) (noise '(inst sub rcx rsp-tn)) + #.(unless (= word-shift n-fixnum-tag-bits) + '(noise '(inst shr rcx + (- word-shift n-fixnum-tag-bits)))) ;; Move the necessary args to registers, ;; this moves them all even if they are ;; not all needed. @@ -799,7 +820,7 @@ do (noise `(loadw ,name new-fp ,index))) (noise)) '((if (zerop nargs) - (inst xor rcx rcx) + (zeroize rcx) (inst mov rcx (fixnumize nargs))))) ,@(cond ((eq return :tail) '(;; Python has figured out what frame we should @@ -822,20 +843,20 @@ ;; FIXME: FORMAT T for stale ;; diagnostic output (several of ;; them around here), ick - (format t "** tail-call old-fp not S0~%") + (error "** tail-call old-fp not S0~%") (move old-fp-tmp old-fp) (storew old-fp-tmp rbp-tn - (- (1+ ocfp-save-offset))))) + (frame-word-offset ocfp-save-offset)))) ((any-reg descriptor-reg) - (format t "** tail-call old-fp in reg not S0~%") + (error "** tail-call old-fp in reg not S0~%") (storew old-fp rbp-tn - (- (1+ ocfp-save-offset))))) + (frame-word-offset ocfp-save-offset)))) ;; For tail call, we have to push the ;; return-pc so that it looks like we CALLed - ;; drspite the fact that we are going to JMP. + ;; despite the fact that we are going to JMP. (inst push return-pc) )) (t @@ -854,14 +875,25 @@ ;; there are at least 3 slots. This hack ;; just adds 3 more. ,(if variable - '(inst sub rsp-tn (fixnumize 3))) + '(inst sub rsp-tn (* 3 n-word-bytes))) + + ;; Bias the new-fp for use as an fp + ,(if variable + '(inst sub new-fp (* sp->fp-offset n-word-bytes))) ;; Save the fp - (storew rbp-tn new-fp (- (1+ ocfp-save-offset))) + (storew rbp-tn new-fp + (frame-word-offset ocfp-save-offset)) (move rbp-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) @@ -874,15 +906,16 @@ fun-pointer-lowtag)))) ,@(ecase return (:fixed - '((default-unknown-values vop values nvals))) + '((default-unknown-values vop values nvals node))) (:unknown '((note-this-location vop :unknown-return) - (receive-unknown-values values-start nvals start count))) + (receive-unknown-values values-start nvals start count + node))) (:tail)) (trace-table-entry trace-table-normal))))) (define-full-call call nil :fixed nil) - (define-full-call call-named t :fixed nil) + (define-full-call call-named t :fixed nil) (define-full-call multiple-call nil :unknown nil) (define-full-call multiple-call-named t :unknown nil) (define-full-call tail-call nil :tail nil) @@ -898,101 +931,46 @@ (:args (args :scs (any-reg control-stack) :target rsi) (function :scs (descriptor-reg control-stack) :target rax) (old-fp) - (ret-addr)) + (return-pc)) (:temporary (:sc unsigned-reg :offset rsi-offset :from (:argument 0)) rsi) (:temporary (:sc unsigned-reg :offset rax-offset :from (:argument 1)) rax) (:temporary (:sc unsigned-reg) call-target) -; (:ignore ret-addr old-fp) (:generator 75 + (check-ocfp-and-return-pc old-fp return-pc) ;; Move these into the passing locations if they are not already there. (move rsi args) (move rax function) - - ;; 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?")) - (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?")) - - - (inst lea call-target - (make-ea :qword - :disp (make-fixup 'tail-call-variable :assembly-routine))) ;; And jump to the assembly routine. + (inst mov call-target (make-fixup 'tail-call-variable :assembly-routine)) (inst jmp call-target))) ;;;; unknown values return -;;; Return a single-value using the Unknown-Values convention. Specifically, -;;; we jump to clear the stack and jump to return-pc+3. -;;; -;;; We require old-fp to be in a register, because we want to reset RSP before -;;; restoring RBP. If old-fp were still on the stack, it could get clobbered -;;; by a signal. +;;; Return a single-value using the Unknown-Values convention. ;;; ;;; 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)) (:ignore value) (:generator 6 + (check-ocfp-and-return-pc old-fp return-pc) (trace-table-entry trace-table-fun-epilogue) - ;; 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 rsp-tn (make-ea :dword :base rbp-tn - :disp (- (* (1+ ocfp-save-offset) - n-word-bytes)))) - (inst pop rbp-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 rsp 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 rsp-tn rbp-tn) - (move rbp-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 rsp-tn (make-ea :dword :base rbp-tn - :disp (- (* (1+ (tn-offset return-pc)) - n-word-bytes)))) - ;; Set single-value return flag - (inst clc) - ;; Restore the old frame pointer - (move rbp-tn old-fp) - ;; And return, dropping the rest of the stack as we go. - (inst ret (* (tn-offset return-pc) n-word-bytes)))))) + ;; Drop stack above old-fp + (inst mov rsp-tn rbp-tn) + ;; Clear the multiple-value return flag + (inst clc) + ;; Restore the old frame pointer + (inst pop rbp-tn) + ;; And return. + (inst ret))) ;;; Do unknown-values return of a fixed (other than 1) number of ;;; values. The VALUES are required to be set up in the standard @@ -1007,12 +985,10 @@ (values :more t)) (:ignore values) (:info nvals) - ;; In the case of other than one value, we need these registers to ;; tell the caller where they are and how many there are. (:temporary (:sc unsigned-reg :offset rbx-offset) rbx) (:temporary (:sc unsigned-reg :offset rcx-offset) rcx) - ;; We need to stretch the lifetime of return-pc past the argument ;; registers so that we can default the argument registers without ;; trashing return-pc. @@ -1024,18 +1000,17 @@ :from :eval) a2) (:generator 6 + (check-ocfp-and-return-pc old-fp return-pc) + (when (= nvals 1) + ;; This is handled in RETURN-SINGLE. + (error "nvalues is 1")) (trace-table-entry trace-table-fun-epilogue) ;; Establish the values pointer and values count. - (move rbx rbp-tn) + (inst lea rbx (make-ea :qword :base rbp-tn + :disp (* sp->fp-offset n-word-bytes))) (if (zerop nvals) - (inst xor rcx rcx) ; smaller - (inst mov rcx (fixnumize nvals))) - ;; Restore the frame pointer. - (move rbp-tn old-fp) - ;; Clear as much of the stack as possible, but not past the return - ;; address. - (inst lea rsp-tn (make-ea :qword :base rbx - :disp (- (* (max nvals 2) n-word-bytes)))) + (zeroize rcx) ; smaller + (inst mov rcx (fixnumize nvals))) ;; Pre-default any argument register that need it. (when (< nvals register-arg-count) (let* ((arg-tns (nthcdr nvals (list a0 a1 a2))) @@ -1048,17 +1023,26 @@ ;; 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 RBX instead of RBP. - (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? + (cond ((<= nvals register-arg-count) + (inst mov rsp-tn rbp-tn) + (inst pop rbp-tn) (inst ret)) (t - (inst jmp (make-ea :qword :base rbx - :disp (- (* (1+ (tn-offset return-pc)) - n-word-bytes)))))) + ;; Some values are on the stack after RETURN-PC and OLD-FP, + ;; can't return normally and some slots of the frame will + ;; be used as temporaries by the receiver. + ;; + ;; Clear as much of the stack as possible, but not past the + ;; old frame address. + (inst lea rsp-tn + (make-ea :qword :base rbp-tn + :disp (frame-byte-offset (1- nvals)))) + (move rbp-tn old-fp) + (inst push (make-ea :qword :base rbx + :disp (frame-byte-offset + (+ sp->fp-offset + (tn-offset return-pc))))) + (inst ret))) (trace-table-entry trace-table-normal))) @@ -1069,57 +1053,41 @@ ;;; assembly-routine. ;;; ;;; The assembly routine takes the following args: -;;; RAX -- the return-pc to finally jump to. -;;; RBX -- pointer to where to put the values. ;;; RCX -- number of values to find there. ;;; RSI -- pointer to where to find the values. (define-vop (return-multiple) - (:args (old-fp :to (:eval 1) :target old-fp-temp) - (return-pc :target rax) + (:args (old-fp) + (return-pc) (vals :scs (any-reg) :target rsi) (nvals :scs (any-reg) :target rcx)) - - (:temporary (:sc unsigned-reg :offset rax-offset :from (:argument 1)) rax) (:temporary (:sc unsigned-reg :offset rsi-offset :from (:argument 2)) rsi) (:temporary (:sc unsigned-reg :offset rcx-offset :from (:argument 3)) rcx) - (:temporary (:sc unsigned-reg :offset rbx-offset :from (:eval 0)) rbx) (:temporary (:sc unsigned-reg) return-asm) (:temporary (:sc descriptor-reg :offset (first *register-arg-offsets*) :from (:eval 0)) a0) - (:temporary (:sc unsigned-reg :from (:eval 1)) old-fp-temp) (:node-var node) - (:generator 13 + (check-ocfp-and-return-pc old-fp return-pc) (trace-table-entry trace-table-fun-epilogue) - ;; Load the return-pc. - (move rax return-pc) (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 rsp-tn rbp-tn) - (move rbp-tn old-fp-temp) + ;; Clear the stack until ocfp. + (inst mov rsp-tn rbp-tn) ;; clear the multiple-value return flag (inst clc) ;; Out of here. - (inst jmp rax) - + (inst pop rbp-tn) + (inst ret) ;; Nope, not the single case. Jump to the assembly routine. (emit-label not-single))) (move rsi vals) (move rcx nvals) - (move rbx rbp-tn) - (move rbp-tn old-fp) - (inst lea return-asm - (make-ea :qword :disp (make-fixup 'return-multiple - :assembly-routine))) + (inst mov return-asm (make-fixup 'return-multiple :assembly-routine)) (inst jmp return-asm) (trace-table-entry trace-table-normal))) @@ -1144,43 +1112,38 @@ ;;; Copy a &MORE arg from the argument area to the end of the current ;;; frame. FIXED is the number of non-&MORE arguments. -;;; -;;; The tricky part is doing this without trashing any of the calling -;;; convention registers that are still needed. This vop is emitted -;;; directly after the xep-allocate frame. That means the registers -;;; are in use as follows: -;;; -;;; RAX -- The lexenv. -;;; RBX -- Available. -;;; RCX -- The total number of arguments. -;;; RDX -- The first arg. -;;; RDI -- The second arg. -;;; RSI -- The third arg. -;;; -;;; So basically, we have one register available for our use: RBX. -;;; -;;; What we can do is push the other regs onto the stack, and then -;;; restore their values by looking directly below where we put the -;;; more-args. (define-vop (copy-more-arg) + (:temporary (:sc any-reg :offset r8-offset) copy-index) + (:temporary (:sc any-reg :offset r9-offset) source) + (:temporary (:sc descriptor-reg :offset r10-offset) temp) (:info fixed) (:generator 20 ;; Avoid the copy if there are no more args. (cond ((zerop fixed) - (inst jecxz JUST-ALLOC-FRAME)) + (inst jrcxz JUST-ALLOC-FRAME)) (t (inst cmp rcx-tn (fixnumize fixed)) (inst jmp :be JUST-ALLOC-FRAME))) + ;; Create a negated copy of the number of arguments to allow us to + ;; use EA calculations in order to do scaled subtraction. + (inst mov temp rcx-tn) + (inst neg temp) + ;; Allocate the space on the stack. - ;; stack = rbp - (max 3 frame-size) - (nargs - fixed) - (inst lea rbx-tn + ;; stack = rbp + sp->fp-offset - (max 3 frame-size) - (nargs - fixed) + ;; if we'd move SP backward, swap the meaning of rsp and source; + ;; otherwise, we'd be accessing values below SP, and that's no good + ;; if a signal interrupts this code sequence. In that case, store + ;; the final value in rsp after the stack-stack memmove loop. + (inst lea (if (<= fixed (max 3 (sb-allocated-size 'stack))) + rsp-tn + source) (make-ea :qword :base rbp-tn - :disp (- (fixnumize fixed) - (* n-word-bytes - (max 3 (sb-allocated-size 'stack)))))) - (inst sub rbx-tn rcx-tn) ; Got the new stack in rbx - (inst mov rsp-tn rbx-tn) + :index temp :scale (ash 1 (- word-shift n-fixnum-tag-bits)) + :disp (* n-word-bytes + (- (+ sp->fp-offset fixed) + (max 3 (sb-allocated-size 'stack)))))) ;; Now: nargs>=1 && nargs>fixed @@ -1188,111 +1151,132 @@ (inst mov rbx-tn rcx-tn) (cond ((< fixed register-arg-count) + ;; the code above only moves the final value of rsp in + ;; rsp directly if that condition is satisfied. Currently, + ;; r-a-c is 3, so the aver is OK. If the calling convention + ;; ever changes, the logic above with LEA will have to be + ;; adjusted. + (aver (<= fixed (max 3 (sb-allocated-size 'stack)))) ;; 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 rcx-tn (fixnumize register-arg-count)) + (inst sub rbx-tn (fixnumize register-arg-count)) ;; Everything of interest in registers. (inst jmp :be DO-REGS)) (t ;; Number to copy = nargs-fixed - (inst sub rcx-tn (fixnumize fixed)))) - - ;; Save rdi and rsi register args. - (inst push rdi-tn) - (inst push rsi-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 rdi-tn (make-ea :qword :base rsp-tn :disp 16)) - - ;; Initialize src to be end of args. - (inst mov rsi-tn rbp-tn) - (inst sub rsi-tn rbx-tn) - - (inst shr rcx-tn word-shift) ; make word count - ;; And copy the args. - (inst cld) ; auto-inc RSI and RDI. - (inst rep) - (inst movs :qword) + (inst sub rbx-tn (fixnumize fixed)))) - ;; So now we need to restore RDI and RSI. - (inst pop rsi-tn) - (inst pop rdi-tn) + ;; Initialize R8 to be the end of args. + ;; Swap with SP if necessary to mirror the previous condition + (inst lea (if (<= fixed (max 3 (sb-allocated-size 'stack))) + source + rsp-tn) + (make-ea :qword :base rbp-tn + :index temp :scale (ash 1 (- word-shift n-fixnum-tag-bits)) + :disp (* sp->fp-offset n-word-bytes))) + ;; src: rbp + temp + sp->fp + ;; dst: rbp + temp + sp->fp + (fixed - (max 3 [stack-size])) + (let ((delta (- fixed (max 3 (sb-allocated-size 'stack)))) + (loop (gen-label)) + (fixnum->word (ash 1 (- word-shift n-fixnum-tag-bits)))) + (cond ((zerop delta)) ; no-op move + ((minusp delta) + ;; dst is lower than src, copy forward + (zeroize copy-index) + ;; We used to use REP MOVS here, but on modern x86 it performs + ;; much worse than an explicit loop for small blocks. + + (emit-label loop) + (inst mov temp (make-ea :qword :base source :index copy-index)) + (inst mov (make-ea :qword :base rsp-tn :index copy-index) temp) + (inst add copy-index n-word-bytes) + (inst sub rbx-tn (fixnumize 1)) + (inst jmp :nz loop)) + ((plusp delta) + ;; dst is higher than src; copy backward + (emit-label loop) + (inst sub rbx-tn (fixnumize 1)) + (inst mov temp (make-ea :qword :base rsp-tn + :index rbx-tn :scale fixnum->word)) + (inst mov (make-ea :qword :base source + :index rbx-tn :scale fixnum->word) + temp) + (inst jmp :nz loop) + ;; done with the stack--stack copy. Reset RSP to its final + ;; value + (inst mov rsp-tn source)))) DO-REGS - ;; Restore RCX - (inst mov rcx-tn rbx-tn) - ;; 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 rbp - (inst mov (make-ea :qword :base rbp-tn - :disp (- (* n-word-bytes - (+ 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 rcx-tn rcx-tn) - (inst cmp rcx-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 rbp + (inst mov (make-ea :qword :base rbp-tn + :disp (* n-word-bytes + (- sp->fp-offset + (+ 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 rcx-tn rcx-tn) + (inst cmp rcx-tn (fixnumize i))) + (inst jmp :eq DONE))) (inst jmp DONE) JUST-ALLOC-FRAME (inst lea rsp-tn (make-ea :qword :base rbp-tn - :disp (- (* n-word-bytes + :disp (* n-word-bytes + (- sp->fp-offset (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) :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 :qword :base object :index temp)))) + (:results (value :scs (descriptor-reg any-reg)) + (keyword :scs (descriptor-reg any-reg))) + (:result-types * *) + (:generator 4 + (inst mov value (make-ea :qword :base object :index index + :scale (ash 1 (- word-shift n-fixnum-tag-bits)))) + (inst mov keyword (make-ea :qword :base object :index index + :scale (ash 1 (- word-shift n-fixnum-tag-bits)) + :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 :qword :base object :disp (- (* index n-word-bytes)))))) + (move value index) + (inst neg value) + (inst mov value (make-ea :qword :base object :index value + :scale (ash 1 (- word-shift n-fixnum-tag-bits)))))) ;;; 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) @@ -1314,16 +1298,10 @@ (move rcx 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 :qword :index rcx :scale 2)) + (inst jrcxz done) + (inst lea dst (make-ea :qword :index rcx :scale (ash 2 (- word-shift n-fixnum-tag-bits)))) (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 rcx (1- n-lowtag-bits)) - ;; Set decrement mode (successive args at lower addresses) - (inst std) + (allocation dst dst node stack-allocate-p list-pointer-lowtag) ;; Set up the result. (move result dst) ;; Jump into the middle of the loop, 'cause that's where we want @@ -1336,10 +1314,12 @@ (storew dst dst -1 list-pointer-lowtag) (emit-label enter) ;; Grab one value and stash it in the car of this cons. - (inst lods rax) + (inst mov rax (make-ea :qword :base src)) + (inst sub src n-word-bytes) (storew rax dst 0 list-pointer-lowtag) ;; Go back for more. - (inst loop loop) + (inst sub rcx (fixnumize 1)) + (inst jmp :nz loop) ;; NIL out the last cons. (storew nil-value dst 1 list-pointer-lowtag)) (emit-label done)))) @@ -1369,8 +1349,9 @@ ;; SP at this point points at the last arg pushed. ;; Point to the first more-arg, not above it. (inst lea context (make-ea :qword :base rsp-tn - :index count :scale 1 - :disp (- (+ (fixnumize fixed) n-word-bytes)))) + :index count + :scale (ash 1 (- word-shift n-fixnum-tag-bits)) + :disp (- (* (1+ fixed) n-word-bytes)))) (unless (zerop fixed) (inst sub count (fixnumize fixed))))) @@ -1385,7 +1366,7 @@ (: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))) @@ -1403,7 +1384,7 @@ (:vop-var vop) (:save-p :compute-only) (:generator 1000 - (error-call vop ,error ,@args))))) + (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 @@ -1415,3 +1396,37 @@ (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. While this isn't critical for x86-64, + ;; it's more serious for x86. + #!+sb-thread + (inst cmp (make-ea :qword + :base thread-base-tn + :disp (* thread-stepping-slot n-word-bytes)) + nil-value) + #!-sb-thread + (inst cmp (make-ea :qword + :disp (+ nil-value (static-symbol-offset + 'sb!impl::*stepping*) + (* symbol-value-slot n-word-bytes) + (- other-pointer-lowtag))) + 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)))