From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.io!.POSTED.blaine.gmane.org!not-for-mail From: Michael Welsh Duggan Newsgroups: gmane.emacs.bugs Subject: bug#50268: 28.0.50; Assertion warning during native compilation Date: Sat, 04 Sep 2021 10:00:54 -0400 Message-ID: <87tuj0qw2x.fsf@md5i.com> References: <87sfyrt4df.fsf@md5i.com> Mime-Version: 1.0 Content-Type: text/plain Content-Transfer-Encoding: quoted-printable Injection-Info: ciao.gmane.io; posting-host="blaine.gmane.org:116.202.254.214"; logging-data="38295"; mail-complaints-to="usenet@ciao.gmane.io" User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) To: 50268@debbugs.gnu.org Original-X-From: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane-mx.org@gnu.org Sat Sep 04 16:02:26 2021 Return-path: Envelope-to: geb-bug-gnu-emacs@m.gmane-mx.org Original-Received: from lists.gnu.org ([209.51.188.17]) by ciao.gmane.io with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1mMWFV-0009k3-15 for geb-bug-gnu-emacs@m.gmane-mx.org; Sat, 04 Sep 2021 16:02:25 +0200 Original-Received: from localhost ([::1]:54512 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1mMWFT-00071q-Qe for geb-bug-gnu-emacs@m.gmane-mx.org; Sat, 04 Sep 2021 10:02:23 -0400 Original-Received: from eggs.gnu.org ([2001:470:142:3::10]:57950) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1mMWF8-00071Q-Pv for bug-gnu-emacs@gnu.org; Sat, 04 Sep 2021 10:02:03 -0400 Original-Received: from debbugs.gnu.org ([209.51.188.43]:36784) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1mMWF8-0003i3-He for bug-gnu-emacs@gnu.org; Sat, 04 Sep 2021 10:02:02 -0400 Original-Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1mMWF8-0005oF-Co for bug-gnu-emacs@gnu.org; Sat, 04 Sep 2021 10:02:02 -0400 X-Loop: help-debbugs@gnu.org Resent-From: Michael Welsh Duggan Original-Sender: "Debbugs-submit" Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Sat, 04 Sep 2021 14:02:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 50268 X-GNU-PR-Package: emacs Original-Received: via spool by 50268-submit@debbugs.gnu.org id=B50268.163076406922269 (code B ref 50268); Sat, 04 Sep 2021 14:02:02 +0000 Original-Received: (at 50268) by debbugs.gnu.org; 4 Sep 2021 14:01:09 +0000 Original-Received: from localhost ([127.0.0.1]:48330 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1mMWED-0005n2-V0 for submit@debbugs.gnu.org; Sat, 04 Sep 2021 10:01:09 -0400 Original-Received: from md5i.com ([75.151.244.229]:53036) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1mMWE8-0005mN-Is for 50268@debbugs.gnu.org; Sat, 04 Sep 2021 10:01:04 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=md5i.com; s=dkim; h=Content-Transfer-Encoding:Content-Type:MIME-Version:Message-ID: In-Reply-To:Date:References:Subject:To:From:Sender:Reply-To:Cc:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=w0RCAvgyhoDN+JsPKlwbnCK2ViIBg0eaWpOBl0HVzKc=; b=K0TGtCuIRJ0+razxiM32koZMo4 ShnaCLg2SD7RIItdatFUTL/WPH8m7UZ3DombKsDrf6a9H+L67CJzrL3i7M8X1KeETaAWmvt+EiLmz 2NS6MBY2OM1oHWoj9brUkNeoW; Original-Received: from abode ([192.168.177.1] helo=miko) by md5i.com with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1mMWE2-0036qh-Tq for 50268@debbugs.gnu.org; Sat, 04 Sep 2021 10:00:54 -0400 In-Reply-To: <87sfyrt4df.fsf@md5i.com> (Michael Welsh Duggan's message of "Mon, 30 Aug 2021 10:05:16 -0400") X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list X-BeenThere: bug-gnu-emacs@gnu.org List-Id: "Bug reports for GNU Emacs, the Swiss army knife of text editors" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane-mx.org@gnu.org Original-Sender: "bug-gnu-emacs" Xref: news.gmane.io gmane.emacs.bugs:213420 Archived-At: Michael Welsh Duggan 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=20 > 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)) (>=3D 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-e= nd vec)) (>=3D idx (comp-vec-beg vec))) nil)) cl--assertion-failed((and (< idx (comp-vec-end vec)) (>=3D 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 # :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 "F616e6f6e796d6f7= 5732d6c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&res= t) "DIRECT" #) :doc "DIRECT\n\n(fn &rest)" :in= t-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-return . 0)) :ssa-statu= s nil :frame-size 1 :vframe-size 0 :blocks # :lap-block # :edges-h # :block-cnt-gen #f(compiled-function () #) :edge-cnt-gen #f(compiled-function () #) :has-non-local nil :speed 2 :pure nil :type nil :args #s(com= p-nargs :min 0 :nonrest 0 :rest t))) #("F616e6f6e7= 96d6f75732d6c616d626461_anonymous_lambda_0" #s(comp-func-l :name nil :c-nam= e "F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func #f(comp= iled-function (&rest) "DIRECT" #) :doc "DIRECT= \n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-retu= rn . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks # :lap-block # = :edges-h # :block-cnt-gen #f(compiled-f= unction () #) :edge-cnt-gen #f(compiled-function (= ) #) :has-non-local nil :speed 2 :pure nil :ty= pe 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-e= nd vec)) (>=3D idx (comp-vec-beg vec))) nil)) cl--assertion-failed((and (< idx (comp-vec-end vec)) (>=3D 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 ve= c 3))) (>=3D 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)) (>=3D idx (co= mp-vec-beg vec))))) (progn (or (and (< idx (progn (or (progn (and (memq (type-of vec) cl-stru= ct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec vec))) (= aref vec 3))) (>=3D idx (progn (or (progn (and (memq (type-of vec) cl-struc= t-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec vec))) (a= ref vec 2)))) (cl--assertion-failed '(and (< idx (comp-vec-end vec)) (>=3D = idx (comp-vec-beg vec))))) nil) comp-vec--verify-idx(#s(comp-vec :data # :beg 0 :end 1) 1) comp-vec-aref(#s(comp-vec :data # :be= g 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-p= ass))) (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 la= bel-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 (=3D (1- label-sp) (progn (or (= progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (sig= nal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass = 3))) (cl--assertion-failed '(=3D (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-pas= s) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'co= mp-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 (pro= gn (or (progn (and (memq (type-of comp-pass) cl-struct-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-limplif= y-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-stru= ct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplif= y comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-em= it (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-p= ass) 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 (c= omp-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 'wr= ong-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-pa= ss) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'c= omp-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 (c= omp-emit-set-call-subr 'consp 0))) ((eq op 'byte-stringp) (let nil nil (com= p-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-str= uct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpli= fy comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-e= mit-set-call-subr 'memq -1))) ((eq op 'byte-not) (let nil nil (comp-emit-se= t-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 'b= yte-cons) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-stru= ct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplif= y comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-em= it-set-call-subr 'cons -1))) ((eq op 'byte-list1) (let nil nil (comp-limpli= fy-listn 1))) ((eq op 'byte-list2) (let nil (progn (or (progn (and (memq (t= ype-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-arg= ument (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 (p= rogn (or (progn (and (memq (type-of comp-pass) 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))) ((e= q 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)) (ase= t v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'aref -1))) ((eq op 'byt= e-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-e= mit-set-call-subr 'symbol-value 0))) ((eq op 'byte-symbol-function) (let ni= l nil (comp-emit-set-call-subr 'symbol-function 0))) ((eq op 'byte-set) (le= t nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limpl= ify-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-s= ubr 'set -1))) ((eq op 'byte-fset) (let nil (progn (or (progn (and (memq (t= ype-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-arg= ument (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) (l= et nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limp= lify-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 (m= emq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-ty= pe-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 'b= yte-concat2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-s= truct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limp= lify 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-l= implify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pa= ss))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-ca= ll (comp-callref 'concat 3 (comp-sp))))) ((eq op 'byte-concat4) (let nil (p= rogn (or (progn (and (memq (type-of comp-pass) 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-cal= lref 'concat 4 (comp-sp))))) ((eq op 'byte-sub1) (let nil nil (comp-emit-se= t-call-subr '1- 0))) ((eq op 'byte-add1) (let nil nil (comp-emit-set-call-s= ubr '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-ar= gument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+= (comp-sp) -1)))) (comp-emit-set-call-subr '=3D -1))) ((eq op 'byte-gtr) (l= et nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limp= lify-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 (typ= e-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argum= ent (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (c= omp-sp) -1)))) (comp-emit-set-call-subr '< -1))) ((eq op 'byte-leq) (let ni= l (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-= tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (l= et* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr = '<=3D -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-argumen= t (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (com= p-sp) -1)))) (comp-emit-set-call-subr '>=3D -1))) ((eq op 'byte-diff) (let = nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplif= y-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-sub= r '- -1))) ((eq op 'byte-negate) (let nil nil (comp-emit-set-call (comp-cal= l 'negate (comp-slot))))) ((eq op 'byte-plus) (let nil (progn (or (progn (a= nd (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wro= ng-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (a= set 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-c= omp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify co= mp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-s= et-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-c= omp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify co= mp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-s= et-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 'b= yte-insert) (let nil nil (comp-emit-set-call-subr 'insert 0))) ((eq op 'byt= e-point-max) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-s= truct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limp= lify 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-mi= n 1))) ((eq op 'byte-char-after) (let nil nil (comp-emit-set-call-subr 'cha= r-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 com= p-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (lis= t '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-c= olumn) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-= comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify c= omp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-s= et-call-subr 'current-column 1))) ((eq op 'byte-indent-to) (let nil nil (co= mp-emit-set-call (comp-call 'indent-to (comp-slot) (make-comp-mvar :constan= t 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-c= omp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify co= mp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-se= t-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-b= olp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-co= mp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify com= p-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-t= ype-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-cu= rrent-buffer) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-= struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-lim= plify 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-b= uffer) (let nil nil (comp-emit (comp-call 'record_unwind_current_buffer))))= ((eq op 'byte-set-mark-OBSOLETE) (let nil (signal 'native-ice (list "unsup= ported LAP op" '"byte-set-mark-OBSOLETE")))) ((eq op 'byte-interactive-p-OB= SOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-inte= ractive-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-forwar= d) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-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-limpli= fy-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-su= br 'skip-chars-backward -1))) ((eq op 'byte-forward-line) (let nil nil (com= p-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-substr= ing) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-co= mp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify com= p-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-se= t-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-tag= s) 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 'de= lete-region -1))) ((eq op 'byte-narrow-to-region) (let nil (progn (or (prog= n (and (memq (type-of comp-pass) cl-struct-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-r= egion (comp-slot) (comp-slot+1))))) ((eq op 'byte-widen) (let nil (progn (o= r (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (= signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v com= p-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 "u= nsupported 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 n= il (progn (or (progn (and (memq (type-of comp-pass) cl-struct-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 (co= mp-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 (o= r (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (= signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v com= p-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-pa= ss) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'c= omp-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 (me= mq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-typ= e-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 'b= yte-discard) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-s= truct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limp= lify 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-p= ass) cl-struct-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 'by= te-save-window-excursion-OBSOLETE) (let nil (signal 'native-ice (list "unsu= pported LAP op" '"byte-save-window-excursion-OBSOLETE")))) ((eq op 'byte-sa= ve-restriction) (let nil nil (comp-emit (comp-call 'helper_save_restriction= )))) ((eq op 'byte-catch) (let nil (signal 'native-ice (list "unsupported L= AP 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)) (si= gnal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-= pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'helper_unwind_p= rotect (comp-slot+1))))) ((eq op 'byte-condition-case) (let nil (signal 'na= tive-ice (list "unsupported LAP op" '"byte-condition-case")))) ((eq op 'byt= e-temp-output-buffer-setup-OBSOLETE) (let nil (signal 'native-ice (list "un= supported LAP op" '"byte-temp-output-buffer-setup-OBSOLETE")))) ((eq op 'by= te-temp-output-buffer-show-OBSOLETE) (let nil (signal 'native-ice (list "un= supported LAP op" '"byte-temp-output-buffer-show-OBSOLETE")))) ((eq op 'byt= e-unbind-all) (let nil (signal 'native-ice (list "unsupported LAP op" '"byt= e-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)) (ase= t v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'set-marker -2))) ((eq o= p 'byte-match-beginning) (let nil nil (comp-emit-set-call-subr 'match-begin= ning 0))) ((eq op 'byte-match-end) (let nil nil (comp-emit-set-call-subr 'm= atch-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=3D) (let nil (progn (or (progn (and (mem= q (type-of comp-pass) cl-struct-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-lim= plify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (com= p-emit-set-call-subr 'string-lessp -1))) ((eq op 'byte-equal) (let nil (pro= gn (or (progn (and (memq (type-of comp-pass) cl-struct-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 n= il (progn (or (progn (and (memq (type-of comp-pass) cl-struct-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 (ty= pe-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argu= ment (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-li= mplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pas= s))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-cal= l-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 'by= te-setcdr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-str= uct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpli= fy comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-e= mit-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 (com= p-emit-set-call-subr 'cdr-safe 0))) ((eq op 'byte-nconc) (let nil (progn (o= r (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (= signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v com= p-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-pa= ss) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'c= omp-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)) (s= ignal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp= -pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '% -1))) ((e= q op 'byte-numberp) (let nil nil (comp-emit-set-call-subr 'numberp 0))) ((e= q 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))))) ((e= q 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-s= tack-set2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-str= uct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpli= fy 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 ni= l nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limpl= ify-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 (prog= n (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t= )) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref com= p-pass 2))) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (li= st 'comp-block (progn (or (progn (and (memq (type-of comp-pass) cl-struct-c= omp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify co= mp-pass))) (aref comp-pass 2))))) (aref (progn (or (progn (and (memq (type-= of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argumen= t (list 'comp-limplify comp-pass))) (aref comp-pass 2)) 2)))))) ((eq op 'by= te-constant) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-s= truct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limp= lify 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 i= nsn)))) (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)))) (s= ignal 'wrong-number-of-arguments (list '(_TAG label-num . label-sp) (length= label-sp))))) (label-num (car-safe (prog1 label-sp (setq label-sp (cdr lab= el-sp)))))) (progn (if label-sp (progn (progn (or (=3D (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 '(=3D (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 co= mp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (li= st '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 ni= l (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-= tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (l= et* ((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-l= implify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pa= ss))) (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) c= l-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-l= implify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (c= omp-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-s= p) (- arg))))) (comp-emit-set-call (comp-callref 'funcall (1+ arg) (comp-sp= ))))) ((eq op 'byte-unbind) (let nil nil (comp-emit (comp-call 'helper_unbi= nd_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-ta= gs) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let= * ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-handler (cdr (cd= r insn)) 'condition-case))) ((eq op 'byte-pushcatch) (let nil (progn (or (p= rogn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (sign= al 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pa= ss)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-handler (cdr (cdr insn)) 'cat= cher))) ((eq op 'byte-nth) (let nil (progn (or (progn (and (memq (type-of c= omp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (l= ist '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 ni= l 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 ni= l (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)) (si= gnal '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))) ((e= q 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-e= mit-set-call (comp-call 'eq (comp-slot-n (comp-sp)) (make-comp-mvar :consta= nt 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) c= l-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-l= implify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (c= omp-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 (m= emq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-ty= pe-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-limplif= y-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-em= it-set-call-subr 'length 0))) ((eq op 'byte-aref) (let nil (progn (or (prog= n (and (memq (type-of comp-pass) cl-struct-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 o= p '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-lim= plify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (com= p-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-se= t) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-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 (m= emq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-ty= pe-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-g= et) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-com= p-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 'wr= ong-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 'com= p-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-co= ncat3) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-= comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify c= omp-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-limplif= y-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 (co= mp-callref 'concat 4 (comp-sp))))) ((eq op 'byte-sub1) (let nil nil (comp-e= mit-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-t= ype-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset = v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '=3D -1))) ((eq op 'byte-g= tr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-com= p-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 (mem= q (type-of comp-pass) cl-struct-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-lim= plify-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 '<=3D -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-a= rgument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (= + (comp-sp) -1)))) (comp-emit-set-call-subr '>=3D -1))) ((eq op 'byte-diff)= (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-l= implify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pa= ss))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-ca= ll-subr '- -1))) ((eq op 'byte-negate) (let nil nil (comp-emit-set-call (co= mp-call 'negate (comp-slot))))) ((eq op 'byte-plus) (let nil (progn (or (pr= ogn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signa= l 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pas= s)) (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-st= ruct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpl= ify 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-st= ruct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpl= ify 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 o= p '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 'com= p-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-ta= gs) 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 'po= int-min 1))) ((eq op 'byte-char-after) (let nil nil (comp-emit-set-call-sub= r '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-argumen= t (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (com= p-sp) 1)))) (comp-emit-set-call-subr 'preceding-char 1))) ((eq op 'byte-cur= rent-column) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-s= truct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limp= lify 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 n= il (comp-emit-set-call (comp-call 'indent-to (comp-slot) (make-comp-mvar :c= onstant nil))))) ((eq op 'byte-scan-buffer-OBSOLETE) (let nil (signal 'nati= ve-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-st= ruct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpl= ify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-e= mit-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-str= uct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpli= fy comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-em= it-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 'w= rong-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 'b= yte-current-buffer) (let nil (progn (or (progn (and (memq (type-of comp-pas= s) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'co= mp-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) (l= et nil nil (comp-emit-set-call-subr 'set-buffer 0))) ((eq op 'byte-save-cur= rent-buffer) (let nil nil (comp-emit (comp-call 'record_unwind_current_buff= er)))) ((eq op 'byte-set-mark-OBSOLETE) (let nil (signal 'native-ice (list = "unsupported LAP op" '"byte-set-mark-OBSOLETE")))) ((eq op 'byte-interactiv= e-p-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byt= e-interactive-p-OBSOLETE")))) ((eq op 'byte-forward-char) (let nil nil (com= p-emit-set-call-subr 'forward-char 0))) ((eq op 'byte-forward-word) (let ni= l 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-struc= t-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify= comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emi= t-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-p= ass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-c= all-subr 'skip-chars-backward -1))) ((eq op 'byte-forward-line) (let nil ni= l (comp-emit-set-call-subr 'forward-line 0))) ((eq op 'byte-char-syntax) (l= et 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-str= uct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpli= fy comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-e= mit-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-limpli= fy-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-su= br '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)) (s= ignal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp= -pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call (comp-call 'narro= w-to-region (comp-slot) (comp-slot+1))))) ((eq op 'byte-widen) (let nil (pr= ogn (or (progn (and (memq (type-of comp-pass) cl-struct-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 (l= ist "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-li= mplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pas= s))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-ju= mp (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-o= f comp-pass) cl-struct-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 ni= l) 0 (cdr (cdr insn)) t))) ((eq op 'byte-goto-if-nil-else-pop) (let nil (pr= ogn (or (progn (and (memq (type-of comp-pass) cl-struct-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-slo= t+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 c= omp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (l= ist '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 (a= nd (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wro= ng-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (a= set 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 'com= p-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-s= p) 1)))) (comp-copy-slot (1- (comp-sp))))) ((eq op 'byte-save-excursion) (l= et 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 'b= yte-save-restriction) (let nil nil (comp-emit (comp-call 'helper_save_restr= iction)))) ((eq op 'byte-catch) (let nil (signal 'native-ice (list "unsuppo= rted LAP op" '"byte-catch")))) ((eq op 'byte-unwind-protect) (let nil (prog= n (or (progn (and (memq (type-of comp-pass) cl-struct-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_un= wind_protect (comp-slot+1))))) ((eq op 'byte-condition-case) (let nil (sign= al 'native-ice (list "unsupported LAP op" '"byte-condition-case")))) ((eq o= p 'byte-temp-output-buffer-setup-OBSOLETE) (let nil (signal 'native-ice (li= st "unsupported LAP op" '"byte-temp-output-buffer-setup-OBSOLETE")))) ((eq = op 'byte-temp-output-buffer-show-OBSOLETE) (let nil (signal 'native-ice (li= st "unsupported LAP op" '"byte-temp-output-buffer-show-OBSOLETE")))) ((eq o= p 'byte-unbind-all) (let nil (signal 'native-ice (list "unsupported LAP op"= '"byte-unbind-all")))) ((eq op 'byte-set-marker) (let nil (progn (or (prog= n (and (memq (type-of comp-pass) 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-s= ubr '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=3D) (let nil (progn (or (progn (an= d (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wron= g-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (as= et v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-equal -1))) ((e= q op 'byte-string<) (let nil (progn (or (progn (and (memq (type-of comp-pas= s) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'co= mp-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 ni= l (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-= tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (l= et* ((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 (t= ype-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-arg= ument (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-li= mplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pas= s))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-cal= l-subr 'elt -1))) ((eq op 'byte-member) (let nil (progn (or (progn (and (me= mq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-typ= e-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-c= omp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify co= mp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-s= et-call-subr 'assq -1))) ((eq op 'byte-nreverse) (let nil nil (comp-emit-se= t-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 ni= l (comp-emit-set-call-subr 'cdr-safe 0))) ((eq op 'byte-nconc) (let nil (pr= ogn (or (progn (and (memq (type-of comp-pass) cl-struct-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 'ncon= c -1))) ((eq op 'byte-quo) (let nil (progn (or (progn (and (memq (type-of c= omp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (l= ist '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 (pro= gn (or (progn (and (memq (type-of comp-pass) cl-struct-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-o= f comp-pass) cl-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-o= f comp-pass) cl-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-lim= plify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (com= p-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-t= ags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (ar= ef comp-pass 2))) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argume= nt (list 'comp-block (progn (or (progn (and (memq (type-of comp-pass) cl-st= ruct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpl= ify 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-a= rgument (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 'com= p-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-ta= gs) 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" (s= ymbol-name op))))))) comp-limplify-lap-inst((byte-constant "DIRECT" . 0)) (progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-ce= ll))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of c= omp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (l= ist '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) (l= et* ((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-saf= e x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (= or (=3D (1- label-sp) (comp-sp)) (cl--assertion-failed '(=3D (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 (t= ype-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-arg= ument (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))))) (i= f (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 (prog= n (and (memq (type-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-saf= e x741)) (x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if l= abel-sp (progn (progn (or (=3D (1- label-sp) (comp-sp)) (cl--assertion-fail= ed '(=3D (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-p= ass 4)) stack-depth))) (progn (or (progn (and (memq (type-of cl-x) cl-struc= t-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-struc= t-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 ne= xt-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (o= r (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (= signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v com= p-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 x74= 0 '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 (=3D (1- label-sp) (comp-sp)) (cl--asserti= on-failed '(=3D (1- label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if l= abel-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-tag= s) 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) c= l-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-bloc= k cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb) c= l-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-bloc= k bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw '--cl-bl= ock-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 'com= p-limplify comp-pass))) (aref comp-pass 4)) (progn (or (progn (and (memq (t= ype-of comp-func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argumen= t (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-p= ass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fa= ll-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 x= 742) (label-sp x743)) (if label-sp (progn (progn (or (=3D (1- label-sp) (co= mp-sp)) (cl--assertion-failed '(=3D (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-stru= ct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplif= y comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or (progn (and (m= emq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argum= ent (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-argum= ent (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)) (s= ignal '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-ce= ll))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of c= omp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (l= ist '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) (l= et* ((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-saf= e x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (= or (=3D (1- label-sp) (comp-sp)) (cl--assertion-failed '(=3D (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 (t= ype-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-arg= ument (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))))) (i= f (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-- n= il)) nil)) comp-limplify-block(#s(comp-block-lap :name bb_0 :insns nil :closed nil := in-edges nil :out-edges nil :idom nil :df # :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-argumen= t (list 'comp-limplify comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (p= rog1 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-saf= e (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-= tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (l= et* ((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 'entr= y (comp-sp)) (comp-emit-annotation (concat "Lisp function: " (symbol-name (= progn (or (progn (and (memq (type-of func) cl-struct-comp-func-tags) t)) (s= ignal '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-t= ags) 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-str= uct-comp-args-tags) t)) (signal 'wrong-type-argument (list 'comp-args args)= )) (aref args 2)))) (while (< i --cl-var--) (progn (or (progn (and (memq (t= ype-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-arg= ument (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 (l= ist 'comp-args-base args))) (aref args 1)) (progn (or (progn (and (memq (ty= pe-of args) cl-struct-comp-nargs-tags) t)) (signal 'wrong-type-argument (li= st '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 'c= omp-nargs args))) (aref args 3))))))) (comp-emit '(jump bb_0)) (comp-bb-may= be-add 0 (comp-sp)) (let* ((next-bb nil) (--cl-var-- t)) (while (progn (set= q next-bb (car-safe (progn (or (progn (and (memq (type-of comp-pass) cl-str= uct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limpli= fy comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (prog1 x (aset v 6 (cd= r x))))))) next-bb) (comp-limplify-block next-bb) (setq --cl-var-- nil)) ni= l) (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-st= ruct-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 (get= hash addr addr-h)) (cl--assertion-failed '(null (gethash addr addr-h)))) ni= l) (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-argu= ment (list 'comp-func func))) (aref func 10))) nil) (comp-limplify-finalize= -function func)) comp-limplify-function(#s(comp-func-l :name nil :c-name "F616e6f6e796d6f7= 5732d6c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&res= t) "DIRECT" #) :doc "DIRECT\n\n(fn &rest)" :in= t-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-return . 0)) :ssa-statu= s nil :frame-size 1 :vframe-size 0 :blocks # :lap-block # :edges-h # :block-cnt-gen (closure ((n . 0) cl-struct-comp= -edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-stru= ct-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 (set= q n (1+ n))) :edge-cnt-gen (closure ((n . -1) cl-struct-comp-edge-tags cl-s= truct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-l= ap-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))) :h= as-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :n= onrest 0 :rest t))) (closure ((_) cl-struct-comp-limplify-tags cl-struct-comp-mvar-tags cl-st= ruct-comp-func-d-tags cl-struct-comp-func-l-tags cl-struct-comp-func-tags c= l-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-com= p-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-stru= ct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tag= s t) (_ f) (comp-limplify-function f))("F616e6f6e796d6f75732d6c616d626461_a= nonymous_lambda_0" #s(comp-func-l :name nil :c-name "F616e6f6e796d6f75732d6= c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&rest) "DI= RECT" #) :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 # := lap-block # :edges-h # :block-cnt-gen (closure ((n . 0) cl-struct-comp-edge-= tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-com= p-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-str= uct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags c= l-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-tag= s cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-t= ags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-d= ata-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-ta= gs cl-struct-comp-func-d-tags cl-struct-comp-func-l-tags cl-struct-comp-fun= c-tags cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-co= mp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-st= ruct-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)) #) comp-limplify(nil) funcall(comp-limplify nil) (setq data (funcall pass data)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Runn= ing 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 (ca= r --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (form= at "(%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))) rep= ort)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (w= hile (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-va= r-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pa= ss (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 (fu= ncall pass data)) (setq report (cons (cons pass (float-time (time-since t0)= )) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f ni= l)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (s= etq --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 "D= one 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-passe= s) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pas= s) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-= time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-pos= t-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 (an= d comp-async-compilation (not (eq (car err) 'native-compiler-error))) (prog= n (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 functi= on-or-file err-val))))))) (let* ((data function-or-file) (comp-native-compiling t) (byte-native-qua= lities nil) (byte-compile-debug t) (comp-ctxt (make-comp-ctxt :output outpu= t :with-late-load with-late-load))) (comp-log "\n\f\n" 1) (condition-case e= rr (let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass nil) (--cl-v= ar-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq p= ass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-lo= g (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (f= uncall pass data)) (setq report (cons (cons pass (float-time (time-since t0= ))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f n= il)) (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 (ca= r-safe (prog1 time (setq time (cdr time))))) (comp-log (format "Pass %s too= k: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--))) nil))) nil) (nat= ive-compiler-skip) (t (let ((err-val (cdr err))) (if (and comp-async-compil= ation (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) 'err= or-message) (car-safe err-val)) (kill-emacs -1)) (signal (car err) (if (con= sp 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-com= piling t) (byte-native-qualities nil) (byte-compile-debug t) (comp-ctxt (ma= ke-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-disable= d-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-f= ile pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass = (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass c= omp-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-- (r= everse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time= (car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (com= p-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-o= r-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 (nativ= e-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) --=20 Michael Welsh Duggan (md5i@md5i.com)