Trigger native compilation when loading bytecode

Introduce a first mechanism to trigger compilation when lex elc files
are loaded.  This is off by default and has to be better tested.

diff --git a/lisp/emacs-lisp/comp.el b/lisp/emacs-lisp/comp.el
index c00a68307b097e3247634007a83eda037a45b686..0728c4f0a81c0b313ab37f2fa2bf3b4b9fd783ee 100644 (file)
--- a/lisp/emacs-lisp/comp.el
+++ b/lisp/emacs-lisp/comp.el
@@ -40,6 +40,11 @@
   "Emacs Lisp native compiler."
   :group 'lisp)
 
+(defcustom comp-deferred-compilation nil
+  "If t compile asyncronously all lexically bound .elc files being loaded."
+  :type 'boolean
+  :group 'comp)
+
 (defcustom comp-speed 2
   "Compiler optimization level.  From 0 to 3.
 - 0 no optimizations are performed, compile time is favored.

diff --git a/src/comp.c b/src/comp.c
index b9ecef07f327adf92d47898fd5aceb396f5da509..74b74a83b77aacccc4158deba3388dcf53acf98f 100644 (file)
--- a/src/comp.c
+++ b/src/comp.c
@@ -492,7 +492,7 @@ declare_imported_func (Lisp_Object subr_sym, gcc_jit_type *ret_type,
 
   /* String containing the function ptr name.  */
   Lisp_Object f_ptr_name =
-    CALLN (Ffuncall, intern_c_string (STR (comp-c-func-name)),
+    CALLN (Ffuncall, intern_c_string ("comp-c-func-name"),
           subr_sym, make_string ("R", 1));
 
   gcc_jit_type *f_ptr_type =
@@ -3359,6 +3359,40 @@ helper_PSEUDOVECTOR_TYPEP_XUNTAG (Lisp_Object a, enum pvec_type code)
                             code);
 }
 
+\f
+/***********************************/
+/* Deferred compilation mechanism. */
+/***********************************/
+
+void
+maybe_defer_native_compilation (Lisp_Object function_name,
+                               Lisp_Object definition)
+{
+  Lisp_Object src = Qnil;
+  Lisp_Object load_list = Vcurrent_load_list;
+
+  FOR_EACH_TAIL (load_list)
+    {
+      src = XCAR (load_list);
+      if (!CONSP (src))
+       break;
+    }
+
+  if (!comp_deferred_compilation
+      || noninteractive
+      || !NILP (Vpurify_flag)
+      || !COMPILEDP (definition)
+      || !FIXNUMP (AREF (definition, COMPILED_ARGLIST))
+      || !STRINGP (src)
+      || !suffix_p (src, ".elc"))
+    return;
+
+  src = concat2 (CALL1I (file-name-sans-extension, src),
+                build_pure_c_string (".el"));
+  if (!NILP (Ffile_exists_p (src)))
+    CALLN (Ffuncall, intern_c_string ("native-compile-async"), src, Qnil);
+}
+
 \f
 /**************************************/
 /* Functions used to load eln files.  */
@@ -3552,6 +3586,8 @@ void
 syms_of_comp (void)
 {
   /* Compiler control customizes.  */
+  DEFVAR_BOOL ("comp-deferred-compilation", comp_deferred_compilation,
+              doc: /* If t compile asyncronously every .elc file loaded.  */);
   DEFSYM (Qcomp_speed, "comp-speed");
   DEFSYM (Qcomp_debug, "comp-debug");
 

diff --git a/src/comp.h b/src/comp.h
index 070ec4d5ca95c282bc7dab88f541be586090d0a4..f3bcd4c09bc91fbac2f162e8391ebbf6f161a9a6 100644 (file)
--- a/src/comp.h
+++ b/src/comp.h
@@ -68,5 +68,15 @@ extern void load_comp_unit (struct Lisp_Native_Comp_Unit *comp_u,
                            bool loading_dump);
 extern void syms_of_comp (void);
 
+extern void maybe_defer_native_compilation (Lisp_Object function_name,
+                                           Lisp_Object definition);
+#else
+
+static inline void
+maybe_defer_native_compilation (Lisp_Object function_name,
+                               Lisp_Object definition)
+{}
+
 #endif
+
 #endif

diff --git a/src/data.c b/src/data.c
index 8a0546ce09b47607bad31cbef7f0b9d4c1098371..173b92c5bf4df9cc73b8528a1fba832770d23ab9 100644 (file)
--- a/src/data.c
+++ b/src/data.c
@@ -814,6 +814,8 @@ The return value is undefined.  */)
       Ffset (symbol, definition);
   }
 
+  maybe_defer_native_compilation (symbol, definition);
+
   if (!NILP (docstring))
     Fput (symbol, Qfunction_documentation, docstring);
   /* We used to return `definition', but now that `defun' and `defmacro' expand

diff --git a/src/lisp.h b/src/lisp.h
index cd543f5047d556bcb712ce4d27da0f8a408f876e..969597648794e425b631882d5b92d4b0c71773f9 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4102,6 +4102,7 @@ LOADHIST_ATTACH (Lisp_Object x)
   if (initialized)
     Vcurrent_load_list = Fcons (x, Vcurrent_load_list);
 }
+extern bool suffix_p (Lisp_Object, const char *);
 extern Lisp_Object save_match_data_load (Lisp_Object, Lisp_Object, Lisp_Object,
                                         Lisp_Object, Lisp_Object);
 extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,

diff --git a/src/lread.c b/src/lread.c
index 32c83bfae8b3b672c528b5e76bab42b91e607b2d..2d90bccdc07c8c6f6e973ab82fa5e77964393b79 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -1077,7 +1077,7 @@ effective_load_path (void)
 }
 
 /* Return true if STRING ends with SUFFIX.  */
-static bool
+bool
 suffix_p (Lisp_Object string, const char *suffix)
 {
   ptrdiff_t suffix_len = strlen (suffix);