| blob | 7cee71171ea2ec7e509032336968f23d2c308e9b |
1 ;;;; This file implements type check generation. This is a phase that
2 ;;;; runs at the very end of IR1. If a type check is too complex for
3 ;;;; the back end to directly emit in-line, then we transform the check
4 ;;;; into an explicit conditional using TYPEP.
6 ;;;; This software is part of the SBCL system. See the README file for
7 ;;;; more information.
8 ;;;;
9 ;;;; This software is derived from the CMU CL system, which was
10 ;;;; written at Carnegie Mellon University and released into the
11 ;;;; public domain. The software is in the public domain and is
12 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
13 ;;;; files for more information.
16 \f
17 ;;;; cost estimation
19 ;;; Return some sort of guess about the cost of a call to a function.
20 ;;; If the function has some templates, we return the cost of the
21 ;;; cheapest one, otherwise we return the cost of CALL-NAMED. Calling
22 ;;; this with functions that have transforms can result in relatively
23 ;;; meaningless results (exaggerated costs.)
24 ;;;
25 ;;; We special-case NULL, since it does have a source tranform and is
26 ;;; interesting to us.
38 call-cost)))
40 ;;; Return some sort of guess for the cost of doing a test against
41 ;;; TYPE. The result need not be precise as long as it isn't way out
42 ;;; in space. The units are based on the costs specified for various
43 ;;; templates in the VM definition.
54 nil))
78 ;; FIXME: Our canonicalization isn't quite ideal for this. We get
79 ;; types such as:
80 ;;
81 ;; (OR (AND (SATISFIES FOO) (INTEGER -100 -50))
82 ;; (AND (SATISFIES FOO) (INTEGER 100 200)))
83 ;;
84 ;; here, and weakening that into
85 ;;
86 ;; (AND (SATISFIES FOO) (INTEGER -100 200))
87 ;;
88 ;; is too much work to do here ... but if we canonicalized things
89 ;; differently, we could get it for free with trivial changes here.
99 new))
105 bound
111 bound
122 rest
127 type))))
135 type)
137 ;; Simple range checks are not that expensive, and we *don't*
138 ;; want to accidentally lose eg. array bounds checks due to
139 ;; weakening, so for integer types we simply collapse all
140 ;; ranges into one.
154 samep)
155 ;; If the supertype is equal in cost to the type, we
156 ;; prefer the supertype. This produces a closer
157 ;; approximation of the right thing in the presence of
158 ;; poor cost info.
160 min-type stype
161 min-cost stype-cost))))))
162 ;; This used to return the *UNIVERSAL-TYPE* if no supertype was found,
163 ;; but that's too liberal: it's far too easy for the user to create
164 ;; a union type (which are excluded above), and then trick the compiler
165 ;; into trusting the union type... and finally ending up corrupting the
166 ;; heap once a bad object sneaks past the missing type check.
168 min-type
169 type)))))
183 \f
184 ;;;; checking strategy determination
186 ;;; Return the type we should test for when we really want to check
187 ;;; for TYPE. If type checking policy is "fast", then we return a
188 ;;; weaker type if it is easier to check. First we try the defined
189 ;;; type weakenings, then look for any predicate that is cheaper.
197 ;;; LVAR is an lvar we are doing a type check on and TYPES is a list
198 ;;; of types that we are checking its values against. If we have
199 ;;; proven that LVAR generates a fixed number of values, then for each
200 ;;; value, we check whether it is cheaper to then difference between
201 ;;; the proven type and the corresponding type in TYPES. If so, we opt
202 ;;; for a :HAIRY check with that test negated. Otherwise, we try to do
203 ;;; a simple test, and if that is impossible, we do a hairy test with
204 ;;; non-negated types. If true, FORCE-HAIRY forces a hairy type check.
209 and c in types
210 and a in original-types
211 and i from 0
214 c)
222 ;;; Determine if CAST can be checked.
223 ;;; We may check only fixed number of values; in any case the number
224 ;;; of generated values is trusted. If we know the number of produced
225 ;;; values, all of them are checked; otherwise if we know the number
226 ;;; of consumed -- only they are checked; otherwise the check is not
227 ;;; performed.
229 ;;; In the types are checkable it returns :SIMPLE and the second value
230 ;;; of the form:
231 ;;; (NOT-P TYPE ORIGINAL-TYPE)
232 ;;;
233 ;;; If true, the NOT-P flag indicates a test that the corresponding
234 ;;; value is *not* of the specified TYPE. ORIGINAL-TYPE is the type
235 ;;; asserted on this value in the lvar, for use in error
236 ;;; messages. When NOT-P is true, this will be different from TYPE.
237 ;;;
238 ;;; This allows us to take what has been proven about CAST's argument
239 ;;; type into consideration. If it is cheaper to test for the
240 ;;; difference between the derived type and the asserted type, then we
241 ;;; check for the negation of this type instead.
251 nil)
262 ;; we [almost] know how many values are produced
267 n-required)))
269 ;; exactly one value is consumed
281 n-required)))))
284 ;; we know the number of consumed values
287 n-consumed
290 n-consumed
292 n-required)))
296 ;;; Return T is the cast appears to be from the declaration of the callee,
297 ;;; and should be checked externally -- that is, by the callee and not the caller.
303 ;; The theory is that the type assertion is from a declaration on the
304 ;; callee, so the callee should be able to do the check. We want to
305 ;; let the callee do the check, because it is possible that by the
306 ;; time of call that declaration will be changed and we do not want
307 ;; to make people recompile all calls to a function when they were
308 ;; originally compiled with a bad declaration.
309 ;;
310 ;; ALMOST-IMMEDIATELY-USED-P ensures that we don't delegate casts
311 ;; that occur before nodes that can cause observable side effects --
312 ;; most commonly other non-external casts: so the order in which
313 ;; possible type errors are signalled matches with the evaluation
314 ;; order.
315 ;;
316 ;; FIXME: We should let more cases be handled by the callee then we
317 ;; currently do, see: https://bugs.launchpad.net/sbcl/+bug/309104
318 ;; This is not fixable quite here, though, because flow-analysis has
319 ;; deleted the LVAR of the cast by the time we get here, so there is
320 ;; no destination. Perhaps we should mark cases inserted by
321 ;; ASSERT-CALL-TYPE explicitly, and delete those whose destination is
322 ;; deemed unreachable?
327 ;; Type specifiers handled by the general-purpose MAKE-TYPE-CHECK-FORM are often
328 ;; trivial enough to have an internal error number assigned to them that can be
329 ;; used in lieu of OBJECT-NOT-TYPE-ERROR. On x86-64 this saves 16 bytes: 1 word
330 ;; for the symbol in the function's constant area, a MOV instruction to load it,
331 ;; and an sc-offset in the error trap.
334 ;; read-time-eval so that during cold-init we can recreate the
335 ;; table using the target's sxhash function, but without relying
336 ;; on readiness of the type system for parsing/unparsing specifiers.
343 ;; This is effectively a compact read-only binned hashtable.
351 entries)
352 hashtable))
363 ;; spec -> (count . primitive-p)
367 answer)))
369 ;;; Return a lambda form that we can convert to do a type check
370 ;;; of the specified TYPES. TYPES is a list of the format returned by
371 ;;; CAST-CHECK-TYPES.
372 ;;;
373 ;;; Note that we don't attempt to check for required values being
374 ;;; unsupplied. Such checking is impossible to efficiently do at the
375 ;;; source level because our fixed-values conventions are optimized
376 ;;; for the common MV-BIND case.
392 temps
393 types)
396 ;;; Splice in explicit type check code immediately before CAST. This
397 ;;; code receives the value(s) that were being passed to CAST-VALUE,
398 ;;; checks the type(s) of the value(s), then passes them further.
409 atype)
423 ;;; Check all possible arguments of CAST and emit type warnings for
424 ;;; those with type errors. If the value of USE is being used for a
425 ;;; variable binding, we figure out which one for source context. If
426 ;;; the value is a constant, we print it specially.
453 pos)))))))
456 :format-control
457 "~:[This~;~:*~A~] is not a ~<~%~9T~:;~S:~>~% ~S"
458 :format-arguments
463 :format-control
464 "~:[Result~;~:*~A~] is a ~S, ~<~%~9T~:;not a ~S.~>"
465 :format-arguments
469 ;;; Loop over all blocks in COMPONENT that have TYPE-CHECK set,
470 ;;; looking for CASTs with TYPE-CHECK T. We do two mostly unrelated
471 ;;; things: detect compile-time type errors and determine if and how
472 ;;; to do run-time type checks.
473 ;;;
474 ;;; If there is a compile-time type error, then we mark the CAST and
475 ;;; emit a warning if appropriate. This part loops over all the uses
476 ;;; of the continuation, since after we convert the check, the
477 ;;; :DELETED kind will inhibit warnings about the types of other uses.
478 ;;;
479 ;;; If the cast is too complex to be checked by the back end, or is
480 ;;; better checked with explicit code, then convert to an explicit
481 ;;; test. Assertions that can checked by the back end are passed
482 ;;; through. Assertions that can't be tested are flamed about and
483 ;;; marked as not needing to be checked.
484 ;;;
485 ;;; If we determine that a type check won't be done, then we set
486 ;;; TYPE-CHECK to :NO-CHECK. In the non-hairy cases, this is just to
487 ;;; prevent us from wasting time coming to the same conclusion again
488 ;;; on a later iteration. In the hairy case, we must indicate to LTN
489 ;;; that it must choose a safe implementation, since IR2 conversion
490 ;;; will choke on the check.
491 ;;;
492 ;;; The generation of the type checks is delayed until all the type
493 ;;; check decisions have been made because the generation of the type
494 ;;; checks creates new nodes whose derived types aren't always updated
495 ;;; which may lead to inappropriate template choices due to the
496 ;;; modification of argument types.
502 ;; CAST-EXTERNALLY-CHECKABLE-P wants the backward pass
510 ;; it is possible that NODE was marked :EXTERNAL by
511 ;; the previous pass
519 (:simple
521 (:too-hairy
525 "type assertion too complex to check:~% ~S."