* bug#50720: unnamed &rest broken @ 2021-09-21 11:15 Mattias Engdegård 2021-09-21 16:11 ` bug#50720: bug#50268: 28.0.50; Assertion warning during native compilation Lars Ingebrigtsen 0 siblings, 1 reply; 22+ messages in thread From: Mattias Engdegård @ 2021-09-21 11:15 UTC (permalink / raw) To: 50720 The interpreter and compiler allow &rest to be used without a variable name following but the generated byte code is completely broken: (funcall (byte-compile (lambda (&rest) 'ta))) crashes, and (defun boo (a &rest) (if a a (list 1 2 3 4))) (boo 'hiss) => hiss ; interpreted => (1 2 3 4) ; compiled The reason is that the compiler generates code from the argument variable list but the byte-code interpreter will only look at the signature code which was generated from the actual signature: (byte-compile (lambda (&rest) 'ta)) => #[128 "\300\207" [ta] 1 "..."] The 128 indicates zero positional parameters and a &rest argument, and the 1 is the maximum stack size required which is wrong; 2 stack slots are needed and that's what we get if naming the argument: (byte-compile (lambda (&rest _r) 'ta)) => #[128 "\300\207" [ta] 2 "..."] In the `boo` case above, it is clear that the compiler doesn't expect any &rest param to have been pushed at all so the stack offsets are wrong. Now, either we fix this bug or we stop pretending that unnamed &rest arguments work at all and signal an error, because it's clear from the above that they can't have seen much use. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50720: bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 11:15 bug#50720: unnamed &rest broken Mattias Engdegård @ 2021-09-21 16:11 ` Lars Ingebrigtsen 2021-09-21 16:22 ` Mattias Engdegård 2021-09-21 16:26 ` Eli Zaretskii 0 siblings, 2 replies; 22+ messages in thread From: Lars Ingebrigtsen @ 2021-09-21 16:11 UTC (permalink / raw) To: Mattias Engdegård; +Cc: 50720, 50268 Mattias Engdegård <mattiase@acm.org> writes: > Now, either we fix this bug or we stop pretending that unnamed &rest > arguments work at all and signal an error, because it's clear from the > above that they can't have seen much use. I did a quick grep through core and GNU ELPA, and I couldn't find any instances of it being used, so I'd be fine with either solution (i.e., either fixing the bug or signalling an error). Perhaps Eli has an opinion (added to the CCs). -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 16:11 ` bug#50720: bug#50268: 28.0.50; Assertion warning during native compilation Lars Ingebrigtsen @ 2021-09-21 16:22 ` Mattias Engdegård 2021-09-21 17:09 ` Noam Postavsky 2021-09-21 16:26 ` Eli Zaretskii 1 sibling, 1 reply; 22+ messages in thread From: Mattias Engdegård @ 2021-09-21 16:22 UTC (permalink / raw) To: Lars Ingebrigtsen; +Cc: 50720, Noam Postavsky, 50268 21 sep. 2021 kl. 18.11 skrev Lars Ingebrigtsen <larsi@gnus.org>: > I did a quick grep through core and GNU ELPA, and I couldn't find any > instances of it being used, so I'd be fine with either solution (i.e., > either fixing the bug or signalling an error). I know how to fix it but there's no really elegant way of doing it, and unless a convincing case can be made for permitting anonymous &rest, I'd favour disallowing it. Unless I'm mistaken it was Noam who added it (1d47d777ef24c0be9153b0a1c8ba21918fa1025a), so let's ask him. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 16:22 ` Mattias Engdegård @ 2021-09-21 17:09 ` Noam Postavsky 2021-09-21 17:53 ` Eli Zaretskii 0 siblings, 1 reply; 22+ messages in thread From: Noam Postavsky @ 2021-09-21 17:09 UTC (permalink / raw) To: Mattias Engdegård; +Cc: Lars Ingebrigtsen, 50268 Mattias Engdegård <mattiase@acm.org> writes: > 21 sep. 2021 kl. 18.11 skrev Lars Ingebrigtsen <larsi@gnus.org>: > >> I did a quick grep through core and GNU ELPA, and I couldn't find any >> instances of it being used, so I'd be fine with either solution (i.e., >> either fixing the bug or signalling an error). > > I know how to fix it but there's no really elegant way of doing it, > and unless a convincing case can be made for permitting anonymous > &rest, I'd favour disallowing it. > > Unless I'm mistaken it was Noam who added it > (1d47d777ef24c0be9153b0a1c8ba21918fa1025a), so let's ask him. It's been a while, but looking at Bug#29165, the reason I added it is that it was supported in Emacs 25 and earlier. Stefan M had some justifications there for &optional without variables, but I think they don't apply for &rest. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 17:09 ` Noam Postavsky @ 2021-09-21 17:53 ` Eli Zaretskii 2021-09-21 19:32 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 22+ messages in thread From: Eli Zaretskii @ 2021-09-21 17:53 UTC (permalink / raw) To: Noam Postavsky, Stefan Monnier; +Cc: mattiase, larsi, 50268 > From: Noam Postavsky <npostavs@gmail.com> > Cc: Lars Ingebrigtsen <larsi@gnus.org>, Eli Zaretskii <eliz@gnu.org>, 50268@debbugs.gnu.org > Date: Tue, 21 Sep 2021 13:09:24 -0400 > > Mattias Engdegård <mattiase@acm.org> writes: > > > 21 sep. 2021 kl. 18.11 skrev Lars Ingebrigtsen <larsi@gnus.org>: > > > >> I did a quick grep through core and GNU ELPA, and I couldn't find any > >> instances of it being used, so I'd be fine with either solution (i.e., > >> either fixing the bug or signalling an error). > > > > I know how to fix it but there's no really elegant way of doing it, > > and unless a convincing case can be made for permitting anonymous > > &rest, I'd favour disallowing it. > > > > Unless I'm mistaken it was Noam who added it > > (1d47d777ef24c0be9153b0a1c8ba21918fa1025a), so let's ask him. > > It's been a while, but looking at Bug#29165, the reason I added it is > that it was supported in Emacs 25 and earlier. Stefan M had some > justifications there for &optional without variables, but I think they > don't apply for &rest. Stefan, can you please chime in? ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 17:53 ` Eli Zaretskii @ 2021-09-21 19:32 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-22 5:43 ` Eli Zaretskii 0 siblings, 1 reply; 22+ messages in thread From: Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 19:32 UTC (permalink / raw) To: Eli Zaretskii; +Cc: mattiase, larsi, Noam Postavsky, 50268 >> It's been a while, but looking at Bug#29165, the reason I added it is >> that it was supported in Emacs 25 and earlier. Stefan M had some >> justifications there for &optional without variables, but I think they >> don't apply for &rest. > Stefan, can you please chime in? With my type-systems-guy hat on, I'd say we want to detect those `&rest` without a following variable and shame the author of the code. But at the same time we could think of `&rest` as something similar to `&optional` and decide that it can be handy for generated code to be able to generate (x y &optional z &rest). The main difference I see is that `(x y &optional ,@args) makes a lot of sense and will naturally occasionally lead to `&optional` not followed by anything, whereas `&rest` only expects 1 following identifier so it seems much less likely that the code will sometimes put 0 vars in there. After all, we do signal an error if there's more than 1 var after `&rest`, so I think it makes sense to follow my types-systems-guy heart here. Stefan ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 19:32 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-22 5:43 ` Eli Zaretskii 2021-09-23 1:46 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 22+ messages in thread From: Eli Zaretskii @ 2021-09-22 5:43 UTC (permalink / raw) To: Stefan Monnier; +Cc: mattiase, larsi, npostavs, 50268 > From: Stefan Monnier <monnier@iro.umontreal.ca> > Cc: Noam Postavsky <npostavs@gmail.com>, mattiase@acm.org, larsi@gnus.org, > 50268@debbugs.gnu.org > Date: Tue, 21 Sep 2021 15:32:32 -0400 > > With my type-systems-guy hat on, I'd say we want to detect those `&rest` > without a following variable and shame the author of the code. > > But at the same time we could think of `&rest` as something similar to > `&optional` and decide that it can be handy for generated code to be > able to generate (x y &optional z &rest). > > The main difference I see is that > > `(x y &optional ,@args) > > makes a lot of sense and will naturally occasionally lead to `&optional` > not followed by anything, whereas `&rest` only expects 1 following > identifier so it seems much less likely that the code will sometimes put > 0 vars in there. After all, we do signal an error if there's more than > 1 var after `&rest`, so I think it makes sense to follow my > types-systems-guy heart here. Which basically means we should revert Noam's commit of yore, is that right? ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-22 5:43 ` Eli Zaretskii @ 2021-09-23 1:46 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-23 6:38 ` Eli Zaretskii 2021-09-23 11:09 ` Mattias Engdegård 0 siblings, 2 replies; 22+ messages in thread From: Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-23 1:46 UTC (permalink / raw) To: Eli Zaretskii; +Cc: mattiase, larsi, npostavs, 50268 > Which basically means we should revert Noam's commit of yore, is that > right? Not all of it, no. Only the part which makes (&rest) acceptable. Stefan ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-23 1:46 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-23 6:38 ` Eli Zaretskii 2021-09-23 11:09 ` Mattias Engdegård 1 sibling, 0 replies; 22+ messages in thread From: Eli Zaretskii @ 2021-09-23 6:38 UTC (permalink / raw) To: Stefan Monnier; +Cc: mattiase, larsi, npostavs, 50268 > From: Stefan Monnier <monnier@iro.umontreal.ca> > Cc: mattiase@acm.org, larsi@gnus.org, npostavs@gmail.com, > 50268@debbugs.gnu.org > Date: Wed, 22 Sep 2021 21:46:24 -0400 > > > Which basically means we should revert Noam's commit of yore, is that > > right? > > Not all of it, no. Only the part which makes (&rest) acceptable. That's what I meant, sorry for not being clear enough. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-23 1:46 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-23 6:38 ` Eli Zaretskii @ 2021-09-23 11:09 ` Mattias Engdegård 2021-09-23 21:03 ` Lars Ingebrigtsen 1 sibling, 1 reply; 22+ messages in thread From: Mattias Engdegård @ 2021-09-23 11:09 UTC (permalink / raw) To: Stefan Monnier; +Cc: Lars Ingebrigtsen, 50268, Noam Postavsky [-- Attachment #1: Type: text/plain, Size: 150 bytes --] 23 sep. 2021 kl. 03.46 skrev Stefan Monnier <monnier@iro.umontreal.ca>: > Not all of it, no. Only the part which makes (&rest) acceptable. Patch. [-- Attachment #2: 0001-Renege-on-anonymous-rest-bug-50268-bug-50720.patch --] [-- Type: application/octet-stream, Size: 7575 bytes --] From c69c3b8c97e9aa9ff350b009c06b4e3e8842ba83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mattias=20Engdeg=C3=A5rd?= <mattiase@acm.org> Date: Thu, 23 Sep 2021 12:43:41 +0200 Subject: [PATCH] Renege on anonymous &rest (bug#50268, bug#50720) Allowing &rest without a variable name following turned out not to be very useful, and it never worked properly. Disallow it. * lisp/emacs-lisp/bytecomp.el (byte-compile-check-lambda-list): * src/eval.c (funcall_lambda): Signal error for &rest without variable name. * doc/lispref/functions.texi (Argument List): Adjust manual. * etc/NEWS (file): Announce. * test/src/eval-tests.el (eval-tests--bugs-24912-and-24913): Extend test, also checking with and without lexical binding. (eval-tests-accept-empty-optional-rest): Reduce to... (eval-tests-accept-empty-optional): ...this, again checking with and without lexical binding. --- doc/lispref/functions.texi | 2 +- etc/NEWS | 7 +++++ lisp/emacs-lisp/bytecomp.el | 2 ++ src/eval.c | 9 ++++-- test/src/eval-tests.el | 57 +++++++++++++++++++++---------------- 5 files changed, 49 insertions(+), 28 deletions(-) diff --git a/doc/lispref/functions.texi b/doc/lispref/functions.texi index 77d1465c87..c856557c3c 100644 --- a/doc/lispref/functions.texi +++ b/doc/lispref/functions.texi @@ -378,7 +378,7 @@ Argument List @group (@var{required-vars}@dots{} @r{[}&optional @r{[}@var{optional-vars}@dots{}@r{]}@r{]} - @r{[}&rest @r{[}@var{rest-var}@r{]}@r{]}) + @r{[}&rest @var{rest-var}@r{]}) @end group @end example diff --git a/etc/NEWS b/etc/NEWS index fb7a7f628a..cf3f90304d 100644 --- a/etc/NEWS +++ b/etc/NEWS @@ -3215,6 +3215,13 @@ local variable would not be heeded. This has now changed, and a file with a 'lexical-binding' cookie is always heeded. To revert to the old behavior, set 'permanently-enabled-local-variables' to nil. ++++ +** '&rest' in argument lists must always be followed by a variable name. +Omitting the variable name after '&rest' was previously tolerated in +some cases but not consistently so; it could lead to crashes or +outright wrong results. Since the utility was marginal at best, it is +now an error to omit the variable. + --- ** 'kill-all-local-variables' has changed how it handles non-symbol hooks. The function is documented to eliminate all buffer-local bindings diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el index be74195778..d7da7a2149 100644 --- a/lisp/emacs-lisp/bytecomp.el +++ b/lisp/emacs-lisp/bytecomp.el @@ -2930,6 +2930,8 @@ byte-compile-check-lambda-list (macroexp--const-symbol-p arg t)) (error "Invalid lambda variable %s" arg)) ((eq arg '&rest) + (unless (cdr list) + (error "&rest without variable name")) (when (cddr list) (error "Garbage following &rest VAR in lambda-list")) (when (memq (cadr list) '(&optional &rest)) diff --git a/src/eval.c b/src/eval.c index 2bb7cfe600..66d34808f8 100644 --- a/src/eval.c +++ b/src/eval.c @@ -3245,6 +3245,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs, emacs_abort (); i = optional = rest = 0; + bool previous_rest = false; for (; CONSP (syms_left); syms_left = XCDR (syms_left)) { maybe_quit (); @@ -3255,13 +3256,14 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs, if (EQ (next, Qand_rest)) { - if (rest) + if (rest || previous_rest) xsignal1 (Qinvalid_function, fun); rest = 1; + previous_rest = true; } else if (EQ (next, Qand_optional)) { - if (optional || rest) + if (optional || rest || previous_rest) xsignal1 (Qinvalid_function, fun); optional = 1; } @@ -3287,10 +3289,11 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs, else /* Dynamically bind NEXT. */ specbind (next, arg); + previous_rest = false; } } - if (!NILP (syms_left)) + if (!NILP (syms_left) || previous_rest) xsignal1 (Qinvalid_function, fun); else if (i < nargs) xsignal2 (Qwrong_number_of_arguments, fun, make_fixnum (nargs)); diff --git a/test/src/eval-tests.el b/test/src/eval-tests.el index b2b7dfefda..3c3e703341 100644 --- a/test/src/eval-tests.el +++ b/test/src/eval-tests.el @@ -39,31 +39,40 @@ byte-compile-debug (ert-deftest eval-tests--bugs-24912-and-24913 () "Check that Emacs doesn't accept weird argument lists. Bug#24912 and Bug#24913." - (dolist (args '((&rest &optional) - (&rest a &optional) (&rest &optional a) - (&optional &optional) (&optional &optional a) - (&optional a &optional b) - (&rest &rest) (&rest &rest a) - (&rest a &rest b))) - (should-error (eval `(funcall (lambda ,args)) t) :type 'invalid-function) - (should-error (byte-compile-check-lambda-list args)) - (let ((byte-compile-debug t)) - (ert-info ((format "bytecomp: args = %S" args)) - (should-error (eval `(byte-compile (lambda ,args)) t)))))) - -(ert-deftest eval-tests-accept-empty-optional-rest () - "Check that Emacs accepts empty &optional and &rest arglists. + (dolist (lb '(t false)) + (ert-info ((prin1-to-string lb) :prefix "lexical-binding: ") + (let ((lexical-binding lb)) + (dolist (args '((&rest &optional) + (&rest a &optional) (&rest &optional a) + (&optional &optional) (&optional &optional a) + (&optional a &optional b) + (&rest &rest) (&rest &rest a) + (&rest a &rest b) + (&rest) (&optional &rest) + )) + (ert-info ((prin1-to-string args) :prefix "args: ") + (should-error + (eval `(funcall (lambda ,args)) lb) :type 'invalid-function) + (should-error (byte-compile-check-lambda-list args)) + (let ((byte-compile-debug t)) + (should-error (eval `(byte-compile (lambda ,args)) lb))))))))) + +(ert-deftest eval-tests-accept-empty-optional () + "Check that Emacs accepts empty &optional arglists. Bug#24912." - (dolist (args '((&optional) (&rest) (&optional &rest) - (&optional &rest a) (&optional a &rest))) - (let ((fun `(lambda ,args 'ok))) - (ert-info ("eval") - (should (eq (funcall (eval fun t)) 'ok))) - (ert-info ("byte comp check") - (byte-compile-check-lambda-list args)) - (ert-info ("bytecomp") - (let ((byte-compile-debug t)) - (should (eq (funcall (byte-compile fun)) 'ok))))))) + (dolist (lb '(t false)) + (ert-info ((prin1-to-string lb) :prefix "lexical-binding: ") + (let ((lexical-binding lb)) + (dolist (args '((&optional) (&optional &rest a))) + (ert-info ((prin1-to-string args) :prefix "args: ") + (let ((fun `(lambda ,args 'ok))) + (ert-info ("eval") + (should (eq (funcall (eval fun lb)) 'ok))) + (ert-info ("byte comp check") + (byte-compile-check-lambda-list args)) + (ert-info ("bytecomp") + (let ((byte-compile-debug t)) + (should (eq (funcall (byte-compile fun)) 'ok))))))))))) (dolist (form '(let let*)) -- 2.21.1 (Apple Git-122.3) ^ permalink raw reply related [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-23 11:09 ` Mattias Engdegård @ 2021-09-23 21:03 ` Lars Ingebrigtsen 2021-09-24 6:07 ` Eli Zaretskii 0 siblings, 1 reply; 22+ messages in thread From: Lars Ingebrigtsen @ 2021-09-23 21:03 UTC (permalink / raw) To: Mattias Engdegård; +Cc: Stefan Monnier, 50268, Noam Postavsky Mattias Engdegård <mattiase@acm.org> writes: > Allowing &rest without a variable name following turned out not to be > very useful, and it never worked properly. Disallow it. Makes sense to me. Since it's that non-invasive, I think it'd be fine to push to Emacs 28. Perhaps Eli has a different opinion, though. -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-23 21:03 ` Lars Ingebrigtsen @ 2021-09-24 6:07 ` Eli Zaretskii 2021-09-25 0:51 ` Lars Ingebrigtsen 2021-09-25 18:37 ` Mattias Engdegård 0 siblings, 2 replies; 22+ messages in thread From: Eli Zaretskii @ 2021-09-24 6:07 UTC (permalink / raw) To: Lars Ingebrigtsen; +Cc: mattiase, monnier, 50268, npostavs > From: Lars Ingebrigtsen <larsi@gnus.org> > Cc: Stefan Monnier <monnier@iro.umontreal.ca>, Eli Zaretskii > <eliz@gnu.org>, Noam Postavsky <npostavs@gmail.com>, > 50268@debbugs.gnu.org > Date: Thu, 23 Sep 2021 23:03:04 +0200 > > Mattias Engdegård <mattiase@acm.org> writes: > > > Allowing &rest without a variable name following turned out not to be > > very useful, and it never worked properly. Disallow it. > > Makes sense to me. Since it's that non-invasive, I think it'd be fine > to push to Emacs 28. Perhaps Eli has a different opinion, though. Let's do it now. Thanks. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-24 6:07 ` Eli Zaretskii @ 2021-09-25 0:51 ` Lars Ingebrigtsen 2021-09-25 18:37 ` Mattias Engdegård 1 sibling, 0 replies; 22+ messages in thread From: Lars Ingebrigtsen @ 2021-09-25 0:51 UTC (permalink / raw) To: Eli Zaretskii; +Cc: mattiase, monnier, 50268, npostavs Eli Zaretskii <eliz@gnu.org> writes: >> Makes sense to me. Since it's that non-invasive, I think it'd be fine >> to push to Emacs 28. Perhaps Eli has a different opinion, though. > > Let's do it now. OK, Mattias, go ahead and push. -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-24 6:07 ` Eli Zaretskii 2021-09-25 0:51 ` Lars Ingebrigtsen @ 2021-09-25 18:37 ` Mattias Engdegård 1 sibling, 0 replies; 22+ messages in thread From: Mattias Engdegård @ 2021-09-25 18:37 UTC (permalink / raw) To: Eli Zaretskii Cc: Lars Ingebrigtsen, Stefan Monnier, 50268-done, Noam Postavsky 24 sep. 2021 kl. 08.07 skrev Eli Zaretskii <eliz@gnu.org>: > Let's do it now. Thank you, pushed to master. Closing. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 16:11 ` bug#50720: bug#50268: 28.0.50; Assertion warning during native compilation Lars Ingebrigtsen 2021-09-21 16:22 ` Mattias Engdegård @ 2021-09-21 16:26 ` Eli Zaretskii 1 sibling, 0 replies; 22+ messages in thread From: Eli Zaretskii @ 2021-09-21 16:26 UTC (permalink / raw) To: Lars Ingebrigtsen; +Cc: mattiase, 50720, 50268 > From: Lars Ingebrigtsen <larsi@gnus.org> > Cc: 50720@debbugs.gnu.org, 50268@debbugs.gnu.org, Eli Zaretskii <eliz@gnu.org> > Date: Tue, 21 Sep 2021 18:11:34 +0200 > > Mattias Engdegård <mattiase@acm.org> writes: > > > Now, either we fix this bug or we stop pretending that unnamed &rest > > arguments work at all and signal an error, because it's clear from the > > above that they can't have seen much use. > > I did a quick grep through core and GNU ELPA, and I couldn't find any > instances of it being used, so I'd be fine with either solution (i.e., > either fixing the bug or signalling an error). > > Perhaps Eli has an opinion (added to the CCs). I think I'd like to at least see the prototype of the fix to have an opinion. ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation
@ 2021-08-30 14:05 Michael Welsh Duggan
2021-09-04 14:00 ` Michael Welsh Duggan
0 siblings, 1 reply; 22+ messages in thread
From: Michael Welsh Duggan @ 2021-08-30 14:05 UTC (permalink / raw)
To: 50268
[-- Attachment #1: Type: text/plain, Size: 453 bytes --]
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)))
[-- Attachment #2: pacproxy.el --]
[-- Type: application/emacs-lisp, Size: 2855 bytes --]
[-- Attachment #3: Type: text/plain, Size: 5363 bytes --]
In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
of 2021-08-30 built on miko
Repository revision: bc9516a6f12d21971db62ad5def51a3b4858a488
Windowing system distributor 'The X.Org Foundation', version 11.0.12011000
System Description: Debian GNU/Linux bookworm/sid
Configured using:
'configure --without-toolkit-scroll-bars --with-x-toolkit=lucid
--with-native-compilation'
Configured features:
CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GPM GSETTINGS HARFBUZZ JPEG JSON
LCMS2 LIBOTF LIBSELINUX LIBSYSTEMD LIBXML2 M17N_FLT MODULES NATIVE_COMP
NOTIFY INOTIFY PDUMPER PNG RSVG SECCOMP SOUND THREADS TIFF X11 XAW3D
XDBE XIM XPM LUCID ZLIB
Important settings:
value of $LANG: en_US.UTF-8
value of $XMODIFIERS: @im=ibus
locale-coding-system: utf-8-unix
Major mode: Lisp Interaction
Minor modes in effect:
flyspell-mode: t
display-time-mode: t
magit-wip-initial-backup-mode: t
magit-wip-before-change-mode: t
magit-wip-after-apply-mode: t
magit-wip-after-save-mode: t
magit-wip-mode: t
global-git-commit-mode: t
magit-auto-revert-mode: t
shell-dirtrack-mode: t
tooltip-mode: t
global-eldoc-mode: t
eldoc-mode: t
electric-indent-mode: t
mouse-wheel-mode: t
tool-bar-mode: t
menu-bar-mode: t
file-name-shadow-mode: t
global-font-lock-mode: t
font-lock-mode: t
auto-composition-mode: t
auto-encryption-mode: t
auto-compression-mode: t
line-number-mode: t
Load-path shadows:
/usr/share/emacs/site-lisp/cmake-mode hides /home/md5i/.config/emacs/elpa/cmake-mode-20210104.1831/cmake-mode
/home/md5i/.config/emacs/elpa/transient-20210311.1549/transient hides /usr/local/share/emacs/28.0.50/lisp/transient
Features:
(shadow sort mail-extr gnus-msg gnus-art mm-uu mml2015 mm-view mml-smime
smime dig gnus-sum shr kinsoku svg gnus-group gnus-undo gnus-start
gnus-dbus gnus-cloud gnus-spec gnus-win emacsbug sendmail flyspell
ispell view pacproxy dbus xml descr-text cus-edit pp cus-load time
sieve-manage sasl sasl-anonymous sasl-login sasl-plain rng-loc rng-uri
rng-parse rng-match rng-dt rng-util rng-pttrn nxml-parse nxml-ns
nxml-enc xmltok nxml-util sgml-mode facemenu dom python tramp-sh tramp
tramp-loaddefs trampver tramp-integration files-x tramp-compat
parse-time iso8601 ls-lisp ps-print ps-print-loaddefs ps-def lpr picture
magit-submodule magit-obsolete magit-blame magit-stash magit-reflog
magit-bisect magit-push magit-pull magit-fetch magit-clone magit-remote
magit-commit magit-sequence magit-notes magit-worktree magit-tag
magit-merge magit-branch magit-reset magit-files magit-refs magit-status
magit magit-repos magit-apply magit-wip magit-log magit-diff smerge-mode
diff git-commit log-edit pcvs-util add-log magit-core magit-autorevert
autorevert filenotify magit-margin magit-transient magit-process
with-editor shell pcomplete server magit-mode transient format-spec
magit-git magit-section comp comp-cstr warnings rx cl-extra help-mode
benchmark magit-utils pcase which-func imenu vc-git diff-mode easy-mmode
vc-dispatcher ido crm dash nnimap nnmail gnus-int gnus-range mail-source
message rfc822 mml mml-sec epa mm-decode mm-bodies mm-encode mailabbrev
gmm-utils mailheader utf7 netrc nnoo gnus wid-edit nnheader gnus-util
rmail rmail-loaddefs time-date mail-utils gnus-o365-oauth2 oauth2
url-http url-auth mail-parse rfc2231 rfc2047 rfc2045 mm-util ietf-drums
mail-prsvr url-gw nsm rmc puny plstore generated generic-x epg rfc6068
epg-config ediff ediff-merg ediff-mult ediff-wind ediff-diff ediff-help
ediff-init ediff-util dired-x dired dired-loaddefs compile
text-property-search comint ring ansi-color cc-mode cc-fonts cc-guess
cc-menus cc-cmds cc-styles cc-align cc-engine cc-vars cc-defs edmacro
kmacro derived debian-el finder-inf info package browse-url url
url-proxy url-privacy url-expand url-methods url-history url-cookie
url-domsuf url-util mailcap url-handlers url-parse auth-source cl-seq
eieio eieio-core cl-macs eieio-loaddefs password-cache json subr-x map
url-vars seq byte-opt gv bytecomp byte-compile cconv cl-loaddefs cl-lib
iso-transl tooltip eldoc electric uniquify ediff-hook vc-hooks
lisp-float-type mwheel term/x-win x-win term/common-win x-dnd tool-bar
dnd fontset image regexp-opt fringe tabulated-list replace newcomment
text-mode elisp-mode lisp-mode prog-mode register page tab-bar menu-bar
rfn-eshadow isearch easymenu timer select scroll-bar mouse jit-lock
font-lock syntax font-core term/tty-colors frame minibuffer cl-generic
cham georgian utf-8-lang misc-lang vietnamese tibetan thai tai-viet lao
korean japanese eucjp-ms cp51932 hebrew greek romanian slovak czech
european ethiopic indian cyrillic chinese composite charscript charprop
case-table epa-hook jka-cmpr-hook help simple abbrev obarray
cl-preloaded nadvice button loaddefs faces cus-face macroexp files
window text-properties overlay sha1 md5 base64 format env code-pages
mule custom widget hashtable-print-readable backquote threads dbusbind
inotify lcms2 dynamic-setting system-font-setting font-render-setting
cairo x-toolkit x multi-tty make-network-process native-compile emacs)
Memory information:
((conses 16 472475 15472)
(symbols 48 29207 0)
(strings 32 96154 4379)
(string-bytes 1 3212668)
(vectors 16 46522)
(vector-slots 8 809008 15265)
(floats 8 664 82)
(intervals 56 418 14)
(buffers 992 14))
--
Michael Welsh Duggan
(md5i@md5i.com)
^ permalink raw reply [flat|nested] 22+ messages in thread* bug#50268: 28.0.50; Assertion warning during native compilation 2021-08-30 14:05 Michael Welsh Duggan @ 2021-09-04 14:00 ` Michael Welsh Duggan 2021-09-05 15:31 ` Michael Welsh Duggan 0 siblings, 1 reply; 22+ messages in thread From: Michael Welsh Duggan @ 2021-09-04 14:00 UTC (permalink / raw) To: 50268 Michael Welsh Duggan <md5i@md5i.com> writes: > With the included file in the current working directory... > > First, byte compile the file: > emacs -Q -batch --eval '(byte-compile-file "pacproxy.el")' > > Then, from > emacs -Q > > M-: (push default-directory load-path) RET > M-x load-library RET pacproxy RET > > For me, this results in the following warning: > > Warning (comp): /home/md5i/tmp/tmp/pacproxy.el: Error: Assertion > failed (and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec))) I did some more testing on this. I used the following after making the obvious change to the first line. (setq pacproxy-directory "/directory/containing/pacproxy") (native-compile (concat pacproxy-directory "/pacproxy.el")) The result was the following backtrace: Debugger entered--Lisp error: (cl-assertion-failed ((and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec))) nil)) cl--assertion-failed((and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec)))) comp-limplify-lap-inst((byte-constant "DIRECT" . 0)) comp-limplify-block(#s(comp-block-lap :name bb_0 :insns nil :closed nil :in-edges nil :out-edges nil :idom nil :df #<hash-table eql 0/65 0x158ad8eec809> :post-num nil :final-frame nil :sp 0 :addr 0 :non-ret-insn nil :no-ret nil)) comp-limplify-function(#s(comp-func-l :name nil :c-name "F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc "DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks #<hash-table eq 3/65 0x158ad8ad88f1> :lap-block #<hash-table equal 0/65 0x158ad8ad8911> :edges-h #<hash-table eql 0/65 0x158ad8e0343f> :block-cnt-gen #f(compiled-function () #<bytecode 0x1f53ba4c3e92>) :edge-cnt-gen #f(compiled-function () #<bytecode -0xfffe0ac45b3c16c>) :has-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :nonrest 0 :rest t))) #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_69>("F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" #s(comp-func-l :name nil :c-name "F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc "DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks #<hash-table eq 3/65 0x158ad8ad88f1> :lap-block #<hash-table equal 0/65 0x158ad8ad8911> :edges-h #<hash-table eql 0/65 0x158ad8e0343f> :block-cnt-gen #f(compiled-function () #<bytecode 0x1f53ba4c3e92>) :edge-cnt-gen #f(compiled-function () #<bytecode -0xfffe0ac45b3c16c>) :has-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :nonrest 0 :rest t))) comp-limplify(nil) comp--native-compile("~/src/elisp/pacproxy.el" nil nil) native-compile("~/src/elisp/pacproxy.el") (progn (native-compile "~/src/elisp/pacproxy.el")) elisp--eval-last-sexp(t) eval-last-sexp(t) eval-print-last-sexp(nil) funcall-interactively(eval-print-last-sexp nil) command-execute(eval-print-last-sexp) I ran again after evaluating comp.el manually, and got the following expanded backtrace: Debugger entered--Lisp error: (cl-assertion-failed ((and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec))) nil)) cl--assertion-failed((and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec)))) (or (and (< idx (progn (or (progn (and (memq (type-of vec) cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec vec))) (aref vec 3))) (>= idx (progn (or (progn (and (memq (type-of vec) cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec vec))) (aref vec 2)))) (cl--assertion-failed '(and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec))))) (progn (or (and (< idx (progn (or (progn (and (memq (type-of vec) cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec vec))) (aref vec 3))) (>= idx (progn (or (progn (and (memq (type-of vec) cl-struct-comp-vec-tags) t)) (signal 'wrong-type-argument (list 'comp-vec vec))) (aref vec 2)))) (cl--assertion-failed '(and (< idx (comp-vec-end vec)) (>= idx (comp-vec-beg vec))))) nil) comp-vec--verify-idx(#s(comp-vec :data #<hash-table eql 1/65 0x158ad87bcbdf> :beg 0 :end 1) 1) comp-vec-aref(#s(comp-vec :data #<hash-table eql 1/65 0x158ad87bcbdf> :beg 0 :end 1) 1) comp-slot-n(1) comp-slot() (list 'setimm (comp-slot) val) (comp-emit (list 'setimm (comp-slot) val)) comp-emit-setimm("DIRECT") (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-setimm arg)) (cond ((eq op 'TAG) (let nil nil (let* ((label-sp insn) (_TAG (if (cdr label-sp) (car-safe (prog1 label-sp (setq label-sp (cdr label-sp)))) (signal 'wrong-number-of-arguments (list '(_TAG label-num . label-sp) (length label-sp))))) (label-num (car-safe (prog1 label-sp (setq label-sp (cdr label-sp)))))) (progn (if label-sp (progn (progn (or (= (1- label-sp) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 3))) (cl--assertion-failed '(= (1- label-sp) (comp-limplify-sp comp-pass)))) nil))) (comp-emit-annotation (format "LAP TAG %d" label-num)))))) ((eq op 'byte-stack-ref) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-copy-slot (- (comp-sp) arg 1)))) ((eq op 'byte-varref) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call (comp-call 'symbol-value (make-comp-mvar :constant arg))))) ((eq op 'byte-varset) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'set_internal (make-comp-mvar :constant arg) (comp-slot+1))))) ((eq op 'byte-varbind) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'specbind (make-comp-mvar :constant arg) (comp-slot+1))))) ((eq op 'byte-call) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))) (comp-emit-set-call (comp-callref 'funcall (1+ arg) (comp-sp))))) ((eq op 'byte-unbind) (let nil nil (comp-emit (comp-call 'helper_unbind_n (make-comp-mvar :constant arg))))) ((eq op 'byte-pophandler) (let nil nil (comp-emit '(pop-handler)))) ((eq op 'byte-pushconditioncase) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-handler (cdr (cdr insn)) 'condition-case))) ((eq op 'byte-pushcatch) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-handler (cdr (cdr insn)) 'catcher))) ((eq op 'byte-nth) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nth -1))) ((eq op 'byte-symbolp) (let nil nil (comp-emit-set-call-subr 'symbolp 0))) ((eq op 'byte-consp) (let nil nil (comp-emit-set-call-subr 'consp 0))) ((eq op 'byte-stringp) (let nil nil (comp-emit-set-call-subr 'stringp 0))) ((eq op 'byte-listp) (let nil nil (comp-emit-set-call-subr 'listp 0))) ((eq op 'byte-eq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'eq -1))) ((eq op 'byte-memq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'memq -1))) ((eq op 'byte-not) (let nil nil (comp-emit-set-call (comp-call 'eq (comp-slot-n (comp-sp)) (make-comp-mvar :constant nil))))) ((eq op 'byte-car) (let nil nil (comp-emit-set-call-subr 'car 0))) ((eq op 'byte-cdr) (let nil nil (comp-emit-set-call-subr 'cdr 0))) ((eq op 'byte-cons) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'cons -1))) ((eq op 'byte-list1) (let nil nil (comp-limplify-listn 1))) ((eq op 'byte-list2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-limplify-listn 2))) ((eq op 'byte-list3) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-limplify-listn 3))) ((eq op 'byte-list4) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3)))) (comp-limplify-listn 4))) ((eq op 'byte-length) (let nil nil (comp-emit-set-call-subr 'length 0))) ((eq op 'byte-aref) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'aref -1))) ((eq op 'byte-aset) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'aset -2))) ((eq op 'byte-symbol-value) (let nil nil (comp-emit-set-call-subr 'symbol-value 0))) ((eq op 'byte-symbol-function) (let nil nil (comp-emit-set-call-subr 'symbol-function 0))) ((eq op 'byte-set) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'set -1))) ((eq op 'byte-fset) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'fset -1))) ((eq op 'byte-get) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'get -1))) ((eq op 'byte-substring) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'substring -2))) ((eq op 'byte-concat2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call (comp-callref 'concat 2 (comp-sp))))) ((eq op 'byte-concat3) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call (comp-callref 'concat 3 (comp-sp))))) ((eq op 'byte-concat4) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3)))) (comp-emit-set-call (comp-callref 'concat 4 (comp-sp))))) ((eq op 'byte-sub1) (let nil nil (comp-emit-set-call-subr '1- 0))) ((eq op 'byte-add1) (let nil nil (comp-emit-set-call-subr '1+ 0))) ((eq op 'byte-eqlsign) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '= -1))) ((eq op 'byte-gtr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '> -1))) ((eq op 'byte-lss) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '< -1))) ((eq op 'byte-leq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '<= -1))) ((eq op 'byte-geq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '>= -1))) ((eq op 'byte-diff) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '- -1))) ((eq op 'byte-negate) (let nil nil (comp-emit-set-call (comp-call 'negate (comp-slot))))) ((eq op 'byte-plus) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '+ -1))) ((eq op 'byte-max) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'max -1))) ((eq op 'byte-min) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'min -1))) ((eq op 'byte-mult) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '* -1))) ((eq op 'byte-point) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point 1))) ((eq op 'byte-goto-char) (let nil nil (comp-emit-set-call-subr 'goto-char 0))) ((eq op 'byte-insert) (let nil nil (comp-emit-set-call-subr 'insert 0))) ((eq op 'byte-point-max) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point-max 1))) ((eq op 'byte-point-min) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point-min 1))) ((eq op 'byte-char-after) (let nil nil (comp-emit-set-call-subr 'char-after 0))) ((eq op 'byte-following-char) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'following-char 1))) ((eq op 'byte-preceding-char) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'preceding-char 1))) ((eq op 'byte-current-column) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'current-column 1))) ((eq op 'byte-indent-to) (let nil nil (comp-emit-set-call (comp-call 'indent-to (comp-slot) (make-comp-mvar :constant nil))))) ((eq op 'byte-scan-buffer-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-scan-buffer-OBSOLETE")))) ((eq op 'byte-eolp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'eolp 1))) ((eq op 'byte-eobp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'eobp 1))) ((eq op 'byte-bolp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'bolp 1))) ((eq op 'byte-bobp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'bobp 1))) ((eq op 'byte-current-buffer) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'current-buffer 1))) ((eq op 'byte-set-buffer) (let nil nil (comp-emit-set-call-subr 'set-buffer 0))) ((eq op 'byte-save-current-buffer) (let nil nil (comp-emit (comp-call 'record_unwind_current_buffer)))) ((eq op 'byte-set-mark-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-set-mark-OBSOLETE")))) ((eq op 'byte-interactive-p-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-interactive-p-OBSOLETE")))) ((eq op 'byte-forward-char) (let nil nil (comp-emit-set-call-subr 'forward-char 0))) ((eq op 'byte-forward-word) (let nil nil (comp-emit-set-call-subr 'forward-word 0))) ((eq op 'byte-skip-chars-forward) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-forward -1))) ((eq op 'byte-skip-chars-backward) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-backward -1))) ((eq op 'byte-forward-line) (let nil nil (comp-emit-set-call-subr 'forward-line 0))) ((eq op 'byte-char-syntax) (let nil nil (comp-emit-set-call-subr 'char-syntax 0))) ((eq op 'byte-buffer-substring) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'buffer-substring -1))) ((eq op 'byte-delete-region) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'delete-region -1))) ((eq op 'byte-narrow-to-region) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call (comp-call 'narrow-to-region (comp-slot) (comp-slot+1))))) ((eq op 'byte-widen) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call (comp-call 'widen)))) ((eq op 'byte-end-of-line) (let nil nil (comp-emit-set-call-subr 'end-of-line 0))) ((eq op 'byte-constant2) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-constant2")))) ((eq op 'byte-goto) (let nil nil (comp-emit-uncond-jump (cdr (cdr insn))))) ((eq op 'byte-goto-if-nil) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 0 (cdr (cdr insn)) nil))) ((eq op 'byte-goto-if-not-nil) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 0 (cdr (cdr insn)) t))) ((eq op 'byte-goto-if-nil-else-pop) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 1 (cdr (cdr insn)) nil))) ((eq op 'byte-goto-if-not-nil-else-pop) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 1 (cdr (cdr insn)) t))) ((eq op 'byte-return) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (list 'return (comp-slot+1))))) ((eq op 'byte-discard) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) 'pass)) ((eq op 'byte-dup) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-copy-slot (1- (comp-sp))))) ((eq op 'byte-save-excursion) (let nil nil (comp-emit (comp-call 'record_unwind_protect_excursion)))) ((eq op 'byte-save-window-excursion-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-save-window-excursion-OBSOLETE")))) ((eq op 'byte-save-restriction) (let nil nil (comp-emit (comp-call 'helper_save_restriction)))) ((eq op 'byte-catch) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-catch")))) ((eq op 'byte-unwind-protect) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'helper_unwind_protect (comp-slot+1))))) ((eq op 'byte-condition-case) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-condition-case")))) ((eq op 'byte-temp-output-buffer-setup-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-temp-output-buffer-setup-OBSOLETE")))) ((eq op 'byte-temp-output-buffer-show-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-temp-output-buffer-show-OBSOLETE")))) ((eq op 'byte-unbind-all) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-unbind-all")))) ((eq op 'byte-set-marker) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'set-marker -2))) ((eq op 'byte-match-beginning) (let nil nil (comp-emit-set-call-subr 'match-beginning 0))) ((eq op 'byte-match-end) (let nil nil (comp-emit-set-call-subr 'match-end 0))) ((eq op 'byte-upcase) (let nil nil (comp-emit-set-call-subr 'upcase 0))) ((eq op 'byte-downcase) (let nil nil (comp-emit-set-call-subr 'downcase 0))) ((eq op 'byte-string=) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-equal -1))) ((eq op 'byte-string<) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-lessp -1))) ((eq op 'byte-equal) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'equal -1))) ((eq op 'byte-nthcdr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nthcdr -1))) ((eq op 'byte-elt) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'elt -1))) ((eq op 'byte-member) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'member -1))) ((eq op 'byte-assq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'assq -1))) ((eq op 'byte-nreverse) (let nil nil (comp-emit-set-call-subr 'nreverse 0))) ((eq op 'byte-setcar) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'setcar -1))) ((eq op 'byte-setcdr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'setcdr -1))) ((eq op 'byte-car-safe) (let nil nil (comp-emit-set-call-subr 'car-safe 0))) ((eq op 'byte-cdr-safe) (let nil nil (comp-emit-set-call-subr 'cdr-safe 0))) ((eq op 'byte-nconc) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nconc -1))) ((eq op 'byte-quo) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '/ -1))) ((eq op 'byte-rem) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '% -1))) ((eq op 'byte-numberp) (let nil nil (comp-emit-set-call-subr 'numberp 0))) ((eq op 'byte-integerp) (let nil nil (comp-emit-set-call-subr 'integerp 0))) ((eq op 'byte-listN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1 arg))))) (comp-emit-set-call (comp-callref 'list arg (comp-sp))))) ((eq op 'byte-concatN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1 arg))))) (comp-emit-set-call (comp-callref 'concat arg (comp-sp))))) ((eq op 'byte-insertN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1 arg))))) (comp-emit-set-call (comp-callref 'insert arg (comp-sp))))) ((eq op 'byte-stack-set) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-copy-slot (1+ (comp-sp)) (- (comp-sp) arg -1)))) ((eq op 'byte-stack-set2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (progn (or nil (cl--assertion-failed 'nil)) nil))) ((eq op 'byte-discardN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))))) ((eq op 'byte-switch) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-switch (comp-slot+1) (cl-first (progn (or (progn (and (memq (type-of (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2))) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2))))) (aref (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2)) 2)))))) ((eq op 'byte-constant) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-setimm arg))) ((eq op 'byte-discardN-preserve-tos) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))) (comp-copy-slot (+ arg (comp-sp))))) (t (let nil (signal 'native-ice (list "unexpected LAP op" (symbol-name op)))))) (let ((op (car insn)) (arg (if (consp (cdr insn)) (car (cdr insn)) (cdr insn)))) (cond ((eq op 'TAG) (let nil nil (let* ((label-sp insn) (_TAG (if (cdr label-sp) (car-safe (prog1 label-sp (setq label-sp (cdr label-sp)))) (signal 'wrong-number-of-arguments (list '(_TAG label-num . label-sp) (length label-sp))))) (label-num (car-safe (prog1 label-sp (setq label-sp (cdr label-sp)))))) (progn (if label-sp (progn (progn (or (= (1- label-sp) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 3))) (cl--assertion-failed '(= (1- label-sp) (comp-limplify-sp comp-pass)))) nil))) (comp-emit-annotation (format "LAP TAG %d" label-num)))))) ((eq op 'byte-stack-ref) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-copy-slot (- (comp-sp) arg 1)))) ((eq op 'byte-varref) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call (comp-call 'symbol-value (make-comp-mvar :constant arg))))) ((eq op 'byte-varset) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'set_internal (make-comp-mvar :constant arg) (comp-slot+1))))) ((eq op 'byte-varbind) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'specbind (make-comp-mvar :constant arg) (comp-slot+1))))) ((eq op 'byte-call) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))) (comp-emit-set-call (comp-callref 'funcall (1+ arg) (comp-sp))))) ((eq op 'byte-unbind) (let nil nil (comp-emit (comp-call 'helper_unbind_n (make-comp-mvar :constant arg))))) ((eq op 'byte-pophandler) (let nil nil (comp-emit '(pop-handler)))) ((eq op 'byte-pushconditioncase) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-handler (cdr (cdr insn)) 'condition-case))) ((eq op 'byte-pushcatch) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-handler (cdr (cdr insn)) 'catcher))) ((eq op 'byte-nth) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nth -1))) ((eq op 'byte-symbolp) (let nil nil (comp-emit-set-call-subr 'symbolp 0))) ((eq op 'byte-consp) (let nil nil (comp-emit-set-call-subr 'consp 0))) ((eq op 'byte-stringp) (let nil nil (comp-emit-set-call-subr 'stringp 0))) ((eq op 'byte-listp) (let nil nil (comp-emit-set-call-subr 'listp 0))) ((eq op 'byte-eq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'eq -1))) ((eq op 'byte-memq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'memq -1))) ((eq op 'byte-not) (let nil nil (comp-emit-set-call (comp-call 'eq (comp-slot-n (comp-sp)) (make-comp-mvar :constant nil))))) ((eq op 'byte-car) (let nil nil (comp-emit-set-call-subr 'car 0))) ((eq op 'byte-cdr) (let nil nil (comp-emit-set-call-subr 'cdr 0))) ((eq op 'byte-cons) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'cons -1))) ((eq op 'byte-list1) (let nil nil (comp-limplify-listn 1))) ((eq op 'byte-list2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-limplify-listn 2))) ((eq op 'byte-list3) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-limplify-listn 3))) ((eq op 'byte-list4) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3)))) (comp-limplify-listn 4))) ((eq op 'byte-length) (let nil nil (comp-emit-set-call-subr 'length 0))) ((eq op 'byte-aref) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'aref -1))) ((eq op 'byte-aset) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'aset -2))) ((eq op 'byte-symbol-value) (let nil nil (comp-emit-set-call-subr 'symbol-value 0))) ((eq op 'byte-symbol-function) (let nil nil (comp-emit-set-call-subr 'symbol-function 0))) ((eq op 'byte-set) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'set -1))) ((eq op 'byte-fset) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'fset -1))) ((eq op 'byte-get) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'get -1))) ((eq op 'byte-substring) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'substring -2))) ((eq op 'byte-concat2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call (comp-callref 'concat 2 (comp-sp))))) ((eq op 'byte-concat3) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call (comp-callref 'concat 3 (comp-sp))))) ((eq op 'byte-concat4) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -3)))) (comp-emit-set-call (comp-callref 'concat 4 (comp-sp))))) ((eq op 'byte-sub1) (let nil nil (comp-emit-set-call-subr '1- 0))) ((eq op 'byte-add1) (let nil nil (comp-emit-set-call-subr '1+ 0))) ((eq op 'byte-eqlsign) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '= -1))) ((eq op 'byte-gtr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '> -1))) ((eq op 'byte-lss) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '< -1))) ((eq op 'byte-leq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '<= -1))) ((eq op 'byte-geq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '>= -1))) ((eq op 'byte-diff) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '- -1))) ((eq op 'byte-negate) (let nil nil (comp-emit-set-call (comp-call 'negate (comp-slot))))) ((eq op 'byte-plus) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '+ -1))) ((eq op 'byte-max) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'max -1))) ((eq op 'byte-min) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'min -1))) ((eq op 'byte-mult) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '* -1))) ((eq op 'byte-point) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point 1))) ((eq op 'byte-goto-char) (let nil nil (comp-emit-set-call-subr 'goto-char 0))) ((eq op 'byte-insert) (let nil nil (comp-emit-set-call-subr 'insert 0))) ((eq op 'byte-point-max) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point-max 1))) ((eq op 'byte-point-min) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'point-min 1))) ((eq op 'byte-char-after) (let nil nil (comp-emit-set-call-subr 'char-after 0))) ((eq op 'byte-following-char) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'following-char 1))) ((eq op 'byte-preceding-char) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'preceding-char 1))) ((eq op 'byte-current-column) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'current-column 1))) ((eq op 'byte-indent-to) (let nil nil (comp-emit-set-call (comp-call 'indent-to (comp-slot) (make-comp-mvar :constant nil))))) ((eq op 'byte-scan-buffer-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-scan-buffer-OBSOLETE")))) ((eq op 'byte-eolp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'eolp 1))) ((eq op 'byte-eobp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'eobp 1))) ((eq op 'byte-bolp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'bolp 1))) ((eq op 'byte-bobp) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'bobp 1))) ((eq op 'byte-current-buffer) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call-subr 'current-buffer 1))) ((eq op 'byte-set-buffer) (let nil nil (comp-emit-set-call-subr 'set-buffer 0))) ((eq op 'byte-save-current-buffer) (let nil nil (comp-emit (comp-call 'record_unwind_current_buffer)))) ((eq op 'byte-set-mark-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-set-mark-OBSOLETE")))) ((eq op 'byte-interactive-p-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-interactive-p-OBSOLETE")))) ((eq op 'byte-forward-char) (let nil nil (comp-emit-set-call-subr 'forward-char 0))) ((eq op 'byte-forward-word) (let nil nil (comp-emit-set-call-subr 'forward-word 0))) ((eq op 'byte-skip-chars-forward) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-forward -1))) ((eq op 'byte-skip-chars-backward) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'skip-chars-backward -1))) ((eq op 'byte-forward-line) (let nil nil (comp-emit-set-call-subr 'forward-line 0))) ((eq op 'byte-char-syntax) (let nil nil (comp-emit-set-call-subr 'char-syntax 0))) ((eq op 'byte-buffer-substring) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'buffer-substring -1))) ((eq op 'byte-delete-region) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'delete-region -1))) ((eq op 'byte-narrow-to-region) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call (comp-call 'narrow-to-region (comp-slot) (comp-slot+1))))) ((eq op 'byte-widen) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-set-call (comp-call 'widen)))) ((eq op 'byte-end-of-line) (let nil nil (comp-emit-set-call-subr 'end-of-line 0))) ((eq op 'byte-constant2) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-constant2")))) ((eq op 'byte-goto) (let nil nil (comp-emit-uncond-jump (cdr (cdr insn))))) ((eq op 'byte-goto-if-nil) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 0 (cdr (cdr insn)) nil))) ((eq op 'byte-goto-if-not-nil) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 0 (cdr (cdr insn)) t))) ((eq op 'byte-goto-if-nil-else-pop) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 1 (cdr (cdr insn)) nil))) ((eq op 'byte-goto-if-not-nil-else-pop) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-cond-jump (comp-slot+1) (make-comp-mvar :constant nil) 1 (cdr (cdr insn)) t))) ((eq op 'byte-return) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (list 'return (comp-slot+1))))) ((eq op 'byte-discard) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) 'pass)) ((eq op 'byte-dup) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-copy-slot (1- (comp-sp))))) ((eq op 'byte-save-excursion) (let nil nil (comp-emit (comp-call 'record_unwind_protect_excursion)))) ((eq op 'byte-save-window-excursion-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-save-window-excursion-OBSOLETE")))) ((eq op 'byte-save-restriction) (let nil nil (comp-emit (comp-call 'helper_save_restriction)))) ((eq op 'byte-catch) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-catch")))) ((eq op 'byte-unwind-protect) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit (comp-call 'helper_unwind_protect (comp-slot+1))))) ((eq op 'byte-condition-case) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-condition-case")))) ((eq op 'byte-temp-output-buffer-setup-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-temp-output-buffer-setup-OBSOLETE")))) ((eq op 'byte-temp-output-buffer-show-OBSOLETE) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-temp-output-buffer-show-OBSOLETE")))) ((eq op 'byte-unbind-all) (let nil (signal 'native-ice (list "unsupported LAP op" '"byte-unbind-all")))) ((eq op 'byte-set-marker) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-set-call-subr 'set-marker -2))) ((eq op 'byte-match-beginning) (let nil nil (comp-emit-set-call-subr 'match-beginning 0))) ((eq op 'byte-match-end) (let nil nil (comp-emit-set-call-subr 'match-end 0))) ((eq op 'byte-upcase) (let nil nil (comp-emit-set-call-subr 'upcase 0))) ((eq op 'byte-downcase) (let nil nil (comp-emit-set-call-subr 'downcase 0))) ((eq op 'byte-string=) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-equal -1))) ((eq op 'byte-string<) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'string-lessp -1))) ((eq op 'byte-equal) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'equal -1))) ((eq op 'byte-nthcdr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nthcdr -1))) ((eq op 'byte-elt) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'elt -1))) ((eq op 'byte-member) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'member -1))) ((eq op 'byte-assq) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'assq -1))) ((eq op 'byte-nreverse) (let nil nil (comp-emit-set-call-subr 'nreverse 0))) ((eq op 'byte-setcar) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'setcar -1))) ((eq op 'byte-setcdr) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'setcdr -1))) ((eq op 'byte-car-safe) (let nil nil (comp-emit-set-call-subr 'car-safe 0))) ((eq op 'byte-cdr-safe) (let nil nil (comp-emit-set-call-subr 'cdr-safe 0))) ((eq op 'byte-nconc) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr 'nconc -1))) ((eq op 'byte-quo) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '/ -1))) ((eq op 'byte-rem) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-emit-set-call-subr '% -1))) ((eq op 'byte-numberp) (let nil nil (comp-emit-set-call-subr 'numberp 0))) ((eq op 'byte-integerp) (let nil nil (comp-emit-set-call-subr 'integerp 0))) ((eq op 'byte-listN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1 arg))))) (comp-emit-set-call (comp-callref 'list arg (comp-sp))))) ((eq op 'byte-concatN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1 arg))))) (comp-emit-set-call (comp-callref 'concat arg (comp-sp))))) ((eq op 'byte-insertN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- 1 arg))))) (comp-emit-set-call (comp-callref 'insert arg (comp-sp))))) ((eq op 'byte-stack-set) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (comp-copy-slot (1+ (comp-sp)) (- (comp-sp) arg -1)))) ((eq op 'byte-stack-set2) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -1)))) (progn (or nil (cl--assertion-failed 'nil)) nil))) ((eq op 'byte-discardN) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))))) ((eq op 'byte-switch) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) -2)))) (comp-emit-switch (comp-slot+1) (cl-first (progn (or (progn (and (memq (type-of (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2))) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2))))) (aref (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 2)) 2)))))) ((eq op 'byte-constant) (let nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit-setimm arg))) ((eq op 'byte-discardN-preserve-tos) (let nil nil (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) (- arg))))) (comp-copy-slot (+ arg (comp-sp))))) (t (let nil (signal 'native-ice (list "unexpected LAP op" (symbol-name op))))))) comp-limplify-lap-inst((byte-constant "DIRECT" . 0)) (progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or (progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst))) (and (consp inst-cell) (progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or (progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst)))) (while (and (consp inst-cell) (progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or (progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst)))) (setq inst-cell (cdr inst-cell)) (setq --cl-var-- nil)) (let* ((inst-cell (nthcdr (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) (progn (or (progn (and (memq (type-of comp-func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument (list 'comp-func comp-func))) (aref comp-func 6)))) (inst nil) (next-inst nil) (--cl-var-- t)) (while (and (consp inst-cell) (progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or (progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst)))) (setq inst-cell (cdr inst-cell)) (setq --cl-var-- nil)) nil) (catch '--cl-block-nil-- (let* ((inst-cell (nthcdr (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) (progn (or (progn (and (memq (type-of comp-func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument (list 'comp-func comp-func))) (aref comp-func 6)))) (inst nil) (next-inst nil) (--cl-var-- t)) (while (and (consp inst-cell) (progn (setq inst (car inst-cell)) (setq next-inst (car-safe (cdr inst-cell))) (comp-limplify-lap-inst inst) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 4 (+ (aref v 4) 1)))) (if (comp-lap-fall-through-p inst) (progn (if (consp next-inst) (let* ((x740 (car-safe next-inst))) (if (eq x740 'TAG) (let* ((x741 (cdr-safe next-inst))) (if (consp x741) (let* ((x742 (car-safe x741)) (x743 (cdr-safe x741))) (let ((_label x742) (label-sp x743)) (if label-sp (progn (progn (or (= (1- label-sp) (comp-sp)) (cl--assertion-failed '(= (1- label-sp) (comp-sp)))) nil))) (let* ((stack-depth (if label-sp (1- label-sp) (comp-sp))) (next-bb (let ((cl-x (comp-bb-maybe-add (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (aref comp-pass 4)) stack-depth))) (progn (or (progn (and (memq (type-of cl-x) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block cl-x))) (aref cl-x 1))))) (if (progn (or (progn (and (memq (type-of bb) cl-struct-comp-block-tags) t)) (signal 'wrong-type-argument (list 'comp-block bb))) (aref bb 3)) nil (comp-emit (list 'jump next-bb)))) (throw '--cl-block-nil-- nil)))))))))) (not (comp-lap-eob-p inst)))) (setq inst-cell (cdr inst-cell)) (setq --cl-var-- nil)) nil)) comp-limplify-block(#s(comp-block-lap :name bb_0 :insns nil :closed nil :in-edges nil :out-edges nil :idom nil :df #<hash-table eql 0/65 0x158ad84a5305> :post-num nil :final-frame nil :sp 0 :addr 0 :non-ret-insn nil :no-ret nil)) (while (progn (setq next-bb (car-safe (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (prog1 x (aset v 6 (cdr x))))))) next-bb) (comp-limplify-block next-bb) (setq --cl-var-- nil)) (let* ((next-bb nil) (--cl-var-- t)) (while (progn (setq next-bb (car-safe (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (prog1 x (aset v 6 (cdr x))))))) next-bb) (comp-limplify-block next-bb) (setq --cl-var-- nil)) nil) (let* ((frame-size (progn (or (progn (and (memq (type-of func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument (list 'comp-func func))) (aref func 8))) (comp-func func) (comp-pass (make-comp-limplify :frame (comp-new-frame frame-size 0)))) (comp-fill-label-h) (comp-make-curr-block 'entry (comp-sp)) (comp-emit-annotation (concat "Lisp function: " (symbol-name (progn (or (progn (and (memq (type-of func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument (list 'comp-func func))) (aref func 1))))) (if (progn (and (memq (type-of func) cl-struct-comp-func-l-tags) t)) (progn (let ((args (progn (or (progn (and (memq (type-of func) cl-struct-comp-func-l-tags) t)) (signal 'wrong-type-argument (list 'comp-func-l func))) (aref func 19)))) (if (progn (and (memq (type-of args) cl-struct-comp-args-tags) t)) (let* ((i 0) (--cl-var-- (progn (or (progn (and (memq (type-of args) cl-struct-comp-args-tags) t)) (signal 'wrong-type-argument (list 'comp-args args))) (aref args 2)))) (while (< i --cl-var--) (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass)) (aset v 3 (+ (comp-sp) 1)))) (comp-emit (list 'set-par-to-local (comp-slot) i)) (setq i (+ i 1))) nil) (comp-emit-narg-prologue (progn (or (progn (and (memq (type-of args) cl-struct-comp-args-base-tags) t)) (signal 'wrong-type-argument (list 'comp-args-base args))) (aref args 1)) (progn (or (progn (and (memq (type-of args) cl-struct-comp-nargs-tags) t)) (signal 'wrong-type-argument (list 'comp-nargs args))) (aref args 2)) (progn (or (progn (and (memq (type-of args) cl-struct-comp-nargs-tags) t)) (signal 'wrong-type-argument (list 'comp-nargs args))) (aref args 3))))))) (comp-emit '(jump bb_0)) (comp-bb-maybe-add 0 (comp-sp)) (let* ((next-bb nil) (--cl-var-- t)) (while (progn (setq next-bb (car-safe (progn (or (progn (and (memq (type-of comp-pass) cl-struct-comp-limplify-tags) t)) (signal 'wrong-type-argument (list 'comp-limplify comp-pass))) (let* ((v comp-pass) (x (aref v 6))) (prog1 x (aset v 6 (cdr x))))))) next-bb) (comp-limplify-block next-bb) (setq --cl-var-- nil)) nil) (let* ((addr-h (make-hash-table)) (addr nil) (--cl-var-- t)) (maphash #'(lambda (--cl-var-- bb) (setq addr (if (progn (and (memq (type-of bb) cl-struct-comp-block-lap-tags) t)) (progn (progn (or (progn (and (memq (type-of bb) cl-struct-comp-block-lap-tags) t)) (signal 'wrong-type-argument (list 'comp-block-lap bb))) (aref bb 11))))) (if addr (progn (progn (or (null (gethash addr addr-h)) (cl--assertion-failed '(null (gethash addr addr-h)))) nil) (puthash addr t addr-h))) (setq --cl-var-- nil)) (progn (or (progn (and (memq (type-of func) cl-struct-comp-func-tags) t)) (signal 'wrong-type-argument (list 'comp-func func))) (aref func 10))) nil) (comp-limplify-finalize-function func)) comp-limplify-function(#s(comp-func-l :name nil :c-name "F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc "DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks #<hash-table eq 3/65 0x158ad8ea2a3d> :lap-block #<hash-table equal 0/65 0x158ad8e035af> :edges-h #<hash-table eql 0/65 0x158ad8eebf5d> :block-cnt-gen (closure ((n . 0) cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+ n))) :edge-cnt-gen (closure ((n . -1) cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+ n))) :has-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :nonrest 0 :rest t))) (closure ((_) cl-struct-comp-limplify-tags cl-struct-comp-mvar-tags cl-struct-comp-func-d-tags cl-struct-comp-func-l-tags cl-struct-comp-func-tags cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) (_ f) (comp-limplify-function f))("F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" #s(comp-func-l :name nil :c-name "F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_0" :byte-func #f(compiled-function (&rest) "DIRECT" #<bytecode -0x976cfd456815730>) :doc "DIRECT\n\n(fn &rest)" :int-spec nil :lap ((byte-constant "DIRECT" . 0) (byte-return . 0)) :ssa-status nil :frame-size 1 :vframe-size 0 :blocks #<hash-table eq 3/65 0x158ad8ea2a3d> :lap-block #<hash-table equal 0/65 0x158ad8e035af> :edges-h #<hash-table eql 0/65 0x158ad8eebf5d> :block-cnt-gen (closure ((n . 0) cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+ n))) :edge-cnt-gen (closure ((n . -1) cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) nil (setq n (1+ n))) :has-non-local nil :speed 2 :pure nil :type nil :args #s(comp-nargs :min 0 :nonrest 0 :rest t))) maphash((closure ((_) cl-struct-comp-limplify-tags cl-struct-comp-mvar-tags cl-struct-comp-func-d-tags cl-struct-comp-func-l-tags cl-struct-comp-func-tags cl-struct-comp-edge-tags cl-struct-comp-block-cstr-tags cl-struct-comp-latch-tags cl-struct-comp-block-lap-tags cl-struct-comp-block-tags cl-struct-comp-nargs-tags cl-struct-comp-args-tags cl-struct-comp-args-base-tags cl-struct-comp-ctxt-tags cl-struct-comp-data-container-tags cl-struct-comp-vec-tags t) (_ f) (comp-limplify-function f)) #<hash-table equal 7/65 0x158ad8e77251>) comp-limplify(nil) funcall(comp-limplify nil) (setq data (funcall pass data)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass nil) (--cl-var-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (if comp-log-time-report (progn (comp-log (format "Done compiling %s" data) 0) (let* ((--cl-var-- (reverse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time (car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (comp-log (format "Pass %s took: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--))) nil))) nil) (condition-case err (let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass nil) (--cl-var-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (if comp-log-time-report (progn (comp-log (format "Done compiling %s" data) 0) (let* ((--cl-var-- (reverse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time (car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (comp-log (format "Pass %s took: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--))) nil))) nil) (native-compiler-skip) (t (let ((err-val (cdr err))) (if (and comp-async-compilation (not (eq (car err) 'native-compiler-error))) (progn (message (if err-val "%s: Error: %s %s" "%s: Error %s") function-or-file (get (car err) 'error-message) (car-safe err-val)) (kill-emacs -1)) (signal (car err) (if (consp err-val) (cons function-or-file err-val) (list function-or-file err-val))))))) (let* ((data function-or-file) (comp-native-compiling t) (byte-native-qualities nil) (byte-compile-debug t) (comp-ctxt (make-comp-ctxt :output output :with-late-load with-late-load))) (comp-log "\n\f\n" 1) (condition-case err (let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass nil) (--cl-var-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (if comp-log-time-report (progn (comp-log (format "Done compiling %s" data) 0) (let* ((--cl-var-- (reverse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time (car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (comp-log (format "Pass %s took: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--))) nil))) nil) (native-compiler-skip) (t (let ((err-val (cdr err))) (if (and comp-async-compilation (not (eq (car err) 'native-compiler-error))) (progn (message (if err-val "%s: Error: %s %s" "%s: Error %s") function-or-file (get (car err) 'error-message) (car-safe err-val)) (kill-emacs -1)) (signal (car err) (if (consp err-val) (cons function-or-file err-val) (list function-or-file err-val))))))) (if (stringp function-or-file) data (native-elisp-load data))) (catch 'no-native-compile (let* ((data function-or-file) (comp-native-compiling t) (byte-native-qualities nil) (byte-compile-debug t) (comp-ctxt (make-comp-ctxt :output output :with-late-load with-late-load))) (comp-log "\n\f\n" 1) (condition-case err (let* ((report nil) (t0 nil) (--cl-var-- comp-passes) (pass nil) (--cl-var-- t)) (while (progn (setq t0 (current-time)) (consp --cl-var--)) (setq pass (car --cl-var--)) (if (memq pass comp-disabled-passes) (progn) (comp-log (format "(%s) Running pass %s:\n" function-or-file pass) 2) (setq data (funcall pass data)) (setq report (cons (cons pass (float-time (time-since t0))) report)) (let* ((--cl-var-- (alist-get pass comp-post-pass-hooks)) (f nil)) (while (consp --cl-var--) (setq f (car --cl-var--)) (funcall f data) (setq --cl-var-- (cdr --cl-var--))) nil)) (setq --cl-var-- (cdr --cl-var--)) (setq --cl-var-- nil)) (if comp-log-time-report (progn (comp-log (format "Done compiling %s" data) 0) (let* ((--cl-var-- (reverse report)) (time nil) (pass nil)) (while (consp --cl-var--) (setq time (car --cl-var--) pass (car-safe (prog1 time (setq time (cdr time))))) (comp-log (format "Pass %s took: %fs." pass time) 0) (setq --cl-var-- (cdr --cl-var--))) nil))) nil) (native-compiler-skip) (t (let ((err-val (cdr err))) (if (and comp-async-compilation (not (eq (car err) 'native-compiler-error))) (progn (message (if err-val "%s: Error: %s %s" "%s: Error %s") function-or-file (get (car err) 'error-message) (car-safe err-val)) (kill-emacs -1)) (signal (car err) (if (consp err-val) (cons function-or-file err-val) (list function-or-file err-val))))))) (if (stringp function-or-file) data (native-elisp-load data)))) comp--native-compile("~/src/elisp/pacproxy.el" nil nil) native-compile("~/src/elisp/pacproxy.el") (progn (native-compile "~/src/elisp/pacproxy.el")) elisp--eval-last-sexp(t) eval-last-sexp(t) eval-print-last-sexp(nil) funcall-interactively(eval-print-last-sexp nil) command-execute(eval-print-last-sexp) -- Michael Welsh Duggan (md5i@md5i.com) ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-04 14:00 ` Michael Welsh Duggan @ 2021-09-05 15:31 ` Michael Welsh Duggan 2021-09-20 22:12 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 22+ messages in thread From: Michael Welsh Duggan @ 2021-09-05 15:31 UTC (permalink / raw) To: 50268; +Cc: Stefan Monnier I was able to determine that there was a bug in the pacproxy.el code that I included in the bug report. Fixing that bug caused native compilation to work. The assertion and backtrace were not particularly useful in determining the bug in the code, though. The bug was in the `pacproxy--retrieve-wpad' function when I let-bound the following illegal lambda: (lambda (&rest) "DIRECT") The fix was to change this to: (lambda (&rest _) "DIRECT") Is there another part of the compiler that could have caught this and returned a useful diagnostic? -- Michael Welsh Duggan (md5i@md5i.com) ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-05 15:31 ` Michael Welsh Duggan @ 2021-09-20 22:12 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-21 7:50 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 22+ messages in thread From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-20 22:12 UTC (permalink / raw) To: Michael Welsh Duggan; +Cc: Stefan Monnier, 50268 Michael Welsh Duggan <mwd@md5i.com> writes: > I was able to determine that there was a bug in the pacproxy.el code > that I included in the bug report. Fixing that bug caused native > compilation to work. The assertion and backtrace were not particularly > useful in determining the bug in the code, though. The bug was in the > `pacproxy--retrieve-wpad' function when I let-bound the following > illegal lambda: > > (lambda (&rest) "DIRECT") > > The fix was to change this to: > > (lambda (&rest _) "DIRECT") > > Is there another part of the compiler that could have caught this and > returned a useful diagnostic? Hi Michael & all, I had a quick look and these are my findings: (byte-compile '(lambda (&rest _) "DIRECT")) => #[128 "\300\207" ["DIRECT"] 2 "DIRECT (fn &rest _)"] Here we have as encoded signature 128 (one rest arg) and the frame size is 2 (one for the rest arg and one for the immediate). Fine... (byte-compile '(lambda () "DIRECT")) => #[0 "\300\207" ["DIRECT"] 1 "DIRECT"] Here we have as encoded signature 0 (no args) and the frame size is 1 (will be used by the immediate). Fine as well. (byte-compile '(lambda (&rest) "DIRECT")) => #[128 "\300\207" ["DIRECT"] 1 "DIRECT (fn &rest)"] This is the problematic case that was signaled as reproducer. Here we have as encoded signature 128 (one rest arg) but the frame size (1) is not accounting for this. I think this output is a incoherent and I guess the byte compiler should probably just raise an error and refuse to compile if the lambda list is invalid. Am I wrong? Regards Andrea ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-20 22:12 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 7:50 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-21 12:17 ` Basil L. Contovounesios via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 22+ messages in thread From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 7:50 UTC (permalink / raw) To: 50268; +Cc: mwd, monnier Andrea Corallo via "Bug reports for GNU Emacs, the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org> writes: > Michael Welsh Duggan <mwd@md5i.com> writes: > >> I was able to determine that there was a bug in the pacproxy.el code >> that I included in the bug report. Fixing that bug caused native >> compilation to work. The assertion and backtrace were not particularly >> useful in determining the bug in the code, though. The bug was in the >> `pacproxy--retrieve-wpad' function when I let-bound the following >> illegal lambda: >> >> (lambda (&rest) "DIRECT") >> >> The fix was to change this to: >> >> (lambda (&rest _) "DIRECT") >> >> Is there another part of the compiler that could have caught this and >> returned a useful diagnostic? > > Hi Michael & all, > > I had a quick look and these are my findings: > > (byte-compile '(lambda (&rest _) "DIRECT")) > => > #[128 "\300\207" ["DIRECT"] 2 "DIRECT > > (fn &rest _)"] > > Here we have as encoded signature 128 (one rest arg) and the frame size > is 2 (one for the rest arg and one for the immediate). Fine... > > (byte-compile '(lambda () "DIRECT")) > => > #[0 "\300\207" ["DIRECT"] 1 "DIRECT"] > > Here we have as encoded signature 0 (no args) and the frame size is 1 > (will be used by the immediate). Fine as well. > > (byte-compile '(lambda (&rest) "DIRECT")) > => > #[128 "\300\207" ["DIRECT"] 1 "DIRECT > > (fn &rest)"] > > This is the problematic case that was signaled as reproducer. Here we > have as encoded signature 128 (one rest arg) but the frame size (1) is > not accounting for this. > > I think this output is a incoherent and I guess the byte compiler should > probably just raise an error and refuse to compile if the lambda list is > invalid. Am I wrong? I can't verify in this moment but I guess is very possible we even overflow in the byte interpreter when executing the mentioned bytecode. Andrea ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 7:50 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 12:17 ` Basil L. Contovounesios via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-21 15:56 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 22+ messages in thread From: Basil L. Contovounesios via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 12:17 UTC (permalink / raw) To: 50268; +Cc: mwd, Mattias Engdegård, monnier, Andrea Corallo Andrea Corallo [2021-09-21 07:50 +0000] wrote: > Andrea Corallo via "Bug reports for GNU Emacs, the Swiss army knife of > text editors" <bug-gnu-emacs@gnu.org> writes: > >> Michael Welsh Duggan <mwd@md5i.com> writes: >> >>> I was able to determine that there was a bug in the pacproxy.el code >>> that I included in the bug report. Fixing that bug caused native >>> compilation to work. The assertion and backtrace were not particularly >>> useful in determining the bug in the code, though. The bug was in the >>> `pacproxy--retrieve-wpad' function when I let-bound the following >>> illegal lambda: >>> >>> (lambda (&rest) "DIRECT") >>> >>> The fix was to change this to: >>> >>> (lambda (&rest _) "DIRECT") >>> >>> Is there another part of the compiler that could have caught this and >>> returned a useful diagnostic? >> >> Hi Michael & all, >> >> I had a quick look and these are my findings: >> >> (byte-compile '(lambda (&rest _) "DIRECT")) >> => >> #[128 "\300\207" ["DIRECT"] 2 "DIRECT >> >> (fn &rest _)"] >> >> Here we have as encoded signature 128 (one rest arg) and the frame size >> is 2 (one for the rest arg and one for the immediate). Fine... >> >> (byte-compile '(lambda () "DIRECT")) >> => >> #[0 "\300\207" ["DIRECT"] 1 "DIRECT"] >> >> Here we have as encoded signature 0 (no args) and the frame size is 1 >> (will be used by the immediate). Fine as well. >> >> (byte-compile '(lambda (&rest) "DIRECT")) >> => >> #[128 "\300\207" ["DIRECT"] 1 "DIRECT >> >> (fn &rest)"] >> >> This is the problematic case that was signaled as reproducer. Here we >> have as encoded signature 128 (one rest arg) but the frame size (1) is >> not accounting for this. >> >> I think this output is a incoherent and I guess the byte compiler should >> probably just raise an error and refuse to compile if the lambda list is >> invalid. Am I wrong? > > I can't verify in this moment but I guess is very possible we even > overflow in the byte interpreter when executing the mentioned bytecode. In the meantime I think Mattias ran into the same problem in the following threads: https://lists.gnu.org/r/emacs-devel/2021-09/msg01492.html https://bugs.gnu.org/50720 Thanks, -- Basil ^ permalink raw reply [flat|nested] 22+ messages in thread
* bug#50268: 28.0.50; Assertion warning during native compilation 2021-09-21 12:17 ` Basil L. Contovounesios via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 15:56 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 0 replies; 22+ messages in thread From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-09-21 15:56 UTC (permalink / raw) To: Basil L. Contovounesios; +Cc: mwd, Mattias Engdegård, monnier, 50268 "Basil L. Contovounesios" <contovob@tcd.ie> writes: > Andrea Corallo [2021-09-21 07:50 +0000] wrote: > [...] >> I can't verify in this moment but I guess is very possible we even >> overflow in the byte interpreter when executing the mentioned bytecode. > > In the meantime I think Mattias ran into the same problem in the > following threads: > > https://lists.gnu.org/r/emacs-devel/2021-09/msg01492.html > https://bugs.gnu.org/50720 > > Thanks, Hi Basil, thanks, if I've done it correctly this and 50720 should be merged now. Regards Andrea ^ permalink raw reply [flat|nested] 22+ messages in thread
end of thread, other threads:[~2021-09-25 18:37 UTC | newest] Thread overview: 22+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2021-09-21 11:15 bug#50720: unnamed &rest broken Mattias Engdegård 2021-09-21 16:11 ` bug#50720: bug#50268: 28.0.50; Assertion warning during native compilation Lars Ingebrigtsen 2021-09-21 16:22 ` Mattias Engdegård 2021-09-21 17:09 ` Noam Postavsky 2021-09-21 17:53 ` Eli Zaretskii 2021-09-21 19:32 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-22 5:43 ` Eli Zaretskii 2021-09-23 1:46 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-23 6:38 ` Eli Zaretskii 2021-09-23 11:09 ` Mattias Engdegård 2021-09-23 21:03 ` Lars Ingebrigtsen 2021-09-24 6:07 ` Eli Zaretskii 2021-09-25 0:51 ` Lars Ingebrigtsen 2021-09-25 18:37 ` Mattias Engdegård 2021-09-21 16:26 ` Eli Zaretskii -- strict thread matches above, loose matches on Subject: below -- 2021-08-30 14:05 Michael Welsh Duggan 2021-09-04 14:00 ` Michael Welsh Duggan 2021-09-05 15:31 ` Michael Welsh Duggan 2021-09-20 22:12 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-21 7:50 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-21 12:17 ` Basil L. Contovounesios via Bug reports for GNU Emacs, the Swiss army knife of text editors 2021-09-21 15:56 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
Code repositories for project(s) associated with this public inbox https://git.savannah.gnu.org/cgit/emacs.git This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).