[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04
|
From: |
David Bjergaard |
|
Subject: |
Re: [STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04 |
|
Date: |
Thu, 9 Jun 2011 12:46:42 -0500 |
Hi,
I've also recompiled stumpwm in 11.04 after upgrading, but I installed
the latest sbcl from source because the binary distributed with 11.04
doesn't enable threading by default making it impossible to take
advantage of slime and swank features. Try downloading and compiling
the latest sbcl and then follow the instructions on the archwiki. It
took a little more tweaking than I expected but eventually I got it
working.
Cheers,
Dave
On Tue, Jun 7, 2011 at 11:03 PM, Jay Belanger <address@hidden> wrote:
>
> I recently upgraded to Ubuntu 11.04, and now stumpwm won't compile (and
> complains quite a bit that specific number types aren't used). The
> output says that it might be a bug in sbcl, but I thought it would make
> sense to work my way up and see if it may be a problem with stumpwm.
> Is anybody else having a problem like this?
>
> The actual bug message follows, and the entire compilation output is at
> the end of this message.
>
> BUG MESSAGE:
>
> debugger invoked on a SB-INT:BUG in thread #<THREAD "initial thread" RUNNING
> {AB638D1}>:
> failed AVER: (AND (NULL (TN-READS TN)) (NULL (TN-WRITES TN)))
> This is probably a bug in SBCL itself. (Alternatively, SBCL might have been
> corrupted by bad user code, e.g. by an undefined Lisp operation like
> (FMAKUNBOUND 'COMPILE), or by stray pointers from alien code or from unsafe
> Lisp code; or there might be a bug in the OS or hardware that SBCL is running
> on.) If it seems to be a bug in SBCL itself, the maintainers would like to
> know about it. Bug reports are welcome on the SBCL mailing lists, which you
> can find at <http://sbcl.sourceforge.net/>.
>
> Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.
>
> restarts (invokable by number or by possibly-abbreviated name):
> 0: [TRY-RECOMPILING] Try recompiling requests
> 1: [RETRY ] Retry compiling component ("clx" "requests").
> 2: [ACCEPT ] Continue, treating
> compiling component ("clx" "requests") as having been
> successful.
> 3: [CONTINUE ] Ignore runtime option --load "./make-image.lisp".
> 4: [ABORT ] Skip rest of --eval and --load options.
> 5: Skip to toplevel READ/EVAL/PRINT loop.
> 6: [QUIT ] Quit SBCL (calling #'QUIT, killing the process).
>
> (SB-INT:BUG
> "~@<failed AVER: ~2I~_~A~:>"
> (AND (NULL (SB-C::TN-READS SB-C:TN)) (NULL (SB-C::TN-WRITES SB-C:TN))))
> 0] 6
>
> ; compilation aborted after 0:00:18.588
> ;
> ; compilation unit aborted
> ; caught 2 fatal ERROR conditions
> ; printed 145 notes
> make: *** [stumpwm] Error 1
>
>
> COMPILATION OUTPUT:
>
>
> [/usr/local/src/stumpwmorig]> make clean
> rm -f *.fasl *.fas *.lib *.*fsl
> rm -f *.log *.fns *.fn *.aux *.cp *.ky *.log *.toc *.pg *.tp *.vr *.vrs
> rm -f stumpwm stumpwm.texi stumpwm.info
> [/usr/local/src/stumpwmorig]> git pull
> Already up-to-date.
> [/usr/local/src/stumpwmorig]> autoconf
> [/usr/local/src/stumpwmorig]> ./configure
> checking for sbcl... /usr/bin/sbcl
> checking for clisp... no
> checking for ccl... no
> checking for ecl... no
> configure: Using sbcl at /usr/bin/sbcl
> checking for makeinfo... yes
> checking for xdpyinfo... yes
> configure: creating ./config.status
> config.status: creating Makefile
> configure: creating ./config.status
> config.status: creating Makefile
> config.status: creating make-image.lisp
> configure: creating ./config.status
> config.status: creating Makefile
> config.status: creating make-image.lisp
> config.status: creating version.lisp
> [/usr/local/src/stumpwmorig]> make
> /usr/bin/sbcl --load ./make-image.lisp
> This is SBCL 1.0.45.0.debian, an implementation of ANSI Common Lisp.
> More information about SBCL is available at <http://www.sbcl.org/>.
>
> SBCL is free software, provided as is, with absolutely no warranty.
> It is mostly in the public domain; some portions are provided under
> BSD-style licenses. See the CREDITS and COPYING files in the
> distribution for more information.
> ; Loading system definition from /usr/local/src/stumpwmorig/stumpwm.asd into
> ; #<PACKAGE "ASDF0">
> ; Registering #<SYSTEM :STUMPWM> as STUMPWM
> ; Loading system definition from /usr/lib/sbcl/sb-posix/sb-posix.asd into
> ; #<PACKAGE "ASDF0">
> ; Loading system definition from /usr/lib/sbcl/sb-grovel/sb-grovel.asd into
> ; #<PACKAGE "ASDF1">
> ; Registering #<SYSTEM SB-GROVEL> as SB-GROVEL
> ; Registering #<SYSTEM SB-POSIX> as SB-POSIX
> ; Registering #<SYSTEM SB-POSIX-TESTS> as SB-POSIX-TESTS
> ; Loading system definition from /usr/share/common-lisp/systems/clx.asd into
> ; #<PACKAGE "ASDF0">
> ; Registering #<SYSTEM CLX> as CLX
> ; Loading system definition from
> ; /usr/lib/sbcl/sb-bsd-sockets/sb-bsd-sockets.asd into #<PACKAGE "ASDF0">
> ; Registering #<SYSTEM SB-BSD-SOCKETS> as SB-BSD-SOCKETS
> ; Registering #<SYSTEM SB-BSD-SOCKETS-TESTS> as SB-BSD-SOCKETS-TESTS
> ; Loading system definition from /usr/share/common-lisp/systems/cl-ppcre.asd
> ; into #<PACKAGE "ASDF0">
> ; Registering #<SYSTEM :CL-PPCRE> as CL-PPCRE
> ; Registering #<SYSTEM :CL-PPCRE-TEST> as CL-PPCRE-TEST
> STYLE-WARNING: Couldn't grovel for EAI_ADDRFAMILY (unknown to the C compiler).
>
> ; compiling file "/usr/share/common-lisp/source/clx/requests.lisp" (written
> 28 NOV 2009 09:43:30 AM):
> ; compiling (IN-PACKAGE :XLIB)
> ; compiling (DEFUN CREATE-WINDOW ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN CREATE-WINDOW
> ; (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:WINDOW 'XLIB:WINDOW)
> ; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK LET FUNCALL
> ; --> SB-C::%FUNCALL THE
> ; ==>
> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
> ;
> ; note: unable to
> ; optimize
> ; because:
> ; optimize away possible call to FDEFINITION at runtime
>
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEWINDOW+)
> ; (XLIB::DATA XLIB::DEPTH)
> ; (XLIB:RESOURCE-ID XLIB::WID)
> ; (XLIB:WINDOW XLIB::PARENT)
> ; (XLIB:INT16 XLIB::X XLIB::Y)
> ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH)
> ; ((XLIB::MEMBER16 :COPY :INPUT-OUTPUT :INPUT-ONLY) CLASS)
> ; (XLIB:RESOURCE-ID
> ; (COND ((EQ XLIB::VISUAL :COPY) 0)
> ; ((TYPEP XLIB::VISUAL 'XLIB:RESOURCE-ID) XLIB::VISUAL)
> ; (T (XLIB:VISUAL-INFO-ID XLIB::VISUAL))))
> ; (XLIB::MASK
> ; (XLIB:CARD32 XLIB::BACK-PIXMAP XLIB::BACK-PIXEL XLIB::BORDER-PIXMAP
> ; XLIB::BORDER-PIXEL)
> ; ((XLIB::MEMBER-VECTOR XLIB::+BIT-GRAVITY-VECTOR+) XLIB:BIT-GRAVITY)
> ; ((XLIB::MEMBER-VECTOR XLIB::+WIN-GRAVITY-VECTOR+) XLIB::GRAVITY)
> ; ((MEMBER :NOT-USEFUL :WHEN-MAPPED :ALWAYS) XLIB::BACKING-STORE)
> ; (XLIB:CARD32 XLIB::BACKING-PLANES XLIB::BACKING-PIXEL)
> ; ((MEMBER :OFF :ON) XLIB::OVERRIDE-REDIRECT XLIB::SAVE-UNDER)
> ; (XLIB:CARD32 XLIB:EVENT-MASK XLIB::DO-NOT-PROPAGATE-MASK)
> ; ((OR (MEMBER :COPY) XLIB:COLORMAP) XLIB:COLORMAP)
> ; ((OR (MEMBER :NONE) XLIB:CURSOR) XLIB:CURSOR)))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* LET
> ; --> INCF LET*
> ; ==>
> ; (+ (XLIB::BUFFER-BOFFSET #:TMP131) #:G132)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* LET
> ; --> UNLESS IF PROGN SETQ THE
> ; ==>
> ; (LOGIOR XLIB::%MASK 2)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 4)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 8)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 16)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 32)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 64)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 128)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 256)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 512)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 1024)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 2048)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 4096)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 8192)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; ==>
> ; (LOGIOR XLIB::%MASK 16384)
> ;
> ; note: forced to do static-fun Two-arg-ior (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
> ; (UNSIGNED-BYTE 32)
> ; &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET* LET
> ; --> INCF LET*
> ; ==>
> ; (+ (XLIB::BUFFER-BOFFSET #:TMP131) #:G132)
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST
> T).
> ; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
> ; The first argument is a NUMBER, not a (SIGNED-BYTE 32).
> ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE
> 32)
> ; &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN DESTROY-WINDOW ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN DESTROY-WINDOW
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-DESTROYWINDOW+)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN DESTROY-SUBWINDOWS ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN DESTROY-SUBWINDOWS
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-DESTROYSUBWINDOWS+)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN ADD-TO-SAVE-SET ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN ADD-TO-SAVE-SET
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-CHANGESAVESET+)
> ; (XLIB::DATA 0)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN REMOVE-FROM-SAVE-SET ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN REMOVE-FROM-SAVE-SET
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-CHANGESAVESET+)
> ; (XLIB::DATA 1)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN REPARENT-WINDOW ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN REPARENT-WINDOW
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-REPARENTWINDOW+)
> ; (XLIB:WINDOW XLIB:WINDOW XLIB::PARENT)
> ; (XLIB:INT16 XLIB::X XLIB::Y))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN MAP-WINDOW ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN MAP-WINDOW
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-MAPWINDOW+)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN MAP-SUBWINDOWS ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN MAP-SUBWINDOWS
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-MAPSUBWINDOWS+)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN UNMAP-WINDOW ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN UNMAP-WINDOW
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-UNMAPWINDOW+)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN UNMAP-SUBWINDOWS ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN UNMAP-SUBWINDOWS
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-UNMAPSUBWINDOWS+)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN CIRCULATE-WINDOW-UP ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN CIRCULATE-WINDOW-UP
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-CIRCULATEWINDOW+)
> ; (XLIB::DATA 0)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN CIRCULATE-WINDOW-DOWN ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN CIRCULATE-WINDOW-DOWN
> ; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
> ; XLIB::+X-CIRCULATEWINDOW+)
> ; (XLIB::DATA 1)
> ; (XLIB:WINDOW XLIB:WINDOW))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN QUERY-TREE ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN QUERY-TREE
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-QUERYTREE+
> NIL
> ; :SIZES (8 16 32))
> ; ((XLIB:WINDOW XLIB:WINDOW))
> ; (VALUES (XLIB::WINDOW-GET 8) (XLIB::RESOURCE-ID-GET 12)
> ; (XLIB::SEQUENCE-GET :LENGTH (XLIB::CARD16-GET 16) :RESULT-TYPE
> ; XLIB::RESULT-TYPE :INDEX
> XLIB::+REPLYSIZE+)))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN INTERN-ATOM ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN INTERN-ATOM
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-INTERNATOM+
> 12
> ; :SIZES 32)
> ; ((XLIB::DATA 0) (XLIB:CARD16 (LENGTH STRING)) (XLIB::PAD16 NIL)
> ; (STRING STRING))
> ; (VALUES (XLIB::RESOURCE-ID-GET 8)))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN FIND-ATOM ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN FIND-ATOM
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-INTERNATOM+
> 12
> ; :SIZES 32)
> ; ((XLIB::DATA 1) (XLIB:CARD16 (LENGTH STRING)) (XLIB::PAD16 NIL)
> ; (STRING STRING))
> ; (VALUES (XLIB::OR-GET 8 NULL XLIB:RESOURCE-ID)))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN ATOM-NAME ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN ATOM-NAME
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
> XLIB::+X-GETATOMNAME+ NIL
> ; :SIZES (16))
> ; ((XLIB:RESOURCE-ID XLIB::ATOM-ID))
> ; (VALUES (XLIB::STRING-GET (XLIB::CARD16-GET 8) XLIB::+REPLYSIZE+)))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN LOOKUP-XATOM ...)
> ; compiling (DEFUN CHANGE-PROPERTY ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN CHANGE-PROPERTY
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEPROPERTY+)
> ; ((XLIB::DATA (MEMBER :REPLACE :PREPEND :APPEND)) XLIB::MODE)
> ; (XLIB:WINDOW XLIB:WINDOW)
> ; (XLIB:RESOURCE-ID XLIB::PROPERTY-ID XLIB::TYPE-ID)
> ; (XLIB:CARD8 FORMAT)
> ; (XLIB:CARD32 LENGTH)
> ; (PROGN
> ; (ECASE FORMAT
> ; (8
> ; (XLIB::SEQUENCE-PUT 24 XLIB::DATA :FORMAT XLIB:CARD8 :START
> XLIB::START
> ; :END XLIB::END :TRANSFORM XLIB::TRANSFORM))
> ; (16
> ; (XLIB::SEQUENCE-PUT 24 XLIB::DATA :FORMAT XLIB:CARD16 :START
> ; XLIB::START :END XLIB::END :TRANSFORM
> ; XLIB::TRANSFORM))
> ; (32
> ; (XLIB::SEQUENCE-PUT 24 XLIB::DATA :FORMAT XLIB:CARD32 :START
> ; XLIB::START :END XLIB::END :TRANSFORM
> ; XLIB::TRANSFORM)))))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN DELETE-PROPERTY ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN DELETE-PROPERTY
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-DELETEPROPERTY+)
> ; (XLIB:WINDOW XLIB:WINDOW)
> ; (XLIB:RESOURCE-ID XLIB::PROPERTY-ID))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN GET-PROPERTY ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN GET-PROPERTY
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
> XLIB::+X-GETPROPERTY+ NIL
> ; :SIZES (8 32))
> ; (((XLIB::DATA BOOLEAN) XLIB::DELETE-P) (XLIB:WINDOW XLIB:WINDOW)
> ; (XLIB:RESOURCE-ID XLIB::PROPERTY-ID)
> ; ((OR NULL XLIB:RESOURCE-ID) XLIB::TYPE-ID) (XLIB:CARD32
> XLIB::START)
> ; (XLIB:CARD32 (XLIB::INDEX- (OR XLIB::END 64000) XLIB::START)))
> ; (LET ((XLIB::REPLY-FORMAT (XLIB::CARD8-GET 1))
> ; (XLIB::REPLY-TYPE (XLIB::CARD32-GET 8))
> ; (XLIB::BYTES-AFTER (XLIB::CARD32-GET 12))
> ; (XLIB::NITEMS (XLIB::CARD32-GET 16)))
> ; (VALUES XLIB::REPLY-FORMAT XLIB::REPLY-TYPE XLIB::BYTES-AFTER
> ; (AND (PLUSP XLIB::NITEMS) (ECASE XLIB::REPLY-FORMAT # # #
> #)))))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN ROTATE-PROPERTIES ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN ROTATE-PROPERTIES
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-ROTATEPROPERTIES+)
> ; (XLIB:WINDOW XLIB:WINDOW)
> ; (XLIB:CARD16 LENGTH)
> ; (XLIB:INT16 (- XLIB::DELTA))
> ; ((SEQUENCE :END LENGTH) SEQUENCE))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN LIST-PROPERTIES ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN LIST-PROPERTIES
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
> XLIB::+X-LISTPROPERTIES+
> ; NIL :SIZES 16)
> ; ((XLIB:WINDOW XLIB:WINDOW))
> ; (VALUES
> ; (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH
> ; (XLIB::CARD16-GET 8) :INDEX XLIB::+REPLYSIZE+)))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN SELECTION-OWNER ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN SELECTION-OWNER
> ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
> ; XLIB::+X-GETSELECTIONOWNER+ 12
> :SIZES
> ; 32)
> ; ((XLIB:RESOURCE-ID XLIB::SELECTION-ID))
> ; (VALUES (XLIB::RESOURCE-ID-OR-NIL-GET 8)))
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
> ; --> BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN XLIB::WITH-BUFFER MACROLET
> ; --> LET XLIB::HOLDING-LOCK SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET
> ; --> BLOCK XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
> ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK
> ; --> SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN SET-SELECTION-OWNER ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN SET-SELECTION-OWNER
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETSELECTIONOWNER+)
> ; ((OR NULL XLIB:WINDOW) XLIB::OWNER)
> ; (XLIB:RESOURCE-ID XLIB::SELECTION-ID)
> ; ((OR NULL XLIB:CARD32) TIME))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFSETF SELECTION-OWNER ...)
> ; compiling (DEFUN CONVERT-SELECTION ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN CONVERT-SELECTION
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CONVERTSELECTION+)
> ; (XLIB:WINDOW XLIB::REQUESTOR)
> ; (XLIB:RESOURCE-ID XLIB::SELECTION-ID XLIB::TYPE-ID)
> ; ((OR NULL XLIB:RESOURCE-ID) XLIB::PROPERTY-ID)
> ; ((OR NULL XLIB:CARD32) TIME))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> ; compiling (DEFUN SEND-EVENT ...)
> ; file: /usr/share/common-lisp/source/clx/requests.lisp
> ; in: DEFUN SEND-EVENT
> ; (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE)
> ; XLIB:DISPLAY XLIB::ARGS)
> ; --> MULTIPLE-VALUE-CALL
> ; ==>
> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN
> ; (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE))
> ;
> ; note: unable to
> ; optimize
> ; because:
> ; optimize away possible call to FDEFINITION at runtime
>
> ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SENDEVENT+)
> ; ((XLIB::DATA BOOLEAN) XLIB::PROPAGATE-P)
> ; (LENGTH 11)
> ; ((OR (MEMBER :POINTER-WINDOW :INPUT-FOCUS) XLIB:WINDOW) XLIB:WINDOW)
> ; (XLIB:CARD32 (XLIB::ENCODE-EVENT-MASK XLIB:EVENT-MASK))
> ; (XLIB:CARD8 XLIB::EXTERNAL-EVENT-CODE)
> ; (PROGN
> ; (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE)
> ; XLIB:DISPLAY XLIB::ARGS)
> ; (SETF (XLIB::BUFFER-BOFFSET XLIB:DISPLAY)
> ; (XLIB::INDEX+ XLIB::BUFFER-BOFFSET 44))))
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB 1+
> ; ==>
> ; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a FLOAT.
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
> ;
> ; note: unable to
> ; optimize
> ; due to type uncertainty:
> ; The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
> ;
> ; note: forced to do GENERIC-+ (cost 10)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a NUMBER, not a FIXNUM.
> ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM
> &REST T).
> ; etc.
>
> ; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
> ; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
> ; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
> ; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
> ; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND LET
> ; --> LDB SB-KERNEL:%LDB
> ; ==>
> ; (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
> ;
> ; note: forced to do static-fun Two-arg-and (cost 53)
> ; unable to do inline fixnum arithmetic (cost 1) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; unable to do inline fixnum arithmetic (cost 2) because:
> ; The first argument is a INTEGER, not a FIXNUM.
> ; etc.
>
> debugger invoked on a SB-INT:BUG in thread #<THREAD "initial thread" RUNNING
> {AB638D1}>:
> failed AVER: (AND (NULL (TN-READS TN)) (NULL (TN-WRITES TN)))
> This is probably a bug in SBCL itself. (Alternatively, SBCL might have been
> corrupted by bad user code, e.g. by an undefined Lisp operation like
> (FMAKUNBOUND 'COMPILE), or by stray pointers from alien code or from unsafe
> Lisp code; or there might be a bug in the OS or hardware that SBCL is running
> on.) If it seems to be a bug in SBCL itself, the maintainers would like to
> know about it. Bug reports are welcome on the SBCL mailing lists, which you
> can find at <http://sbcl.sourceforge.net/>.
>
> Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.
>
> restarts (invokable by number or by possibly-abbreviated name):
> 0: [TRY-RECOMPILING] Try recompiling requests
> 1: [RETRY ] Retry compiling component ("clx" "requests").
> 2: [ACCEPT ] Continue, treating
> compiling component ("clx" "requests") as having been
> successful.
> 3: [CONTINUE ] Ignore runtime option --load "./make-image.lisp".
> 4: [ABORT ] Skip rest of --eval and --load options.
> 5: Skip to toplevel READ/EVAL/PRINT loop.
> 6: [QUIT ] Quit SBCL (calling #'QUIT, killing the process).
>
> (SB-INT:BUG
> "~@<failed AVER: ~2I~_~A~:>"
> (AND (NULL (SB-C::TN-READS SB-C:TN)) (NULL (SB-C::TN-WRITES SB-C:TN))))
> 0] 6
>
> ; compilation aborted after 0:00:18.588
> ;
> ; compilation unit aborted
> ; caught 2 fatal ERROR conditions
> ; printed 145 notes
> make: *** [stumpwm] Error 1
> [/usr/local/src/stumpwmorig]>
>
> _______________________________________________
> Stumpwm-devel mailing list
> address@hidden
> https://lists.nongnu.org/mailman/listinfo/stumpwm-devel
>