Use magic refs for code loading state

10 files changed, 45 insertions, 46 deletions

diff --git a/bootstrap/lib/kernel/ebin/code.beam b/bootstrap/lib/kernel/ebin/code.beam
index fae275107e..0ebd85824c 100644
--- a/bootstrap/lib/kernel/ebin/code.beam
+++ b/bootstrap/lib/kernel/ebin/code.beam
diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index a5891a0ec2..4ba8c2a669 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -156,11 +156,13 @@ BIF_RETTYPE code_make_stub_module_3(BIF_ALIST_3)
     Module* modp;
     Eterm res, mod;
 
-    if (!ERTS_TERM_IS_MAGIC_BINARY(BIF_ARG_1) ||
-	is_not_atom(mod = erts_module_for_prepared_code
-		    (((ProcBin*)binary_val(BIF_ARG_1))->val))) {
+    if (!is_internal_magic_ref(BIF_ARG_1))
+	BIF_ERROR(BIF_P, BADARG);
+
+    mod = erts_module_for_prepared_code(erts_magic_ref2bin(BIF_ARG_1));
+
+    if (is_not_atom(mod))
 	BIF_ERROR(BIF_P, BADARG);
-    }
 
     if (!erts_try_seize_code_write_permission(BIF_P)) {
 	ERTS_BIF_YIELD3(bif_export[BIF_code_make_stub_module_3],
@@ -229,8 +231,8 @@ prepare_loading_2(BIF_ALIST_2)
 	res = TUPLE2(hp, am_error, reason);
 	BIF_RET(res);
     }
-    hp = HAlloc(BIF_P, PROC_BIN_SIZE);
-    res = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), magic);
+    hp = HAlloc(BIF_P, ERTS_MAGIC_REF_THING_SIZE);
+    res = erts_mk_magic_ref(&hp, &MSO(BIF_P), magic);
     erts_refc_dec(&magic->refc, 1);
     BIF_RET(res);
 }
