This function attempts to read an expression that resembles a similar one in DUMP-I-VECTOR:

(defun test (xc-host-p cl-user::my-word-bits)
  (declare (special cl-user::my-word-bits))
  (let ((*features*
(if xc-host-p (cons :sb-xc-host *features*) *features*)))
    (read-from-string
     "(typecase foo
       ((simple-array (unsigned-byte 32) (*))
         (dump-unsigned-vector 32 (* 4 len)))
        #-sb-xc-host
        #!+#.(cl:if (cl:= 64 cl-user::my-word-bits) '(and) '(or))
        ((simple-array (unsigned-byte 63) (*))
         (dump-unsigned-vector 63 (* 8 len)))
        #!+#.(cl:if (cl:= 64 cl-user::my-word-bits) '(and) '(or))
        ((simple-array (unsigned-byte 64) (*))
         (dump-unsigned-vector 64 (* 8 len)))
        ((simple-array (signed-byte 8) (*)) ; <-- Watch this
         (dump-signed-vector 8 len))
        ((simple-array (signed-byte 16) (*))
         (dump-signed-vector 16 (* 2 len))))")))

Notice what if 'xc-host' is true and bits = 32 the (SIGNED-BYTE 8) clause disappears.
* (test t 32) =>
(TYPECASE FOO
  ((SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) (DUMP-UNSIGNED-VECTOR 32 (* 4 LEN)))
  ((SIMPLE-ARRAY (SIGNED-BYTE 16) (*)) (DUMP-SIGNED-VECTOR 16 (* 2 LEN))))
624

Obviously not what was intended. The '#-xc-host' needs to read and discard a form, but neither of the next 2 macros produces a value. The form seen and discarded by #-sb-xc-host is the (signed-byte 8) clause.

A few things would make this kind of construct more concise and legible:
1. Avoid #![-+] when the feature expression following is just (AND) or (OR) stuffed in by a read-time eval of an arbitrary Lisp form. It makes no difference whether that "feature" is evaluated with respect to host or target features. Better still, add a :64-bit feature which replaces the somewhat obscure expression
  (cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
with just
  #!+64-bit

2. Avoid nesting of the macros - it's not very clear.  If the #! reader were to understand :sb-xc-host as a special-case, treating it as if it were a target feature, then the conditionalized form
     #-sb-xc-host
     #!+#.(cl:if ....)
     ((simple-array (unsigned-byte 63) (*)) ...)
could be written as
     #!+(and (not sb-xc-host) :64-bit)
     ((simple-array (unsigned-byte 63) (*)) ...)

Similarly in x86-64/vm.lisp
    #!+sb-simd-pack
    (#+sb-xc-host nil
     #-sb-xc-host (simd-pack double-float)
        (sc-number-or-lose 'double-sse-immediate))
could be written as
#!+(and (not sb-xc-host) sb-simd-pack)
((simd-pack double-float) (sb-number-or-lose ...)