| blob | fce8524fc6fcc0d5252a639aa866a1fa2a62761f |
1 ;;;; This file provides a functional interface to global information
2 ;;;; about named things in the system. Information is considered to be
3 ;;;; global if it must persist between invocations of the compiler. The
4 ;;;; use of a functional interface eliminates the need for the compiler
5 ;;;; to worry about the actual representation. This is important, since
6 ;;;; the information may well have several representations.
7 ;;;;
8 ;;;; The database contains arbitrary Lisp values, addressed by a
9 ;;;; <Name,Info-Number> pair, where Info-Number is identified by
10 ;;;; a <Category,Kind> pair, each being a keyword. The Name is a thing
11 ;;;; which we are recording information about. [Names are compared by EQUAL.]
12 ;;;; Category and Kind create a taxonomy of the data values for a thing.
13 ;;;; For example, '+ names both a function and a variable, so has (at least)
14 ;;;; two categories of information. Within each category, we have several
15 ;;;; pieces of info, and in fact some of these have the same-named :Kind
16 ;;;; such as <:FUNCTION,:TYPE> and <:VARIABLE,:TYPE>.
17 ;;;; (And sometimes the Kind is literally :KIND, as a consequence of
18 ;;;; how users of the database desire to name their keys.)
20 ;;;; The relation between this file and 'info-vectors' is that the
21 ;;;; latter provides a fundamental mechanism to create property-list-like
22 ;;;; things whose "indicators" are restricted to small integers.
23 ;;;; The globaldb abstraction is layered on top of that and is responsible
24 ;;;; for translating <Category,Kind> to a small integer.
26 ;;;; This software is part of the SBCL system. See the README file for
27 ;;;; more information.
28 ;;;;
29 ;;;; This software is derived from the CMU CL system, which was
30 ;;;; written at Carnegie Mellon University and released into the
31 ;;;; public domain. The software is in the public domain and is
32 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
33 ;;;; files for more information.
37 #-no-ansi-print-object
46 ;;; This is sorta semantically equivalent to SXHASH, but better-behaved for
47 ;;; legal function names. It performs more work by not cutting off as soon
48 ;;; in the CDR direction, thereby improving the distribution of method names.
49 ;;; More work here equates to less work in the global hashtable.
50 ;;; To wit: (eq (sxhash '(foo a b c bar)) (sxhash '(foo a b c d))) => T
51 ;;; but the corresponding globaldb-sxhashoids differ.
52 ;;; This is no longer inline because for the cases where it is needed -
53 ;;; names which are not just symbols or (SETF F) - an extra call has no impact.
55 ;; we can't use MIX because it's in 'target-sxhash',
56 ;; so use the host's sxhash, but ensure that the result is a target fixnum.
58 #-sb-xc-host
61 ;; TRAVERSE will walk across more cons cells than RECURSE will descend.
62 ;; That's why this isn't just one self-recursive function.
78 ;;; Given any non-negative integer, return a prime number >= to it.
79 ;;;
80 ;;; FIXME: This logic should be shared with ALMOST-PRIMIFY in
81 ;;; hash-table.lisp. Perhaps the merged logic should be
82 ;;; PRIMIFY-HASH-TABLE-SIZE, implemented as a lookup table of primes
83 ;;; after integral powers of two:
84 ;;; #(17 37 67 131 ..)
85 ;;; (Or, if that's too coarse, after half-integral powers of two.) By
86 ;;; thus getting rid of any need for primality testing at runtime, we
87 ;;; could punt POSITIVE-PRIMEP, too.
92 \f
93 ;;; Why do we suppress the :COMPILE-TOPLEVEL situation here when we're
94 ;;; running the cross-compiler? The cross-compiler (which was built
95 ;;; from these sources) has its version of these data and functions
96 ;;; defined in the same places we'd be defining into. We're happy with
97 ;;; its version, since it was compiled from the same sources, so
98 ;;; there's no point in overwriting its nice compiled version of this
99 ;;; stuff with our interpreted version. (And any time we're *not*
100 ;;; happy with its version, perhaps because we've been editing the
101 ;;; sources partway through bootstrapping, tch tch, overwriting its
102 ;;; version with our version would be unlikely to help, because that
103 ;;; would make the cross-compiler very confused.)
121 (!register-meta-info
123 (!make-meta-info id category kind type-spec type-checker
124 validate-function default)))))
128 #-sb-xc
131 ;; The SB!FASL: symbols are poor style, but the lesser evil.
132 ;; If exported, then they'll stick around in the target image.
133 ;; Perhaps SB-COLD should re-export some of these.
138 id
146 (!cold-init-forms
148 ;; Genesis writes the *INFO-TYPES* array, but setting up the mapping
149 ;; from keyword-pair to object is deferred until cold-init.
151 \f
152 ;;;; info types, and type numbers, part II: what's
153 ;;;; needed only at compile time, not at run time
155 ;;; Define a new type of global information.
156 ;;; CATEGORY/KIND form a two-part name for the piece of information,
157 ;;; DEFAULT is a defaulting expression, and TYPE-SPEC
158 ;;; is a type specifier which data values must satisfy.
159 ;;; Roughly speaking there is a hierarchy to the two-piece names
160 ;;; but this is a fiction that is not maintained anywhere in the internals.
161 ;;;
162 ;;; If the defaulting expression's value is a function, it is called with
163 ;;; the name for which the information is being looked up; otherwise it is
164 ;;; taken as the default value. The defaulting expression is used each time
165 ;;; a value is needed when one hasn't been previously set. (The result
166 ;;; does not automatically become the new value for the piece of info.)
167 ;;; Should a default value be itself a function, this must be expressed as
168 ;;; :DEFAULT (CONSTANTLY #'<a-function-name>) to adhere to the convention
169 ;;; that default objects satisfying FUNCTIONP will always be funcalled.
170 ;;;
172 ;; This convoluted idiom creates a macro that disappears from the target,
173 ;; kind of an alternative to the "!" name convention.
174 (#+sb-xc-host defmacro
179 default)
181 ;; There was formerly a remark that (COPY-TREE TYPE-SPEC) ensures repeatable
182 ;; fasls. That's not true now, probably never was. A compiler is permitted to
183 ;; coalesce EQUAL quoted lists and there's no defense against it, so why try?
185 `(!%define-info-type
188 ;; evil KLUDGE to avoid "undefined type" warnings
189 ;; when building the cross-compiler.
190 #+sb-xc-host
198 x
203 ;; Rationale for hardcoding here is explained at INFO-VECTOR-FDEFN.
208 \f
211 ;; don't need to type-check META-INFO's result, since it
212 ;; defaults to signaling an error if no meta-info found.
214 ;;; INFO is the standard way to access the database. It's settable.
215 ;;;
216 ;;; Return the information of the specified CATEGORY and KIND for NAME.
217 ;;; The second value returned is true if there is any such information
218 ;;; recorded. If there is no information, the first value returned is
219 ;;; the default and the second value returned is NIL.
231 ;; Clear the information of the specified CATEGORY and KIND for NAME in
232 ;; the current environment. Return true if there was any info.
242 ;; A call to UNCROSS was suspiciously absent, so I added this ERROR
243 ;; to be certain that it's not supposed to happen when building the xc.
245 name info-numbers)
248 :simple
249 ;; If PACKED-INFO-REMOVE has nothing to do, it returns NIL,
250 ;; corresponding to the input that UPDATE-SYMBOL-INFO expects.
254 :hairy
255 ;; The global hashtable is not imbued with knowledge of the convention
256 ;; for PACKED-INFO-REMOVE because that would render it less useful
257 ;; as a general-purpose global hashtable for other kinds of stuff
258 ;; that I might want it to store aside from packed infos.
259 ;; So here UPDATE might receive NIL but must not return NIL if
260 ;; there was a non-nil input. NIL doesn't mean "do nothing".
263 ;; if -REMOVE => nil, then update NEW but return OLD
266 old))))
270 ;;;; *INFO-ENVIRONMENT*
272 (!cold-init-forms
276 ;;;; GET-INFO-VALUE
278 ;;; If non-nil, *GLOBALDB-OBSERVER*'s CAR is a bitmask over info numbers
279 ;;; for which you'd like to call the function in the CDR whenever info
280 ;;; of that number is queried.
286 ;;; Return the value of NAME / INFO-NUMBER from the global environment,
287 ;;; or return the default if there is no global info.
288 ;;; The secondary value indicates whether info was found vs defaulted.
290 get-info-value))
299 ;; In the :simple branch, KEY1 is no doubt a symbol,
300 ;; but constraint propagation isn't informing the compiler here.
310 name info-number answer t))
318 ;; interface to %ATOMIC-SET-INFO-VALUE
319 ;; GET-INFO-VALUE-INITIALIZING is a restricted case of this,
320 ;; and perhaps could be implemented as such.
321 ;; Atomic update will be important for making the fasloader threadsafe
322 ;; using a predominantly lock-free design, and other nice things.
330 ;; rewrite as FLET because the compiler is unable to dxify
331 ;; (DX-LET ((x (LAMBDA <whatever>))) (F x))
337 ;; Call FUNCTION once for each Name in globaldb that has information associated
338 ;; with it, passing the function the Name as its only argument.
339 ;;
346 ;; Try to process each symbol at most once by associating it with
347 ;; a single package. If a symbol is apparently uninterned,
348 ;; always keep it since we can't know if it has been seen once.
357 \f
358 ;;;; ":FUNCTION" subsection - Data pertaining to globally known functions.
362 ;;; the kind of functional object being described. If null, NAME isn't
363 ;;; a known functional object.
366 ;; I'm a little confused what the correct behavior of this default
367 ;; is. It's not clear how to generalize the FBOUNDP expression to
368 ;; the cross-compiler. As far as I can tell, NIL is a safe default
369 ;; -- it might keep the compiler from making some valid
370 ;; optimization, but it shouldn't produce incorrect code. -- WHN
371 ;; 19990330
372 :default
373 #+sb-xc-host nil
376 ;;; Indicates whether the function is deprecated.
383 ;;; The type specifier for this function.
385 :type-spec ctype
386 ;; Again [as in (DEFINE-INFO-TYPE (:FUNCTION :TYPE) ...)] it's
387 ;; not clear how to generalize the FBOUNDP expression to the
388 ;; cross-compiler. -- WHN 19990330
389 :default
390 ;; Delay evaluation of (SPECIFIER-TYPE) since it can't work yet
398 ;;; the ASSUMED-TYPE for this function, if we have to infer the type
399 ;;; due to not having a declaration or definition
401 ;; FIXME: The type-spec really should be
402 ;; (or approximate-fun-type null)).
403 ;; It was changed to T as a hopefully-temporary hack while getting
404 ;; cold init problems untangled.
407 ;;; where this information came from:
408 ;;; :ASSUMED = from uses of the object
409 ;;; :DEFINED = from examination of the definition
410 ;;; :DEFINED-METHOD = implicit, incremental declaration by CLOS.
411 ;;; :DECLARED = from a declaration
412 ;;; :DEFINED trumps :ASSUMED, :DEFINED-METHOD trumps :DEFINED,
413 ;;; and :DECLARED trumps :DEFINED-METHOD.
414 ;;; :DEFINED and :ASSUMED are useful for issuing compile-time warnings,
415 ;;; :DEFINED-METHOD and :DECLARED are useful for ANSIly specializing
416 ;;; code which implements the function, or which uses the function's
417 ;;; return values.
420 :default
421 ;; Again [as in (DEFINE-INFO-TYPE (:FUNCTION :KIND) ...)] it's
422 ;; not clear how to generalize the FBOUNDP expression to the
423 ;; cross-compiler. -- WHN 19990606
427 ;;; something which can be decoded into the inline expansion of the
428 ;;; function, or NIL if there is none
429 ;;;
430 ;;; To inline a function, we want a lambda expression, e.g.
431 ;;; '(LAMBDA (X) (+ X 1)).
435 ;;; This specifies whether this function may be expanded inline. If
436 ;;; null, we don't care.
439 ;;; Track how many times IR2 converted a call to this function as a full call
440 ;;; that was not in the scope of a local or global notinline declaration.
441 ;;; Useful for finding functions that were supposed to have been converted
442 ;;; through some kind of transformation but were not.
445 ;;; a macro-like function which transforms a call to this function
446 ;;; into some other Lisp form. This expansion is inhibited if inline
447 ;;; expansion is inhibited.
448 ;;; As an exception, a cons of two atoms represents structure metadata
449 ;;; which is recognized and transformed in a stylized way.
453 ;;; the macroexpansion function for this macro
456 ;;; the compiler-macroexpansion function for this function or macro
460 ;;; a function which converts this special form into IR1
463 ;;; If a function is "known" to the compiler, then this is a FUN-INFO
464 ;;; structure containing the info used to special-case compilation.
467 ;;; This is a type specifier <t> such that if an argument X to the function
468 ;;; does not satisfy (TYPEP x <t>) then the function definitely returns NIL.
469 ;;; When the named function is a predicate that appears in (SATISFIES p)
470 ;;; specifiers, it is possible for type operations to see into the predicate
471 ;;; just enough to determine that something like
472 ;;; (AND (SATISFIES UNINTERESTING-METHOD-REDEFINITION-P) RATIONAL)
473 ;;; is *empty-type*, which in turn avoids type cache pollution.
475 \f
476 ;;;; ":VARIABLE" subsection - Data pertaining to globally known variables.
478 ;;; the kind of variable-like thing described
483 :constant
492 ;;; the declared type for this variable
494 :type-spec ctype
495 ;; This gets set to *UNIVERSAL-TYPE* in 'late-type'
498 ;;; where this type and kind information came from
502 ;;; the macro-expansion for symbol-macros
510 ;; :WIRED-TLS describes how SYMBOL-VALUE (implicit or not) should be compiled.
511 ;; - :ALWAYS-HAS-TLS means that calls to SYMBOL-VALUE should access the TLS
512 ;; with a fixed offset. The index is assigned no later than load-time of
513 ;; the file containing code thus compiled. Presence of an index in the
514 ;; image that performed compilation is irrelevant (for now).
515 ;; - :ALWAYS-THREAD-LOCAL implies a fixed offset, *and* that the check for
516 ;; no-tls-value may be elided. There is currently no way to set this.
517 ;; Note that this does not affect elision of the check for unbound-marker
518 ;; which is under control of the :ALWAYS-BOUND info.
519 ;; - an integer is a permanent index, and also implies :ALWAYS-THREAD-LOCAL.
520 ;; Specials in the CL package (notably reader/printer controls) use a wired-tls,
521 ;; whether or not we bind per-thread [if we don't, that's a bug!]
522 ;; We don't assume wired TLS more generally, because user code often defines
523 ;; thousands of DEFVARs, possibly due to poor style, or due to ANSI's stance
524 ;; that DEFCONSTANT is only for EQL-comparable objects. In such cases with
525 ;; more symbols than can be bound per-thread, the compiler won't exacerbate
526 ;; things by making the loader eagerly assign a TLS index to every symbol
527 ;; ever referenced by SYMBOL-VALUE or SET. Depletion should occur lazily.
528 ;;
532 :default
536 #-sb-xc-host
538 #+sb-xc-host
543 ;; I'm not worried about random extra externals in some bizarro
544 ;; host lisp. TLS assignment has no bearing on semantics at all.
549 ;;;; ":TYPE" subsection - Data pertaining to globally known types.
551 ;;; the kind of type described. We return :INSTANCE for standard types
552 ;;; that are implemented as structures. For PCL classes, that have
553 ;;; only been compiled, but not loaded yet, we return
554 ;;; :FORTHCOMING-DEFCLASS-TYPE.
555 ;;; The only major distinction between :PRIMITIVE and :DEFINED
556 ;;; is how badly the system complains about attempted redefinition.
562 ;; The compiler-macro signals an error
563 ;; on forward-referenced info-types.
571 ;;; Either a CTYPE which is the translation of this type name,
572 ;;; or a function that parses type specifiers into CTYPE structures.
573 ;;; The :BUILTIN property is mutually exclusive with a CTYPE stored here.
574 ;;; :BUILTIN could probably be eliminated, as it is redundant since we
575 ;;; can discern a :BUILTIN by its :KIND being :PRIMITIVE.
578 ;; This error is never seen by a user. After meta-compile there is no
579 ;; means to define additional types with custom translators.
581 ;; The compiler-macro signals an error
582 ;; on forward-referenced info-types.
587 new-value
591 ;;; The expander function for a defined type.
592 ;;; It returns a type expression, not a CTYPE.
595 ;; This error is never seen by a user.
596 ;; The user sees "illegal to redefine standard type".
601 ;;; If true, then the type coresponding to this name. Note that if
602 ;;; this is a built-in class with a translation, then this is the
603 ;;; translation, not the class object. This info type keeps track of
604 ;;; various atomic types (NIL etc.) and also serves as a means to
605 ;;; ensure that common standard types are only consed once.
613 ;;; The classoid-cell for this type
624 ;;; Return the classoid with the specified NAME. If ERRORP is false,
625 ;;; then NIL is returned when no such class exists.
632 :datum nil
637 ;;; layout for this type being used by the compiler
644 ;;; DEFTYPE lambda-list
645 ;; FIXME: remove this after making swank-fancy-inspector not use it.
650 ;;; Indicates whether the type is deprecated.
654 ;;;; ":TYPED-STRUCTURE" subsection.
655 ;;;; Data pertaining to structures that used DEFSTRUCT's :TYPE option.
659 ;;;; ":DECLARATION" subsection - Data pertaining to user-defined declarations.
660 ;; CLTL2 offers an API to provide a list of known declarations, but it is
661 ;; inefficient to iterate over all symbols to find ones which have the
662 ;; (:DECLARATION :RECOGNIZED) info.
663 ;; Therefore maintain a list of recognized declarations. This list makes the
664 ;; globaldb storage of same redundant, but oh well.
667 :type-spec boolean
668 ;; There's no portable way to unproclaim that a symbol is a declaration,
669 ;; but at the low-level permit new-value to be NIL.
683 ;;;; ":ALIEN-TYPE" subsection - Data pertaining to globally known alien-types.
693 ;;;; ":SETF" subsection - Data pertaining to expansion of the omnipotent macro.
699 ;;;; ":CAS" subsection - Like SETF but there are no "inverses", just expanders
702 ;;;; ":RANDOM-DOCUMENTATION" subsection.
703 ;;; This is used for storing miscellaneous documentation types. The
704 ;;; stuff is an alist translating documentation kinds to values.
707 ;;;; ":SOURCE-LOCATION" subsection.
708 ;;; This is kind of the opposite of what I'd have thought more logical,
709 ;;; where each of the above categories has one of its kinds of information
710 ;;; being :SOURCE-LOCATION.
711 ;;; And in fact that *is* how :TYPE was handled. However, many global entities
712 ;;; store their source-location hanging off some other hook, avoiding the
713 ;;; globaldb entirely, such as functions using a #<code-component>.
714 ;;; So either way is basically a hodgepodge.
724 ;; This is for the SB-INTROSPECT contrib module, and debugging.
729 ;; This is for debugging at the REPL.
742 sym)))
743 \f