src/compiler/early-c.lisp

   1 ;;;; This file contains compiler code and compiler-related stuff which
   2 ;;;; can be built early on. Some of the stuff may be here because it's
   3 ;;;; needed early on, some other stuff (e.g. constants) just because
   4 ;;;; it might as well be done early so we don't have to think about
   5 ;;;; whether it's done early enough.
   6
   7 ;;;; This software is part of the SBCL system. See the README file for
   8 ;;;; more information.
   9 ;;;;
  10 ;;;; This software is derived from the CMU CL system, which was
  11 ;;;; written at Carnegie Mellon University and released into the
  12 ;;;; public domain. The software is in the public domain and is
  13 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
  14 ;;;; files for more information.
  15
  16 (in-package "SB!C")
  17
  18 ;;; ANSI limits on compilation
  19 (def!constant sb!xc:call-arguments-limit sb!xc:most-positive-fixnum
  20   #!+sb-doc
  21   "The exclusive upper bound on the number of arguments which may be passed
  22   to a function, including &REST args.")
  23 (def!constant sb!xc:lambda-parameters-limit sb!xc:most-positive-fixnum
  24   #!+sb-doc
  25   "The exclusive upper bound on the number of parameters which may be specifed
  26   in a given lambda list. This is actually the limit on required and &OPTIONAL
  27   parameters. With &KEY and &AUX you can get more.")
  28 (def!constant sb!xc:multiple-values-limit sb!xc:most-positive-fixnum
  29   #!+sb-doc
  30   "The exclusive upper bound on the number of multiple VALUES that you can
  31   return.")
  32 \f
  33 ;;;; cross-compiler-only versions of CL special variables, so that we
  34 ;;;; don't have weird interactions with the host compiler
  35
  36 (defvar sb!xc:*compile-file-pathname*)
  37 (defvar sb!xc:*compile-file-truename*)
  38 (defvar sb!xc:*compile-print*)
  39 (defvar sb!xc:*compile-verbose*)
  40 \f
  41 ;;;; miscellaneous types used both in the cross-compiler and on the target
  42
  43 ;;;; FIXME: The INDEX and LAYOUT-DEPTHOID definitions probably belong
  44 ;;;; somewhere else, not "early-c", since they're after all not part
  45 ;;;; of the compiler.
  46
  47 ;;; the type of LAYOUT-DEPTHOID slot values
  48 (def!type sb!kernel::layout-depthoid () '(or index (integer -1 -1)))
  49 \f
  50 ;;; possible values for the INLINE-ness of a function.
  51 (deftype inlinep ()
  52   '(member :inline :maybe-inline :notinline nil))
  53 (defparameter *inlinep-translations*
  54   '((inline . :inline)
  55     (notinline . :notinline)
  56     (maybe-inline . :maybe-inline)))
  57
  58 ;;; the lexical environment we are currently converting in
  59 (defvar *lexenv*)
  60 (declaim (type lexenv *lexenv*))
  61
  62 ;;; *FREE-VARS* translates from the names of variables referenced
  63 ;;; globally to the LEAF structures for them. *FREE-FUNS* is like
  64 ;;; *FREE-VARS*, only it deals with function names.
  65 (defvar *free-vars*)
  66 (defvar *free-funs*)
  67 (declaim (type hash-table *free-vars* *free-funs*))
  68
  69 ;;; We use the same CONSTANT structure to represent all equal anonymous
  70 ;;; constants. This hashtable translates from constants to the LEAFs that
  71 ;;; represent them.
  72 (defvar *constants*)
  73 (declaim (type hash-table *constants*))
  74
  75 ;;; *ALLOW-INSTRUMENTING* controls whether we should allow the
  76 ;;; insertion of instrumenting code (like a (CATCH ...)) around code
  77 ;;; to allow the debugger RETURN and STEP commands to function (we
  78 ;;; disallow it for internal stuff).
  79 (defvar *allow-instrumenting*)
  80
  81 ;;; miscellaneous forward declarations
  82 (defvar *code-segment*)
  83 #!+sb-dyncount (defvar *collect-dynamic-statistics*)
  84 (defvar *component-being-compiled*)
  85 (defvar *compiler-error-context*)
  86 (defvar *compiler-error-count*)
  87 (defvar *compiler-warning-count*)
  88 (defvar *compiler-style-warning-count*)
  89 (defvar *compiler-note-count*)
  90 (defvar *compiler-trace-output*)
  91 (defvar *constraint-universe*)
  92 (defvar *count-vop-usages*)
  93 (defvar *current-path*)
  94 (defvar *current-component*)
  95 (defvar *delayed-ir1-transforms*)
  96 (defvar *handled-conditions*)
  97 (defvar *disabled-package-locks*)
  98 (defvar *policy*)
  99 (defvar *dynamic-counts-tn*)
 100 (defvar *elsewhere*)
 101 (defvar *event-info*)
 102 (defvar *event-note-threshold*)
 103 (defvar *failure-p*)
 104 (defvar *fixup-notes*)
 105 (defvar *in-pack*)
 106 (defvar *info-environment*)
 107 #!+inline-constants
 108 (progn
 109   (defvar *constant-segment*)
 110   (defvar *constant-table*)
 111   (defvar *constant-vector*))
 112 (defvar *lexenv*)
 113 (defvar *source-info*)
 114 (defvar *source-plist*)
 115 (defvar *source-namestring*)
 116 (defvar *trace-table*)
 117 (defvar *undefined-warnings*)
 118 (defvar *warnings-p*)
 119 (defvar *lambda-conversions*)
 120
 121 (defvar *stack-allocate-dynamic-extent* t
 122   "If true (the default), the compiler respects DYNAMIC-EXTENT declarations
 123 and stack allocates otherwise inaccessible parts of the object whenever
 124 possible. Potentially long (over one page in size) vectors are, however, not
 125 stack allocated except in zero SAFETY code, as such a vector could overflow
 126 the stack without triggering overflow protection.")
 127
 128 (!begin-collecting-cold-init-forms)
 129 ;;; This lock is seized in the compiler, and related areas -- like the
 130 ;;; classoid/layout/class system.
 131 (defglobal **world-lock** nil)
 132 (!cold-init-forms
 133  (setf **world-lock** (sb!thread:make-mutex :name "World Lock")))
 134 (!defun-from-collected-cold-init-forms !world-lock-cold-init)
 135
 136 (defmacro with-world-lock (() &body body)
 137   `(sb!thread:with-recursive-lock (**world-lock**)
 138      ,@body))
 139
 140 (declaim (type fixnum *compiler-sset-counter*))
 141 (defvar *compiler-sset-counter* 0)
 142
 143 ;;; unique ID for the next object created (to let us track object
 144 ;;; identity even across GC, useful for understanding weird compiler
 145 ;;; bugs where something is supposed to be unique but is instead
 146 ;;; exists as duplicate objects)
 147 #!+sb-show
 148 (progn
 149   (defvar *object-id-counter* 0)
 150   (defun new-object-id ()
 151     (prog1
 152         *object-id-counter*
 153       (incf *object-id-counter*))))
 154 \f
 155 ;;;; miscellaneous utilities
 156
 157 ;;; Delete any undefined warnings for NAME and KIND. This is for the
 158 ;;; benefit of the compiler, but it's sometimes called from stuff like
 159 ;;; type-defining code which isn't logically part of the compiler.
 160 (declaim (ftype (function ((or symbol cons) keyword) (values))
 161                 note-name-defined))
 162 (defun note-name-defined (name kind)
 163   ;; We do this BOUNDP check because this function can be called when
 164   ;; not in a compilation unit (as when loading top level forms).
 165   (when (boundp '*undefined-warnings*)
 166     (setq *undefined-warnings*
 167           (delete-if (lambda (x)
 168                        (and (equal (undefined-warning-name x) name)
 169                             (eq (undefined-warning-kind x) kind)))
 170                      *undefined-warnings*)))
 171   (values))
 172
 173 ;;; to be called when a variable is lexically bound
 174 (declaim (ftype (function (symbol) (values)) note-lexical-binding))
 175 (defun note-lexical-binding (symbol)
 176     ;; This check is intended to protect us from getting silently
 177     ;; burned when we define
 178     ;;   foo.lisp:
 179     ;;     (DEFVAR *FOO* -3)
 180     ;;     (DEFUN FOO (X) (+ X *FOO*))
 181     ;;   bar.lisp:
 182     ;;     (DEFUN BAR (X)
 183     ;;       (LET ((*FOO* X))
 184     ;;         (FOO 14)))
 185     ;; and then we happen to compile bar.lisp before foo.lisp.
 186   (when (looks-like-name-of-special-var-p symbol)
 187     ;; FIXME: should be COMPILER-STYLE-WARNING?
 188     (style-warn 'sb!kernel:asterisks-around-lexical-variable-name
 189                 :format-control
 190                 "using the lexical binding of the symbol ~
 191                  ~/sb-impl::print-symbol-with-prefix/, not the~@
 192                  dynamic binding"
 193                 :format-arguments (list symbol)))
 194   (values))
 195
 196 (def!struct (debug-name-marker (:make-load-form-fun dump-debug-name-marker)
 197                                (:print-function print-debug-name-marker)))
 198
 199 (defvar *debug-name-level* 4)
 200 (defvar *debug-name-length* 12)
 201 (defvar *debug-name-punt*)
 202 (defvar *debug-name-sharp*)
 203 (defvar *debug-name-ellipsis*)
 204
 205 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
 206   (defun dump-debug-name-marker (marker &optional env)
 207     (declare (ignore env))
 208     (cond ((eq marker *debug-name-sharp*)
 209            `(if (boundp '*debug-name-sharp*)
 210                 *debug-name-sharp*
 211                 (make-debug-name-marker)))
 212           ((eq marker *debug-name-ellipsis*)
 213            `(if (boundp '*debug-name-ellipsis*)
 214                 *debug-name-ellipsis*
 215                 (make-debug-name-marker)))
 216           (t
 217            (warn "Dumping unknown debug-name marker.")
 218            '(make-debug-name-marker)))))
 219
 220 (defun print-debug-name-marker (marker stream level)
 221   (declare (ignore level))
 222   (cond ((eq marker *debug-name-sharp*)
 223          (write-char #\# stream))
 224         ((eq marker *debug-name-ellipsis*)
 225          (write-string "..." stream))
 226         (t
 227          (write-string "???" stream))))
 228
 229 (setf *debug-name-sharp* (make-debug-name-marker)
 230       *debug-name-ellipsis* (make-debug-name-marker))
 231
 232 (defun debug-name (type thing)
 233   (let ((*debug-name-punt* nil))
 234     (labels ((walk (x)
 235                (typecase x
 236                  (cons
 237                   (if (plusp *debug-name-level*)
 238                       (let ((*debug-name-level* (1- *debug-name-level*)))
 239                         (do ((tail (cdr x) (cdr tail))
 240                              (name (cons (walk (car x)) nil)
 241                                    (cons (walk (car tail)) name))
 242                              (n (1- *debug-name-length*) (1- n)))
 243                             ((or (not (consp tail))
 244                                  (not (plusp n))
 245                                  *debug-name-punt*)
 246                              (cond (*debug-name-punt*
 247                                     (setf *debug-name-punt* nil)
 248                                     (nreverse name))
 249                                    ((atom tail)
 250                                     (nconc (nreverse name) (walk tail)))
 251                                    (t
 252                                     (setf *debug-name-punt* t)
 253                                     (nconc (nreverse name) (list *debug-name-ellipsis*)))))))
 254                       *debug-name-sharp*))
 255                  ((or symbol number string)
 256                   x)
 257                  (t
 258                   (type-of x)))))
 259       (let ((name (list type (walk thing))))
 260         (when (legal-fun-name-p name)
 261           (bug "~S is a legal function name, and cannot be used as a ~
 262                 debug name." name))
 263         name))))