\f
;;;; utilities for optimizing array operations
-;;; Return UPGRADED-ARRAY-ELEMENT-TYPE for CONTINUATION, or do
+;;; Return UPGRADED-ARRAY-ELEMENT-TYPE for LVAR, or do
;;; GIVE-UP-IR1-TRANSFORM if the upgraded element type can't be
;;; determined.
-(defun upgraded-element-type-specifier-or-give-up (continuation)
- (let* ((element-ctype (extract-upgraded-element-type continuation))
- (element-type-specifier (type-specifier element-ctype)))
+(defun upgraded-element-type-specifier-or-give-up (lvar)
+ (let* ((element-ctype (extract-upgraded-element-type lvar))
+ (element-type-specifier (type-specifier element-ctype)))
(if (eq element-type-specifier '*)
- (give-up-ir1-transform
- "upgraded array element type not known at compile time")
- element-type-specifier)))
+ (give-up-ir1-transform
+ "upgraded array element type not known at compile time")
+ element-type-specifier)))
;;; Array access functions return an object from the array, hence its
;;; type is going to be the array upgraded element type.
(defun extract-upgraded-element-type (array)
- (let ((type (continuation-type array)))
- ;; Note that this IF mightn't be satisfied even if the runtime
- ;; value is known to be a subtype of some specialized ARRAY, because
- ;; we can have values declared e.g. (AND SIMPLE-VECTOR UNKNOWN-TYPE),
- ;; which are represented in the compiler as INTERSECTION-TYPE, not
- ;; array type.
+ (let ((type (lvar-type array)))
+ (cond
+ ;; Note that this IF mightn't be satisfied even if the runtime
+ ;; value is known to be a subtype of some specialized ARRAY, because
+ ;; we can have values declared e.g. (AND SIMPLE-VECTOR UNKNOWN-TYPE),
+ ;; which are represented in the compiler as INTERSECTION-TYPE, not
+ ;; array type.
+ ((array-type-p type) (array-type-specialized-element-type type))
+ ;; fix for bug #396. This type logic corresponds to the special
+ ;; case for strings in HAIRY-DATA-VECTOR-REF
+ ;; (generic/vm-tran.lisp)
+ ((csubtypep type (specifier-type 'simple-string))
+ (cond
+ ((csubtypep type (specifier-type '(simple-array character (*))))
+ (specifier-type 'character))
+ #!+sb-unicode
+ ((csubtypep type (specifier-type '(simple-array base-char (*))))
+ (specifier-type 'base-char))
+ ((csubtypep type (specifier-type '(simple-array nil (*))))
+ *empty-type*)
+ ;; see KLUDGE below.
+ (t *wild-type*)))
+ (t
+ ;; KLUDGE: there is no good answer here, but at least
+ ;; *wild-type* won't cause HAIRY-DATA-VECTOR-{REF,SET} to be
+ ;; erroneously optimized (see generic/vm-tran.lisp) -- CSR,
+ ;; 2002-08-21
+ *wild-type*))))
+
+(defun extract-declared-element-type (array)
+ (let ((type (lvar-type array)))
(if (array-type-p type)
- (array-type-specialized-element-type type)
- ;; KLUDGE: there is no good answer here, but at least
- ;; *wild-type* won't cause HAIRY-DATA-VECTOR-{REF,SET} to be
- ;; erroneously optimized (see generic/vm-tran.lisp) -- CSR,
- ;; 2002-08-21
- *wild-type*)))
+ (array-type-element-type type)
+ *wild-type*)))
;;; The ``new-value'' for array setters must fit in the array, and the
;;; return type is going to be the same as the new-value for SETF
;;; functions.
(defun assert-new-value-type (new-value array)
- (let ((type (continuation-type array)))
+ (let ((type (lvar-type array)))
(when (array-type-p type)
- (assert-continuation-type
+ (assert-lvar-type
new-value
(array-type-specialized-element-type type)
- (lexenv-policy (node-lexenv (continuation-dest new-value))))))
- (continuation-type new-value))
+ (lexenv-policy (node-lexenv (lvar-dest new-value))))))
+ (lvar-type new-value))
(defun assert-array-complex (array)
- (assert-continuation-type
+ (assert-lvar-type
array
(make-array-type :complexp t
:element-type *wild-type*)
- (lexenv-policy (node-lexenv (continuation-dest array)))))
+ (lexenv-policy (node-lexenv (lvar-dest array))))
+ nil)
-;;; Return true if ARG is NIL, or is a constant-continuation whose
+;;; Return true if ARG is NIL, or is a constant-lvar whose
;;; value is NIL, false otherwise.
(defun unsupplied-or-nil (arg)
- (declare (type (or continuation null) arg))
+ (declare (type (or lvar null) arg))
(or (not arg)
- (and (constant-continuation-p arg)
- (not (continuation-value arg)))))
+ (and (constant-lvar-p arg)
+ (not (lvar-value arg)))))
\f
;;;; DERIVE-TYPE optimizers
;;; Array operations that use a specific number of indices implicitly
;;; assert that the array is of that rank.
(defun assert-array-rank (array rank)
- (assert-continuation-type
+ (assert-lvar-type
array
(specifier-type `(array * ,(make-list rank :initial-element '*)))
- (lexenv-policy (node-lexenv (continuation-dest array)))))
+ (lexenv-policy (node-lexenv (lvar-dest array)))))
(defoptimizer (array-in-bounds-p derive-type) ((array &rest indices))
(assert-array-rank array (length indices))
(defoptimizer (aref derive-type) ((array &rest indices) node)
(assert-array-rank array (length indices))
- ;; If the node continuation has a single use then assert its type.
- (let ((cont (node-cont node)))
- (when (= (length (find-uses cont)) 1)
- (assert-continuation-type cont (extract-upgraded-element-type array)
- (lexenv-policy (node-lexenv node)))))
(extract-upgraded-element-type array))
(defoptimizer (%aset derive-type) ((array &rest stuff))
(assert-array-rank array (1- (length stuff)))
(assert-new-value-type (car (last stuff)) array))
-(defoptimizer (hairy-data-vector-ref derive-type) ((array index))
- (extract-upgraded-element-type array))
-(defoptimizer (data-vector-ref derive-type) ((array index))
+(macrolet ((define (name)
+ `(defoptimizer (,name derive-type) ((array index))
+ (extract-upgraded-element-type array))))
+ (define hairy-data-vector-ref)
+ (define hairy-data-vector-ref/check-bounds)
+ (define data-vector-ref))
+
+#!+(or x86 x86-64)
+(defoptimizer (data-vector-ref-with-offset derive-type) ((array index offset))
(extract-upgraded-element-type array))
-(defoptimizer (data-vector-set derive-type) ((array index new-value))
- (assert-new-value-type new-value array))
-(defoptimizer (hairy-data-vector-set derive-type) ((array index new-value))
+(macrolet ((define (name)
+ `(defoptimizer (,name derive-type) ((array index new-value))
+ (assert-new-value-type new-value array))))
+ (define hairy-data-vector-set)
+ (define hairy-data-vector-set/check-bounds)
+ (define data-vector-set))
+
+#!+(or x86 x86-64)
+(defoptimizer (data-vector-set-with-offset derive-type) ((array index offset new-value))
(assert-new-value-type new-value array))
;;; Figure out the type of the data vector if we know the argument
;;; element type.
-(defoptimizer (%with-array-data derive-type) ((array start end))
- (let ((atype (continuation-type array)))
+(defun derive-%with-array-data/mumble-type (array)
+ (let ((atype (lvar-type array)))
(when (array-type-p atype)
- (values-specifier-type
- `(values (simple-array ,(type-specifier
- (array-type-specialized-element-type atype))
- (*))
- index index index)))))
+ (specifier-type
+ `(simple-array ,(type-specifier
+ (array-type-specialized-element-type atype))
+ (*))))))
+(defoptimizer (%with-array-data derive-type) ((array start end))
+ (derive-%with-array-data/mumble-type array))
+(defoptimizer (%with-array-data/fp derive-type) ((array start end))
+ (derive-%with-array-data/mumble-type array))
(defoptimizer (array-row-major-index derive-type) ((array &rest indices))
(assert-array-rank array (length indices))
(assert-new-value-type new-value array))
(defoptimizer (make-array derive-type)
- ((dims &key initial-element element-type initial-contents
- adjustable fill-pointer displaced-index-offset displaced-to))
+ ((dims &key initial-element element-type initial-contents
+ adjustable fill-pointer displaced-index-offset displaced-to))
(let ((simple (and (unsupplied-or-nil adjustable)
- (unsupplied-or-nil displaced-to)
- (unsupplied-or-nil fill-pointer))))
+ (unsupplied-or-nil displaced-to)
+ (unsupplied-or-nil fill-pointer))))
(or (careful-specifier-type
`(,(if simple 'simple-array 'array)
,(cond ((not element-type) t)
- ((constant-continuation-p element-type)
- (continuation-value element-type))
+ ((constant-lvar-p element-type)
+ (let ((ctype (careful-specifier-type
+ (lvar-value element-type))))
+ (cond
+ ((or (null ctype) (unknown-type-p ctype)) '*)
+ (t (sb!xc:upgraded-array-element-type
+ (lvar-value element-type))))))
(t
'*))
- ,(cond ((not simple)
- '*)
- ((constant-continuation-p dims)
- (let ((val (continuation-value dims)))
- (if (listp val) val (list val))))
- ((csubtypep (continuation-type dims)
+ ,(cond ((constant-lvar-p dims)
+ (let* ((val (lvar-value dims))
+ (cdims (if (listp val) val (list val))))
+ (if simple
+ cdims
+ (length cdims))))
+ ((csubtypep (lvar-type dims)
(specifier-type 'integer))
'(*))
(t
;;; elements.
(define-source-transform vector (&rest elements)
(let ((len (length elements))
- (n -1))
+ (n -1))
(once-only ((n-vec `(make-array ,len)))
`(progn
- ,@(mapcar (lambda (el)
- (once-only ((n-val el))
- `(locally (declare (optimize (safety 0)))
- (setf (svref ,n-vec ,(incf n))
- ,n-val))))
- elements)
- ,n-vec))))
+ ,@(mapcar (lambda (el)
+ (once-only ((n-val el))
+ `(locally (declare (optimize (safety 0)))
+ (setf (svref ,n-vec ,(incf n)) ,n-val))))
+ elements)
+ ,n-vec))))
;;; Just convert it into a MAKE-ARRAY.
(deftransform make-string ((length &key
- (element-type 'base-char)
- (initial-element
- #.*default-init-char-form*)))
- '(make-array (the index length)
- :element-type element-type
- :initial-element initial-element))
-
-(defstruct (specialized-array-element-type-properties
- (:conc-name saetp-)
- (:constructor !make-saetp (ctype
- initial-element-default
- n-bits
- typecode
- &key
- (n-pad-elements 0)))
- (:copier nil))
- ;; the element type, e.g. #<BUILT-IN-CLASS BASE-CHAR (sealed)> or
- ;; #<SB-KERNEL:NUMERIC-TYPE (UNSIGNED-BYTE 4)>
- (ctype (missing-arg) :type ctype :read-only t)
- ;; what we get when the low-level vector-creation logic zeroes all
- ;; the bits (which also serves as the default value of MAKE-ARRAY's
- ;; :INITIAL-ELEMENT keyword)
- (initial-element-default (missing-arg) :read-only t)
- ;; how many bits per element
- (n-bits (missing-arg) :type index :read-only t)
- ;; the low-level type code
- (typecode (missing-arg) :type index :read-only t)
- ;; the number of extra elements we use at the end of the array for
- ;; low level hackery (e.g., one element for arrays of BASE-CHAR,
- ;; which is used for a fixed #\NULL so that when we call out to C
- ;; we don't need to cons a new copy)
- (n-pad-elements (missing-arg) :type index :read-only t))
-
-(defparameter *specialized-array-element-type-properties*
- (map 'simple-vector
- (lambda (args)
- (destructuring-bind (type-spec &rest rest) args
- (let ((ctype (specifier-type type-spec)))
- (apply #'!make-saetp ctype rest))))
- `(;; Erm. Yeah. There aren't a lot of things that make sense
- ;; for an initial element for (ARRAY NIL). -- CSR, 2002-03-07
- (nil '#:mu 0 ,sb!vm:simple-array-nil-widetag)
- (base-char ,(code-char 0) 8 ,sb!vm:simple-string-widetag
- ;; (SIMPLE-STRINGs are stored with an extra trailing
- ;; #\NULL for convenience in calling out to C.)
- :n-pad-elements 1)
- (single-float 0.0f0 32 ,sb!vm:simple-array-single-float-widetag)
- (double-float 0.0d0 64 ,sb!vm:simple-array-double-float-widetag)
- #!+long-float (long-float 0.0L0 #!+x86 96 #!+sparc 128
- ,sb!vm:simple-array-long-float-widetag)
- (bit 0 1 ,sb!vm:simple-bit-vector-widetag)
- ;; KLUDGE: The fact that these UNSIGNED-BYTE entries come
- ;; before their SIGNED-BYTE partners is significant in the
- ;; implementation of the compiler; some of the cross-compiler
- ;; code (see e.g. COERCE-TO-SMALLEST-ELTYPE in
- ;; src/compiler/debug-dump.lisp) attempts to create an array
- ;; specialized on (UNSIGNED-BYTE FOO), where FOO could be 7;
- ;; (UNSIGNED-BYTE 7) is SUBTYPEP (SIGNED-BYTE 8), so if we're
- ;; not careful we could get the wrong specialized array when
- ;; we try to FIND-IF, below. -- CSR, 2002-07-08
- ((unsigned-byte 2) 0 2 ,sb!vm:simple-array-unsigned-byte-2-widetag)
- ((unsigned-byte 4) 0 4 ,sb!vm:simple-array-unsigned-byte-4-widetag)
- ((unsigned-byte 8) 0 8 ,sb!vm:simple-array-unsigned-byte-8-widetag)
- ((unsigned-byte 16) 0 16 ,sb!vm:simple-array-unsigned-byte-16-widetag)
- ((unsigned-byte 32) 0 32 ,sb!vm:simple-array-unsigned-byte-32-widetag)
- ((signed-byte 8) 0 8 ,sb!vm:simple-array-signed-byte-8-widetag)
- ((signed-byte 16) 0 16 ,sb!vm:simple-array-signed-byte-16-widetag)
- ((signed-byte 30) 0 32 ,sb!vm:simple-array-signed-byte-30-widetag)
- ((signed-byte 32) 0 32 ,sb!vm:simple-array-signed-byte-32-widetag)
- ((complex single-float) #C(0.0f0 0.0f0) 64
- ,sb!vm:simple-array-complex-single-float-widetag)
- ((complex double-float) #C(0.0d0 0.0d0) 128
- ,sb!vm:simple-array-complex-double-float-widetag)
- #!+long-float ((complex long-float) #C(0.0L0 0.0L0)
- #!+x86 192 #!+sparc 256
- ,sb!vm:simple-array-complex-long-float-widetag)
- (t 0 32 ,sb!vm:simple-vector-widetag))))
+ (element-type 'character)
+ (initial-element
+ #.*default-init-char-form*)))
+ `(the simple-string (make-array (the index length)
+ :element-type element-type
+ ,@(when initial-element
+ '(:initial-element initial-element)))))
(deftransform make-array ((dims &key initial-element element-type
- adjustable fill-pointer)
- (t &rest *))
+ adjustable fill-pointer)
+ (t &rest *))
(when (null initial-element)
(give-up-ir1-transform))
(let* ((eltype (cond ((not element-type) t)
- ((not (constant-continuation-p element-type))
- (give-up-ir1-transform
- "ELEMENT-TYPE is not constant."))
- (t
- (continuation-value element-type))))
- (eltype-type (ir1-transform-specifier-type eltype))
- (saetp (find-if (lambda (saetp)
- (csubtypep eltype-type (saetp-ctype saetp)))
- *specialized-array-element-type-properties*))
- (creation-form `(make-array dims
- :element-type ',(type-specifier (saetp-ctype saetp))
- ,@(when fill-pointer
- '(:fill-pointer fill-pointer))
- ,@(when adjustable
- '(:adjustable adjustable)))))
+ ((not (constant-lvar-p element-type))
+ (give-up-ir1-transform
+ "ELEMENT-TYPE is not constant."))
+ (t
+ (lvar-value element-type))))
+ (eltype-type (ir1-transform-specifier-type eltype))
+ (saetp (find-if (lambda (saetp)
+ (csubtypep eltype-type (sb!vm:saetp-ctype saetp)))
+ sb!vm:*specialized-array-element-type-properties*))
+ (creation-form `(make-array dims
+ :element-type ',(type-specifier (sb!vm:saetp-ctype saetp))
+ ,@(when fill-pointer
+ '(:fill-pointer fill-pointer))
+ ,@(when adjustable
+ '(:adjustable adjustable)))))
(unless saetp
(give-up-ir1-transform "ELEMENT-TYPE not found in *SAETP*: ~S" eltype))
- (cond ((and (constant-continuation-p initial-element)
- (eql (continuation-value initial-element)
- (saetp-initial-element-default saetp)))
- creation-form)
- (t
- ;; error checking for target, disabled on the host because
- ;; (CTYPE-OF #\Null) is not possible.
- #-sb-xc-host
- (when (constant-continuation-p initial-element)
- (let ((value (continuation-value initial-element)))
- (cond
- ((not (csubtypep (ctype-of value)
- (saetp-ctype saetp)))
- ;; this case will cause an error at runtime, so we'd
- ;; better WARN about it now.
- (compiler-warn "~@<~S is not a ~S (which is the ~
- UPGRADED-ARRAY-ELEMENT-TYPE of ~S).~@:>"
- value
- (type-specifier (saetp-ctype saetp))
- eltype))
- ((not (csubtypep (ctype-of value) eltype-type))
- ;; this case will not cause an error at runtime, but
- ;; it's still worth STYLE-WARNing about.
- (compiler-style-warn "~S is not a ~S."
- value eltype)))))
- `(let ((array ,creation-form))
- (multiple-value-bind (vector)
- (%data-vector-and-index array 0)
- (fill vector initial-element))
- array)))))
+ (cond ((and (constant-lvar-p initial-element)
+ (eql (lvar-value initial-element)
+ (sb!vm:saetp-initial-element-default saetp)))
+ creation-form)
+ (t
+ ;; error checking for target, disabled on the host because
+ ;; (CTYPE-OF #\Null) is not possible.
+ #-sb-xc-host
+ (when (constant-lvar-p initial-element)
+ (let ((value (lvar-value initial-element)))
+ (cond
+ ((not (ctypep value (sb!vm:saetp-ctype saetp)))
+ ;; this case will cause an error at runtime, so we'd
+ ;; better WARN about it now.
+ (warn 'array-initial-element-mismatch
+ :format-control "~@<~S is not a ~S (which is the ~
+ ~S of ~S).~@:>"
+ :format-arguments
+ (list
+ value
+ (type-specifier (sb!vm:saetp-ctype saetp))
+ 'upgraded-array-element-type
+ eltype)))
+ ((not (ctypep value eltype-type))
+ ;; this case will not cause an error at runtime, but
+ ;; it's still worth STYLE-WARNing about.
+ (compiler-style-warn "~S is not a ~S."
+ value eltype)))))
+ `(let ((array ,creation-form))
+ (multiple-value-bind (vector)
+ (%data-vector-and-index array 0)
+ (fill vector initial-element))
+ array)))))
;;; The integer type restriction on the length ensures that it will be
;;; a vector. The lack of :ADJUSTABLE, :FILL-POINTER, and
;;; :INITIAL-ELEMENT relies on another transform to deal with that
;;; kind of initialization efficiently.
(deftransform make-array ((length &key element-type)
- (integer &rest *))
+ (integer &rest *))
(let* ((eltype (cond ((not element-type) t)
- ((not (constant-continuation-p element-type))
- (give-up-ir1-transform
- "ELEMENT-TYPE is not constant."))
- (t
- (continuation-value element-type))))
- (len (if (constant-continuation-p length)
- (continuation-value length)
- '*))
- (result-type-spec `(simple-array ,eltype (,len)))
- (eltype-type (ir1-transform-specifier-type eltype))
- (saetp (find-if (lambda (saetp)
- (csubtypep eltype-type (saetp-ctype saetp)))
- *specialized-array-element-type-properties*)))
+ ((not (constant-lvar-p element-type))
+ (give-up-ir1-transform
+ "ELEMENT-TYPE is not constant."))
+ (t
+ (lvar-value element-type))))
+ (len (if (constant-lvar-p length)
+ (lvar-value length)
+ '*))
+ (eltype-type (ir1-transform-specifier-type eltype))
+ (result-type-spec
+ `(simple-array
+ ,(if (unknown-type-p eltype-type)
+ (give-up-ir1-transform
+ "ELEMENT-TYPE is an unknown type: ~S" eltype)
+ (sb!xc:upgraded-array-element-type eltype))
+ (,len)))
+ (saetp (find-if (lambda (saetp)
+ (csubtypep eltype-type (sb!vm:saetp-ctype saetp)))
+ sb!vm:*specialized-array-element-type-properties*)))
(unless saetp
(give-up-ir1-transform
"cannot open-code creation of ~S" result-type-spec))
#-sb-xc-host
- (unless (csubtypep (ctype-of (saetp-initial-element-default saetp))
- eltype-type)
+ (unless (ctypep (sb!vm:saetp-initial-element-default saetp) eltype-type)
;; This situation arises e.g. in (MAKE-ARRAY 4 :ELEMENT-TYPE
;; '(INTEGER 1 5)) ANSI's definition of MAKE-ARRAY says "If
;; INITIAL-ELEMENT is not supplied, the consequences of later
;; he writes code:-), we'll signal a STYLE-WARNING in case he
;; didn't realize this.
(compiler-style-warn "The default initial element ~S is not a ~S."
- (saetp-initial-element-default saetp)
- eltype))
- (let* ((n-bits-per-element (saetp-n-bits saetp))
- (typecode (saetp-typecode saetp))
- (n-pad-elements (saetp-n-pad-elements saetp))
- (padded-length-form (if (zerop n-pad-elements)
- 'length
- `(+ length ,n-pad-elements)))
- (n-words-form
- (cond
- ((= n-bits-per-element 0) 0)
- ((>= n-bits-per-element sb!vm:n-word-bits)
- `(* ,padded-length-form
- (the fixnum ; i.e., not RATIO
- ,(/ n-bits-per-element sb!vm:n-word-bits))))
- (t
- (let ((n-elements-per-word (/ sb!vm:n-word-bits
- n-bits-per-element)))
- (declare (type index n-elements-per-word)) ; i.e., not RATIO
- `(ceiling ,padded-length-form ,n-elements-per-word))))))
+ (sb!vm:saetp-initial-element-default saetp)
+ eltype))
+ (let* ((n-bits-per-element (sb!vm:saetp-n-bits saetp))
+ (typecode (sb!vm:saetp-typecode saetp))
+ (n-pad-elements (sb!vm:saetp-n-pad-elements saetp))
+ (padded-length-form (if (zerop n-pad-elements)
+ 'length
+ `(+ length ,n-pad-elements)))
+ (n-words-form
+ (cond
+ ((= n-bits-per-element 0) 0)
+ ((>= n-bits-per-element sb!vm:n-word-bits)
+ `(* ,padded-length-form
+ (the fixnum ; i.e., not RATIO
+ ,(/ n-bits-per-element sb!vm:n-word-bits))))
+ (t
+ (let ((n-elements-per-word (/ sb!vm:n-word-bits
+ n-bits-per-element)))
+ (declare (type index n-elements-per-word)) ; i.e., not RATIO
+ `(ceiling ,padded-length-form ,n-elements-per-word))))))
(values
`(truly-the ,result-type-spec
- (allocate-vector ,typecode length ,n-words-form))
+ (allocate-vector ,typecode length ,n-words-form))
'((declare (type index length)))))))
;;; The list type restriction does not ensure that the result will be a
;;; %DATA-VECTOR-AND-INDEX in the VECTOR case problem is solved? --
;;; CSR, 2002-07-01
(deftransform make-array ((dims &key element-type)
- (list &rest *))
- (unless (or (null element-type) (constant-continuation-p element-type))
+ (list &rest *))
+ (unless (or (null element-type) (constant-lvar-p element-type))
(give-up-ir1-transform
"The element-type is not constant; cannot open code array creation."))
- (unless (constant-continuation-p dims)
+ (unless (constant-lvar-p dims)
(give-up-ir1-transform
"The dimension list is not constant; cannot open code array creation."))
- (let ((dims (continuation-value dims)))
+ (let ((dims (lvar-value dims)))
(unless (every #'integerp dims)
(give-up-ir1-transform
"The dimension list contains something other than an integer: ~S"
dims))
(if (= (length dims) 1)
- `(make-array ',(car dims)
- ,@(when element-type
- '(:element-type element-type)))
- (let* ((total-size (reduce #'* dims))
- (rank (length dims))
- (spec `(simple-array
- ,(cond ((null element-type) t)
- ((constant-continuation-p element-type)
- (continuation-value element-type))
- (t '*))
- ,(make-list rank :initial-element '*))))
- `(let ((header (make-array-header sb!vm:simple-array-widetag ,rank)))
- (setf (%array-fill-pointer header) ,total-size)
- (setf (%array-fill-pointer-p header) nil)
- (setf (%array-available-elements header) ,total-size)
- (setf (%array-data-vector header)
- (make-array ,total-size
- ,@(when element-type
- '(:element-type element-type))))
- (setf (%array-displaced-p header) nil)
- ,@(let ((axis -1))
- (mapcar (lambda (dim)
- `(setf (%array-dimension header ,(incf axis))
- ,dim))
- dims))
- (truly-the ,spec header))))))
+ `(make-array ',(car dims)
+ ,@(when element-type
+ '(:element-type element-type)))
+ (let* ((total-size (reduce #'* dims))
+ (rank (length dims))
+ (spec `(simple-array
+ ,(cond ((null element-type) t)
+ ((and (constant-lvar-p element-type)
+ (ir1-transform-specifier-type
+ (lvar-value element-type)))
+ (sb!xc:upgraded-array-element-type
+ (lvar-value element-type)))
+ (t '*))
+ ,(make-list rank :initial-element '*))))
+ `(let ((header (make-array-header sb!vm:simple-array-widetag ,rank)))
+ (setf (%array-fill-pointer header) ,total-size)
+ (setf (%array-fill-pointer-p header) nil)
+ (setf (%array-available-elements header) ,total-size)
+ (setf (%array-data-vector header)
+ (make-array ,total-size
+ ,@(when element-type
+ '(:element-type element-type))))
+ (setf (%array-displaced-p header) nil)
+ ,@(let ((axis -1))
+ (mapcar (lambda (dim)
+ `(setf (%array-dimension header ,(incf axis))
+ ,dim))
+ dims))
+ (truly-the ,spec header))))))
\f
;;;; miscellaneous properties of arrays
;;; Transforms for various array properties. If the property is know
;;; at compile time because of a type spec, use that constant value.
+;;; Most of this logic may end up belonging in code/late-type.lisp;
+;;; however, here we also need the -OR-GIVE-UP for the transforms, and
+;;; maybe this is just too sloppy for actual type logic. -- CSR,
+;;; 2004-02-18
+(defun array-type-dimensions-or-give-up (type)
+ (typecase type
+ (array-type (array-type-dimensions type))
+ (union-type
+ (let ((types (union-type-types type)))
+ ;; there are at least two types, right?
+ (aver (> (length types) 1))
+ (let ((result (array-type-dimensions-or-give-up (car types))))
+ (dolist (type (cdr types) result)
+ (unless (equal (array-type-dimensions-or-give-up type) result)
+ (give-up-ir1-transform))))))
+ ;; FIXME: intersection type [e.g. (and (array * (*)) (satisfies foo)) ]
+ (t (give-up-ir1-transform))))
+
+(defun conservative-array-type-complexp (type)
+ (typecase type
+ (array-type (array-type-complexp type))
+ (union-type
+ (let ((types (union-type-types type)))
+ (aver (> (length types) 1))
+ (let ((result (conservative-array-type-complexp (car types))))
+ (dolist (type (cdr types) result)
+ (unless (eq (conservative-array-type-complexp type) result)
+ (return-from conservative-array-type-complexp :maybe))))))
+ ;; FIXME: intersection type
+ (t :maybe)))
+
;;; If we can tell the rank from the type info, use it instead.
(deftransform array-rank ((array))
- (let ((array-type (continuation-type array)))
- (unless (array-type-p array-type)
- (give-up-ir1-transform))
- (let ((dims (array-type-dimensions array-type)))
+ (let ((array-type (lvar-type array)))
+ (let ((dims (array-type-dimensions-or-give-up array-type)))
(if (not (listp dims))
- (give-up-ir1-transform
- "The array rank is not known at compile time: ~S"
- dims)
- (length dims)))))
+ (give-up-ir1-transform
+ "The array rank is not known at compile time: ~S"
+ dims)
+ (length dims)))))
;;; If we know the dimensions at compile time, just use it. Otherwise,
;;; if we can tell that the axis is in bounds, convert to
;;; %ARRAY-DIMENSION (which just indirects the array header) or length
;;; (if it's simple and a vector).
(deftransform array-dimension ((array axis)
- (array index))
- (unless (constant-continuation-p axis)
+ (array index))
+ (unless (constant-lvar-p axis)
(give-up-ir1-transform "The axis is not constant."))
- (let ((array-type (continuation-type array))
- (axis (continuation-value axis)))
- (unless (array-type-p array-type)
- (give-up-ir1-transform))
- (let ((dims (array-type-dimensions array-type)))
+ (let ((array-type (lvar-type array))
+ (axis (lvar-value axis)))
+ (let ((dims (array-type-dimensions-or-give-up array-type)))
(unless (listp dims)
- (give-up-ir1-transform
- "The array dimensions are unknown; must call ARRAY-DIMENSION at runtime."))
+ (give-up-ir1-transform
+ "The array dimensions are unknown; must call ARRAY-DIMENSION at runtime."))
(unless (> (length dims) axis)
- (abort-ir1-transform "The array has dimensions ~S, ~W is too large."
- dims
- axis))
+ (abort-ir1-transform "The array has dimensions ~S, ~W is too large."
+ dims
+ axis))
(let ((dim (nth axis dims)))
- (cond ((integerp dim)
- dim)
- ((= (length dims) 1)
- (ecase (array-type-complexp array-type)
- ((t)
- '(%array-dimension array 0))
- ((nil)
- '(length array))
- ((:maybe)
- (give-up-ir1-transform
- "can't tell whether array is simple"))))
- (t
- '(%array-dimension array axis)))))))
+ (cond ((integerp dim)
+ dim)
+ ((= (length dims) 1)
+ (ecase (conservative-array-type-complexp array-type)
+ ((t)
+ '(%array-dimension array 0))
+ ((nil)
+ '(length array))
+ ((:maybe)
+ (give-up-ir1-transform
+ "can't tell whether array is simple"))))
+ (t
+ '(%array-dimension array axis)))))))
;;; If the length has been declared and it's simple, just return it.
(deftransform length ((vector)
- ((simple-array * (*))))
- (let ((type (continuation-type vector)))
- (unless (array-type-p type)
- (give-up-ir1-transform))
- (let ((dims (array-type-dimensions type)))
+ ((simple-array * (*))))
+ (let ((type (lvar-type vector)))
+ (let ((dims (array-type-dimensions-or-give-up type)))
(unless (and (listp dims) (integerp (car dims)))
- (give-up-ir1-transform
- "Vector length is unknown, must call LENGTH at runtime."))
+ (give-up-ir1-transform
+ "Vector length is unknown, must call LENGTH at runtime."))
(car dims))))
;;; All vectors can get their length by using VECTOR-LENGTH. If it's
;;; If a simple array with known dimensions, then VECTOR-LENGTH is a
;;; compile-time constant.
-(deftransform vector-length ((vector) ((simple-array * (*))))
- (let ((vtype (continuation-type vector)))
- (if (array-type-p vtype)
- (let ((dim (first (array-type-dimensions vtype))))
- (when (eq dim '*) (give-up-ir1-transform))
- dim)
- (give-up-ir1-transform))))
+(deftransform vector-length ((vector))
+ (let ((vtype (lvar-type vector)))
+ (let ((dim (first (array-type-dimensions-or-give-up vtype))))
+ (when (eq dim '*)
+ (give-up-ir1-transform))
+ (when (conservative-array-type-complexp vtype)
+ (give-up-ir1-transform))
+ dim)))
;;; Again, if we can tell the results from the type, just use it.
;;; Otherwise, if we know the rank, convert into a computation based
;;; multiplications because we know that the total size must be an
;;; INDEX.
(deftransform array-total-size ((array)
- (array))
- (let ((array-type (continuation-type array)))
- (unless (array-type-p array-type)
- (give-up-ir1-transform))
- (let ((dims (array-type-dimensions array-type)))
+ (array))
+ (let ((array-type (lvar-type array)))
+ (let ((dims (array-type-dimensions-or-give-up array-type)))
(unless (listp dims)
- (give-up-ir1-transform "can't tell the rank at compile time"))
+ (give-up-ir1-transform "can't tell the rank at compile time"))
(if (member '* dims)
- (do ((form 1 `(truly-the index
- (* (array-dimension array ,i) ,form)))
- (i 0 (1+ i)))
- ((= i (length dims)) form))
- (reduce #'* dims)))))
+ (do ((form 1 `(truly-the index
+ (* (array-dimension array ,i) ,form)))
+ (i 0 (1+ i)))
+ ((= i (length dims)) form))
+ (reduce #'* dims)))))
;;; Only complex vectors have fill pointers.
(deftransform array-has-fill-pointer-p ((array))
- (let ((array-type (continuation-type array)))
- (unless (array-type-p array-type)
- (give-up-ir1-transform))
- (let ((dims (array-type-dimensions array-type)))
+ (let ((array-type (lvar-type array)))
+ (let ((dims (array-type-dimensions-or-give-up array-type)))
(if (and (listp dims) (not (= (length dims) 1)))
- nil
- (ecase (array-type-complexp array-type)
- ((t)
- t)
- ((nil)
- nil)
- ((:maybe)
- (give-up-ir1-transform
- "The array type is ambiguous; must call ~
- ARRAY-HAS-FILL-POINTER-P at runtime.")))))))
+ nil
+ (ecase (conservative-array-type-complexp array-type)
+ ((t)
+ t)
+ ((nil)
+ nil)
+ ((:maybe)
+ (give-up-ir1-transform
+ "The array type is ambiguous; must call ~
+ ARRAY-HAS-FILL-POINTER-P at runtime.")))))))
;;; Primitive used to verify indices into arrays. If we can tell at
;;; compile-time or we are generating unsafe code, don't bother with
;;; the VOP.
-(deftransform %check-bound ((array dimension index))
- (unless (constant-continuation-p dimension)
- (give-up-ir1-transform))
- (let ((dim (continuation-value dimension)))
- `(the (integer 0 ,dim) index)))
-(deftransform %check-bound ((array dimension index) * *
- :policy (and (> speed safety) (= safety 0)))
- 'index)
+(deftransform %check-bound ((array dimension index) * * :node node)
+ (cond ((policy node (= insert-array-bounds-checks 0))
+ 'index)
+ ((not (constant-lvar-p dimension))
+ (give-up-ir1-transform))
+ (t
+ (let ((dim (lvar-value dimension)))
+ ;; FIXME: Can SPEED > SAFETY weaken this check to INTEGER?
+ `(the (integer 0 (,dim)) index)))))
\f
;;;; WITH-ARRAY-DATA
;;; the DEFTRANSFORM can't tell that that's going on, so it can make
;;; sense to use FORCE-INLINE option in that case.
(def!macro with-array-data (((data-var array &key offset-var)
- (start-var &optional (svalue 0))
- (end-var &optional (evalue nil))
- &key force-inline)
- &body forms)
+ (start-var &optional (svalue 0))
+ (end-var &optional (evalue nil))
+ &key force-inline check-fill-pointer)
+ &body forms
+ &environment env)
(once-only ((n-array array)
- (n-svalue `(the index ,svalue))
- (n-evalue `(the (or index null) ,evalue)))
- `(multiple-value-bind (,data-var
- ,start-var
- ,end-var
- ,@(when offset-var `(,offset-var)))
- (if (not (array-header-p ,n-array))
- (let ((,n-array ,n-array))
- (declare (type (simple-array * (*)) ,n-array))
- ,(once-only ((n-len `(length ,n-array))
- (n-end `(or ,n-evalue ,n-len)))
- `(if (<= ,n-svalue ,n-end ,n-len)
- ;; success
- (values ,n-array ,n-svalue ,n-end 0)
- (failed-%with-array-data ,n-array
- ,n-svalue
- ,n-evalue))))
- (,(if force-inline '%with-array-data-macro '%with-array-data)
- ,n-array ,n-svalue ,n-evalue))
- ,@forms)))
+ (n-svalue `(the index ,svalue))
+ (n-evalue `(the (or index null) ,evalue)))
+ (let ((check-bounds (policy env (= 0 insert-array-bounds-checks))))
+ `(multiple-value-bind (,data-var
+ ,start-var
+ ,end-var
+ ,@(when offset-var `(,offset-var)))
+ (if (not (array-header-p ,n-array))
+ (let ((,n-array ,n-array))
+ (declare (type (simple-array * (*)) ,n-array))
+ ,(once-only ((n-len (if check-fill-pointer
+ `(length ,n-array)
+ `(array-total-size ,n-array)))
+ (n-end `(or ,n-evalue ,n-len)))
+ (if check-bounds
+ `(values ,n-array ,n-svalue ,n-end 0)
+ `(if (<= ,n-svalue ,n-end ,n-len)
+ (values ,n-array ,n-svalue ,n-end 0)
+ ,(if check-fill-pointer
+ `(sequence-bounding-indices-bad-error ,n-array ,n-svalue ,n-evalue)
+ `(array-bounding-indices-bad-error ,n-array ,n-svalue ,n-evalue))))))
+ ,(if force-inline
+ `(%with-array-data-macro ,n-array ,n-svalue ,n-evalue
+ :check-bounds ,check-bounds
+ :check-fill-pointer ,check-fill-pointer)
+ (if check-fill-pointer
+ `(%with-array-data/fp ,n-array ,n-svalue ,n-evalue)
+ `(%with-array-data ,n-array ,n-svalue ,n-evalue))))
+ ,@forms))))
;;; This is the fundamental definition of %WITH-ARRAY-DATA, for use in
;;; DEFTRANSFORMs and DEFUNs.
(def!macro %with-array-data-macro (array
- start
- end
- &key
- (element-type '*)
- unsafe?
- fail-inline?)
- (let ((size (gensym "SIZE-"))
- (defaulted-end (gensym "DEFAULTED-END-"))
- (data (gensym "DATA-"))
- (cumulative-offset (gensym "CUMULATIVE-OFFSET-")))
- `(let* ((,size (array-total-size ,array))
- (,defaulted-end
- (cond (,end
- (unless (or ,unsafe? (<= ,end ,size))
- ,(if fail-inline?
- `(error 'bounding-indices-bad-error
- :datum (cons ,start ,end)
- :expected-type `(cons (integer 0 ,',size)
- (integer ,',start ,',size))
- :object ,array)
- `(failed-%with-array-data ,array ,start ,end)))
- ,end)
- (t ,size))))
- (unless (or ,unsafe? (<= ,start ,defaulted-end))
- ,(if fail-inline?
- `(error 'bounding-indices-bad-error
- :datum (cons ,start ,end)
- :expected-type `(cons (integer 0 ,',size)
- (integer ,',start ,',size))
- :object ,array)
- `(failed-%with-array-data ,array ,start ,end)))
+ start
+ end
+ &key
+ (element-type '*)
+ check-bounds
+ check-fill-pointer)
+ (with-unique-names (size defaulted-end data cumulative-offset)
+ `(let* ((,size ,(if check-fill-pointer
+ `(length ,array)
+ `(array-total-size ,array)))
+ (,defaulted-end (or ,end ,size)))
+ ,@(when check-bounds
+ `((unless (<= ,start ,defaulted-end ,size)
+ ,(if check-fill-pointer
+ `(sequence-bounding-indices-bad-error ,array ,start ,end)
+ `(array-bounding-indices-bad-error ,array ,start ,end)))))
(do ((,data ,array (%array-data-vector ,data))
- (,cumulative-offset 0
- (+ ,cumulative-offset
- (%array-displacement ,data))))
- ((not (array-header-p ,data))
- (values (the (simple-array ,element-type 1) ,data)
- (the index (+ ,cumulative-offset ,start))
- (the index (+ ,cumulative-offset ,defaulted-end))
- (the index ,cumulative-offset)))
- (declare (type index ,cumulative-offset))))))
-
+ (,cumulative-offset 0
+ (+ ,cumulative-offset
+ (%array-displacement ,data))))
+ ((not (array-header-p ,data))
+ (values (the (simple-array ,element-type 1) ,data)
+ (the index (+ ,cumulative-offset ,start))
+ (the index (+ ,cumulative-offset ,defaulted-end))
+ (the index ,cumulative-offset)))
+ (declare (type index ,cumulative-offset))))))
+
+(defun transform-%with-array-data/muble (array node check-fill-pointer)
+ (let ((element-type (upgraded-element-type-specifier-or-give-up array))
+ (type (lvar-type array)))
+ (if (and (array-type-p type)
+ (listp (array-type-dimensions type))
+ (not (null (cdr (array-type-dimensions type)))))
+ ;; If it's a simple multidimensional array, then just return
+ ;; its data vector directly rather than going through
+ ;; %WITH-ARRAY-DATA-MACRO. SBCL doesn't generally generate
+ ;; code that would use this currently, but we have encouraged
+ ;; users to use WITH-ARRAY-DATA and we may use it ourselves at
+ ;; some point in the future for optimized libraries or
+ ;; similar.
+ ;;
+ ;; FIXME: The return values here don't seem sane, and
+ ;; bounds-checks are elided!
+ `(let ((data (truly-the (simple-array ,element-type (*))
+ (%array-data-vector array))))
+ (values data 0 (length data) 0))
+ `(%with-array-data-macro array start end
+ :check-fill-pointer ,check-fill-pointer
+ :check-bounds ,(policy node (< 0 insert-array-bounds-checks))
+ :element-type ,element-type))))
+
+;; It might very well be reasonable to allow general ARRAY here, I
+;; just haven't tried to understand the performance issues involved.
+;; -- WHN, and also CSR 2002-05-26
(deftransform %with-array-data ((array start end)
- ;; It might very well be reasonable to
- ;; allow general ARRAY here, I just
- ;; haven't tried to understand the
- ;; performance issues involved. --
- ;; WHN, and also CSR 2002-05-26
- ((or vector simple-array) index (or index null))
- *
- :important t
- :node node
- :policy (> speed space))
+ ((or vector simple-array) index (or index null) t)
+ *
+ :node node
+ :policy (> speed space))
+ "inline non-SIMPLE-vector-handling logic"
+ (transform-%with-array-data/muble array node nil))
+(deftransform %with-array-data/fp ((array start end)
+ ((or vector simple-array) index (or index null) t)
+ *
+ :node node
+ :policy (> speed space))
"inline non-SIMPLE-vector-handling logic"
- (let ((element-type (upgraded-element-type-specifier-or-give-up array)))
- `(%with-array-data-macro array start end
- :unsafe? ,(policy node (= safety 0))
- :element-type ,element-type)))
+ (transform-%with-array-data/muble array node t))
\f
;;;; array accessors
;;; We convert all typed array accessors into AREF and %ASET with type
;;; assertions on the array.
+(macrolet ((define-bit-frob (reffer setter simplep)
+ `(progn
+ (define-source-transform ,reffer (a &rest i)
+ `(aref (the (,',(if simplep 'simple-array 'array)
+ bit
+ ,(mapcar (constantly '*) i))
+ ,a) ,@i))
+ (define-source-transform ,setter (a &rest i)
+ `(%aset (the (,',(if simplep 'simple-array 'array)
+ bit
+ ,(cdr (mapcar (constantly '*) i)))
+ ,a) ,@i)))))
+ (define-bit-frob sbit %sbitset t)
+ (define-bit-frob bit %bitset nil))
(macrolet ((define-frob (reffer setter type)
- `(progn
- (define-source-transform ,reffer (a &rest i)
- `(aref (the ,',type ,a) ,@i))
- (define-source-transform ,setter (a &rest i)
- `(%aset (the ,',type ,a) ,@i)))))
- (define-frob sbit %sbitset (simple-array bit))
- (define-frob bit %bitset (array bit)))
-(macrolet ((define-frob (reffer setter type)
- `(progn
- (define-source-transform ,reffer (a i)
- `(aref (the ,',type ,a) ,i))
- (define-source-transform ,setter (a i v)
- `(%aset (the ,',type ,a) ,i ,v)))))
+ `(progn
+ (define-source-transform ,reffer (a i)
+ `(aref (the ,',type ,a) ,i))
+ (define-source-transform ,setter (a i v)
+ `(%aset (the ,',type ,a) ,i ,v)))))
(define-frob svref %svset simple-vector)
(define-frob schar %scharset simple-string)
(define-frob char %charset string))
(macrolet (;; This is a handy macro for computing the row-major index
- ;; given a set of indices. We wrap each index with a call
- ;; to %CHECK-BOUND to ensure that everything works out
- ;; correctly. We can wrap all the interior arithmetic with
- ;; TRULY-THE INDEX because we know the the resultant
- ;; row-major index must be an index.
- (with-row-major-index ((array indices index &optional new-value)
- &rest body)
- `(let (n-indices dims)
- (dotimes (i (length ,indices))
- (push (make-symbol (format nil "INDEX-~D" i)) n-indices)
- (push (make-symbol (format nil "DIM-~D" i)) dims))
- (setf n-indices (nreverse n-indices))
- (setf dims (nreverse dims))
- `(lambda (,',array ,@n-indices
- ,@',(when new-value (list new-value)))
- (let* (,@(let ((,index -1))
- (mapcar (lambda (name)
- `(,name (array-dimension
- ,',array
- ,(incf ,index))))
- dims))
- (,',index
- ,(if (null dims)
- 0
- (do* ((dims dims (cdr dims))
- (indices n-indices (cdr indices))
- (last-dim nil (car dims))
- (form `(%check-bound ,',array
- ,(car dims)
- ,(car indices))
- `(truly-the
- index
- (+ (truly-the index
- (* ,form
- ,last-dim))
- (%check-bound
- ,',array
- ,(car dims)
- ,(car indices))))))
- ((null (cdr dims)) form)))))
- ,',@body)))))
+ ;; given a set of indices. We wrap each index with a call
+ ;; to %CHECK-BOUND to ensure that everything works out
+ ;; correctly. We can wrap all the interior arithmetic with
+ ;; TRULY-THE INDEX because we know the resultant
+ ;; row-major index must be an index.
+ (with-row-major-index ((array indices index &optional new-value)
+ &rest body)
+ `(let (n-indices dims)
+ (dotimes (i (length ,indices))
+ (push (make-symbol (format nil "INDEX-~D" i)) n-indices)
+ (push (make-symbol (format nil "DIM-~D" i)) dims))
+ (setf n-indices (nreverse n-indices))
+ (setf dims (nreverse dims))
+ `(lambda (,',array ,@n-indices
+ ,@',(when new-value (list new-value)))
+ (let* (,@(let ((,index -1))
+ (mapcar (lambda (name)
+ `(,name (array-dimension
+ ,',array
+ ,(incf ,index))))
+ dims))
+ (,',index
+ ,(if (null dims)
+ 0
+ (do* ((dims dims (cdr dims))
+ (indices n-indices (cdr indices))
+ (last-dim nil (car dims))
+ (form `(%check-bound ,',array
+ ,(car dims)
+ ,(car indices))
+ `(truly-the
+ index
+ (+ (truly-the index
+ (* ,form
+ ,last-dim))
+ (%check-bound
+ ,',array
+ ,(car dims)
+ ,(car indices))))))
+ ((null (cdr dims)) form)))))
+ ,',@body)))))
;; Just return the index after computing it.
(deftransform array-row-major-index ((array &rest indices))
(deftransform aref ((array &rest indices))
(with-row-major-index (array indices index)
(hairy-data-vector-ref array index)))
+
(deftransform %aset ((array &rest stuff))
(let ((indices (butlast stuff)))
(with-row-major-index (array indices index new-value)
- (hairy-data-vector-set array index new-value)))))
+ (hairy-data-vector-set array index new-value)))))
+
+;; For AREF of vectors we do the bounds checking in the callee. This
+;; lets us do a significantly more efficient check for simple-arrays
+;; without bloating the code. If we already know the type of the array
+;; with sufficient precision, skip directly to DATA-VECTOR-REF.
+(deftransform aref ((array index) (t t) * :node node)
+ (let ((type (lvar-type array)))
+ (cond ((and (array-type-p type)
+ (null (array-type-complexp type))
+ (not (eql (extract-upgraded-element-type array)
+ *wild-type*))
+ (eql (length (array-type-dimensions type)) 1))
+ `(data-vector-ref array (%check-bound array
+ (array-dimension array 0)
+ index)))
+ ((policy node (zerop insert-array-bounds-checks))
+ `(hairy-data-vector-ref array index))
+ (t
+ `(hairy-data-vector-ref/check-bounds array index)))))
+
+(deftransform %aset ((array index new-value) (t t t) * :node node)
+ (if (policy node (zerop insert-array-bounds-checks))
+ `(hairy-data-vector-set array index new-value)
+ `(hairy-data-vector-set/check-bounds array index new-value)))
+
+;;; But if we find out later that there's some useful type information
+;;; available, switch back to the normal one to give other transforms
+;;; a stab at it.
+(macrolet ((define (name transform-to extra extra-type)
+ `(deftransform ,name ((array index ,@extra))
+ (let ((type (lvar-type array))
+ (element-type (extract-upgraded-element-type array)))
+ ;; If an element type has been declared, we want to
+ ;; use that information it for type checking (even
+ ;; if the access can't be optimized due to the array
+ ;; not being simple).
+ (when (and (eql element-type *wild-type*)
+ ;; This type logic corresponds to the special
+ ;; case for strings in HAIRY-DATA-VECTOR-REF
+ ;; (generic/vm-tran.lisp)
+ (not (csubtypep type (specifier-type 'simple-string))))
+ (when (or (not (array-type-p type))
+ ;; If it's a simple array, we might be able
+ ;; to inline the access completely.
+ (not (null (array-type-complexp type))))
+ (give-up-ir1-transform
+ "Upgraded element type of array is not known at compile time."))))
+ `(,',transform-to array
+ (%check-bound array
+ (array-dimension array 0)
+ index)
+ ,@',extra))))
+ (define hairy-data-vector-ref/check-bounds
+ hairy-data-vector-ref nil nil)
+ (define hairy-data-vector-set/check-bounds
+ hairy-data-vector-set (new-value) (*)))
;;; Just convert into a HAIRY-DATA-VECTOR-REF (or
;;; HAIRY-DATA-VECTOR-SET) after checking that the index is inside the
;;; array total size.
(deftransform row-major-aref ((array index))
`(hairy-data-vector-ref array
- (%check-bound array (array-total-size array) index)))
+ (%check-bound array (array-total-size array) index)))
(deftransform %set-row-major-aref ((array index new-value))
`(hairy-data-vector-set array
- (%check-bound array (array-total-size array) index)
- new-value))
+ (%check-bound array (array-total-size array) index)
+ new-value))
\f
;;;; bit-vector array operation canonicalization
;;;;
(macrolet ((def (fun)
`(progn
(deftransform ,fun ((bit-array-1 bit-array-2
- &optional result-bit-array)
+ &optional result-bit-array)
(bit-vector bit-vector &optional null) *
:policy (>= speed space))
`(,',fun bit-array-1 bit-array-2
- (make-array (length bit-array-1) :element-type 'bit)))
+ (make-array (array-dimension bit-array-1 0) :element-type 'bit)))
;; If result is T, make it the first arg.
(deftransform ,fun ((bit-array-1 bit-array-2 result-bit-array)
- (bit-vector bit-vector (member t)) *)
+ (bit-vector bit-vector (eql t)) *)
`(,',fun bit-array-1 bit-array-2 bit-array-1)))))
(def bit-and)
(def bit-ior)
;;; Similar for BIT-NOT, but there is only one arg...
(deftransform bit-not ((bit-array-1 &optional result-bit-array)
- (bit-vector &optional null) *
- :policy (>= speed space))
+ (bit-vector &optional null) *
+ :policy (>= speed space))
'(bit-not bit-array-1
- (make-array (length bit-array-1) :element-type 'bit)))
+ (make-array (array-dimension bit-array-1 0) :element-type 'bit)))
(deftransform bit-not ((bit-array-1 result-bit-array)
- (bit-vector (constant-arg t)))
+ (bit-vector (eql t)))
'(bit-not bit-array-1 bit-array-1))
-;;; FIXME: What does (CONSTANT-ARG T) mean? Is it the same thing
-;;; as (CONSTANT-ARG (MEMBER T)), or does it mean any constant
-;;; value?
\f
;;; Pick off some constant cases.
-(deftransform array-header-p ((array) (array))
- (let ((type (continuation-type array)))
- (unless (array-type-p type)
- (give-up-ir1-transform))
- (let ((dims (array-type-dimensions type)))
- (cond ((csubtypep type (specifier-type '(simple-array * (*))))
- ;; no array header
- nil)
- ((and (listp dims) (> (length dims) 1))
- ;; multi-dimensional array, will have a header
- t)
- (t
- (give-up-ir1-transform))))))
+(defoptimizer (array-header-p derive-type) ((array))
+ (let ((type (lvar-type array)))
+ (cond ((not (array-type-p type))
+ ;; FIXME: use analogue of ARRAY-TYPE-DIMENSIONS-OR-GIVE-UP
+ nil)
+ (t
+ (let ((dims (array-type-dimensions type)))
+ (cond ((csubtypep type (specifier-type '(simple-array * (*))))
+ ;; no array header
+ (specifier-type 'null))
+ ((and (listp dims) (/= (length dims) 1))
+ ;; multi-dimensional array, will have a header
+ (specifier-type '(eql t)))
+ ((eql (array-type-complexp type) t)
+ (specifier-type '(eql t)))
+ (t
+ nil)))))))
projects / sbcl.git / blobdiff