@@ -239,15 +241,13 @@ BIF_RETTYPE
 has_prepared_code_on_load_1(BIF_ALIST_1)
 {
     Eterm res;
-    ProcBin* pb;
 
-    if (!ERTS_TERM_IS_MAGIC_BINARY(BIF_ARG_1)) {
+    if (!is_internal_magic_ref(BIF_ARG_1)) {
     error:
 	BIF_ERROR(BIF_P, BADARG);
     }
 
-    pb = (ProcBin*) binary_val(BIF_ARG_1);
-    res = erts_has_code_on_load(pb->val);
+    res = erts_has_code_on_load(erts_magic_ref2bin(BIF_ARG_1));
     if (res == NIL) {
 	goto error;
     }
@@ -333,13 +333,11 @@ finish_loading_1(BIF_ALIST_1)
     for (i = 0; i < n; i++) {
 	Eterm* cons = list_val(BIF_ARG_1);
 	Eterm term = CAR(cons);
-	ProcBin* pb;
 
-	if (!ERTS_TERM_IS_MAGIC_BINARY(term)) {
+	if (!is_internal_magic_ref(term)) {
 	    goto badarg;
 	}
-	pb = (ProcBin*) binary_val(term);
-	p[i].code = pb->val;
+	p[i].code = erts_magic_ref2bin(term);
 	p[i].module = erts_module_for_prepared_code(p[i].code);
 	if (p[i].module == NIL) {
 	    goto badarg;
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 9f38dd4c3a..e75e7afd54 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -6322,8 +6322,8 @@ erts_make_stub_module(Process* p, Eterm hipe_magic_bin, Eterm Beam, Eterm Info)
     stp = ERTS_MAGIC_BIN_DATA(magic);
     hipe_code = erts_alloc(ERTS_ALC_T_HIPE, sizeof(*hipe_code));
 
-    if (!ERTS_TERM_IS_MAGIC_BINARY(hipe_magic_bin) ||
-	!(hipe_magic = ((ProcBin*)binary_val(hipe_magic_bin))->val,
+    if (!is_internal_magic_ref(hipe_magic_bin) ||
+	!(hipe_magic = erts_magic_ref2bin(hipe_magic_bin),
 	  hipe_stp = hipe_get_loader_state(hipe_magic)) ||
 	hipe_stp->module == NIL || hipe_stp->text_segment == 0) {
 	goto error;
@@ -6568,8 +6568,8 @@ int erts_commit_hipe_patch_load(Eterm hipe_magic_bin)
     HipeModule *hipe_code;
     Module* modp;
 
-    if (!ERTS_TERM_IS_MAGIC_BINARY(hipe_magic_bin) ||
-	!(hipe_magic = ((ProcBin*)binary_val(hipe_magic_bin))->val,
+    if (!is_internal_magic_ref(hipe_magic_bin) ||
+	!(hipe_magic = erts_magic_ref2bin(hipe_magic_bin),
 	  hipe_stp = hipe_get_loader_state(hipe_magic)) ||
 	hipe_stp->module == NIL || hipe_stp->text_segment == 0) {
 	return 0;
diff --git a/erts/emulator/hipe/hipe_bif0.c b/erts/emulator/hipe/hipe_bif0.c
index 3011860e51..688c82ab7a 100644
--- a/erts/emulator/hipe/hipe_bif0.c
+++ b/erts/emulator/hipe/hipe_bif0.c
@@ -381,12 +381,9 @@ BIF_RETTYPE hipe_bifs_ref_set_2(BIF_ALIST_2)
 
 static HipeLoaderState *get_loader_state(Eterm term)
 {
-    ProcBin *pb;
+    if (!is_internal_magic_ref(term)) return NULL;
 
-    if (!ERTS_TERM_IS_MAGIC_BINARY(term)) return NULL;
-
-    pb = (ProcBin*) binary_val(term);
-    return hipe_get_loader_state(pb->val);
+    return hipe_get_loader_state(erts_magic_ref2bin(term));
 }
 
 
@@ -1982,8 +1979,8 @@ BIF_RETTYPE hipe_bifs_alloc_loader_state_1(BIF_ALIST_1)
     if (!magic)
 	BIF_ERROR(BIF_P, BADARG);
 
-    hp = HAlloc(BIF_P, PROC_BIN_SIZE);
-    res = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), magic);
+    hp = HAlloc(BIF_P, ERTS_MAGIC_REF_THING_SIZE);
+    res = erts_mk_magic_ref(&hp, &MSO(BIF_P), magic);
     erts_refc_dec(&magic->refc, 1);
     BIF_RET(res);
 }
diff --git a/erts/preloaded/ebin/erlang.beam b/erts/preloaded/ebin/erlang.beam
index 0799546c60..7cdf2931a1 100644
--- a/erts/preloaded/ebin/erlang.beam
+++ b/erts/preloaded/ebin/erlang.beam
diff --git a/erts/preloaded/ebin/init.beam b/erts/preloaded/ebin/init.beam
index ffddf2d54d..8123d63a9e 100644
--- a/erts/preloaded/ebin/init.beam
+++ b/erts/preloaded/ebin/init.beam
diff --git a/erts/preloaded/src/erlang.erl b/erts/preloaded/src/erlang.erl
index be7ceb928b..ca181343e3 100644
--- a/erts/preloaded/src/erlang.erl
+++ b/erts/preloaded/src/erlang.erl
@@ -83,6 +83,10 @@
       | 'micro_seconds'
       | 'nano_seconds'.
 
+-opaque prepared_code() :: reference().
+
+-export_type([prepared_code/0]).
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% Native code BIF stubs and their types
 %% (BIF's actually implemented in this module goes last in the file)
@@ -791,9 +795,9 @@ external_size(_Term, _Options) ->
     erlang:nif_error(undefined).
 
 %% finish_loading/2
--spec erlang:finish_loading(PreparedCodeBinaries) -> ok | Error when
-      PreparedCodeBinaries :: [PreparedCodeBinary],
-      PreparedCodeBinary :: binary(),
+-spec erlang:finish_loading(PreparedCodeList) -> ok | Error when
+      PreparedCodeList :: [PreparedCode],
+      PreparedCode :: prepared_code(),
       ModuleList :: [module()],
       Error :: {not_purged,ModuleList} | {on_load,ModuleList}.
 finish_loading(_List) ->
@@ -1030,7 +1034,7 @@ halt(_Status, _Options) ->
 
 %% has_prepared_code_on_load/1
 -spec erlang:has_prepared_code_on_load(PreparedCode) -> boolean() when
-      PreparedCode :: binary().
+      PreparedCode :: prepared_code().
 has_prepared_code_on_load(_PreparedCode) ->
     erlang:nif_error(undefined).
 
@@ -1447,7 +1451,7 @@ timestamp() ->
 -spec erlang:prepare_loading(Module, Code) -> PreparedCode | {error, Reason} when
       Module :: module(),
       Code :: binary(),
-      PreparedCode :: binary(),
+      PreparedCode :: prepared_code(),
       Reason :: bad_file.
 prepare_loading(_Module, _Code) ->
     erlang:nif_error(undefined).
@@ -2007,8 +2011,8 @@ load_module(Mod, Code) ->
     case erlang:prepare_loading(Mod, Code) of
 	{error,_}=Error ->
 	    Error;
-	Bin when erlang:is_binary(Bin) ->
-	    case erlang:finish_loading([Bin]) of
+	Prep when erlang:is_reference(Prep) ->
+	    case erlang:finish_loading([Prep]) of
 		ok ->
 		    {module,Mod};
 		{Error,[Mod]} ->
diff --git a/erts/preloaded/src/init.erl b/erts/preloaded/src/init.erl
index 551ca4ea40..86dc9a2957 100644
--- a/erts/preloaded/src/init.erl
+++ b/erts/preloaded/src/init.erl
@@ -932,15 +932,15 @@ load_rest([], _) ->
 prepare_loading_fun() ->
     fun(Mod, FullName, Beam) ->
 	    case erlang:prepare_loading(Mod, Beam) of
-		Prepared when is_binary(Prepared) ->
+		{error,_}=Error ->
+		    Error;
+		Prepared ->
 		    case erlang:has_prepared_code_on_load(Prepared) of
 			true ->
 			    {ok,{on_load,Beam,FullName}};
 			false ->
 			    {ok,{prepared,Prepared,FullName}}
-		    end;
-		{error,_}=Error ->
-		    Error
+		    end
 	    end
     end.
 
diff --git a/lib/kernel/src/code.erl b/lib/kernel/src/code.erl
index 5a7ca493cc..2a06d0cb15 100644
--- a/lib/kernel/src/code.erl
+++ b/lib/kernel/src/code.erl
@@ -489,13 +489,13 @@ prepare_check_uniq_1([], [_|_]=Errors) ->
     {error,Errors}.
 
 partition_on_load(Prep) ->
-    P = fun({_,{Bin,_,_}}) ->
-		erlang:has_prepared_code_on_load(Bin)
+    P = fun({_,{PC,_,_}}) ->
+		erlang:has_prepared_code_on_load(PC)
 	end,
     lists:partition(P, Prep).
 
 verify_prepared([{M,{Prep,Name,_Native}}|T])
-  when is_atom(M), is_binary(Prep), is_list(Name) ->
+  when is_atom(M), is_list(Name) ->
     try erlang:has_prepared_code_on_load(Prep) of
 	false ->
 	    verify_prepared(T);
@@ -562,10 +562,10 @@ prepare_loading_fun() ->
     GetNative = get_native_fun(),
     fun(Mod, FullName, Beam) ->
 	    case erlang:prepare_loading(Mod, Beam) of
-		Prepared when is_binary(Prepared) ->
-		    {ok,{Prepared,FullName,GetNative(Beam)}};
 		{error,_}=Error ->
-		    Error
+		    Error;
+		Prepared ->
+		    {ok,{Prepared,FullName,GetNative(Beam)}}
 	    end
     end.
 
diff --git a/lib/kernel/test/multi_load_SUITE.erl b/lib/kernel/test/multi_load_SUITE.erl
index 369e25ac64..920839f4f9 100644
--- a/lib/kernel/test/multi_load_SUITE.erl
+++ b/lib/kernel/test/multi_load_SUITE.erl
@@ -144,14 +144,14 @@ prep_magic([H|T]) ->
 prep_magic(Tuple) when is_tuple(Tuple) ->
     L = prep_magic(tuple_to_list(Tuple)),
     list_to_tuple(L);
-prep_magic(Bin) when is_binary(Bin) ->
-    try erlang:has_prepared_code_on_load(Bin) of
+prep_magic(Ref) when is_reference(Ref) ->
+    try erlang:has_prepared_code_on_load(Ref) of
 	false ->
-	    %% Create a different kind of magic binary.
+	    %% Create a different kind of magic ref.
 	    ets:match_spec_compile([{'_',[true],['$_']}])
     catch
 	_:_ ->
-	    Bin
+	    Ref
     end;
 prep_magic(Other) ->
     Other.