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.

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.

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);
 }
 
+
+/***********************************/
+/* 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);
+}
+
 
 /**************************************/
 /* 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");
 

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

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

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,

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);