(in-package "SB!C")
-;;; FIXME: Shouldn't SB!C::&MORE be in this list?
-(defconstant-eqx 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
;;;; cross-compiler-only versions of CL special variables, so that we
;;; 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::policy-quality () '(or (rational 0 3) null))
-\f
-;;;; policy stuff
-
-;;; a map from optimization policy quality to corresponding POLICY
-;;; slot name, used to automatically keep POLICY-related definitions
-;;; in sync even if future maintenance changes POLICY slots
-(eval-when (:compile-toplevel :load-toplevel :execute)
- (defstruct (policy-quality-slot (:constructor %make-pqs (quality accessor)))
- ;; the name of the quality
- (quality (required-argument) :type symbol)
- ;; the name of the structure slot accessor
- (accessor (required-argument) :type symbol))
- (defparameter *policy-quality-slots*
- (list (%make-pqs 'speed 'policy-speed)
- (%make-pqs 'space 'policy-space)
- (%make-pqs 'safety 'policy-safety)
- (%make-pqs 'cspeed 'policy-cspeed)
- (%make-pqs 'brevity 'policy-brevity)
- (%make-pqs 'debug 'policy-debug)))
- (defun named-policy-quality-slot (name)
- (find name *policy-quality-slots* :key #'policy-quality-slot-quality)))
-
-;;; A POLICY object holds information about the compilation policy for
-;;; a node. See the LEXENV definition for a description of how it is used.
-#.`(def!struct (policy
- (:copier nil)) ; (but see DEFUN COPY-POLICY)
- ,@(mapcar (lambda (pqs)
- `(,(policy-quality-slot-quality pqs) nil
- :type policy-quality))
- *policy-quality-slots*))
-
-;;; an annoyingly hairy way of doing COPY-STRUCTURE on POLICY objects
-;;;
-;;; (We need this explicit, separate, hairy DEFUN only because we need
-;;; to be able to copy POLICY objects 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).)
-#.`(defun copy-policy (policy)
- (make-policy
- ,@(mapcan (lambda (pqs)
- `(,(keywordicate (policy-quality-slot-quality pqs))
- (,(policy-quality-slot-accessor pqs) policy)))
- *policy-quality-slots*)))
-
-;;; *DEFAULT-POLICY* 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-POLICY* holds any values specified by an
-;;; OPTIMIZE-INTERFACE declaration.
-(declaim (type policy *default-policy* *default-interface-policy*))
-(defvar *default-policy*) ; initialized in cold init
-(defvar *default-interface-policy*) ; initialized in cold init
\f
;;; possible values for the INLINE-ness of a function.
(deftype inlinep ()
(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*))
;;; 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-policy*)
-(defvar *default-interface-policy*)
+(defvar *delayed-ir1-transforms*)
+(defvar *handled-conditions*)
+(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
;; foo.lisp:
;; (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)))))
- ;; FIXME: should be COMPILER-STYLE-WARNING?
- (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))
+
+;;; Hacky (duplicating machinery found elsewhere because this function
+;;; turns out to be on a critical path in the compiler) shorthand for
+;;; creating debug names from source names or other stems, e.g.
+;;;
+;;; (DEBUG-NAMIFY "FLET " SOURCE-NAME) -> "FLET FOO:BAR"
+;;; (DEBUG-NAMIFY "top level form " FORM) -> "top level form (QUUX :FOO)"
+;;;
+;;; If ALT is given it must be a string -- it is then used in place of
+;;; either HEAD or TAIL if either of them is EQ to SB-C::.ANONYMOUS.
+;;;
+(declaim (inline debug-namify))
+(defun debug-namify (head tail &optional alt)
+ (declare (type (or null string) alt))
+ (flet ((symbol-debug-name (symbol)
+ ;; KLUDGE: (OAOOM warning) very much akin to OUTPUT-SYMBOL.
+ (if (and alt (eq '.anonymous. symbol))
+ alt
+ (let ((package (symbol-package symbol))
+ (name (symbol-name symbol)))
+ (cond
+ ((eq package *keyword-package*)
+ (concatenate 'string ":" name))
+ ((eq package *cl-package*)
+ name)
+ ((null package)
+ (concatenate 'string "#:" name))
+ (t
+ (multiple-value-bind (symbol status)
+ (find-symbol name package)
+ (declare (ignore symbol))
+ (concatenate 'string
+ (package-name package)
+ (if (eq status :external) ":" "::")
+ name))))))))
+ (cond ((and (stringp head) (stringp tail))
+ (concatenate 'string head tail))
+ ((and (stringp head) (symbolp tail))
+ (concatenate 'string head (symbol-debug-name tail)))
+ ((and (symbolp head) (stringp tail))
+ (concatenate 'string (symbol-debug-name head) tail))
+ (t
+ (macrolet ((out (obj s)
+ `(typecase ,obj
+ (string (write-string ,obj ,s))
+ (symbol (write-string (symbol-debug-name ,obj) ,s))
+ (t (prin1 ,obj ,s)))))
+ (with-standard-io-syntax
+ (let ((*print-readably* nil)
+ (*print-pretty* nil)
+ (*package* *cl-package*)
+ (*print-length* 3)
+ (*print-level* 2))
+ (with-output-to-string (s)
+ (out head s)
+ (out tail s)))))))))
projects / sbcl.git / blobdiff