(in-package "SB!C")
-(file-comment
- "$Header$")
-
-;;; FIXME: shouldn't SB-C::&MORE be in this list?
-(defconstant sb!xc:lambda-list-keywords
- '(&optional &rest &key &aux &body &whole &allow-other-keys &environment)
+;;; ANSI limits on compilation
+(def!constant sb!xc:call-arguments-limit most-positive-fixnum
+ #!+sb-doc
+ "The exclusive upper bound on the number of arguments which may be passed
+ to a function, including &REST args.")
+(def!constant sb!xc:lambda-parameters-limit most-positive-fixnum
+ #!+sb-doc
+ "The exclusive upper bound on the number of parameters which may be specifed
+ in a given lambda list. This is actually the limit on required and &OPTIONAL
+ parameters. With &KEY and &AUX you can get more.")
+(def!constant sb!xc:multiple-values-limit most-positive-fixnum
+ #!+sb-doc
+ "The exclusive upper bound on the number of multiple VALUES that you can
+ return.")
+
+(defconstant-eqx sb!xc:lambda-list-keywords
+ '(&allow-other-keys
+ &aux
+ &body
+ &environment
+ &key
+ &more
+ &optional
+ &rest
+ &whole)
+ #'equal
#!+sb-doc
"symbols which are magical in a lambda list")
\f
;;;; somewhere else, not "early-c", since they're after all not part
;;;; of the compiler.
-(def!type sb!kernel:index () `(integer 0 (,sb!xc:array-dimension-limit)))
-
;;; the type of LAYOUT-DEPTHOID slot values
(def!type sb!kernel::layout-depthoid () '(or index (integer -1 -1)))
-
-;;; a value for an optimization declaration
-(def!type sb!c::cookie-quality () '(or (rational 0 3) null))
\f
-;;; A COOKIE holds information about the compilation environment for a
-;;; node. See the LEXENV definition for a description of how it is
-;;; used.
-(def!struct (cookie (:copier nil))
- (speed nil :type cookie-quality)
- (space nil :type cookie-quality)
- (safety nil :type cookie-quality)
- (cspeed nil :type cookie-quality)
- (brevity nil :type cookie-quality)
- (debug nil :type cookie-quality))
-
-;;; KLUDGE: This needs to be executable in cold init toplevel forms, earlier
-;;; than the default copier closure created by DEFSTRUCT toplevel forms would
-;;; be available, and earlier than LAYOUT-INFO is initialized (which is a
-;;; prerequisite for COPY-STRUCTURE to work), so we define it explicitly using
-;;; DEFUN, so that it can be installed by the cold loader, and using
-;;; hand-written, hand-maintained slot-by-slot copy it doesn't need to call
-;;; COPY-STRUCTURE. -- WHN 19991019
-(defun copy-cookie (cookie)
- (make-cookie :speed (cookie-speed cookie)
- :space (cookie-space cookie)
- :safety (cookie-safety cookie)
- :cspeed (cookie-cspeed cookie)
- :brevity (cookie-brevity cookie)
- :debug (cookie-debug cookie)))
-
-;;; *DEFAULT-COOKIE* holds the current global compiler policy information.
-;;; Whenever the policy is changed, we copy the structure so that old uses will
-;;; still get the old values. *DEFAULT-INTERFACE-COOKIE* holds any values
-;;; specified by an OPTIMIZE-INTERFACE declaration.
-;;;
-;;; FIXME: Why isn't COOKIE called POLICY?
-(declaim (type cookie *default-cookie* *default-interface-cookie*))
-(defvar *default-cookie*) ; initialized in cold init
-(defvar *default-interface-cookie*) ; initialized in cold init
-
;;; possible values for the INLINE-ness of a function.
(deftype inlinep ()
'(member :inline :maybe-inline :notinline nil))
-(defconstant inlinep-translations
+(defparameter *inlinep-translations*
'((inline . :inline)
(notinline . :notinline)
(maybe-inline . :maybe-inline)))
-;;; The lexical environment we are currently converting in.
+;;; the lexical environment we are currently converting in
(defvar *lexenv*)
(declaim (type lexenv *lexenv*))
-;;; *FREE-VARIABLES* translates from the names of variables referenced
-;;; globally to the LEAF structures for them. *FREE-FUNCTIONS* is like
-;;; *FREE-VARIABLES*, only it deals with function names.
-(defvar *free-variables*)
-(defvar *free-functions*)
-(declaim (hash-table *free-variables* *free-functions*))
+;;; *FREE-VARS* translates from the names of variables referenced
+;;; globally to the LEAF structures for them. *FREE-FUNS* is like
+;;; *FREE-VARS*, only it deals with function names.
+(defvar *free-vars*)
+(defvar *free-funs*)
+(declaim (type hash-table *free-vars* *free-funs*))
-;;; We use the same Constant structure to represent all equal anonymous
-;;; constants. This hashtable translates from constants to the Leafs that
+;;; We use the same CONSTANT structure to represent all equal anonymous
+;;; constants. This hashtable translates from constants to the LEAFs that
;;; represent them.
(defvar *constants*)
-(declaim (hash-table *constants*))
+(declaim (type hash-table *constants*))
+
+;;; *ALLOW-INSTRUMENTING* controls whether we should allow the
+;;; insertion of instrumenting code (like a (CATCH ...)) around code
+;;; to allow the debugger RETURN and STEP commands to function (we
+;;; disallow it for internal stuff).
+(defvar *allow-instrumenting*)
;;; miscellaneous forward declarations
(defvar *code-segment*)
(defvar *compiler-warning-count*)
(defvar *compiler-style-warning-count*)
(defvar *compiler-note-count*)
-(defvar *converting-for-interpreter*)
+(defvar *compiler-trace-output*)
+(defvar *constraint-number*)
(defvar *count-vop-usages*)
(defvar *current-path*)
(defvar *current-component*)
-(defvar *default-cookie*)
-(defvar *default-interface-cookie*)
+(defvar *delayed-ir1-transforms*)
+(defvar *handled-conditions*)
+(defvar *disabled-package-locks*)
+(defvar *policy*)
(defvar *dynamic-counts-tn*)
(defvar *elsewhere*)
(defvar *event-info*)
(defvar *event-note-threshold*)
(defvar *failure-p*)
-(defvar *fixups*)
+(defvar *fixup-notes*)
(defvar *in-pack*)
(defvar *info-environment*)
(defvar *lexenv*)
(defvar *trace-table*)
(defvar *undefined-warnings*)
(defvar *warnings-p*)
+
+;;; This lock is seized in the compiler, and related areas: the
+;;; compiler is not presently thread-safe
+(defvar *big-compiler-lock*
+ (sb!thread:make-mutex :name "big compiler lock"))
+
+;;; unique ID for the next object created (to let us track object
+;;; identity even across GC, useful for understanding weird compiler
+;;; bugs where something is supposed to be unique but is instead
+;;; exists as duplicate objects)
+#!+sb-show
+(progn
+ (defvar *object-id-counter* 0)
+ (defun new-object-id ()
+ (prog1
+ *object-id-counter*
+ (incf *object-id-counter*))))
\f
;;;; miscellaneous utilities
note-name-defined))
(defun note-name-defined (name kind)
;; We do this BOUNDP check because this function can be called when
- ;; not in a compilation unit (as when loading top-level forms).
+ ;; not in a compilation unit (as when loading top level forms).
(when (boundp '*undefined-warnings*)
(setq *undefined-warnings*
(delete-if (lambda (x)
;;; to be called when a variable is lexically bound
(declaim (ftype (function (symbol) (values)) note-lexical-binding))
(defun note-lexical-binding (symbol)
- (let ((name (symbol-name symbol)))
- ;; This check is intended to protect us from getting silently burned when
- ;; we define
+ ;; This check is intended to protect us from getting silently
+ ;; burned when we define
;; foo.lisp:
- ;; (DEFVAR *FOO*)
- ;; (DEFUN FOO (X) (1+ X *FOO*))
+ ;; (DEFVAR *FOO* -3)
+ ;; (DEFUN FOO (X) (+ X *FOO*))
;; bar.lisp:
;; (DEFUN BAR (X)
;; (LET ((*FOO* X))
;; (FOO 14)))
;; and then we happen to compile bar.lisp before foo.lisp.
- (when (and (char= #\* (aref name 0))
- (char= #\* (aref name (1- (length name)))))
- (style-warn "using the lexical binding of the symbol ~S, not the~@
+ (when (looks-like-name-of-special-var-p symbol)
+ ;; FIXME: should be COMPILER-STYLE-WARNING?
+ (style-warn "using the lexical binding of the symbol ~S, not the~@
dynamic binding, even though the symbol name follows the usual naming~@
-convention (names like *FOO*) for special variables" symbol)))
+convention (names like *FOO*) for special variables" symbol))
(values))
+
+(defvar *debug-name-level* 6)
+
+(defun debug-name (type thing)
+ (labels ((walk (x level)
+ (if (> *debug-name-level* (incf level))
+ (typecase x
+ (cons
+ (cons (walk (car x) level) (walk (cdr x) level)))
+ ((or symbol number string)
+ x)
+ (t
+ (format nil "#<~S>" (type-of x))))
+ "#<...>")))
+ ;; FIXME: It might be nice to put markers in the tree instead of
+ ;; this #<...> business, so that they would evantually be printed
+ ;; without the quotes.
+ (let ((name (list type (walk thing 0))))
+ (when (legal-fun-name-p name)
+ (bug "~S is a legal function name, and cannot be used as a ~
+ debug name." name))
+ name)))
projects / sbcl.git / blobdiff