simplify limple instruction set

diff --git a/lisp/emacs-lisp/comp.el b/lisp/emacs-lisp/comp.el
index bac1c6af696e243aef8c4e719883c992fc4f2b43..0270788e215d3092ebacae20fa5e2fc557ac4e87 100644 (file)
--- a/lisp/emacs-lisp/comp.el
+++ b/lisp/emacs-lisp/comp.el
@@ -197,7 +197,7 @@ To be used when ncall-conv is nil.")
         (make-comp-mvar :slot (comp-sp)
                         :type (alist-get (cadr src-slot)
                                          comp-known-ret-types)))
-  (push (list '=call (comp-slot) src-slot) comp-limple))
+  (push (list 'set (comp-slot) src-slot) comp-limple))
 
 (defun comp-push-slot-n (n)
   "Push slot number N into frame."
@@ -207,7 +207,7 @@ To be used when ncall-conv is nil.")
     (setf (comp-slot)
           (copy-sequence src-slot))
     (setf (comp-mvar-slot (comp-slot)) (comp-sp))
-    (push (list '=slot (comp-slot) src-slot) comp-limple)))
+    (push (list 'set (comp-slot) src-slot) comp-limple)))
 
 (defun comp-emit-annotation (str)
   "Emit annotation STR."
@@ -220,7 +220,7 @@ VAL is known at compile time."
   (setf (comp-slot) (make-comp-mvar :slot (comp-sp)
                                     :const-vld t
                                     :constant val))
-  (push (list '=const (comp-slot) val) comp-limple))
+  (push (list 'setimm (comp-slot) val) comp-limple))
 
 (defun comp-push-block (bblock)
   "Push basic block BBLOCK."
@@ -306,7 +306,7 @@ VAL is known at compile time."
     (cl-loop for i below (comp-args-mandatory (comp-func-args func))
              do (progn
                   (cl-incf (comp-sp))
-                  (push `(=par ,(comp-slot) ,i) comp-limple)))
+                  (push `(setpar ,(comp-slot) ,i) comp-limple)))
     (push '(jump body) comp-limple)
     ;; Body
     (comp-push-block 'body)

diff --git a/src/comp.c b/src/comp.c
index 1d6eaf6648e7ae11434d97723a793843e6ce90e2..cbbc5f0378279dca5db3d7f435776d3970f949cb 100644 (file)
--- a/src/comp.c
+++ b/src/comp.c
@@ -951,12 +951,12 @@ emit_PURE_P (gcc_jit_rvalue *ptr)
 /*   return emit_call (f_name, comp.lisp_obj_type, 2, args); */
 /* } */
 
-/* Retrive an r-value from a meta variable.
+/* Emit an r-value from an mvar meta variable.
    In case this is a constant that was propagated return it otherwise load it
-   from the frame.  */
+   from frame.  */
 
 static gcc_jit_rvalue *
-retrive_mvar_val (Lisp_Object mvar)
+emit_mvar_val (Lisp_Object mvar)
 {
   if (NILP (FUNCALL1 (comp-mvar-const-vld, mvar)))
     return
@@ -971,6 +971,7 @@ emit_limple_inst (Lisp_Object inst)
 {
   Lisp_Object op = XCAR (inst);
   Lisp_Object arg0 = SECOND (inst);
+  gcc_jit_rvalue *res;
 
   if (EQ (op, Qblock))
     {
@@ -984,40 +985,43 @@ emit_limple_inst (Lisp_Object inst)
       gcc_jit_block_end_with_jump (comp.block, NULL, target);
       comp.block = target;
     }
-  else if (EQ (op, Qcall_ass))
+  else if (EQ (op, Qset))
     {
-      /*
-         Ex: (=call #s(comp-mvar 6 1 nil nil nil)
-                   (call Fcar #s(comp-mvar 4 0 nil nil nil)))
-
-        Ex: (=call #s(comp-mvar 5 0 nil nil cons)
-                    (call Fcons #s(comp-mvar 3 0 t 1 nil)
-                               #s(comp-mvar 4 nil t nil nil)))
-      */
       EMACS_UINT slot_n = XFIXNUM (FUNCALL1 (comp-mvar-slot, arg0));
       Lisp_Object arg1 = THIRD (inst);
 
-      if (FIRST (arg1) == Qcall)
+      if (EQ (Ftype_of (arg1), Qcomp_mvar))
        {
-         char *calle = (char *) SDATA (SYMBOL_NAME (SECOND (arg1)));
+       /*
+          Ex: (= #s(comp-mvar 6 2 nil nil nil)
+                  #s(comp-mvar 6 0 nil nil nil)).
+       */
+         res = emit_mvar_val (arg1);
+       }
+      else if (EQ (FIRST (arg1), Qcall))
+       {
+         /*
+           Ex: (= #s(comp-mvar 6 1 nil nil nil)
+                  (call Fcar #s(comp-mvar 4 0 nil nil nil)))
+
+           Ex: (= #s(comp-mvar 5 0 nil nil cons)
+                  (call Fcons #s(comp-mvar 3 0 t 1 nil)
+                        #s(comp-mvar 4 nil t nil nil)))
+         */
 
+         char *calle = (char *) SDATA (SYMBOL_NAME (SECOND (arg1)));
          Lisp_Object call_args = XCDR (XCDR (arg1));
          ptrdiff_t nargs = list_length (call_args);
          gcc_jit_rvalue *gcc_args[nargs];
          int i = 0;
          FOR_EACH_TAIL (call_args)
-           gcc_args[i++] = retrive_mvar_val (XCAR (call_args));
-         gcc_jit_rvalue *res =
-           emit_call (calle, comp.lisp_obj_type, nargs, gcc_args);
-
-         gcc_jit_block_add_assignment (comp.block,
-                                       NULL,
-                                       comp.frame[slot_n],
-                                       res);
+           gcc_args[i++] = emit_mvar_val (XCAR (call_args));
+         res = emit_call (calle, comp.lisp_obj_type, nargs, gcc_args);
        }
-      else if ((FIRST (arg1) == Qcallref))
+      else if (EQ (FIRST (arg1), Qcallref))
        {
-         /* Ex: (=call #s(comp-mvar 10 1 nil nil nil) (callref Fplus 2 0)).  */
+         /* Ex: (= #s(comp-mvar 10 1 nil nil nil) (callref Fplus 2 0)).  */
+
          char *calle = (char *) SDATA (SYMBOL_NAME (SECOND (arg1)));
          EMACS_UINT nargs = XFIXNUM (THIRD (arg1));
          EMACS_UINT base_ptr = XFIXNUM (FORTH (arg1));
@@ -1028,17 +1032,18 @@ emit_limple_inst (Lisp_Object inst)
              gcc_jit_lvalue_get_address (
                comp.frame[base_ptr],
                NULL) };
-         gcc_jit_rvalue *res =
-           emit_call (calle, comp.lisp_obj_type, 2, gcc_args);
-         gcc_jit_block_add_assignment (comp.block,
-                                       NULL,
-                                       comp.frame[slot_n],
-                                       res);
+         res = emit_call (calle, comp.lisp_obj_type, 2, gcc_args);
        }
       else
-       error ("LIMPLE inconsistent arg1 for op =call");
+       {
+         error ("LIMPLE inconsistent arg1 for op =");
+       }
+      gcc_jit_block_add_assignment (comp.block,
+                                   NULL,
+                                   comp.frame[slot_n],
+                                   res);
     }
-  else if (EQ (op, Qpar_ass))
+  else if (EQ (op, Qsetpar))
     {
       /* Ex: (=par #s(comp-mvar 2 0 nil nil nil) 0).  */
       EMACS_UINT slot_n = XFIXNUM (FUNCALL1 (comp-mvar-slot, arg0));
@@ -1051,9 +1056,9 @@ emit_limple_inst (Lisp_Object inst)
                                    comp.frame[slot_n],
                                    param);
     }
-  else if (EQ (op, Qconst_ass))
+  else if (EQ (op, Qsetimm))
     {
-      /* EX: (=const #s(comp-mvar 9 1 t 3 nil) 3).  */
+      /* EX: (=imm #s(comp-mvar 9 1 t 3 nil) 3).  */
       Lisp_Object arg1 = THIRD (inst);
       EMACS_UINT slot_n = XFIXNUM (FUNCALL1 (comp-mvar-slot, arg0));
       gcc_jit_block_add_assignment (comp.block,
@@ -1070,7 +1075,7 @@ emit_limple_inst (Lisp_Object inst)
     {
       gcc_jit_block_end_with_return (comp.block,
                                     NULL,
-                                    retrive_mvar_val (arg0));
+                                    emit_mvar_val (arg0));
     }
 }
 
@@ -2054,10 +2059,10 @@ syms_of_comp (void)
   DEFSYM (Qcall, "call");
   DEFSYM (Qcallref, "callref");
   DEFSYM (Qncall, "ncall");
-  DEFSYM (Qpar_ass, "=par");
-  DEFSYM (Qcall_ass, "=call");
-  DEFSYM (Qconst_ass, "=const");
+  DEFSYM (Qsetpar, "setpar");
+  DEFSYM (Qsetimm, "setimm");
   DEFSYM (Qreturn, "return");
+  DEFSYM (Qcomp_mvar, "comp-mvar");
 
   defsubr (&Scomp_init_ctxt);
   defsubr (&Scomp_release_ctxt);