0.8.3.44:
[sbcl.git] / src / compiler / generic / vm-array.lisp
1 ;;;; this file centralizes information about the array types
2 ;;;; implemented by the system, where previously such information was
3 ;;;; spread over several files.
4
5 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; more information.
7 ;;;;
8 ;;;; This software is derived from the CMU CL system, which was
9 ;;;; written at Carnegie Mellon University and released into the
10 ;;;; public domain. The software is in the public domain and is
11 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
12 ;;;; files for more information.
13
14 (in-package "SB!VM")
15
16 (defstruct (specialized-array-element-type-properties
17             (:conc-name saetp-)
18             (:constructor
19              !make-saetp
20              (specifier
21               initial-element-default
22               n-bits
23               primitive-type-name
24               &key (n-pad-elements 0) complex-typecode (importance 0)
25               &aux (typecode
26                     (eval (symbolicate primitive-type-name "-WIDETAG")))))
27             (:copier nil))
28   ;; the element specifier, e.g. BASE-CHAR or (UNSIGNED-BYTE 4)
29   (specifier (missing-arg) :type type-specifier :read-only t)
30   ;; the element type, e.g. #<BUILT-IN-CLASS BASE-CHAR (sealed)> or
31   ;; #<SB-KERNEL:NUMERIC-TYPE (UNSIGNED-BYTE 4)>
32   (ctype nil :type (or ctype null))
33   ;; what we get when the low-level vector-creation logic zeroes all
34   ;; the bits (which also serves as the default value of MAKE-ARRAY's
35   ;; :INITIAL-ELEMENT keyword)
36   (initial-element-default (missing-arg) :read-only t)
37   ;; how many bits per element
38   (n-bits (missing-arg) :type index :read-only t)
39   ;; the low-level type code (aka "widetag")
40   (typecode (missing-arg) :type index :read-only t)
41   ;; if an integer, a typecode corresponding to a complex vector
42   ;; specialized on this element type.
43   (complex-typecode nil :type (or index null) :read-only t)
44   ;; the name of the primitive type of data vectors specialized on
45   ;; this type
46   (primitive-type-name (missing-arg) :type symbol :read-only t)
47   ;; the number of extra elements we use at the end of the array for
48   ;; low level hackery (e.g., one element for arrays of BASE-CHAR,
49   ;; which is used for a fixed #\NULL so that when we call out to C
50   ;; we don't need to cons a new copy)
51   (n-pad-elements (missing-arg) :type index :read-only t)
52   ;; the relative importance of this array type.  Used for determining
53   ;; the order of the TYPECASE in HAIRY-DATA-VECTOR-{REF,SET}.  High
54   ;; positive numbers are near the top; low negative numbers near the
55   ;; bottom.
56   (importance (missing-arg) :type fixnum :read-only t))
57
58 (defparameter *specialized-array-element-type-properties*
59   (map 'simple-vector
60        (lambda (args)
61          (apply #'!make-saetp args))
62        `(;; Erm.  Yeah.  There aren't a lot of things that make sense
63          ;; for an initial element for (ARRAY NIL). -- CSR, 2002-03-07
64          (nil #:mu 0 simple-array-nil
65               :complex-typecode #.sb!vm:complex-vector-nil-widetag
66               :importance 0)
67          (base-char ,(code-char 0) 8 simple-base-string
68                     ;; (SIMPLE-BASE-STRINGs are stored with an extra
69                     ;; trailing #\NULL for convenience in calling out
70                     ;; to C.)
71                     :n-pad-elements 1
72                     :complex-typecode #.sb!vm:complex-base-string-widetag
73                     :importance 17)
74          (single-float 0.0f0 32 simple-array-single-float
75           :importance 6)
76          (double-float 0.0d0 64 simple-array-double-float
77           :importance 5)
78          #!+long-float
79          (long-float 0.0l0 #!+x86 96 #!+sparc 128 simple-array-long-float
80           :importance 4)
81          (bit 0 1 simple-bit-vector
82               :complex-typecode #.sb!vm:complex-bit-vector-widetag
83               :importance 16)
84          ;; KLUDGE: The fact that these UNSIGNED-BYTE entries come
85          ;; before their SIGNED-BYTE partners is significant in the
86          ;; implementation of the compiler; some of the cross-compiler
87          ;; code (see e.g. COERCE-TO-SMALLEST-ELTYPE in
88          ;; src/compiler/debug-dump.lisp) attempts to create an array
89          ;; specialized on (UNSIGNED-BYTE FOO), where FOO could be 7;
90          ;; (UNSIGNED-BYTE 7) is SUBTYPEP (SIGNED-BYTE 8), so if we're
91          ;; not careful we could get the wrong specialized array when
92          ;; we try to FIND-IF, below. -- CSR, 2002-07-08
93          ((unsigned-byte 2) 0 2 simple-array-unsigned-byte-2
94                             :importance 15)
95          ((unsigned-byte 4) 0 4 simple-array-unsigned-byte-4
96                             :importance 14)
97          ((unsigned-byte 7) 0 8 simple-array-unsigned-byte-7
98                             :importance 13)
99          ((unsigned-byte 8) 0 8 simple-array-unsigned-byte-8
100           :importance 13)
101          ((unsigned-byte 15) 0 16 simple-array-unsigned-byte-15
102           :importance 12)
103          ((unsigned-byte 16) 0 16 simple-array-unsigned-byte-16
104           :importance 12)
105          ((unsigned-byte 29) 0 32 simple-array-unsigned-byte-29
106           :importance 8)
107          ((unsigned-byte 31) 0 32 simple-array-unsigned-byte-31
108           :importance 11)
109          ((unsigned-byte 32) 0 32 simple-array-unsigned-byte-32
110           :importance 11)
111          ((signed-byte 8) 0 8 simple-array-signed-byte-8
112           :importance 10)
113          ((signed-byte 16) 0 16 simple-array-signed-byte-16
114           :importance 9)
115          ;; KLUDGE: See the comment in PRIMITIVE-TYPE-AUX,
116          ;; compiler/generic/primtype.lisp, for why this is FIXNUM and
117          ;; not (SIGNED-BYTE 30)
118          (fixnum 0 32 simple-array-signed-byte-30
119           :importance 8)
120          ((signed-byte 32) 0 32 simple-array-signed-byte-32
121           :importance 7)
122          ((complex single-float) #C(0.0f0 0.0f0) 64
123           simple-array-complex-single-float
124           :importance 3)
125          ((complex double-float) #C(0.0d0 0.0d0) 128
126           simple-array-complex-double-float
127           :importance 2)
128          #!+long-float
129          ((complex long-float) #C(0.0l0 0.0l0) #!+x86 192 #!+sparc 256
130           simple-array-complex-long-float
131           :importance 1)
132          (t 0 32 simple-vector :importance 18))))
133
134 (defvar sb!kernel::*specialized-array-element-types*
135   (map 'list
136        #'saetp-specifier
137        *specialized-array-element-type-properties*))
138
139 #-sb-xc-host
140 (defun !vm-type-cold-init ()
141   (setf sb!kernel::*specialized-array-element-types*
142         '#.sb!kernel::*specialized-array-element-types*))
143
144 (defvar *simple-array-primitive-types*
145   (map 'list
146        (lambda (saetp)
147          (cons (saetp-specifier saetp)
148                (saetp-primitive-type-name saetp)))
149        *specialized-array-element-type-properties*)
150   #!+sb-doc
151   "An alist for mapping simple array element types to their
152 corresponding primitive types.")