[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
bug#50268: 28.0.50; Assertion warning during native compilation
|
From: |
Michael Welsh Duggan |
|
Subject: |
bug#50268: 28.0.50; Assertion warning during native compilation |
|
Date: |
Sat, 04 Sep 2021 10:00:54 -0400 |
|
User-agent: |
Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) |
Michael Welsh Duggan <md5i@md5i.com> writes:
> With the included file in the current working directory...
>
> First, byte compile the file:
> emacs -Q -batch --eval '(byte-compile-file "pacproxy.el")'
>
> Then, from
> emacs -Q
>
> M-: (push default-directory load-path) RET
> M-x load-library RET pacproxy RET
>
> For me, this results in the following warning:
>
> Warning (comp): /home/md5i/tmp/tmp/pacproxy.el: Error: Assertion
> failed (and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec)))
I did some more testing on this. I used the following after making the
obvious change to the first line.
(setq pacproxy-directory "/directory/containing/pacproxy")
(native-compile (concat pacproxy-directory "/pacproxy.el"))
The result was the following backtrace:
Debugger entered--Lisp error: (cl-assertion-failed ((and (< idx (comp-vec-end
vec)) (>= idx (comp-vec-beg vec))) nil))
cl--assertion-failed((and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg
vec))))
comp-limplify-lap-inst((byte-constant "DIRECT" . 0))
comp-limplify-block(#s(comp-block-lap :name bb_0 :insns nil :closed nil
:in-edges nil :out-edges nil :idom nil :df #<hash-table eql 0/65
0x158ad8eec809> :post-num nil :final-frame nil :sp 0 :addr 0 :non-ret-insn nil
:no-ret nil))
comp-limplify-function(#s(comp-func-l :name nil :c-name
"F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func
#f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc
"DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0)
(byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks
#<hash-table eq 3/65 0x158ad8ad88f1> :lap-block #<hash-table equal 0/65
0x158ad8ad8911> :edges-h #<hash-table eql 0/65 0x158ad8e0343f> :block-cnt-gen
#f(compiled-function () #<bytecode 0x1f53ba4c3e92>) :edge-cnt-gen
#f(compiled-function () #<bytecode -0xfffe0ac45b3c16c>) :has-non-local nil
:speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :nonrest 0 :rest t)))
#<subr
F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_69>("F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0"
#s(comp-func-l :name nil :c-name
"F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func
#f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc
"DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0)
(byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks
#<hash-table eq 3/65 0x158ad8ad88f1> :lap-block #<hash-table equal 0/65
0x158ad8ad8911> :edges-h #<hash-table eql 0/65 0x158ad8e0343f> :block-cnt-gen
#f(compiled-function () #<bytecode 0x1f53ba4c3e92>) :edge-cnt-gen
#f(compiled-function () #<bytecode -0xfffe0ac45b3c16c>) :has-non-local nil
:speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :nonrest 0 :rest t)))
comp-limplify(nil)
comp--native-compile("~/src/elisp/pacproxy.el" nil nil)
native-compile("~/src/elisp/pacproxy.el")
(progn (native-compile "~/src/elisp/pacproxy.el"))
elisp--eval-last-sexp(t)
eval-last-sexp(t)
eval-print-last-sexp(nil)
funcall-interactively(eval-print-last-sexp nil)
command-execute(eval-print-last-sexp)
I ran again after evaluating comp.el manually, and got the following
expanded backtrace:
Debugger entered--Lisp error: (cl-assertion-failed ((and (< idx (comp-vec-end
vec)) (>= idx (comp-vec-beg vec))) nil))
cl--assertion-failed((and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg
vec))))
(or (and (< idx (progn (or (progn (and (memq (type-of vec)
cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec
vec))) (aref vec 3))) (>= idx (progn (or (progn (and (memq (type-of vec)
cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec
vec))) (aref vec 2)))) (cl--assertion-failed '(and (< idx (comp-vec-end vec))
(>= idx (comp-vec-beg vec)))))
(progn (or (and (< idx (progn (or (progn (and (memq (type-of vec)
cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec
vec))) (aref vec 3))) (>= idx (progn (or (progn (and (memq (type-of vec)
cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec
vec))) (aref vec 2)))) (cl--assertion-failed '(and (< idx (comp-vec-end vec))
(>= idx (comp-vec-beg vec))))) nil)
comp-vec--verify-idx(#s(comp-vec :data #<hash-table eql 1/65 0x158ad87bcbdf>
:beg 0 :end 1) 1)
comp-vec-aref(#s(comp-vec :data #<hash-table eql 1/65 0x158ad87bcbdf> :beg 0
:end 1) 1)
comp-slot-n(1)
comp-slot()
(list 'setimm (comp-slot) val)
(comp-emit (list 'setimm (comp-slot) val))
comp-emit-setimm("DIRECT")
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-setimm arg))
(cond ((eq op 'TAG) (let nil nil (let* ((label-sp insn) (_TAG (if (cdr
label-sp) (car-safe (prog1 label-sp (setq label-sp (cdr label-sp)))) (signal
'wrong-number-of-arguments (list '(_TAG label-num . label-sp) (length
label-sp))))) (label-num (car-safe (prog1 label-sp (setq label-sp (cdr
label-sp)))))) (progn (if label-sp (progn (progn (or (= (1- label-sp) (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass
3))) (cl--assertion-failed '(= (1- label-sp) (comp-limplify-sp comp-pass))))
nil))) (comp-emit-annotation (format "LAP TAG %d" label-num)))))) ((eq op
'byte-stack-ref) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-copy-slot (- (comp-sp) arg 1)))) ((eq op 'byte-varref) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call (comp-call
'symbol-value (make-comp-mvar :constant arg))))) ((eq op 'byte-varset) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'set_internal
(make-comp-mvar :constant arg) (comp-slot+1))))) ((eq op 'byte-varbind) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit (comp-call 'specbind (make-comp-mvar :constant arg)
(comp-slot+1))))) ((eq op 'byte-call) (let nil nil (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) (- arg))))) (comp-emit-set-call (comp-callref 'funcall
(1+ arg) (comp-sp))))) ((eq op 'byte-unbind) (let nil nil (comp-emit (comp-call
'helper_unbind_n (make-comp-mvar :constant arg))))) ((eq op 'byte-pophandler)
(let nil nil (comp-emit '(pop-handler)))) ((eq op 'byte-pushconditioncase) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-handler (cdr (cdr insn)) 'condition-case))) ((eq op 'byte-pushcatch)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-handler (cdr (cdr insn)) 'catcher))) ((eq op 'byte-nth) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nth -1)))
((eq op 'byte-symbolp) (let nil nil (comp-emit-set-call-subr 'symbolp 0))) ((eq
op 'byte-consp) (let nil nil (comp-emit-set-call-subr 'consp 0))) ((eq op
'byte-stringp) (let nil nil (comp-emit-set-call-subr 'stringp 0))) ((eq op
'byte-listp) (let nil nil (comp-emit-set-call-subr 'listp 0))) ((eq op
'byte-eq) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'eq -1))) ((eq op 'byte-memq) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'memq -1))) ((eq op
'byte-not) (let nil nil (comp-emit-set-call (comp-call 'eq (comp-slot-n
(comp-sp)) (make-comp-mvar :constant nil))))) ((eq op 'byte-car) (let nil nil
(comp-emit-set-call-subr 'car 0))) ((eq op 'byte-cdr) (let nil nil
(comp-emit-set-call-subr 'cdr 0))) ((eq op 'byte-cons) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'cons -1))) ((eq op
'byte-list1) (let nil nil (comp-limplify-listn 1))) ((eq op 'byte-list2) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-limplify-listn 2))) ((eq op 'byte-list3) (let nil (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -2)))) (comp-limplify-listn 3))) ((eq op 'byte-list4)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3))))
(comp-limplify-listn 4))) ((eq op 'byte-length) (let nil nil
(comp-emit-set-call-subr 'length 0))) ((eq op 'byte-aref) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'aref -1))) ((eq op
'byte-aset) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2))))
(comp-emit-set-call-subr 'aset -2))) ((eq op 'byte-symbol-value) (let nil nil
(comp-emit-set-call-subr 'symbol-value 0))) ((eq op 'byte-symbol-function) (let
nil nil (comp-emit-set-call-subr 'symbol-function 0))) ((eq op 'byte-set) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'set -1))) ((eq op 'byte-fset) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'fset -1))) ((eq op
'byte-get) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'get -1))) ((eq op 'byte-substring) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'substring
-2))) ((eq op 'byte-concat2) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call (comp-callref 'concat 2 (comp-sp))))) ((eq op
'byte-concat3) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2))))
(comp-emit-set-call (comp-callref 'concat 3 (comp-sp))))) ((eq op
'byte-concat4) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3))))
(comp-emit-set-call (comp-callref 'concat 4 (comp-sp))))) ((eq op 'byte-sub1)
(let nil nil (comp-emit-set-call-subr '1- 0))) ((eq op 'byte-add1) (let nil nil
(comp-emit-set-call-subr '1+ 0))) ((eq op 'byte-eqlsign) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '= -1))) ((eq op
'byte-gtr) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '> -1))) ((eq op 'byte-lss) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '< -1))) ((eq op
'byte-leq) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '<= -1))) ((eq op 'byte-geq) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '>= -1))) ((eq op
'byte-diff) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '- -1))) ((eq op 'byte-negate) (let nil nil
(comp-emit-set-call (comp-call 'negate (comp-slot))))) ((eq op 'byte-plus) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '+ -1))) ((eq op 'byte-max) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'max -1))) ((eq op
'byte-min) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'min -1))) ((eq op 'byte-mult) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '* -1))) ((eq op
'byte-point) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'point 1))) ((eq op 'byte-goto-char) (let nil nil
(comp-emit-set-call-subr 'goto-char 0))) ((eq op 'byte-insert) (let nil nil
(comp-emit-set-call-subr 'insert 0))) ((eq op 'byte-point-max) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point-max
1))) ((eq op 'byte-point-min) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'point-min 1))) ((eq op 'byte-char-after) (let nil nil
(comp-emit-set-call-subr 'char-after 0))) ((eq op 'byte-following-char) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'following-char 1))) ((eq op 'byte-preceding-char)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'preceding-char 1))) ((eq op 'byte-current-column)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'current-column 1))) ((eq op 'byte-indent-to) (let nil
nil (comp-emit-set-call (comp-call 'indent-to (comp-slot) (make-comp-mvar
:constant nil))))) ((eq op 'byte-scan-buffer-OBSOLETE) (let nil (signal
'native-ice (list "unsupported LAP op" '"byte-scan-buffer-OBSOLETE")))) ((eq op
'byte-eolp) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'eolp 1))) ((eq op 'byte-eobp) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'eobp 1))) ((eq op
'byte-bolp) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'bolp 1))) ((eq op 'byte-bobp) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'bobp 1))) ((eq op
'byte-current-buffer) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'current-buffer 1))) ((eq op 'byte-set-buffer) (let
nil nil (comp-emit-set-call-subr 'set-buffer 0))) ((eq op
'byte-save-current-buffer) (let nil nil (comp-emit (comp-call
'record_unwind_current_buffer)))) ((eq op 'byte-set-mark-OBSOLETE) (let nil
(signal 'native-ice (list "unsupported LAP op" '"byte-set-mark-OBSOLETE"))))
((eq op 'byte-interactive-p-OBSOLETE) (let nil (signal 'native-ice (list
"unsupported LAP op" '"byte-interactive-p-OBSOLETE")))) ((eq op
'byte-forward-char) (let nil nil (comp-emit-set-call-subr 'forward-char 0)))
((eq op 'byte-forward-word) (let nil nil (comp-emit-set-call-subr 'forward-word
0))) ((eq op 'byte-skip-chars-forward) (let nil (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-forward
-1))) ((eq op 'byte-skip-chars-backward) (let nil (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-backward
-1))) ((eq op 'byte-forward-line) (let nil nil (comp-emit-set-call-subr
'forward-line 0))) ((eq op 'byte-char-syntax) (let nil nil
(comp-emit-set-call-subr 'char-syntax 0))) ((eq op 'byte-buffer-substring) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'buffer-substring -1))) ((eq op 'byte-delete-region)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'delete-region -1))) ((eq op 'byte-narrow-to-region)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call (comp-call 'narrow-to-region (comp-slot) (comp-slot+1)))))
((eq op 'byte-widen) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call (comp-call 'widen)))) ((eq op 'byte-end-of-line) (let nil
nil (comp-emit-set-call-subr 'end-of-line 0))) ((eq op 'byte-constant2) (let
nil (signal 'native-ice (list "unsupported LAP op" '"byte-constant2")))) ((eq
op 'byte-goto) (let nil nil (comp-emit-uncond-jump (cdr (cdr insn))))) ((eq op
'byte-goto-if-nil) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 0 (cdr (cdr
insn)) nil))) ((eq op 'byte-goto-if-not-nil) (let nil (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1)
(make-comp-mvar :constant nil) 0 (cdr (cdr insn)) t))) ((eq op
'byte-goto-if-nil-else-pop) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 1 (cdr (cdr
insn)) nil))) ((eq op 'byte-goto-if-not-nil-else-pop) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1)
(make-comp-mvar :constant nil) 1 (cdr (cdr insn)) t))) ((eq op 'byte-return)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit (list 'return (comp-slot+1))))) ((eq op 'byte-discard) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) 'pass)) ((eq op 'byte-dup) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-copy-slot (1- (comp-sp))))) ((eq
op 'byte-save-excursion) (let nil nil (comp-emit (comp-call
'record_unwind_protect_excursion)))) ((eq op
'byte-save-window-excursion-OBSOLETE) (let nil (signal 'native-ice (list
"unsupported LAP op" '"byte-save-window-excursion-OBSOLETE")))) ((eq op
'byte-save-restriction) (let nil nil (comp-emit (comp-call
'helper_save_restriction)))) ((eq op 'byte-catch) (let nil (signal 'native-ice
(list "unsupported LAP op" '"byte-catch")))) ((eq op 'byte-unwind-protect) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit (comp-call 'helper_unwind_protect (comp-slot+1))))) ((eq op
'byte-condition-case) (let nil (signal 'native-ice (list "unsupported LAP op"
'"byte-condition-case")))) ((eq op 'byte-temp-output-buffer-setup-OBSOLETE)
(let nil (signal 'native-ice (list "unsupported LAP op"
'"byte-temp-output-buffer-setup-OBSOLETE")))) ((eq op
'byte-temp-output-buffer-show-OBSOLETE) (let nil (signal 'native-ice (list
"unsupported LAP op" '"byte-temp-output-buffer-show-OBSOLETE")))) ((eq op
'byte-unbind-all) (let nil (signal 'native-ice (list "unsupported LAP op"
'"byte-unbind-all")))) ((eq op 'byte-set-marker) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'set-marker -2))) ((eq
op 'byte-match-beginning) (let nil nil (comp-emit-set-call-subr
'match-beginning 0))) ((eq op 'byte-match-end) (let nil nil
(comp-emit-set-call-subr 'match-end 0))) ((eq op 'byte-upcase) (let nil nil
(comp-emit-set-call-subr 'upcase 0))) ((eq op 'byte-downcase) (let nil nil
(comp-emit-set-call-subr 'downcase 0))) ((eq op 'byte-string=) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr
'string-equal -1))) ((eq op 'byte-string<) (let nil (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-lessp -1))) ((eq
op 'byte-equal) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'equal -1))) ((eq op 'byte-nthcdr) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nthcdr -1))) ((eq op
'byte-elt) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'elt -1))) ((eq op 'byte-member) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'member -1))) ((eq op
'byte-assq) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'assq -1))) ((eq op 'byte-nreverse) (let nil nil
(comp-emit-set-call-subr 'nreverse 0))) ((eq op 'byte-setcar) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'setcar
-1))) ((eq op 'byte-setcdr) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'setcdr -1))) ((eq op 'byte-car-safe) (let nil nil
(comp-emit-set-call-subr 'car-safe 0))) ((eq op 'byte-cdr-safe) (let nil nil
(comp-emit-set-call-subr 'cdr-safe 0))) ((eq op 'byte-nconc) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nconc -1)))
((eq op 'byte-quo) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '/ -1))) ((eq op 'byte-rem) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '% -1))) ((eq op
'byte-numberp) (let nil nil (comp-emit-set-call-subr 'numberp 0))) ((eq op
'byte-integerp) (let nil nil (comp-emit-set-call-subr 'integerp 0))) ((eq op
'byte-listN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1
arg))))) (comp-emit-set-call (comp-callref 'list arg (comp-sp))))) ((eq op
'byte-concatN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1
arg))))) (comp-emit-set-call (comp-callref 'concat arg (comp-sp))))) ((eq op
'byte-insertN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1
arg))))) (comp-emit-set-call (comp-callref 'insert arg (comp-sp))))) ((eq op
'byte-stack-set) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-copy-slot (1+ (comp-sp)) (- (comp-sp) arg -1)))) ((eq op
'byte-stack-set2) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(progn (or nil (cl--assertion-failed 'nil)) nil))) ((eq op 'byte-discardN) (let
nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (-
arg))))))) ((eq op 'byte-switch) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2))))
(comp-emit-switch (comp-slot+1) (cl-first (progn (or (progn (and (memq (type-of
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref
comp-pass 2))) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument
(list 'comp-block (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (aref comp-pass 2))))) (aref (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2))
2)))))) ((eq op 'byte-constant) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-setimm arg))) ((eq op 'byte-discardN-preserve-tos) (let nil nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))) (comp-copy-slot (+ arg
(comp-sp))))) (t (let nil (signal 'native-ice (list "unexpected LAP op"
(symbol-name op))))))
(let ((op (car insn)) (arg (if (consp (cdr insn)) (car (cdr insn)) (cdr
insn)))) (cond ((eq op 'TAG) (let nil nil (let* ((label-sp insn) (_TAG (if (cdr
label-sp) (car-safe (prog1 label-sp (setq label-sp (cdr label-sp)))) (signal
'wrong-number-of-arguments (list '(_TAG label-num . label-sp) (length
label-sp))))) (label-num (car-safe (prog1 label-sp (setq label-sp (cdr
label-sp)))))) (progn (if label-sp (progn (progn (or (= (1- label-sp) (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass
3))) (cl--assertion-failed '(= (1- label-sp) (comp-limplify-sp comp-pass))))
nil))) (comp-emit-annotation (format "LAP TAG %d" label-num)))))) ((eq op
'byte-stack-ref) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-copy-slot (- (comp-sp) arg 1)))) ((eq op 'byte-varref) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call (comp-call
'symbol-value (make-comp-mvar :constant arg))))) ((eq op 'byte-varset) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'set_internal
(make-comp-mvar :constant arg) (comp-slot+1))))) ((eq op 'byte-varbind) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit (comp-call 'specbind (make-comp-mvar :constant arg)
(comp-slot+1))))) ((eq op 'byte-call) (let nil nil (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) (- arg))))) (comp-emit-set-call (comp-callref 'funcall
(1+ arg) (comp-sp))))) ((eq op 'byte-unbind) (let nil nil (comp-emit (comp-call
'helper_unbind_n (make-comp-mvar :constant arg))))) ((eq op 'byte-pophandler)
(let nil nil (comp-emit '(pop-handler)))) ((eq op 'byte-pushconditioncase) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-handler (cdr (cdr insn)) 'condition-case))) ((eq op 'byte-pushcatch)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-handler (cdr (cdr insn)) 'catcher))) ((eq op 'byte-nth) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nth -1)))
((eq op 'byte-symbolp) (let nil nil (comp-emit-set-call-subr 'symbolp 0))) ((eq
op 'byte-consp) (let nil nil (comp-emit-set-call-subr 'consp 0))) ((eq op
'byte-stringp) (let nil nil (comp-emit-set-call-subr 'stringp 0))) ((eq op
'byte-listp) (let nil nil (comp-emit-set-call-subr 'listp 0))) ((eq op
'byte-eq) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'eq -1))) ((eq op 'byte-memq) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'memq -1))) ((eq op
'byte-not) (let nil nil (comp-emit-set-call (comp-call 'eq (comp-slot-n
(comp-sp)) (make-comp-mvar :constant nil))))) ((eq op 'byte-car) (let nil nil
(comp-emit-set-call-subr 'car 0))) ((eq op 'byte-cdr) (let nil nil
(comp-emit-set-call-subr 'cdr 0))) ((eq op 'byte-cons) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'cons -1))) ((eq op
'byte-list1) (let nil nil (comp-limplify-listn 1))) ((eq op 'byte-list2) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-limplify-listn 2))) ((eq op 'byte-list3) (let nil (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -2)))) (comp-limplify-listn 3))) ((eq op 'byte-list4)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3))))
(comp-limplify-listn 4))) ((eq op 'byte-length) (let nil nil
(comp-emit-set-call-subr 'length 0))) ((eq op 'byte-aref) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'aref -1))) ((eq op
'byte-aset) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2))))
(comp-emit-set-call-subr 'aset -2))) ((eq op 'byte-symbol-value) (let nil nil
(comp-emit-set-call-subr 'symbol-value 0))) ((eq op 'byte-symbol-function) (let
nil nil (comp-emit-set-call-subr 'symbol-function 0))) ((eq op 'byte-set) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'set -1))) ((eq op 'byte-fset) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'fset -1))) ((eq op
'byte-get) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'get -1))) ((eq op 'byte-substring) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'substring
-2))) ((eq op 'byte-concat2) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call (comp-callref 'concat 2 (comp-sp))))) ((eq op
'byte-concat3) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2))))
(comp-emit-set-call (comp-callref 'concat 3 (comp-sp))))) ((eq op
'byte-concat4) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3))))
(comp-emit-set-call (comp-callref 'concat 4 (comp-sp))))) ((eq op 'byte-sub1)
(let nil nil (comp-emit-set-call-subr '1- 0))) ((eq op 'byte-add1) (let nil nil
(comp-emit-set-call-subr '1+ 0))) ((eq op 'byte-eqlsign) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '= -1))) ((eq op
'byte-gtr) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '> -1))) ((eq op 'byte-lss) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '< -1))) ((eq op
'byte-leq) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '<= -1))) ((eq op 'byte-geq) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '>= -1))) ((eq op
'byte-diff) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '- -1))) ((eq op 'byte-negate) (let nil nil
(comp-emit-set-call (comp-call 'negate (comp-slot))))) ((eq op 'byte-plus) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '+ -1))) ((eq op 'byte-max) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'max -1))) ((eq op
'byte-min) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'min -1))) ((eq op 'byte-mult) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '* -1))) ((eq op
'byte-point) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'point 1))) ((eq op 'byte-goto-char) (let nil nil
(comp-emit-set-call-subr 'goto-char 0))) ((eq op 'byte-insert) (let nil nil
(comp-emit-set-call-subr 'insert 0))) ((eq op 'byte-point-max) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point-max
1))) ((eq op 'byte-point-min) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'point-min 1))) ((eq op 'byte-char-after) (let nil nil
(comp-emit-set-call-subr 'char-after 0))) ((eq op 'byte-following-char) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'following-char 1))) ((eq op 'byte-preceding-char)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'preceding-char 1))) ((eq op 'byte-current-column)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'current-column 1))) ((eq op 'byte-indent-to) (let nil
nil (comp-emit-set-call (comp-call 'indent-to (comp-slot) (make-comp-mvar
:constant nil))))) ((eq op 'byte-scan-buffer-OBSOLETE) (let nil (signal
'native-ice (list "unsupported LAP op" '"byte-scan-buffer-OBSOLETE")))) ((eq op
'byte-eolp) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'eolp 1))) ((eq op 'byte-eobp) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'eobp 1))) ((eq op
'byte-bolp) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'bolp 1))) ((eq op 'byte-bobp) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'bobp 1))) ((eq op
'byte-current-buffer) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call-subr 'current-buffer 1))) ((eq op 'byte-set-buffer) (let
nil nil (comp-emit-set-call-subr 'set-buffer 0))) ((eq op
'byte-save-current-buffer) (let nil nil (comp-emit (comp-call
'record_unwind_current_buffer)))) ((eq op 'byte-set-mark-OBSOLETE) (let nil
(signal 'native-ice (list "unsupported LAP op" '"byte-set-mark-OBSOLETE"))))
((eq op 'byte-interactive-p-OBSOLETE) (let nil (signal 'native-ice (list
"unsupported LAP op" '"byte-interactive-p-OBSOLETE")))) ((eq op
'byte-forward-char) (let nil nil (comp-emit-set-call-subr 'forward-char 0)))
((eq op 'byte-forward-word) (let nil nil (comp-emit-set-call-subr 'forward-word
0))) ((eq op 'byte-skip-chars-forward) (let nil (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-forward
-1))) ((eq op 'byte-skip-chars-backward) (let nil (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-backward
-1))) ((eq op 'byte-forward-line) (let nil nil (comp-emit-set-call-subr
'forward-line 0))) ((eq op 'byte-char-syntax) (let nil nil
(comp-emit-set-call-subr 'char-syntax 0))) ((eq op 'byte-buffer-substring) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'buffer-substring -1))) ((eq op 'byte-delete-region)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'delete-region -1))) ((eq op 'byte-narrow-to-region)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call (comp-call 'narrow-to-region (comp-slot) (comp-slot+1)))))
((eq op 'byte-widen) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-set-call (comp-call 'widen)))) ((eq op 'byte-end-of-line) (let nil
nil (comp-emit-set-call-subr 'end-of-line 0))) ((eq op 'byte-constant2) (let
nil (signal 'native-ice (list "unsupported LAP op" '"byte-constant2")))) ((eq
op 'byte-goto) (let nil nil (comp-emit-uncond-jump (cdr (cdr insn))))) ((eq op
'byte-goto-if-nil) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 0 (cdr (cdr
insn)) nil))) ((eq op 'byte-goto-if-not-nil) (let nil (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1)
(make-comp-mvar :constant nil) 0 (cdr (cdr insn)) t))) ((eq op
'byte-goto-if-nil-else-pop) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 1 (cdr (cdr
insn)) nil))) ((eq op 'byte-goto-if-not-nil-else-pop) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1)
(make-comp-mvar :constant nil) 1 (cdr (cdr insn)) t))) ((eq op 'byte-return)
(let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit (list 'return (comp-slot+1))))) ((eq op 'byte-discard) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) 'pass)) ((eq op 'byte-dup) (let nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-copy-slot (1- (comp-sp))))) ((eq
op 'byte-save-excursion) (let nil nil (comp-emit (comp-call
'record_unwind_protect_excursion)))) ((eq op
'byte-save-window-excursion-OBSOLETE) (let nil (signal 'native-ice (list
"unsupported LAP op" '"byte-save-window-excursion-OBSOLETE")))) ((eq op
'byte-save-restriction) (let nil nil (comp-emit (comp-call
'helper_save_restriction)))) ((eq op 'byte-catch) (let nil (signal 'native-ice
(list "unsupported LAP op" '"byte-catch")))) ((eq op 'byte-unwind-protect) (let
nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit (comp-call 'helper_unwind_protect (comp-slot+1))))) ((eq op
'byte-condition-case) (let nil (signal 'native-ice (list "unsupported LAP op"
'"byte-condition-case")))) ((eq op 'byte-temp-output-buffer-setup-OBSOLETE)
(let nil (signal 'native-ice (list "unsupported LAP op"
'"byte-temp-output-buffer-setup-OBSOLETE")))) ((eq op
'byte-temp-output-buffer-show-OBSOLETE) (let nil (signal 'native-ice (list
"unsupported LAP op" '"byte-temp-output-buffer-show-OBSOLETE")))) ((eq op
'byte-unbind-all) (let nil (signal 'native-ice (list "unsupported LAP op"
'"byte-unbind-all")))) ((eq op 'byte-set-marker) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'set-marker -2))) ((eq
op 'byte-match-beginning) (let nil nil (comp-emit-set-call-subr
'match-beginning 0))) ((eq op 'byte-match-end) (let nil nil
(comp-emit-set-call-subr 'match-end 0))) ((eq op 'byte-upcase) (let nil nil
(comp-emit-set-call-subr 'upcase 0))) ((eq op 'byte-downcase) (let nil nil
(comp-emit-set-call-subr 'downcase 0))) ((eq op 'byte-string=) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr
'string-equal -1))) ((eq op 'byte-string<) (let nil (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-lessp -1))) ((eq
op 'byte-equal) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'equal -1))) ((eq op 'byte-nthcdr) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nthcdr -1))) ((eq op
'byte-elt) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'elt -1))) ((eq op 'byte-member) (let nil (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'member -1))) ((eq op
'byte-assq) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'assq -1))) ((eq op 'byte-nreverse) (let nil nil
(comp-emit-set-call-subr 'nreverse 0))) ((eq op 'byte-setcar) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'setcar
-1))) ((eq op 'byte-setcdr) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr 'setcdr -1))) ((eq op 'byte-car-safe) (let nil nil
(comp-emit-set-call-subr 'car-safe 0))) ((eq op 'byte-cdr-safe) (let nil nil
(comp-emit-set-call-subr 'cdr-safe 0))) ((eq op 'byte-nconc) (let nil (progn
(or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t))
(signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nconc -1)))
((eq op 'byte-quo) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-emit-set-call-subr '/ -1))) ((eq op 'byte-rem) (let nil (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '% -1))) ((eq op
'byte-numberp) (let nil nil (comp-emit-set-call-subr 'numberp 0))) ((eq op
'byte-integerp) (let nil nil (comp-emit-set-call-subr 'integerp 0))) ((eq op
'byte-listN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1
arg))))) (comp-emit-set-call (comp-callref 'list arg (comp-sp))))) ((eq op
'byte-concatN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1
arg))))) (comp-emit-set-call (comp-callref 'concat arg (comp-sp))))) ((eq op
'byte-insertN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1
arg))))) (comp-emit-set-call (comp-callref 'insert arg (comp-sp))))) ((eq op
'byte-stack-set) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(comp-copy-slot (1+ (comp-sp)) (- (comp-sp) arg -1)))) ((eq op
'byte-stack-set2) (let nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1))))
(progn (or nil (cl--assertion-failed 'nil)) nil))) ((eq op 'byte-discardN) (let
nil nil (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (-
arg))))))) ((eq op 'byte-switch) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2))))
(comp-emit-switch (comp-slot+1) (cl-first (progn (or (progn (and (memq (type-of
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref
comp-pass 2))) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument
(list 'comp-block (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (aref comp-pass 2))))) (aref (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2))
2)))))) ((eq op 'byte-constant) (let nil (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1))))
(comp-emit-setimm arg))) ((eq op 'byte-discardN-preserve-tos) (let nil nil
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))) (comp-copy-slot (+ arg
(comp-sp))))) (t (let nil (signal 'native-ice (list "unexpected LAP op"
(symbol-name op)))))))
comp-limplify-lap-inst((byte-constant "DIRECT" . 0))
(progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr
inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if
(consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let*
((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741))
(x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp
(progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1-
label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp)
(comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4))
stack-depth))) (progn (or (progn (and (memq (type-of cl-x)
cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block
cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb)
cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block
bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw
'--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst)))
(and (consp inst-cell) (progn (setq inst (car inst-cell)) (setq next-inst
(car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn
(and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if
(consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let*
((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741))
(x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp
(progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1-
label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp)
(comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4))
stack-depth))) (progn (or (progn (and (memq (type-of cl-x)
cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block
cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb)
cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block
bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw
'--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst))))
(while (and (consp inst-cell) (progn (setq inst (car inst-cell)) (setq
next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or
(progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if
(consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let*
((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741))
(x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp
(progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1-
label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp)
(comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4))
stack-depth))) (progn (or (progn (and (memq (type-of cl-x)
cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block
cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb)
cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block
bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw
'--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst)))) (setq inst-cell
(cdr inst-cell)) (setq --cl-var-- nil))
(let* ((inst-cell (nthcdr (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (aref comp-pass 4)) (progn (or (progn (and (memq
(type-of comp-func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument
(list 'comp-func comp-func))) (aref comp-func 6)))) (inst nil) (next-inst nil)
(--cl-var-- t)) (while (and (consp inst-cell) (progn (setq inst (car
inst-cell)) (setq next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst
inst) (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1))))
(if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740
(car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst)))
(if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let
((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp)
(comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let*
((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x
(comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or
(progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal
'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or
(progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal
'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list
'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p
inst)))) (setq inst-cell (cdr inst-cell)) (setq --cl-var-- nil)) nil)
(catch '--cl-block-nil-- (let* ((inst-cell (nthcdr (progn (or (progn (and
(memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4))
(progn (or (progn (and (memq (type-of comp-func) cl-struct-comp-func-tags) t))
(signal 'wrong-type-argument (list 'comp-func comp-func))) (aref comp-func
6)))) (inst nil) (next-inst nil) (--cl-var-- t)) (while (and (consp inst-cell)
(progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-cell)))
(comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1))))
(if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740
(car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst)))
(if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let
((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp)
(comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let*
((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x
(comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or
(progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal
'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or
(progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal
'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list
'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p
inst)))) (setq inst-cell (cdr inst-cell)) (setq --cl-var-- nil)) nil))
comp-limplify-block(#s(comp-block-lap :name bb_0 :insns nil :closed nil
:in-edges nil :out-edges nil :idom nil :df #<hash-table eql 0/65
0x158ad84a5305> :post-num nil :final-frame nil :sp 0 :addr 0 :non-ret-insn nil
:no-ret nil))
(while (progn (setq next-bb (car-safe (progn (or (progn (and (memq (type-of
comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (prog1 x (aset
v 6 (cdr x))))))) next-bb) (comp-limplify-block next-bb) (setq --cl-var-- nil))
(let* ((next-bb nil) (--cl-var-- t)) (while (progn (setq next-bb (car-safe
(progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags)
t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v
comp-pass) (x (aref v 6))) (prog1 x (aset v 6 (cdr x))))))) next-bb)
(comp-limplify-block next-bb) (setq --cl-var-- nil)) nil)
(let* ((frame-size (progn (or (progn (and (memq (type-of func)
cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument (list 'comp-func
func))) (aref func 8))) (comp-func func) (comp-pass (make-comp-limplify :frame
(comp-new-frame frame-size 0)))) (comp-fill-label-h) (comp-make-curr-block
'entry (comp-sp)) (comp-emit-annotation (concat "Lisp function: " (symbol-name
(progn (or (progn (and (memq (type-of func) cl-struct-comp-func-tags) t))
(signal 'wrong-type-argument (list 'comp-func func))) (aref func 1))))) (if
(progn (and (memq (type-of func) cl-struct-comp-func-l-tags) t)) (progn (let
((args (progn (or (progn (and (memq (type-of func) cl-struct-comp-func-l-tags)
t)) (signal 'wrong-type-argument (list 'comp-func-l func))) (aref func 19))))
(if (progn (and (memq (type-of args) cl-struct-comp-args-tags) t)) (let* ((i 0)
(--cl-var-- (progn (or (progn (and (memq (type-of args)
cl-struct-comp-args-tags) t)) (signal 'wrong-type-argument (list 'comp-args
args))) (aref args 2)))) (while (< i --cl-var--) (progn (or (progn (and (memq
(type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal
'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass))
(aset v 3 (+ (comp-sp) 1)))) (comp-emit (list 'set-par-to-local (comp-slot) i))
(setq i (+ i 1))) nil) (comp-emit-narg-prologue (progn (or (progn (and (memq
(type-of args) cl-struct-comp-args-base-tags) t)) (signal 'wrong-type-argument
(list 'comp-args-base args))) (aref args 1)) (progn (or (progn (and (memq
(type-of args) cl-struct-comp-nargs-tags) t)) (signal 'wrong-type-argument
(list 'comp-nargs args))) (aref args 2)) (progn (or (progn (and (memq (type-of
args) cl-struct-comp-nargs-tags) t)) (signal 'wrong-type-argument (list
'comp-nargs args))) (aref args 3))))))) (comp-emit '(jump bb_0))
(comp-bb-maybe-add 0 (comp-sp)) (let* ((next-bb nil) (--cl-var-- t)) (while
(progn (setq next-bb (car-safe (progn (or (progn (and (memq (type-of comp-pass)
cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list
'comp-limplify comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (prog1 x (aset
v 6 (cdr x))))))) next-bb) (comp-limplify-block next-bb) (setq --cl-var-- nil))
nil) (let* ((addr-h (make-hash-table)) (addr nil) (--cl-var-- t)) (maphash
#'(lambda (--cl-var-- bb) (setq addr (if (progn (and (memq (type-of bb)
cl-struct-comp-block-lap-tags) t)) (progn (progn (or (progn (and (memq (type-of
bb) cl-struct-comp-block-lap-tags) t)) (signal 'wrong-type-argument (list
'comp-block-lap bb))) (aref bb 11))))) (if addr (progn (progn (or (null
(gethash addr addr-h)) (cl--assertion-failed '(null (gethash addr addr-h))))
nil) (puthash addr t addr-h))) (setq --cl-var-- nil)) (progn (or (progn (and
(memq (type-of func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument
(list 'comp-func func))) (aref func 10))) nil) (comp-limplify-finalize-function
func))
comp-limplify-function(#s(comp-func-l :name nil :c-name
"F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func
#f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc
"DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0)
(byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks
#<hash-table eq 3/65 0x158ad8ea2a3d> :lap-block #<hash-table equal 0/65
0x158ad8e035af> :edges-h #<hash-table eql 0/65 0x158ad8eebf5d> :block-cnt-gen
(closure ((n . 0) cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags
cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags
cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags
cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags
cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+
n))) :edge-cnt-gen (closure ((n . -1) cl-struct-comp-edge-tags
cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags
cl-struct-comp-block-lap-tags cl-struct-comp-block-tags
cl-struct-comp-nargs-tags cl-struct-comp-args-tags
cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags
cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+
n))) :has-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0
:nonrest 0 :rest t)))
(closure ((_) cl-struct-comp-limplify-tags cl-struct-comp-mvar-tags
cl-struct-comp-func-d-tags cl-struct-comp-func-l-tags cl-struct-comp-func-tags
cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags
cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags
cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags
cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags
cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) (_ f)
(comp-limplify-function
f))("F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" #s(comp-func-l :name
nil :c-name "F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func
#f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc
"DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0)
(byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks
#<hash-table eq 3/65 0x158ad8ea2a3d> :lap-block #<hash-table equal 0/65
0x158ad8e035af> :edges-h #<hash-table eql 0/65 0x158ad8eebf5d> :block-cnt-gen
(closure ((n . 0) cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags
cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags
cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags
cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags
cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+
n))) :edge-cnt-gen (closure ((n . -1) cl-struct-comp-edge-tags
cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags
cl-struct-comp-block-lap-tags cl-struct-comp-block-tags
cl-struct-comp-nargs-tags cl-struct-comp-args-tags
cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags
cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+
n))) :has-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0
:nonrest 0 :rest t)))
maphash((closure ((_) cl-struct-comp-limplify-tags cl-struct-comp-mvar-tags
cl-struct-comp-func-d-tags cl-struct-comp-func-l-tags cl-struct-comp-func-tags
cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags
cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags
cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags
cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags
cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) (_ f)
(comp-limplify-function f)) #<hash-table equal 7/65 0x158ad8e77251>)
comp-limplify(nil)
funcall(comp-limplify nil)
(setq data (funcall pass data))
(if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running
pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq
report (cons (cons pass (float-time (time-since t0))) report)) (let*
((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp
--cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr
--cl-var--))) nil))
(while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car
--cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format
"(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass
data)) (setq report (cons (cons pass (float-time (time-since t0))) report))
(let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while
(consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var--
(cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var--
nil))
(let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass nil) (--cl-var--
t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car
--cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format
"(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass
data)) (setq report (cons (cons pass (float-time (time-since t0))) report))
(let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while
(consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var--
(cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var--
nil)) (if comp-log-time-report (progn (comp-log (format "Done compiling %s"
data) 0) (let* ((--cl-var-- (reverse report)) (time nil) (pass nil)) (while
(consp --cl-var--) (setq time (car --cl-var--) pass (car-safe (prog1 time (setq
time (cdr time))))) (comp-log (format "Pass %s took: %fs." pass time) 0) (setq
--cl-var-- (cdr --cl-var--))) nil))) nil)
(condition-case err (let* ((report nil) (t0 nil) (--cl-var-- comp-passes)
(pass nil) (--cl-var-- t)) (while (progn (setq t0 (current-time)) (consp
--cl-var--)) (setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes)
(progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2)
(setq data (funcall pass data)) (setq report (cons (cons pass (float-time
(time-since t0))) report)) (let* ((--cl-var-- (alist-get pass
comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car
--cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq
--cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (if comp-log-time-report
(progn (comp-log (format "Done compiling %s" data) 0) (let* ((--cl-var--
(reverse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time
(car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (comp-log
(format "Pass %s took: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--)))
nil))) nil) (native-compiler-skip) (t (let ((err-val (cdr err))) (if (and
comp-async-compilation (not (eq (car err) 'native-compiler-error))) (progn
(message (if err-val "%s: Error: %s %s" "%s: Error %s") function-or-file (get
(car err) 'error-message) (car-safe err-val)) (kill-emacs -1)) (signal (car
err) (if (consp err-val) (cons function-or-file err-val) (list function-or-file
err-val)))))))
(let* ((data function-or-file) (comp-native-compiling t)
(byte-native-qualities nil) (byte-compile-debug t) (comp-ctxt (make-comp-ctxt
:output output :with-late-load with-late-load))) (comp-log "\n\f\n" 1)
(condition-case err (let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass
nil) (--cl-var-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--))
(setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn)
(comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq
data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since
t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f
nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data)
(setq --cl-var-- (cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--))
(setq --cl-var-- nil)) (if comp-log-time-report (progn (comp-log (format "Done
compiling %s" data) 0) (let* ((--cl-var-- (reverse report)) (time nil) (pass
nil)) (while (consp --cl-var--) (setq time (car --cl-var--) pass (car-safe
(prog1 time (setq time (cdr time))))) (comp-log (format "Pass %s took: %fs."
pass time) 0) (setq --cl-var-- (cdr --cl-var--))) nil))) nil)
(native-compiler-skip) (t (let ((err-val (cdr err))) (if (and
comp-async-compilation (not (eq (car err) 'native-compiler-error))) (progn
(message (if err-val "%s: Error: %s %s" "%s: Error %s") function-or-file (get
(car err) 'error-message) (car-safe err-val)) (kill-emacs -1)) (signal (car
err) (if (consp err-val) (cons function-or-file err-val) (list function-or-file
err-val))))))) (if (stringp function-or-file) data (native-elisp-load data)))
(catch 'no-native-compile (let* ((data function-or-file)
(comp-native-compiling t) (byte-native-qualities nil) (byte-compile-debug t)
(comp-ctxt (make-comp-ctxt :output output :with-late-load with-late-load)))
(comp-log "\n\f\n" 1) (condition-case err (let* ((report nil) (t0 nil)
(--cl-var-- comp-passes) (pass nil) (--cl-var-- t)) (while (progn (setq t0
(current-time)) (consp --cl-var--)) (setq pass (car --cl-var--)) (if (memq pass
comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n"
function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons
(cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get
pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car
--cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq
--cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (if comp-log-time-report
(progn (comp-log (format "Done compiling %s" data) 0) (let* ((--cl-var--
(reverse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time
(car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (comp-log
(format "Pass %s took: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--)))
nil))) nil) (native-compiler-skip) (t (let ((err-val (cdr err))) (if (and
comp-async-compilation (not (eq (car err) 'native-compiler-error))) (progn
(message (if err-val "%s: Error: %s %s" "%s: Error %s") function-or-file (get
(car err) 'error-message) (car-safe err-val)) (kill-emacs -1)) (signal (car
err) (if (consp err-val) (cons function-or-file err-val) (list function-or-file
err-val))))))) (if (stringp function-or-file) data (native-elisp-load data))))
comp--native-compile("~/src/elisp/pacproxy.el" nil nil)
native-compile("~/src/elisp/pacproxy.el")
(progn (native-compile "~/src/elisp/pacproxy.el"))
elisp--eval-last-sexp(t)
eval-last-sexp(t)
eval-print-last-sexp(nil)
funcall-interactively(eval-print-last-sexp nil)
command-execute(eval-print-last-sexp)
--
Michael Welsh Duggan
(md5i@md5i.com)
- bug#50268: 28.0.50; Assertion warning during native compilation,
Michael Welsh Duggan <=