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

1 files changed, 74 insertions, 61 deletions

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