| blob | b3b4abb37a7b10db966db302658b6308dd27c7c5 |
1 ;;;; the VM definition of function call for the Sparc
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.
14 \f
15 ;;;; Interfaces to IR2 conversion:
17 ;;; Return a wired TN describing the N'th full call argument passing
18 ;;; location.
27 ;;; Make a passing location TN for a local call return PC. If
28 ;;; standard is true, then use the standard (full call) location,
29 ;;; otherwise use any legal location. Even in the non-standard case,
30 ;;; this may be restricted by a desire to use a subroutine call
31 ;;; instruction.
37 ;;; This is similar to MAKE-RETURN-PC-PASSING-LOCATION, but makes a
38 ;;; location to pass OLD-FP in. This is (obviously) wired in the
39 ;;; standard convention, but is totally unrestricted in non-standard
40 ;;; conventions, since we can always fetch it off of the stack using
41 ;;; the arg pointer.
47 ;;; Make the TNs used to hold Old-FP and Return-PC within the current
48 ;;; function. We treat these specially so that the debugger can find
49 ;;; them at a known location.
54 control-stack-arg-scn
55 ocfp-save-offset)))
61 control-stack-arg-scn
62 lra-save-offset)))
64 ;;; Make a TN for the standard argument count passing location. We
65 ;;; only need to make the standard location, since a count is never
66 ;;; passed when we are using non-standard conventions.
71 ;;; Make a TN to hold the number-stack frame pointer. This is
72 ;;; allocated once per component, and is component-live.
83 ;;; Return a list of TNs that can be used to represent an
84 ;;; unknown-values continuation within a function.
90 ;;; This function is called by the ENTRY-ANALYZE phase, allowing
91 ;;; VM-dependent initialization of the IR2-COMPONENT structure. We push
92 ;;; placeholder entries in the CONSTANTS to leave room for additional
93 ;;; noise in the code object header.
100 \f
101 ;;;; Frame hackery:
103 ;;; Return the number of bytes needed for the current non-descriptor
104 ;;; stack frame. Non-descriptor stack frames must be multiples of 8
105 ;;; bytes on the PMAX.
108 n-word-bytes))
110 ;;; Used for setting up the Old-FP in local call.
116 ;;; Used for computing the caller's NFP for use in known-values return. Only
117 ;;; works assuming there is no variable size stuff on the nstack.
118 ;;;
134 ;; Make sure the function is aligned, and drop a label pointing to this
135 ;; function header.
139 ;; Allocate function header.
143 ;; The start of the actual code.
144 ;; Fix CODE, cause the function object was passed in.
146 ;; Build our stack frames.
169 ;;; Allocate a partial frame for passing stack arguments in a full call. Nargs
170 ;;; is the number of arguments passed. If no stack arguments are passed, then
171 ;;; we don't have to do anything.
172 ;;;
183 \f
184 ;;; Emit code needed at the return-point from an unknown-values call
185 ;;; for a fixed number of values. Values is the head of the TN-REF
186 ;;; list for the locations that the values are to be received into.
187 ;;; Nvals is the number of values that are to be received (should
188 ;;; equal the length of Values).
189 ;;;
190 ;;; Move-Temp is a Descriptor-Reg TN used as a temporary.
191 ;;;
192 ;;; This code exploits the fact that in the unknown-values convention,
193 ;;; a single value return returns at the return PC + 8, whereas a
194 ;;; return of other than one value returns directly at the return PC.
195 ;;;
196 ;;; If 0 or 1 values are expected, then we just emit an instruction to
197 ;;; reset the SP (which will only be executed when other than 1 value
198 ;;; is returned.)
199 ;;;
200 ;;; In the general case, we have to do three things:
201 ;;; -- Default unsupplied register values. This need only be done when a
202 ;;; single value is returned, since register values are defaulted by the
203 ;;; called in the non-single case.
204 ;;; -- Default unsupplied stack values. This needs to be done whenever there
205 ;;; are stack values.
206 ;;; -- Reset SP. This must be done whenever other than 1 value is returned,
207 ;;; regardless of the number of values desired.
208 ;;;
209 ;;; The general-case code looks like this:
210 #|
211 b regs-defaulted ; Skip if MVs
212 nop
214 move a1 null-tn ; Default register values
215 ...
217 move old-fp csp ; Set up args for SP resetting
219 regs-defaulted
220 subcc temp nargs register-arg-count
224 subcc temp 1
225 store-stack-tn val4-tn move-temp
227 b :lt default-value-8
228 loadw move-temp ocfp-tn 7
229 subcc temp 1
230 store-stack-tn val5-tn move-temp
232 ...
234 defaulting-done
235 move csp ocfp ; Reset SP.
239 default-value-7
240 store-stack-tn val4-tn null-tn ; Nil out 7'th value. (first on stack)
242 default-value-8
243 store-stack-tn val5-tn null-tn ; Nil out 8'th value.
245 ...
247 br defaulting-done
248 nop
249 |#
263 ;; Branch off to the MV case.
271 ;; Do the single value calse.
319 \f
320 ;;; Emit code needed at the return point for an unknown-values call
321 ;;; for an arbitrary number of values.
322 ;;;
323 ;;; We do the single and non-single cases with no shared code: there
324 ;;; doesn't seem to be any potential overlap, and receiving a single
325 ;;; value is more important efficiency-wise.
326 ;;;
327 ;;; When there is a single value, we just push it on the stack,
328 ;;; returning the old SP and 1.
329 ;;;
330 ;;; When there is a variable number of values, we move all of the
331 ;;; argument registers onto the stack, and return ARGS and NARGS.
332 ;;;
333 ;;; ARGS and NARGS are TNs wired to the named locations. We must
334 ;;; explicitly allocate these TNs, since their lifetimes overlap with
335 ;;; the results START and COUNT. (Also, it's nice to be able to target
336 ;;; them.)
369 ;;; VOP that can be inherited by unknown values receivers. The main
370 ;;; thing this handles is allocation of the result temporaries.
372 (:results
377 values-start)
380 nvals)
384 \f
385 ;;;; Local call with unknown values convention return:
387 ;;; Non-TR local call for a fixed number of values passed according to the
388 ;;; unknown values convention.
389 ;;;
390 ;;; Args are the argument passing locations, which are specified only to
391 ;;; terminate their lifetimes in the caller.
392 ;;;
393 ;;; Values are the return value locations (wired to the standard passing
394 ;;; locations).
395 ;;;
396 ;;; Save is the save info, which we can ignore since saving has been done.
397 ;;; Return-PC is the TN that the return PC should be passed in.
398 ;;; Target is a continuation pointing to the start of the called function.
399 ;;; Nvals is the number of values received.
400 ;;;
401 ;;; Note: we can't use normal load-tn allocation for the fixed args, since all
402 ;;; registers may be tied up by the more operand. Instead, we use
403 ;;; MAYBE-LOAD-STACK-TN.
440 ;;; Non-TR local call for a variable number of return values passed according
441 ;;; to the unknown values convention. The results are the start of the values
442 ;;; glob and the number of values received.
443 ;;;
444 ;;; Note: we can't use normal load-tn allocation for the fixed args, since all
445 ;;; registers may be tied up by the more operand. Instead, we use
446 ;;; MAYBE-LOAD-STACK-TN.
479 \f
480 ;;;; Local call with known values return:
482 ;;; Non-TR local call with known return locations. Known-value return works
483 ;;; just like argument passing in local call.
484 ;;;
485 ;;; Note: we can't use normal load-tn allocation for the fixed args, since all
486 ;;; registers may be tied up by the more operand. Instead, we use
487 ;;; MAYBE-LOAD-STACK-TN.
521 ;;; Return from known values call. We receive the return locations as
522 ;;; arguments to terminate their lifetimes in the returning function. We
523 ;;; restore FP and CSP and jump to the Return-PC.
524 ;;;
525 ;;; Note: we can't use normal load-tn allocation for the fixed args, since all
526 ;;; registers may be tied up by the more operand. Instead, we use
527 ;;; MAYBE-LOAD-STACK-TN.
547 number-stack-displacement))))
552 \f
553 ;;;; Full call:
554 ;;;
555 ;;; There is something of a cross-product effect with full calls.
556 ;;; Different versions are used depending on whether we know the
557 ;;; number of arguments or the name of the called function, and
558 ;;; whether we want fixed values, unknown values, or a tail call.
559 ;;;
560 ;;; In full call, the arguments are passed creating a partial frame on
561 ;;; the stack top and storing stack arguments into that frame. On
562 ;;; entry to the callee, this partial frame is pointed to by FP. If
563 ;;; there are no stack arguments, we don't bother allocating a partial
564 ;;; frame, and instead set FP to SP just before the call.
566 ;;; This macro helps in the definition of full call VOPs by avoiding code
567 ;;; replication in defining the cross-product VOPs.
568 ;;;
569 ;;; Name is the name of the VOP to define.
570 ;;;
571 ;;; Named is true if the first argument is a symbol whose global function
572 ;;; definition is to be called.
573 ;;;
574 ;;; Return is either :Fixed, :Unknown or :Tail:
575 ;;; -- If :Fixed, then the call is for a fixed number of values, returned in
576 ;;; the standard passing locations (passed as result operands).
577 ;;; -- If :Unknown, then the result values are pushed on the stack, and the
578 ;;; result values are specified by the Start and Count as in the
579 ;;; unknown-values continuation representation.
580 ;;; -- If :Tail, then do a tail-recursive call. No values are returned.
581 ;;; The Old-Fp and Return-PC are passed as the second and third arguments.
582 ;;;
583 ;;; In non-tail calls, the pointer to the stack arguments is passed as the last
584 ;;; fixed argument. If Variable is false, then the passing locations are
585 ;;; passed as a more arg. Variable is true if there are a variable number of
586 ;;; arguments passed on the stack. Variable cannot be specified with :Tail
587 ;;; return. TR variable argument call is implemented separately.
588 ;;;
589 ;;; In tail call with fixed arguments, the passing locations are passed as a
590 ;;; more arg, but there is no new-FP, since the arguments have been set up in
591 ;;; the current frame.
597 (:args
624 (:ignore
629 :offset ocfp-offset
633 old-fp-pass)
636 :offset lra-offset
639 return-pc-pass)
645 name-pass)
649 lexenv))
652 function)
654 nargs-pass)
673 15
686 return-pc-pass)
690 '(:comp-lra
693 :save-fp
699 (:load-nargs
706 register-arg-names)))
709 '((:load-old-fp
716 (:load-return-pc
723 (:frob-nfp
726 number-stack-displacement))))
727 `((:comp-lra
729 return-pc-pass code-tn lra-label temp))
730 (:frob-nfp
732 (:save-fp
734 (:load-fp
750 other-pointer-lowtag)
753 other-pointer-lowtag)
762 other-pointer-lowtag)
765 fun-pointer-lowtag)
775 fun-pointer-lowtag))
779 (:fixed
782 temp lra-label)
785 (:unknown
789 lra-label temp)
807 ;;; Defined separately, since needs special code that BLT's the
808 ;;; arguments down.
810 (:args
827 ;; Move these into the passing locations if they are not already there.
833 ;; Clear the number stack if anything is there.
838 number-stack-displacement))))
840 ;; And jump to the assembly-routine that does the bliting.
844 \f
845 ;;;; Unknown values return:
848 ;;; Return a single value using the unknown-values convention.
857 ;; Clear the number stack.
862 number-stack-displacement))))
863 ;; Clear the control stack, and restore the frame pointer.
866 ;; Out of here.
870 ;;; Do unknown-values return of a fixed number of values. The Values are
871 ;;; required to be set up in the standard passing locations. Nvals is the
872 ;;; number of values returned.
873 ;;;
874 ;;; If returning a single value, then deallocate the current frame, restore
875 ;;; FP and jump to the single-value entry at Return-PC + 8.
876 ;;;
877 ;;; If returning other than one value, then load the number of values returned,
878 ;;; NIL out unsupplied values registers, restore FP and return at Return-PC.
879 ;;; When there are stack values, we must initialize the argument pointer to
880 ;;; point to the beginning of the values block (which is the beginning of the
881 ;;; current frame.)
883 (:args
900 ;; Clear the number stack.
905 number-stack-displacement))))
907 ;; Clear the control stack, and restore the frame pointer.
910 ;; Out of here.
913 ;; Establish the values pointer and values count.
916 ;; restore the frame pointer and clear as much of the control
917 ;; stack as possible.
920 ;; pre-default any argument register that need it.
924 ;; And away we go.
928 ;;; Do unknown-values return of an arbitrary number of values (passed on the
929 ;;; stack.) We check for the common case of a single return value, and do that
930 ;;; inline using the normal single value return convention. Otherwise, we
931 ;;; branch off to code that calls an assembly-routine.
933 (:args
952 ;; Clear the number stack.
957 number-stack-displacement))))
959 ;; Check for the single case.
964 ;; Return with one value.
969 ;; Nope, not the single case.
980 \f
981 ;;;; XEP hackery:
984 ;;; We don't need to do anything special for regular functions.
989 ;; Don't bother doing anything.
990 ))
992 ;;; Get the lexical environment from it's passing location.
996 lexenv)
1001 ;; Get result.
1004 ;;; Copy a more arg from the argument area to the end of the current frame.
1005 ;;; Fixed is the number of non-more arguments.
1018 ;; Save a pointer to the results so we can fill in register args.
1019 ;; We don't need this if there are more fixed args than reg args.
1021 ;; Allocate the space on the stack.
1032 ;; We must stop when we run out of stack args, not when we run out of
1033 ;; more args.
1035 ;; Everything of interest in registers.
1037 ;; Initialize dst to be end of stack.
1039 ;; Initialize src to be end of args.
1043 ;; *--dst = *--src, --count
1053 ;; Now we have to deposit any more args that showed up in registers.
1057 ;; Don't deposit any more than there are.
1060 ;; Store it relative to the pointer saved at the start.
1065 ;;; More args are stored consequtively on the stack, starting immediately at
1066 ;;; the context pointer. The context pointer is not typed, so the lowtag is 0.
1071 ;;; Turn more arg (context, count) into a list.
1073 t)
1095 ;; Check to see if there are any arguments.
1100 ;; We need to do this atomically.
1104 ;; Allocate a cons (2 words) for each item.
1112 ;; Compute the next cons and store it in the current one.
1117 ;; Grab one value.
1122 ;; Dec count, and if != zero, go back for more.
1126 ;; Store the value into the car of the current cons (in the delay
1127 ;; slot).
1130 ;; NIL out the last cons.
1135 ;;; Return the location and size of the more arg glob created by Copy-More-Arg.
1136 ;;; Supplied is the total number of arguments supplied (originally passed in
1137 ;;; NARGS.) Fixed is the number of non-rest arguments.
1138 ;;;
1139 ;;; We must duplicate some of the work done by Copy-More-Arg, since at that
1140 ;;; time the environment is in a pretty brain-damaged state, preventing this
1141 ;;; info from being returned as values. What we do is compute
1142 ;;; supplied - fixed, and return a pointer that many words below the current
1143 ;;; stack top.
1159 ;;; Signal wrong argument count error if Nargs isn't = to Count.
1160 ;;;
1174 ;; Assume we don't take the branch
1179 ;;; Signal various errors.
1187 args))
1195 object type)
1197 object layout)