| blob | 3b645e9377b3bc44b6b8b62f70bd0c5c56e28688 |
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
43 ;;; Given any non-negative integer, return a prime number >= to it.
44 ;;;
45 ;;; FIXME: This logic should be shared with ALMOST-PRIMIFY in
46 ;;; hash-table.lisp. Perhaps the merged logic should be
47 ;;; PRIMIFY-HASH-TABLE-SIZE, implemented as a lookup table of primes
48 ;;; after integral powers of two:
49 ;;; #(17 37 67 131 ..)
50 ;;; (Or, if that's too coarse, after half-integral powers of two.) By
51 ;;; thus getting rid of any need for primality testing at runtime, we
52 ;;; could punt POSITIVE-PRIMEP, too.
57 \f
58 ;;; Why do we suppress the :COMPILE-TOPLEVEL situation here when we're
59 ;;; running the cross-compiler? The cross-compiler (which was built
60 ;;; from these sources) has its version of these data and functions
61 ;;; defined in the same places we'd be defining into. We're happy with
62 ;;; its version, since it was compiled from the same sources, so
63 ;;; there's no point in overwriting its nice compiled version of this
64 ;;; stuff with our interpreted version. (And any time we're *not*
65 ;;; happy with its version, perhaps because we've been editing the
66 ;;; sources partway through bootstrapping, tch tch, overwriting its
67 ;;; version with our version would be unlikely to help, because that
68 ;;; would make the cross-compiler very confused.)
85 (!register-meta-info
87 (!make-meta-info id category kind type-spec type-checker
88 validate-function default)))))
90 #-sb-xc
93 ;; The SB!FASL: symbols are poor style, but the lesser evil.
94 ;; If exported, then they'll stick around in the target image.
95 ;; Perhaps SB-COLD should re-export some of these.
100 id
107 \f
108 ;;;; info types, and type numbers, part II: what's
109 ;;;; needed only at compile time, not at run time
111 ;;; Define a new type of global information.
112 ;;; CATEGORY/KIND form a two-part name for the piece of information,
113 ;;; DEFAULT is a defaulting expression, and TYPE-SPEC
114 ;;; is a type specifier which data values must satisfy.
115 ;;; Roughly speaking there is a hierarchy to the two-piece names
116 ;;; but this is a fiction that is not maintained anywhere in the internals.
117 ;;;
118 ;;; If the defaulting expression's value is a function, it is called with
119 ;;; the name for which the information is being looked up; otherwise it is
120 ;;; taken as the default value. The defaulting expression is used each time
121 ;;; a value is needed when one hasn't been previously set. (The result
122 ;;; does not automatically become the new value for the piece of info.)
123 ;;; Should a default value be itself a function, this must be expressed as
124 ;;; :DEFAULT (CONSTANTLY #'<a-function-name>) to adhere to the convention
125 ;;; that default objects satisfying FUNCTIONP will always be funcalled.
126 ;;;
128 ;; This convoluted idiom creates a macro that disappears from the target,
129 ;; kind of an alternative to the "!" name convention.
130 (#+sb-xc-host defmacro
135 default)
137 ;; There was formerly a remark that (COPY-TREE TYPE-SPEC) ensures repeatable
138 ;; fasls. That's not true now, probably never was. A compiler is permitted to
139 ;; coalesce EQUAL quoted lists and there's no defense against it, so why try?
140 `(!%define-info-type
143 '#'identity
146 ;; Rationale for hardcoding here is explained at INFO-VECTOR-FDEFN.
150 \f
153 ;; don't need to type-check META-INFO's result, since it
154 ;; defaults to signaling an error if no meta-info found.
156 ;;; INFO is the standard way to access the database. It's settable.
157 ;;;
158 ;;; Return the information of the specified CATEGORY and KIND for NAME.
159 ;;; The second value returned is true if there is any such information
160 ;;; recorded. If there is no information, the first value returned is
161 ;;; the default and the second value returned is NIL.
173 ;; Clear the information of the specified CATEGORY and KIND for NAME in
174 ;; the current environment. Return true if there was any info.
184 ;; A call to UNCROSS was suspiciously absent, so I added this ERROR
185 ;; to be certain that it's not supposed to happen when building the xc.
187 name info-numbers)
190 :simple
191 ;; If PACKED-INFO-REMOVE has nothing to do, it returns NIL,
192 ;; corresponding to the input that UPDATE-SYMBOL-INFO expects.
196 :hairy
197 ;; The global hashtable is not imbued with knowledge of the convention
198 ;; for PACKED-INFO-REMOVE because that would render it less useful
199 ;; as a general-purpose global hashtable for other kinds of stuff
200 ;; that I might want it to store aside from packed infos.
201 ;; So here UPDATE might receive NIL but must not return NIL if
202 ;; there was a non-nil input. NIL doesn't mean "do nothing".
205 ;; if -REMOVE => nil, then update NEW but return OLD
208 old))))
212 ;;;; *INFO-ENVIRONMENT*
215 ;; Genesis writes the *INFO-TYPES* array, but setting up the mapping
216 ;; from keyword-pair to object is deferred until cold-init.
221 ;;;; GET-INFO-VALUE
223 ;;; If non-nil, *GLOBALDB-OBSERVER*'s CAR is a bitmask over info numbers
224 ;;; for which you'd like to call the function in the CDR whenever info
225 ;;; of that number is queried.
231 ;;; Return the value of NAME / INFO-NUMBER from the global environment,
232 ;;; or return the default if there is no global info.
233 ;;; The secondary value indicates whether info was found vs defaulted.
235 get-info-value))
244 ;; In the :simple branch, KEY1 is no doubt a symbol,
245 ;; but constraint propagation isn't informing the compiler here.
255 name info-number answer t))
263 ;; Call FUNCTION once for each Name in globaldb that has information associated
264 ;; with it, passing the function the Name as its only argument.
265 ;;
272 ;; Try to process each symbol at most once by associating it with
273 ;; a single package. If a symbol is apparently uninterned,
274 ;; always keep it since we can't know if it has been seen once.
283 \f
284 ;;;; ":FUNCTION" subsection - Data pertaining to globally known functions.
288 ;;; the kind of functional object being described. If null, NAME isn't
289 ;;; a known functional object.
292 ;; I'm a little confused what the correct behavior of this default
293 ;; is. It's not clear how to generalize the FBOUNDP expression to
294 ;; the cross-compiler. As far as I can tell, NIL is a safe default
295 ;; -- it might keep the compiler from making some valid
296 ;; optimization, but it shouldn't produce incorrect code. -- WHN
297 ;; 19990330
298 :default
299 #+sb-xc-host nil
302 ;;; Indicates whether the function is deprecated.
309 ;;; the ASSUMED-TYPE for this function, if we have to infer the type
310 ;;; due to not having a declaration or definition
312 ;; FIXME: The type-spec really should be
313 ;; (or approximate-fun-type null)).
314 ;; It was changed to T as a hopefully-temporary hack while getting
315 ;; cold init problems untangled.
318 ;;; where this information came from:
319 ;;; :ASSUMED = from uses of the object
320 ;;; :DEFINED = from examination of the definition
321 ;;; :DEFINED-METHOD = implicit, incremental declaration by CLOS.
322 ;;; :DECLARED = from a declaration
323 ;;; :DEFINED trumps :ASSUMED, :DEFINED-METHOD trumps :DEFINED,
324 ;;; and :DECLARED trumps :DEFINED-METHOD.
325 ;;; :DEFINED and :ASSUMED are useful for issuing compile-time warnings,
326 ;;; :DEFINED-METHOD and :DECLARED are useful for ANSIly specializing
327 ;;; code which implements the function, or which uses the function's
328 ;;; return values.
331 :default
332 ;; Again [as in (DEFINE-INFO-TYPE (:FUNCTION :KIND) ...)] it's
333 ;; not clear how to generalize the FBOUNDP expression to the
334 ;; cross-compiler. -- WHN 19990606
338 ;;; something which can be decoded into the inline expansion of the
339 ;;; function, or NIL if there is none
340 ;;;
341 ;;; To inline a function, we want a lambda expression, e.g.
342 ;;; '(LAMBDA (X) (+ X 1)).
346 ;;; This specifies whether this function may be expanded inline. If
347 ;;; null, we don't care.
350 ;;; Track how many times IR2 converted a call to this function as a full call
351 ;;; that was not in the scope of a local or global notinline declaration.
352 ;;; Useful for finding functions that were supposed to have been converted
353 ;;; through some kind of transformation but were not.
356 ;;; a macro-like function which transforms a call to this function
357 ;;; into some other Lisp form. This expansion is inhibited if inline
358 ;;; expansion is inhibited.
359 ;;; As an exception, a cons of two atoms represents structure metadata
360 ;;; which is recognized and transformed in a stylized way.
361 ;;;
362 ;;; This item is almost mutually exclusive with an inline expansion,
363 ;;; but both are possible in the rare case of a system-defined transform
364 ;;; that may decline to expand. If it does, an inline expansion could win.
365 ;;; We don't actually have anything like that any more though.
366 ;;; For user-defined functions, the invariant is maintained that at most
367 ;;; one of :source-transform and an inline-expansion exist.
371 ;;; the macroexpansion function for this macro
374 ;;; the compiler-macroexpansion function for this function or macro
378 ;;; a function which converts this special form into IR1
381 ;;; If a function is "known" to the compiler, then this is a FUN-INFO
382 ;;; structure containing the info used to special-case compilation.
385 ;;; This is a type specifier <t> such that if an argument X to the function
386 ;;; does not satisfy (TYPEP x <t>) then the function definitely returns NIL.
387 ;;; When the named function is a predicate that appears in (SATISFIES p)
388 ;;; specifiers, it is possible for type operations to see into the predicate
389 ;;; just enough to determine that something like
390 ;;; (AND (SATISFIES UNINTERESTING-METHOD-REDEFINITION-P) RATIONAL)
391 ;;; is *empty-type*, which in turn avoids type cache pollution.
393 \f
394 ;;;; ":VARIABLE" subsection - Data pertaining to globally known variables.
396 ;;; the kind of variable-like thing described
401 :constant
410 ;;; the declared type for this variable
412 :type-spec ctype
418 ;;; where this type and kind information came from
422 ;;; the macro-expansion for symbol-macros
430 ;; :WIRED-TLS describes how SYMBOL-VALUE (implicit or not) should be compiled.
431 ;; - :ALWAYS-HAS-TLS means that calls to SYMBOL-VALUE should access the TLS
432 ;; with a fixed offset. The index is assigned no later than load-time of
433 ;; the file containing code thus compiled. Presence of an index in the
434 ;; image that performed compilation is irrelevant (for now).
435 ;; - :ALWAYS-THREAD-LOCAL implies a fixed offset, *and* that the check for
436 ;; no-tls-value may be elided. There is currently no way to set this.
437 ;; Note that this does not affect elision of the check for unbound-marker
438 ;; which is under control of the :ALWAYS-BOUND info.
439 ;; - an integer is a permanent index, and also implies :ALWAYS-THREAD-LOCAL.
440 ;; Specials in the CL package (notably reader/printer controls) use a wired-tls,
441 ;; whether or not we bind per-thread [if we don't, that's a bug!]
442 ;; We don't assume wired TLS more generally, because user code often defines
443 ;; thousands of DEFVARs, possibly due to poor style, or due to ANSI's stance
444 ;; that DEFCONSTANT is only for EQL-comparable objects. In such cases with
445 ;; more symbols than can be bound per-thread, the compiler won't exacerbate
446 ;; things by making the loader eagerly assign a TLS index to every symbol
447 ;; ever referenced by SYMBOL-VALUE or SET. Depletion should occur lazily.
448 ;;
452 :default
456 #-sb-xc-host
458 #+sb-xc-host
463 ;; I'm not worried about random extra externals in some bizarro
464 ;; host lisp. TLS assignment has no bearing on semantics at all.
469 ;;;; ":TYPE" subsection - Data pertaining to globally known types.
471 ;;; the kind of type described. We return :INSTANCE for standard types
472 ;;; that are implemented as structures. For PCL classes, that have
473 ;;; only been compiled, but not loaded yet, we return
474 ;;; :FORTHCOMING-DEFCLASS-TYPE.
475 ;;; The only major distinction between :PRIMITIVE and :DEFINED
476 ;;; is how badly the system complains about attempted redefinition.
482 ;; The compiler-macro signals an error
483 ;; on forward-referenced info-types.
491 ;;; The expander function for a defined type,
492 ;;; or a cons whose CAR is a function which is a builtin type translator.
495 ;;; If non-nil, then the type coresponding to this name. Note that if
496 ;;; this is a built-in class with a translation, then this is the
497 ;;; translation, not the class object. This info type keeps track of
498 ;;; various atomic types (NIL etc.) and also serves as a means to
499 ;;; ensure that common standard types are only consed once.
502 ;;; The classoid-cell for this type
505 ;;; DEFTYPE lambda-list
506 ;; FIXME: remove this after making swank-fancy-inspector not use it.
511 ;;; Indicates whether the type is deprecated.
515 ;;;; ":TYPED-STRUCTURE" subsection.
516 ;;;; Data pertaining to structures that used DEFSTRUCT's :TYPE option.
520 ;;;; ":DECLARATION" subsection - Data pertaining to user-defined declarations.
521 ;; CLTL2 offers an API to provide a list of known declarations, but it is
522 ;; inefficient to iterate over all symbols to find ones which have the
523 ;; (:DECLARATION :RECOGNIZED) info.
524 ;; Therefore maintain a list of recognized declarations. This list makes the
525 ;; globaldb storage of same redundant, but oh well.
528 :type-spec boolean
529 ;; There's no portable way to unproclaim that a symbol is a declaration,
530 ;; but at the low-level permit new-value to be NIL.
544 ;;;; ":ALIEN-TYPE" subsection - Data pertaining to globally known alien-types.
554 ;;;; ":SETF" subsection - Data pertaining to expansion of the omnipotent macro.
560 ;;;; ":CAS" subsection - Like SETF but there are no "inverses", just expanders
563 ;;;; ":RANDOM-DOCUMENTATION" subsection.
564 ;;; This is used for storing miscellaneous documentation types. The
565 ;;; stuff is an alist translating documentation kinds to values.
568 ;;;; ":SOURCE-LOCATION" subsection.
569 ;;; This is kind of the opposite of what I'd have thought more logical,
570 ;;; where each of the above categories has one of its kinds of information
571 ;;; being :SOURCE-LOCATION.
572 ;;; And in fact that *is* how :TYPE was handled. However, many global entities
573 ;;; store their source-location hanging off some other hook, avoiding the
574 ;;; globaldb entirely, such as functions using a #<code-component>.
575 ;;; So either way is basically a hodgepodge.
585 ;; This is for the SB-INTROSPECT contrib module, and debugging.
590 ;; This is for debugging at the REPL.
603 sym)))