| blob | 67e1cb7e6c70696db35689ddfb11e6cf669eca49 |
1 ;;;; function call for the x86 VM
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
30 ;;; Make the TNs used to hold OLD-FP and RETURN-PC within the current
31 ;;; function. We treat these specially so that the debugger can find
32 ;;; them at a known location.
33 ;;;
34 ;;; Without using a save-tn - which does not make much sense if it is
35 ;;; wired to the stack?
38 control-stack-sc-number
39 ocfp-save-offset)))
41 tn))
44 sap-stack-sc-number return-pc-save-offset)))
46 tn))
48 ;;; Make a TN for the standard argument count passing location. We only
49 ;;; need to make the standard location, since a count is never passed when we
50 ;;; are using non-standard conventions.
53 \f
54 ;;;; frame hackery
56 ;;; This is used for setting up the Old-FP in local call.
62 ;;; We don't have a separate NFP, so we don't need to do anything here.
67 nil))
69 ;;; Accessing a slot from an earlier stack frame is definite hackery.
92 frame-pointer)))
123 collect
124 `(,name
130 fp value res))
133 fp new-val value)))))))))
135 ancestor-frame-ref/double-float
138 ancestor-frame-ref/single-float
141 ancestor-frame-ref/complex-double-float
144 ancestor-frame-ref/complex-single-float
147 ancestor-frame-ref/signed-byte-64
150 ancestor-frame-ref/unsigned-byte-64
153 ancestor-frame-ref/unsigned-byte-64
156 ancestor-frame-ref/system-area-pointer
167 ;; Skip space for the function header.
170 ;; The start of the actual code.
171 ;; Save the return-pc.
185 ;;; This is emitted directly before either a known-call-local, call-local,
186 ;;; or a multiple-call-local. All it does is allocate stack space for the
187 ;;; callee (who has the same size stack as us).
198 ;; Avoid using a temporary register if the new frame pointer will be
199 ;; at the same location as the new stack pointer
203 nargs
206 n-word-bytes)))
210 ;;; Allocate a partial frame for passing stack arguments in a full
211 ;;; call. NARGS is the number of arguments passed. We allocate at
212 ;;; least 2 slots, because the XEP noise is going to want to use them
213 ;;; before it can extend the stack.
220 nargs
223 n-word-bytes)))
230 \f
231 ;;; Emit code needed at the return-point from an unknown-values call
232 ;;; for a fixed number of values. Values is the head of the TN-REF
233 ;;; list for the locations that the values are to be received into.
234 ;;; Nvals is the number of values that are to be received (should
235 ;;; equal the length of Values).
236 ;;;
237 ;;; If 0 or 1 values are expected, then we just emit an instruction to
238 ;;; reset the SP (which will only be executed when other than 1 value
239 ;;; is returned.)
240 ;;;
241 ;;; In the general case we have to do three things:
242 ;;; -- Default unsupplied register values. This need only be done
243 ;;; when a single value is returned, since register values are
244 ;;; defaulted by the called in the non-single case.
245 ;;; -- Default unsupplied stack values. This needs to be done whenever
246 ;;; there are stack values.
247 ;;; -- Reset SP. This must be done whenever other than 1 value is
248 ;;; returned, regardless of the number of values desired.
275 max-values)))
295 SKIP)))
302 register-arg-count)))
318 ;; Default the unsupplied registers.
328 for count from 2 below register-arg-count
330 do
334 regs-defaulted))
337 (< register-arg-count
351 collect tn
355 while ref
362 ;; If it returned exactly one value the registers and the
363 ;; stack slots need to be filled with NIL.
371 for reg in used-registers
374 REGS-DEFAULTED
384 ;; Note that the max number of values received
385 ;; is assumed to fit in a :dword register.
394 DEFAULTING-DONE
398 DONE
406 for reg in used-registers
413 \f
414 ;;;; unknown values receiving
416 ;;; Emit code needed at the return point for an unknown-values call
417 ;;; for an arbitrary number of values.
418 ;;;
419 ;;; We do the single and non-single cases with no shared code: there
420 ;;; doesn't seem to be any potential overlap, and receiving a single
421 ;;; value is more important efficiency-wise.
422 ;;;
423 ;;; When there is a single value, we just push it on the stack,
424 ;;; returning the old SP and 1.
425 ;;;
426 ;;; When there is a variable number of values, we move all of the
427 ;;; argument registers onto the stack, and return ARGS and NARGS.
428 ;;;
429 ;;; ARGS and NARGS are TNs wired to the named locations. We must
430 ;;; explicitly allocate these TNs, since their lifetimes overlap with
431 ;;; the results start and count. (Also, it's nice to be able to target
432 ;;; them.)
453 ;; The stack frame is burnt and RETurned from if there are no
454 ;; stack values. In this case quickly reallocate sufficient space.
456 register-arg-count)
468 ;; dtc: this writes the registers onto the stack even if they are
469 ;; not needed, only the number specified in rcx are used and have
470 ;; stack allocated to them. No harm is done.
473 for i downfrom -1
484 ;;; VOP that can be inherited by unknown values receivers. The main thing this
485 ;;; handles is allocation of the result temporaries.
489 values-start)
492 nvals)
495 \f
496 ;;;; local call with unknown values convention return
499 #+nil
503 #+nil
515 ;;; The local call convention doesn't fit that well with x86-style
516 ;;; calls. Emit a header for local calls to pop the return address
517 ;;; in the right place.
528 ;;; Non-TR local call for a fixed number of values passed according to
529 ;;; the unknown values convention.
530 ;;;
531 ;;; FP is the frame pointer in install before doing the call.
532 ;;;
533 ;;; NFP would be the number-stack frame pointer if we had a separate
534 ;;; number stack.
535 ;;;
536 ;;; Args are the argument passing locations, which are specified only
537 ;;; to terminate their lifetimes in the caller.
538 ;;;
539 ;;; VALUES are the return value locations (wired to the standard
540 ;;; passing locations). NVALS is the number of values received.
541 ;;;
542 ;;; Save is the save info, which we can ignore since saving has been
543 ;;; done.
544 ;;;
545 ;;; TARGET is a continuation pointing to the start of the called
546 ;;; function.
565 ;;; Non-TR local call for a variable number of return values passed according
566 ;;; to the unknown values convention. The results are the start of the values
567 ;;; glob and the number of values received.
584 \f
585 ;;;; local call with known values return
587 ;;; Non-TR local call with known return locations. Known-value return
588 ;;; works just like argument passing in local call.
589 ;;;
590 ;;; Note: we can't use normal load-tn allocation for the fixed args,
591 ;;; since all registers may be tied up by the more operand. Instead,
592 ;;; we use MAYBE-LOAD-STACK-TN.
608 \f
609 ;;; From Douglas Crosher
610 ;;; Return from known values call. We receive the return locations as
611 ;;; arguments to terminate their lifetimes in the returning function. We
612 ;;; restore FP and CSP and jump to the Return-PC.
623 ;; Zot all of the stack except for the old-fp and return-pc.
626 \f
627 ;;;; full call
628 ;;;
629 ;;; There is something of a cross-product effect with full calls.
630 ;;; Different versions are used depending on whether we know the
631 ;;; number of arguments or the name of the called function, and
632 ;;; whether we want fixed values, unknown values, or a tail call.
633 ;;;
634 ;;; In full call, the arguments are passed creating a partial frame on
635 ;;; the stack top and storing stack arguments into that frame. On
636 ;;; entry to the callee, this partial frame is pointed to by FP.
638 ;;; This macro helps in the definition of full call VOPs by avoiding
639 ;;; code replication in defining the cross-product VOPs.
640 ;;;
641 ;;; NAME is the name of the VOP to define.
642 ;;;
643 ;;; NAMED is true if the first argument is an fdefinition object whose
644 ;;; definition is to be called.
645 ;;;
646 ;;; RETURN is either :FIXED, :UNKNOWN or :TAIL:
647 ;;; -- If :FIXED, then the call is for a fixed number of values, returned in
648 ;;; the standard passing locations (passed as result operands).
649 ;;; -- If :UNKNOWN, then the result values are pushed on the stack, and the
650 ;;; result values are specified by the Start and Count as in the
651 ;;; unknown-values continuation representation.
652 ;;; -- If :TAIL, then do a tail-recursive call. No values are returned.
653 ;;; The Old-Fp and Return-PC are passed as the second and third arguments.
654 ;;;
655 ;;; In non-tail calls, the pointer to the stack arguments is passed as
656 ;;; the last fixed argument. If Variable is false, then the passing
657 ;;; locations are passed as a more arg. Variable is true if there are
658 ;;; a variable number of arguments passed on the stack. Variable
659 ;;; cannot be specified with :TAIL return. TR variable argument call
660 ;;; is implemented separately.
661 ;;;
662 ;;; In tail call with fixed arguments, the passing locations are
663 ;;; passed as a more arg, but there is no new-FP, since the arguments
664 ;;; have been set up in the current frame.
694 ;; Intuitively you might want FUN to be the first codegen arg,
695 ;; but that won't work, because EMIT-ARG-MOVES wants the
696 ;; passing locs in (FIRST (vop-codegen-info vop)).
699 step-instrumenting
706 ;; For anonymous call, RAX is the function. For named call, RAX will be the linkage
707 ;; table base if not stepping, or the linkage cell itself if stepping.
708 ;; Calls from immobile-space without stepping avoid using RAX, and instead
709 ;; access the linkage table relative to RIP.
712 ;; We pass the number of arguments in RCX.
713 (:temporary
715 rcx)
718 ;; Save it for DEFAULT-UNKNOWN-VALUES to work
722 ;; With variable call, we have to load the
723 ;; register-args out of the (new) stack frame before
724 ;; doing the call. Therefore, we have to tell the
725 ;; lifetime stuff that we need to use them.
737 old-fp-tmp)))
743 15
748 ;; This has to be done before the frame pointer is
749 ;; changed! RAX stores the 'lexical environment' needed
750 ;; for closures.
754 ;; For variable call, compute the number of
755 ;; arguments and move some of the arguments to
756 ;; registers.
760 ;; Move the necessary args to registers,
761 ;; this moves them all even if they are
762 ;; not all needed.
764 for index downfrom -1
773 ;; return to so might as well use that clue.
774 ;; This seems really important to the
775 ;; implementation of things like
776 ;; (without-interrupts ...)
777 ;;
778 ;; dtc; Could be doing a tail call from a
779 ;; known-call-local etc in which the old-fp
780 ;; or ret-pc are in regs or in non-standard
781 ;; places. If the passing location were
782 ;; wired to the stack in standard locations
783 ;; then these moves will be un-necessary;
784 ;; this is probably best for the x86.
788 ;; FIXME: FORMAT T for stale
789 ;; diagnostic output (several of
790 ;; them around here), ick
798 ;; For tail call, we have to push the
799 ;; return-pc so that it looks like we CALLed
800 ;; despite the fact that we are going to JMP.
803 ;; For non-tail call, we have to save our
804 ;; frame pointer and install the new frame
805 ;; pointer. We can't load stack tns after this
806 ;; point.
808 ;; here which doesn't leave room for the
809 ;; ofp/ret stuff.
811 ;; The variable args are on the stack and
812 ;; become the frame, but there may be <3
813 ;; args and 3 stack slots are assumed
814 ;; allocate on the call. So need to ensure
815 ;; there are at least 3 slots. This hack
816 ;; just adds 3 more.
820 ;; Bias the new-fp for use as an fp
824 ;; Save the fp
833 DONE
837 node step-instrumenting))
844 (:unknown
864 ;;; Call NAME "directly" meaning in a single JMP or CALL instruction,
865 ;;; if possible (without loading RAX)
868 ;; If step-instrumenting, then RAX points to the linkage table cell
873 ;; get the linkage table base into RAX
877 ;;; Invoke the function-designator FUN.
881 fun)))
883 (:designator
889 not-fun))
891 not-fun
894 (:symbol
901 (:symbol
911 call
913 fun))
914 ret))))
916 ;;; This is defined separately, since it needs special code that BLT's
917 ;;; the arguments down. All the real work is done in the assembly
918 ;;; routine. We just set things up so that it can find what it needs.
930 ;; Move these into the passing locations if they are not already there.
933 ;; And jump to the assembly routine.
935 'tail-call-variable
937 vop)))
938 \f
939 ;;;; unknown values return
941 ;;; Return a single-value using the Unknown-Values convention.
942 ;;;
943 ;;; pfw--get wired-tn conflicts sometimes if register sc specd for args
944 ;;; having problems targeting args to regs -- using temps instead.
945 ;;;
946 ;;; First off, modifying the return-pc defeats the branch-prediction
947 ;;; optimizations on modern CPUs quite handily. Second, we can do all
948 ;;; this without needing a temp register. Fixed the latter, at least.
949 ;;; -- AB 2006/Feb/04
957 ;; Drop stack above old-fp and restore old frame pointer
959 ;; Clear the multiple-value return flag
961 ;; And return.
964 ;;; Do unknown-values return of a fixed (other than 1) number of
965 ;;; values. The VALUES are required to be set up in the standard
966 ;;; passing locations. NVALS is the number of values returned.
967 ;;;
968 ;;; Basically, we just load RCX with the number of values returned and
969 ;;; RBX with a pointer to the values, set RSP to point to the end of
970 ;;; the values, and jump directly to return-pc.
977 ;; In the case of other than one value, we need these registers to
978 ;; tell the caller where they are and how many there are.
981 ;; We need to stretch the lifetime of return-pc past the argument
982 ;; registers so that we can default the argument registers without
983 ;; trashing return-pc.
994 ;; This is handled in RETURN-SINGLE.
996 ;; Establish the values pointer and values count.
1001 ;; Pre-default any argument register that need it.
1008 ;; Set the multiple value return flag.
1010 ;; And away we go. Except that return-pc is still on the
1011 ;; stack and we've changed the stack pointer. So we have to
1012 ;; tell it to index off of RBX instead of RBP.
1017 ;; Some values are on the stack after RETURN-PC and OLD-FP,
1018 ;; can't return normally and some slots of the frame will
1019 ;; be used as temporaries by the receiver.
1020 ;;
1021 ;; Clear as much of the stack as possible, but not past the
1022 ;; old frame address.
1028 rbx))
1031 ;;; Do unknown-values return of an arbitrary number of values (passed
1032 ;;; on the stack.) We check for the common case of a single return
1033 ;;; value, and do that inline using the normal single value return
1034 ;;; convention. Otherwise, we branch off to code that calls an
1035 ;;; assembly-routine.
1036 ;;;
1037 ;;; The assembly routine takes the following args:
1038 ;;; RCX -- number of values to find there.
1039 ;;; RSI -- pointer to where to find the values.
1054 ;; Check for the single case.
1058 ;; Return with one value.
1060 ;; Clear the stack until ocfp.
1062 ;; clear the multiple-value return flag
1064 ;; Out of here.
1066 ;; Nope, not the single case. Jump to the assembly routine.
1071 \f
1072 ;;;; XEP hackery
1074 ;;; Get the lexical environment from its passing location.
1080 ;; Get result.
1083 ;;; Copy a &MORE arg from the argument area to the end of the current
1084 ;;; frame. FIXED is the number of non-&MORE arguments.
1091 ;; Avoid the copy if there are no more args.
1097 ;; verify-arg-count will do a CMP
1103 ;; Create a negated copy of the number of arguments to allow us to
1104 ;; use EA calculations in order to do scaled subtraction.
1108 ;; Allocate the space on the stack.
1109 ;; stack = rbp + sp->fp-offset - frame-size - (nargs - fixed)
1110 ;; if we'd move SP backward, swap the meaning of rsp and source;
1111 ;; otherwise, we'd be accessing values below SP, and that's no good
1112 ;; if a signal interrupts this code sequence. In that case, store
1113 ;; the final value in rsp after the stack-stack memmove loop.
1122 ;; Now: nargs>=1 && nargs>fixed
1125 ;; the code above only moves the final value of rsp in
1126 ;; rsp directly if that condition is satisfied. Currently,
1127 ;; r-a-c is 3, so the aver is OK. If the calling convention
1128 ;; ever changes, the logic above with LEA will have to be
1129 ;; adjusted.
1131 ;; We must stop when we run out of stack args, not when we
1132 ;; run out of more args.
1133 ;; Number to copy = nargs-3
1134 ;; Save the original count of args.
1137 ;; Everything of interest in registers.
1140 ;; Number to copy = nargs-fixed
1143 ;; Initialize R8 to be the end of args.
1144 ;; Swap with SP if necessary to mirror the previous condition
1150 ;; src: rbp + temp + sp->fp
1151 ;; dst: rbp + temp + sp->fp + (fixed - [stack-size])
1154 ;; dst is lower than src, copy forward
1156 ;; We used to use REP MOVS here, but on modern x86 it performs
1157 ;; much worse than an explicit loop for small blocks.
1166 ;; dst is higher than src; copy backward
1172 ;; done with the stack--stack copy. Reset RSP to its final
1173 ;; value
1175 DO-REGS
1177 ;; Here: nargs>=1 && nargs>fixed
1179 ;; Now we have to deposit any more args that showed up in
1180 ;; registers.
1183 ;; Store it relative to rbp
1187 rbp-tn)
1194 ;; Don't deposit any more than there are.
1199 ;; Use a single comparison for 1 and 2
1208 JUST-ALLOC-FRAME
1210 (* n-word-bytes
1214 DONE))
1268 done))
1270 ;;; Turn more arg (context, count) into a list.
1271 ;;; Cons cells will be filled in right-to-left.
1272 ;;; This has a slight advantage in code size, and eliminates an initial
1273 ;;; forward jump into the loop. it also admits an interesting possibility
1274 ;;; to reduce the scope of the pseudo-atomic section so as not to
1275 ;;; encompass construction of the list. To do that, we will need to invent
1276 ;;; a new widetag for "contiguous CONS block" which has a header conveying
1277 ;;; the total payload length. Initially we would store that into the CAR of the
1278 ;;; first cons cell. Upon seeing such header, GC shall treat that entire object
1279 ;;; as a boxed payload of specified length. It will be implicitly pinned
1280 ;;; (if conservative) or transported as a whole (if precise). Then when the CAR
1281 ;;; of the first cons is overwritten, the object changes to a linked list.
1285 ;; CONTEXT is used throughout the copying loop
1289 ;; The only advantage to specifying RCX here is that JRCXZ can be used
1290 ;; in one place, and then only in the unlikely scenario that CONTEXT is not
1291 ;; in RCX. If it was, SHL sets/clears the Z flag, but LEA doesn't.
1292 ;; Not much of an advantage, but why not.
1294 ;; Note that DST conflicts with RESULT because we use both as temps
1300 #|
1301 ;; TODO: if instrumenting, just revert to the older way of precomputing
1302 ;; a size rather than scaling by 8 in ALLOCATION so that we don't have
1303 ;; to scale and unscale.
1304 ;; Compute the number of bytes to allocate
1309 |#
1311 ;; Setup for the CDR of the last cons (or the entire result) being NIL.
1323 ;; Produce an untagged pointer into DST
1326 ;; LEA on RSP would be ok but we'd need to negate RCX first, then un-negate
1327 ;; to compute the final cons, then negate again. So use SHL and SUB instead.
1334 :overflow
1340 node)
1344 ;; Recalculate DST as a tagged pointer to the last cons
1346 ;; scale=8 implies RCX counts ncells (as a fixnum) therefore just untag it.
1347 ;; scale=1 implies RCX counts nbytes therefore ncells = RCX/16
1349 ;; The rightmost arguments are at lower addresses.
1350 ;; Start by indexing the last argument
1352 LOOP
1353 ;; Grab one value and store into this cons. Use RCX as an index into the
1354 ;; vector of values in CONTEXT, but add 8 because CONTEXT points exactly at
1355 ;; the 0th value, which means that the index is 1 word too low.
1356 ;; (It's -1 if there is exactly 1 value, instead of 0, and so on)
1358 ;; RESULT began as NIL which gives the correct value for the CDR in the final cons.
1359 ;; Subsequently it points to each cons just populated, which is correct all the way
1360 ;; up to and including the final result.
1367 ALLOC-DONE)
1368 DONE))
1370 ;;; Return the location and size of the &MORE arg glob created by
1371 ;;; COPY-MORE-ARG. SUPPLIED is the total number of arguments supplied
1372 ;;; (originally passed in RCX). FIXED is the number of non-rest
1373 ;;; arguments.
1374 ;;;
1375 ;;; We must duplicate some of the work done by COPY-MORE-ARG, since at
1376 ;;; that time the environment is in a pretty brain-damaged state,
1377 ;;; preventing this info from being returned as values. What we do is
1378 ;;; compute supplied - fixed, and return a pointer that many words
1379 ;;; below the current stack top.
1392 ;; SP at this point points at the last arg pushed.
1393 ;; Point to the first more-arg, not above it.
1395 rsp-tn count
1409 ;; NOTE: copy-more-arg expects this to issue a CMP for min > 1
1430 ;;; Single-stepping
1433 ;; We use different ways of representing whether stepping is on on
1434 ;; +SB-THREAD / -SB-THREAD: on +SB-THREAD, we use a slot in the
1435 ;; thread structure. On -SB-THREAD we use the value of a static
1436 ;; symbol. Things are done this way, since reading a thread-local
1437 ;; slot from a symbol would require an extra register on +SB-THREAD,
1438 ;; and reading a slot from a thread structure would require an extra
1439 ;; register on -SB-THREAD. While this isn't critical for x86-64,
1440 ;; it's more serious for x86.
1451 DONE