unofficial mirror of bug-gnu-emacs@gnu.org 
 help / color / mirror / code / Atom feed
* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
@ 2021-02-14  5:05 Michael Welsh Duggan
  2021-02-18  9:47 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  0 siblings, 1 reply; 23+ messages in thread
From: Michael Welsh Duggan @ 2021-02-14  5:05 UTC (permalink / raw)
  To: 46502

[-- Attachment #1: Type: text/plain, Size: 825 bytes --]

I decided to attempt building the native-comp feature branch, since it
seems like it may make it to mainline fairly soon.  When bootstrapping
with

  make NATIVE_FULL_AOT=1 -j 32 bootstrap

I get an error compiling gnus/gnus-icalendar.el.  I've put the log
below.  I've updated the emacs information from my running emacs below
to match the version of the repository from which I built.


In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
 of 2021-02-13 built on miko
Repository revision: d3a399dd299bf7e811cf42950d5f8ac67f063b36
Repository branch: native-comp
Windowing system distributor 'The X.Org Foundation', version 11.0.12010000
System Description: Debian GNU/Linux bullseye/sid

Configured using:
 'configure --without-toolkit-scroll-bars --with-x-toolkit=lucid --with-nativecomp'


[-- Attachment #2: Type: text/plain, Size: 43624 bytes --]


Debugger entered--Lisp error: (error "Lisp nesting exceeds ‘max-lisp-eval-depth’")
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (args-and-body cl--nmp))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv (cl-next-method-p closure #2 (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #5) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" (propertize ... ... ...) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers ...)) (when (and ... rsvp) (setq headers ...)) (concat (mapconcat ... headers "\n") "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv #2 (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #8) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" ... ...))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let (...) (when ... ...) (concat ... "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (newenv (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv (cl-next-method-p closure #2 (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #5) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" (propertize ... ... ...) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers ...)) (when (and ... rsvp) (setq headers ...)) (concat (mapconcat ... headers "\n") "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv #2 (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #8) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" ... ...))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let (...) (when ... ...) (concat ... "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (newenv (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv (cl-next-method-p closure #2 (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #5) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" (propertize ... ... ...) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers ...)) (when (and ... rsvp) (setq headers ...)) (concat (mapconcat ... headers "\n") "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv #2 (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #8) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" ... ...))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let (...) (when ... ...) (concat ... "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (newenv (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv (cl-next-method-p closure #2 (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #5) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" (propertize ... ... ...) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers ...)) (when (and ... rsvp) (setq headers ...)) (concat (mapconcat ... headers "\n") "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv #2 (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #8) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" ... ...))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let (...) (when ... ...) (concat ... "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (newenv (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv (cl-next-method-p closure #2 (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #5) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" (propertize ... ... ...) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers ...)) (when (and ... rsvp) (setq headers ...)) (concat (mapconcat ... headers "\n") "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv #2 (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #8) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" ... ...))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let (...) (when ... ...) (concat ... "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (newenv (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv (cl-next-method-p closure #2 (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #5) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" (propertize ... ... ...) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers ...)) (when (and ... rsvp) (setq headers ...)) (concat (mapconcat ... headers "\n") "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) (newenv #2 (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) . #8) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))) (binds) (body (cl-labels ((format-header (x) (format "%-12s%s" ... ...))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let (...) (when ... ...) (concat ... "\n\n" description))))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))))
  macroexp--fgrep(((--cl-format-header-- #'(lambda (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (car (cdr x)))))) (newenv (cl-next-method-p closure ((args-and-body cl--nmp) (var . cl--nmp) (binding cl-next-method-p cl--nmp) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-call-next-method closure ((args-and-body cl--cnm) (var . cl--cnm) (binding cl-call-next-method cl--cnm) (--dolist-tail--) #2 (binds) (body (cl-labels ((format-header ... ...)) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ... ... ...)))) (bindings (cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) cl--loop-symbol-macs cl--loop-steps cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-name cl--loop-iterator-function cl--loop-initially cl--loop-first-flag cl--loop-finish-flag cl--loop-finally cl--loop-conditions cl--loop-body cl--loop-bindings cl--loop-accum-vars cl--loop-accum-var cl--loop-args cl--bind-forms cl--bind-lets cl--bind-enquote cl--bind-defs cl--bind-block t) (&rest args) (if (eq (car args) cl--labels-magic) (list cl--labels-magic var) (cons 'funcall (cons var args)))) (cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
...
  macroexpand-all((cl-flet ((cl-call-next-method cl--cnm) (cl-next-method-p cl--nmp)) (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `...)) (when (and (not ...) rsvp) (setq headers (append headers ...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description))))) ((cl-generic-current-method-specializers . #f(compiled-function () #<bytecode 0x1f4000153e91>)) (declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  cl--generic-lambda(((event gnus-icalendar-event) &optional reply-status) ("Format an overview of EVENT details." (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `...)) (when (and (not ...) rsvp) (setq headers (append headers ...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description))))))
  #f(compiled-function (arg1 arg2 &rest rest) "Define a new method for generic function NAME.\nThis it defines an implementation of NAME to use for invocations\nof specific types of arguments.\n\nARGS is a list of dispatch arguments (see `cl-defun'), but where\neach variable element is either just a single variable name VAR,\nor a list on the form (VAR TYPE).\n\nFor instance:\n\n  (cl-defmethod foo (bar (format-string string) &optional zot)\n    (format format-string bar))\n\nThe dispatch arguments have to be among the mandatory arguments, and\nall methods of NAME have to use the same set of arguments for dispatch.\nEach dispatch argument and TYPE are specified in ARGS where the corresponding\nformal argument appears as (VAR TYPE) rather than just VAR.\n\nThe optional second argument QUALIFIER is a specifier that\nmodifies how the method is combined with other methods, including:\n   :before  - Method will be called before the primary\n   :after   - Method will be called after the primary\n   :around  - Method will be called around everything else\nThe absence of QUALIFIER means this is a \"primary\" method.\nThe set of acceptable qualifiers and their meaning is defined\n(and can be extended) by the methods of `cl-generic-combine-methods'.\n\nARGS can also include so-called context specializers, introduced by\n`&context' (which should appear right after the mandatory arguments,\nbefore any &optional or &rest).  They have the form (EXPR TYPE) where\nEXPR is an Elisp expression whose value should match TYPE for the\nmethod to be applicable.\n\nThe set of acceptable TYPEs (also called \"specializers\") is defined\n(and can be extended) by the various methods of `cl-generic-generalizers'." #<bytecode 0xd8ef7e2cfe3ee7b>)(gnus-icalendar-event->gnus-calendar ((event gnus-icalendar-event) &optional reply-status) "Format an overview of EVENT details." (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat (car x) ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `(... ... ... ... ... ...))) (when (and (not (gnus-icalendar-event-reply-p event)) rsvp) (setq headers (append headers `...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description)))))
  macroexpand((cl-defmethod gnus-icalendar-event->gnus-calendar ((event gnus-icalendar-event) &optional reply-status) "Format an overview of EVENT details." (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `...)) (when (and (not ...) rsvp) (setq headers (append headers ...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description))))) ((declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  macroexp-macroexpand((cl-defmethod gnus-icalendar-event->gnus-calendar ((event gnus-icalendar-event) &optional reply-status) "Format an overview of EVENT details." (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `...)) (when (and (not ...) rsvp) (setq headers (append headers ...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description))))) ((declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile . #f(compiled-function (&rest body) #<bytecode 0x5e4fe9ce2dc9015>)) (eval-and-compile . #f(compiled-function (&rest body) #<bytecode 0x1385801da54a6c7b>)) (with-suppressed-warnings . #f(compiled-function (warnings &rest body) #<bytecode -0xfaa1404d6c9c8f7>))))
  byte-compile-recurse-toplevel((cl-defmethod gnus-icalendar-event->gnus-calendar ((event gnus-icalendar-event) &optional reply-status) "Format an overview of EVENT details." (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `...)) (when (and (not ...) rsvp) (setq headers (append headers ...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description))))) #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_45>)
  byte-compile-toplevel-file-form((cl-defmethod gnus-icalendar-event->gnus-calendar ((event gnus-icalendar-event) &optional reply-status) "Format an overview of EVENT details." (cl-labels ((format-header (x) (format "%-12s%s" (propertize (concat ... ":") 'face 'bold) (cadr x)))) (with-slots (organizer summary description location recur uid method rsvp participation-type) event (let ((headers `...)) (when (and (not ...) rsvp) (setq headers (append headers ...))) (concat (mapconcat #'format-header headers "\n") "\n\n" description))))))
  #<subr F616e6f6e796d6f75732d6c616d626461_anonymous_lambda_43>(#<buffer  *Compiler Input*>)
  byte-compile-from-buffer(#<buffer  *Compiler Input*>)
  byte-compile-file("gnus/gnus-icalendar.el")
  #f(compiled-function (filename) "Byte-compile FILENAME spilling data from the byte compiler." #<bytecode 0x4256aac1328e719>)("gnus/gnus-icalendar.el")
  apply(#f(compiled-function (filename) "Byte-compile FILENAME spilling data from the byte compiler." #<bytecode 0x4256aac1328e719>) "gnus/gnus-icalendar.el" nil)
  comp-spill-lap-function("gnus/gnus-icalendar.el")
  comp-spill-lap("gnus/gnus-icalendar.el")
  comp--native-compile("gnus/gnus-icalendar.el")
  batch-native-compile()
  batch-byte-native-compile-for-bootstrap()
  command-line-1(("--eval" "(setq load-prefer-newer t)" "-l" "comp" "-f" "batch-byte-n ELC+ELN   mail/mail-utils.elc
ative-compile-for-bootstrap" "gnus/gnus-icalendar.el"))
  command-line()
  normal-top-level()

make[3]: *** [Makefile:319: gnus/gnus-icalendar.elc] Error 255
make[3]: *** Waiting for unfinished jobs....
make[3]: Leaving directory '/home/md5i/src/emacs/native-comp/lisp'
make[2]: *** [Makefile:353: compile-main] Error 2
make[2]: Leaving directory '/home/md5i/src/emacs/native-comp/lisp'
make[1]: *** [Makefile:421: lisp] Error 2
make[1]: Leaving directory '/home/md5i/src/emacs/native-comp'
make: *** [Makefile:1148: bootstrap] Error 2

[-- Attachment #3: Type: text/plain, Size: 42 bytes --]


-- 
Michael Welsh Duggan
(md5i@md5i.com)

^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-14  5:05 bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure Michael Welsh Duggan
@ 2021-02-18  9:47 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  2021-02-18 10:14   ` Pip Cet
  2021-02-18 14:55   ` Michael Welsh Duggan
  0 siblings, 2 replies; 23+ messages in thread
From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-02-18  9:47 UTC (permalink / raw)
  To: Michael Welsh Duggan; +Cc: 46502

Michael Welsh Duggan <mwd@md5i.com> writes:

> I decided to attempt building the native-comp feature branch, since it
> seems like it may make it to mainline fairly soon.  When bootstrapping
> with
>
>   make NATIVE_FULL_AOT=1 -j 32 bootstrap
>
> I get an error compiling gnus/gnus-icalendar.el.  I've put the log
> below.  I've updated the emacs information from my running emacs below
> to match the version of the repository from which I built.
>
>
> In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
>  of 2021-02-13 built on miko
> Repository revision: d3a399dd299bf7e811cf42950d5f8ac67f063b36
> Repository branch: native-comp
> Windowing system distributor 'The X.Org Foundation', version 11.0.12010000
> System Description: Debian GNU/Linux bullseye/sid
>
> Configured using:
>  'configure --without-toolkit-scroll-bars --with-x-toolkit=lucid --with-nativecomp'
>
>
> Debugger entered--Lisp error: (error "Lisp nesting exceeds ‘max-lisp-eval-depth’")

Hi Michael,

just tried compiling the current branch (f92bb788a0) following your
configuration with no issues.  Could you retry on the current head maybe
starting from a "git clean -xfd" to be on the safe side?

Thanks

  Andrea





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-18  9:47 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
@ 2021-02-18 10:14   ` Pip Cet
  2021-02-18 10:29     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  2021-02-18 14:34     ` Eli Zaretskii
  2021-02-18 14:55   ` Michael Welsh Duggan
  1 sibling, 2 replies; 23+ messages in thread
From: Pip Cet @ 2021-02-18 10:14 UTC (permalink / raw)
  To: Andrea Corallo; +Cc: Michael Welsh Duggan, 46502

On Thu, Feb 18, 2021 at 10:04 AM Andrea Corallo via Bug reports for
GNU Emacs, the Swiss army knife of text editors
<bug-gnu-emacs@gnu.org> wrote:
> Michael Welsh Duggan <mwd@md5i.com> writes:
> > I decided to attempt building the native-comp feature branch, since it
> > seems like it may make it to mainline fairly soon.  When bootstrapping
> > with
> >
> >   make NATIVE_FULL_AOT=1 -j 32 bootstrap
> >
> > I get an error compiling gnus/gnus-icalendar.el.  I've put the log
> > below.  I've updated the emacs information from my running emacs below
> > to match the version of the repository from which I built.
> >
> >
> > In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
> >  of 2021-02-13 built on miko
> > Repository revision: d3a399dd299bf7e811cf42950d5f8ac67f063b36
> > Repository branch: native-comp
> > Windowing system distributor 'The X.Org Foundation', version 11.0.12010000
> > System Description: Debian GNU/Linux bullseye/sid
> >
> > Configured using:
> >  'configure --without-toolkit-scroll-bars --with-x-toolkit=lucid --with-nativecomp'
> >
> >
> > Debugger entered--Lisp error: (error "Lisp nesting exceeds ‘max-lisp-eval-depth’")
>
> Hi Michael,
>
> just tried compiling the current branch (f92bb788a0) following your
> configuration with no issues.  Could you retry on the current head maybe
> starting from a "git clean -xfd" to be on the safe side?

One thing I've noticed in my experiments is that many builds that are
interrupted at the wrong point and then resumed produce different
results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
type "make" again and you get a different result.

We should fix that, and it might lead to the behavior Michael has
observed (macroexp being executed from source code when compiling
gnus)...

BTW, I'm also seeing very deep recursion when building the nativecomp
branch, even outside of the garbage collector (which is easy to "fix"
so it allocates more than one object at the same time on the C stack).
Maybe we can avoid that by doing an -O0 compile first, then compiling
the optimized compiler with the unoptimized one?





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-18 10:14   ` Pip Cet
@ 2021-02-18 10:29     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  2021-02-18 14:34     ` Eli Zaretskii
  1 sibling, 0 replies; 23+ messages in thread
From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-02-18 10:29 UTC (permalink / raw)
  To: Pip Cet; +Cc: Michael Welsh Duggan, 46502

Pip Cet <pipcet@gmail.com> writes:

> On Thu, Feb 18, 2021 at 10:04 AM Andrea Corallo via Bug reports for
> GNU Emacs, the Swiss army knife of text editors
> <bug-gnu-emacs@gnu.org> wrote:
>> Michael Welsh Duggan <mwd@md5i.com> writes:
>> > I decided to attempt building the native-comp feature branch, since it
>> > seems like it may make it to mainline fairly soon.  When bootstrapping
>> > with
>> >
>> >   make NATIVE_FULL_AOT=1 -j 32 bootstrap
>> >
>> > I get an error compiling gnus/gnus-icalendar.el.  I've put the log
>> > below.  I've updated the emacs information from my running emacs below
>> > to match the version of the repository from which I built.
>> >
>> >
>> > In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
>> >  of 2021-02-13 built on miko
>> > Repository revision: d3a399dd299bf7e811cf42950d5f8ac67f063b36
>> > Repository branch: native-comp
>> > Windowing system distributor 'The X.Org Foundation', version 11.0.12010000
>> > System Description: Debian GNU/Linux bullseye/sid
>> >
>> > Configured using:
>> >  'configure --without-toolkit-scroll-bars --with-x-toolkit=lucid --with-nativecomp'
>> >
>> >
>> > Debugger entered--Lisp error: (error "Lisp nesting exceeds ‘max-lisp-eval-depth’")
>>
>> Hi Michael,
>>
>> just tried compiling the current branch (f92bb788a0) following your
>> configuration with no issues.  Could you retry on the current head maybe
>> starting from a "git clean -xfd" to be on the safe side?
>
> One thing I've noticed in my experiments is that many builds that are
> interrupted at the wrong point and then resumed produce different
> results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
> type "make" again and you get a different result.
>
> We should fix that, and it might lead to the behavior Michael has
> observed (macroexp being executed from source code when compiling
> gnus)...
>
> BTW, I'm also seeing very deep recursion when building the nativecomp
> branch, even outside of the garbage collector (which is easy to "fix"
> so it allocates more than one object at the same time on the C stack).
> Maybe we can avoid that by doing an -O0 compile first, then compiling
> the optimized compiler with the unoptimized one?

Agree, I think might be even better in terms of bootstrap time to just
byte compile the initial COMPILE_FIRST files and then re-compiling and
loading them nativelly later-on (before dumping).

Never had time to tackle this.

  Andrea





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-18 10:14   ` Pip Cet
  2021-02-18 10:29     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
@ 2021-02-18 14:34     ` Eli Zaretskii
  2021-02-19 13:31       ` Pip Cet
  1 sibling, 1 reply; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-18 14:34 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, 46502, akrl

> From: Pip Cet <pipcet@gmail.com>
> Date: Thu, 18 Feb 2021 10:14:24 +0000
> Cc: Michael Welsh Duggan <mwd@md5i.com>, 46502@debbugs.gnu.org
> 
> One thing I've noticed in my experiments is that many builds that are
> interrupted at the wrong point and then resumed produce different
> results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
> type "make" again and you get a different result.

What does "different result" mean in this case? is the produced .eln
file different? or something else?

> BTW, I'm also seeing very deep recursion when building the nativecomp
> branch

How do you see that?  And what code recurses so deeply?





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-18  9:47 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  2021-02-18 10:14   ` Pip Cet
@ 2021-02-18 14:55   ` Michael Welsh Duggan
  2021-02-18 15:12     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  1 sibling, 1 reply; 23+ messages in thread
From: Michael Welsh Duggan @ 2021-02-18 14:55 UTC (permalink / raw)
  To: Andrea Corallo; +Cc: Michael Welsh Duggan, 46502

Andrea Corallo <akrl@sdf.org> writes:

> Michael Welsh Duggan <mwd@md5i.com> writes:
>
>> I decided to attempt building the native-comp feature branch, since it
>> seems like it may make it to mainline fairly soon.  When bootstrapping
>> with
>>
>>   make NATIVE_FULL_AOT=1 -j 32 bootstrap
>>
>> I get an error compiling gnus/gnus-icalendar.el.  I've put the log
>> below.  I've updated the emacs information from my running emacs below
>> to match the version of the repository from which I built.
>>
>>
>> In GNU Emacs 28.0.50 (build 1, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
>>  of 2021-02-13 built on miko
>> Repository revision: d3a399dd299bf7e811cf42950d5f8ac67f063b36
>> Repository branch: native-comp
>> Windowing system distributor 'The X.Org Foundation', version 11.0.12010000
>> System Description: Debian GNU/Linux bullseye/sid
>>
>> Configured using:
>>  'configure --without-toolkit-scroll-bars --with-x-toolkit=lucid --with-nativecomp'
>>
>>
>> Debugger entered--Lisp error: (error "Lisp nesting exceeds ‘max-lisp-eval-depth’")
>
> Hi Michael,
>
> just tried compiling the current branch (f92bb788a0) following your
> configuration with no issues.  Could you retry on the current head maybe
> starting from a "git clean -xfd" to be on the safe side?

I do not encounter the problem compiling from the current branch head
(f92bb788a0).  Thank you.

-- 
Michael Welsh Duggan
(md5i@md5i.com)





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-18 14:55   ` Michael Welsh Duggan
@ 2021-02-18 15:12     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  0 siblings, 0 replies; 23+ messages in thread
From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-02-18 15:12 UTC (permalink / raw)
  To: Michael Welsh Duggan; +Cc: 46502-done

Michael Welsh Duggan <mwd@md5i.com> writes:

[...]

>> Hi Michael,
>>
>> just tried compiling the current branch (f92bb788a0) following your
>> configuration with no issues.  Could you retry on the current head maybe
>> starting from a "git clean -xfd" to be on the safe side?
>
> I do not encounter the problem compiling from the current branch head
> (f92bb788a0).  Thank you.

Nice, closing.

Thanks for reporting.

  Andrea





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-18 14:34     ` Eli Zaretskii
@ 2021-02-19 13:31       ` Pip Cet
  2021-02-19 13:48         ` Eli Zaretskii
  0 siblings, 1 reply; 23+ messages in thread
From: Pip Cet @ 2021-02-19 13:31 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: mwd, 46502, akrl

On Thu, Feb 18, 2021 at 2:33 PM Eli Zaretskii <eliz@gnu.org> wrote:
> > From: Pip Cet <pipcet@gmail.com>
> > Date: Thu, 18 Feb 2021 10:14:24 +0000
> > Cc: Michael Welsh Duggan <mwd@md5i.com>, 46502@debbugs.gnu.org
> >
> > One thing I've noticed in my experiments is that many builds that are
> > interrupted at the wrong point and then resumed produce different
> > results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
> > type "make" again and you get a different result.
>
> What does "different result" mean in this case? is the produced .eln
> file different? or something else?

There are differences both in the .elc and .eln, and I saw different
success/failure behavior but only with local modifications. It's
possible that this is all harmless, but I have the bad habit of
assuming I can just type "make" again and have it resume an
interrupted build, and that certainly does not work on the native-comp
branch (I'm not sure it works on the master branch).

Note that all this is in serial builds. That parallelized builds are
unpredictable is a different issue entirely.

> > BTW, I'm also seeing very deep recursion when building the nativecomp
> > branch
> How do you see that?

Stack overflows in a limited-stack environment, even with the GC code
modified to allocate stack space more efficiently.

> And what code recurses so deeply?

Unfortunately, the environment I'm playing with doesn't have very good
backtrace facilities. (This is WebAssembly run by the Mozilla jsshell,
which has a small-ish stack size limit. I'll try finding what limits
the reported backtrace depth and disabling it.)





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-19 13:31       ` Pip Cet
@ 2021-02-19 13:48         ` Eli Zaretskii
  2021-02-19 14:26           ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  2021-02-20  4:35           ` Pip Cet
  0 siblings, 2 replies; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-19 13:48 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, 46502, akrl

> From: Pip Cet <pipcet@gmail.com>
> Date: Fri, 19 Feb 2021 13:31:49 +0000
> Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> 
> > > One thing I've noticed in my experiments is that many builds that are
> > > interrupted at the wrong point and then resumed produce different
> > > results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
> > > type "make" again and you get a different result.
> >
> > What does "different result" mean in this case? is the produced .eln
> > file different? or something else?
> 
> There are differences both in the .elc and .eln, and I saw different
> success/failure behavior but only with local modifications.

Let's talk about *.elc files first, as this is not supposed to happen.
AFAIR, we write the bytecode into a temporary file, and then rename it
atomically only when the compilation finishes successfully.  So
interrupting should not do any harm, and therefore I'm curious what
kind of differences in *.elc files do you see in these cases.

> It's possible that this is all harmless, but I have the bad habit of
> assuming I can just type "make" again and have it resume an
> interrupted build, and that certainly does not work on the
> native-comp branch (I'm not sure it works on the master branch).

I'd suggest to start with master, as that is supposed to be much more
mature.  If that turns out to work correctly (and (IME it is), then we
could take a look at the native-comp branch, where there could be
problems we didn't yet fix.

In general, Make itself will delete any target files it knows about
that were not fully built at the time of SIGINT.  Maybe we don't tell
Make enough about the files native-comp produces?

> > > BTW, I'm also seeing very deep recursion when building the nativecomp
> > > branch
> > How do you see that?
> 
> Stack overflows in a limited-stack environment, even with the GC code
> modified to allocate stack space more efficiently.
> 
> > And what code recurses so deeply?
> 
> Unfortunately, the environment I'm playing with doesn't have very good
> backtrace facilities. (This is WebAssembly run by the Mozilla jsshell,
> which has a small-ish stack size limit. I'll try finding what limits
> the reported backtrace depth and disabling it.)

I think it'd be interesting to know what code overflows the stack, if
it isn't GC.





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-19 13:48         ` Eli Zaretskii
@ 2021-02-19 14:26           ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
  2021-02-20  4:35           ` Pip Cet
  1 sibling, 0 replies; 23+ messages in thread
From: Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-02-19 14:26 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: mwd, 46502, Pip Cet

Eli Zaretskii <eliz@gnu.org> writes:

>> From: Pip Cet <pipcet@gmail.com>
>> Date: Fri, 19 Feb 2021 13:31:49 +0000
>> Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
>> 
>> > > One thing I've noticed in my experiments is that many builds that are
>> > > interrupted at the wrong point and then resumed produce different
>> > > results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
>> > > type "make" again and you get a different result.
>> >
>> > What does "different result" mean in this case? is the produced .eln
>> > file different? or something else?
>> 
>> There are differences both in the .elc and .eln, and I saw different
>> success/failure behavior but only with local modifications.
>
> Let's talk about *.elc files first, as this is not supposed to happen.
> AFAIR, we write the bytecode into a temporary file, and then rename it
> atomically only when the compilation finishes successfully.  So
> interrupting should not do any harm, and therefore I'm curious what
> kind of differences in *.elc files do you see in these cases.

In native-comp this is very similar, the elc renaming is postponed to be
done when native compilation is done and the temporary eln has been
renamed to its final name.  As eln compilation is triggered by the elc
targets this is supposed to work, or at least it *should* as it does on
master.

  Andrea





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-19 13:48         ` Eli Zaretskii
  2021-02-19 14:26           ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
@ 2021-02-20  4:35           ` Pip Cet
  2021-02-20  8:56             ` Eli Zaretskii
  1 sibling, 1 reply; 23+ messages in thread
From: Pip Cet @ 2021-02-20  4:35 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: mwd, 46502, akrl

On Fri, Feb 19, 2021 at 1:47 PM Eli Zaretskii <eliz@gnu.org> wrote:
> > From: Pip Cet <pipcet@gmail.com>
> > Date: Fri, 19 Feb 2021 13:31:49 +0000
> > Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> >
> > > > One thing I've noticed in my experiments is that many builds that are
> > > > interrupted at the wrong point and then resumed produce different
> > > > results. I.e. you type "make", then hit Ctrl-C at the wrong time, then
> > > > type "make" again and you get a different result.
> > >
> > > What does "different result" mean in this case? is the produced .eln
> > > file different? or something else?
> >
> > There are differences both in the .elc and .eln, and I saw different
> > success/failure behavior but only with local modifications.
>
> Let's talk about *.elc files first, as this is not supposed to happen.

Okay. Here's what I'm seeing (master branch, interrupted after
macroexp.elc is compiled).

--- build-uninterrupted/lisp/emacs-lisp/bytecomp.elc    2021-02-20
01:13:51.706632694 +0000
+++ build-interrupted/lisp/emacs-lisp/bytecomp.elc    2021-02-20
02:26:57.242906775 +0000
-(defalias 'byte-compile-form #[513
"\211 :\204H\09\203 \0\211\305>\206
\0\306!\262\203+\09\203$\0\307!\210\310!\210\202\203A\0
   \203A\09\203<\0\307!\210\311
\202f\312!\210\202f@9\2031@\211\313N\314N\206\\\0\n>\315>\203\236\0
A\211:\203\235\0\211@\211:\203\234\0\211@\211\316=\203\233\0A\211:\203\232\0\211@A\211\204\230\0\211
>\203\227\0\317\320\321 \f
#!\210\210\266\210\210\210\210\322>\203\266\0
A\242\211\242\316=\203\265\0\323A@\311\"\210\210\324\325!\203\320\0\211\305>\206\306\0\306!\262\203\320\0\326\327
\"\210\324\314 \"\203\375\0\211\203\375\0\326\330
;\203\355\0\331\332\333  !\"\202\373\0 \334=\204\372\0\320\335
\"\202\373\0\336#\210 @K\242\337=\203 \317\331\340
@#!\210\203)\341!\203)\342=\204) !\266 \202f\343 !\266
\202f\344@!\203E\f\345>\203E\346!\210\202f@\242\347=\203b\350
!\211\262 =\204b\35\"\210\311 \202f\343!\21\205l\352
)\207" [byte-compile--for-effect byte-compile-delete-errors
byte-compile-interactive-only-functions byte-compile-lexical-variables
byte-optimize (nil t) keywordp byte-compile-set-symbol-position
byte-compile-constant nil byte-compile-variable-ref byte-compile
interactive-only (set symbol-value run-hooks add-hook remove-hook
run-hook-with-args run-hook-with-args-until-success
run-hook-with-args-until-failure) quote byte-compile-report-error
format-message "%s cannot use lexical var `%s'" (add-hook remove-hook)
byte-compile-check-variable byte-compile-warning-enabled-p suspicious
byte-compile-warn "`%s' called as a function" "`%s' is for interactive
use only%s" format "; %s" substitute-command-keys t "; use `%s'
instead." "." macro "`%s' defined after use in %S (missing `require'
of a library file?)" functionp cl-byte-compile-compiler-macro
byte-compile-normal-call byte-code-function-p (t lap)
byte-compile-unfold-bcf lambda macroexp--unfold-lambda
byte-compile-form byte-compile-discard] 17 (#$ . 90529)])
\350>\203\221\351!\210\202\262@\242\352=\203\256\353 !\211\262
=\204\256\35\"\210\306 \202\262\346!\21\205\270\355
)\207" [byte-compile--for-effect byte-compile-const-variables
byte-compile-delete-errors byte-compile-interactive-only-functions
byte-compile-lexical-variables byte-optimize nil (nil t) keywordp
boundp (setting-constant) t byte-compile-set-symbol-position
byte-compile-constant byte-compile-variable-ref byte-compile
interactive-only (set symbol-value run-hooks add-hook remove-hook
run-hook-with-args run-hook-with-args-until-success
run-hook-with-args-until-failure) quote byte-compile-report-error
format-message "%s cannot use lexical var `%s'" (add-hook remove-hook)
byte-compile-check-variable byte-compile-warning-enabled-p suspicious
byte-compile-warn "`%s' called as a function" "`%s' is for interactive
use only%s" format "; %s" substitute-command-keys "; use `%s'
instead." "." macro "`%s' defined after use in %S (missing `require'
of a library file?)" functionp cl-byte-compile-compiler-macro
byte-compile-normal-call byte-code-function-p (t lap)
byte-compile-unfold-bcf lambda macroexp--unfold-lambda
byte-compile-form byte-compile-discard] 17 (#$ . 90718)])

It looks like macroexp--const-symbol-p, a defsubst, is substituted in
both cases, but differently. This makes sense to me given the make
rules, and it's not harmful, but I don't like it.

> AFAIR, we write the bytecode into a temporary file, and then rename it
> atomically only when the compilation finishes successfully.  So
> interrupting should not do any harm, and therefore I'm curious what
> kind of differences in *.elc files do you see in these cases.

I'm not sure I'm seeing harmful differences, just ... differences.

So what happens on the three branches appears to be:

master: harmless differences between interrupted make and uninterrupted make
native-comp: interrupting make at the wrong point will sometimes
result in an unbuildable tree
local: interrupting make at the wrong point and resuming it will
sometimes succeed when the uninterrupted build wouldn't have

We should deal with the first two; the third is likely to be related
to my stack size limit or my local changes.

> > It's possible that this is all harmless, but I have the bad habit of
> > assuming I can just type "make" again and have it resume an
> > interrupted build, and that certainly does not work on the
> > native-comp branch (I'm not sure it works on the master branch).
> I'd suggest to start with master, as that is supposed to be much more
> mature.  If that turns out to work correctly (and (IME it is), then we
> could take a look at the native-comp branch, where there could be
> problems we didn't yet fix.

I'll leave it to you to decide whether the harmless differences I've
seen so far count as incorrect behavior.

> In general, Make itself will delete any target files it knows about
> that were not fully built at the time of SIGINT.  Maybe we don't tell
> Make enough about the files native-comp produces?

So we should delete the early-compilation .elcs if we end up deleting
bootstrap-emacs.pdmp, too?

I'll try getting a usable backtrace for the stack overflow.





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20  4:35           ` Pip Cet
@ 2021-02-20  8:56             ` Eli Zaretskii
  2021-02-20  9:15               ` Pip Cet
  0 siblings, 1 reply; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-20  8:56 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, 46502, akrl

> From: Pip Cet <pipcet@gmail.com>
> Date: Sat, 20 Feb 2021 04:35:39 +0000
> Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> 
> Okay. Here's what I'm seeing (master branch, interrupted after
> macroexp.elc is compiled).

It's hard to see the differences, since your MUA seemed to have folded
long lines.  Can you send the diffs as an attachment?

And when exactly did you interrupt the second run?  The first things
that get compiled are these:

  COMPILE_FIRST = \
	  $(lisp)/emacs-lisp/macroexp.elc \
	  $(lisp)/emacs-lisp/cconv.elc    \
	  $(lisp)/emacs-lisp/byte-opt.elc \
	  $(lisp)/emacs-lisp/bytecomp.elc \
	  $(lisp)/emacs-lisp/autoload.elc

Which one of these was being compiled when you pressed Ctrl-C?

> > In general, Make itself will delete any target files it knows about
> > that were not fully built at the time of SIGINT.  Maybe we don't tell
> > Make enough about the files native-comp produces?
> 
> So we should delete the early-compilation .elcs if we end up deleting
> bootstrap-emacs.pdmp, too?

No, I don't think so.  (What is the relation between
bootstrap-emacs.pdmp and the produced *.elc files?)  If the
compilation of these *.elc files has finished, I see no reason to
delete them, because they should be correct and usable.





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20  8:56             ` Eli Zaretskii
@ 2021-02-20  9:15               ` Pip Cet
  2021-02-20 11:21                 ` Eli Zaretskii
  0 siblings, 1 reply; 23+ messages in thread
From: Pip Cet @ 2021-02-20  9:15 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: mwd, 46502, akrl

[-- Attachment #1: Type: text/plain, Size: 2028 bytes --]

On Sat, Feb 20, 2021 at 8:56 AM Eli Zaretskii <eliz@gnu.org> wrote:
> > From: Pip Cet <pipcet@gmail.com>
> > Date: Sat, 20 Feb 2021 04:35:39 +0000
> > Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> >
> > Okay. Here's what I'm seeing (master branch, interrupted after
> > macroexp.elc is compiled).
>
> It's hard to see the differences, since your MUA seemed to have folded
> long lines.

Oh no! Sorry about that.

> Can you send the diffs as an attachment?

I'm sending the complete diff, even though it's a bit large... The
path differences are obviously okay, and I'm not going to complain
about differences in gensym numbering, but byte-optimize-lapcode, to
pick an example at random, differs in the bytecode.

> And when exactly did you interrupt the second run?  The first things
> that get compiled are these:
>
>   COMPILE_FIRST = \
>           $(lisp)/emacs-lisp/macroexp.elc \

HERE

>           $(lisp)/emacs-lisp/cconv.elc    \
>           $(lisp)/emacs-lisp/byte-opt.elc \
>           $(lisp)/emacs-lisp/bytecomp.elc \
>           $(lisp)/emacs-lisp/autoload.elc
>
> Which one of these was being compiled when you pressed Ctrl-C?

cconv.el, after macroexp.el had been compiled successfully.

> > > In general, Make itself will delete any target files it knows about
> > > that were not fully built at the time of SIGINT.  Maybe we don't tell
> > > Make enough about the files native-comp produces?
> >
> > So we should delete the early-compilation .elcs if we end up deleting
> > bootstrap-emacs.pdmp, too?
>
> No, I don't think so.  (What is the relation between
> bootstrap-emacs.pdmp and the produced *.elc files?)

A circular one. bootstrap-emacs.pdmp includes status derived from the
.elc files if those are present before the dump, and it is used to
generate the .elc files otherwise.

> If the
> compilation of these *.elc files has finished, I see no reason to
> delete them, because they should be correct and usable.

Correct and usable, yes. Identical to what they would otherwise have been, no.

[-- Attachment #2: bug46502.diff.gz --]
[-- Type: application/gzip, Size: 261878 bytes --]

^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20  9:15               ` Pip Cet
@ 2021-02-20 11:21                 ` Eli Zaretskii
  2021-02-20 11:48                   ` Eli Zaretskii
  2021-02-20 15:42                   ` Stefan Monnier
  0 siblings, 2 replies; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-20 11:21 UTC (permalink / raw)
  To: Pip Cet, Stefan Monnier; +Cc: mwd, 46502, akrl

> From: Pip Cet <pipcet@gmail.com>
> Date: Sat, 20 Feb 2021 09:15:48 +0000
> Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> 
> > Can you send the diffs as an attachment?
> 
> I'm sending the complete diff, even though it's a bit large... The
> path differences are obviously okay, and I'm not going to complain
> about differences in gensym numbering, but byte-optimize-lapcode, to
> pick an example at random, differs in the bytecode.

Thanks.  Stefan, any idea why we see differences here?

> > And when exactly did you interrupt the second run?  The first things
> > that get compiled are these:
> >
> >   COMPILE_FIRST = \
> >           $(lisp)/emacs-lisp/macroexp.elc \
> 
> HERE
> 
> >           $(lisp)/emacs-lisp/cconv.elc    \
> >           $(lisp)/emacs-lisp/byte-opt.elc \
> >           $(lisp)/emacs-lisp/bytecomp.elc \
> >           $(lisp)/emacs-lisp/autoload.elc
> >
> > Which one of these was being compiled when you pressed Ctrl-C?
> 
> cconv.el, after macroexp.el had been compiled successfully.

So it's possible that in one case the compilation used some of these
files in .elc form, while in the other case they were used in .el
form?

> > > So we should delete the early-compilation .elcs if we end up deleting
> > > bootstrap-emacs.pdmp, too?
> >
> > No, I don't think so.  (What is the relation between
> > bootstrap-emacs.pdmp and the produced *.elc files?)
> 
> A circular one. bootstrap-emacs.pdmp includes status derived from the
> .elc files if those are present before the dump, and it is used to
> generate the .elc files otherwise.

If the differences between the .elc files don't exist, or are
innocent, this doesn't matter, does it?  It's the same as when the
compiler injects the timestamp of the compilation into the object
files it produces.





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 11:21                 ` Eli Zaretskii
@ 2021-02-20 11:48                   ` Eli Zaretskii
  2021-02-20 12:03                     ` Pip Cet
  2021-02-20 15:42                   ` Stefan Monnier
  1 sibling, 1 reply; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-20 11:48 UTC (permalink / raw)
  To: pipcet; +Cc: mwd, monnier, 46502, akrl

> Date: Sat, 20 Feb 2021 13:21:38 +0200
> From: Eli Zaretskii <eliz@gnu.org>
> Cc: mwd@md5i.com, 46502@debbugs.gnu.org, akrl@sdf.org
> 
> > From: Pip Cet <pipcet@gmail.com>
> > Date: Sat, 20 Feb 2021 09:15:48 +0000
> > Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> > 
> > > Can you send the diffs as an attachment?
> > 
> > I'm sending the complete diff, even though it's a bit large... The
> > path differences are obviously okay, and I'm not going to complain
> > about differences in gensym numbering, but byte-optimize-lapcode, to
> > pick an example at random, differs in the bytecode.
> 
> Thanks.  Stefan, any idea why we see differences here?

Btw, if you let macroexp.el byte-compile uninterrupted, then rename
the .elc file and re-compile the .el file, do you get identical .elc
files?





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 11:48                   ` Eli Zaretskii
@ 2021-02-20 12:03                     ` Pip Cet
  2021-02-20 12:42                       ` Eli Zaretskii
  0 siblings, 1 reply; 23+ messages in thread
From: Pip Cet @ 2021-02-20 12:03 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: mwd, Stefan Monnier, 46502, akrl

On Sat, Feb 20, 2021 at 11:48 AM Eli Zaretskii <eliz@gnu.org> wrote:
> > Date: Sat, 20 Feb 2021 13:21:38 +0200
> > From: Eli Zaretskii <eliz@gnu.org>
> > Cc: mwd@md5i.com, 46502@debbugs.gnu.org, akrl@sdf.org
> >
> > > From: Pip Cet <pipcet@gmail.com>
> > > Date: Sat, 20 Feb 2021 09:15:48 +0000
> > > Cc: akrl@sdf.org, mwd@md5i.com, 46502@debbugs.gnu.org
> > >
> > > > Can you send the diffs as an attachment?
> > >
> > > I'm sending the complete diff, even though it's a bit large... The
> > > path differences are obviously okay, and I'm not going to complain
> > > about differences in gensym numbering, but byte-optimize-lapcode, to
> > > pick an example at random, differs in the bytecode.
> >
> > Thanks.  Stefan, any idea why we see differences here?
>
> Btw, if you let macroexp.el byte-compile uninterrupted, then rename
> the .elc file and re-compile the .el file, do you get identical .elc
> files?

So what I did is this:

1. make
2. wait for bootstrap.pdmp to be built
3. wait for macroexp.elc and the other files in compile-first to be generated
4. interrupt
5. rename byte-opt.elc to byte-opt.elc.1
6. make
7. wait for byte-opt.elc to be rebuilt
8. diff

I saw differences as before.

Did you want me to rename "macroexp.elc" in step 5?





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 12:03                     ` Pip Cet
@ 2021-02-20 12:42                       ` Eli Zaretskii
  2021-02-20 17:00                         ` Pip Cet
  0 siblings, 1 reply; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-20 12:42 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, monnier, 46502, akrl

> From: Pip Cet <pipcet@gmail.com>
> Date: Sat, 20 Feb 2021 12:03:42 +0000
> Cc: Stefan Monnier <monnier@iro.umontreal.ca>, mwd@md5i.com, 46502@debbugs.gnu.org, 
> 	akrl@sdf.org
> 
> > Btw, if you let macroexp.el byte-compile uninterrupted, then rename
> > the .elc file and re-compile the .el file, do you get identical .elc
> > files?
> 
> So what I did is this:
> 
> 1. make
> 2. wait for bootstrap.pdmp to be built
> 3. wait for macroexp.elc and the other files in compile-first to be generated
> 4. interrupt
> 5. rename byte-opt.elc to byte-opt.elc.1
> 6. make
> 7. wait for byte-opt.elc to be rebuilt
> 8. diff
> 
> I saw differences as before.
> 
> Did you want me to rename "macroexp.elc" in step 5?

No, you did TRT.

So the conclusion is that the differences have nothing to do with
interrupting the build, they are caused by some of the COMPILE_FIRST
files being not yet compiled?





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 11:21                 ` Eli Zaretskii
  2021-02-20 11:48                   ` Eli Zaretskii
@ 2021-02-20 15:42                   ` Stefan Monnier
  2021-02-20 17:02                     ` Pip Cet
  1 sibling, 1 reply; 23+ messages in thread
From: Stefan Monnier @ 2021-02-20 15:42 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, 46502, akrl

>> > Can you send the diffs as an attachment?
>> 
>> I'm sending the complete diff, even though it's a bit large... The
>> path differences are obviously okay, and I'm not going to complain
>> about differences in gensym numbering, but byte-optimize-lapcode, to
>> pick an example at random, differs in the bytecode.
>
> Thanks.  Stefan, any idea why we see differences here?

One of the possibility is always the inlining (where we either inline
the source code or the bytecode depending on whether the function to be
inlined has already been byte-compiled).

Can you try the patch below to see if it makes a difference?


        Stefan


diff --git a/lisp/emacs-lisp/byte-opt.el b/lisp/emacs-lisp/byte-opt.el
index e0feb95a46..06c925b7bf 100644
--- a/lisp/emacs-lisp/byte-opt.el
+++ b/lisp/emacs-lisp/byte-opt.el
@@ -268,32 +269,16 @@ byte-compile-inline-expand
        ;; The byte-code will be really inlined in byte-compile-unfold-bcf.
        `(,fn ,@(cdr form)))
       ((or `(lambda . ,_) `(closure . ,_))
-       (if (not (or (eq fn localfn)     ;From the same file => same mode.
-                    (eq (car fn)        ;Same mode.
-                        (if lexical-binding 'closure 'lambda))))
-           ;; While byte-compile-unfold-bcf can inline dynbind byte-code into
-           ;; letbind byte-code (or any other combination for that matter), we
-           ;; can only inline dynbind source into dynbind source or letbind
-           ;; source into letbind source.
-           (progn
-             ;; We can of course byte-compile the inlined function
-             ;; first, and then inline its byte-code.
-             (byte-compile name)
-             `(,(symbol-function name) ,@(cdr form)))
-         (let ((newfn (if (eq fn localfn)
-                          ;; If `fn' is from the same file, it has already
-                          ;; been preprocessed!
-                          `(function ,fn)
-                        ;; Try and process it "in its original environment".
-                        (let ((byte-compile-bound-variables nil))
-                          (byte-compile-preprocess
-                           (byte-compile--reify-function fn))))))
-           (if (eq (car-safe newfn) 'function)
-               (macroexp--unfold-lambda `(,(cadr newfn) ,@(cdr form)))
-             ;; This can happen because of macroexp-warn-and-return &co.
-             (byte-compile-warn
-              "Inlining closure %S failed" name)
-             form))))
+       (if (eq fn localfn)     ;From the same file => same mode.
+           (macroexp--unfold-lambda `(,fn ,@(cdr form)))
+         ;; While byte-compile-unfold-bcf can inline dynbind byte-code into
+         ;; letbind byte-code (or any other combination for that matter), we
+         ;; can only inline dynbind source into dynbind source or letbind
+         ;; source into letbind source.
+         ;; We can of course byte-compile the inlined function
+         ;; first, and then inline its byte-code.
+         (byte-compile name)
+         `(,(symbol-function name) ,@(cdr form))))
 
       (_ ;; Give up on inlining.
        form))))






^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 12:42                       ` Eli Zaretskii
@ 2021-02-20 17:00                         ` Pip Cet
  2021-02-20 17:18                           ` Eli Zaretskii
  0 siblings, 1 reply; 23+ messages in thread
From: Pip Cet @ 2021-02-20 17:00 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: mwd, Stefan Monnier, 46502, akrl

On Sat, Feb 20, 2021 at 12:42 PM Eli Zaretskii <eliz@gnu.org> wrote:
> > From: Pip Cet <pipcet@gmail.com>
> > Date: Sat, 20 Feb 2021 12:03:42 +0000
> > Cc: Stefan Monnier <monnier@iro.umontreal.ca>, mwd@md5i.com, 46502@debbugs.gnu.org,
> >       akrl@sdf.org
> So the conclusion is that the differences have nothing to do with
> interrupting the build, they are caused by some of the COMPILE_FIRST
> files being not yet compiled?

Er, I'm not sure what you're saying. They have everything to do with
interrupting the build, of course, it's what causes them. They don't
have anything to do with interrupting Emacs, though, just make. Is
that what you meant?

I'm now convinced the differences, while still vexing, are harmless,
possibly just constant-folding not happening when the defsubst is
inlined. (The weird thing is that the uninterrupted make results in
ever so slightly worse code than the interrupted one.)





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 15:42                   ` Stefan Monnier
@ 2021-02-20 17:02                     ` Pip Cet
  2021-02-20 17:12                       ` Stefan Monnier
  0 siblings, 1 reply; 23+ messages in thread
From: Pip Cet @ 2021-02-20 17:02 UTC (permalink / raw)
  To: Stefan Monnier; +Cc: mwd, 46502, akrl

On Sat, Feb 20, 2021 at 3:42 PM Stefan Monnier <monnier@iro.umontreal.ca> wrote:
> One of the possibility is always the inlining (where we either inline
> the source code or the bytecode depending on whether the function to be
> inlined has already been byte-compiled).

That's what it looks like. Are we supposed to fold constants in both cases?

> Can you try the patch below to see if it makes a difference?

It does, no difference with the patch.





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 17:02                     ` Pip Cet
@ 2021-02-20 17:12                       ` Stefan Monnier
       [not found]                         ` <jwvo8etr7hf.fsf-monnier+emacs@gnu.org>
  0 siblings, 1 reply; 23+ messages in thread
From: Stefan Monnier @ 2021-02-20 17:12 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, 46502, akrl

>> One of the possibility is always the inlining (where we either inline
>> the source code or the bytecode depending on whether the function to be
>> inlined has already been byte-compiled).
> That's what it looks like. Are we supposed to fold constants in both cases?

Not sure what you mean by "fold constants", but when inlining byte-code
we "disassemble" the byte code into LAP code (which is just like byte
code but represented as a Lisp list with symbols) an then splice that
into the LAP code of the caller.  So it tends to lead to slightly less
good code because we don't get to apply the source-level optimizer to
the combination of the caller and callee (but we still do apply the
bytecode (so called "peephole") optimizer).

For example, Mattias's new constant propagation code and the resulting
constant folding opportunities doesn't work as well.

We could change the way `defsubst` works so we *always* inline the
source code[1] (but at the cost of having to keep the source code
around).  But it doesn't seem worth it: we already have `cl-defsubst`
which does just that, and we also have `define-inline` which can do an
even better job.

>> Can you try the patch below to see if it makes a difference?
> It does, no difference with the patch.

So the effect of the patch is that the build is now (more) reproducible?


        Stefan


[1] except when cross-inlining from different dialects, of course.






^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
  2021-02-20 17:00                         ` Pip Cet
@ 2021-02-20 17:18                           ` Eli Zaretskii
  0 siblings, 0 replies; 23+ messages in thread
From: Eli Zaretskii @ 2021-02-20 17:18 UTC (permalink / raw)
  To: Pip Cet; +Cc: mwd, monnier, 46502, akrl

> From: Pip Cet <pipcet@gmail.com>
> Date: Sat, 20 Feb 2021 17:00:44 +0000
> Cc: Stefan Monnier <monnier@iro.umontreal.ca>, mwd@md5i.com, 46502@debbugs.gnu.org, 
> 	akrl@sdf.org
> 
> > So the conclusion is that the differences have nothing to do with
> > interrupting the build, they are caused by some of the COMPILE_FIRST
> > files being not yet compiled?
> 
> Er, I'm not sure what you're saying. They have everything to do with
> interrupting the build, of course, it's what causes them.

??? The build was interrupted after macroexp.el as compiled, so how
can the interrupt affect the next build?





^ permalink raw reply	[flat|nested] 23+ messages in thread

* bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure
       [not found]                         ` <jwvo8etr7hf.fsf-monnier+emacs@gnu.org>
@ 2021-04-05  2:56                           ` Michael Welsh Duggan
  0 siblings, 0 replies; 23+ messages in thread
From: Michael Welsh Duggan @ 2021-04-05  2:56 UTC (permalink / raw)
  To: Stefan Monnier; +Cc: mwd, Pip Cet, 46502, akrl

Stefan Monnier <monnier@iro.umontreal.ca> writes:

> Ping?

Sorry.  Wasn't able to trigger a failure on Friday.  (I tried.)  And
I've had other things to do on the weekend.  I'll be trying again Monday
morning.

>
> Stefan Monnier [2021-02-20 12:12:54] wrote:
>
>>>> One of the possibility is always the inlining (where we either inline
>>>> the source code or the bytecode depending on whether the function to be
>>>> inlined has already been byte-compiled).
>>> That's what it looks like. Are we supposed to fold constants in both cases?
>>
>> Not sure what you mean by "fold constants", but when inlining byte-code
>> we "disassemble" the byte code into LAP code (which is just like byte
>> code but represented as a Lisp list with symbols) an then splice that
>> into the LAP code of the caller.  So it tends to lead to slightly less
>> good code because we don't get to apply the source-level optimizer to
>> the combination of the caller and callee (but we still do apply the
>> bytecode (so called "peephole") optimizer).
>>
>> For example, Mattias's new constant propagation code and the resulting
>> constant folding opportunities doesn't work as well.
>>
>> We could change the way `defsubst` works so we *always* inline the
>> source code[1] (but at the cost of having to keep the source code
>> around).  But it doesn't seem worth it: we already have `cl-defsubst`
>> which does just that, and we also have `define-inline` which can do an
>> even better job.
>>
>>>> Can you try the patch below to see if it makes a difference?
>>> It does, no difference with the patch.
>>
>> So the effect of the patch is that the build is now (more) reproducible?
>>
>>
>>         Stefan
>>
>>
>> [1] except when cross-inlining from different dialects, of course.
>

-- 
Michael Welsh Duggan
(md5i@md5i.com)





^ permalink raw reply	[flat|nested] 23+ messages in thread

end of thread, other threads:[~2021-04-05  2:56 UTC | newest]

Thread overview: 23+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-02-14  5:05 bug#46502: 28.0.50; [feature/native-comp] (d3a399dd) native-comp bootstrap failure Michael Welsh Duggan
2021-02-18  9:47 ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-02-18 10:14   ` Pip Cet
2021-02-18 10:29     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-02-18 14:34     ` Eli Zaretskii
2021-02-19 13:31       ` Pip Cet
2021-02-19 13:48         ` Eli Zaretskii
2021-02-19 14:26           ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors
2021-02-20  4:35           ` Pip Cet
2021-02-20  8:56             ` Eli Zaretskii
2021-02-20  9:15               ` Pip Cet
2021-02-20 11:21                 ` Eli Zaretskii
2021-02-20 11:48                   ` Eli Zaretskii
2021-02-20 12:03                     ` Pip Cet
2021-02-20 12:42                       ` Eli Zaretskii
2021-02-20 17:00                         ` Pip Cet
2021-02-20 17:18                           ` Eli Zaretskii
2021-02-20 15:42                   ` Stefan Monnier
2021-02-20 17:02                     ` Pip Cet
2021-02-20 17:12                       ` Stefan Monnier
     [not found]                         ` <jwvo8etr7hf.fsf-monnier+emacs@gnu.org>
2021-04-05  2:56                           ` Michael Welsh Duggan
2021-02-18 14:55   ` Michael Welsh Duggan
2021-02-18 15:12     ` Andrea Corallo via Bug reports for GNU Emacs, the Swiss army knife of text editors

unofficial mirror of bug-gnu-emacs@gnu.org 

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://yhetil.org/emacs-bugs/0 emacs-bugs/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 emacs-bugs emacs-bugs/ https://yhetil.org/emacs-bugs \
		bug-gnu-emacs@gnu.org
	public-inbox-index emacs-bugs

Example config snippet for mirrors.
Newsgroups are available over NNTP:
	nntp://news.yhetil.org/yhetil.emacs.bugs
	nntp://news.gmane.io/gmane.emacs.bugs


code repositories for project(s) associated with this inbox:

	https://git.savannah.gnu.org/cgit/emacs.git

AGPL code for this site: git clone http://ou63pmih66umazou.onion/public-inbox.git