Subject: bug#50268: 28.0.50; Assertion warning during native compilation

From: Michael Welsh Duggan <[email-masked]>
Date: Sat, 04 Sep 2021 10:00:54 -0400

Michael Welsh Duggan <[email-masked]> 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
([email-masked])