1 files changed, 64 insertions, 10 deletions

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index ab5920a67e..ec4f9b4339 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -379,6 +379,7 @@ do {                                            \
 #  define NOINLINE
 #endif
 
+int tuple_module_apply;
 
 /*
  * The following functions are called directly by process_main().
@@ -421,6 +422,7 @@ static Eterm add_stacktrace(Process* c_p, Eterm Value, Eterm exc);
 static void save_stacktrace(Process* c_p, BeamInstr* pc, Eterm* reg,
 			    ErtsCodeMFA *bif_mfa, Eterm args);
 static struct StackTrace * get_trace_from_exc(Eterm exc);
+static Eterm *get_freason_ptr_from_exc(Eterm exc);
 static Eterm make_arglist(Process* c_p, Eterm* reg, int a);
 
 void
@@ -579,6 +581,7 @@ init_emulator(void)
  * the instructions' C labels to the loader.
  * The second call starts execution of BEAM code. This call never returns.
  */
+ERTS_NO_RETPOLINE
 void process_main(Eterm * x_reg_array, FloatDef* f_reg_array)
 {
     static int init_done = 0;
@@ -1902,6 +1905,25 @@ static int is_raised_exc(Eterm exc) {
     }
 }
 
+static Eterm *get_freason_ptr_from_exc(Eterm exc) {
+    static Eterm dummy_freason;
+    struct StackTrace* s;
+
+    if (exc == NIL) {
+        /*
+         * Is is not exactly clear when exc can be NIL. Probably only
+         * when the exception has been generated from native code.
+         * Return a pointer to an Eterm that can be safely written and
+         * ignored.
+         */
+	return &dummy_freason;
+    } else {
+	ASSERT(is_list(exc));
+        s = (struct StackTrace *) big_val(CDR(list_val(exc)));
+        return &s->freason;
+    }
+}
+
 /*
  * Creating a list with the argument registers
  */
@@ -2209,6 +2231,7 @@ apply(Process* p, Eterm* reg, BeamInstr *I, Uint stack_offset)
     Eterm module = reg[0];
     Eterm function = reg[1];
     Eterm args = reg[2];
+    Eterm this;
 
     /*
      * Check the arguments which should be of the form apply(Module,
@@ -2231,8 +2254,20 @@ apply(Process* p, Eterm* reg, BeamInstr *I, Uint stack_offset)
 
     while (1) {
 	Eterm m, f, a;
-
-	if (is_not_atom(module)) goto error;
+	/* The module argument may be either an atom or an abstract module
+	 * (currently implemented using tuples, but this might change).
+	 */
+	this = THE_NON_VALUE;
+	if (is_not_atom(module)) {
+	    Eterm* tp;
+
+	    if (!tuple_module_apply || is_not_tuple(module)) goto error;
+	    tp = tuple_val(module);
+	    if (arityval(tp[0]) < 1) goto error;
+	    this = module;
+	    module = tp[1];
+	    if (is_not_atom(module)) goto error;
+	}
 
 	if (module != am_erlang || function != am_apply)
 	    break;
@@ -2267,7 +2302,9 @@ apply(Process* p, Eterm* reg, BeamInstr *I, Uint stack_offset)
     }
     /*
      * Walk down the 3rd parameter of apply (the argument list) and copy
-     * the parameters to the x registers (reg[]).
+     * the parameters to the x registers (reg[]). If the module argument
+     * was an abstract module, add 1 to the function arity and put the
+     * module argument in the n+1st x register as a THIS reference.
      */
 
     tmp = args;
@@ -2284,6 +2321,9 @@ apply(Process* p, Eterm* reg, BeamInstr *I, Uint stack_offset)
     if (is_not_nil(tmp)) {	/* Must be well-formed list */
 	goto error;
     }
+    if (this != THE_NON_VALUE) {
+        reg[arity++] = this;
+    }
 
     /*
      * Get the index into the export table, or failing that the export
@@ -2322,7 +2362,18 @@ fixed_apply(Process* p, Eterm* reg, Uint arity,
 	return 0;
     }
 
-    if (is_not_atom(module)) goto error;
+    /* The module argument may be either an atom or an abstract module
+     * (currently implemented using tuples, but this might change).
+     */
+    if (is_not_atom(module)) {
+	Eterm* tp;
+        if (!tuple_module_apply || is_not_tuple(module)) goto error;
+        tp = tuple_val(module);
+        if (arityval(tp[0]) < 1) goto error;
+        module = tp[1];
+        if (is_not_atom(module)) goto error;
+        ++arity;
+    }
 
     /* Handle apply of apply/3... */
     if (module == am_erlang && function == am_apply && arity == 3) {
@@ -3230,20 +3281,23 @@ erts_is_builtin(Eterm Mod, Eterm Name, int arity)
 
 
 /*
- * Return the current number of reductions for the given process.
+ * Return the current number of reductions consumed by the given process.
  * To get the total number of reductions, p->reds must be added.
  */
 
 Uint
-erts_current_reductions(Process *current, Process *p)
+erts_current_reductions(Process *c_p, Process *p)
 {
-    if (current != p) {
+    Sint reds_left;
+    if (c_p != p || !(erts_atomic32_read_nob(&c_p->state)
+                      & ERTS_PSFLG_RUNNING)) {
 	return 0;
-    } else if (current->fcalls < 0 && ERTS_PROC_GET_SAVED_CALLS_BUF(current)) {
-	return current->fcalls + CONTEXT_REDS;
+    } else if (c_p->fcalls < 0 && ERTS_PROC_GET_SAVED_CALLS_BUF(c_p)) {
+	reds_left = c_p->fcalls + CONTEXT_REDS;
     } else {
-	return REDS_IN(current) - current->fcalls;
+        reds_left = c_p->fcalls;
     }
+    return REDS_IN(c_p) - reds_left - erts_proc_sched_data(p)->virtual_reds;
 }
 
 int