Merge branch 'sverk/bif-args/OTP-9662'

* sverk/bif-args/OTP-9662:
  erts,hipe: Limited support for hipe cross compilation
  erts-hipe: Change THE_NON_VALUE for HiPE enabled debug emulator
  erts-hipe: Enable debug compiled hipe-VM with lock checker
  erts-hipe: Rename fail_bif_interface_0 to standard_bif_interface_0
  erts-hipe: Deliberate leak of native fun entries
  erts-hipe: Fix new trap conventions for x86, amd64 and ppc
  Store the trap address in p->i
  Store the trap arguments in the X register array
  erts-hipe: Make some primops use new BIF calling convention
  erts-hipe: Adapt generated BIF wrappers for new calling convention
  erts-hipe: Remove obscuring macros in generated assembler code
  erts-hipe: Make hipe enabled emulator compile with new BIF calls
  Simplify the instructions for calling BIFs
  Change the calling convention for BIFs
  Use the proper macros in all BIFs

Conflicts:
	erts/emulator/beam/bif.h
	erts/emulator/beam/erl_bif_info.c

29 files changed, 861 insertions, 808 deletions

diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index fffb172c68..18c5081d4c 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -49,15 +49,18 @@ void dbg_bt(Process* p, Eterm* sp);
 void dbg_where(BeamInstr* addr, Eterm x0, Eterm* reg);
 
 static int print_op(int to, void *to_arg, int op, int size, BeamInstr* addr);
-Eterm
-erts_debug_same_2(Process* p, Eterm term1, Eterm term2)
+
+BIF_RETTYPE
+erts_debug_same_2(BIF_ALIST_2)
 {
-    return (term1 == term2) ? am_true : am_false;
+    return (BIF_ARG_1 == BIF_ARG_2) ? am_true : am_false;
 }
 
-Eterm
-erts_debug_flat_size_1(Process* p, Eterm term)
+BIF_RETTYPE
+erts_debug_flat_size_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm term = BIF_ARG_1;
     Uint size = size_object(term);
 
     if (IS_USMALL(0, size)) {
@@ -68,9 +71,13 @@ erts_debug_flat_size_1(Process* p, Eterm term)
     }
 }
 
-Eterm
-erts_debug_breakpoint_2(Process* p, Eterm MFA, Eterm bool)
+
+BIF_RETTYPE
+erts_debug_breakpoint_2(BIF_ALIST_2)
 {
+    Process* p = BIF_P;
+    Eterm MFA = BIF_ARG_1;
+    Eterm bool = BIF_ARG_2;
     Eterm* tp;
     Eterm mfa[3];
     int i;
@@ -175,9 +182,11 @@ erts_debug_instructions_0(BIF_ALIST_0)
     return res;
 }
 
-Eterm
-erts_debug_disassemble_1(Process* p, Eterm addr)
+BIF_RETTYPE
+erts_debug_disassemble_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm addr = BIF_ARG_1;
     erts_dsprintf_buf_t *dsbufp;
     Eterm* hp;
     Eterm* tp;
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 76912ebbd6..6e6380d6b1 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -303,44 +303,6 @@ extern int count_instructions;
      PROCESS_MAIN_CHK_LOCKS((P));					\
      ERTS_SMP_UNREQ_PROC_MAIN_LOCK((P))
 
-#if defined(HYBRID)
-#  define POST_BIF_GC_SWAPIN_0(_p, _res)				\
-     if (((_p)->mbuf) || (MSO(_p).overhead >= BIN_VHEAP_SZ(_p)) ) {	\
-       _res = erts_gc_after_bif_call((_p), (_res), NULL, 0);		\
-     }									\
-     SWAPIN
-
-#  define POST_BIF_GC_SWAPIN(_p, _res, _regs, _arity)			\
-     if (((_p)->mbuf) || (MSO(_p).overhead >= BIN_VHEAP_SZ(_p)) ) {	\
-       _regs[0] = r(0);							\
-       _res = erts_gc_after_bif_call((_p), (_res), _regs, (_arity));	\
-       r(0) = _regs[0];							\
-     }									\
-     SWAPIN
-#else
-#  define POST_BIF_GC_SWAPIN_0(_p, _res)				\
-     ERTS_SMP_REQ_PROC_MAIN_LOCK((_p));					\
-     PROCESS_MAIN_CHK_LOCKS((_p));					\
-     ERTS_VERIFY_UNUSED_TEMP_ALLOC((_p));				\
-     if (((_p)->mbuf) || (MSO(_p).overhead >= BIN_VHEAP_SZ(_p)) ) {	\
-       _res = erts_gc_after_bif_call((_p), (_res), NULL, 0);		\
-       E = (_p)->stop;							\
-     }									\
-     HTOP = HEAP_TOP((_p))
-
-#  define POST_BIF_GC_SWAPIN(_p, _res, _regs, _arity)			\
-     ERTS_VERIFY_UNUSED_TEMP_ALLOC((_p));				\
-     ERTS_SMP_REQ_PROC_MAIN_LOCK((_p));					\
-     PROCESS_MAIN_CHK_LOCKS((_p));					\
-     if (((_p)->mbuf) || (MSO(_p).overhead >= BIN_VHEAP_SZ(_p)) ) {	\
-       _regs[0] = r(0);							\
-       _res = erts_gc_after_bif_call((_p), (_res), _regs, (_arity));	\
-       r(0) = _regs[0];							\
-       E = (_p)->stop;							\
-     }									\
-     HTOP = HEAP_TOP((_p))
-#endif
-
 #define db(N) (N)
 #define tb(N) (N)
 #define xb(N) (*(Eterm *) (((unsigned char *)reg) + (N)))
@@ -794,11 +756,11 @@ extern int count_instructions;
      }						\
   } while (0)
 
-#define IsFunction2(F, A, Action)		\
-  do {						\
-     if (is_function_2(c_p, F, A) != am_true ) {\
-          Action;				\
-     }						\
+#define IsFunction2(F, A, Action)			\
+  do {							\
+     if (erl_is_function(c_p, F, A) != am_true ) {	\
+          Action;					\
+     }							\
   } while (0)
 
 #define IsTupleOfArity(Src, Arity, Fail)				      \
@@ -1541,9 +1503,17 @@ void process_main(void)
 
      PRE_BIF_SWAPOUT(c_p);
      c_p->fcalls = FCALLS - 1;
-     result = send_2(c_p, r(0), x(1));
+     reg[0] = r(0);
+     result = erl_send(c_p, r(0), x(1));
      PreFetch(0, next);
-     POST_BIF_GC_SWAPIN(c_p, result, reg, 2);
+     ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
+     PROCESS_MAIN_CHK_LOCKS(c_p);
+     if (c_p->mbuf || MSO(c_p).overhead >= BIN_VHEAP_SZ(c_p)) {
+	 result = erts_gc_after_bif_call(c_p, result, reg, 2);
+	 r(0) = reg[0];
+	 E = c_p->stop;
+     }
+     HTOP = HEAP_TOP(c_p);
      FCALLS = c_p->fcalls;
      if (is_value(result)) {
 	 r(0) = result;
@@ -1551,10 +1521,9 @@ void process_main(void)
 	 NextPF(0, next);
      } else if (c_p->freason == TRAP) {
 	 SET_CP(c_p, I+1);
-	 SET_I(*((BeamInstr **) (BeamInstr) ((c_p)->def_arg_reg + 3)));
+	 SET_I(c_p->i);
 	 SWAPIN;
-	 r(0) = c_p->def_arg_reg[0];
-	 x(1) = c_p->def_arg_reg[1];
+	 r(0) = reg[0];
 	 Dispatch();
      }
      goto find_func_info;
@@ -2209,16 +2178,16 @@ void process_main(void)
 
  OpCase(bif1_fbsd):
     {
-	Eterm (*bf)(Process*, Eterm);
-	Eterm arg;
+	Eterm (*bf)(Process*, Eterm*);
+	Eterm tmp_reg[1];
 	Eterm result;
 
-	GetArg1(2, arg);
+	GetArg1(2, tmp_reg[0]);
 	bf = (BifFunction) Arg(1);
 	c_p->fcalls = FCALLS;
 	PROCESS_MAIN_CHK_LOCKS(c_p);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, arg);
+	result = (*bf)(c_p, tmp_reg);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 	ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
 	PROCESS_MAIN_CHK_LOCKS(c_p);
@@ -2237,17 +2206,17 @@ void process_main(void)
 
  OpCase(bif1_body_bsd):
     {
-	Eterm (*bf)(Process*, Eterm);
+	Eterm (*bf)(Process*, Eterm*);
 
-	Eterm arg;
+	Eterm tmp_reg[1];
 	Eterm result;
 
-	GetArg1(1, arg);
+	GetArg1(1, tmp_reg[0]);
 	bf = (BifFunction) Arg(0);
 	c_p->fcalls = FCALLS;
 	PROCESS_MAIN_CHK_LOCKS(c_p);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, arg);
+	result = (*bf)(c_p, tmp_reg);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 	ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
 	PROCESS_MAIN_CHK_LOCKS(c_p);
@@ -2256,7 +2225,7 @@ void process_main(void)
 	if (is_value(result)) {
 	    StoreBifResult(2, result);
 	}
-	reg[0] = arg;
+	reg[0] = tmp_reg[0];
 	SWAPOUT;
 	I = handle_error(c_p, I, reg, bf);
 	goto post_error_handling;
@@ -2380,14 +2349,15 @@ void process_main(void)
   */
  OpCase(i_bif2_fbd):
     {
-	Eterm (*bf)(Process*, Eterm, Eterm);
+	Eterm tmp_reg[2] = {tmp_arg1, tmp_arg2};
+	Eterm (*bf)(Process*, Eterm*);
 	Eterm result;
 
 	bf = (BifFunction) Arg(1);
 	c_p->fcalls = FCALLS;
 	PROCESS_MAIN_CHK_LOCKS(c_p);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, tmp_arg1, tmp_arg2);
+	result = (*bf)(c_p, tmp_reg);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 	ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
 	PROCESS_MAIN_CHK_LOCKS(c_p);
@@ -2405,13 +2375,14 @@ void process_main(void)
   */
  OpCase(i_bif2_body_bd):
     {
-	Eterm (*bf)(Process*, Eterm, Eterm);
+	Eterm tmp_reg[2] = {tmp_arg1, tmp_arg2};
+	Eterm (*bf)(Process*, Eterm*);
 	Eterm result;
 
 	bf = (BifFunction) Arg(0);
 	PROCESS_MAIN_CHK_LOCKS(c_p);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, tmp_arg1, tmp_arg2);
+	result = (*bf)(c_p, tmp_reg);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 	ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
 	PROCESS_MAIN_CHK_LOCKS(c_p);
@@ -2431,77 +2402,9 @@ void process_main(void)
      * The most general BIF call.  The BIF may build any amount of data
      * on the heap.  The result is always returned in r(0).
      */
- OpCase(call_bif0_e):
-    {
-	Eterm (*bf)(Process*, BeamInstr*) = GET_BIF_ADDRESS(Arg(0));
-
-	PRE_BIF_SWAPOUT(c_p);
-	c_p->fcalls = FCALLS - 1;
-	if (FCALLS <= 0) {
-	    save_calls(c_p, (Export *) Arg(0));
-	}
-
-	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	r(0) = (*bf)(c_p, I);
-	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(r(0)));
-	ERTS_HOLE_CHECK(c_p);
-	POST_BIF_GC_SWAPIN_0(c_p, r(0));
-	FCALLS = c_p->fcalls;
-	if (is_value(r(0))) {
-	    CHECK_TERM(r(0));
-	    Next(1);
-	}
-	else if (c_p->freason == TRAP) {
-	    goto call_bif_trap3;
-	}
-
-	/*
-	 * Error handling.  SWAPOUT is not needed because it was done above.
-	 */
-	ASSERT(c_p->stop == E);
-	reg[0] = r(0);
-	I = handle_error(c_p, I, reg, bf);
-	goto post_error_handling;
-    }
-
- OpCase(call_bif1_e):
-    {
-	Eterm (*bf)(Process*, Eterm, BeamInstr*) = GET_BIF_ADDRESS(Arg(0));
-	Eterm result;
-	BeamInstr *next;
-
-	c_p->fcalls = FCALLS - 1;
-	if (FCALLS <= 0) {
-	    save_calls(c_p, (Export *) Arg(0));
-	}
-	PreFetch(1, next);
-	PRE_BIF_SWAPOUT(c_p);
-	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, r(0), I);
-	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
-	ERTS_HOLE_CHECK(c_p);
-	POST_BIF_GC_SWAPIN(c_p, result, reg, 1);
-	FCALLS = c_p->fcalls;
-        if (is_value(result)) {
-	    r(0) = result;
-	    CHECK_TERM(r(0));
-	    NextPF(1, next);
-	} else if (c_p->freason == TRAP) {
-	    goto call_bif_trap3;
-	}
-
-	/*
-	 * Error handling.  SWAPOUT is not needed because it was done above.
-	 */
-	ASSERT(c_p->stop == E);
-	reg[0] = r(0);
-	I = handle_error(c_p, I, reg, bf);
-	goto post_error_handling;
-    }
-
- OpCase(call_bif2_e):
+ OpCase(call_bif_e):
     {
-	Eterm (*bf)(Process*, Eterm, Eterm, BeamInstr*) = GET_BIF_ADDRESS(Arg(0));
+	Eterm (*bf)(Process*, Eterm*, BeamInstr*) = GET_BIF_ADDRESS(Arg(0));
 	Eterm result;
 	BeamInstr *next;
 
@@ -2511,61 +2414,29 @@ void process_main(void)
 	   save_calls(c_p, (Export *) Arg(0));
 	}
 	PreFetch(1, next);
-	CHECK_TERM(r(0));
-	CHECK_TERM(x(1));
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, r(0), x(1), I);
-	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
-	ERTS_HOLE_CHECK(c_p);
-	POST_BIF_GC_SWAPIN(c_p, result, reg, 2);
-	FCALLS = c_p->fcalls;
-	if (is_value(result)) {
-	    r(0) = result;
-	    CHECK_TERM(r(0));
-	    NextPF(1, next);
-	} else if (c_p->freason == TRAP) {
-	    goto call_bif_trap3;
-	}
-
-	/*
-	 * Error handling.  SWAPOUT is not needed because it was done above.
-	 */
-	ASSERT(c_p->stop == E);
 	reg[0] = r(0);
-	I = handle_error(c_p, I, reg, bf);
-	goto post_error_handling;
-    }
-
- OpCase(call_bif3_e):
-    {
-	Eterm (*bf)(Process*, Eterm, Eterm, Eterm, BeamInstr*) = GET_BIF_ADDRESS(Arg(0));
-	Eterm result;
-	BeamInstr *next;
-
-	PRE_BIF_SWAPOUT(c_p);
-	c_p->fcalls = FCALLS - 1;
-	if (FCALLS <= 0) {
-	   save_calls(c_p, (Export *) Arg(0));
-	}
-	PreFetch(1, next);
-	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-	result = (*bf)(c_p, r(0), x(1), x(2), I);
+	result = (*bf)(c_p, reg, I);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 	ERTS_HOLE_CHECK(c_p);
-	POST_BIF_GC_SWAPIN(c_p, result, reg, 3);
+	ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
+	PROCESS_MAIN_CHK_LOCKS(c_p);
+	if (c_p->mbuf || MSO(c_p).overhead >= BIN_VHEAP_SZ(c_p)) {
+	    Uint arity = ((Export *)Arg(0))->code[2];
+	    result = erts_gc_after_bif_call(c_p, result, reg, arity);
+	    E = c_p->stop;
+	}
+	HTOP = HEAP_TOP(c_p);
 	FCALLS = c_p->fcalls;
 	if (is_value(result)) {
 	    r(0) = result;
 	    CHECK_TERM(r(0));
 	    NextPF(1, next);
 	} else if (c_p->freason == TRAP) {
-	call_bif_trap3:
 	    SET_CP(c_p, I+2);
-	    SET_I(*((BeamInstr **) (UWord) ((c_p)->def_arg_reg + 3)));
+	    SET_I(c_p->i);
 	    SWAPIN;
-	    r(0) = c_p->def_arg_reg[0];
-	    x(1) = c_p->def_arg_reg[1];
-	    x(2) = c_p->def_arg_reg[2];
+	    r(0) = reg[0];
 	    Dispatch();
 	}
 
@@ -2573,7 +2444,6 @@ void process_main(void)
 	 * Error handling.  SWAPOUT is not needed because it was done above.
 	 */
 	ASSERT(c_p->stop == E);
-	reg[0] = r(0);
 	I = handle_error(c_p, I, reg, bf);
 	goto post_error_handling;
     }
@@ -3326,64 +3196,23 @@ void process_main(void)
 	    ASSERT(bif_nif_arity <= 3);
 	    ERTS_SMP_UNREQ_PROC_MAIN_LOCK(c_p);
 	    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-	    switch (bif_nif_arity) {
-	    case 3:
-		{
-		    Eterm (*bf)(Process*, Eterm, Eterm, Eterm, BeamInstr*) = vbf;
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-		    nif_bif_result = (*bf)(c_p, r(0), x(1), x(2), I);
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p) ||
-			   is_non_value(nif_bif_result));
-		    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-		    PROCESS_MAIN_CHK_LOCKS(c_p);
-		}
-		break;
-	    case 2:
-		{
-		    Eterm (*bf)(Process*, Eterm, Eterm, BeamInstr*) = vbf;
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-		    nif_bif_result = (*bf)(c_p, r(0), x(1), I);
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p) ||
-			   is_non_value(nif_bif_result));
-		    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-		    PROCESS_MAIN_CHK_LOCKS(c_p);
-		}
-		break;
-	    case 1:
-		{
-		    Eterm (*bf)(Process*, Eterm, BeamInstr*) = vbf;
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-		    nif_bif_result = (*bf)(c_p, r(0), I);
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p) ||
-			   is_non_value(nif_bif_result));
-		    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-		    PROCESS_MAIN_CHK_LOCKS(c_p);
-		}
-		break;
-	    case 0:
-		{
-		    Eterm (*bf)(Process*, BeamInstr*) = vbf;
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-		    nif_bif_result = (*bf)(c_p, I);
-		    ASSERT(!ERTS_PROC_IS_EXITING(c_p) ||
-			   is_non_value(nif_bif_result));
-		    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-		    PROCESS_MAIN_CHK_LOCKS(c_p);
-		    break;
-		}
-	    default:
-		erl_exit(1, "apply_bif: invalid arity: %u\n",
-			 bif_nif_arity);
+	    reg[0] = r(0);
+	    {
+		Eterm (*bf)(Process*, Eterm*, BeamInstr*) = vbf;
+		ASSERT(!ERTS_PROC_IS_EXITING(c_p));
+		nif_bif_result = (*bf)(c_p, reg, I);
+		ASSERT(!ERTS_PROC_IS_EXITING(c_p) ||
+		       is_non_value(nif_bif_result));
+		ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
+		PROCESS_MAIN_CHK_LOCKS(c_p);
 	    }
 
 	apply_bif_or_nif_epilogue:
 	    ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
 	    ERTS_HOLE_CHECK(c_p);
 	    if (c_p->mbuf) {
-		reg[0] = r(0);
 		nif_bif_result = erts_gc_after_bif_call(c_p, nif_bif_result,
 						  reg, bif_nif_arity);
-		r(0) = reg[0];
 	    }
 	    SWAPIN;  /* There might have been a garbage collection. */
 	    FCALLS = c_p->fcalls;
@@ -3394,17 +3223,14 @@ void process_main(void)
 		c_p->cp = 0;
 		Goto(*I);
 	    } else if (c_p->freason == TRAP) {
-		SET_I(*((BeamInstr **) (UWord) ((c_p)->def_arg_reg + 3)));
-		r(0) = c_p->def_arg_reg[0];
-		x(1) = c_p->def_arg_reg[1];
-		x(2) = c_p->def_arg_reg[2];
+		SET_I(c_p->i);
+		r(0) = reg[0];
 		if (c_p->flags & F_HIBERNATE_SCHED) {
 		    c_p->flags &= ~F_HIBERNATE_SCHED;
 		    goto do_schedule;
 		}
 		Dispatch();
 	    }
-	    reg[0] = r(0);
 	    I = handle_error(c_p, c_p->cp, reg, vbf);
 	    goto post_error_handling;
 	}
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index d82b5dbcac..3836f1ae96 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -5369,9 +5369,12 @@ find_function_from_pc(BeamInstr* pc)
  * Read a specific chunk from a Beam binary.
  */
 
-Eterm
-code_get_chunk_2(Process* p, Eterm Bin, Eterm Chunk)
+BIF_RETTYPE
+code_get_chunk_2(BIF_ALIST_2)
 {
+    Process* p = BIF_P;
+    Eterm Bin = BIF_ARG_1;
+    Eterm Chunk = BIF_ARG_2;
     LoaderState state;
     Uint chunk = 0;
     ErlSubBin* sb;
@@ -5436,9 +5439,11 @@ code_get_chunk_2(Process* p, Eterm Bin, Eterm Chunk)
  * Calculate the MD5 for a module.
  */
   
-Eterm
-code_module_md5_1(Process* p, Eterm Bin)
+BIF_RETTYPE
+code_module_md5_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm Bin = BIF_ARG_1;
     LoaderState state;
     byte* temp_alloc = NULL;
 
@@ -5695,7 +5700,17 @@ patch_funentries(Eterm Patchlist)
 
     fe = erts_get_fun_entry(Mod, uniq, index);
     fe->native_address = (Uint *)native_address;
-    erts_refc_dec(&fe->refc, 1);
+
+    /* Deliberate MEMORY LEAK of native fun entries!!!
+     *
+     * Uncomment line below when hipe code upgrade and purging works correctly.
+     * Today we may get cases when old (leaked) native code of a purged module
+     * gets called and tries to create instances of a deleted fun entry.
+     *
+     * Reproduced on a debug emulator with stdlib_test/qlc_SUITE:join_merge
+     *
+     * erts_refc_dec(&fe->refc, 1);
+     */
 
     if (!patch(Addresses, (Uint) fe))
       return 0;
diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 76086860dd..4bfae7e2db 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -1107,9 +1107,9 @@ BIF_RETTYPE hibernate_3(BIF_ALIST_3)
 
 /**********************************************************************/
 
-BIF_RETTYPE get_stacktrace_0(Process* p)
+BIF_RETTYPE get_stacktrace_0(BIF_ALIST_0)
 {
-    Eterm t = build_stacktrace(p, p->ftrace);
+    Eterm t = build_stacktrace(BIF_P, BIF_P->ftrace);
     BIF_RET(t);
 }
 
@@ -1119,10 +1119,10 @@ BIF_RETTYPE get_stacktrace_0(Process* p)
  * the process, and the final error value will be {Term,StackTrace}.
  */
 
-BIF_RETTYPE error_1(Process* p, Eterm term)
+BIF_RETTYPE error_1(BIF_ALIST_1)
 {
-    p->fvalue = term;
-    BIF_ERROR(p, EXC_ERROR);
+    BIF_P->fvalue = BIF_ARG_1;
+    BIF_ERROR(BIF_P, EXC_ERROR);
 }
 
 /**********************************************************************/
@@ -1131,12 +1131,12 @@ BIF_RETTYPE error_1(Process* p, Eterm term)
  * in the stacktrace.
  */
 
-BIF_RETTYPE error_2(Process* p, Eterm value, Eterm args)
+BIF_RETTYPE error_2(BIF_ALIST_2)
 {
-    Eterm* hp = HAlloc(p, 3);
+    Eterm* hp = HAlloc(BIF_P, 3);
 
-    p->fvalue = TUPLE2(hp, value, args);
-    BIF_ERROR(p, EXC_ERROR_2);
+    BIF_P->fvalue = TUPLE2(hp, BIF_ARG_1, BIF_ARG_2);
+    BIF_ERROR(BIF_P, EXC_ERROR_2);
 }
 
 /**********************************************************************/
@@ -1146,10 +1146,10 @@ BIF_RETTYPE error_2(Process* p, Eterm value, Eterm args)
  * It is useful in stub functions for NIFs.
  */
 
-BIF_RETTYPE nif_error_1(Process* p, Eterm term)
+BIF_RETTYPE nif_error_1(BIF_ALIST_1)
 {
-    p->fvalue = term;
-    BIF_ERROR(p, EXC_ERROR);
+    BIF_P->fvalue = BIF_ARG_1;
+    BIF_ERROR(BIF_P, EXC_ERROR);
 }
 
 /**********************************************************************/
@@ -1159,12 +1159,12 @@ BIF_RETTYPE nif_error_1(Process* p, Eterm term)
  * It is useful in stub functions for NIFs.
  */
 
-BIF_RETTYPE nif_error_2(Process* p, Eterm value, Eterm args)
+BIF_RETTYPE nif_error_2(BIF_ALIST_2)
 {
-    Eterm* hp = HAlloc(p, 3);
+    Eterm* hp = HAlloc(BIF_P, 3);
 
-    p->fvalue = TUPLE2(hp, value, args);
-    BIF_ERROR(p, EXC_ERROR_2);
+    BIF_P->fvalue = TUPLE2(hp, BIF_ARG_1, BIF_ARG_2);
+    BIF_ERROR(BIF_P, EXC_ERROR_2);
 }
 
 /**********************************************************************/
@@ -1183,8 +1183,12 @@ BIF_RETTYPE exit_1(BIF_ALIST_1)
  * If there is an error in the argument format, 
  * return the atom 'badarg' instead.
  */
-Eterm 
-raise_3(Process *c_p, Eterm class, Eterm value, Eterm stacktrace) {
+BIF_RETTYPE raise_3(BIF_ALIST_3)
+{
+    Process *c_p = BIF_P;
+    Eterm class = BIF_ARG_1;
+    Eterm value = BIF_ARG_2;
+    Eterm stacktrace = BIF_ARG_3;
     Eterm reason;
     Eterm l, *hp, *hp_end, *tp;
     int depth, cnt;
@@ -1730,10 +1734,10 @@ BIF_RETTYPE whereis_1(BIF_ALIST_1)
  * erlang:'!'/2
  */
 
-Eterm
-ebif_bang_2(Process* p, Eterm To, Eterm Message)
+BIF_RETTYPE
+ebif_bang_2(BIF_ALIST_2)
 {
-    return send_2(p, To, Message);
+    return erl_send(BIF_P, BIF_ARG_1, BIF_ARG_2);
 }
 
 
@@ -2070,8 +2074,13 @@ do_send(Process *p, Eterm to, Eterm msg, int suspend) {
 }
 
 
-Eterm
-send_3(Process *p, Eterm to, Eterm msg, Eterm opts) {
+BIF_RETTYPE send_3(BIF_ALIST_3)
+{
+    Process *p = BIF_P;
+    Eterm to = BIF_ARG_1;
+    Eterm msg = BIF_ARG_2;
+    Eterm opts = BIF_ARG_3;
+
     int connect = !0;
     int suspend = !0;
     Eterm l = opts;
@@ -2135,8 +2144,13 @@ send_3(Process *p, Eterm to, Eterm msg, Eterm opts) {
     BIF_ERROR(p, BADARG);
 }
 
-Eterm
-send_2(Process *p, Eterm to, Eterm msg) {
+BIF_RETTYPE send_2(BIF_ALIST_2)
+{
+    return erl_send(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+Eterm erl_send(Process *p, Eterm to, Eterm msg)
+{
     Sint result = do_send(p, to, msg, !0);
     
     if (result > 0) {
@@ -3312,8 +3326,11 @@ time_to_parts(Eterm date, Sint* year, Sint* month, Sint* day,
 /* return the universal time */
 
 BIF_RETTYPE 
-localtime_to_universaltime_2(Process *p, Eterm localtime, Eterm dst)
+localtime_to_universaltime_2(BIF_ALIST_2)
 {
+    Process *p = BIF_P;
+    Eterm localtime = BIF_ARG_1;
+    Eterm dst = BIF_ARG_2;
     Sint year, month, day;
     Sint hour, minute, second;
     int isdst;
@@ -3562,9 +3579,10 @@ BIF_RETTYPE erts_debug_display_1(BIF_ALIST_1)
 }
 
 
-Eterm
-display_string_1(Process* p, Eterm string)
+BIF_RETTYPE display_string_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm string = BIF_ARG_1;
     int len = is_string(string);
     char *str;
 
@@ -3580,8 +3598,7 @@ display_string_1(Process* p, Eterm string)
     BIF_RET(am_true);
 }
 
-Eterm
-display_nl_0(Process* p)
+BIF_RETTYPE display_nl_0(BIF_ALIST_0)
 {
     erts_fprintf(stderr, "\n");
     BIF_RET(am_true);
@@ -3645,8 +3662,13 @@ BIF_RETTYPE function_exported_3(BIF_ALIST_3)
 
 /**********************************************************************/    
 
-BIF_RETTYPE is_builtin_3(Process* p, Eterm Mod, Eterm Name, Eterm Arity)
+BIF_RETTYPE is_builtin_3(BIF_ALIST_3)
 {
+    Process* p = BIF_P;
+    Eterm Mod = BIF_ARG_1;
+    Eterm Name = BIF_ARG_2;
+    Eterm Arity = BIF_ARG_3;
+
     if (is_not_atom(Mod) || is_not_atom(Name) || is_not_small(Arity)) {
 	BIF_ERROR(p, BADARG);
     }
@@ -3711,9 +3733,11 @@ BIF_RETTYPE make_fun_3(BIF_ALIST_3)
     BIF_RET(make_export(hp));
 }
 
-Eterm
-fun_to_list_1(Process* p, Eterm fun)
+BIF_RETTYPE fun_to_list_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm fun = BIF_ARG_1;
+
     if (is_not_any_fun(fun))
 	BIF_ERROR(p, BADARG);
     BIF_RET(term2list_dsprintf(p, fun));
@@ -4051,7 +4075,7 @@ BIF_RETTYPE system_flag_2(BIF_ALIST_2)
 	erts_backtrace_depth = n;
 	BIF_RET(make_small(oval));
     } else if (BIF_ARG_1 == am_trace_control_word) {
-	BIF_RET(db_set_trace_control_word_1(BIF_P, BIF_ARG_2));
+	BIF_RET(db_set_trace_control_word(BIF_P, BIF_ARG_2));
     } else if (BIF_ARG_1 == am_sequential_tracer) {
         Eterm old_value = erts_set_system_seq_tracer(BIF_P,
 						     ERTS_PROC_LOCK_MAIN,
diff --git a/erts/emulator/beam/bif.h b/erts/emulator/beam/bif.h
index 66f152a6ea..d20089a9fb 100644
--- a/erts/emulator/beam/bif.h
+++ b/erts/emulator/beam/bif.h
@@ -26,14 +26,14 @@ extern Export* erts_format_cpu_topology_trap;
 
 #define BIF_P A__p
 
-#define BIF_ALIST_0 Process* A__p
-#define BIF_ALIST_1 Process* A__p, Eterm A_1
-#define BIF_ALIST_2 Process* A__p, Eterm A_1, Eterm A_2
-#define BIF_ALIST_3 Process* A__p, Eterm A_1, Eterm A_2, Eterm A_3
+#define BIF_ALIST_0 Process* A__p, Eterm* BIF__ARGS
+#define BIF_ALIST_1 Process* A__p, Eterm* BIF__ARGS
+#define BIF_ALIST_2 Process* A__p, Eterm* BIF__ARGS
+#define BIF_ALIST_3 Process* A__p, Eterm* BIF__ARGS
 
-#define BIF_ARG_1  A_1
-#define BIF_ARG_2  A_2
-#define BIF_ARG_3  A_3
+#define BIF_ARG_1  (BIF__ARGS[0])
+#define BIF_ARG_2  (BIF__ARGS[1])
+#define BIF_ARG_3  (BIF__ARGS[2])
 
 #define BUMP_ALL_REDS(p) do {			\
     if (!ERTS_PROC_GET_SAVED_CALLS_BUF((p))) 	\
@@ -122,100 +122,106 @@ do {						\
 } while (0)
 
 
-#define ERTS_BIF_PREP_TRAP0(Ret, Trap, Proc)		\
-do {							\
-    (Proc)->arity = 0;					\
-    *((UWord *) (UWord) ((Proc)->def_arg_reg + 3)) = (UWord) ((Trap)->address);	\
-    (Proc)->freason = TRAP;				\
-    (Ret) = THE_NON_VALUE;				\
+#define ERTS_BIF_PREP_TRAP0(Ret, Trap, Proc)	\
+do {						\
+    (Proc)->arity = 0;				\
+    (Proc)->i = (BeamInstr*) ((Trap)->address);	\
+    (Proc)->freason = TRAP;			\
+    (Ret) = THE_NON_VALUE;			\
 } while (0)
 
-#define ERTS_BIF_PREP_TRAP1(Ret, Trap, Proc, A0)	\
-do {							\
-    (Proc)->arity = 1;					\
-    (Proc)->def_arg_reg[0] = (Eterm) (A0);		\
-    *((UWord *) (UWord) ((Proc)->def_arg_reg + 3)) = (UWord) ((Trap)->address);	\
-    (Proc)->freason = TRAP;				\
-    (Ret) = THE_NON_VALUE;				\
+#define ERTS_BIF_PREP_TRAP1(Ret, Trap, Proc, A0)		\
+do {								\
+    Eterm* reg = ERTS_PROC_GET_SCHDATA((Proc))->x_reg_array;	\
+    (Proc)->arity = 1;						\
+    reg[0] = (Eterm) (A0);					\
+    (Proc)->i = (BeamInstr*) ((Trap)->address);			\
+    (Proc)->freason = TRAP;					\
+    (Ret) = THE_NON_VALUE;					\
 } while (0)
 
-#define ERTS_BIF_PREP_TRAP2(Ret, Trap, Proc, A0, A1)	\
-do {							\
-    (Proc)->arity = 2;					\
-    (Proc)->def_arg_reg[0] = (Eterm) (A0);		\
-    (Proc)->def_arg_reg[1] = (Eterm) (A1);		\
-    *((UWord *) (UWord) ((Proc)->def_arg_reg + 3)) = (UWord) ((Trap)->address);	\
-    (Proc)->freason = TRAP;				\
-    (Ret) = THE_NON_VALUE;				\
+#define ERTS_BIF_PREP_TRAP2(Ret, Trap, Proc, A0, A1)		\
+do {								\
+    Eterm* reg = ERTS_PROC_GET_SCHDATA((Proc))->x_reg_array;	\
+    (Proc)->arity = 2;						\
+    reg[0] = (Eterm) (A0);					\
+    reg[1] = (Eterm) (A1);					\
+    (Proc)->i = (BeamInstr*) ((Trap)->address);			\
+    (Proc)->freason = TRAP;					\
+    (Ret) = THE_NON_VALUE;					\
 } while (0)
 
-#define ERTS_BIF_PREP_TRAP3(Ret, Trap, Proc, A0, A1, A2)\
-do {							\
-    (Proc)->arity = 3;					\
-    (Proc)->def_arg_reg[0] = (Eterm) (A0);		\
-    (Proc)->def_arg_reg[1] = (Eterm) (A1);		\
-    (Proc)->def_arg_reg[2] = (Eterm) (A2);		\
-    *((UWord *) (UWord) ((Proc)->def_arg_reg + 3)) = (UWord) ((Trap)->address);	\
-    (Proc)->freason = TRAP;				\
-    (Ret) = THE_NON_VALUE;				\
+#define ERTS_BIF_PREP_TRAP3(Ret, Trap, Proc, A0, A1, A2)	\
+do {								\
+    Eterm* reg = ERTS_PROC_GET_SCHDATA((Proc))->x_reg_array;	\
+    (Proc)->arity = 3;						\
+    reg[0] = (Eterm) (A0);					\
+    reg[1] = (Eterm) (A1);					\
+    reg[2] = (Eterm) (A2);					\
+    (Proc)->i = (BeamInstr*) ((Trap)->address);			\
+    (Proc)->freason = TRAP;					\
+    (Ret) = THE_NON_VALUE;					\
 } while (0)
 
 #define ERTS_BIF_PREP_TRAP3_NO_RET(Trap, Proc, A0, A1, A2)\
 do {							\
+    Eterm* reg = ERTS_PROC_GET_SCHDATA((Proc))->x_reg_array;	\
     (Proc)->arity = 3;					\
-    (Proc)->def_arg_reg[0] = (Eterm) (A0);		\
-    (Proc)->def_arg_reg[1] = (Eterm) (A1);		\
-    (Proc)->def_arg_reg[2] = (Eterm) (A2);		\
-    *((UWord *) (UWord) ((Proc)->def_arg_reg + 3)) = (UWord) ((Trap)->address);	\
+    reg[0] = (Eterm) (A0);		\
+    reg[1] = (Eterm) (A1);		\
+    reg[2] = (Eterm) (A2);		\
+    (Proc)->i = (BeamInstr*) ((Trap)->address);			\
     (Proc)->freason = TRAP;				\
 } while (0)
 
-
-#define BIF_TRAP0(p, Trap_) do {			\
-      (p)->arity = 0;					\
-      *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) ((Trap_)->address);	\
-      (p)->freason = TRAP;				\
-      return THE_NON_VALUE;				\
+#define BIF_TRAP0(p, Trap_) do {		\
+      (p)->arity = 0;				\
+      (p)->i = (BeamInstr*) ((Trap_)->address);	\
+      (p)->freason = TRAP;			\
+      return THE_NON_VALUE;			\
  } while(0)
 
-#define BIF_TRAP1(Trap_, p, A0) do {			\
-      (p)->arity = 1;					\
-      (p)->def_arg_reg[0] = (A0);			\
-      *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) ((Trap_)->address);	\
-      (p)->freason = TRAP;				\
-      return THE_NON_VALUE;				\
+#define BIF_TRAP1(Trap_, p, A0) do {				\
+      Eterm* reg = ERTS_PROC_GET_SCHDATA((p))->x_reg_array;	\
+      (p)->arity = 1;						\
+      reg[0] = (A0);						\
+      (p)->i = (BeamInstr*) ((Trap_)->address);			\
+      (p)->freason = TRAP;					\
+      return THE_NON_VALUE;					\
  } while(0)
 
-#define BIF_TRAP2(Trap_, p, A0, A1) do {		\
-      (p)->arity = 2;					\
-      (p)->def_arg_reg[0] = (A0);			\
-      (p)->def_arg_reg[1] = (A1);			\
-      *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) ((Trap_)->address);	\
-      (p)->freason = TRAP;				\
-      return THE_NON_VALUE;				\
+#define BIF_TRAP2(Trap_, p, A0, A1) do {			\
+      Eterm* reg = ERTS_PROC_GET_SCHDATA((p))->x_reg_array;	\
+      (p)->arity = 2;						\
+      reg[0] = (A0);						\
+      reg[1] = (A1);						\
+      (p)->i = (BeamInstr*) ((Trap_)->address);			\
+      (p)->freason = TRAP;					\
+      return THE_NON_VALUE;					\
  } while(0)
 
-#define BIF_TRAP3(Trap_, p, A0, A1, A2) do {		\
-      (p)->arity = 3;					\
-      (p)->def_arg_reg[0] = (A0);			\
-      (p)->def_arg_reg[1] = (A1);			\
-      (p)->def_arg_reg[2] = (A2);			\
-      *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) ((Trap_)->address);	\
-      (p)->freason = TRAP;				\
-      return THE_NON_VALUE;				\
+#define BIF_TRAP3(Trap_, p, A0, A1, A2) do {			\
+      Eterm* reg = ERTS_PROC_GET_SCHDATA((p))->x_reg_array;	\
+      (p)->arity = 3;						\
+      reg[0] = (A0);						\
+      reg[1] = (A1);						\
+      reg[2] = (A2);						\
+      (p)->i = (BeamInstr*) ((Trap_)->address);			\
+      (p)->freason = TRAP;					\
+      return THE_NON_VALUE;					\
  } while(0)
 
-#define BIF_TRAP_CODE_PTR_0(p, Code_) do {		\
-      (p)->arity = 0;					\
-      *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) (Code_);	\
-      (p)->freason = TRAP;				\
-      return THE_NON_VALUE;				\
+#define BIF_TRAP_CODE_PTR_0(p, Code_) do {	\
+      (p)->arity = 0;				\
+      (p)->i = (BeamInstr*) (Code_);		\
+      (p)->freason = TRAP;			\
+      return THE_NON_VALUE;			\
  } while(0)
 
-#define BIF_TRAP_CODE_PTR_(p, Code_) do {		\
-      *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) (Code_);	\
-      (p)->freason = TRAP;				\
-      return THE_NON_VALUE;				\
+#define BIF_TRAP_CODE_PTR_(p, Code_) do {	\
+      (p)-> i = (BeamInstr*) (Code_);		\
+      (p)->freason = TRAP;			\
+      return THE_NON_VALUE;			\
  } while(0)
 
 extern Export bif_return_trap_export;
diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 432b3d0780..8132bbeaa1 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -94,7 +94,7 @@ process_killer(void)
 	    erts_printf("(k)ill (n)ext (r)eturn:\n");
 	    while(1) {
 		if ((j = sys_get_key(0)) <= 0)
-		    halt_0(0);
+		    erl_exit(0, "");
 		switch(j) {
 		case 'k':
 		    if (rp->status == P_WAITING) {
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index ad042ec088..29b83520dd 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -2730,85 +2730,92 @@ BIF_RETTYPE is_alive_0(BIF_ALIST_0)
 /**********************************************************************/
 /* erlang:monitor_node(Node, Bool, Options) -> Bool */
 
-BIF_RETTYPE monitor_node_3(BIF_ALIST_3)
+static BIF_RETTYPE
+monitor_node(Process* p, Eterm Node, Eterm Bool, Eterm Options)
 {
     DistEntry *dep;
     ErtsLink *lnk;
     Eterm l;
 
-    for (l = BIF_ARG_3; l != NIL && is_list(l); l = CDR(list_val(l))) {
+    for (l = Options; l != NIL && is_list(l); l = CDR(list_val(l))) {
 	Eterm t = CAR(list_val(l));
 	/* allow_passive_connect the only available option right now */
 	if (t != am_allow_passive_connect) {
-	    BIF_ERROR(BIF_P, BADARG);
+	    BIF_ERROR(p, BADARG);
 	}
     }
     if (l != NIL) {
-	BIF_ERROR(BIF_P, BADARG);
+	BIF_ERROR(p, BADARG);
     }
 
-    if (is_not_atom(BIF_ARG_1) ||
-	((BIF_ARG_2 != am_true) && (BIF_ARG_2 != am_false)) ||
+    if (is_not_atom(Node) ||
+	((Bool != am_true) && (Bool != am_false)) ||
 	((erts_this_node->sysname == am_Noname)
-	 && (BIF_ARG_1 != erts_this_node->sysname))) {
-	BIF_ERROR(BIF_P, BADARG);
+	 && (Node != erts_this_node->sysname))) {
+	BIF_ERROR(p, BADARG);
     }
-    dep = erts_sysname_to_connected_dist_entry(BIF_ARG_1);
+    dep = erts_sysname_to_connected_dist_entry(Node);
     if (!dep) {
     do_trap:
-	BIF_TRAP3(dmonitor_node_trap, BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+	BIF_TRAP3(dmonitor_node_trap, p, Node, Bool, Options);
     }
     if (dep == erts_this_dist_entry)
 	goto done;
 
-    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_LINK);
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_LINK);
     erts_smp_de_rlock(dep);
     if (ERTS_DE_IS_NOT_CONNECTED(dep)) {
-	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_LINK);
+	erts_smp_proc_unlock(p, ERTS_PROC_LOCK_LINK);
 	erts_smp_de_runlock(dep);
 	goto do_trap;
     }
     erts_smp_de_links_lock(dep);
     erts_smp_de_runlock(dep);
 
-    if (BIF_ARG_2 == am_true) {
+    if (Bool == am_true) {
 	ASSERT(dep->cid != NIL);
 	lnk = erts_add_or_lookup_link(&(dep->node_links), LINK_NODE, 
-				      BIF_P->id);
+				      p->id);
 	++ERTS_LINK_REFC(lnk);
-	lnk = erts_add_or_lookup_link(&(BIF_P->nlinks), LINK_NODE, BIF_ARG_1);
+	lnk = erts_add_or_lookup_link(&(p->nlinks), LINK_NODE, Node);
 	++ERTS_LINK_REFC(lnk);
     }
     else  {
-	lnk = erts_lookup_link(dep->node_links, BIF_P->id);
+	lnk = erts_lookup_link(dep->node_links, p->id);
 	if (lnk != NULL) {
 	    if ((--ERTS_LINK_REFC(lnk)) == 0) {
 		erts_destroy_link(erts_remove_link(&(dep->node_links), 
-						   BIF_P->id));
+						   p->id));
 	    }
 	}
-	lnk = erts_lookup_link(BIF_P->nlinks, BIF_ARG_1);
+	lnk = erts_lookup_link(p->nlinks, Node);
 	if (lnk != NULL) {
 	    if ((--ERTS_LINK_REFC(lnk)) == 0) {
-		erts_destroy_link(erts_remove_link(&(BIF_P->nlinks), 
-						   BIF_ARG_1));
+		erts_destroy_link(erts_remove_link(&(p->nlinks),
+						   Node));
 	    }
 	}
     }
 
     erts_smp_de_links_unlock(dep);
-    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_LINK);
+    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_LINK);
 
  done:
     erts_deref_dist_entry(dep);
     BIF_RET(am_true);
 }
 
+BIF_RETTYPE monitor_node_3(BIF_ALIST_3)
+{
+    BIF_RET(monitor_node(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3));
+}
+
+
 /* monitor_node(Node, Bool) -> Bool */
 
 BIF_RETTYPE monitor_node_2(BIF_ALIST_2)
 {
-    BIF_RET(monitor_node_3(BIF_P,BIF_ARG_1,BIF_ARG_2,NIL));
+    BIF_RET(monitor_node(BIF_P, BIF_ARG_1, BIF_ARG_2, NIL));
 }
 
 BIF_RETTYPE net_kernel_dflag_unicode_io_1(BIF_ALIST_1)
diff --git a/erts/emulator/beam/erl_arith.c b/erts/emulator/beam/erl_arith.c
index 64fad9fe0e..5150a8a507 100644
--- a/erts/emulator/beam/erl_arith.c
+++ b/erts/emulator/beam/erl_arith.c
@@ -164,14 +164,14 @@ BIF_RETTYPE bxor_2(BIF_ALIST_2)
     BIF_RET(erts_bxor(BIF_P, BIF_ARG_1, BIF_ARG_2));
 } 
 
-BIF_RETTYPE bsl_2(Process* p, Eterm arg1, Eterm arg2)
+BIF_RETTYPE bsl_2(BIF_ALIST_2)
 {
-    BIF_RET(shift(p, arg1, arg2, 0));
+    BIF_RET(shift(BIF_P, BIF_ARG_1, BIF_ARG_2, 0));
 } 
 
-BIF_RETTYPE bsr_2(Process* p, Eterm arg1, Eterm arg2)
+BIF_RETTYPE bsr_2(BIF_ALIST_2)
 {
-    BIF_RET(shift(p, arg1, arg2, 1));
+    BIF_RET(shift(BIF_P, BIF_ARG_1, BIF_ARG_2, 1));
 } 
 
 static Eterm
diff --git a/erts/emulator/beam/erl_bif_binary.c b/erts/emulator/beam/erl_bif_binary.c
index 684fa5d12f..6d022e0d11 100644
--- a/erts/emulator/beam/erl_bif_binary.c
+++ b/erts/emulator/beam/erl_bif_binary.c
@@ -65,6 +65,10 @@ static Export binary_copy_trap_export;
 static BIF_RETTYPE binary_copy_trap(BIF_ALIST_2);
 static Uint max_loop_limit;
 
+static BIF_RETTYPE
+binary_match(Process *p, Eterm arg1, Eterm arg2, Eterm arg3);
+static BIF_RETTYPE
+binary_matches(Process *p, Eterm arg1, Eterm arg2, Eterm arg3);
 
 void erts_init_bif_binary(void)
 {
@@ -1399,6 +1403,12 @@ static BIF_RETTYPE binary_matches_trap(BIF_ALIST_3)
 
 BIF_RETTYPE binary_match_3(BIF_ALIST_3)
 {
+    return binary_match(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+}
+
+static BIF_RETTYPE
+binary_match(Process *p, Eterm arg1, Eterm arg2, Eterm arg3)
+{
     Uint hsstart;
     Uint hsend;
     Eterm *tp;
@@ -1408,17 +1418,17 @@ BIF_RETTYPE binary_match_3(BIF_ALIST_3)
     int runres;
     Eterm result;
 
-    if (is_not_binary(BIF_ARG_1)) {
+    if (is_not_binary(arg1)) {
 	goto badarg;
     }
-    if (parse_match_opts_list(BIF_ARG_3,BIF_ARG_1,&hsstart,&hsend)) {
+    if (parse_match_opts_list(arg3,arg1,&hsstart,&hsend)) {
 	goto badarg;
     }
     if (hsend == 0) {
 	BIF_RET(am_nomatch);
     }
-    if (is_tuple(BIF_ARG_2)) {
-	tp = tuple_val(BIF_ARG_2);
+    if (is_tuple(arg2)) {
+	tp = tuple_val(arg2);
 	if (arityval(*tp) != 2 || is_not_atom(tp[1])) {
 	    goto badarg;
 	}
@@ -1437,13 +1447,13 @@ BIF_RETTYPE binary_match_3(BIF_ALIST_3)
 	    goto badarg;
 	}
 	bin_term = tp[2];
-    } else if (do_binary_match_compile(BIF_ARG_2,&type,&bin)) {
+    } else if (do_binary_match_compile(arg2,&type,&bin)) {
 	goto badarg;
     }
-    runres = do_binary_match(BIF_P,BIF_ARG_1,hsstart,hsend,type,bin,NIL,&result);
+    runres = do_binary_match(p,arg1,hsstart,hsend,type,bin,NIL,&result);
     if (runres == DO_BIN_MATCH_RESTART && bin_term == NIL) {
-	Eterm *hp = HAlloc(BIF_P, PROC_BIN_SIZE);
-	bin_term = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), bin);
+	Eterm *hp = HAlloc(p, PROC_BIN_SIZE);
+	bin_term = erts_mk_magic_binary_term(&hp, &MSO(p), bin);
     } else if (bin_term == NIL) {
 	erts_bin_free(bin);
     }
@@ -1451,17 +1461,23 @@ BIF_RETTYPE binary_match_3(BIF_ALIST_3)
     case DO_BIN_MATCH_OK:
 	BIF_RET(result);
     case DO_BIN_MATCH_RESTART:
-	BUMP_ALL_REDS(BIF_P);
-	BIF_TRAP3(&binary_match_trap_export, BIF_P, BIF_ARG_1, result, bin_term);
+	BUMP_ALL_REDS(p);
+	BIF_TRAP3(&binary_match_trap_export, p, arg1, result, bin_term);
     default:
 	goto badarg;
     }
  badarg:
-    BIF_ERROR(BIF_P,BADARG);
+    BIF_ERROR(p,BADARG);
 }
 
 BIF_RETTYPE binary_matches_3(BIF_ALIST_3)
 {
+    return binary_matches(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+}
+
+static BIF_RETTYPE
+binary_matches(Process *p, Eterm arg1, Eterm arg2, Eterm arg3)
+{
     Uint hsstart, hsend;
     Eterm *tp;
     Eterm type;
@@ -1470,17 +1486,17 @@ BIF_RETTYPE binary_matches_3(BIF_ALIST_3)
     int runres;
     Eterm result;
 
-    if (is_not_binary(BIF_ARG_1)) {
+    if (is_not_binary(arg1)) {
 	goto badarg;
     }
-    if (parse_match_opts_list(BIF_ARG_3,BIF_ARG_1,&hsstart,&hsend)) {
+    if (parse_match_opts_list(arg3,arg1,&hsstart,&hsend)) {
 	goto badarg;
     }
     if (hsend == 0) {
 	BIF_RET(NIL);
     }
-    if (is_tuple(BIF_ARG_2)) {
-	tp = tuple_val(BIF_ARG_2);
+    if (is_tuple(arg2)) {
+	tp = tuple_val(arg2);
 	if (arityval(*tp) != 2 || is_not_atom(tp[1])) {
 	    goto badarg;
 	}
@@ -1499,14 +1515,14 @@ BIF_RETTYPE binary_matches_3(BIF_ALIST_3)
 	    goto badarg;
 	}
 	bin_term = tp[2];
-    } else if (do_binary_match_compile(BIF_ARG_2,&type,&bin)) {
+    } else if (do_binary_match_compile(arg2,&type,&bin)) {
 	goto badarg;
     }
-    runres = do_binary_matches(BIF_P,BIF_ARG_1,hsstart,hsend,type,bin,
+    runres = do_binary_matches(p,arg1,hsstart,hsend,type,bin,
 			       NIL,&result);
     if (runres == DO_BIN_MATCH_RESTART && bin_term == NIL) {
-	Eterm *hp = HAlloc(BIF_P, PROC_BIN_SIZE);
-	bin_term = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), bin);
+	Eterm *hp = HAlloc(p, PROC_BIN_SIZE);
+	bin_term = erts_mk_magic_binary_term(&hp, &MSO(p), bin);
     } else if (bin_term == NIL) {
 	erts_bin_free(bin);
     }
@@ -1514,26 +1530,26 @@ BIF_RETTYPE binary_matches_3(BIF_ALIST_3)
     case DO_BIN_MATCH_OK:
 	BIF_RET(result);
     case DO_BIN_MATCH_RESTART:
-	BUMP_ALL_REDS(BIF_P);
-	BIF_TRAP3(&binary_matches_trap_export, BIF_P, BIF_ARG_1, result,
+	BUMP_ALL_REDS(p);
+	BIF_TRAP3(&binary_matches_trap_export, p, arg1, result,
 		  bin_term);
     default:
 	goto badarg;
     }
  badarg:
-    BIF_ERROR(BIF_P,BADARG);
+    BIF_ERROR(p,BADARG);
 }
 
 
 BIF_RETTYPE binary_match_2(BIF_ALIST_2)
 {
-    return binary_match_3(BIF_P,BIF_ARG_1,BIF_ARG_2,((Eterm) 0));
+    return binary_match(BIF_P,BIF_ARG_1,BIF_ARG_2,((Eterm) 0));
 }
 
 
 BIF_RETTYPE binary_matches_2(BIF_ALIST_2)
 {
-    return binary_matches_3(BIF_P,BIF_ARG_1,BIF_ARG_2,((Eterm) 0));
+    return binary_matches(BIF_P,BIF_ARG_1,BIF_ARG_2,((Eterm) 0));
 }
 
 
diff --git a/erts/emulator/beam/erl_bif_ddll.c b/erts/emulator/beam/erl_bif_ddll.c
index d714eacd06..a9fd28c66b 100644
--- a/erts/emulator/beam/erl_bif_ddll.c
+++ b/erts/emulator/beam/erl_bif_ddll.c
@@ -142,9 +142,11 @@ static void ddll_no_more_references(void *vdh);
  * really load and add as LOADED {ok,loaded} {ok,pending_driver}
  * {error, permanent} {error,load_error()}
  */
-BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term, 
-				Eterm name_term, Eterm options)
+BIF_RETTYPE erl_ddll_try_load_3(BIF_ALIST_3)
 {
+    Eterm path_term = BIF_ARG_1;
+    Eterm name_term = BIF_ARG_2;
+    Eterm options = BIF_ARG_3;
     char *path = NULL;
     Uint path_len;
     char *name = NULL;
@@ -236,7 +238,7 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
     sys_strcpy(path+path_len,name);
 
 #if DDLL_SMP
-    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
     lock_drv_list();
 #endif
     if ((drv = lookup_driver(name)) != NULL) {
@@ -247,7 +249,7 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 	} else {
 	    dh = drv->handle;
 	    if (dh->status == ERL_DE_OK) {
-		int is_last = is_last_user(dh,p);
+		int is_last = is_last_user(dh, BIF_P);
 		if (reload == 1 && !is_last) {
 		    /*Want reload if no other users, 
 		      but there are others...*/
@@ -261,7 +263,8 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 			soft_error_term = am_inconsistent;
 			goto soft_error;
 		    }
-		    if ((old = find_proc_entry(dh, p, ERL_DE_PROC_LOADED)) == 
+		    if ((old = find_proc_entry(dh, BIF_P,
+					       ERL_DE_PROC_LOADED)) ==
 			NULL) {
 			soft_error_term = am_not_loaded_by_this_process;
 			goto soft_error;
@@ -272,7 +275,7 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 		    }
 		    /* Reload requested and granted */
 		    dereference_all_processes(dh);
-		    set_driver_reloading(dh, p, path, name, flags);
+		    set_driver_reloading(dh, BIF_P, path, name, flags);
 		    if (dh->flags & ERL_DE_FL_KILL_PORTS) {
 			kill_ports = 1;
 		    }
@@ -286,7 +289,7 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 			soft_error_term = am_inconsistent;
 			goto soft_error;
 		    }
-		    add_proc_loaded(dh,p);
+		    add_proc_loaded(dh, BIF_P);
 		    erts_ddll_reference_driver(dh);
 		    monitor = 0;
 		    ok_term = mkatom("already_loaded");
@@ -308,7 +311,7 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 		notify_all(dh, drv->name, 
 			   ERL_DE_PROC_AWAIT_UNLOAD, am_UP, 
 			   am_unload_cancelled);
-		add_proc_loaded(dh,p);
+		add_proc_loaded(dh, BIF_P);
 		erts_ddll_reference_driver(dh);
 		monitor = 0;
 		ok_term = mkatom("already_loaded");
@@ -325,7 +328,8 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 		    goto soft_error;
 		}
 		/* Load of granted unload... */
-		add_proc_loaded_deref(dh,p); /* Dont reference, will happen after reload */
+		/* Don't reference, will happen after reload */
+		add_proc_loaded_deref(dh, BIF_P);
 		++monitor;
 		ok_term = am_pending_driver;
 	    } else { /* ERL_DE_PERMANENT */
@@ -345,7 +349,7 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 	    goto soft_error;
 	} else {
 	    dh->flags = flags;
-	    add_proc_loaded(dh,p);
+	    add_proc_loaded(dh, BIF_P);
 	    first_ddll_reference(dh);
 	    monitor = 0;
 	    ok_term = mkatom("loaded");
@@ -397,18 +401,18 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 #if DDLL_SMP
     erts_ddll_reference_driver(dh);
     unlock_drv_list();
-    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
     lock_drv_list();
     erts_ddll_dereference_driver(dh);
 #endif
 
-    p->flags |= F_USING_DDLL;
+    BIF_P->flags |= F_USING_DDLL;
     if (monitor) {
-	Eterm mref = add_monitor(p, dh, ERL_DE_PROC_AWAIT_LOAD);
-	hp = HAlloc(p,4);
+	Eterm mref = add_monitor(BIF_P, dh, ERL_DE_PROC_AWAIT_LOAD);
+	hp = HAlloc(BIF_P, 4);
 	t = TUPLE3(hp, am_ok, ok_term, mref);
     } else {
-	hp = HAlloc(p,3);
+	hp = HAlloc(BIF_P, 3);
 	t = TUPLE2(hp, am_ok, ok_term);
     }
 #if DDLL_SMP
@@ -416,33 +420,33 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
 #endif
     erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
     erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
-    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(BIF_P));
     BIF_RET(t);
  soft_error:
 #if DDLL_SMP
     unlock_drv_list();
-    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 #endif
     if (do_build_load_error) {
-	soft_error_term = build_load_error(p, build_this_load_error);
+	soft_error_term = build_load_error(BIF_P, build_this_load_error);
     }
 
-    hp = HAlloc(p,3);
+    hp = HAlloc(BIF_P, 3);
     t = TUPLE2(hp, am_error, soft_error_term);
     erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
     erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
-    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(BIF_P));
     BIF_RET(t);
  error:
     assert_drv_list_not_locked();
-    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(BIF_P));
     if (path != NULL) {
 	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
     }
     if (name != NULL) {
 	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
     }
-    BIF_ERROR(p,BADARG);
+    BIF_ERROR(BIF_P, BADARG);
 }
 
 /*
@@ -481,8 +485,10 @@ BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term,
    any AWAIT_LOAD-waiters with {'DOWN', ref(), driver, name(), load_cancelled}
    If the driver made itself permanent, {'UP', ref(), driver, name(), permanent}
 */
-Eterm erl_ddll_try_unload_2(Process *p, Eterm name_term, Eterm options)
+Eterm erl_ddll_try_unload_2(BIF_ALIST_2)
 {
+    Eterm name_term = BIF_ARG_1;
+    Eterm options = BIF_ARG_2;
     char *name = NULL;
     Eterm ok_term = NIL;
     Eterm soft_error_term = NIL;
@@ -495,7 +501,7 @@ Eterm erl_ddll_try_unload_2(Process *p, Eterm name_term, Eterm options)
     Eterm l;
     int kill_ports = 0;
 
-    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
     for(l = options; is_list(l); l =  CDR(list_val(l))) {
 	Eterm opt = CAR(list_val(l));
@@ -548,7 +554,7 @@ Eterm erl_ddll_try_unload_2(Process *p, Eterm name_term, Eterm options)
     if (dh->flags & ERL_DE_FL_KILL_PORTS) {
 	kill_ports = 1;
     }
-    if ((pe = find_proc_entry(dh, p, ERL_DE_PROC_LOADED)) == NULL) {
+    if ((pe = find_proc_entry(dh, BIF_P, ERL_DE_PROC_LOADED)) == NULL) {
 	if (num_procs(dh, ERL_DE_PROC_LOADED) > 0) {
 	    soft_error_term = am_not_loaded_by_this_process;
 	    goto soft_error;
@@ -624,22 +630,22 @@ done:
 #if DDLL_SMP
     erts_ddll_reference_driver(dh);
     unlock_drv_list();
-    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
     lock_drv_list();
     erts_ddll_dereference_driver(dh);
 #endif
     erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
-    p->flags |= F_USING_DDLL;
+    BIF_P->flags |= F_USING_DDLL;
     if (monitor > 0) {
-	Eterm mref = add_monitor(p, dh, ERL_DE_PROC_AWAIT_UNLOAD);
-	hp = HAlloc(p,4);
+	Eterm mref = add_monitor(BIF_P, dh, ERL_DE_PROC_AWAIT_UNLOAD);
+	hp = HAlloc(BIF_P, 4);
 	t = TUPLE3(hp, am_ok, ok_term, mref);
     } else {
-	hp = HAlloc(p,3);
+	hp = HAlloc(BIF_P, 3);
 	t = TUPLE2(hp, am_ok, ok_term);
     }
     if (kill_ports > 1) {
-	ERTS_BIF_CHK_EXITED(p); /* May be exited by port killing */
+	ERTS_BIF_CHK_EXITED(BIF_P); /* May be exited by port killing */
     }
 #if DDLL_SMP
     unlock_drv_list();
@@ -651,8 +657,8 @@ soft_error:
     unlock_drv_list();
 #endif
     erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
-    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
-    hp = HAlloc(p,3);
+    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
+    hp = HAlloc(BIF_P, 3);
     t = TUPLE2(hp, am_error, soft_error_term);
     BIF_RET(t);
  
@@ -661,21 +667,21 @@ soft_error:
     if (name != NULL) {
 	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
     }
-    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
-    BIF_ERROR(p,BADARG);
+    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
+    BIF_ERROR(BIF_P, BADARG);
 }
 
 
 /* 
  * A shadow of the "real" demonitor BIF
  */
-BIF_RETTYPE erl_ddll_demonitor_1(Process *p, Eterm ref)
+BIF_RETTYPE erl_ddll_demonitor_1(BIF_ALIST_1)
 {
-   if (is_not_internal_ref(ref)) {
-       BIF_ERROR(p, BADARG);
+   if (is_not_internal_ref(BIF_ARG_1)) {
+       BIF_ERROR(BIF_P, BADARG);
    }
-   if (p->flags & F_USING_DDLL) {
-       erts_ddll_remove_monitor(p, ref, ERTS_PROC_LOCK_MAIN);
+   if (BIF_P->flags & F_USING_DDLL) {
+       erts_ddll_remove_monitor(BIF_P, BIF_ARG_1, ERTS_PROC_LOCK_MAIN);
    }
    BIF_RET(am_true);
 }
@@ -683,18 +689,18 @@ BIF_RETTYPE erl_ddll_demonitor_1(Process *p, Eterm ref)
 /* 
  * A shadow of the "real" monitor BIF
  */
-BIF_RETTYPE erl_ddll_monitor_2(Process *p, Eterm dr, Eterm what)
+BIF_RETTYPE erl_ddll_monitor_2(BIF_ALIST_2)
 {
-    if (dr != am_driver) {
-	BIF_ERROR(p,BADARG);
+    if (BIF_ARG_1 != am_driver) {
+	BIF_ERROR(BIF_P, BADARG);
     }
-    return erts_ddll_monitor_driver(p, what, ERTS_PROC_LOCK_MAIN);
+    return erts_ddll_monitor_driver(BIF_P, BIF_ARG_2, ERTS_PROC_LOCK_MAIN);
 }
 
 /* 
  * Return list of loaded drivers {ok,[string()]} 
  */
-Eterm erl_ddll_loaded_drivers_0(Process *p)
+BIF_RETTYPE erl_ddll_loaded_drivers_0(BIF_ALIST_0)
 {
     Eterm *hp;
     int need = 3;
@@ -706,7 +712,7 @@ Eterm erl_ddll_loaded_drivers_0(Process *p)
     for (drv = driver_list; drv; drv = drv->next) {
 	need += sys_strlen(drv->name)*2+2;
     }
-    hp = HAlloc(p,need);
+    hp = HAlloc(BIF_P, need);
     for (drv = driver_list; drv; drv = drv->next) {
 	Eterm l;
 	l = buf_to_intlist(&hp, drv->name, sys_strlen(drv->name), NIL);
@@ -726,8 +732,11 @@ Eterm erl_ddll_loaded_drivers_0(Process *p)
  * item is processes, driver_options, port_count, linked_in_driver, 
  * permanent, awaiting_load, awaiting_unload 
  */
-Eterm erl_ddll_info_2(Process *p, Eterm name_term, Eterm item) 
+BIF_RETTYPE erl_ddll_info_2(BIF_ALIST_2)
 {
+    Process *p = BIF_P;
+    Eterm name_term = BIF_ARG_1;
+    Eterm item = BIF_ARG_2;
     char *name = NULL;
     Eterm res = NIL;
     erts_driver_t *drv;
@@ -850,8 +859,10 @@ Eterm erl_ddll_info_2(Process *p, Eterm name_term, Eterm item)
  * Backend for erl_ddll:format_error, handles all "soft" errors returned by builtins,
  * possibly by calling the system specific error handler
  */
-Eterm erl_ddll_format_error_int_1(Process *p, Eterm code_term)
+BIF_RETTYPE erl_ddll_format_error_int_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm code_term = BIF_ARG_1;
     char *errstring = NULL;
     int errint;
     int len;
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index de5e4046fa..8a9e6cca08 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -123,6 +123,8 @@ static char erts_system_version[] = ("Erlang " ERLANG_OTP_RELEASE
 static Eterm os_type_tuple;
 static Eterm os_version_tuple;
 
+static BIF_RETTYPE port_info(Process* p, Eterm portid, Eterm item);
+
 static Eterm
 current_function(Process* p, Process* rp, Eterm** hpp, int full_info);
 static Eterm current_stacktrace(Process* p, Process* rp, Eterm** hpp);
@@ -2104,7 +2106,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 	BIF_RET(am_undefined);
 #endif
     } else if (BIF_ARG_1 == am_trace_control_word) {
-	BIF_RET(db_get_trace_control_word_0(BIF_P));
+	BIF_RET(db_get_trace_control_word(BIF_P));
     } else if (ERTS_IS_ATOM_STR("ets_realloc_moves", BIF_ARG_1)) {
  	BIF_RET((erts_ets_realloc_always_moves) ? am_true : am_false);
     } else if (ERTS_IS_ATOM_STR("ets_always_compress", BIF_ARG_1)) {
@@ -2695,9 +2697,11 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
     BIF_ERROR(BIF_P, BADARG);
 }
 
-Eterm
-port_info_1(Process* p, Eterm pid)
+BIF_RETTYPE
+port_info_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm pid = BIF_ARG_1;
     static Eterm keys[] = {
 	am_name,
 	am_links,
@@ -2720,7 +2724,7 @@ port_info_1(Process* p, Eterm pid)
     for (i = 0; i < ASIZE(keys); i++) {
 	Eterm item;
 
-	item = port_info_2(p, pid, keys[i]);
+	item = port_info(p, pid, keys[i]);
 	if (is_non_value(item)) {
 	    return THE_NON_VALUE;
 	}
@@ -2729,7 +2733,7 @@ port_info_1(Process* p, Eterm pid)
 	}
 	items[i] = item;
     }
-    reg_name = port_info_2(p, pid, am_registered_name);
+    reg_name = port_info(p, pid, am_registered_name);
 
     /*
      * Build the resulting list.
@@ -2765,24 +2769,27 @@ port_info_1(Process* p, Eterm pid)
 
 BIF_RETTYPE port_info_2(BIF_ALIST_2)
 {
+    return port_info(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+static BIF_RETTYPE port_info(Process* p, Eterm portid, Eterm item)
+{
     BIF_RETTYPE ret;
-    Eterm portid = BIF_ARG_1;
     Port *prt;
-    Eterm item = BIF_ARG_2;
     Eterm res;
     Eterm* hp;
     int count;
 
     if (is_internal_port(portid))
-	prt = erts_id2port(portid, BIF_P, ERTS_PROC_LOCK_MAIN);
+	prt = erts_id2port(portid, p, ERTS_PROC_LOCK_MAIN);
     else if (is_atom(portid))
-	erts_whereis_name(BIF_P, ERTS_PROC_LOCK_MAIN,
+	erts_whereis_name(p, ERTS_PROC_LOCK_MAIN,
 			  portid, NULL, 0, 0, &prt);
     else if (is_external_port(portid)
 	     && external_port_dist_entry(portid) == erts_this_dist_entry)
 	BIF_RET(am_undefined);
     else {
-	BIF_ERROR(BIF_P, BADARG);
+	BIF_ERROR(p, BADARG);
     }
 
     if (!prt) {
@@ -2790,7 +2797,7 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
     }
 
     if (item == am_id) {
-	hp = HAlloc(BIF_P, 3);
+	hp = HAlloc(p, 3);
 	res = make_small(internal_port_number(portid));
     }
     else if (item == am_links) {
@@ -2802,10 +2809,10 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 
 	erts_doforall_links(prt->nlinks, &collect_one_link, &mic);
 
-	hp = HAlloc(BIF_P, 3 + mic.sz);
+	hp = HAlloc(p, 3 + mic.sz);
 	res = NIL;
 	for (i = 0; i < mic.mi_i; i++) {
-	    item = STORE_NC(&hp, &MSO(BIF_P), mic.mi[i].entity); 
+	    item = STORE_NC(&hp, &MSO(p), mic.mi[i].entity);
 	    res = CONS(hp, item, res);
 	    hp += 2;
 	}
@@ -2821,11 +2828,11 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 
 	erts_doforall_monitors(prt->monitors, &collect_one_origin_monitor, &mic);
 
-	hp = HAlloc(BIF_P, 3 + mic.sz);
+	hp = HAlloc(p, 3 + mic.sz);
 	res = NIL;
 	for (i = 0; i < mic.mi_i; i++) {
 	    Eterm t;
-	    item = STORE_NC(&hp, &MSO(BIF_P), mic.mi[i].entity); 
+	    item = STORE_NC(&hp, &MSO(p), mic.mi[i].entity);
 	    t = TUPLE2(hp, am_process, item);
 	    hp += 3;
 	    res = CONS(hp, t, res);
@@ -2837,25 +2844,25 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
     else if (item == am_name) {
 	count = sys_strlen(prt->name);
 
-	hp = HAlloc(BIF_P, 3 + 2*count);
+	hp = HAlloc(p, 3 + 2*count);
 	res = buf_to_intlist(&hp, prt->name, count, NIL);
     }
     else if (item == am_connected) {
-	hp = HAlloc(BIF_P, 3);
+	hp = HAlloc(p, 3);
 	res = prt->connected; /* internal pid */
     }
     else if (item == am_input) {
 	Uint hsz = 3;
 	Uint n = prt->bytes_in;
 	(void) erts_bld_uint(NULL, &hsz, n);
-	hp = HAlloc(BIF_P, hsz);
+	hp = HAlloc(p, hsz);
 	res = erts_bld_uint(&hp, NULL, n);
     }
     else if (item == am_output) {
 	Uint hsz = 3;
 	Uint n = prt->bytes_out;
 	(void) erts_bld_uint(NULL, &hsz, n);
-	hp = HAlloc(BIF_P, hsz);
+	hp = HAlloc(p, hsz);
 	res = erts_bld_uint(&hp, NULL, n);
     }
     else if (item == am_registered_name) {
@@ -2865,7 +2872,7 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 	    ERTS_BIF_PREP_RET(ret, NIL);
 	    goto done;
 	} else {
-	    hp = HAlloc(BIF_P, 3);
+	    hp = HAlloc(p, 3);
 	    res = reg->name;
 	}
     }
@@ -2877,7 +2884,7 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 	Uint size = 0;
 	ErlHeapFragment* bp;
 
-	hp = HAlloc(BIF_P, 3);
+	hp = HAlloc(p, 3);
 
 	erts_doforall_links(prt->nlinks, &one_link_size, &size);
 
@@ -2894,18 +2901,18 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 	   hard to retrieve... */
 	
 	(void) erts_bld_uint(NULL, &hsz, size);
-	hp = HAlloc(BIF_P, hsz);
+	hp = HAlloc(p, hsz);
 	res = erts_bld_uint(&hp, NULL, size);
     }
     else if (item == am_queue_size) {
 	Uint ioq_size = erts_port_ioq_size(prt);
 	Uint hsz = 3;
 	(void) erts_bld_uint(NULL, &hsz, ioq_size);
-	hp = HAlloc(BIF_P, hsz);
+	hp = HAlloc(p, hsz);
 	res = erts_bld_uint(&hp, NULL, ioq_size);
     }
     else if (ERTS_IS_ATOM_STR("locking", item)) {
-	hp = HAlloc(BIF_P, 3);
+	hp = HAlloc(p, 3);
 #ifndef ERTS_SMP
 	res = am_false;
 #else
@@ -2924,7 +2931,7 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 #endif
     }
     else {
-	ERTS_BIF_PREP_ERROR(ret, BIF_P, BADARG);
+	ERTS_BIF_PREP_ERROR(ret, p, BADARG);
 	goto done;
     }
 
@@ -2938,9 +2945,12 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 }
 
 
-Eterm
-fun_info_2(Process* p, Eterm fun, Eterm what)
+BIF_RETTYPE
+fun_info_2(BIF_ALIST_2)
 {
+    Process* p = BIF_P;
+    Eterm fun = BIF_ARG_1;
+    Eterm what = BIF_ARG_2;
     Eterm* hp;
     Eterm val;
 
diff --git a/erts/emulator/beam/erl_bif_lists.c b/erts/emulator/beam/erl_bif_lists.c
index 47c48e74d6..1805366cfe 100644
--- a/erts/emulator/beam/erl_bif_lists.c
+++ b/erts/emulator/beam/erl_bif_lists.c
@@ -34,27 +34,7 @@
 
 static Eterm keyfind(int Bif, Process* p, Eterm Key, Eterm Pos, Eterm List);
 
-/*
- * erlang:'++'/2
- */
-
-Eterm
-ebif_plusplus_2(Process* p, Eterm A, Eterm B)
-{
-    return append_2(p, A, B);
-}
-
-/*
- * erlang:'--'/2
- */
-
-Eterm
-ebif_minusminus_2(Process* p, Eterm A, Eterm B)
-{
-    return subtract_2(p, A, B);
-}
-
-BIF_RETTYPE append_2(BIF_ALIST_2)
+static BIF_RETTYPE append(Process* p, Eterm A, Eterm B)
 {
     Eterm list;
     Eterm copy;
@@ -63,18 +43,18 @@ BIF_RETTYPE append_2(BIF_ALIST_2)
     Eterm* hp;
     int i;
 
-    if ((i = list_length(BIF_ARG_1)) < 0) {
-	BIF_ERROR(BIF_P, BADARG);
+    if ((i = list_length(A)) < 0) {
+	BIF_ERROR(p, BADARG);
     }
     if (i == 0) {
-	BIF_RET(BIF_ARG_2);
-    } else if (is_nil(BIF_ARG_2)) {
-	BIF_RET(BIF_ARG_1);
+	BIF_RET(B);
+    } else if (is_nil(B)) {
+	BIF_RET(A);
     }
 
     need = 2*i;
-    hp = HAlloc(BIF_P, need); 
-    list = BIF_ARG_1;
+    hp = HAlloc(p, need);
+    list = A;
     copy = last = CONS(hp, CAR(list_val(list)), make_list(hp+2));
     list = CDR(list_val(list));
     hp += 2;
@@ -85,12 +65,31 @@ BIF_RETTYPE append_2(BIF_ALIST_2)
 	list = CDR(listp);
 	hp += 2;
     }
-    CDR(list_val(last)) = BIF_ARG_2;
+    CDR(list_val(last)) = B;
     BIF_RET(copy);
 }
 
+/*
+ * erlang:'++'/2
+ */
+
+Eterm
+ebif_plusplus_2(BIF_ALIST_2)
+{
+    return append(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+BIF_RETTYPE append_2(BIF_ALIST_2)
+{
+    return append(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+/*
+ * erlang:'--'/2
+ */
+
 #define SMALL_VEC_SIZE 10
-BIF_RETTYPE subtract_2(BIF_ALIST_2)
+static Eterm subtract(Process* p, Eterm A, Eterm B)
 {
     Eterm  list;
     Eterm* hp;
@@ -103,17 +102,17 @@ BIF_RETTYPE subtract_2(BIF_ALIST_2)
     int     n;
     int     m;
     
-    if ((n = list_length(BIF_ARG_1)) < 0) {
-	BIF_ERROR(BIF_P, BADARG);
+    if ((n = list_length(A)) < 0) {
+	BIF_ERROR(p, BADARG);
     }
-    if ((m = list_length(BIF_ARG_2)) < 0) {
-	BIF_ERROR(BIF_P, BADARG);
+    if ((m = list_length(B)) < 0) {
+	BIF_ERROR(p, BADARG);
     }
     
     if (n == 0)
 	BIF_RET(NIL);
     if (m == 0)
-	BIF_RET(BIF_ARG_1);
+	BIF_RET(A);
     
     /* allocate element vector */
     if (n <= SMALL_VEC_SIZE)
@@ -123,7 +122,7 @@ BIF_RETTYPE subtract_2(BIF_ALIST_2)
     
     /* PUT ALL ELEMENTS IN VP */
     vp = vec_p;
-    list = BIF_ARG_1;
+    list = A;
     i = n;
     while(i--) {
 	Eterm* listp = list_val(list);
@@ -132,7 +131,7 @@ BIF_RETTYPE subtract_2(BIF_ALIST_2)
     }
     
     /* UNMARK ALL DELETED CELLS */
-    list = BIF_ARG_2;
+    list = B;
     m = 0;  /* number of deleted elements */
     while(is_list(list)) {
 	Eterm* listp = list_val(list);
@@ -153,11 +152,11 @@ BIF_RETTYPE subtract_2(BIF_ALIST_2)
     if (m == n)      /* All deleted ? */
 	res = NIL;
     else if (m == 0)  /* None deleted ? */
-	res = BIF_ARG_1;
+	res = A;
     else {			/* REBUILD LIST */
 	res = NIL;
 	need = 2*(n - m);
-	hp = HAlloc(BIF_P, need);
+	hp = HAlloc(p, need);
 	vp = vec_p + n - 1;
 	while(vp >= vec_p) {
 	    if (is_value(*vp)) {
@@ -172,6 +171,16 @@ BIF_RETTYPE subtract_2(BIF_ALIST_2)
     BIF_RET(res);
 }
 
+BIF_RETTYPE ebif_minusminus_2(BIF_ALIST_2)
+{
+    return subtract(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+BIF_RETTYPE subtract_2(BIF_ALIST_2)
+{
+    return subtract(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
 BIF_RETTYPE lists_member_2(BIF_ALIST_2)
 {
     Eterm term;
@@ -278,11 +287,12 @@ BIF_RETTYPE lists_reverse_2(BIF_ALIST_2)
 }
 
 BIF_RETTYPE
-lists_keymember_3(Process* p, Eterm Key, Eterm Pos, Eterm List)
+lists_keymember_3(BIF_ALIST_3)
 {
     Eterm res;
 
-    res = keyfind(BIF_lists_keymember_3, p, Key, Pos, List);
+    res = keyfind(BIF_lists_keymember_3, BIF_P,
+		  BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
     if (is_value(res) && is_tuple(res)) {
 	return am_true;
     } else {
@@ -291,23 +301,25 @@ lists_keymember_3(Process* p, Eterm Key, Eterm Pos, Eterm List)
 }
 
 BIF_RETTYPE
-lists_keysearch_3(Process* p, Eterm Key, Eterm Pos, Eterm List)
+lists_keysearch_3(BIF_ALIST_3)
 {
     Eterm res;
     
-    res = keyfind(BIF_lists_keysearch_3, p, Key, Pos, List);
+    res = keyfind(BIF_lists_keysearch_3, BIF_P,
+		  BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
     if (is_non_value(res) || is_not_tuple(res)) {
 	return res;
     } else {			/* Tuple */
-	Eterm* hp = HAlloc(p, 3);
+	Eterm* hp = HAlloc(BIF_P, 3);
 	return TUPLE2(hp, am_value, res);
     }
 }
 
 BIF_RETTYPE
-lists_keyfind_3(Process* p, Eterm Key, Eterm Pos, Eterm List)
+lists_keyfind_3(BIF_ALIST_3)
 {
-    return keyfind(BIF_lists_keyfind_3, p, Key, Pos, List);
+    return keyfind(BIF_lists_keyfind_3, BIF_P,
+		   BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
 }
 
 static Eterm
diff --git a/erts/emulator/beam/erl_bif_op.c b/erts/emulator/beam/erl_bif_op.c
index deda7adc1f..13f8b1f63c 100644
--- a/erts/emulator/beam/erl_bif_op.c
+++ b/erts/emulator/beam/erl_bif_op.c
@@ -225,18 +225,23 @@ BIF_RETTYPE is_function_1(BIF_ALIST_1)
 
 BIF_RETTYPE is_function_2(BIF_ALIST_2)
 {
+    BIF_RET(erl_is_function(BIF_P, BIF_ARG_1, BIF_ARG_2));
+}
+
+Eterm erl_is_function(Process* p, Eterm arg1, Eterm arg2)
+{
     Sint arity;
 
     /*
      * Verify argument 2 (arity); arity must be >= 0.
      */ 
-    if (is_small(BIF_ARG_2)) {
-	arity = signed_val(BIF_ARG_2);
+    if (is_small(arg2)) {
+	arity = signed_val(arg2);
 	if (arity < 0) {
 	error:
-	    BIF_ERROR(BIF_P, BADARG);
+	    BIF_ERROR(p, BADARG);
 	}
-    } else if (is_big(BIF_ARG_2) && !bignum_header_is_neg(*big_val(BIF_ARG_2))) {
+    } else if (is_big(arg2) && !bignum_header_is_neg(*big_val(arg2))) {
 	/* A positive bignum is OK, but can't possibly match. */
 	arity = -1;
     } else {
@@ -244,20 +249,20 @@ BIF_RETTYPE is_function_2(BIF_ALIST_2)
 	goto error;
     }
 
-    if (is_fun(BIF_ARG_1)) {
-	ErlFunThing* funp = (ErlFunThing *) fun_val(BIF_ARG_1);
+    if (is_fun(arg1)) {
+	ErlFunThing* funp = (ErlFunThing *) fun_val(arg1);
 
 	if (funp->arity == (Uint) arity) {
 	    BIF_RET(am_true);
 	}
-    } else if (is_export(BIF_ARG_1)) {
-	Export* exp = (Export *) EXPAND_POINTER((export_val(BIF_ARG_1))[1]);
+    } else if (is_export(arg1)) {
+	Export* exp = (Export *) EXPAND_POINTER((export_val(arg1))[1]);
 
 	if (exp->code[2] == (Uint) arity) {
 	    BIF_RET(am_true);
 	}
-    } else if (is_tuple(BIF_ARG_1)) {
-	Eterm* tp = tuple_val(BIF_ARG_1);
+    } else if (is_tuple(arg1)) {
+	Eterm* tp = tuple_val(arg1);
 	if (tp[0] == make_arityval(2) && is_atom(tp[1]) && is_atom(tp[2])) {
 	    BIF_RET(am_true);
 	}
diff --git a/erts/emulator/beam/erl_bif_os.c b/erts/emulator/beam/erl_bif_os.c
index 954b1f9729..58d48199fa 100644
--- a/erts/emulator/beam/erl_bif_os.c
+++ b/erts/emulator/beam/erl_bif_os.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  * 
- * Copyright Ericsson AB 1999-2009. All Rights Reserved.
+ * Copyright Ericsson AB 1999-2010. All Rights Reserved.
  * 
  * The contents of this file are subject to the Erlang Public License,
  * Version 1.1, (the "License"); you may not use this file except in
@@ -53,20 +53,18 @@ BIF_RETTYPE os_timestamp_0(BIF_ALIST_0)
 }
 
 
-Eterm
-os_getpid_0(Process* p)
+BIF_RETTYPE os_getpid_0(BIF_ALIST_0)
 {
      char pid_string[21]; /* enough for a 64 bit number */
      int n;
      Eterm* hp;
      sys_get_pid(pid_string); /* In sys.c */
      n = sys_strlen(pid_string);
-     hp = HAlloc(p, n*2);
+     hp = HAlloc(BIF_P, n*2);
      BIF_RET(buf_to_intlist(&hp, pid_string, n, NIL));
 }
 
-Eterm
-os_getenv_0(Process* p)
+BIF_RETTYPE os_getenv_0(BIF_ALIST_0)
 {
     GETENV_STATE state;
     char *cp;
@@ -80,7 +78,7 @@ os_getenv_0(Process* p)
     ret = NIL;
     while ((cp = getenv_string(&state)) != NULL) {
 	len = strlen(cp);
-	hp = HAlloc(p, len*2+2);
+	hp = HAlloc(BIF_P, len*2+2);
 	str = buf_to_intlist(&hp, cp, len, NIL);
 	ret = CONS(hp, str, ret);
     }
@@ -90,9 +88,11 @@ os_getenv_0(Process* p)
     return ret;
 }
 
-Eterm
-os_getenv_1(Process* p, Eterm key)
+
+BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm key = BIF_ARG_1;
     Eterm str;
     int len, res;
     char *key_str, *val;
@@ -145,9 +145,11 @@ os_getenv_1(Process* p, Eterm key)
     BIF_RET(str);
 }
 
-Eterm
-os_putenv_2(Process* p, Eterm key, Eterm value)
+BIF_RETTYPE os_putenv_2(BIF_ALIST_2)
 {
+    Process* p = BIF_P;
+    Eterm key = BIF_ARG_1;
+    Eterm value = BIF_ARG_2;
     char def_buf[1024];
     char *buf = NULL;
     int sep_ix, i, key_len, value_len, tot_len;
diff --git a/erts/emulator/beam/erl_bif_port.c b/erts/emulator/beam/erl_bif_port.c
index 3fd35dd963..b21cda6347 100644
--- a/erts/emulator/beam/erl_bif_port.c
+++ b/erts/emulator/beam/erl_bif_port.c
@@ -48,6 +48,9 @@ static void free_args(char **);
 
 char *erts_default_arg0 = "default";
 
+static BIF_RETTYPE
+port_call(Process* p, Eterm arg1, Eterm arg2, Eterm arg3);
+
 BIF_RETTYPE open_port_2(BIF_ALIST_2)
 {
     int port_num;
@@ -117,11 +120,9 @@ id_or_name2port(Process *c_p, Eterm id)
 #define ERTS_PORT_COMMAND_FLAG_FORCE		(((Uint32) 1) << 0)
 #define ERTS_PORT_COMMAND_FLAG_NOSUSPEND	(((Uint32) 1) << 1)
 
-static BIF_RETTYPE do_port_command(Process *BIF_P,
-				   Eterm BIF_ARG_1,
-				   Eterm BIF_ARG_2,
-				   Eterm BIF_ARG_3,
-				   Uint32 flags)
+static BIF_RETTYPE
+do_port_command(Process *BIF_P, Eterm arg1, Eterm arg2, Eterm arg3,
+		Uint32 flags)
 {
     BIF_RETTYPE res;
     Port *p;
@@ -135,7 +136,7 @@ static BIF_RETTYPE do_port_command(Process *BIF_P,
     	profile_runnable_proc(BIF_P, am_inactive);
     }
 
-    p = id_or_name2port(BIF_P, BIF_ARG_1);
+    p = id_or_name2port(BIF_P, arg1);
     if (!p) {
     	if (IS_TRACED_FL(BIF_P, F_TRACE_SCHED_PROCS)) {
 	    trace_virtual_sched(BIF_P, am_in);
@@ -172,13 +173,13 @@ static BIF_RETTYPE do_port_command(Process *BIF_P,
 		monitor_generic(BIF_P, am_busy_port, p->id);
 	    }
 	    ERTS_BIF_PREP_YIELD3(res, bif_export[BIF_port_command_3], BIF_P,
-				 BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);    
+				 arg1, arg2, arg3);
 	}
     } else {
 	int wres;
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	ERTS_SMP_CHK_NO_PROC_LOCKS;
-	wres = erts_write_to_port(BIF_P->id, p, BIF_ARG_2);
+	wres = erts_write_to_port(BIF_P->id, p, arg2);
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	if (wres != 0) {
 	    ERTS_BIF_PREP_ERROR(res, BIF_P, BADARG);
@@ -237,11 +238,17 @@ BIF_RETTYPE port_command_3(BIF_ALIST_3)
 
 BIF_RETTYPE port_call_2(BIF_ALIST_2)
 {
-    return port_call_3(BIF_P,BIF_ARG_1,make_small(0),BIF_ARG_2);
+    return port_call(BIF_P,BIF_ARG_1, make_small(0), BIF_ARG_2);
 }
 
 BIF_RETTYPE port_call_3(BIF_ALIST_3)
 {
+    return port_call(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+}
+
+static BIF_RETTYPE
+port_call(Process* c_p, Eterm arg1, Eterm arg2, Eterm arg3)
+{
     Uint op;
     Port *p;
     Uint size;
@@ -266,15 +273,15 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
     /* trace of port scheduling with virtual process descheduling
      * lock wait 
      */
-    if (IS_TRACED_FL(BIF_P, F_TRACE_SCHED_PROCS)) {
-    	trace_virtual_sched(BIF_P, am_out);
+    if (IS_TRACED_FL(c_p, F_TRACE_SCHED_PROCS)) {
+	trace_virtual_sched(c_p, am_out);
     }
 
     if (erts_system_profile_flags.runnable_procs && erts_system_profile_flags.exclusive) {
-    	profile_runnable_proc(BIF_P, am_inactive);
+	profile_runnable_proc(c_p, am_inactive);
     }
 
-    p = id_or_name2port(BIF_P, BIF_ARG_1);
+    p = id_or_name2port(c_p, arg1);
     if (!p) {
     error:
 	if (port_resp != port_result && 
@@ -286,22 +293,22 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
 	/* Need to virtual schedule in the process if there
 	 * was an error.
 	 */
-    	if (IS_TRACED_FL(BIF_P, F_TRACE_SCHED_PROCS)) {
-    	    trace_virtual_sched(BIF_P, am_in);
+	if (IS_TRACED_FL(c_p, F_TRACE_SCHED_PROCS)) {
+	    trace_virtual_sched(c_p, am_in);
     	}
 
 	if (erts_system_profile_flags.runnable_procs && erts_system_profile_flags.exclusive) {
-    	    profile_runnable_proc(BIF_P, am_active);
+	    profile_runnable_proc(c_p, am_active);
     	}
 
 	if (p)
 	    erts_port_release(p);
 #ifdef ERTS_SMP
-	ERTS_SMP_BIF_CHK_PENDING_EXIT(BIF_P, ERTS_PROC_LOCK_MAIN);
+	ERTS_SMP_BIF_CHK_PENDING_EXIT(c_p, ERTS_PROC_LOCK_MAIN);
 #else
-	ERTS_BIF_CHK_EXITED(BIF_P);
+	ERTS_BIF_CHK_EXITED(c_p);
 #endif
-	BIF_ERROR(BIF_P, BADARG);
+	BIF_ERROR(c_p, BADARG);
     }
 
     if ((drv = p->drv_ptr) == NULL) {
@@ -310,10 +317,10 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
     if (drv->call == NULL) {
 	goto error;
     }
-    if (!term_to_Uint(BIF_ARG_2, &op)) {
+    if (!term_to_Uint(arg2, &op)) {
 	goto error;
     }
-    p->caller = BIF_P->id;
+    p->caller = c_p->id;
     
     /* Lock taken, virtual schedule of port */
     if (IS_TRACED_FL(p, F_TRACE_SCHED_PORTS)) {
@@ -323,19 +330,19 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
     if (erts_system_profile_flags.runnable_ports && !erts_port_is_scheduled(p)) {
     	profile_runnable_port(p, am_active);
     }
-    size = erts_encode_ext_size(BIF_ARG_3);
+    size = erts_encode_ext_size(arg3);
     if (size > sizeof(port_input))
 	bytes = erts_alloc(ERTS_ALC_T_PORT_CALL_BUF, size);
 
     endp = bytes;
-    erts_encode_ext(BIF_ARG_3, &endp);
+    erts_encode_ext(arg3, &endp);
 
     real_size = endp - bytes;
     if (real_size > size) {
 	erl_exit(1, "%s, line %d: buffer overflow: %d word(s)\n",
 		 __FILE__, __LINE__, endp - (bytes + size));
     }
-    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
     prc  = (char *) port_resp;
     fpe_was_unmasked = erts_block_fpe();
     ret = drv->call((ErlDrvData)p->drv_data, 
@@ -356,7 +363,7 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
    
     port_resp = (byte *) prc;
     p->caller = NIL;
-    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
+    erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
 #ifdef HARDDEBUG
     { 
 	int z;
@@ -382,14 +389,14 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
     if (result_size < 0) {
 	goto error;
     }
-    hp = HAlloc(BIF_P, result_size);
+    hp = HAlloc(c_p, result_size);
     hp_end = hp + result_size;
     endp = port_resp;
-    res = erts_decode_ext(&hp, &MSO(BIF_P), &endp);
+    res = erts_decode_ext(&hp, &MSO(c_p), &endp);
     if (res == THE_NON_VALUE) {
 	goto error;
     }
-    HRelease(BIF_P, hp_end, hp);
+    HRelease(c_p, hp_end, hp);
     if (port_resp != port_result && !(ret_flags & DRIVER_CALL_KEEP_BUFFER)) {
 	driver_free(port_resp);
     }
@@ -398,16 +405,16 @@ BIF_RETTYPE port_call_3(BIF_ALIST_3)
     if (p)
 	erts_port_release(p);
 #ifdef ERTS_SMP
-    ERTS_SMP_BIF_CHK_PENDING_EXIT(BIF_P, ERTS_PROC_LOCK_MAIN);
+    ERTS_SMP_BIF_CHK_PENDING_EXIT(c_p, ERTS_PROC_LOCK_MAIN);
 #else
-    ERTS_BIF_CHK_EXITED(BIF_P);
+    ERTS_BIF_CHK_EXITED(c_p);
 #endif
-    if (IS_TRACED_FL(BIF_P, F_TRACE_SCHED_PROCS)) {
-    	trace_virtual_sched(BIF_P, am_in);
+    if (IS_TRACED_FL(c_p, F_TRACE_SCHED_PROCS)) {
+	trace_virtual_sched(c_p, am_in);
     }
 
     if (erts_system_profile_flags.runnable_procs && erts_system_profile_flags.exclusive) {
-    	profile_runnable_proc(BIF_P, am_active);
+	profile_runnable_proc(c_p, am_active);
     }
   
     return res;
diff --git a/erts/emulator/beam/erl_bif_re.c b/erts/emulator/beam/erl_bif_re.c
index 26891c4348..6b843d2e08 100644
--- a/erts/emulator/beam/erl_bif_re.c
+++ b/erts/emulator/beam/erl_bif_re.c
@@ -45,6 +45,7 @@ static Export *urun_trap_exportp = NULL;
 static Export *ucompile_trap_exportp = NULL;
 
 static BIF_RETTYPE re_exec_trap(BIF_ALIST_3);
+static BIF_RETTYPE re_run(Process *p, Eterm arg1, Eterm arg2, Eterm arg3);
 
 static void *erts_erts_pcre_malloc(size_t size) {
     return erts_alloc(ERTS_ALC_T_RE_HEAP,size);
@@ -414,8 +415,8 @@ build_compile_result(Process *p, Eterm error_tag, pcre *result, int errcode, con
  * Compile BIFs
  */
 
-BIF_RETTYPE
-re_compile_2(BIF_ALIST_2)
+static BIF_RETTYPE
+re_compile(Process* p, Eterm arg1, Eterm arg2)
 {
     Uint slen;
     char *expr;
@@ -429,43 +430,49 @@ re_compile_2(BIF_ALIST_2)
     int unicode = 0;
 
 
-    if (parse_options(BIF_ARG_2,&options,NULL,&pflags,NULL,NULL)
+    if (parse_options(arg2,&options,NULL,&pflags,NULL,NULL)
 	< 0) {
-	BIF_ERROR(BIF_P,BADARG);
+	BIF_ERROR(p,BADARG);
     }
 
     if (pflags & PARSE_FLAG_UNIQUE_EXEC_OPT) {
-	BIF_ERROR(BIF_P,BADARG);
+	BIF_ERROR(p,BADARG);
     }
 
     unicode = (pflags & PARSE_FLAG_UNICODE) ? 1 : 0;
 
-    if (pflags & PARSE_FLAG_UNICODE && !is_binary(BIF_ARG_1)) { 
-	BIF_TRAP2(ucompile_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2);
+    if (pflags & PARSE_FLAG_UNICODE && !is_binary(arg1)) {
+	BIF_TRAP2(ucompile_trap_exportp, p, arg1, arg2);
     }
 
-    if (erts_iolist_size(BIF_ARG_1, &slen)) {
-        BIF_ERROR(BIF_P,BADARG);
+    if (erts_iolist_size(arg1, &slen)) {
+        BIF_ERROR(p,BADARG);
     }
     expr = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, slen + 1);
-    if (io_list_to_buf(BIF_ARG_1, expr, slen) != 0) {
+    if (io_list_to_buf(arg1, expr, slen) != 0) {
 	erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
-	BIF_ERROR(BIF_P,BADARG);
+	BIF_ERROR(p,BADARG);
     }
     expr[slen]='\0';
     result = erts_pcre_compile2(expr, options, &errcode, 
 			   &errstr, &errofset, default_table);
 
-    ret = build_compile_result(BIF_P, am_error, result, errcode, 
+    ret = build_compile_result(p, am_error, result, errcode,
 			       errstr, errofset, unicode, 1);
     erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
     BIF_RET(ret);
 }
 
 BIF_RETTYPE
+re_compile_2(BIF_ALIST_2)
+{
+    return re_compile(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+BIF_RETTYPE
 re_compile_1(BIF_ALIST_1)
 {
-    return re_compile_2(BIF_P,BIF_ARG_1,NIL);
+    return re_compile(BIF_P, BIF_ARG_1, NIL);
 }
 
 /*
@@ -845,8 +852,8 @@ build_capture(Eterm capture_spec[CAPSPEC_SIZE], const pcre *code)
 /*
  * The actual re:run/2,3 BIFs
  */
-BIF_RETTYPE
-re_run_3(BIF_ALIST_3)
+static BIF_RETTYPE
+re_run(Process *p, Eterm arg1, Eterm arg2, Eterm arg3)
 {
     const pcre *code_tmp;
     RestartContext restart;
@@ -865,15 +872,15 @@ re_run_3(BIF_ALIST_3)
     Eterm capture[CAPSPEC_SIZE];
     int is_list_cap;
 
-    if (parse_options(BIF_ARG_3,&comp_options,&options,&pflags,&startoffset,capture)
+    if (parse_options(arg3,&comp_options,&options,&pflags,&startoffset,capture)
 	< 0) {
-	BIF_ERROR(BIF_P,BADARG);
+	BIF_ERROR(p,BADARG);
     }
     is_list_cap = ((pflags & PARSE_FLAG_CAPTURE_OPT) && 
 		   (capture[CAPSPEC_TYPE] == am_list));
 
-    if (is_not_tuple(BIF_ARG_2) || (arityval(*tuple_val(BIF_ARG_2)) != 4)) {
-	if (is_binary(BIF_ARG_2) || is_list(BIF_ARG_2) || is_nil(BIF_ARG_2)) { 
+    if (is_not_tuple(arg2) || (arityval(*tuple_val(arg2)) != 4)) {
+	if (is_binary(arg2) || is_list(arg2) || is_nil(arg2)) {
 	    /* Compile from textual RE */
 	    Uint slen;
 	    char *expr;
@@ -884,19 +891,19 @@ re_run_3(BIF_ALIST_3)
 	    int capture_count;
 
 	    if (pflags & PARSE_FLAG_UNICODE && 
-		(!is_binary(BIF_ARG_2) || !is_binary(BIF_ARG_1) ||
+		(!is_binary(arg2) || !is_binary(arg1) ||
 		 (is_list_cap && !(pflags & PARSE_FLAG_GLOBAL)))) { 
-		BIF_TRAP3(urun_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+		BIF_TRAP3(urun_trap_exportp, p, arg1, arg2, arg3);
 	    }
 	    
-	    if (erts_iolist_size(BIF_ARG_2, &slen)) {
-		BIF_ERROR(BIF_P,BADARG);
+	    if (erts_iolist_size(arg2, &slen)) {
+		BIF_ERROR(p,BADARG);
 	    }
 	    
 	    expr = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, slen + 1);
-	    if (io_list_to_buf(BIF_ARG_2, expr, slen) != 0) {
+	    if (io_list_to_buf(arg2, expr, slen) != 0) {
 		erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
-		BIF_ERROR(BIF_P,BADARG);
+		BIF_ERROR(p,BADARG);
 	    }
 	    expr[slen]='\0';
 	    result = erts_pcre_compile2(expr, comp_options, &errcode, 
@@ -905,11 +912,11 @@ re_run_3(BIF_ALIST_3)
 		erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
 		/* Compilation error gives badarg except in the compile 
 		   function */
-		BIF_ERROR(BIF_P,BADARG);
+		BIF_ERROR(p,BADARG);
 	    }
 	    if (pflags & PARSE_FLAG_GLOBAL) {
 		Eterm precompiled = 
-		    build_compile_result(BIF_P, am_error, 
+		    build_compile_result(p, am_error,
 					 result, errcode, 
 					 errstr, errofset, 
 					 (pflags & 
@@ -917,13 +924,13 @@ re_run_3(BIF_ALIST_3)
 					 0);
 		Eterm *hp,r;
 		erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
-		hp = HAlloc(BIF_P,4);
-		/* BIF_ARG_2 is in the tuple just to make exceptions right */
-		r = TUPLE3(hp,BIF_ARG_3,
+		hp = HAlloc(p,4);
+		/* arg2 is in the tuple just to make exceptions right */
+		r = TUPLE3(hp,arg3,
 			   ((pflags & PARSE_FLAG_UNIQUE_COMPILE_OPT) ? 
 			    am_true : 
-			    am_false), BIF_ARG_2);
-		BIF_TRAP3(grun_trap_exportp, BIF_P, BIF_ARG_1, precompiled, r);
+			    am_false), arg2);
+		BIF_TRAP3(grun_trap_exportp, p, arg1, precompiled, r);
 	    }
 
 	    erts_pcre_fullinfo(result, NULL, PCRE_INFO_SIZE, &code_size);
@@ -935,31 +942,31 @@ re_run_3(BIF_ALIST_3)
 	    erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
 	    /*unicode = (pflags & PARSE_FLAG_UNICODE) ? 1 : 0;*/
 	} else {  
-	    BIF_ERROR(BIF_P,BADARG);
+	    BIF_ERROR(p,BADARG);
 	}
     } else {
 	if (pflags & PARSE_FLAG_UNIQUE_COMPILE_OPT) {
-	    BIF_ERROR(BIF_P,BADARG);
+	    BIF_ERROR(p,BADARG);
 	}
 
-	tp = tuple_val(BIF_ARG_2);
+	tp = tuple_val(arg2);
 	if (tp[1] != am_re_pattern || is_not_small(tp[2]) || 
 	    is_not_small(tp[3]) || is_not_binary(tp[4])) {
-	    BIF_ERROR(BIF_P,BADARG);
+	    BIF_ERROR(p,BADARG);
 	}
 
 	if (unsigned_val(tp[3]) && 
-	    (!is_binary(BIF_ARG_1) || 
+	    (!is_binary(arg1) ||
 	     (is_list_cap && !(pflags & PARSE_FLAG_GLOBAL)))) { /* unicode */
-	    BIF_TRAP3(urun_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2, 
-		      BIF_ARG_3);
+	    BIF_TRAP3(urun_trap_exportp, p, arg1, arg2,
+		      arg3);
 	}
 
 	if (pflags & PARSE_FLAG_GLOBAL) {
 	    Eterm *hp,r;
-	    hp = HAlloc(BIF_P,3);
-	    r = TUPLE2(hp,BIF_ARG_3,am_false);
-	    BIF_TRAP3(grun_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2, 
+	    hp = HAlloc(p,3);
+	    r = TUPLE2(hp,arg3,am_false);
+	    BIF_TRAP3(grun_trap_exportp, p, arg1, arg2,
 		      r);
 	}
 
@@ -968,7 +975,7 @@ re_run_3(BIF_ALIST_3)
 	if ((code_tmp = (const pcre *) 
 	     erts_get_aligned_binary_bytes(tp[4], &temp_alloc)) == NULL) {
 	    erts_free_aligned_binary_bytes(temp_alloc);
-	    BIF_ERROR(BIF_P, BADARG);
+	    BIF_ERROR(p, BADARG);
 	}
 	restart.code = erts_alloc(ERTS_ALC_T_RE_SUBJECT, code_size);
 	memcpy(restart.code, code_tmp, code_size);
@@ -980,7 +987,7 @@ re_run_3(BIF_ALIST_3)
     restart.ovector =  erts_alloc(ERTS_ALC_T_RE_SUBJECT, ovsize * sizeof(int));
     restart.extra.flags = PCRE_EXTRA_TABLES | PCRE_EXTRA_LOOP_LIMIT;
     restart.extra.tables = default_table;
-    restart.extra.loop_limit = ERTS_BIF_REDS_LEFT(BIF_P) * LOOP_FACTOR;
+    restart.extra.loop_limit = ERTS_BIF_REDS_LEFT(p) * LOOP_FACTOR;
     loop_limit_tmp = max_loop_limit; /* To lesser probability of race in debug
 					situation (erts_debug) */
     if (restart.extra.loop_limit > loop_limit_tmp) {
@@ -996,7 +1003,7 @@ re_run_3(BIF_ALIST_3)
 	if ((restart.ret_info = build_capture(capture,restart.code)) == NULL) {
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ovector);
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.code);
-	    BIF_ERROR(BIF_P,BADARG);
+	    BIF_ERROR(p,BADARG);
 	}
     }
 	    
@@ -1004,7 +1011,7 @@ re_run_3(BIF_ALIST_3)
        copying, also binary returns can be sub binaries in that case */
 
     restart.flags = 0;
-    if (is_binary(BIF_ARG_1)) {
+    if (is_binary(arg1)) {
 	Eterm real_bin;
 	Uint offset;
 	Eterm* bptr;
@@ -1012,9 +1019,9 @@ re_run_3(BIF_ALIST_3)
 	int bitsize;
 	ProcBin* pb;
 
-	ERTS_GET_REAL_BIN(BIF_ARG_1, real_bin, offset, bitoffs, bitsize);
+	ERTS_GET_REAL_BIN(arg1, real_bin, offset, bitoffs, bitsize);
 
-	slength = binary_size(BIF_ARG_1);
+	slength = binary_size(arg1);
 	bptr = binary_val(real_bin);
 	if (bitsize != 0 || bitoffs != 0 ||  (*bptr != HEADER_PROC_BIN)) {
 	    goto handle_iolist;
@@ -1027,24 +1034,24 @@ re_run_3(BIF_ALIST_3)
 	restart.flags |= RESTART_FLAG_SUBJECT_IN_BINARY;
     } else {
 handle_iolist:
-	if (erts_iolist_size(BIF_ARG_1, &slength)) {
+	if (erts_iolist_size(arg1, &slength)) {
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ovector);
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.code);
 	    if (restart.ret_info != NULL) {
 		erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ret_info);
 	    }
-	    BIF_ERROR(BIF_P,BADARG);
+	    BIF_ERROR(p,BADARG);
 	}
 	restart.subject = erts_alloc(ERTS_ALC_T_RE_SUBJECT, slength);
 
-	if (io_list_to_buf(BIF_ARG_1, restart.subject, slength) != 0) {
+	if (io_list_to_buf(arg1, restart.subject, slength) != 0) {
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ovector);
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.code);
 	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.subject);
 	    if (restart.ret_info != NULL) {
 		erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ret_info);
 	    }
-	    BIF_ERROR(BIF_P,BADARG);
+	    BIF_ERROR(p,BADARG);
 	}
     }
 
@@ -1056,7 +1063,7 @@ handle_iolist:
     rc = erts_pcre_exec(restart.code, &(restart.extra), restart.subject, slength, startoffset, 
 		   options, restart.ovector, ovsize);
     ASSERT(loop_count != 0xFFFFFFFF);
-    BUMP_REDS(BIF_P, loop_count / LOOP_FACTOR);
+    BUMP_REDS(p, loop_count / LOOP_FACTOR);
     if (rc == PCRE_ERROR_LOOP_LIMIT) {
 	/* Trap */
 	Binary *mbp = erts_create_magic_binary(sizeof(RestartContext),
@@ -1065,17 +1072,17 @@ handle_iolist:
 	Eterm magic_bin;
 	Eterm *hp;
 	memcpy(restartp,&restart,sizeof(RestartContext));
-	BUMP_ALL_REDS(BIF_P);
-	hp = HAlloc(BIF_P, PROC_BIN_SIZE);
-	magic_bin = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), mbp);
+	BUMP_ALL_REDS(p);
+	hp = HAlloc(p, PROC_BIN_SIZE);
+	magic_bin = erts_mk_magic_binary_term(&hp, &MSO(p), mbp);
 	BIF_TRAP3(&re_exec_trap_export, 
-		  BIF_P, 
-		  BIF_ARG_1, 
-		  BIF_ARG_2 /* To avoid GC of precompiled code, XXX: not utilized yet */, 
+		  p,
+		  arg1,
+		  arg2 /* To avoid GC of precompiled code, XXX: not utilized yet */,
 		  magic_bin);
     }
     
-    res = build_exec_return(BIF_P, rc, &restart, BIF_ARG_1);
+    res = build_exec_return(p, rc, &restart, arg1);
  
     cleanup_restart_context(&restart);
 
@@ -1083,9 +1090,15 @@ handle_iolist:
 }
 
 BIF_RETTYPE
+re_run_3(BIF_ALIST_3)
+{
+    return re_run(BIF_P,BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+}
+
+BIF_RETTYPE
 re_run_2(BIF_ALIST_2) 
 {
-    return re_run_3(BIF_P,BIF_ARG_1, BIF_ARG_2, NIL);
+    return re_run(BIF_P,BIF_ARG_1, BIF_ARG_2, NIL);
 }
 
 /*
diff --git a/erts/emulator/beam/erl_bif_trace.c b/erts/emulator/beam/erl_bif_trace.c
index 7a08182e18..af49345410 100644
--- a/erts/emulator/beam/erl_bif_trace.c
+++ b/erts/emulator/beam/erl_bif_trace.c
@@ -47,6 +47,11 @@ static Binary                     *erts_default_meta_match_spec;
 static struct trace_pattern_flags  erts_default_trace_pattern_flags;
 static Eterm                       erts_default_meta_tracer_pid;
 
+static Eterm
+trace_pattern(Process* p, Eterm MFA, Eterm Pattern, Eterm flaglist);
+static BIF_RETTYPE
+system_monitor(Process *p, Eterm monitor_pid, Eterm list);
+
 static void new_seq_trace_token(Process* p); /* help func for seq_trace_2*/
 static int already_traced(Process *p, Process *tracee_p, Eterm tracer);
 static int port_already_traced(Process *p, Port *tracee_port, Eterm tracer);
@@ -76,13 +81,19 @@ erts_bif_trace_init(void)
  */
   
 Eterm
-trace_pattern_2(Process* p, Eterm MFA, Eterm Pattern)
+trace_pattern_2(BIF_ALIST_2)
 {
-    return trace_pattern_3(p,MFA,Pattern,NIL);
+    return trace_pattern(BIF_P, BIF_ARG_1, BIF_ARG_2, NIL);
 }
 
 Eterm
-trace_pattern_3(Process* p, Eterm MFA, Eterm Pattern, Eterm flaglist)       
+trace_pattern_3(BIF_ALIST_3)
+{
+    return trace_pattern(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+}
+
+static Eterm
+trace_pattern(Process* p, Eterm MFA, Eterm Pattern, Eterm flaglist)
 {
     DeclareTmpHeap(mfa,3,p); /* Not really heap here, but might be when setting pattern */
     int i;
@@ -435,9 +446,12 @@ erts_trace_flags(Eterm List,
     return 0;
 }
 
-Eterm
-trace_3(Process* p, Eterm pid_spec, Eterm how, Eterm list)
+Eterm trace_3(BIF_ALIST_3)
 {
+    Process* p = BIF_P;
+    Eterm pid_spec = BIF_ARG_1;
+    Eterm how = BIF_ARG_2;
+    Eterm list = BIF_ARG_3;
     int on;
     Eterm tracer = NIL;
     int matches = 0;
@@ -820,9 +834,11 @@ static int already_traced(Process *c_p, Process *tracee_p, Eterm tracer)
  * Return information about a process or an external function being traced.
  */
 
-Eterm
-trace_info_2(Process* p, Eterm What, Eterm Key)
+Eterm trace_info_2(BIF_ALIST_2)
 {
+    Process* p = BIF_P;
+    Eterm What = BIF_ARG_1;
+    Eterm Key = BIF_ARG_2;
     Eterm res;
     if (What == am_on_load) {
 	res = trace_info_on_load(p, Key);
@@ -1752,23 +1768,20 @@ new_seq_trace_token(Process* p)
     }
 }
 
-BIF_RETTYPE seq_trace_info_1(BIF_ALIST_1)
+BIF_RETTYPE erl_seq_trace_info(Process *p, Eterm item)
 {
-    Eterm item;
     Eterm res;
     Eterm* hp;
     Uint current_flag;
 
-    if (is_not_atom(BIF_ARG_1)) {
-	BIF_ERROR(BIF_P, BADARG);
+    if (is_not_atom(item)) {
+	BIF_ERROR(p, BADARG);
     }
 
-    item = BIF_ARG_1;
-
-    if (SEQ_TRACE_TOKEN(BIF_P) == NIL) {
+    if (SEQ_TRACE_TOKEN(p) == NIL) {
 	if ((item == am_send) || (item == am_receive) || 
 	    (item == am_print) || (item == am_timestamp)) {
-	    hp = HAlloc(BIF_P,3);
+	    hp = HAlloc(p,3);
 	    res = TUPLE2(hp, item, am_false);
 	    BIF_RET(res);
 	} else if ((item == am_label) || (item == am_serial)) {
@@ -1778,35 +1791,40 @@ BIF_RETTYPE seq_trace_info_1(BIF_ALIST_1)
 	}
     }
 
-    if (BIF_ARG_1 == am_send) {
+    if (item == am_send) {
 	current_flag = SEQ_TRACE_SEND;
-    } else if (BIF_ARG_1 == am_receive) {
+    } else if (item == am_receive) {
 	current_flag = SEQ_TRACE_RECEIVE; 
-    } else if (BIF_ARG_1 == am_print) {
+    } else if (item == am_print) {
 	current_flag = SEQ_TRACE_PRINT; 
-    } else if (BIF_ARG_1 == am_timestamp) {
+    } else if (item == am_timestamp) {
 	current_flag = SEQ_TRACE_TIMESTAMP; 
     } else {
 	current_flag = 0;
     }
 
     if (current_flag) {
-	res = unsigned_val(SEQ_TRACE_TOKEN_FLAGS(BIF_P)) & current_flag ? 
+	res = unsigned_val(SEQ_TRACE_TOKEN_FLAGS(p)) & current_flag ?
 	    am_true : am_false;
     } else if (item == am_label) {
-	res = SEQ_TRACE_TOKEN_LABEL(BIF_P);
+	res = SEQ_TRACE_TOKEN_LABEL(p);
     } else if (item  == am_serial) {
-	hp = HAlloc(BIF_P, 3);
-	res = TUPLE2(hp, SEQ_TRACE_TOKEN_LASTCNT(BIF_P), SEQ_TRACE_TOKEN_SERIAL(BIF_P));
+	hp = HAlloc(p, 3);
+	res = TUPLE2(hp, SEQ_TRACE_TOKEN_LASTCNT(p), SEQ_TRACE_TOKEN_SERIAL(p));
     } else {
     error:
-	BIF_ERROR(BIF_P, BADARG);
+	BIF_ERROR(p, BADARG);
     }
-    hp = HAlloc(BIF_P, 3);
+    hp = HAlloc(p, 3);
     res = TUPLE2(hp, item, res);
     BIF_RET(res);
 }
 
+BIF_RETTYPE seq_trace_info_1(BIF_ALIST_1)
+{
+    BIF_RET(erl_seq_trace_info(BIF_P, BIF_ARG_1));
+}
+
 /*
    seq_trace_print(Message) -> true | false
    This function passes Message to the system_tracer
@@ -1919,23 +1937,35 @@ static Eterm system_monitor_get(Process *p)
 }
 
 
-BIF_RETTYPE system_monitor_0(Process *p) {
-    BIF_RET(system_monitor_get(p));
+BIF_RETTYPE system_monitor_0(BIF_ALIST_0)
+{
+    BIF_RET(system_monitor_get(BIF_P));
 }
 
-BIF_RETTYPE system_monitor_1(Process *p, Eterm spec) {
+BIF_RETTYPE system_monitor_1(BIF_ALIST_1)
+{
+    Process* p = BIF_P;
+    Eterm spec = BIF_ARG_1;
+
     if (spec == am_undefined) {
-	BIF_RET(system_monitor_2(p, spec, NIL));
+	BIF_RET(system_monitor(p, spec, NIL));
     } else if (is_tuple(spec)) {
 	Eterm *tp = tuple_val(spec);
 	if (tp[0] != make_arityval(2)) goto error;
-	BIF_RET(system_monitor_2(p, tp[1], tp[2]));
+	BIF_RET(system_monitor(p, tp[1], tp[2]));
     }
  error:
     BIF_ERROR(p, BADARG);
 }
 
-BIF_RETTYPE system_monitor_2(Process *p, Eterm monitor_pid, Eterm list) {
+BIF_RETTYPE system_monitor_2(BIF_ALIST_2)
+{
+    return system_monitor(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+static BIF_RETTYPE
+system_monitor(Process *p, Eterm monitor_pid, Eterm list)
+{
     Eterm prev;
     int system_blocked = 0;
 
@@ -2053,11 +2083,16 @@ static Eterm system_profile_get(Process *p) {
     }
 }
 
-BIF_RETTYPE system_profile_0(Process *p) {
-    BIF_RET(system_profile_get(p));
+BIF_RETTYPE system_profile_0(BIF_ALIST_0)
+{
+    BIF_RET(system_profile_get(BIF_P));
 }
 
-BIF_RETTYPE system_profile_2(Process *p, Eterm profiler, Eterm list) {
+BIF_RETTYPE system_profile_2(BIF_ALIST_2)
+{
+    Process *p = BIF_P;
+    Eterm profiler = BIF_ARG_1;
+    Eterm list = BIF_ARG_2;
     Eterm prev;
     int system_blocked = 0;
     Process *profiler_p = NULL;
diff --git a/erts/emulator/beam/erl_db.c b/erts/emulator/beam/erl_db.c
index ee6e1771d0..d8b4294a30 100644
--- a/erts/emulator/beam/erl_db.c
+++ b/erts/emulator/beam/erl_db.c
@@ -129,8 +129,6 @@ static Uint meta_main_tab_slot_mask;    /* The slot index part of an unnamed tab
 static Uint meta_main_tab_seq_incr;
 static Uint meta_main_tab_seq_cnt = 0;  /* To give unique(-ish) table identifiers */
 
-
-
 /* 
 ** The meta hash table of all NAMED ets tables
 */
@@ -202,12 +200,17 @@ static int free_table_cont(Process *p,
 			   int first,
 			   int clean_meta_tab);
 static void print_table(int to, void *to_arg, int show,  DbTable* tb);
-static BIF_RETTYPE ets_select_delete_1(Process *p, Eterm a1);
-static BIF_RETTYPE ets_select_count_1(Process *p, Eterm a1);
-static BIF_RETTYPE ets_select_trap_1(Process *p, Eterm a1);
-static BIF_RETTYPE ets_delete_trap(Process *p, Eterm a1);
+static BIF_RETTYPE ets_select_delete_1(BIF_ALIST_1);
+static BIF_RETTYPE ets_select_count_1(BIF_ALIST_1);
+static BIF_RETTYPE ets_select_trap_1(BIF_ALIST_1);
+static BIF_RETTYPE ets_delete_trap(BIF_ALIST_1);
 static Eterm table_info(Process* p, DbTable* tb, Eterm What);
 
+static BIF_RETTYPE ets_select1(Process* p, Eterm arg1);
+static BIF_RETTYPE ets_select2(Process* p, Eterm arg1, Eterm arg2);
+static BIF_RETTYPE ets_select3(Process* p, Eterm arg1, Eterm arg2, Eterm arg3);
+
+
 /* 
  * Exported global
  */
@@ -1947,8 +1950,10 @@ BIF_RETTYPE ets_delete_object_2(BIF_ALIST_2)
 /*
 ** This is for trapping, cannot be called directly.
 */
-static BIF_RETTYPE ets_select_delete_1(Process *p, Eterm a1)
+static BIF_RETTYPE ets_select_delete_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm a1 = BIF_ARG_1;
     BIF_RETTYPE result;
     DbTable* tb;
     int cret;
@@ -2114,7 +2119,7 @@ BIF_RETTYPE ets_slot_2(BIF_ALIST_2)
 
 BIF_RETTYPE ets_match_1(BIF_ALIST_1)
 {
-    return ets_select_1(BIF_P, BIF_ARG_1);
+    return ets_select1(BIF_P, BIF_ARG_1);
 }
 
 BIF_RETTYPE ets_match_2(BIF_ALIST_2)
@@ -2130,7 +2135,7 @@ BIF_RETTYPE ets_match_2(BIF_ALIST_2)
     ms = TUPLE3(hp, BIF_ARG_2, NIL, ms); 
     hp += 4;
     ms = CONS(hp, ms, NIL);
-    res = ets_select_2(BIF_P, BIF_ARG_1, ms);
+    res = ets_select2(BIF_P, BIF_ARG_1, ms);
     UnUseTmpHeap(8,BIF_P);
     return res;
 }
@@ -2148,7 +2153,7 @@ BIF_RETTYPE ets_match_3(BIF_ALIST_3)
     ms = TUPLE3(hp, BIF_ARG_2, NIL, ms); 
     hp += 4;
     ms = CONS(hp, ms, NIL);
-    res = ets_select_3(BIF_P, BIF_ARG_1, ms, BIF_ARG_3);
+    res = ets_select3(BIF_P, BIF_ARG_1, ms, BIF_ARG_3);
     UnUseTmpHeap(8,BIF_P);
     return res;
 }
@@ -2156,6 +2161,12 @@ BIF_RETTYPE ets_match_3(BIF_ALIST_3)
 
 BIF_RETTYPE ets_select_3(BIF_ALIST_3)
 {
+    return ets_select3(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+}
+
+static BIF_RETTYPE
+ets_select3(Process* p, Eterm arg1, Eterm arg2, Eterm arg3)
+{
     BIF_RETTYPE result;
     DbTable* tb;
     int cret;
@@ -2166,22 +2177,22 @@ BIF_RETTYPE ets_select_3(BIF_ALIST_3)
     CHECK_TABLES();
 
     /* Chunk size strictly greater than 0 */
-    if (is_not_small(BIF_ARG_3) || (chunk_size = signed_val(BIF_ARG_3)) <= 0) {
-	BIF_ERROR(BIF_P, BADARG);
+    if (is_not_small(arg3) || (chunk_size = signed_val(arg3)) <= 0) {
+	BIF_ERROR(p, BADARG);
     }
-    if ((tb = db_get_table(BIF_P, BIF_ARG_1, DB_READ, LCK_READ)) == NULL) {
-	BIF_ERROR(BIF_P, BADARG);
+    if ((tb = db_get_table(p, arg1, DB_READ, LCK_READ)) == NULL) {
+	BIF_ERROR(p, BADARG);
     }
-    safety = ITERATION_SAFETY(BIF_P,tb);
+    safety = ITERATION_SAFETY(p,tb);
     if (safety == ITER_UNSAFE) {
 	local_fix_table(tb);
     }
-    cret = tb->common.meth->db_select_chunk(BIF_P, tb,
-					    BIF_ARG_2, chunk_size, 
+    cret = tb->common.meth->db_select_chunk(p, tb,
+					    arg2, chunk_size,
 					    0 /* not reversed */,
 					    &ret);
-    if (DID_TRAP(BIF_P,ret) && safety != ITER_SAFE) {
-	fix_table_locked(BIF_P, tb);
+    if (DID_TRAP(p,ret) && safety != ITER_SAFE) {
+	fix_table_locked(p, tb);
     }
     if (safety == ITER_UNSAFE) {
 	local_unfix_table(tb);
@@ -2193,22 +2204,24 @@ BIF_RETTYPE ets_select_3(BIF_ALIST_3)
 	ERTS_BIF_PREP_RET(result, ret);
 	break;
     case DB_ERROR_SYSRES:
-	ERTS_BIF_PREP_ERROR(result, BIF_P, SYSTEM_LIMIT);
+	ERTS_BIF_PREP_ERROR(result, p, SYSTEM_LIMIT);
 	break;
     default:
-	ERTS_BIF_PREP_ERROR(result, BIF_P, BADARG);
+	ERTS_BIF_PREP_ERROR(result, p, BADARG);
 	break;
     }
 
-    erts_match_set_release_result(BIF_P);
+    erts_match_set_release_result(p);
 
     return result;
 }
 
 
 /* We get here instead of in the real BIF when trapping */
-static BIF_RETTYPE ets_select_trap_1(Process *p, Eterm a1)
+static BIF_RETTYPE ets_select_trap_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm a1 = BIF_ARG_1;
     BIF_RETTYPE result;
     DbTable* tb;
     int cret;
@@ -2253,6 +2266,11 @@ static BIF_RETTYPE ets_select_trap_1(Process *p, Eterm a1)
 
 BIF_RETTYPE ets_select_1(BIF_ALIST_1)
 {
+    return ets_select1(BIF_P, BIF_ARG_1);
+}
+
+static BIF_RETTYPE ets_select1(Process *p, Eterm arg1)
+{
     BIF_RETTYPE result;
     DbTable* tb;
     int cret;
@@ -2266,28 +2284,27 @@ BIF_RETTYPE ets_select_1(BIF_ALIST_1)
      * Make sure that the table exists.
      */
 
-    if (!is_tuple(BIF_ARG_1)) {
-	if (BIF_ARG_1 == am_EOT) {
+    if (!is_tuple(arg1)) {
+	if (arg1 == am_EOT) {
 	    BIF_RET(am_EOT);
 	}
-	BIF_ERROR(BIF_P, BADARG);
+	BIF_ERROR(p, BADARG);
     }
-    tptr = tuple_val(BIF_ARG_1);
+    tptr = tuple_val(arg1);
     if (arityval(*tptr) < 1 ||
-	(tb = db_get_table(BIF_P, tptr[1], DB_READ, LCK_READ)) == NULL) {
-	BIF_ERROR(BIF_P, BADARG);
+	(tb = db_get_table(p, tptr[1], DB_READ, LCK_READ)) == NULL) {
+	BIF_ERROR(p, BADARG);
     }
 
-    safety = ITERATION_SAFETY(BIF_P,tb);
+    safety = ITERATION_SAFETY(p,tb);
     if (safety == ITER_UNSAFE) {
 	local_fix_table(tb);
     }
 
-    cret = tb->common.meth->db_select_continue(BIF_P,tb,
-					       BIF_ARG_1, &ret);
+    cret = tb->common.meth->db_select_continue(p,tb, arg1, &ret);
 
-    if (DID_TRAP(BIF_P,ret) && safety != ITER_SAFE) {
-	fix_table_locked(BIF_P, tb);
+    if (DID_TRAP(p,ret) && safety != ITER_SAFE) {
+	fix_table_locked(p, tb);
     }
     if (safety == ITER_UNSAFE) {
 	local_unfix_table(tb);
@@ -2299,20 +2316,26 @@ BIF_RETTYPE ets_select_1(BIF_ALIST_1)
 	ERTS_BIF_PREP_RET(result, ret);
 	break;
     case DB_ERROR_SYSRES:
-	ERTS_BIF_PREP_ERROR(result, BIF_P, SYSTEM_LIMIT);
+	ERTS_BIF_PREP_ERROR(result, p, SYSTEM_LIMIT);
 	break;
     default:
-	ERTS_BIF_PREP_ERROR(result, BIF_P, BADARG);
+	ERTS_BIF_PREP_ERROR(result, p, BADARG);
 	break;
     }
 
-    erts_match_set_release_result(BIF_P);
+    erts_match_set_release_result(p);
 
     return result;
 }
 
 BIF_RETTYPE ets_select_2(BIF_ALIST_2)
 {
+    return ets_select2(BIF_P, BIF_ARG_1, BIF_ARG_2);
+}
+
+static BIF_RETTYPE
+ets_select2(Process* p, Eterm arg1, Eterm arg2)
+{
     BIF_RETTYPE result;
     DbTable* tb;
     int cret;
@@ -2325,19 +2348,19 @@ BIF_RETTYPE ets_select_2(BIF_ALIST_2)
      * Make sure that the table exists.
      */
 
-    if ((tb = db_get_table(BIF_P, BIF_ARG_1, DB_READ, LCK_READ)) == NULL) {
-	BIF_ERROR(BIF_P, BADARG);
+    if ((tb = db_get_table(p, arg1, DB_READ, LCK_READ)) == NULL) {
+	BIF_ERROR(p, BADARG);
     }
-    safety = ITERATION_SAFETY(BIF_P,tb);
+    safety = ITERATION_SAFETY(p,tb);
     if (safety == ITER_UNSAFE) {
 	local_fix_table(tb);
     }
 
-    cret = tb->common.meth->db_select(BIF_P, tb, BIF_ARG_2,
+    cret = tb->common.meth->db_select(p, tb, arg2,
 				      0, &ret);
 
-    if (DID_TRAP(BIF_P,ret) && safety != ITER_SAFE) {
-	fix_table_locked(BIF_P, tb);
+    if (DID_TRAP(p,ret) && safety != ITER_SAFE) {
+	fix_table_locked(p, tb);
     }    
     if (safety == ITER_UNSAFE) {
 	local_unfix_table(tb);
@@ -2349,21 +2372,23 @@ BIF_RETTYPE ets_select_2(BIF_ALIST_2)
 	ERTS_BIF_PREP_RET(result, ret);
 	break;
     case DB_ERROR_SYSRES:
-	ERTS_BIF_PREP_ERROR(result, BIF_P, SYSTEM_LIMIT);
+	ERTS_BIF_PREP_ERROR(result, p, SYSTEM_LIMIT);
 	break;
     default:
-	ERTS_BIF_PREP_ERROR(result, BIF_P, BADARG);
+	ERTS_BIF_PREP_ERROR(result, p, BADARG);
 	break;
     }
 
-    erts_match_set_release_result(BIF_P);
+    erts_match_set_release_result(p);
 
     return result;
 }
 
 /* We get here instead of in the real BIF when trapping */
-static BIF_RETTYPE ets_select_count_1(Process *p, Eterm a1)
+static BIF_RETTYPE ets_select_count_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm a1 = BIF_ARG_1;
     BIF_RETTYPE result;
     DbTable* tb;
     int cret;
@@ -2504,7 +2529,7 @@ BIF_RETTYPE ets_select_reverse_3(BIF_ALIST_3)
 
 BIF_RETTYPE ets_select_reverse_1(BIF_ALIST_1)
 {
-    return ets_select_1(BIF_P, BIF_ARG_1);
+    return ets_select1(BIF_P, BIF_ARG_1);
 }
 
 BIF_RETTYPE ets_select_reverse_2(BIF_ALIST_2)
@@ -2558,7 +2583,7 @@ BIF_RETTYPE ets_select_reverse_2(BIF_ALIST_2)
 */
 BIF_RETTYPE ets_match_object_1(BIF_ALIST_1)
 {
-    return ets_select_1(BIF_P, BIF_ARG_1);
+    return ets_select1(BIF_P, BIF_ARG_1);
 }
 
 BIF_RETTYPE ets_match_object_2(BIF_ALIST_2)
@@ -2574,7 +2599,7 @@ BIF_RETTYPE ets_match_object_2(BIF_ALIST_2)
     ms = TUPLE3(hp, BIF_ARG_2, NIL, ms); 
     hp += 4;
     ms = CONS(hp, ms, NIL);
-    res = ets_select_2(BIF_P, BIF_ARG_1, ms);
+    res = ets_select2(BIF_P, BIF_ARG_1, ms);
     UnUseTmpHeap(8,BIF_P);
     return res;
 }
@@ -2592,7 +2617,7 @@ BIF_RETTYPE ets_match_object_3(BIF_ALIST_3)
     ms = TUPLE3(hp, BIF_ARG_2, NIL, ms); 
     hp += 4;
     ms = CONS(hp, ms, NIL);
-    res = ets_select_3(BIF_P, BIF_ARG_1, ms, BIF_ARG_3);
+    res = ets_select3(BIF_P, BIF_ARG_1, ms, BIF_ARG_3);
     UnUseTmpHeap(8,BIF_P);
     return res;
 }
@@ -3530,8 +3555,10 @@ static void free_heir_data(DbTable* tb)
     #endif
 }
 
-static BIF_RETTYPE ets_delete_trap(Process *p, Eterm cont)
+static BIF_RETTYPE ets_delete_trap(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm cont = BIF_ARG_1;
     int trap;
     Eterm* ptr = big_val(cont);
     DbTable *tb = *((DbTable **) (UWord) (ptr + 1));
diff --git a/erts/emulator/beam/erl_db_tree.c b/erts/emulator/beam/erl_db_tree.c
index c6f0d80e32..312050b931 100644
--- a/erts/emulator/beam/erl_db_tree.c
+++ b/erts/emulator/beam/erl_db_tree.c
@@ -344,8 +344,8 @@ static int do_partly_bound_can_match_lesser(Eterm a, Eterm b,
 					    int *done);
 static int do_partly_bound_can_match_greater(Eterm a, Eterm b, 
 					     int *done);
-static BIF_RETTYPE ets_select_reverse(Process *p, Eterm a1, 
-				      Eterm a2, Eterm a3);
+static BIF_RETTYPE ets_select_reverse(BIF_ALIST_3);
+
 
 /* Method interface functions */
 static int db_first_tree(Process *p, DbTable *tbl, 
@@ -844,8 +844,12 @@ static int db_slot_tree(Process *p, DbTable *tbl,
 
 
 
-static BIF_RETTYPE ets_select_reverse(Process *p, Eterm a1, Eterm a2, Eterm a3)
+static BIF_RETTYPE ets_select_reverse(BIF_ALIST_3)
 {
+    Process *p = BIF_P;
+    Eterm a1 = BIF_ARG_1;
+    Eterm a2 = BIF_ARG_2;
+    Eterm a3 = BIF_ARG_3;
     Eterm list;
     Eterm result;
     Eterm* hp;
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index 42079a7cee..35e53aaa0e 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -495,7 +495,7 @@ static erts_smp_atomic32_t trace_control_word;
 
 /* This needs to be here, before the bif table... */
 
-static Eterm db_set_trace_control_word_fake_1(Process *p, Eterm val);
+static Eterm db_set_trace_control_word_fake_1(BIF_ALIST_1);
 
 /*
 ** The table of callable bif's, i e guard bif's and 
@@ -908,14 +908,18 @@ static void db_free_tmp_uncompressed(DbTerm* obj);
 /*
 ** Pseudo BIF:s to be callable from the PAM VM.
 */
-
-BIF_RETTYPE db_get_trace_control_word_0(Process *p) 
+BIF_RETTYPE db_get_trace_control_word(Process *p)
 {
     Uint32 tcw = (Uint32) erts_smp_atomic32_read_acqb(&trace_control_word);
     BIF_RET(erts_make_integer((Uint) tcw, p));
 }
 
-BIF_RETTYPE db_set_trace_control_word_1(Process *p, Eterm new) 
+BIF_RETTYPE db_get_trace_control_word_0(BIF_ALIST_0)
+{
+    BIF_RET(db_get_trace_control_word(BIF_P));
+}
+
+BIF_RETTYPE db_set_trace_control_word(Process *p, Eterm new)
 {
     Uint val;
     Uint32 old_tcw;
@@ -923,20 +927,27 @@ BIF_RETTYPE db_set_trace_control_word_1(Process *p, Eterm new)
 	BIF_ERROR(p, BADARG);
     if (val != ((Uint32)val))
 	BIF_ERROR(p, BADARG);
-    
+
     old_tcw = (Uint32) erts_smp_atomic32_xchg_relb(&trace_control_word,
 						   (erts_aint32_t) val);
     BIF_RET(erts_make_integer((Uint) old_tcw, p));
 }
 
-static Eterm db_set_trace_control_word_fake_1(Process *p, Eterm new) 
+BIF_RETTYPE db_set_trace_control_word_1(BIF_ALIST_1)
+{
+    BIF_RET(db_set_trace_control_word(BIF_P, BIF_ARG_1));
+}
+
+static Eterm db_set_trace_control_word_fake_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm new = BIF_ARG_1;
     Uint val;
     if (!term_to_Uint(new, &val))
 	BIF_ERROR(p, BADARG);
     if (val != ((Uint32)val))
 	BIF_ERROR(p, BADARG);
-    BIF_RET(db_get_trace_control_word_0(p));
+    BIF_RET(db_get_trace_control_word(p));
 }
 
 /*
@@ -1704,6 +1715,7 @@ Eterm db_prog_match(Process *c_p, Binary *bprog,
     Process *current_scheduled;
     ErtsSchedulerData *esdp;
     Eterm (*bif)(Process*, ...);
+    Eterm bif_args[3];
     int fail_label;
     int atomic_trace;
 #if HALFWORD_HEAP
@@ -1957,7 +1969,7 @@ restart:
 	    break;
 	case matchCall0:
 	    bif = (Eterm (*)(Process*, ...)) *pc++;
-	    t = (*bif)(build_proc);
+	    t = (*bif)(build_proc, bif_args);
 	    if (is_non_value(t)) {
 		if (do_catch)
 		    t = FAIL_TERM;
@@ -1968,7 +1980,7 @@ restart:
 	    break;
 	case matchCall1:
 	    bif = (Eterm (*)(Process*, ...)) *pc++;
-	    t = (*bif)(build_proc, esp[-1]);
+	    t = (*bif)(build_proc, esp-1);
 	    if (is_non_value(t)) {
 		if (do_catch)
 		    t = FAIL_TERM;
@@ -1979,7 +1991,9 @@ restart:
 	    break;
 	case matchCall2:
 	    bif = (Eterm (*)(Process*, ...)) *pc++;
-	    t = (*bif)(build_proc, esp[-1], esp[-2]);
+	    bif_args[0] = esp[-1];
+	    bif_args[1] = esp[-2];
+	    t = (*bif)(build_proc, bif_args);
 	    if (is_non_value(t)) {
 		if (do_catch)
 		    t = FAIL_TERM;
@@ -1991,7 +2005,10 @@ restart:
 	    break;
 	case matchCall3:
 	    bif = (Eterm (*)(Process*, ...)) *pc++;
-	    t = (*bif)(build_proc, esp[-1], esp[-2], esp[-3]);
+	    bif_args[0] = esp[-1];
+	    bif_args[1] = esp[-2];
+	    bif_args[2] = esp[-3];
+	    t = (*bif)(build_proc, bif_args);
 	    if (is_non_value(t)) {
 		if (do_catch)
 		    t = FAIL_TERM;
@@ -4975,7 +4992,7 @@ static Eterm match_spec_test(Process *p, Eterm against, Eterm spec, int trace)
 
 static Eterm seq_trace_fake(Process *p, Eterm arg1)
 {
-    Eterm result = seq_trace_info_1(p,arg1);
+    Eterm result = erl_seq_trace_info(p, arg1);
     if (is_tuple(result) && *tuple_val(result) == 2) {
 	return (tuple_val(result))[2];
     }
diff --git a/erts/emulator/beam/erl_db_util.h b/erts/emulator/beam/erl_db_util.h
index bb1751d309..6a96e174e1 100644
--- a/erts/emulator/beam/erl_db_util.h
+++ b/erts/emulator/beam/erl_db_util.h
@@ -326,8 +326,10 @@ ERTS_GLB_INLINE int db_eq(DbTableCommon* tb, Eterm a, DbTerm* b)
 (T)->common.owner == (P)->id)
 
 /* Function prototypes */
-Eterm db_get_trace_control_word_0(Process *p);
-Eterm db_set_trace_control_word_1(Process *p, Eterm val);
+BIF_RETTYPE db_get_trace_control_word(Process* p);
+BIF_RETTYPE db_set_trace_control_word(Process* p, Eterm tcw);
+BIF_RETTYPE db_get_trace_control_word_0(BIF_ALIST_0);
+BIF_RETTYPE db_set_trace_control_word_1(BIF_ALIST_1);
 
 void db_initialize_util(void);
 Eterm db_getkey(int keypos, Eterm obj);
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index e3445bcdc5..36615f913d 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -315,7 +315,12 @@ erts_gc_after_bif_call(Process* p, Eterm result, Eterm* regs, Uint arity)
 
     if (is_non_value(result)) {
 	if (p->freason == TRAP) {
-	    cost = erts_garbage_collect(p, 0, p->def_arg_reg, p->arity);
+	  #if HIPE
+	    if (regs == NULL) {
+		regs = ERTS_PROC_GET_SCHDATA(p)->x_reg_array;
+	    }
+	  #endif
+	    cost = erts_garbage_collect(p, 0, regs, p->arity);
 	} else {
 	    cost = erts_garbage_collect(p, 0, regs, arity);
 	}
diff --git a/erts/emulator/beam/erl_monitors.c b/erts/emulator/beam/erl_monitors.c
index 47597f302b..1a84950120 100644
--- a/erts/emulator/beam/erl_monitors.c
+++ b/erts/emulator/beam/erl_monitors.c
@@ -948,8 +948,10 @@ static void erts_dump_links(ErtsLink *root, int indent)
     erts_destroy_tmp_dsbuf(dsbufp);
 }
 
-Eterm erts_debug_dump_monitors_1(Process *p, Eterm pid)
+Eterm erts_debug_dump_monitors_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm pid = BIF_ARG_1;
     Process *rp;
     DistEntry *dep;
     rp = erts_pid2proc(p, ERTS_PROC_LOCK_MAIN, pid, ERTS_PROC_LOCK_LINK);
@@ -976,8 +978,10 @@ Eterm erts_debug_dump_monitors_1(Process *p, Eterm pid)
     }
 }
 
-Eterm erts_debug_dump_links_1(Process *p, Eterm pid)
+Eterm erts_debug_dump_links_1(BIF_ALIST_1)
 {
+    Process *p = BIF_P;
+    Eterm pid = BIF_ARG_1;
     Process *rp;
     DistEntry *dep;
     if (is_internal_port(pid)) {
diff --git a/erts/emulator/beam/erl_term.h b/erts/emulator/beam/erl_term.h
index 1d75fa313c..bc20b2d798 100644
--- a/erts/emulator/beam/erl_term.h
+++ b/erts/emulator/beam/erl_term.h
@@ -331,7 +331,13 @@ _ET_DECLARE_CHECKED(Uint,thing_subtag,Eterm)
  * we now use a non-zero bit-pattern in debug mode.
  */
 #if ET_DEBUG
-#define THE_NON_VALUE	_make_header(0,_TAG_HEADER_FLOAT)
+# ifdef HIPE
+   /* A very large (or negative) value as work-around for ugly hipe-bifs
+      that return untagged integers (eg hipe_bs_put_utf8) */
+#  define THE_NON_VALUE	_make_header((Uint)~0,_TAG_HEADER_FLOAT)
+# else
+#  define THE_NON_VALUE	_make_header(0,_TAG_HEADER_FLOAT)
+# endif
 #else
 #define THE_NON_VALUE	(0)
 #endif
diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index 8833137112..39509f363f 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -2092,8 +2092,7 @@ void save_calls(Process *p, Export *e)
  * entries instead of the original BIF functions.
  */
 Eterm
-erts_bif_trace(int bif_index, Process* p, 
-	       Eterm arg1, Eterm arg2, Eterm arg3, BeamInstr *I)
+erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 {
     Eterm result;
     int meta = !!(erts_bif_trace_flags[bif_index] & BIF_TRACE_AS_META);
@@ -2107,10 +2106,10 @@ erts_bif_trace(int bif_index, Process* p,
 	 * no tracing will occur. Doing the whole else branch will 
 	 * also do nothing, only slower.
 	 */
-	Eterm (*func)(Process*, Eterm, Eterm, Eterm, BeamInstr*) = bif_table[bif_index].f;
-	result = func(p, arg1, arg2, arg3, I);
+	Eterm (*func)(Process*, Eterm*, BeamInstr*) = bif_table[bif_index].f;
+	result = func(p, args, I);
     } else {
-	Eterm (*func)(Process*, Eterm, Eterm, Eterm, BeamInstr*);
+	Eterm (*func)(Process*, Eterm*, BeamInstr*);
 	Export* ep = bif_export[bif_index];
 	Uint32 flags = 0, flags_meta = 0;
 	int global = !!(erts_bif_trace_flags[bif_index] & BIF_TRACE_AS_GLOBAL);
@@ -2122,8 +2121,6 @@ erts_bif_trace(int bif_index, Process* p,
 					       * export entry */
 	BeamInstr *cp = p->cp;
 	
-	Eterm args[3] = {arg1, arg2, arg3};
-	
 	/* 
 	 * Make continuation pointer OK, it is not during direct BIF calls,
 	 * but it is correct during apply of bif.
@@ -2155,7 +2152,7 @@ erts_bif_trace(int bif_index, Process* p,
 	
 	func = bif_table[bif_index].f;
 
-	result = func(p, arg1, arg2, arg3, I);
+	result = func(p, args, I);
 	
 	if (applying && (flags & MATCH_SET_RETURN_TO_TRACE)) {
 	    BeamInstr i_return_trace      = beam_return_trace[0];
diff --git a/erts/emulator/beam/erl_unicode.c b/erts/emulator/beam/erl_unicode.c
index bd5f3cc4c1..fca785a4de 100644
--- a/erts/emulator/beam/erl_unicode.c
+++ b/erts/emulator/beam/erl_unicode.c
@@ -47,7 +47,7 @@ typedef struct _restart_context {
 
 static Uint max_loop_limit;
 
-static BIF_RETTYPE utf8_to_list(BIF_ALIST_1);
+static BIF_RETTYPE utf8_to_list(Process *p, Eterm arg1);
 static BIF_RETTYPE finalize_list_to_list(Process *p, 
 					 byte *bytes,
 					 Eterm rest,
@@ -1828,13 +1828,13 @@ static BIF_RETTYPE characters_to_list_trap_4(BIF_ALIST_1)
  * Instead of building an utf8 buffer, we analyze the binary given and use that.
  */
 
-static BIF_RETTYPE utf8_to_list(BIF_ALIST_1)
+static BIF_RETTYPE utf8_to_list(Process* p, Eterm arg)
 {
-    if (!is_binary(BIF_ARG_1) || aligned_binary_size(BIF_ARG_1) < 0) {
-	BIF_ERROR(BIF_P,BADARG);
+    if (!is_binary(arg) || aligned_binary_size(arg) < 0) {
+	BIF_ERROR(p, BADARG);
     }
-    return do_bif_utf8_to_list(BIF_P, BIF_ARG_1, 0U, 0U, 0U, 
-			       ERTS_UTF8_ANALYZE_MORE,NIL);
+    return do_bif_utf8_to_list(p, arg, 0U, 0U, 0U,
+			       ERTS_UTF8_ANALYZE_MORE, NIL);
 }
 
 
diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c
index 6953e7fe7d..80ce4b969c 100644
--- a/erts/emulator/beam/external.c
+++ b/erts/emulator/beam/external.c
@@ -988,16 +988,16 @@ BIF_RETTYPE erts_debug_dist_ext_to_term_2(BIF_ALIST_2)
 }
 
 
-Eterm
-term_to_binary_1(Process* p, Eterm Term)
+BIF_RETTYPE term_to_binary_1(BIF_ALIST_1)
 {
-    return erts_term_to_binary(p, Term, 0, TERM_TO_BINARY_DFLAGS);
+    return erts_term_to_binary(BIF_P, BIF_ARG_1, 0, TERM_TO_BINARY_DFLAGS);
 }
 
-
-Eterm
-term_to_binary_2(Process* p, Eterm Term, Eterm Flags)
+BIF_RETTYPE term_to_binary_2(BIF_ALIST_2)
 {
+    Process* p = BIF_P;
+    Eterm Term = BIF_ARG_1;
+    Eterm Flags = BIF_ARG_2;
     int level = 0;
     Uint flags = TERM_TO_BINARY_DFLAGS;
 
@@ -1256,8 +1256,11 @@ BIF_RETTYPE binary_to_term_2(BIF_ALIST_2)
 }
 
 Eterm
-external_size_1(Process* p, Eterm Term)
+external_size_1(BIF_ALIST_1)
 {
+    Process* p = BIF_P;
+    Eterm Term = BIF_ARG_1;
+
     Uint size = erts_encode_ext_size(Term);
     if (IS_USMALL(0, size)) {
 	BIF_RET(make_small(size));
@@ -1268,13 +1271,13 @@ external_size_1(Process* p, Eterm Term)
 }
 
 Eterm
-external_size_2(Process* p, Eterm Term, Eterm Flags)
+external_size_2(BIF_ALIST_2)
 {
     Uint size;
     Uint flags = TERM_TO_BINARY_DFLAGS;
 
-    while (is_list(Flags)) {
-        Eterm arg = CAR(list_val(Flags));
+    while (is_list(BIF_ARG_2)) {
+        Eterm arg = CAR(list_val(BIF_ARG_2));
         Eterm* tp;
 
         if (is_tuple(arg) && *(tp = tuple_val(arg)) == make_arityval(2)) {
@@ -1293,19 +1296,19 @@ external_size_2(Process* p, Eterm Term, Eterm Flags)
             }
         } else {
         error:
-            BIF_ERROR(p, BADARG);
+            BIF_ERROR(BIF_P, BADARG);
         }
-        Flags = CDR(list_val(Flags));
+        BIF_ARG_2 = CDR(list_val(BIF_ARG_2));
     }
-    if (is_not_nil(Flags)) {
+    if (is_not_nil(BIF_ARG_2)) {
         goto error;
     }
 
-    size = erts_encode_ext_size_2(Term, flags);
+    size = erts_encode_ext_size_2(BIF_ARG_1, flags);
     if (IS_USMALL(0, size)) {
         BIF_RET(make_small(size));
     } else {
-        Eterm* hp = HAlloc(p, BIG_UINT_HEAP_SIZE);
+        Eterm* hp = HAlloc(BIF_P, BIG_UINT_HEAP_SIZE);
         BIF_RET(uint_to_big(size, hp));
     }
 }
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index a967aa0e3e..1005a7b941 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -852,10 +852,16 @@ void erts_queue_monitor_message(Process *,
 				Eterm,
 				Eterm);
 void erts_init_bif(void);
+Eterm erl_send(Process *p, Eterm to, Eterm msg);
+
+/* erl_bif_op.c */
+
+Eterm erl_is_function(Process* p, Eterm arg1, Eterm arg2);
 
 /* erl_bif_port.c */
 
 /* erl_bif_trace.c */
+Eterm erl_seq_trace_info(Process *p, Eterm arg1);
 void erts_system_monitor_clear(Process *c_p);
 void erts_system_profile_clear(Process *c_p);
 
@@ -1641,8 +1647,7 @@ void monitor_generic(Process *p, Eterm type, Eterm spec);
 Uint erts_trace_flag2bit(Eterm flag);
 int erts_trace_flags(Eterm List, 
 		 Uint *pMask, Eterm *pTracer, int *pCpuTimestamp);
-Eterm erts_bif_trace(int bif_index, Process* p, 
-		     Eterm arg1, Eterm arg2, Eterm arg3, BeamInstr *I);
+Eterm erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr *I);
 
 #ifdef ERTS_SMP
 void erts_send_pending_trace_msgs(ErtsSchedulerData *esdp);
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index 34bd5d0653..fc53a88a3a 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -845,11 +845,11 @@ call_ext_only u==3 u$func:erlang:apply/3 => i_apply_only
 # thus there is no need to generate any return instruction.
 #
 
-call_ext_last u==1 Bif=u$bif:erlang:exit/1 D => call_bif1 Bif
-call_ext_last u==1 Bif=u$bif:erlang:throw/1 D => call_bif1 Bif
+call_ext_last u==1 Bif=u$bif:erlang:exit/1 D => call_bif Bif
+call_ext_last u==1 Bif=u$bif:erlang:throw/1 D => call_bif Bif
 
-call_ext_only u==1 Bif=u$bif:erlang:exit/1 => call_bif1 Bif
-call_ext_only u==1 Bif=u$bif:erlang:throw/1 => call_bif1 Bif
+call_ext_only u==1 Bif=u$bif:erlang:exit/1 => call_bif Bif
+call_ext_only u==1 Bif=u$bif:erlang:throw/1 => call_bif Bif
 
 #
 # The error/1 and error/2 BIFs never execute the instruction following them;
@@ -859,13 +859,13 @@ call_ext_only u==1 Bif=u$bif:erlang:throw/1 => call_bif1 Bif
 # the continuation pointer on the stack.
 #
 
-call_ext_last u==1 Bif=u$bif:erlang:error/1 D => call_bif1 Bif
-call_ext_last u==2 Bif=u$bif:erlang:error/2 D => call_bif2 Bif
+call_ext_last u==1 Bif=u$bif:erlang:error/1 D => call_bif Bif
+call_ext_last u==2 Bif=u$bif:erlang:error/2 D => call_bif Bif
 
 call_ext_only Ar=u==1 Bif=u$bif:erlang:error/1 => \
-  allocate u Ar | call_bif1 Bif
+  allocate u Ar | call_bif Bif
 call_ext_only Ar=u==2 Bif=u$bif:erlang:error/2 => \
-  allocate u Ar | call_bif2 Bif
+  allocate u Ar | call_bif Bif
 
 #
 # The yield/0 BIF is an instruction
@@ -889,24 +889,12 @@ call_ext_only u==3 u$func:erlang:hibernate/3 => i_hibernate
 # To make trapping and stack backtraces work correctly, we make sure that
 # the continuation pointer is always stored on the stack.
 
-call_ext u==0 Bif=u$is_bif => call_bif0 Bif
-call_ext u==1 Bif=u$is_bif => call_bif1 Bif
-call_ext u==2 Bif=u$is_bif => call_bif2 Bif
-call_ext u==3 Bif=$is_bif => call_bif3 Bif
+call_ext u Bif=u$is_bif => call_bif Bif
 
-call_ext_last u==0 Bif=u$is_bif D => call_bif0 Bif | deallocate_return D
-call_ext_last u==1 Bif=u$is_bif D => call_bif1 Bif | deallocate_return D
-call_ext_last u==2 Bif=u$is_bif D => call_bif2 Bif | deallocate_return D
-call_ext_last u==3 Bif=u$is_bif D => call_bif3 Bif | deallocate_return D
+call_ext_last u Bif=u$is_bif D => call_bif Bif | deallocate_return D
 
-call_ext_only Ar=u==0 Bif=u$is_bif => \
-  allocate u Ar | call_bif0 Bif | deallocate_return u
-call_ext_only Ar=u==1 Bif=u$is_bif => \
-  allocate u Ar | call_bif1 Bif | deallocate_return u
-call_ext_only Ar=u==2 Bif=u$is_bif => \
-  allocate u Ar | call_bif2 Bif | deallocate_return u
-call_ext_only Ar=u==3 Bif=u$is_bif => \
-  allocate u Ar | call_bif3 Bif | deallocate_return u
+call_ext_only Ar=u Bif=u$is_bif => \
+  allocate u Ar | call_bif Bif | deallocate_return u
 
 #
 # Any remaining calls are calls to Erlang functions, not BIFs.
@@ -933,10 +921,7 @@ i_apply_fun_only
 
 i_hibernate
 
-call_bif0 e
-call_bif1 e
-call_bif2 e
-call_bif3 e
+call_bif e
 
 #
 # Calls to non-building and guard BIFs.