| blob | ce0672774af8d5d1cc1c67f6aba5faab96614738 |
1 ;;;; This file contains code which does the translation of lambda
2 ;;;; forms from Lisp code to the first intermediate representation
3 ;;;; (IR1).
5 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; more information.
7 ;;;;
8 ;;;; This software is derived from the CMU CL system, which was
9 ;;;; written at Carnegie Mellon University and released into the
10 ;;;; public domain. The software is in the public domain and is
11 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
12 ;;;; files for more information.
16 ;;;; LAMBDA hackery
18 ;;;; Note: Take a look at the compiler-overview.tex section on "Hairy
19 ;;;; function representation" before you seriously mess with this
20 ;;;; stuff.
22 ;;; Verify that the NAME is a legal name for a variable and return a
23 ;;; VAR structure for it, filling in info if it is globally special.
24 ;;; If it is losing, we punt with a COMPILER-ERROR. NAMES-SO-FAR is a
25 ;;; list of names which have previously been bound. If the NAME is in
26 ;;; this list, then we error out.
34 name
35 context))
39 name))
42 local variable.~:@>"
43 name))
46 as a local variable.~:@>"
47 name))
57 ;;; Make the default keyword for a &KEY arg, checking that the keyword
58 ;;; isn't already used by one of the VARS.
63 symbol)))
70 "The keyword ~S appears more than once in the lambda list."
71 key))))
72 key))
74 ;;; Parse a lambda list into a list of VAR structures, stripping off
75 ;;; any &AUX bindings. Each arg name is checked for legality, and
76 ;;; duplicate names are checked for. If an arg is globally special,
77 ;;; the var is marked as :SPECIAL instead of :LEXICAL. &KEY,
78 ;;; &OPTIONAL and &REST args are annotated with an ARG-INFO structure
79 ;;; which contains the extra information. If we hit something losing,
80 ;;; we bug out with COMPILER-ERROR. These values are returned:
81 ;;; 1. a list of the var structures for each top level argument;
82 ;;; 2. a flag indicating whether &KEY was specified;
83 ;;; 3. a flag indicating whether other &KEY args are allowed;
84 ;;; 4. a list of the &AUX variables; and
85 ;;; 5. a list of the &AUX values.
87 make-lambda-vars))
90 morep more-context more-count)
98 ;; for optionals and keywords args.
110 "The list ~S is too long to be an arg specifier."
111 spec)))))))
159 t)))
182 nil))))
197 spec))
206 ;;; This is similar to IR1-CONVERT-PROGN-BODY except that we
207 ;;; sequentially bind each AUX-VAR to the corresponding AUX-VAL before
208 ;;; converting the body. If there are no bindings, just convert the
209 ;;; body, otherwise do one binding and recurse on the rest.
210 ;;;
211 ;;; FIXME: This could and probably should be converted to use
212 ;;; SOURCE-NAME and DEBUG-NAME. But I (WHN) don't use &AUX bindings,
213 ;;; so I'm not motivated. Patches will be accepted...
215 post-binding-lexenv)
227 :post-binding-lexenv post-binding-lexenv
229 '&aux-bindings
230 aux-vars))))
236 ;;; This is similar to IR1-CONVERT-PROGN-BODY except that code to bind
237 ;;; the SPECVAR for each SVAR to the value of the variable is wrapped
238 ;;; around the body. If there are no special bindings, we just convert
239 ;;; the body, otherwise we do one special binding and recurse on the
240 ;;; rest.
241 ;;;
242 ;;; We make a cleanup and introduce it into the lexical
243 ;;; environment. If there are multiple special bindings, the cleanup
244 ;;; for the blocks will end up being the innermost one. We force NEXT
245 ;;; to start a block outside of this cleanup, causing cleanup code to
246 ;;; be emitted when the scope is exited.
254 post-binding-lexenv))
267 body aux-vars aux-vals
269 post-binding-lexenv)))))
272 ;;; Create a lambda node out of some code, returning the result. The
273 ;;; bindings are specified by the list of VAR structures VARS. We deal
274 ;;; with adding the names to the LEXENV-VARS for the conversion. The
275 ;;; result is added to the NEW-FUNCTIONALS in the *CURRENT-COMPONENT*
276 ;;; and linked to the component head and tail.
277 ;;;
278 ;;; We detect special bindings here, replacing the original VAR in the
279 ;;; lambda list with a temporary variable. We then pass a list of the
280 ;;; special vars to IR1-CONVERT-SPECIAL-BINDINGS, which actually emits
281 ;;; the special binding code.
282 ;;;
283 ;;; We ignore any ARG-INFO in the VARS, trusting that someone else is
284 ;;; dealing with &NONSENSE, except for &REST vars with DYNAMIC-EXTENT.
285 ;;;
286 ;;; AUX-VARS is a list of VAR structures for variables that are to be
287 ;;; sequentially bound. Each AUX-VAL is a form that is to be evaluated
288 ;;; to get the initial value for the corresponding AUX-VAR.
290 vars
291 &key
292 aux-vars
293 aux-vals
295 debug-name
297 post-binding-lexenv
298 system-lambda)
301 ;; We're about to try to put new blocks into *CURRENT-COMPONENT*.
306 :bind bind
307 :%source-name source-name
308 :%debug-name debug-name
317 ;; just to check: This function should fail internal assertions if
318 ;; we didn't set up a valid debug name above.
319 ;;
320 ;; (In SBCL we try to make everything have a debug name, since we
321 ;; lack the omniscient perspective the original implementors used
322 ;; to decide which things didn't need one.)
330 ;; As far as I can see, LAMBDA-VAR-HOME should never have
331 ;; been set before. Let's make sure. -- WHN 2001-09-29
344 :lambda lambda
367 result-lvar body
369 post-binding-lexenv)))))
374 lambda))
376 ;;; Entry point CLAMBDAs have a special kind
383 entry)
385 ;;; Create the actual entry-point function for an optional entry
386 ;;; point. The lambda binds copies of each of the VARS, then calls FUN
387 ;;; with the argument VALS and the DEFAULTS. Presumably the VALS refer
388 ;;; to the VARS by name. The VALS are passed in the reverse order.
389 ;;;
390 ;;; If any of the copies of the vars are referenced more than once,
391 ;;; then we mark the corresponding var as EVER-USED to inhibit
392 ;;; "defined but not read" warnings for arguments that are only used
393 ;;; by default forms.
403 fvars))
417 arg-vars
418 ;; FIXME: Would be nice to
419 ;; share these names instead
420 ;; of consing up several
421 ;; identical ones. Oh well.
423 '&optional-processor
424 name)
425 :note-lexical-bindings nil
430 fvars arg-vars)
431 fun))
433 ;;; This function deals with supplied-p vars in optional arguments. If
434 ;;; the there is no supplied-p arg, then we just call
435 ;;; IR1-CONVERT-HAIRY-ARGS on the remaining arguments, and generate a
436 ;;; optional entry that calls the result. If there is a supplied-p
437 ;;; var, then we add it into the default vars and throw a T into the
438 ;;; entry values. The resulting entry point function is returned.
440 entry-vars entry-vals
441 vars supplied-p-p body
442 aux-vars aux-vals
443 source-name debug-name
444 force post-binding-lexenv
445 system-lambda)
448 aux-vars aux-vals))
458 res
464 source-name debug-name
465 force post-binding-lexenv system-lambda)
467 res
473 source-name debug-name
474 force post-binding-lexenv system-lambda))))
476 ;; We want to delay converting the entry, but there exist
477 ;; problems: hidden references should not be established to
478 ;; lambdas of kind NIL should not have (otherwise the compiler
479 ;; might let-convert or delete them) and to variables.
482 supplied-p-p ; this entry will be of kind NIL
485 default-vars default-vals
487 name)
490 ;; DEFAULT can contain a reference to a
491 ;; to-be-optimized-away function/block/tag, so better to
492 ;; reduce code now (but we possibly lose syntax checking
493 ;; in an unreachable code).
497 default-vars default-vals
498 defaults
499 name)
500 res)))))))
502 ;;; Create the MORE-ENTRY function for the OPTIONAL-DISPATCH RES.
503 ;;; ENTRY-VARS and ENTRY-VALS describe the fixed arguments. REST is
504 ;;; the var for any &REST arg. KEYS is a list of the &KEY arg vars.
505 ;;;
506 ;;; The most interesting thing that we do is parse keywords. We create
507 ;;; a bunch of temporary variables to hold the result of the parse,
508 ;;; and then loop over the supplied arguments, setting the appropriate
509 ;;; temps for the supplied keyword. Note that it is significant that
510 ;;; we iterate over the keywords in reverse order --- this implements
511 ;;; the CL requirement that (when a keyword appears more than once)
512 ;;; the first value is used.
513 ;;;
514 ;;; If there is no supplied-p var, then we initialize the temp to the
515 ;;; default and just pass the temp into the main entry. Since
516 ;;; non-constant &KEY args are forcibly given a supplied-p var, we
517 ;;; know that the default is constant, and thus safe to evaluate out
518 ;;; of order.
519 ;;;
520 ;;; If there is a supplied-p var, then we create temps for both the
521 ;;; value and the supplied-p, and pass them into the main entry,
522 ;;; letting it worry about defaulting.
523 ;;;
524 ;;; We deal with :ALLOW-OTHER-KEYS by delaying unknown keyword errors
525 ;;; until we have scanned all the keywords.
552 ;; The reason for all the noise with
553 ;; STACK-GROWS-DOWNWARD-NOT-UPWARD is to enable generation of
554 ;; slightly more efficient code on x86oid processors. (We can
555 ;; hoist the negation of the index outside the main parsing loop
556 ;; and take advantage of the base+index+displacement addressing
557 ;; mode on x86oids.)
571 #!+stack-grows-downward-not-upward
573 #!-stack-grows-downward-not-upward n-value-temp
576 #!-stack-grows-downward-not-upward
619 #!-stack-grows-downward-not-upward
629 #!+stack-grows-downward-not-upward
650 :note-lexical-bindings nil
657 ;;; This is called by IR1-CONVERT-HAIRY-ARGS when we run into a &REST
658 ;;; or &KEY arg. The arguments are similar to that function, but we
659 ;;; split off any &REST arg and pass it in separately. REST is the
660 ;;; &REST arg var, or NIL if there is no &REST arg. KEYS is a list of
661 ;;; the &KEY argument vars.
662 ;;;
663 ;;; When there are &KEY arguments, we introduce temporary gensym
664 ;;; variables to hold the values while keyword defaulting is in
665 ;;; progress to get the required sequential binding semantics.
666 ;;;
667 ;;; This gets interesting mainly when there are &KEY arguments with
668 ;;; supplied-p vars or non-constant defaults. In either case, pass in
669 ;;; a supplied-p var. If the default is non-constant, we introduce an
670 ;;; IF in the main entry that tests the supplied-p var and decides
671 ;;; whether to evaluate the default or not. In this case, the real
672 ;;; incoming value is NIL, so we must union NULL with the declared
673 ;;; type when computing the type for the main entry's argument.
675 rest more-context more-count keys supplied-p-p
676 body aux-vars aux-vals source-name debug-name
677 post-binding-lexenv system-lambda)
680 aux-vars aux-vals))
689 ;; Make up two extra variables, and squirrel them away in
690 ;; ARG-INFO-DEFAULT for transforming (VALUES-LIST REST) into
691 ;; (%MORE-ARG-VALUES CONTEXT 0 COUNT) when possible.
703 more-count count))))
716 "~A-DEFAULTING-TEMP"
747 :post-binding-lexenv post-binding-lexenv
748 :source-name source-name
749 :debug-name debug-name
757 name)
763 last-entry)
764 res)
766 last-entry)))
768 ;;; This function generates the entry point functions for the
769 ;;; OPTIONAL-DISPATCH RES. We accomplish this by recursion on the list
770 ;;; of arguments, analyzing the arglist on the way down and generating
771 ;;; entry points on the way up.
772 ;;;
773 ;;; DEFAULT-VARS is a reversed list of all the argument vars processed
774 ;;; so far, including supplied-p vars. DEFAULT-VALS is a list of the
775 ;;; names of the DEFAULT-VARS.
776 ;;;
777 ;;; ENTRY-VARS is a reversed list of processed argument vars,
778 ;;; excluding supplied-p vars. ENTRY-VALS is a list things that can be
779 ;;; evaluated to get the values for all the vars from the ENTRY-VARS.
780 ;;; It has the var name for each required or optional arg, and has T
781 ;;; for each supplied-p arg.
782 ;;;
783 ;;; VARS is a list of the LAMBDA-VAR structures for arguments that
784 ;;; haven't been processed yet. SUPPLIED-P-P is true if a supplied-p
785 ;;; argument has already been processed; only in this case are the
786 ;;; DEFAULT-XXX and ENTRY-XXX different.
787 ;;;
788 ;;; The result at each point is a lambda which should be called by the
789 ;;; above level to default the remaining arguments and evaluate the
790 ;;; body. We cause the body to be evaluated by converting it and
791 ;;; returning it as the result when the recursion bottoms out.
792 ;;;
793 ;;; Each level in the recursion also adds its entry point function to
794 ;;; the result OPTIONAL-DISPATCH. For most arguments, the defaulting
795 ;;; function and the entry point function will be the same, but when
796 ;;; SUPPLIED-P args are present they may be different.
797 ;;;
798 ;;; When we run into a &REST or &KEY arg, we punt out to
799 ;;; IR1-CONVERT-MORE, which finishes for us in this case.
801 entry-vars entry-vals
802 vars supplied-p-p body aux-vars
803 aux-vals
804 source-name debug-name
805 force post-binding-lexenv
806 system-lambda)
809 aux-vars aux-vals))
813 ;; Handle &KEY with no keys...
815 entry-vars entry-vals
816 nil nil nil vars supplied-p-p body aux-vars
817 aux-vals source-name debug-name
818 post-binding-lexenv system-lambda)
822 :aux-vars aux-vars
823 :aux-vals aux-vals
824 :post-binding-lexenv post-binding-lexenv
825 :source-name source-name
826 :debug-name debug-name
834 name)
835 res)
836 fun)
838 fun)))
845 source-name debug-name
846 nil post-binding-lexenv system-lambda)))
852 (:optional
854 res default-vars default-vals
855 entry-vars entry-vals vars supplied-p-p body
856 aux-vars aux-vals
857 source-name debug-name
858 force post-binding-lexenv
859 system-lambda)))
860 ;; See GENERATE-OPTIONAL-DEFAULT-ENTRY.
865 ep entry-vars entry-vals nil
867 ep)
868 res)
870 ep))
872 ep))
873 (:rest
875 entry-vars entry-vals
877 aux-vars aux-vals
878 source-name debug-name
879 post-binding-lexenv system-lambda))
880 (:more-context
882 entry-vars entry-vals
884 body aux-vars aux-vals
885 source-name debug-name
886 post-binding-lexenv system-lambda))
887 (:keyword
889 entry-vars entry-vals
890 nil nil nil vars supplied-p-p body aux-vars
891 aux-vals source-name debug-name
892 post-binding-lexenv system-lambda)))))))
894 ;;; This function deals with the case where we have to make an
895 ;;; OPTIONAL-DISPATCH to represent a LAMBDA. We cons up the result and
896 ;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we
897 ;;; figure out the MIN-ARGS and MAX-ARGS.
899 &key post-binding-lexenv
901 debug-name system-lambda)
905 :allowp allowp
906 :keyp keyp
907 :%source-name source-name
908 :%debug-name debug-name
915 source-name debug-name nil post-binding-lexenv
916 system-lambda)
917 ;; ir1-convert-hairy-args can throw 'locall-already-let-converted
918 ;; push optional-dispatch into the current component only after it
919 ;; normally returned
925 res))
927 ;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
929 debug-name maybe-add-debug-catch
930 system-lambda)
934 form))
937 'lambda
939 form))
942 "The lambda expression has a missing or non-list lambda list:~% ~S"
943 form))
960 forms))
962 forms
967 allow-other-keys
968 aux-vars aux-vals
969 :post-binding-lexenv post-binding-lexenv
970 :source-name source-name
971 :debug-name debug-name
975 :aux-vars aux-vars
976 :aux-vals aux-vals
977 :post-binding-lexenv post-binding-lexenv
978 :source-name source-name
979 :debug-name debug-name
985 ;; KLUDGE: Not counting TL-XEPs is a lie, of course, but
986 ;; keeps things less confusing to users of TIME, where this
987 ;; count gets used.
990 res))))
993 #!+unwind-to-frame-and-call-vop
997 ;; Just ensure that there won't be any tail-calls, IR2 magic will
998 ;; handle the rest.
1000 #!-unwind-to-frame-and-call-vop
1003 return-value-tag
1004 ;; If DEBUG-CATCH-TAG is thrown (with a thunk as the value) the
1005 ;; RETURN-FROM is elided and we funcall the thunk instead. That
1006 ;; thunk might either return a value (for a RETURN-FROM-FRAME)
1007 ;; or call this same function again (for a RESTART-FRAME).
1008 ;; -- JES, 2007-01-09
1011 ;; Use a constant catch tag instead of consing a new one for every
1012 ;; entry to this block. The uniquencess of the catch tags is
1013 ;; ensured when the tag is throw by the debugger. It'll allocate a
1014 ;; new tag, and modify the reference this tag in the proper
1015 ;; catch-block structure to refer to that new tag. This
1016 ;; significantly decreases the runtime cost of high debug levels.
1017 ;; -- JES, 2007-01-09
1023 ;;; helper for LAMBDA-like things, to massage them into a form
1024 ;;; suitable for IR1-CONVERT-LAMBDA.
1026 &key
1028 debug-name)
1034 :maybe-add-debug-catch t
1035 :source-name source-name
1043 :maybe-add-debug-catch t
1051 res defined-fun-res))
1052 res)
1054 :maybe-add-debug-catch t
1055 :debug-name
1059 :source-name source-name
1061 \f
1062 ;;;; defining global functions
1064 ;;; Convert FUN as a lambda in the null environment, but use the
1065 ;;; current compilation policy. Note that FUN may be a
1066 ;;; LAMBDA-WITH-LEXENV, so we may have to augment the environment to
1067 ;;; reflect the state at the definition site.
1069 &key
1071 debug-name
1072 system-lambda)
1086 macros)
1087 ;; Inherit MUFFLE-CONDITIONS from the call-site lexenv
1088 ;; rather than the definition-site lexenv, since it seems
1089 ;; like a much more common case.
1093 :source-name source-name
1094 :debug-name debug-name
1097 clambda)))
1099 ;;; Given a lambda-list, return a FUN-TYPE object representing the signature:
1100 ;;; return type is *, and each individual arguments type is T -- but we get
1101 ;;; the argument counts and keywords.
1110 ;; When it comes to building a type, &REST means pretty much the
1111 ;; same thing as &MORE.
1117 spec)))
1121 t)))
1122 key-list))))
1126 ;;; Get a DEFINED-FUN object for a function we are about to define. If
1127 ;;; the function has been forward referenced, then substitute for the
1128 ;;; previous references.
1138 :%source-name name
1140 :declared
1149 ;; If *FREE-FUNS* has a previously converted definition
1150 ;; for this name, then blow it away and try again.
1156 ;;; Check a new global function definition for consistency with
1157 ;;; previous declaration or definition, and assert argument/result
1158 ;;; types if appropriate. This assertion is suppressed by the
1159 ;;; EXPLICIT-CHECK attribute, which is specified on functions that
1160 ;;; check their argument types as a consequence of type dispatching.
1161 ;;; This avoids redundant checks such as NUMBERP on the args to +, etc.
1167 fun type
1168 ;; KLUDGE: Common Lisp is such a dynamic language that in general
1169 ;; all we can do here in general is issue a STYLE-WARNING. It
1170 ;; would be nice to issue a full WARNING in the special case of
1171 ;; of type mismatches within a compilation unit (as in section
1172 ;; 3.2.2.3 of the spec) but at least as of sbcl-0.6.11, we don't
1173 ;; keep track of whether the mismatched data came from the same
1174 ;; compilation unit, so we can't do that. -- WHN 2001-02-11
1179 :really-assert
1183 explicit-check))))
1185 "previous declaration"
1188 ;;; Used for global inline expansion. Earlier something like this was
1189 ;;; used by %DEFUN too. FIXME: And now it's probably worth rethinking
1190 ;;; whether this function is a good idea at all.
1192 ;; Unless a :INLINE function, we temporarily clobber the inline
1193 ;; expansion. This prevents recursive inline expansion of
1194 ;; opportunistic pseudo-inlines.
1198 :source-name name
1199 ;; prevent instrumentation of
1200 ;; known function expansions
1205 ;; Associate VAR with the FUN -- and in case of an optional dispatch
1206 ;; with the various entry-points. This allows XREF to know where the
1207 ;; inline CLAMBDA comes from.
1213 ;; Delayed entry-point.
1220 g)))))))))
1226 ;; substitute for any old references
1233 fun))
1238 inline-lambda)
1241 inline-lambda)))
1245 ;;; the even-at-compile-time part of DEFUN
1246 ;;;
1247 ;;; The INLINE-LAMBDA is a LAMBDA-WITH-LEXENV, or NIL if there is no
1248 ;;; inline expansion.
1267 ;; old CMU CL comment:
1268 ;; If there is a type from a previous definition, blast it,
1269 ;; since it is obsolete.
1272 ;; FIXME: If this is a block compilation thing, shouldn't
1273 ;; we be setting the type to the full derived type for the
1274 ;; definition, instead of this most general function type?
1279 \f
1280 ;;; Entry point utilities
1282 ;;; Return a function for the Nth entry point.