[prev in list] [next in list] [prev in thread] [next in thread]
List: sbcl-devel
Subject: Re: [Sbcl-devel] [Sbcl-commits] master: Remove all explicit #-sb-fluid declamations.
From: Stas Boukarev <stassats () gmail ! com>
Date: 2020-08-18 17:42:02
Message-ID: CAF63=10Pn7xCgpwx_RA3S=NMWSxphPfw2bFW2OCBDPTXF-oFkQ () mail ! gmail ! com
[Download RAW message or body]
> for people who use #+sb-fluid.
I don't think anybody actually uses it.
On Tue, Aug 18, 2020 at 7:17 AM apache--- via Sbcl-commits
<sbcl-commits@lists.sourceforge.net> wrote:
>
> The branch "master" has been updated in SBCL:
> via f3413d044473b176b49dc7414a590b443d235735 (commit)
> from 57f2b9a89e31de4f5246d27565976d5906b112ac (commit)
>
> - Log -----------------------------------------------------------------
> commit f3413d044473b176b49dc7414a590b443d235735
> Author: Charles Zhang <charleszhang99@yahoo.com>
> Date: Fri Jul 31 17:10:50 2020 -0700
>
> Remove all explicit #-sb-fluid declamations.
>
> Intercept DECLAIM to accomplish the same thing instead on the host,
> and make inline declarations effectless on the target. (I'm assuming
> that target performance with inline declaration for user code is not a
> priority for people who use #+sb-fluid.)
> ---
> src/code/array.lisp | 1 -
> src/code/bignum.lisp | 8 ++++----
> src/code/bit-bash.lisp | 4 ++--
> src/code/cross-early.lisp | 13 +++++++++++++
> src/code/debug-int.lisp | 4 ++--
> src/code/defstruct.lisp | 2 +-
> src/code/dyncount.lisp | 2 +-
> src/code/early-classoid.lisp | 2 +-
> src/code/early-raw-slots.lisp | 2 +-
> src/code/float-inf-nan.lisp | 1 -
> src/code/float.lisp | 9 ++++-----
> src/code/gc.lisp | 2 --
> src/code/late-type.lisp | 2 +-
> src/code/load.lisp | 2 +-
> src/code/numbers.lisp | 8 ++++----
> src/code/pprint.lisp | 2 +-
> src/code/pred.lisp | 2 +-
> src/code/reader.lisp | 10 ++++------
> src/code/restart.lisp | 2 +-
> src/code/setf-funs.lisp | 2 +-
> src/code/stream.lisp | 24 ++++++++++++------------
> src/code/target-alieneval.lisp | 6 +++---
> src/code/target-char.lisp | 1 -
> src/code/target-hash-table.lisp | 4 ++--
> src/code/target-pathname.lisp | 2 +-
> src/code/target-random.lisp | 8 ++++----
> src/code/target-signal.lisp | 4 ++--
> src/code/target-stream.lisp | 2 +-
> src/code/type-class.lisp | 6 +++---
> src/code/uncross.lisp | 2 +-
> src/code/weak.lisp | 2 +-
> src/code/win32.lisp | 1 -
> src/code/xset.lisp | 2 +-
> src/cold/set-up-cold-packages.lisp | 8 ++++++++
> src/compiler/bit-util.lisp | 1 -
> src/compiler/constraint.lisp | 2 +-
> src/compiler/debug-dump.lisp | 2 +-
> src/compiler/disassem.lisp | 3 +--
> src/compiler/early-constantp.lisp | 4 ++--
> src/compiler/early-globaldb.lisp | 2 +-
> src/compiler/early-lexenv.lisp | 2 +-
> src/compiler/float-tran.lisp | 2 +-
> src/compiler/ir1tran.lisp | 4 ++--
> src/compiler/ir1util.lisp | 4 ++--
> src/compiler/ltn.lisp | 2 +-
> src/compiler/macros.lisp | 2 +-
> src/compiler/node.lisp | 11 +++++------
> src/compiler/pack.lisp | 2 +-
> src/compiler/proclaim.lisp | 3 ++-
> src/compiler/represent.lisp | 2 +-
> src/compiler/target-disassem.lisp | 4 ++--
> src/compiler/vmdef.lisp | 2 +-
> src/pcl/boot.lisp | 8 ++++----
> src/pcl/defs.lisp | 2 +-
> src/pcl/dfun.lisp | 2 +-
> 55 files changed, 114 insertions(+), 104 deletions(-)
>
> diff --git a/src/code/array.lisp b/src/code/array.lisp
> index bdc848ed4..0725706c4 100644
> --- a/src/code/array.lisp
> +++ b/src/code/array.lisp
> @@ -11,7 +11,6 @@
>
> (in-package "SB-VM")
>
> -#-sb-fluid
> (declaim (inline adjustable-array-p
> array-displacement))
>
> diff --git a/src/code/bignum.lisp b/src/code/bignum.lisp
> index e11714695..a0b67cf29 100644
> --- a/src/code/bignum.lisp
> +++ b/src/code/bignum.lisp
> @@ -138,7 +138,7 @@
> (declare (type bignum-element-type digit))
> (not (logbitp (1- digit-size) digit)))
>
> -#-sb-fluid (declaim (inline %bignum-0-or-plusp))
> +(declaim (inline %bignum-0-or-plusp))
> (defun %bignum-0-or-plusp (bignum len)
> (declare (type bignum bignum)
> (type bignum-length len))
> @@ -248,7 +248,7 @@
> ;;; is suitable for infinite sign extension to complete additions,
> ;;; subtractions, negations, etc. This cannot return a -1 represented as
> ;;; a negative fixnum since it would then have to low zeros.
> -#-sb-fluid (declaim (inline %sign-digit))
> +(declaim (inline %sign-digit))
> (defun %sign-digit (bignum len)
> (declare (type bignum bignum)
> (type bignum-length len))
> @@ -646,7 +646,7 @@
>
> ;;; Allocate a single word bignum that holds fixnum. This is useful when
> ;;; we are trying to mix fixnum and bignum operands.
> -#-sb-fluid (declaim (inline make-small-bignum))
> +(declaim (inline make-small-bignum))
> (defun make-small-bignum (fixnum)
> (let ((res (%allocate-bignum 1)))
> (setf (%bignum-ref res 0) (%fixnum-to-digit fixnum))
> @@ -1912,7 +1912,7 @@
> ;;; incoming data, such as in-place shifting. This is basically the same as
> ;;; the first form in %NORMALIZE-BIGNUM, but we return the length of the buffer
> ;;; instead of shrinking the bignum.
> -#-sb-fluid (declaim (maybe-inline %normalize-bignum-buffer))
> +(declaim (maybe-inline %normalize-bignum-buffer))
> (defun %normalize-bignum-buffer (result len)
> (declare (type bignum result)
> (type bignum-length len))
> diff --git a/src/code/bit-bash.lisp b/src/code/bit-bash.lisp
> index 560d7fe8e..965fb6682 100644
> --- a/src/code/bit-bash.lisp
> +++ b/src/code/bit-bash.lisp
> @@ -76,7 +76,7 @@
> (:little-endian
> (ash (ldb (byte (- n-word-bits count) 0) number) count)))))))
>
> -#-sb-fluid (declaim (inline start-mask end-mask))
> +(declaim (inline start-mask end-mask))
>
> ;;; Produce a mask that contains 1's for the COUNT "start" bits and
> ;;; 0's for the remaining "end" bits. Only the lower 5 bits of COUNT
> @@ -94,7 +94,7 @@
> (declare (fixnum count))
> (shift-towards-end most-positive-word (- count)))
>
> -#-sb-fluid (declaim (inline word-sap-ref %set-word-sap-ref))
> +(declaim (inline word-sap-ref %set-word-sap-ref))
> (defun word-sap-ref (sap offset)
> (declare (type system-area-pointer sap)
> (type index offset)
> diff --git a/src/code/cross-early.lisp b/src/code/cross-early.lisp
> index ce95ad14c..2b083e5ba 100644
> --- a/src/code/cross-early.lisp
> +++ b/src/code/cross-early.lisp
> @@ -11,6 +11,19 @@
>
> (in-package "SB-IMPL")
>
> +(defmacro sb-xc:declaim (&rest declaration-specifiers)
> + #+(or sb-devel sb-fluid)
> + (setq declaration-specifiers
> + (remove-if (lambda (declaration-specifier)
> + (member (first declaration-specifier)
> + '(#+sb-fluid inline
> + #+sb-fluid maybe-inline
> + #+sb-fluid sb-ext:freeze-type
> + #+sb-devel start-block
> + #+sb-devel end-block)))
> + declaration-specifiers))
> + `(cl:declaim ,@declaration-specifiers))
> +
> ;;; The STRUCTURE!OBJECT abstract class is the base of the hierarchy
> ;;; of objects that need to be identifiable as SBCL system objects
> ;;; in the host Lisp. This type does not exist in the target.
> diff --git a/src/code/debug-int.lisp b/src/code/debug-int.lisp
> index 490a8caf7..694860f6a 100644
> --- a/src/code/debug-int.lisp
> +++ b/src/code/debug-int.lisp
> @@ -516,7 +516,7 @@
> ;;; address, whereas the one in C is an index into code->constants.
> (defconstant real-lra-slot sb-vm:code-constants-offset)
>
> -#-sb-fluid (declaim (inline control-stack-pointer-valid-p))
> +(declaim (inline control-stack-pointer-valid-p))
> (defun control-stack-pointer-valid-p (x &optional (aligned t))
> (declare (type system-area-pointer x))
> (let* (#-stack-grows-downward-not-upward
> @@ -643,7 +643,7 @@
> ;;; address.
> ;;;
> ;;; XXX Could be a little smarter.
> -#-sb-fluid (declaim (inline ra-pointer-valid-p))
> +(declaim (inline ra-pointer-valid-p))
> (defun ra-pointer-valid-p (ra)
> (declare (type system-area-pointer ra))
> (and
> diff --git a/src/code/defstruct.lisp b/src/code/defstruct.lisp
> index bfb250496..23b46b4df 100644
> --- a/src/code/defstruct.lisp
> +++ b/src/code/defstruct.lisp
> @@ -140,7 +140,7 @@
> ;; and we don't have structures whose slot indices run into the thousands.
> (bits 0 :type fixnum :read-only t)
> (default nil :read-only t)) ; default value expression
> -#-sb-fluid (declaim (freeze-type defstruct-slot-description))
> +(declaim (freeze-type defstruct-slot-description))
>
> (eval-when (:compile-toplevel)
> ;; Ensure that rsd-index is representable in 3 bits. (Can easily be changed)
> diff --git a/src/code/dyncount.lisp b/src/code/dyncount.lisp
> index 8a8d5c063..6d986236a 100644
> --- a/src/code/dyncount.lisp
> +++ b/src/code/dyncount.lisp
> @@ -109,7 +109,7 @@ comments from CMU CL:
> (setf (vop-stats-cost res) cost)
> res))
>
> -#-sb-fluid (declaim (freeze-type dyncount-info vop-stats))
> +(declaim (freeze-type dyncount-info vop-stats))
>
> ;;; Add the Info into the cumulative result on the VOP name plist. We use
> ;;; plists so that we will touch minimal system code outside of this file
> diff --git a/src/code/early-classoid.lisp b/src/code/early-classoid.lisp
> index dd8583eaf..e669290b6 100644
> --- a/src/code/early-classoid.lisp
> +++ b/src/code/early-classoid.lisp
> @@ -82,7 +82,7 @@
> ;; PURIFY).
> ;; This is only meaningful if DD-CLASS-P = T.
> (pure nil :type (member t nil)))
> -#-sb-fluid (declaim (freeze-type defstruct-description))
> +(declaim (freeze-type defstruct-description))
> (!set-load-form-method defstruct-description (:host :xc :target))
>
> ;;;; basic LAYOUT stuff
> diff --git a/src/code/early-raw-slots.lisp b/src/code/early-raw-slots.lisp
> index 1295e1ba2..25907c229 100644
> --- a/src/code/early-raw-slots.lisp
> +++ b/src/code/early-raw-slots.lisp
> @@ -74,7 +74,7 @@
> (defun raw-slot-data-accessor-name (rsd)
> (%simple-fun-name (raw-slot-data-accessor-fun rsd))))
>
> -#-sb-fluid (declaim (freeze-type raw-slot-data))
> +(declaim (freeze-type raw-slot-data))
>
> ;; Simulate DEFINE-LOAD-TIME-GLOBAL - always bound in the image
> ;; but not eval'd in the compiler.
> diff --git a/src/code/float-inf-nan.lisp b/src/code/float-inf-nan.lisp
> index 1fca7137c..169b2085b 100644
> --- a/src/code/float-inf-nan.lisp
> +++ b/src/code/float-inf-nan.lisp
> @@ -15,7 +15,6 @@
>
> (in-package "SB-KERNEL")
>
> -#-sb-fluid
> (declaim (maybe-inline float-denormalized-p float-infinity-p float-nan-p
> float-trapping-nan-p))
>
> diff --git a/src/code/float.lisp b/src/code/float.lisp
> index 454ffd5fc..e7f6d45e0 100644
> --- a/src/code/float.lisp
> +++ b/src/code/float.lisp
> @@ -20,7 +20,7 @@
> ;;; If denormalized, use a subfunction from INTEGER-DECODE-FLOAT to find the
> ;;; actual exponent (and hence how denormalized it is), otherwise we just
> ;;; return the number of digits or 0.
> -#-sb-fluid (declaim (maybe-inline float-precision))
> +(declaim (maybe-inline float-precision))
> (defun float-precision (f)
> "Return a non-negative number of significant digits in its float argument.
> Will be less than FLOAT-DIGITS if denormalized or zero."
> @@ -85,7 +85,7 @@
> #+long-float
> (long-float sb-vm:long-float-digits)))
>
> -#-sb-fluid (declaim (inline float-digits float-radix))
> +(declaim (inline float-digits float-radix))
>
> (defun float-digits (f)
> (declare (explicit-check))
> @@ -105,7 +105,6 @@
> (defconstant-eqx float-decoding-error "Can't decode NaN or infinity: ~S."
> #'string=)
>
> -#-sb-fluid
> (declaim (maybe-inline integer-decode-single-float
> integer-decode-double-float))
>
> @@ -291,7 +290,7 @@
> ((long-float)
> (integer-decode-long-float x))))
>
> -#-sb-fluid (declaim (maybe-inline decode-single-float decode-double-float))
> +(declaim (maybe-inline decode-single-float decode-double-float))
>
> ;;; Handle the denormalized case of DECODE-SINGLE-FLOAT. We call
> ;;; INTEGER-DECODE-SINGLE-DENORM and then make the result into a float.
> @@ -413,7 +412,7 @@
>
> ;;;; SCALE-FLOAT
>
> -#-sb-fluid (declaim (maybe-inline scale-single-float scale-double-float))
> +(declaim (maybe-inline scale-single-float scale-double-float))
>
> ;;; Handle float scaling where the X is denormalized or the result is
> ;;; denormalized or underflows to 0.
> diff --git a/src/code/gc.lisp b/src/code/gc.lisp
> index b834367ee..e40f4f369 100644
> --- a/src/code/gc.lisp
> +++ b/src/code/gc.lisp
> @@ -15,7 +15,6 @@
>
> #+gencgc
> (define-alien-variable ("DYNAMIC_SPACE_START" sb-vm:dynamic-space-start) os-vm-size-t)
> -#-sb-fluid
> (declaim (inline current-dynamic-space-start))
> (defun current-dynamic-space-start ()
> #+gencgc sb-vm:dynamic-space-start
> @@ -27,7 +26,6 @@
> (defun dynamic-space-free-pointer ()
> (extern-alien "dynamic_space_free_pointer" system-area-pointer)))
>
> -#-sb-fluid
> (declaim (inline dynamic-usage))
> #+gencgc
> (defun dynamic-usage ()
> diff --git a/src/code/late-type.lisp b/src/code/late-type.lisp
> index dffd22e7c..15dfe8aa2 100644
> --- a/src/code/late-type.lisp
> +++ b/src/code/late-type.lisp
> @@ -603,7 +603,7 @@
>
> ;;; Return the type of the first value indicated by TYPE. This is used
> ;;; by people who don't want to have to deal with VALUES types.
> -#-sb-fluid (declaim (freeze-type values-type))
> +(declaim (freeze-type values-type))
> ; (inline single-value-type))
> (defun single-value-type (type)
> (declare (type ctype type))
> diff --git a/src/code/load.lisp b/src/code/load.lisp
> index 14230e478..5908e53d2 100644
> --- a/src/code/load.lisp
> +++ b/src/code/load.lisp
> @@ -43,7 +43,7 @@
>
> ;;;; utilities for reading from fasl files
>
> -#-sb-fluid (declaim (inline read-byte))
> +(declaim (inline read-byte))
>
> ;;; This expands into code to read an N-byte unsigned integer using
> ;;; FAST-READ-BYTE.
> diff --git a/src/code/numbers.lisp b/src/code/numbers.lisp
> index 24331f709..e15664f2c 100644
> --- a/src/code/numbers.lisp
> +++ b/src/code/numbers.lisp
> @@ -16,7 +16,7 @@
> ;;; If IMAGPART is 0, return REALPART, otherwise make a complex. This is
> ;;; used when we know that REALPART and IMAGPART are the same type, but
> ;;; rational canonicalization might still need to be done.
> -#-sb-fluid (declaim (inline canonical-complex))
> +(declaim (inline canonical-complex))
> (defun canonical-complex (realpart imagpart)
> (if (eql imagpart 0)
> realpart
> @@ -36,7 +36,7 @@
> ;;; Given a numerator and denominator with the GCD already divided
> ;;; out, make a canonical rational. We make the denominator positive,
> ;;; and check whether it is 1.
> -#-sb-fluid (declaim (inline build-ratio))
> +(declaim (inline build-ratio))
> (defun build-ratio (num den)
> (multiple-value-bind (num den)
> (if (minusp den)
> @@ -51,7 +51,7 @@
> (t (%make-ratio num den)))))
>
> ;;; Truncate X and Y, but bum the case where Y is 1.
> -#-sb-fluid (declaim (inline maybe-truncate))
> +(declaim (inline maybe-truncate))
> (defun maybe-truncate (x y)
> (if (eql y 1)
> x
> @@ -418,7 +418,7 @@
> ;;; ROUND and FROUND are not declared inline since they seem too
> ;;; obscure and too big to inline-expand by default. Also, this gives
> ;;; the compiler a chance to pick off the unary float case.
> -#-sb-fluid (declaim (inline fceiling ffloor ftruncate))
> +(declaim (inline fceiling ffloor ftruncate))
> (defun ftruncate (number &optional (divisor 1))
> "Same as TRUNCATE, but returns first value as a float."
> (declare (explicit-check))
> diff --git a/src/code/pprint.lisp b/src/code/pprint.lisp
> index 885062c97..18b09d9e5 100644
> --- a/src/code/pprint.lisp
> +++ b/src/code/pprint.lisp
> @@ -31,7 +31,7 @@
> (declaim (freeze-type newline)
> (end-block))
>
> -#-sb-fluid (declaim (inline index-posn posn-index posn-column))
> +(declaim (inline index-posn posn-index posn-column))
> (defun index-posn (index stream)
> (declare (type index index) (type pretty-stream stream)
> (values posn))
> diff --git a/src/code/pred.lisp b/src/code/pred.lisp
> index 9233ea4e0..fef56d912 100644
> --- a/src/code/pred.lisp
> +++ b/src/code/pred.lisp
> @@ -13,7 +13,7 @@
>
> ;;;; miscellaneous non-primitive predicates
>
> -#-sb-fluid (declaim (inline streamp))
> +(declaim (inline streamp))
> (defun streamp (stream)
> (typep stream 'stream))
>
> diff --git a/src/code/reader.lisp b/src/code/reader.lisp
> index 314af77e9..4afa029d3 100644
> --- a/src/code/reader.lisp
> +++ b/src/code/reader.lisp
> @@ -173,12 +173,10 @@
>
> ;;; predicates for testing character attributes
>
> -#-sb-fluid
> -(progn
> - (declaim (inline whitespace[1]p whitespace[2]p))
> - (declaim (inline constituentp terminating-macrop))
> - (declaim (inline single-escape-p multiple-escape-p))
> - (declaim (inline token-delimiterp)))
> +(declaim (inline whitespace[1]p whitespace[2]p))
> +(declaim (inline constituentp terminating-macrop))
> +(declaim (inline single-escape-p multiple-escape-p))
> +(declaim (inline token-delimiterp))
>
> ;;; the [1] and [2] here refer to ANSI glossary entries for
> ;;; "whitespace".
> diff --git a/src/code/restart.lisp b/src/code/restart.lisp
> index 1fed81ab0..c6298e910 100644
> --- a/src/code/restart.lisp
> +++ b/src/code/restart.lisp
> @@ -31,7 +31,7 @@
> ;; extent.
> (associated-conditions '() :type list))
>
> -#-sb-fluid (declaim (freeze-type restart))
> +(declaim (freeze-type restart))
>
> (defmacro with-condition-restarts
> (condition-form restarts-form &body body)
> diff --git a/src/code/setf-funs.lisp b/src/code/setf-funs.lisp
> index 35ece7f5a..206e7340b 100644
> --- a/src/code/setf-funs.lisp
> +++ b/src/code/setf-funs.lisp
> @@ -57,7 +57,7 @@
> (let ((type (type-specifier (global-ftype sym))))
> (aver (consp type))
> (list
> - #-sb-fluid `(declaim (inline (setf ,sym)))
> + `(declaim (inline (setf ,sym)))
> (compute-one-setter sym type))))
> (sort (res) #'string<)))))
>
> diff --git a/src/code/stream.lisp b/src/code/stream.lisp
> index a87276177..d8b0bd04c 100644
> --- a/src/code/stream.lisp
> +++ b/src/code/stream.lisp
> @@ -206,7 +206,7 @@
> (ef-char-size (get-external-format external-format)))
>
> ;;; Call the MISC method with the :FILE-POSITION operation.
> -#-sb-fluid (declaim (inline ansi-stream-file-position))
> +(declaim (inline ansi-stream-file-position))
> (defun ansi-stream-file-position (stream position)
> (declare (type stream stream))
> (declare (type (or index (alien sb-unix:unix-offset) (member nil :start :end))
> @@ -334,7 +334,7 @@
> (progn (done-with-fast-read-char)
> (eof-or-lose stream eof-error-p (values eof-value t))))))))
>
> -#-sb-fluid (declaim (inline ansi-stream-read-line))
> +(declaim (inline ansi-stream-read-line))
> (defun ansi-stream-read-line (stream eof-error-p eof-value recursive-p)
> (declare (ignore recursive-p))
> (if (ansi-stream-cin-buffer stream)
> @@ -385,9 +385,9 @@
>
> ;;; We proclaim them INLINE here, then proclaim them NOTINLINE later on,
> ;;; so, except in this file, they are not inline by default, but they can be.
> -#-sb-fluid (declaim (inline read-char unread-char read-byte listen))
> +(declaim (inline read-char unread-char read-byte listen))
>
> -#-sb-fluid (declaim (inline ansi-stream-read-char))
> +(declaim (inline ansi-stream-read-char))
> (defun ansi-stream-read-char (stream eof-error-p eof-value recursive-p)
> (declare (ignore recursive-p))
> (prepare-for-fast-read-char stream
> @@ -409,7 +409,7 @@
> (eof-or-lose stream eof-error-p eof-value)
> (the character char))))))
>
> -#-sb-fluid (declaim (inline ansi-stream-unread-char))
> +(declaim (inline ansi-stream-unread-char))
> (defun ansi-stream-unread-char (character stream)
> (let ((index (1- (ansi-stream-in-index stream)))
> (buffer (ansi-stream-cin-buffer stream)))
> @@ -435,7 +435,7 @@
> (stream-unread-char stream character)))
> nil)
>
> -#-sb-fluid (declaim (inline ansi-stream-listen))
> +(declaim (inline ansi-stream-listen))
> (defun ansi-stream-listen (stream)
> (or (/= (the fixnum (ansi-stream-in-index stream))
> +ansi-stream-in-buffer-length+)
> @@ -453,7 +453,7 @@
> ;; Fall through to Gray streams FUNDAMENTAL-STREAM case.
> (stream-listen stream))))
>
> -#-sb-fluid (declaim (inline ansi-stream-read-char-no-hang))
> +(declaim (inline ansi-stream-read-char-no-hang))
> (defun ansi-stream-read-char-no-hang (stream eof-error-p eof-value recursive-p)
> (if (funcall (ansi-stream-misc stream) stream :listen)
> ;; On T or :EOF get READ-CHAR to do the work.
> @@ -475,7 +475,7 @@
> (eof-or-lose stream eof-error-p eof-value)
> (the (or character null) char))))))
>
> -#-sb-fluid (declaim (inline ansi-stream-clear-input))
> +(declaim (inline ansi-stream-clear-input))
> (defun ansi-stream-clear-input (stream)
> (setf (ansi-stream-in-index stream) +ansi-stream-in-buffer-length+)
> (funcall (ansi-stream-misc stream) stream :clear-input))
> @@ -489,7 +489,7 @@
> (stream-clear-input stream)))
> nil)
>
> -#-sb-fluid (declaim (inline ansi-stream-read-byte))
> +(declaim (inline ansi-stream-read-byte))
> (defun ansi-stream-read-byte (stream eof-error-p eof-value recursive-p)
> ;; Why the "recursive-p" parameter? a-s-r-b is funcall'ed from
> ;; a-s-read-sequence and needs a lambda list that's congruent with
> @@ -518,7 +518,7 @@
> ;;; some cases, but it wasn't being used in SBCL, so it was dropped.
> ;;; If we ever need it, it could be added later as a new variant N-BIN
> ;;; method (perhaps N-BIN-ASAP?) or something.
> -#-sb-fluid (declaim (inline read-n-bytes))
> +(declaim (inline read-n-bytes))
> (defun read-n-bytes (stream buffer start numbytes &optional (eof-error-p t))
> (if (ansi-stream-p stream)
> (ansi-stream-read-n-bytes stream buffer start numbytes eof-error-p)
> @@ -681,7 +681,7 @@
> (with-out-stream stream (ansi-stream-out #\newline) (stream-terpri))
> nil)
>
> -#-sb-fluid (declaim (inline ansi-stream-fresh-line))
> +(declaim (inline ansi-stream-fresh-line))
> (defun ansi-stream-fresh-line (stream)
> (unless (eql (charpos stream) 0)
> (funcall (ansi-stream-out stream) stream #\newline)
> @@ -695,7 +695,7 @@
> ;; must be Gray streams FUNDAMENTAL-STREAM
> (stream-fresh-line stream))))
>
> -#-sb-fluid (declaim (inline ansi-stream-write-string))
> +(declaim (inline ansi-stream-write-string))
> (defun ansi-stream-write-string (string stream start end)
> (with-array-data ((data string) (offset-start start)
> (offset-end end)
> diff --git a/src/code/target-alieneval.lisp b/src/code/target-alieneval.lisp
> index 172d8fcbd..2dd50ecf9 100644
> --- a/src/code/target-alieneval.lisp
> +++ b/src/code/target-alieneval.lisp
> @@ -198,7 +198,7 @@ This is SETFable."
> :sap (sap-int (alien-value-sap value))
> :type (unparse-alien-type (alien-value-type value)))))
>
> -#-sb-fluid (declaim (inline null-alien))
> +(declaim (inline null-alien))
> (defun null-alien (x)
> "Return true if X (which must be an ALIEN pointer) is null, false otherwise."
> (zerop (sap-int (alien-sap x))))
> @@ -296,7 +296,7 @@ Examples:
>
> ;;; Allocate a block of memory at least BYTES bytes long and return a
> ;;; system area pointer to it.
> -#-sb-fluid (declaim (inline %make-alien))
> +(declaim (inline %make-alien))
> (defun %make-alien (bytes)
> (declare (type index bytes)
> (optimize (sb-c:alien-funcall-saves-fp-and-pc 0)))
> @@ -320,7 +320,7 @@ Examples:
> (let ((*saved-fp* (sb-c::current-fp-fixnum)))
> (funcall fn)))
>
> -#-sb-fluid (declaim (inline free-alien))
> +(declaim (inline free-alien))
> (defun free-alien (alien)
> "Dispose of the storage pointed to by ALIEN. The ALIEN must have been
> allocated by MAKE-ALIEN, MAKE-ALIEN-STRING or malloc(3)."
> diff --git a/src/code/target-char.lisp b/src/code/target-char.lisp
> index 7908c972a..4a2197995 100644
> --- a/src/code/target-char.lisp
> +++ b/src/code/target-char.lisp
> @@ -12,7 +12,6 @@
> (in-package "SB-IMPL")
>
> ;;; We compile some trivial character operations via inline expansion.
> -#-sb-fluid
> (declaim (inline standard-char-p graphic-char-p alpha-char-p
> alphanumericp))
> (declaim (maybe-inline upper-case-p lower-case-p both-case-p
> diff --git a/src/code/target-hash-table.lisp b/src/code/target-hash-table.lisp
> index 8fb8240a9..fe148cf07 100644
> --- a/src/code/target-hash-table.lisp
> +++ b/src/code/target-hash-table.lisp
> @@ -52,7 +52,7 @@
> (and (hash-table-weak-p ht)
> (decode-hash-table-weakness (ht-flags-weakness (hash-table-flags ht)))))
>
> -#-sb-fluid (declaim (inline eq-hash))
> +(declaim (inline eq-hash))
> (defun eq-hash (key)
> (declare (values fixnum (member t nil)))
> ;; I think it would be ok to pick off SYMBOL here and use its hash slot
> @@ -105,7 +105,7 @@
> ;; Consider picking off %INSTANCEP too before using EQ-HASH ?
> (eq-hash key)))))
>
> -#-sb-fluid (declaim (inline equal-hash))
> +(declaim (inline equal-hash))
> (defun equal-hash (key)
> (declare (values fixnum (member t nil)))
> (typecase key
> diff --git a/src/code/target-pathname.lisp b/src/code/target-pathname.lisp
> index 6938cb0d7..a04f254f2 100644
> --- a/src/code/target-pathname.lisp
> +++ b/src/code/target-pathname.lisp
> @@ -59,7 +59,7 @@
> ;;; Physical pathnames include all these slots and a device slot.
>
> ;;; We can't freeze HOST because later on we define either UNIX-HOST or WIN32-HOST.
> -#-sb-fluid (declaim (freeze-type logical-host))
> +(declaim (freeze-type logical-host))
>
> ;;; Utility functions
>
> diff --git a/src/code/target-random.lisp b/src/code/target-random.lisp
> index cb33a2b5f..406e70d87 100644
> --- a/src/code/target-random.lisp
> +++ b/src/code/target-random.lisp
> @@ -279,7 +279,7 @@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
> (declaim (start-block random %random-single-float %random-double-float
> random-chunk big-random-chunk))
>
> -#-sb-fluid (declaim (inline random-chunk))
> +(declaim (inline random-chunk))
> #-x86
> (defun random-chunk (state)
> (declare (type random-state state))
> @@ -308,7 +308,7 @@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
> (declare (type random-state state))
> (sb-vm::random-mt19937 (random-state-state state)))
>
> -#-sb-fluid (declaim (inline big-random-chunk))
> +(declaim (inline big-random-chunk))
> (defun big-random-chunk (state)
> (declare (type random-state state))
> (logior (ash (random-chunk state) 32)
> @@ -318,7 +318,7 @@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
> ;;; float between 0.0 and 1.0 by clobbering the significand of 1.0
> ;;; with random bits, then subtracting 1.0. This hides the fact that
> ;;; we have a hidden bit.
> -#-sb-fluid (declaim (inline %random-single-float %random-double-float))
> +(declaim (inline %random-single-float %random-double-float))
> (declaim (ftype (function ((single-float ($0f0)) random-state)
> (single-float $0f0))
> %random-single-float))
> @@ -390,7 +390,7 @@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
> ;;; as the speed gains due to needing fewer loop iterations are by far
> ;;; outweighted by the cost of the two divisions required (one to find
> ;;; the multiplier and one to bring the result into the correct range).
> -#-sb-fluid (declaim (inline %random-fixnum))
> +(declaim (inline %random-fixnum))
> (defun %random-fixnum (arg state)
> (declare (type (integer 1 #.most-positive-fixnum) arg)
> (type random-state state))
> diff --git a/src/code/target-signal.lisp b/src/code/target-signal.lisp
> index 83e71756e..5ba07d10f 100644
> --- a/src/code/target-signal.lisp
> +++ b/src/code/target-signal.lisp
> @@ -15,14 +15,14 @@
>
> ;;; Send the signal SIGNAL to the process with process id PID. SIGNAL
> ;;; should be a valid signal number
> -#-sb-fluid (declaim (inline unix-kill))
> +(declaim (inline unix-kill))
> (define-alien-routine ("kill" unix-kill) int
> (pid int)
> (signal int))
>
> ;;; Send the signal SIGNAL to the all the process in process group
> ;;; PGRP. SIGNAL should be a valid signal number
> -#-sb-fluid (declaim (inline unix-killpg))
> +(declaim (inline unix-killpg))
> (define-alien-routine ("killpg" unix-killpg) int
> (pgrp int)
> (signal int))
> diff --git a/src/code/target-stream.lisp b/src/code/target-stream.lisp
> index ded4ced1d..c6def6bc7 100644
> --- a/src/code/target-stream.lisp
> +++ b/src/code/target-stream.lisp
> @@ -68,7 +68,7 @@
> ;;; unread-char, read-byte, listen here that was removed because these
> ;;; functions are redefined when simple-streams are loaded.
>
> -#-sb-fluid (declaim (inline ansi-stream-peek-char))
> +(declaim (inline ansi-stream-peek-char))
> (defun ansi-stream-peek-char (peek-type stream eof-error-p eof-value
> recursive-p)
> (cond ((typep stream 'echo-stream)
> diff --git a/src/code/type-class.lisp b/src/code/type-class.lisp
> index fad80a7b0..7227e9007 100644
> --- a/src/code/type-class.lisp
> +++ b/src/code/type-class.lisp
> @@ -209,7 +209,7 @@
> (coerce :type (or symbol null))
> |#
> )
> -#-sb-fluid (declaim (freeze-type type-class))
> +(declaim (freeze-type type-class))
>
> (defun type-class-or-lose (name)
> (or (find name *type-classes* :key #'type-class-name)
> @@ -552,13 +552,13 @@
> ;;; FIXME: This was a macro in CMU CL, and is now an INLINE function. Is
> ;;; it important for it to be INLINE, or could be become an ordinary
> ;;; function without significant loss? -- WHN 19990413
> -#-sb-fluid (declaim (inline type-cache-hash))
> +(declaim (inline type-cache-hash))
> (declaim (ftype (function (ctype ctype) (signed-byte #.sb-vm:n-fixnum-bits))
> type-cache-hash))
> (defun type-cache-hash (type1 type2)
> (logxor (ash (type-hash-value type1) -3) (type-hash-value type2)))
>
> -#-sb-fluid (declaim (inline type-list-cache-hash))
> +(declaim (inline type-list-cache-hash))
> (declaim (ftype (function (list) (signed-byte #.sb-vm:n-fixnum-bits))
> type-list-cache-hash))
> (defun type-list-cache-hash (types)
> diff --git a/src/code/uncross.lisp b/src/code/uncross.lisp
> index 1c067b3c0..2138235fb 100644
> --- a/src/code/uncross.lisp
> +++ b/src/code/uncross.lisp
> @@ -19,7 +19,7 @@
> ;;; In the target system's compiler, uncrossing is just identity.
> #-sb-xc-host
> (progn
> - #-sb-fluid (declaim (inline uncross))
> + (declaim (inline uncross))
> (defun uncross (x) x))
> ;;; In the cross-compiler, uncrossing is slightly less trivial.
>
> diff --git a/src/code/weak.lisp b/src/code/weak.lisp
> index a30f8d51e..be1370fb5 100644
> --- a/src/code/weak.lisp
> +++ b/src/code/weak.lisp
> @@ -15,7 +15,7 @@
> "Allocate and return a weak pointer which points to OBJECT."
> (make-weak-pointer object))
>
> -#-sb-fluid (declaim (inline weak-pointer-value))
> +(declaim (inline weak-pointer-value))
> (defun weak-pointer-value (weak-pointer)
> "If WEAK-POINTER is valid, return the value of WEAK-POINTER and T.
> If the referent of WEAK-POINTER has been garbage collected,
> diff --git a/src/code/win32.lisp b/src/code/win32.lisp
> index 085122044..1405b9c87 100644
> --- a/src/code/win32.lisp
> +++ b/src/code/win32.lisp
> @@ -429,7 +429,6 @@
> (defconstant +filetime-unit+ 10000000)
> (defconstant +common-lisp-epoch-filetime-seconds+ 9435484800)
>
> -#-sb-fluid
> (declaim (inline get-time-of-day))
> (defun get-time-of-day ()
> "Return the number of seconds and microseconds since the beginning of the
> diff --git a/src/code/xset.lisp b/src/code/xset.lisp
> index 99de7b492..80c851e45 100644
> --- a/src/code/xset.lisp
> +++ b/src/code/xset.lisp
> @@ -135,6 +135,6 @@
> xset1))
> t))
>
> -#-sb-fluid (declaim (inline xset-empty-p))
> +(declaim (inline xset-empty-p))
> (defun xset-empty-p (xset)
> (not (xset-data xset)))
> diff --git a/src/cold/set-up-cold-packages.lisp b/src/cold/set-up-cold-packages.lisp
> index 0c2e1d54d..1aeed0d2c 100644
> --- a/src/cold/set-up-cold-packages.lisp
> +++ b/src/cold/set-up-cold-packages.lisp
> @@ -291,6 +291,10 @@
> "UPGRADED-ARRAY-ELEMENT-TYPE"
> "UPGRADED-COMPLEX-PART-TYPE"
> "WITH-COMPILATION-UNIT"
> +
> + ;; For debugging purposes, we want to be able to intercept inline
> + ;; and block compilation declamations in the host.
> + "DECLAIM"
> ))
>
> ;;; A symbol in the "dual personality" list refers to the symbol in CL unless
> @@ -354,6 +358,10 @@
> "PROCLAIM"
> "SIMPLE-VECTOR"
> "TYPE-OF" "TYPEP"
> +
> + "DEFCLASS"
> + "DEFGENERIC"
> + "DEFMETHOD"
> ))
> (export (intern name package-name) package-name)))
>
> diff --git a/src/compiler/bit-util.lisp b/src/compiler/bit-util.lisp
> index 9a25b30fb..7424eb918 100644
> --- a/src/compiler/bit-util.lisp
> +++ b/src/compiler/bit-util.lisp
> @@ -12,7 +12,6 @@
>
> (in-package "SB-C")
>
> -#-sb-fluid
> (declaim (inline clear-bit-vector set-bit-vector bit-vector-replace
> bit-vector-copy))
>
> diff --git a/src/compiler/constraint.lisp b/src/compiler/constraint.lisp
> index 0e598a3c6..aaee8ae0f 100644
> --- a/src/compiler/constraint.lisp
> +++ b/src/compiler/constraint.lisp
> @@ -547,7 +547,7 @@
>
> ;;; If REF is to a LAMBDA-VAR with CONSTRAINTs (i.e. we can do flow
> ;;; analysis on it), then return the LAMBDA-VAR, otherwise NIL.
> -#-sb-fluid (declaim (inline ok-ref-lambda-var))
> +(declaim (inline ok-ref-lambda-var))
> (defun ok-ref-lambda-var (ref)
> (declare (type ref ref))
> (let ((leaf (ref-leaf ref)))
> diff --git a/src/compiler/debug-dump.lisp b/src/compiler/debug-dump.lisp
> index 86ca93392..5d60def44 100644
> --- a/src/compiler/debug-dump.lisp
> +++ b/src/compiler/debug-dump.lisp
> @@ -77,7 +77,7 @@
> (- posn (segment-header-skew segment))))))
> (values))
>
> -#-sb-fluid (declaim (inline ir2-block-physenv))
> +(declaim (inline ir2-block-physenv))
> (defun ir2-block-physenv (2block)
> (declare (type ir2-block 2block))
> (block-physenv (ir2-block-block 2block)))
> diff --git a/src/compiler/disassem.lisp b/src/compiler/disassem.lisp
> index 638621259..b7cd6f351 100644
> --- a/src/compiler/disassem.lisp
> +++ b/src/compiler/disassem.lisp
> @@ -67,7 +67,6 @@
> ;;;; KLUDGE: It's not clear that using bit-vectors would be any more efficient.
> ;;;; Perhaps the abstraction could go away. -- WHN 19991124
>
> -#-sb-fluid
> (declaim (inline dchunk-or dchunk-and dchunk-clear dchunk-not
> dchunk-make-mask dchunk-make-field
> dchunk-extract
> @@ -559,7 +558,7 @@
> `((lookup-label ,(maybe-listify numeric-forms)))
> numeric-forms)))))
>
> -#-sb-fluid (declaim (inline bytes-to-bits))
> +(declaim (inline bytes-to-bits))
>
> (defun bytes-to-bits (bytes)
> (declare (type disassem-length bytes))
> diff --git a/src/compiler/early-constantp.lisp b/src/compiler/early-constantp.lisp
> index 1444a4d53..aed9999f0 100644
> --- a/src/compiler/early-constantp.lisp
> +++ b/src/compiler/early-constantp.lisp
> @@ -15,7 +15,7 @@
> (defstruct (abstract-lexenv
> (:constructor nil) (:copier nil) (:predicate nil)))
>
> -#-sb-fluid (declaim (inline constantp))
> +(declaim (inline constantp))
> (defun constantp (form &optional (environment nil envp))
> "True of any FORM that has a constant value: self-evaluating objects,
> keywords, defined constants, quote forms. Additionally the
> @@ -23,7 +23,7 @@ constant-foldability of some function calls and special forms is recognized.
> If ENVIRONMENT is provided, the FORM is first macroexpanded in it."
> (%constantp form environment envp))
>
> -#-sb-fluid (declaim (inline constant-form-value))
> +(declaim (inline constant-form-value))
> (defun constant-form-value (form &optional (environment nil envp))
> "Returns the value of the constant FORM in ENVIRONMENT. Behaviour
> is undefined unless CONSTANTP has been first used to determine the
> diff --git a/src/compiler/early-globaldb.lisp b/src/compiler/early-globaldb.lisp
> index 13450a1f3..09e5c4b95 100644
> --- a/src/compiler/early-globaldb.lisp
> +++ b/src/compiler/early-globaldb.lisp
> @@ -349,6 +349,6 @@
> `(the attributes
> (logand ,@(mapcar (lambda (x) `(the attributes ,x)) attributes))))
> (declaim (ftype (function (attributes attributes) boolean) attributes=))
> -#-sb-fluid (declaim (inline attributes=))
> +(declaim (inline attributes=))
> (defun attributes= (attr1 attr2)
> (eql attr1 attr2))
> diff --git a/src/compiler/early-lexenv.lisp b/src/compiler/early-lexenv.lisp
> index 14cfdee61..13c030dd7 100644
> --- a/src/compiler/early-lexenv.lisp
> +++ b/src/compiler/early-lexenv.lisp
> @@ -69,7 +69,7 @@
>
> ;;; The LEXENV represents the lexical environment used for IR1 conversion.
> ;;; (This is also what shows up as an ENVIRONMENT value in macroexpansion.)
> -#-sb-fluid (declaim (inline internal-make-lexenv)) ; only called in one place
> +(declaim (inline internal-make-lexenv)) ; only called in one place
> (defstruct (lexenv
> (:include abstract-lexenv)
> (:print-function
> diff --git a/src/compiler/float-tran.lisp b/src/compiler/float-tran.lisp
> index 0d2ca5cd6..b625d719b 100644
> --- a/src/compiler/float-tran.lisp
> +++ b/src/compiler/float-tran.lisp
> @@ -225,7 +225,7 @@
> ;;; Given a number X, create a form suitable as a bound for an
> ;;; interval. Make the bound open if OPEN-P is T. NIL remains NIL.
> ;;; FIXME: as this is a constructor, shouldn't it be named MAKE-BOUND?
> -#-sb-fluid (declaim (inline set-bound))
> +(declaim (inline set-bound))
> (defun set-bound (x open-p)
> (if (and x open-p) (list x) x))
>
> diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp
> index ee13cefe3..be1ce16a2 100644
> --- a/src/compiler/ir1tran.lisp
> +++ b/src/compiler/ir1tran.lisp
> @@ -389,7 +389,7 @@
> ;;; determine what is evaluated next. If the ctran has no block, then
> ;;; we make it be in the block that the node is in. If the ctran heads
> ;;; its block, we end our block and link it to that block.
> -#-sb-fluid (declaim (inline use-ctran))
> +(declaim (inline use-ctran))
> (defun use-ctran (node ctran)
> (declare (type node node) (type ctran ctran))
> (if (eq (ctran-kind ctran) :unused)
> @@ -451,7 +451,7 @@
> (setf (lvar-uses lvar) (list node (lvar-uses lvar)))))
> (reoptimize-lvar lvar)))
>
> -#-sb-fluid(declaim (inline use-continuation))
> +(declaim (inline use-continuation))
> (defun use-continuation (node ctran lvar)
> (use-ctran node ctran)
> (use-lvar node lvar))
> diff --git a/src/compiler/ir1util.lisp b/src/compiler/ir1util.lisp
> index c5188c39b..98e001ca5 100644
> --- a/src/compiler/ir1util.lisp
> +++ b/src/compiler/ir1util.lisp
> @@ -622,7 +622,7 @@
> (defun node-physenv (node)
> (lambda-physenv (node-home-lambda node)))
>
> -#-sb-fluid (declaim (inline node-stack-allocate-p))
> +(declaim (inline node-stack-allocate-p))
> (defun node-stack-allocate-p (node)
> (awhen (node-lvar node)
> (lvar-dynamic-extent it)))
> @@ -1112,7 +1112,7 @@
> (defun cast-single-value-p (cast)
> (not (values-type-p (cast-asserted-type cast))))
>
> -#-sb-fluid (declaim (inline lvar-single-value-p))
> +(declaim (inline lvar-single-value-p))
> (defun lvar-single-value-p (lvar)
> (or (not lvar) (%lvar-single-value-p lvar)))
> (defun %lvar-single-value-p (lvar)
> diff --git a/src/compiler/ltn.lisp b/src/compiler/ltn.lisp
> index a0d9bafb9..1933c24cf 100644
> --- a/src/compiler/ltn.lisp
> +++ b/src/compiler/ltn.lisp
> @@ -95,7 +95,7 @@
> (link-blocks node-block next-block)))
>
> ;;; an annotated lvar's primitive-type
> -#-sb-fluid (declaim (inline lvar-ptype))
> +(declaim (inline lvar-ptype))
> (defun lvar-ptype (lvar)
> (declare (type lvar lvar))
> (ir2-lvar-primitive-type (lvar-info lvar)))
> diff --git a/src/compiler/macros.lisp b/src/compiler/macros.lisp
> index f85eea7e5..91dc283c9 100644
> --- a/src/compiler/macros.lisp
> +++ b/src/compiler/macros.lisp
> @@ -747,7 +747,7 @@
> ;;;; functions on directly-linked lists (linked through specialized
> ;;;; NEXT operations)
>
> -#-sb-fluid (declaim (inline find-in position-in))
> +(declaim (inline find-in position-in))
>
> ;;; Find ELEMENT in a null-terminated LIST linked by the accessor
> ;;; function NEXT. KEY and TEST are the same as for generic sequence functions.
> diff --git a/src/compiler/node.lisp b/src/compiler/node.lisp
> index d8a6b0319..a8ba50f6d 100644
> --- a/src/compiler/node.lisp
> +++ b/src/compiler/node.lisp
> @@ -148,16 +148,16 @@
> (when (boundp '*compilation*)
> (format stream "~D" (cont-num x)))))
>
> -#-sb-fluid (declaim (inline lvar-has-single-use-p))
> +(declaim (inline lvar-has-single-use-p))
> (defun lvar-has-single-use-p (lvar)
> (typep (lvar-uses lvar) '(not list)))
>
> ;;; Return the unique node, delivering a value to LVAR.
> -#-sb-fluid (declaim (inline lvar-use))
> +(declaim (inline lvar-use))
> (defun lvar-use (lvar)
> (the (not list) (lvar-uses lvar)))
>
> -#-sb-fluid (declaim (inline lvar-derived-type))
> +(declaim (inline lvar-derived-type))
> (defun lvar-derived-type (lvar)
> (declare (type lvar lvar))
> (or (lvar-%derived-type lvar)
> @@ -216,7 +216,7 @@
> ;; can null out this slot.
> (tail-p nil :type boolean))
>
> -#-sb-fluid (declaim (inline node-block))
> +(declaim (inline node-block))
> (defun node-block (node)
> (ctran-block (node-prev node)))
>
> @@ -239,7 +239,7 @@
> ;; the value is unused.
> (lvar nil :type (or lvar null)))
>
> -#-sb-fluid (declaim (inline node-dest))
> +(declaim (inline node-dest))
> (defun node-dest (node)
> (awhen (node-lvar node) (lvar-dest it)))
>
> @@ -1637,6 +1637,5 @@
>
> ;;;; Freeze some structure types to speed type testing.
>
> -#-sb-fluid
> (declaim (freeze-type node lexenv ctran lvar cblock component cleanup
> physenv tail-set nlx-info leaf))
> diff --git a/src/compiler/pack.lisp b/src/compiler/pack.lisp
> index 13c2aac0a..88bd83e28 100644
> --- a/src/compiler/pack.lisp
> +++ b/src/compiler/pack.lisp
> @@ -1200,7 +1200,7 @@
> ;;; the restriction, we pack a Load-TN and load the operand into it.
> ;;; If a load-tn has already been allocated, we can assume that the
> ;;; restriction is satisfied.
> -#-sb-fluid (declaim (inline check-operand-restrictions))
> +(declaim (inline check-operand-restrictions))
> (defun check-operand-restrictions (scs ops)
> (declare (list scs) (type (or tn-ref null) ops))
>
> diff --git a/src/compiler/proclaim.lisp b/src/compiler/proclaim.lisp
> index 1614a6fbf..db1d46470 100644
> --- a/src/compiler/proclaim.lisp
> +++ b/src/compiler/proclaim.lisp
> @@ -339,6 +339,7 @@
> (ftype #'proclaim-ftype))
> ctype type :declared)))
> (push raw-form *queued-proclaims*)))
> + #-sb-fluid
> (freeze-type
> (map-args #'process-freeze-type-declaration))
> ((start-block end-block)
> @@ -371,7 +372,7 @@
> ((disable-package-locks enable-package-locks)
> (setq *disabled-package-locks*
> (process-package-lock-decl form *disabled-package-locks*)))
> - ((inline notinline maybe-inline)
> + ((#-sb-fluid inline notinline #-sb-fluid maybe-inline)
> (map-args #'process-inline-declaration kind))
> (deprecated
> (destructuring-bind (state since &rest things) args
> diff --git a/src/compiler/represent.lisp b/src/compiler/represent.lisp
> index 1ba4efe11..1ea6f1f10 100644
> --- a/src/compiler/represent.lisp
> +++ b/src/compiler/represent.lisp
> @@ -737,7 +737,7 @@
> ;;; If TN is in a number stack SC, make all the right annotations.
> ;;; Note that this should be called after TN has been referenced,
> ;;; since it must iterate over the referencing environments.
> -#-sb-fluid (declaim (inline note-if-number-stack))
> +(declaim (inline note-if-number-stack))
> (defun note-if-number-stack (tn 2comp restricted)
> (declare (type tn tn) (type ir2-component 2comp))
> (when (if restricted
> diff --git a/src/compiler/target-disassem.lisp b/src/compiler/target-disassem.lisp
> index 7e930121b..eb2773a82 100644
> --- a/src/compiler/target-disassem.lisp
> +++ b/src/compiler/target-disassem.lisp
> @@ -106,7 +106,7 @@
>
> ;;;; choosing an instruction
>
> -#-sb-fluid (declaim (inline inst-matches-p choose-inst-specialization))
> +(declaim (inline inst-matches-p choose-inst-specialization))
>
> ;;; Return non-NIL if all constant-bits in INST match CHUNK.
> (defun inst-matches-p (inst chunk)
> @@ -288,7 +288,7 @@
> ;;; LRA layout (dual word aligned):
> ;;; header-word
>
> -#-sb-fluid (declaim (inline words-to-bytes))
> +(declaim (inline words-to-bytes))
>
> (eval-when (:compile-toplevel :load-toplevel :execute)
> ;;; Convert a word-offset NUM to a byte-offset.
> diff --git a/src/compiler/vmdef.lisp b/src/compiler/vmdef.lisp
> index 27979596a..ed00fd455 100644
> --- a/src/compiler/vmdef.lisp
> +++ b/src/compiler/vmdef.lisp
> @@ -196,7 +196,7 @@
>
> ;;; Return a function type specifier describing TEMPLATE's type computed
> ;;; from the operand type restrictions.
> -#-sb-fluid (declaim (inline template-conditional-p))
> +(declaim (inline template-conditional-p))
> (defun template-conditional-p (template)
> (declare (type template template))
> (let ((rtypes (template-result-types template)))
> diff --git a/src/pcl/boot.lisp b/src/pcl/boot.lisp
> index c68f74967..0360a72e4 100644
> --- a/src/pcl/boot.lisp
> +++ b/src/pcl/boot.lisp
> @@ -1335,7 +1335,7 @@ bootstrapping.
> (defstruct (constant-method-call (:copier nil) (:include method-call))
> value)
>
> -#-sb-fluid (declaim (sb-ext:freeze-type method-call))
> +(declaim (sb-ext:freeze-type method-call))
>
> (defmacro invoke-method-call1 (function args cm-args)
> `(let ((.function. ,function)
> @@ -1361,7 +1361,7 @@ bootstrapping.
> (:copier nil) (:include fast-method-call))
> value)
>
> -#-sb-fluid (declaim (sb-ext:freeze-type fast-method-call))
> +(declaim (sb-ext:freeze-type fast-method-call))
>
> ;; The two variants of INVOKE-FAST-METHOD-CALL differ in how REST-ARGs
> ;; are handled. The first one will get REST-ARG as a single list (as
> @@ -1403,7 +1403,7 @@ bootstrapping.
> (defstruct (fast-instance-boundp (:copier nil))
> (index 0 :type fixnum))
>
> -#-sb-fluid (declaim (sb-ext:freeze-type fast-instance-boundp))
> +(declaim (sb-ext:freeze-type fast-instance-boundp))
>
> (eval-when (:compile-toplevel :load-toplevel :execute)
> (defvar *allow-emf-call-tracing-p* nil)
> @@ -2075,7 +2075,7 @@ bootstrapping.
> (gf-info-c-a-m-emf-std-p t)
> gf-info-fast-mf-p)
>
> -#-sb-fluid (declaim (sb-ext:freeze-type arg-info))
> +(declaim (sb-ext:freeze-type arg-info))
>
> (defun arg-info-valid-p (arg-info)
> (not (null (arg-info-number-optional arg-info))))
> diff --git a/src/pcl/defs.lisp b/src/pcl/defs.lisp
> index 2f0e495a2..21b1d89bc 100644
> --- a/src/pcl/defs.lisp
> +++ b/src/pcl/defs.lisp
> @@ -38,7 +38,7 @@
> has already been partially loaded. This may not work, you may~%~
> need to get a fresh lisp (reboot) and then load PCL."))
>
> -#-sb-fluid (declaim (inline gdefinition))
> +(declaim (inline gdefinition))
> (defun gdefinition (spec)
> ;; This is null layer right now, but once FDEFINITION stops bypasssing
> ;; fwrappers/encapsulations we can do that here.
> diff --git a/src/pcl/dfun.lisp b/src/pcl/dfun.lisp
> index e32ca516d..2a6bfc2b7 100644
> --- a/src/pcl/dfun.lisp
> +++ b/src/pcl/dfun.lisp
> @@ -373,7 +373,7 @@ Except see also BREAK-VICIOUS-METACIRCLE. -- CSR, 2003-05-28
> (lambda (new arg)
> (accessor-miss gf new arg dfun-info)))))
>
> -#-sb-fluid (declaim (sb-ext:freeze-type dfun-info))
> +(declaim (sb-ext:freeze-type dfun-info))
>
> (defun make-one-class-accessor-dfun (gf type wrapper index)
> (let ((emit (ecase type
>
> -----------------------------------------------------------------------
>
>
> hooks/post-receive
> --
> SBCL
>
>
> _______________________________________________
> Sbcl-commits mailing list
> Sbcl-commits@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/sbcl-commits
_______________________________________________
Sbcl-devel mailing list
Sbcl-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic