| blob | e86893943159288d619cdbd6cea9c871171004cc |
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 ;;;; FIXME: where is that file?
19 ;;;; Note: Take a look at the compiler-overview.tex section on "Hairy
20 ;;;; function representation" before you seriously mess with this
21 ;;;; stuff.
23 ;;; Verify that the NAME is a legal name for a variable and return a
24 ;;; VAR structure for it, filling in info if it is globally special.
25 ;;; If it is losing, we punt with a COMPILER-ERROR. NAMES-SO-FAR is a
26 ;;; list of names which have previously been bound. If the NAME is in
27 ;;; this list, then we error out.
35 name
36 context))
40 name))
43 local variable.~:@>"
44 name))
47 as a local variable.~:@>"
48 name))
58 ;;; Make the default keyword for a &KEY arg, checking that the keyword
59 ;;; isn't already used by one of the VARS.
64 symbol)))
71 "The keyword ~S appears more than once in the lambda list."
72 key))))
73 key))
75 ;;; Parse a lambda list into a list of VAR structures, stripping off
76 ;;; any &AUX bindings. Each arg name is checked for legality, and
77 ;;; duplicate names are checked for. If an arg is globally special,
78 ;;; the var is marked as :SPECIAL instead of :LEXICAL. &KEY,
79 ;;; &OPTIONAL and &REST args are annotated with an ARG-INFO structure
80 ;;; which contains the extra information. If we hit something losing,
81 ;;; we bug out with COMPILER-ERROR. These values are returned:
82 ;;; 1. a list of the var structures for each top level argument;
83 ;;; 2. a flag indicating whether &KEY was specified;
84 ;;; 3. a flag indicating whether other &KEY args are allowed;
85 ;;; 4. a list of the &AUX variables; and
86 ;;; 5. a list of the &AUX values.
88 make-lambda-vars))
91 morep more-context more-count)
99 ;; for optionals and keywords args.
111 "The list ~S is too long to be an arg specifier."
112 spec)))))))
160 t)))
183 nil))))
198 spec))
207 ;;; This is similar to IR1-CONVERT-PROGN-BODY except that we
208 ;;; sequentially bind each AUX-VAR to the corresponding AUX-VAL before
209 ;;; converting the body. If there are no bindings, just convert the
210 ;;; body, otherwise do one binding and recurse on the rest.
211 ;;;
212 ;;; FIXME: This could and probably should be converted to use
213 ;;; SOURCE-NAME and DEBUG-NAME. But I (WHN) don't use &AUX bindings,
214 ;;; so I'm not motivated. Patches will be accepted...
216 post-binding-lexenv)
228 :post-binding-lexenv post-binding-lexenv
230 '&aux-bindings
231 aux-vars))))
237 ;;; This is similar to IR1-CONVERT-PROGN-BODY except that code to bind
238 ;;; the SPECVAR for each SVAR to the value of the variable is wrapped
239 ;;; around the body. If there are no special bindings, we just convert
240 ;;; the body, otherwise we do one special binding and recurse on the
241 ;;; rest.
242 ;;;
243 ;;; We make a cleanup and introduce it into the lexical
244 ;;; environment. If there are multiple special bindings, the cleanup
245 ;;; for the blocks will end up being the innermost one. We force NEXT
246 ;;; to start a block outside of this cleanup, causing cleanup code to
247 ;;; be emitted when the scope is exited.
255 post-binding-lexenv))
268 body aux-vars aux-vals
270 post-binding-lexenv)))))
273 ;;; Create a lambda node out of some code, returning the result. The
274 ;;; bindings are specified by the list of VAR structures VARS. We deal
275 ;;; with adding the names to the LEXENV-VARS for the conversion. The
276 ;;; result is added to the NEW-FUNCTIONALS in the *CURRENT-COMPONENT*
277 ;;; and linked to the component head and tail.
278 ;;;
279 ;;; We detect special bindings here, replacing the original VAR in the
280 ;;; lambda list with a temporary variable. We then pass a list of the
281 ;;; special vars to IR1-CONVERT-SPECIAL-BINDINGS, which actually emits
282 ;;; the special binding code.
283 ;;;
284 ;;; We ignore any ARG-INFO in the VARS, trusting that someone else is
285 ;;; dealing with &NONSENSE, except for &REST vars with DYNAMIC-EXTENT.
286 ;;;
287 ;;; AUX-VARS is a list of VAR structures for variables that are to be
288 ;;; sequentially bound. Each AUX-VAL is a form that is to be evaluated
289 ;;; to get the initial value for the corresponding AUX-VAR.
291 vars
292 &key
293 aux-vars
294 aux-vals
296 debug-name
298 post-binding-lexenv
299 system-lambda)
302 ;; We're about to try to put new blocks into *CURRENT-COMPONENT*.
307 :bind bind
308 :%source-name source-name
309 :%debug-name debug-name
318 ;; just to check: This function should fail internal assertions if
319 ;; we didn't set up a valid debug name above.
320 ;;
321 ;; (In SBCL we try to make everything have a debug name, since we
322 ;; lack the omniscient perspective the original implementors used
323 ;; to decide which things didn't need one.)
331 ;; As far as I can see, LAMBDA-VAR-HOME should never have
332 ;; been set before. Let's make sure. -- WHN 2001-09-29
345 :lambda lambda
368 result-lvar body
370 post-binding-lexenv)))))
375 lambda))
377 ;;; Entry point CLAMBDAs have a special kind
384 entry)
386 ;;; Create the actual entry-point function for an optional entry
387 ;;; point. The lambda binds copies of each of the VARS, then calls FUN
388 ;;; with the argument VALS and the DEFAULTS. Presumably the VALS refer
389 ;;; to the VARS by name. The VALS are passed in the reverse order.
390 ;;;
391 ;;; If any of the copies of the vars are referenced more than once,
392 ;;; then we mark the corresponding var as EVER-USED to inhibit
393 ;;; "defined but not read" warnings for arguments that are only used
394 ;;; by default forms.
404 fvars))
416 ;; See lengthy comment at top of 'seqtran'
417 ;; as to why muffling is not done during xc.
418 #-sb-xc-host
424 arg-vars
425 ;; FIXME: Would be nice to
426 ;; share these names instead
427 ;; of consing up several
428 ;; identical ones. Oh well.
430 '&optional-processor
431 name)
432 :note-lexical-bindings nil
437 fvars arg-vars)
438 fun))
440 ;;; This function deals with supplied-p vars in optional arguments. If
441 ;;; there is no supplied-p arg, then we just call
442 ;;; IR1-CONVERT-HAIRY-ARGS on the remaining arguments, and generate a
443 ;;; optional entry that calls the result. If there is a supplied-p
444 ;;; var, then we add it into the default vars and throw a T into the
445 ;;; entry values. The resulting entry point function is returned.
447 entry-vars entry-vals
448 vars supplied-p-p body
449 aux-vars aux-vals
450 source-name debug-name
451 force post-binding-lexenv
452 system-lambda)
455 aux-vars aux-vals))
465 res
471 source-name debug-name
472 force post-binding-lexenv system-lambda)
474 res
480 source-name debug-name
481 force post-binding-lexenv system-lambda))))
483 ;; We want to delay converting the entry, but there exist
484 ;; problems: hidden references should not be established to
485 ;; lambdas of kind NIL should not have (otherwise the compiler
486 ;; might let-convert or delete them) and to variables.
489 supplied-p-p ; this entry will be of kind NIL
492 default-vars default-vals
494 name)
497 ;; DEFAULT can contain a reference to a
498 ;; to-be-optimized-away function/block/tag, so better to
499 ;; reduce code now (but we possibly lose syntax checking
500 ;; in an unreachable code).
504 default-vars default-vals
505 defaults
506 name)
507 res)))))))
509 ;;; Create the MORE-ENTRY function for the OPTIONAL-DISPATCH RES.
510 ;;; ENTRY-VARS and ENTRY-VALS describe the fixed arguments. REST is
511 ;;; the var for any &REST arg. KEYS is a list of the &KEY arg vars.
512 ;;;
513 ;;; The most interesting thing that we do is parse keywords. We create
514 ;;; a bunch of temporary variables to hold the result of the parse,
515 ;;; and then loop over the supplied arguments, setting the appropriate
516 ;;; temps for the supplied keyword. Note that it is significant that
517 ;;; we iterate over the keywords in reverse order --- this implements
518 ;;; the CL requirement that (when a keyword appears more than once)
519 ;;; the first value is used.
520 ;;;
521 ;;; If there is no supplied-p var, then we initialize the temp to the
522 ;;; default and just pass the temp into the main entry. Since
523 ;;; non-constant &KEY args are forcibly given a supplied-p var, we
524 ;;; know that the default is constant, and thus safe to evaluate out
525 ;;; of order.
526 ;;;
527 ;;; If there is a supplied-p var, then we create temps for both the
528 ;;; value and the supplied-p, and pass them into the main entry,
529 ;;; letting it worry about defaulting.
530 ;;;
531 ;;; We deal with :ALLOW-OTHER-KEYS by delaying unknown keyword errors
532 ;;; until we have scanned all the keywords.
559 ;; The reason for all the noise with
560 ;; STACK-GROWS-DOWNWARD-NOT-UPWARD is to enable generation of
561 ;; slightly more efficient code on x86oid processors. (We can
562 ;; hoist the negation of the index outside the main parsing loop
563 ;; and take advantage of the base+index+displacement addressing
564 ;; mode on x86oids.)
578 #!+stack-grows-downward-not-upward
580 #!-stack-grows-downward-not-upward n-value-temp
583 #!-stack-grows-downward-not-upward
598 nil
603 t
634 #!-stack-grows-downward-not-upward
644 #!+stack-grows-downward-not-upward
665 :note-lexical-bindings nil
672 ;;; This is called by IR1-CONVERT-HAIRY-ARGS when we run into a &REST
673 ;;; or &KEY arg. The arguments are similar to that function, but we
674 ;;; split off any &REST arg and pass it in separately. REST is the
675 ;;; &REST arg var, or NIL if there is no &REST arg. KEYS is a list of
676 ;;; the &KEY argument vars.
677 ;;;
678 ;;; When there are &KEY arguments, we introduce temporary gensym
679 ;;; variables to hold the values while keyword defaulting is in
680 ;;; progress to get the required sequential binding semantics.
681 ;;;
682 ;;; This gets interesting mainly when there are &KEY arguments with
683 ;;; supplied-p vars or non-constant defaults. In either case, pass in
684 ;;; a supplied-p var. If the default is non-constant, we introduce an
685 ;;; IF in the main entry that tests the supplied-p var and decides
686 ;;; whether to evaluate the default or not. In this case, the real
687 ;;; incoming value is NIL, so we must union NULL with the declared
688 ;;; type when computing the type for the main entry's argument.
690 rest more-context more-count keys supplied-p-p
691 body aux-vars aux-vals source-name debug-name
692 post-binding-lexenv system-lambda)
695 aux-vars aux-vals))
704 ;; Make up two extra variables, and squirrel them away in
705 ;; ARG-INFO-DEFAULT for transforming (VALUES-LIST REST) into
706 ;; (%MORE-ARG-VALUES CONTEXT 0 COUNT) when possible.
718 more-count count))))
730 ;; was: (format nil "~A-DEFAULTING-TEMP" (leaf-source-name key))
749 nil
769 :post-binding-lexenv post-binding-lexenv
770 :source-name source-name
771 :debug-name debug-name
779 name)
785 last-entry)
786 res)
788 last-entry)))
790 ;;; This function generates the entry point functions for the
791 ;;; OPTIONAL-DISPATCH RES. We accomplish this by recursion on the list
792 ;;; of arguments, analyzing the arglist on the way down and generating
793 ;;; entry points on the way up.
794 ;;;
795 ;;; DEFAULT-VARS is a reversed list of all the argument vars processed
796 ;;; so far, including supplied-p vars. DEFAULT-VALS is a list of the
797 ;;; names of the DEFAULT-VARS.
798 ;;;
799 ;;; ENTRY-VARS is a reversed list of processed argument vars,
800 ;;; excluding supplied-p vars. ENTRY-VALS is a list things that can be
801 ;;; evaluated to get the values for all the vars from the ENTRY-VARS.
802 ;;; It has the var name for each required or optional arg, and has T
803 ;;; for each supplied-p arg.
804 ;;;
805 ;;; VARS is a list of the LAMBDA-VAR structures for arguments that
806 ;;; haven't been processed yet. SUPPLIED-P-P is true if a supplied-p
807 ;;; argument has already been processed; only in this case are the
808 ;;; DEFAULT-XXX and ENTRY-XXX different.
809 ;;;
810 ;;; The result at each point is a lambda which should be called by the
811 ;;; above level to default the remaining arguments and evaluate the
812 ;;; body. We cause the body to be evaluated by converting it and
813 ;;; returning it as the result when the recursion bottoms out.
814 ;;;
815 ;;; Each level in the recursion also adds its entry point function to
816 ;;; the result OPTIONAL-DISPATCH. For most arguments, the defaulting
817 ;;; function and the entry point function will be the same, but when
818 ;;; SUPPLIED-P args are present they may be different.
819 ;;;
820 ;;; When we run into a &REST or &KEY arg, we punt out to
821 ;;; IR1-CONVERT-MORE, which finishes for us in this case.
823 entry-vars entry-vals
824 vars supplied-p-p body aux-vars
825 aux-vals
826 source-name debug-name
827 force post-binding-lexenv
828 system-lambda)
831 aux-vars aux-vals))
835 ;; Handle &KEY with no keys...
837 entry-vars entry-vals
838 nil nil nil vars supplied-p-p body aux-vars
839 aux-vals source-name debug-name
840 post-binding-lexenv system-lambda)
844 :aux-vars aux-vars
845 :aux-vals aux-vals
846 :post-binding-lexenv post-binding-lexenv
847 :source-name source-name
848 :debug-name debug-name
856 name)
857 res)
858 fun)
860 fun)))
867 source-name debug-name
868 nil post-binding-lexenv system-lambda)))
874 (:optional
876 res default-vars default-vals
877 entry-vars entry-vals vars supplied-p-p body
878 aux-vars aux-vals
879 source-name debug-name
880 force post-binding-lexenv
881 system-lambda)))
882 ;; See GENERATE-OPTIONAL-DEFAULT-ENTRY.
887 ep entry-vars entry-vals nil
889 ep)
890 res)
892 ep))
894 ep))
895 (:rest
897 entry-vars entry-vals
899 aux-vars aux-vals
900 source-name debug-name
901 post-binding-lexenv system-lambda))
902 (:more-context
904 entry-vars entry-vals
906 body aux-vars aux-vals
907 source-name debug-name
908 post-binding-lexenv system-lambda))
909 (:keyword
911 entry-vars entry-vals
912 nil nil nil vars supplied-p-p body aux-vars
913 aux-vals source-name debug-name
914 post-binding-lexenv system-lambda)))))))
916 ;;; This function deals with the case where we have to make an
917 ;;; OPTIONAL-DISPATCH to represent a LAMBDA. We cons up the result and
918 ;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we
919 ;;; figure out the MIN-ARGS and MAX-ARGS.
921 &key post-binding-lexenv
923 debug-name system-lambda)
927 :allowp allowp
928 :keyp keyp
929 :%source-name source-name
930 :%debug-name debug-name
937 source-name debug-name nil post-binding-lexenv
938 system-lambda)
939 ;; ir1-convert-hairy-args can throw 'locall-already-let-converted
940 ;; push optional-dispatch into the current component only after it
941 ;; normally returned
947 res))
949 ;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
951 debug-name maybe-add-debug-catch
952 system-lambda)
956 form))
959 'lambda
961 form))
964 "The lambda expression has a missing or non-list lambda list:~% ~S"
965 form))
982 forms))
984 forms
989 allow-other-keys
990 aux-vars aux-vals
991 :post-binding-lexenv post-binding-lexenv
992 :source-name source-name
993 :debug-name debug-name
997 :aux-vars aux-vars
998 :aux-vals aux-vals
999 :post-binding-lexenv post-binding-lexenv
1000 :source-name source-name
1001 :debug-name debug-name
1007 ;; KLUDGE: Not counting TL-XEPs is a lie, of course, but
1008 ;; keeps things less confusing to users of TIME, where this
1009 ;; count gets used.
1012 res))))
1015 #!+unwind-to-frame-and-call-vop
1019 ;; Just ensure that there won't be any tail-calls, IR2 magic will
1020 ;; handle the rest.
1022 #!-unwind-to-frame-and-call-vop
1025 return-value-tag
1026 ;; If DEBUG-CATCH-TAG is thrown (with a thunk as the value) the
1027 ;; RETURN-FROM is elided and we funcall the thunk instead. That
1028 ;; thunk might either return a value (for a RETURN-FROM-FRAME)
1029 ;; or call this same function again (for a RESTART-FRAME).
1030 ;; -- JES, 2007-01-09
1033 ;; Use a constant catch tag instead of consing a new one for every
1034 ;; entry to this block. The uniquencess of the catch tags is
1035 ;; ensured when the tag is throw by the debugger. It'll allocate a
1036 ;; new tag, and modify the reference this tag in the proper
1037 ;; catch-block structure to refer to that new tag. This
1038 ;; significantly decreases the runtime cost of high debug levels.
1039 ;; -- JES, 2007-01-09
1045 ;;; helper for LAMBDA-like things, to massage them into a form
1046 ;;; suitable for IR1-CONVERT-LAMBDA.
1048 &key
1050 debug-name)
1056 :maybe-add-debug-catch t
1057 :source-name source-name
1065 :maybe-add-debug-catch t
1072 ;; Don't treat recursive stubs like CAR as self-calls
1073 ;; Maybe just use the fact that it is a known function?
1074 ;; Though a known function may be used
1075 ;; because of some other attributues but
1076 ;; still wants to get optimized self calls
1086 res defined-fun-res))
1087 res)
1089 :maybe-add-debug-catch t
1090 :debug-name
1094 :source-name source-name
1096 \f
1097 ;;;; defining global functions
1099 ;;; Convert FUN as a lambda in the null environment, but use the
1100 ;;; current compilation policy. Note that FUN may be a
1101 ;;; LAMBDA-WITH-LEXENV, so we may have to augment the environment to
1102 ;;; reflect the state at the definition site.
1104 &key
1106 debug-name
1107 system-lambda)
1121 macros)
1122 ;; Inherit MUFFLE-CONDITIONS from the call-site lexenv
1123 ;; rather than the definition-site lexenv, since it seems
1124 ;; like a much more common case.
1128 :source-name source-name
1129 :debug-name debug-name
1132 clambda)))
1134 ;;; Given a lambda-list, return a FUN-TYPE object representing the signature:
1135 ;;; return type is *, and each individual arguments type is T -- but we get
1136 ;;; the argument counts and keywords.
1145 ;; When it comes to building a type, &REST means pretty much the
1146 ;; same thing as &MORE.
1152 spec)))
1156 t)))
1157 key-list))))
1161 ;;; Get a DEFINED-FUN object for a function we are about to define. If
1162 ;;; the function has been forward referenced, then substitute for the
1163 ;;; previous references.
1173 :%source-name name
1175 :declared
1184 ;; If *FREE-FUNS* has a previously converted definition
1185 ;; for this name, then blow it away and try again.
1191 ;;; Check a new global function definition for consistency with
1192 ;;; previous declaration or definition, and assert argument/result
1193 ;;; types if appropriate. This assertion is suppressed by the
1194 ;;; EXPLICIT-CHECK attribute, which is specified on functions that
1195 ;;; check their argument types as a consequence of type dispatching.
1196 ;;; This avoids redundant checks such as NUMBERP on the args to +, etc.
1202 fun type
1203 ;; KLUDGE: Common Lisp is such a dynamic language that in general
1204 ;; all we can do here is issue a STYLE-WARNING. It would be nice
1205 ;; to issue a full WARNING in the special case of type mismatches
1206 ;; within a compilation unit (as in section 3.2.2.3 of the spec)
1207 ;; but at least as of sbcl-0.6.11, we don't keep track of whether
1208 ;; the mismatched data came from the same compilation unit, so we
1209 ;; can't do that. -- WHN 2001-02-11
1214 :really-assert
1218 explicit-check))))
1220 "previous declaration"
1223 ;;; Used for global inline expansion. Earlier something like this was
1224 ;;; used by %DEFUN too. FIXME: And now it's probably worth rethinking
1225 ;;; whether this function is a good idea at all.
1227 ;; Unless a :INLINE function, we temporarily clobber the inline
1228 ;; expansion. This prevents recursive inline expansion of
1229 ;; opportunistic pseudo-inlines.
1233 :source-name name
1234 ;; prevent instrumentation of
1235 ;; known function expansions
1240 ;; Associate VAR with the FUN -- and in case of an optional dispatch
1241 ;; with the various entry-points. This allows XREF to know where the
1242 ;; inline CLAMBDA comes from.
1248 ;; Delayed entry-point.
1255 g)))))))))
1261 ;; substitute for any old references
1268 fun))
1273 inline-lambda)
1276 inline-lambda)))
1280 ;;; the even-at-compile-time part of DEFUN
1281 ;;;
1282 ;;; The INLINE-LAMBDA is a LAMBDA-WITH-LEXENV, or NIL if there is no
1283 ;;; inline expansion.
1302 ;; old CMU CL comment:
1303 ;; If there is a type from a previous definition, blast it,
1304 ;; since it is obsolete.
1307 ;; FIXME: If this is a block compilation thing, shouldn't
1308 ;; we be setting the type to the full derived type for the
1309 ;; definition, instead of this most general function type?
1314 ;; Similar to above, detect duplicate definitions within a file,
1315 ;; but the package lock check is unnecessary - it's handled elsewhere.
1316 ;;
1317 ;; Additionally, this is a STYLE-WARNING, not a WARNING, because there is
1318 ;; meaningful behavior that can be ascribed to some redefinitions, e.g.
1319 ;; (defmacro foo () first-definition)
1320 ;; (defun f () (use-it (foo )))
1321 ;; (defmacro foo () other-definition)
1322 ;; will use the first definition when compiling F, but make the second available
1323 ;; in the loaded fasl. In this usage it would have made sense to wrap the
1324 ;; respective definitions with EVAL-WHEN for different situations,
1325 ;; but as long as the compile-time behavior is deterministic, it's just bad style
1326 ;; and not flat-out wrong, though there is indeed some waste in the fasl.
1327 ;;
1328 ;; KIND is the globaldb KIND of this NAME
1338 \f
1339 ;;; Entry point utilities
1341 ;;; Return a function for the Nth entry point.