| blob | 63666ade91522c9ad370fd1f954459a0d110451f |
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))
420 arg-vars
421 ;; FIXME: Would be nice to
422 ;; share these names instead
423 ;; of consing up several
424 ;; identical ones. Oh well.
426 '&optional-processor
427 name)
428 :note-lexical-bindings nil
433 fvars arg-vars)
434 fun))
436 ;;; This function deals with supplied-p vars in optional arguments. If
437 ;;; the there is no supplied-p arg, then we just call
438 ;;; IR1-CONVERT-HAIRY-ARGS on the remaining arguments, and generate a
439 ;;; optional entry that calls the result. If there is a supplied-p
440 ;;; var, then we add it into the default vars and throw a T into the
441 ;;; entry values. The resulting entry point function is returned.
443 entry-vars entry-vals
444 vars supplied-p-p body
445 aux-vars aux-vals
446 source-name debug-name
447 force post-binding-lexenv
448 system-lambda)
451 aux-vars aux-vals))
461 res
467 source-name debug-name
468 force post-binding-lexenv system-lambda)
470 res
476 source-name debug-name
477 force post-binding-lexenv system-lambda))))
479 ;; We want to delay converting the entry, but there exist
480 ;; problems: hidden references should not be established to
481 ;; lambdas of kind NIL should not have (otherwise the compiler
482 ;; might let-convert or delete them) and to variables.
485 supplied-p-p ; this entry will be of kind NIL
488 default-vars default-vals
490 name)
493 ;; DEFAULT can contain a reference to a
494 ;; to-be-optimized-away function/block/tag, so better to
495 ;; reduce code now (but we possibly lose syntax checking
496 ;; in an unreachable code).
500 default-vars default-vals
501 defaults
502 name)
503 res)))))))
505 ;;; Create the MORE-ENTRY function for the OPTIONAL-DISPATCH RES.
506 ;;; ENTRY-VARS and ENTRY-VALS describe the fixed arguments. REST is
507 ;;; the var for any &REST arg. KEYS is a list of the &KEY arg vars.
508 ;;;
509 ;;; The most interesting thing that we do is parse keywords. We create
510 ;;; a bunch of temporary variables to hold the result of the parse,
511 ;;; and then loop over the supplied arguments, setting the appropriate
512 ;;; temps for the supplied keyword. Note that it is significant that
513 ;;; we iterate over the keywords in reverse order --- this implements
514 ;;; the CL requirement that (when a keyword appears more than once)
515 ;;; the first value is used.
516 ;;;
517 ;;; If there is no supplied-p var, then we initialize the temp to the
518 ;;; default and just pass the temp into the main entry. Since
519 ;;; non-constant &KEY args are forcibly given a supplied-p var, we
520 ;;; know that the default is constant, and thus safe to evaluate out
521 ;;; of order.
522 ;;;
523 ;;; If there is a supplied-p var, then we create temps for both the
524 ;;; value and the supplied-p, and pass them into the main entry,
525 ;;; letting it worry about defaulting.
526 ;;;
527 ;;; We deal with :ALLOW-OTHER-KEYS by delaying unknown keyword errors
528 ;;; until we have scanned all the keywords.
555 ;; The reason for all the noise with
556 ;; STACK-GROWS-DOWNWARD-NOT-UPWARD is to enable generation of
557 ;; slightly more efficient code on x86oid processors. (We can
558 ;; hoist the negation of the index outside the main parsing loop
559 ;; and take advantage of the base+index+displacement addressing
560 ;; mode on x86oids.)
574 #!+stack-grows-downward-not-upward
576 #!-stack-grows-downward-not-upward n-value-temp
579 #!-stack-grows-downward-not-upward
622 #!-stack-grows-downward-not-upward
632 #!+stack-grows-downward-not-upward
653 :note-lexical-bindings nil
660 ;;; This is called by IR1-CONVERT-HAIRY-ARGS when we run into a &REST
661 ;;; or &KEY arg. The arguments are similar to that function, but we
662 ;;; split off any &REST arg and pass it in separately. REST is the
663 ;;; &REST arg var, or NIL if there is no &REST arg. KEYS is a list of
664 ;;; the &KEY argument vars.
665 ;;;
666 ;;; When there are &KEY arguments, we introduce temporary gensym
667 ;;; variables to hold the values while keyword defaulting is in
668 ;;; progress to get the required sequential binding semantics.
669 ;;;
670 ;;; This gets interesting mainly when there are &KEY arguments with
671 ;;; supplied-p vars or non-constant defaults. In either case, pass in
672 ;;; a supplied-p var. If the default is non-constant, we introduce an
673 ;;; IF in the main entry that tests the supplied-p var and decides
674 ;;; whether to evaluate the default or not. In this case, the real
675 ;;; incoming value is NIL, so we must union NULL with the declared
676 ;;; type when computing the type for the main entry's argument.
678 rest more-context more-count keys supplied-p-p
679 body aux-vars aux-vals source-name debug-name
680 post-binding-lexenv system-lambda)
683 aux-vars aux-vals))
692 ;; Make up two extra variables, and squirrel them away in
693 ;; ARG-INFO-DEFAULT for transforming (VALUES-LIST REST) into
694 ;; (%MORE-ARG-VALUES CONTEXT 0 COUNT) when possible.
706 more-count count))))
718 ;; was: (format nil "~A-DEFAULTING-TEMP" (leaf-source-name key))
749 :post-binding-lexenv post-binding-lexenv
750 :source-name source-name
751 :debug-name debug-name
759 name)
765 last-entry)
766 res)
768 last-entry)))
770 ;;; This function generates the entry point functions for the
771 ;;; OPTIONAL-DISPATCH RES. We accomplish this by recursion on the list
772 ;;; of arguments, analyzing the arglist on the way down and generating
773 ;;; entry points on the way up.
774 ;;;
775 ;;; DEFAULT-VARS is a reversed list of all the argument vars processed
776 ;;; so far, including supplied-p vars. DEFAULT-VALS is a list of the
777 ;;; names of the DEFAULT-VARS.
778 ;;;
779 ;;; ENTRY-VARS is a reversed list of processed argument vars,
780 ;;; excluding supplied-p vars. ENTRY-VALS is a list things that can be
781 ;;; evaluated to get the values for all the vars from the ENTRY-VARS.
782 ;;; It has the var name for each required or optional arg, and has T
783 ;;; for each supplied-p arg.
784 ;;;
785 ;;; VARS is a list of the LAMBDA-VAR structures for arguments that
786 ;;; haven't been processed yet. SUPPLIED-P-P is true if a supplied-p
787 ;;; argument has already been processed; only in this case are the
788 ;;; DEFAULT-XXX and ENTRY-XXX different.
789 ;;;
790 ;;; The result at each point is a lambda which should be called by the
791 ;;; above level to default the remaining arguments and evaluate the
792 ;;; body. We cause the body to be evaluated by converting it and
793 ;;; returning it as the result when the recursion bottoms out.
794 ;;;
795 ;;; Each level in the recursion also adds its entry point function to
796 ;;; the result OPTIONAL-DISPATCH. For most arguments, the defaulting
797 ;;; function and the entry point function will be the same, but when
798 ;;; SUPPLIED-P args are present they may be different.
799 ;;;
800 ;;; When we run into a &REST or &KEY arg, we punt out to
801 ;;; IR1-CONVERT-MORE, which finishes for us in this case.
803 entry-vars entry-vals
804 vars supplied-p-p body aux-vars
805 aux-vals
806 source-name debug-name
807 force post-binding-lexenv
808 system-lambda)
811 aux-vars aux-vals))
815 ;; Handle &KEY with no keys...
817 entry-vars entry-vals
818 nil nil nil vars supplied-p-p body aux-vars
819 aux-vals source-name debug-name
820 post-binding-lexenv system-lambda)
824 :aux-vars aux-vars
825 :aux-vals aux-vals
826 :post-binding-lexenv post-binding-lexenv
827 :source-name source-name
828 :debug-name debug-name
836 name)
837 res)
838 fun)
840 fun)))
847 source-name debug-name
848 nil post-binding-lexenv system-lambda)))
854 (:optional
856 res default-vars default-vals
857 entry-vars entry-vals vars supplied-p-p body
858 aux-vars aux-vals
859 source-name debug-name
860 force post-binding-lexenv
861 system-lambda)))
862 ;; See GENERATE-OPTIONAL-DEFAULT-ENTRY.
867 ep entry-vars entry-vals nil
869 ep)
870 res)
872 ep))
874 ep))
875 (:rest
877 entry-vars entry-vals
879 aux-vars aux-vals
880 source-name debug-name
881 post-binding-lexenv system-lambda))
882 (:more-context
884 entry-vars entry-vals
886 body aux-vars aux-vals
887 source-name debug-name
888 post-binding-lexenv system-lambda))
889 (:keyword
891 entry-vars entry-vals
892 nil nil nil vars supplied-p-p body aux-vars
893 aux-vals source-name debug-name
894 post-binding-lexenv system-lambda)))))))
896 ;;; This function deals with the case where we have to make an
897 ;;; OPTIONAL-DISPATCH to represent a LAMBDA. We cons up the result and
898 ;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we
899 ;;; figure out the MIN-ARGS and MAX-ARGS.
901 &key post-binding-lexenv
903 debug-name system-lambda)
907 :allowp allowp
908 :keyp keyp
909 :%source-name source-name
910 :%debug-name debug-name
917 source-name debug-name nil post-binding-lexenv
918 system-lambda)
919 ;; ir1-convert-hairy-args can throw 'locall-already-let-converted
920 ;; push optional-dispatch into the current component only after it
921 ;; normally returned
927 res))
929 ;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
931 debug-name maybe-add-debug-catch
932 system-lambda)
936 form))
939 'lambda
941 form))
944 "The lambda expression has a missing or non-list lambda list:~% ~S"
945 form))
962 forms))
964 forms
969 allow-other-keys
970 aux-vars aux-vals
971 :post-binding-lexenv post-binding-lexenv
972 :source-name source-name
973 :debug-name debug-name
977 :aux-vars aux-vars
978 :aux-vals aux-vals
979 :post-binding-lexenv post-binding-lexenv
980 :source-name source-name
981 :debug-name debug-name
987 ;; KLUDGE: Not counting TL-XEPs is a lie, of course, but
988 ;; keeps things less confusing to users of TIME, where this
989 ;; count gets used.
992 res))))
995 #!+unwind-to-frame-and-call-vop
999 ;; Just ensure that there won't be any tail-calls, IR2 magic will
1000 ;; handle the rest.
1002 #!-unwind-to-frame-and-call-vop
1005 return-value-tag
1006 ;; If DEBUG-CATCH-TAG is thrown (with a thunk as the value) the
1007 ;; RETURN-FROM is elided and we funcall the thunk instead. That
1008 ;; thunk might either return a value (for a RETURN-FROM-FRAME)
1009 ;; or call this same function again (for a RESTART-FRAME).
1010 ;; -- JES, 2007-01-09
1013 ;; Use a constant catch tag instead of consing a new one for every
1014 ;; entry to this block. The uniquencess of the catch tags is
1015 ;; ensured when the tag is throw by the debugger. It'll allocate a
1016 ;; new tag, and modify the reference this tag in the proper
1017 ;; catch-block structure to refer to that new tag. This
1018 ;; significantly decreases the runtime cost of high debug levels.
1019 ;; -- JES, 2007-01-09
1025 ;;; helper for LAMBDA-like things, to massage them into a form
1026 ;;; suitable for IR1-CONVERT-LAMBDA.
1028 &key
1030 debug-name)
1036 :maybe-add-debug-catch t
1037 :source-name source-name
1045 :maybe-add-debug-catch t
1052 ;; Don't treat recursive stubs like CAR as self-calls
1053 ;; Maybe just use the fact that it is a known function?
1054 ;; Though a known function may be used
1055 ;; because of some other attributues but
1056 ;; still wants to get optimized self calls
1066 res defined-fun-res))
1067 res)
1069 :maybe-add-debug-catch t
1070 :debug-name
1074 :source-name source-name
1076 \f
1077 ;;;; defining global functions
1079 ;;; Convert FUN as a lambda in the null environment, but use the
1080 ;;; current compilation policy. Note that FUN may be a
1081 ;;; LAMBDA-WITH-LEXENV, so we may have to augment the environment to
1082 ;;; reflect the state at the definition site.
1084 &key
1086 debug-name
1087 system-lambda)
1101 macros)
1102 ;; Inherit MUFFLE-CONDITIONS from the call-site lexenv
1103 ;; rather than the definition-site lexenv, since it seems
1104 ;; like a much more common case.
1108 :source-name source-name
1109 :debug-name debug-name
1112 clambda)))
1114 ;;; Given a lambda-list, return a FUN-TYPE object representing the signature:
1115 ;;; return type is *, and each individual arguments type is T -- but we get
1116 ;;; the argument counts and keywords.
1125 ;; When it comes to building a type, &REST means pretty much the
1126 ;; same thing as &MORE.
1132 spec)))
1136 t)))
1137 key-list))))
1141 ;;; Get a DEFINED-FUN object for a function we are about to define. If
1142 ;;; the function has been forward referenced, then substitute for the
1143 ;;; previous references.
1153 :%source-name name
1155 :declared
1164 ;; If *FREE-FUNS* has a previously converted definition
1165 ;; for this name, then blow it away and try again.
1171 ;;; Check a new global function definition for consistency with
1172 ;;; previous declaration or definition, and assert argument/result
1173 ;;; types if appropriate. This assertion is suppressed by the
1174 ;;; EXPLICIT-CHECK attribute, which is specified on functions that
1175 ;;; check their argument types as a consequence of type dispatching.
1176 ;;; This avoids redundant checks such as NUMBERP on the args to +, etc.
1182 fun type
1183 ;; KLUDGE: Common Lisp is such a dynamic language that in general
1184 ;; all we can do here in general is issue a STYLE-WARNING. It
1185 ;; would be nice to issue a full WARNING in the special case of
1186 ;; of type mismatches within a compilation unit (as in section
1187 ;; 3.2.2.3 of the spec) but at least as of sbcl-0.6.11, we don't
1188 ;; keep track of whether the mismatched data came from the same
1189 ;; compilation unit, so we can't do that. -- WHN 2001-02-11
1194 :really-assert
1198 explicit-check))))
1200 "previous declaration"
1203 ;;; Used for global inline expansion. Earlier something like this was
1204 ;;; used by %DEFUN too. FIXME: And now it's probably worth rethinking
1205 ;;; whether this function is a good idea at all.
1207 ;; Unless a :INLINE function, we temporarily clobber the inline
1208 ;; expansion. This prevents recursive inline expansion of
1209 ;; opportunistic pseudo-inlines.
1213 :source-name name
1214 ;; prevent instrumentation of
1215 ;; known function expansions
1220 ;; Associate VAR with the FUN -- and in case of an optional dispatch
1221 ;; with the various entry-points. This allows XREF to know where the
1222 ;; inline CLAMBDA comes from.
1228 ;; Delayed entry-point.
1235 g)))))))))
1241 ;; substitute for any old references
1248 fun))
1253 inline-lambda)
1256 inline-lambda)))
1260 ;;; the even-at-compile-time part of DEFUN
1261 ;;;
1262 ;;; The INLINE-LAMBDA is a LAMBDA-WITH-LEXENV, or NIL if there is no
1263 ;;; inline expansion.
1282 ;; old CMU CL comment:
1283 ;; If there is a type from a previous definition, blast it,
1284 ;; since it is obsolete.
1287 ;; FIXME: If this is a block compilation thing, shouldn't
1288 ;; we be setting the type to the full derived type for the
1289 ;; definition, instead of this most general function type?
1294 ;; Similar to above, detect duplicate definitions within a file,
1295 ;; but the package lock check is unnecessary - it's handled elsewhere.
1296 ;;
1297 ;; Additionally, this is a STYLE-WARNING, not a WARNING, because there is
1298 ;; meaningful behavior that can be ascribed to some redefinitions, e.g.
1299 ;; (defmacro foo () first-definition)
1300 ;; (defun f () (use-it (foo )))
1301 ;; (defmacro foo () other-definition)
1302 ;; will use the first definition when compiling F, but make the second available
1303 ;; in the loaded fasl. In this usage it would have made sense to wrap the
1304 ;; respective definitions with EVAL-WHEN for different situations,
1305 ;; but as long as the compile-time behavior is deterministic, it's just bad style
1306 ;; and not flat-out wrong, though there is indeed some waste in the fasl.
1307 ;;
1308 ;; KIND is the globaldb KIND of this NAME
1318 \f
1319 ;;; Entry point utilities
1321 ;;; Return a function for the Nth entry point.