| blob | b869141d02d9e5fdbd678516ff07eb4fd61c2290 |
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
623 step-instrumenting)
625 (:ignore
630 :offset ocfp-offset
634 old-fp-pass)
637 :offset lra-offset
640 return-pc-pass)
646 name-pass)
650 lexenv))
653 function)
655 nargs-pass)
676 15
690 return-pc-pass)
694 '(:comp-lra
697 :save-fp
703 (:load-nargs
710 register-arg-names)))
713 '((:load-old-fp
720 (:load-return-pc
727 (:frob-nfp
730 number-stack-displacement))))
731 `((:comp-lra
733 return-pc-pass code-tn lra-label temp))
734 (:frob-nfp
736 (:save-fp
738 (:load-fp
746 ;; Conditionally insert a conditional trap:
748 ;; Get the symbol-value of SB!IMPL::*STEPPING*
751 ;; If it's not null, trap.
754 ;; FIXME: this doesn't look right.
756 ;; Construct a trap code with the low bits from
757 ;; SINGLE-STEP-AROUND-TRAP and the high bits from
758 ;; the register number of CALLABLE-TN.
773 other-pointer-lowtag)
777 other-pointer-lowtag)
786 other-pointer-lowtag)
789 fun-pointer-lowtag)
800 fun-pointer-lowtag))
804 (:fixed
807 temp lra-label)
810 (:unknown
814 lra-label temp)
832 ;;; Defined separately, since needs special code that BLT's the
833 ;;; arguments down.
835 (:args
852 ;; Move these into the passing locations if they are not already there.
858 ;; Clear the number stack if anything is there.
863 number-stack-displacement))))
865 ;; And jump to the assembly-routine that does the bliting.
869 \f
870 ;;;; Unknown values return:
873 ;;; Return a single value using the unknown-values convention.
882 ;; Clear the number stack.
887 number-stack-displacement))))
888 ;; Clear the control stack, and restore the frame pointer.
891 ;; Out of here.
895 ;;; Do unknown-values return of a fixed number of values. The Values are
896 ;;; required to be set up in the standard passing locations. Nvals is the
897 ;;; number of values returned.
898 ;;;
899 ;;; If returning a single value, then deallocate the current frame, restore
900 ;;; FP and jump to the single-value entry at Return-PC + 8.
901 ;;;
902 ;;; If returning other than one value, then load the number of values returned,
903 ;;; NIL out unsupplied values registers, restore FP and return at Return-PC.
904 ;;; When there are stack values, we must initialize the argument pointer to
905 ;;; point to the beginning of the values block (which is the beginning of the
906 ;;; current frame.)
908 (:args
925 ;; Clear the number stack.
930 number-stack-displacement))))
932 ;; Clear the control stack, and restore the frame pointer.
935 ;; Out of here.
938 ;; Establish the values pointer and values count.
941 ;; restore the frame pointer and clear as much of the control
942 ;; stack as possible.
945 ;; pre-default any argument register that need it.
949 ;; And away we go.
953 ;;; Do unknown-values return of an arbitrary number of values (passed on the
954 ;;; stack.) We check for the common case of a single return value, and do that
955 ;;; inline using the normal single value return convention. Otherwise, we
956 ;;; branch off to code that calls an assembly-routine.
958 (:args
977 ;; Clear the number stack.
982 number-stack-displacement))))
984 ;; Check for the single case.
989 ;; Return with one value.
994 ;; Nope, not the single case.
1005 \f
1006 ;;;; XEP hackery:
1009 ;;; We don't need to do anything special for regular functions.
1014 ;; Don't bother doing anything.
1015 ))
1017 ;;; Get the lexical environment from it's passing location.
1021 lexenv)
1026 ;; Get result.
1029 ;;; Copy a more arg from the argument area to the end of the current frame.
1030 ;;; Fixed is the number of non-more arguments.
1043 ;; Save a pointer to the results so we can fill in register args.
1044 ;; We don't need this if there are more fixed args than reg args.
1046 ;; Allocate the space on the stack.
1057 ;; We must stop when we run out of stack args, not when we run out of
1058 ;; more args.
1060 ;; Everything of interest in registers.
1062 ;; Initialize dst to be end of stack.
1064 ;; Initialize src to be end of args.
1068 ;; *--dst = *--src, --count
1078 ;; Now we have to deposit any more args that showed up in registers.
1082 ;; Don't deposit any more than there are.
1085 ;; Store it relative to the pointer saved at the start.
1090 ;;; More args are stored consequtively on the stack, starting immediately at
1091 ;;; the context pointer. The context pointer is not typed, so the lowtag is 0.
1096 ;;; Turn more arg (context, count) into a list.
1117 ;; Check to see if there are any arguments.
1122 ;; We need to do this atomically.
1126 ;; Allocate a cons (2 words) for each item.
1134 ;; Compute the next cons and store it in the current one.
1139 ;; Grab one value.
1144 ;; Dec count, and if != zero, go back for more.
1148 ;; Store the value into the car of the current cons (in the delay
1149 ;; slot).
1152 ;; NIL out the last cons.
1157 ;;; Return the location and size of the more arg glob created by Copy-More-Arg.
1158 ;;; Supplied is the total number of arguments supplied (originally passed in
1159 ;;; NARGS.) Fixed is the number of non-rest arguments.
1160 ;;;
1161 ;;; We must duplicate some of the work done by Copy-More-Arg, since at that
1162 ;;; time the environment is in a pretty brain-damaged state, preventing this
1163 ;;; info from being returned as values. What we do is compute
1164 ;;; supplied - fixed, and return a pointer that many words below the current
1165 ;;; stack top.
1181 ;;; Signal wrong argument count error if Nargs isn't = to Count.
1182 ;;;
1196 ;; Assume we don't take the branch
1201 ;;; Signal various errors.
1209 args))
1217 object type)
1219 object layout)
1226 ;;; Single-stepping
1239 DONE))