erts: Refactor more usage of erts_build_proc_bin

5 files changed, 37 insertions, 127 deletions

diff --git a/erts/emulator/beam/erl_bif_binary.c b/erts/emulator/beam/erl_bif_binary.c
index dcffde5777..7bea1630cb 100644
--- a/erts/emulator/beam/erl_bif_binary.c
+++ b/erts/emulator/beam/erl_bif_binary.c
@@ -2731,28 +2731,21 @@ BIF_RETTYPE binary_copy_trap(BIF_ALIST_2)
 	BIF_TRAP2(&binary_copy_trap_export, BIF_P, BIF_ARG_1, BIF_ARG_2);
     } else {
 	Binary *save;
-	ProcBin* pb;
+        Eterm resbin;
 	Uint target_size = cbs->result->orig_size;
 	while (pos < target_size) {
 	    memcpy(t+pos,cbs->source, size);
 	    pos += size;
 	}
-	save =  cbs->result;
+	save = cbs->result;
 	cbs->result = NULL;
 	cleanup_copy_bin_state(mb); /* now cbs is dead */
-	pb = (ProcBin *) HAlloc(BIF_P, PROC_BIN_SIZE);
-	pb->thing_word = HEADER_PROC_BIN;
-	pb->size = target_size;
-	pb->next = MSO(BIF_P).first;
-	MSO(BIF_P).first = (struct erl_off_heap_header*) pb;
-	pb->val = save;
-	pb->bytes = t;
-	pb->flags = 0;
-
-	OH_OVERHEAD(&(MSO(BIF_P)), target_size / sizeof(Eterm));
-	BUMP_REDS(BIF_P,(pos - opos) / BINARY_COPY_LOOP_FACTOR);
-
-	BIF_RET(make_binary(pb));
+
+        resbin = erts_build_proc_bin(&MSO(BIF_P),
+                                     HAlloc(BIF_P, PROC_BIN_SIZE),
+                                     save);
+        BUMP_REDS(BIF_P,(pos - opos) / BINARY_COPY_LOOP_FACTOR);
+	BIF_RET(resbin);
     }
 }
 
diff --git a/erts/emulator/beam/erl_io_queue.c b/erts/emulator/beam/erl_io_queue.c
index 190ba6bbb9..f678889f81 100644
--- a/erts/emulator/beam/erl_io_queue.c
+++ b/erts/emulator/beam/erl_io_queue.c
@@ -817,24 +817,15 @@ static Eterm iol2v_make_sub_bin(iol2v_state_t *state, Eterm bin_term,
 }
 
 static Eterm iol2v_promote_acc(iol2v_state_t *state) {
-    ProcBin *pb;
-
-    state->acc = erts_bin_realloc(state->acc, state->acc_size);
-
-    pb = (ProcBin*)HAlloc(state->process, PROC_BIN_SIZE);
-    pb->thing_word = HEADER_PROC_BIN;
-    pb->size = state->acc_size;
-    pb->val = state->acc;
-    pb->bytes = (byte*)(state->acc)->orig_bytes;
-    pb->flags = 0;
-    pb->next = MSO(state->process).first;
-    OH_OVERHEAD(&(MSO(state->process)), pb->size / sizeof(Eterm));
-    MSO(state->process).first = (struct erl_off_heap_header*)pb;
+    Eterm bin;
 
+    bin = erts_build_proc_bin(&MSO(state->process),
+                              HAlloc(state->process, PROC_BIN_SIZE),
+                              erts_bin_realloc(state->acc, state->acc_size));
     state->acc_size = 0;
     state->acc = NULL;
 
-    return make_binary(pb);
+    return bin;
 }
 
 /* Destructively enqueues a term to the result list, saving us the hassle of
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index f67b67325d..682df1021c 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1343,21 +1343,11 @@ Eterm enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)
     }
     else if (bin->ref_bin != NULL) {
 	Binary* bptr = bin->ref_bin;
-	ProcBin* pb;
 	Eterm bin_term;
 	
-	/* !! Copy-paste from new_binary() !! */
-	pb = (ProcBin *) alloc_heap(env, PROC_BIN_SIZE);
-	pb->thing_word = HEADER_PROC_BIN;
-	pb->size = bptr->orig_size;
-	pb->next = MSO(env->proc).first;
-	MSO(env->proc).first = (struct erl_off_heap_header*) pb;
-	pb->val = bptr;
-	pb->bytes = (byte*) bptr->orig_bytes;
-	pb->flags = 0;
-	
-	OH_OVERHEAD(&(MSO(env->proc)), pb->size / sizeof(Eterm));
-	bin_term = make_binary(pb);	
+        bin_term = erts_build_proc_bin(&MSO(env->proc),
+                                       alloc_heap(env, PROC_BIN_SIZE),
+                                       bptr);
 	if (erts_refc_read(&bptr->intern.refc, 1) == 1) {
 	    /* Total ownership transfer */
 	    bin->ref_bin = NULL;
diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c
index c0a3838d42..050c47c1c3 100644
--- a/erts/emulator/beam/external.c
+++ b/erts/emulator/beam/external.c
@@ -1949,23 +1949,14 @@ static Eterm erts_term_to_binary_int(Process* p, Eterm Term, int level, Uint fla
 		level = context->s.ec.level;
 		BUMP_REDS(p, (initial_reds - reds) / TERM_TO_BINARY_LOOP_FACTOR);
 		if (level == 0 || real_size < 6) { /* We are done */
-		    ProcBin* pb;
 		return_normal:
 		    context->s.ec.result_bin = NULL;
 		    context->alive = 0;
-		    pb = (ProcBin *) HAlloc(p, PROC_BIN_SIZE);
-		    pb->thing_word = HEADER_PROC_BIN;
-		    pb->size = real_size;
-		    pb->next = MSO(p).first;
-		    MSO(p).first = (struct erl_off_heap_header*)pb;
-		    pb->val = result_bin;
-		    pb->bytes = (byte*) result_bin->orig_bytes;
-		    pb->flags = 0;
-		    OH_OVERHEAD(&(MSO(p)), pb->size / sizeof(Eterm));
 		    if (context_b && erts_refc_read(&context_b->intern.refc,0) == 0) {
 			erts_bin_free(context_b);
 		    }
-		    return make_binary(pb);
+		    return erts_build_proc_bin(&MSO(p), HAlloc(p, PROC_BIN_SIZE),
+                                               result_bin);
 		}
 		/* Continue with compression... */
 		/* To make absolutely sure that zlib does not barf on a reallocated context, 
@@ -2022,16 +2013,7 @@ static Eterm erts_term_to_binary_int(Process* p, Eterm Term, int level, Uint fla
 			result_bin = erts_bin_realloc(context->s.cc.destination_bin,
 						      context->s.cc.dest_len+6);
 			context->s.cc.destination_bin = NULL;
-			pb = (ProcBin *) HAlloc(p, PROC_BIN_SIZE);
-			pb->thing_word = HEADER_PROC_BIN;
-			pb->size = context->s.cc.dest_len+6;
-			pb->next = MSO(p).first;
-			MSO(p).first = (struct erl_off_heap_header*)pb;
-			pb->val = result_bin;
 			ASSERT(erts_refc_read(&result_bin->intern.refc, 1));
-			pb->bytes = (byte*) result_bin->orig_bytes;
-			pb->flags = 0;
-			OH_OVERHEAD(&(MSO(p)), pb->size / sizeof(Eterm));
 			erts_bin_free(context->s.cc.result_bin);
 			context->s.cc.result_bin = NULL;
 			context->alive = 0;
@@ -2039,7 +2021,9 @@ static Eterm erts_term_to_binary_int(Process* p, Eterm Term, int level, Uint fla
 			if (context_b && erts_refc_read(&context_b->intern.refc,0) == 0) {
 			    erts_bin_free(context_b);
 			}
-			return make_binary(pb);
+			return erts_build_proc_bin(&MSO(p),
+						   HAlloc(p, PROC_BIN_SIZE),
+                                                   result_bin);
 		    }
 		default: /* Compression error, revert to uncompressed binary (still in 
 			    context) */
@@ -3535,18 +3519,9 @@ dec_term_atom_common:
 		    *objp = make_binary(hb);
 		} else {
 		    Binary* dbin = erts_bin_nrml_alloc(n);
-		    ProcBin* pb;
-		    pb = (ProcBin *) hp;
+
+		    *objp = erts_build_proc_bin(factory->off_heap, hp, dbin);
 		    hp += PROC_BIN_SIZE;
-		    pb->thing_word = HEADER_PROC_BIN;
-		    pb->size = n;
-		    pb->next = factory->off_heap->first;
-		    factory->off_heap->first = (struct erl_off_heap_header*)pb;
-		    OH_OVERHEAD(factory->off_heap, pb->size / sizeof(Eterm));
-		    pb->val = dbin;
-		    pb->bytes = (byte*) dbin->orig_bytes;
-		    pb->flags = 0;
-		    *objp = make_binary(pb);
                     if (ctx) {
                         int n_limit = reds * B2T_MEMCPY_FACTOR;
                         if (n > n_limit) {
@@ -3586,18 +3561,9 @@ dec_term_atom_common:
                     ep += n;
 		} else {
 		    Binary* dbin = erts_bin_nrml_alloc(n);
-		    ProcBin* pb;
+		    Uint n_copy = n;
 
-		    pb = (ProcBin *) hp;
-		    pb->thing_word = HEADER_PROC_BIN;
-		    pb->size = n;
-		    pb->next = factory->off_heap->first;
-		    factory->off_heap->first = (struct erl_off_heap_header*)pb;
-		    OH_OVERHEAD(factory->off_heap, pb->size / sizeof(Eterm));
-		    pb->val = dbin;
-		    pb->bytes = (byte*) dbin->orig_bytes;
-		    pb->flags = 0;
-		    bin = make_binary(pb);
+		    bin = erts_build_proc_bin(factory->off_heap, hp, dbin);
 		    hp += PROC_BIN_SIZE;
                     if (ctx) {
                         int n_limit = reds * B2T_MEMCPY_FACTOR;
@@ -3605,15 +3571,15 @@ dec_term_atom_common:
                             ctx->state = B2TDecodeBinary;
                             ctx->u.dc.remaining_n = n - n_limit;
                             ctx->u.dc.remaining_bytes = dbin->orig_bytes + n_limit;
-                            n = n_limit;
+                            n_copy = n_limit;
                             reds = 0;
                         }
-                        else
+                        else {
                             reds -= n / B2T_MEMCPY_FACTOR;
+			}
                     }
-                    sys_memcpy(dbin->orig_bytes, ep, n);
-                    ep += n;
-                    n = pb->size;
+                    sys_memcpy(dbin->orig_bytes, ep, n_copy);
+                    ep += n_copy;
                 }
 
 		if (bitsize == 8 || n == 0) {
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 3a5ddde5f4..101b8c3db3 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -3434,24 +3434,11 @@ static void deliver_read_message(Port* prt, erts_aint32_t state, Eterm to,
     if ((state & ERTS_PORT_SFLG_BINARY_IO) == 0) {
 	listp = buf_to_intlist(&hp, buf, len, listp);
     } else if (buf != NULL) {
-	ProcBin* pb;
-	Binary* bptr;
-
-	bptr = erts_bin_nrml_alloc(len);
+	Binary* bptr = erts_bin_nrml_alloc(len);
 	sys_memcpy(bptr->orig_bytes, buf, len);
 
-	pb = (ProcBin *) hp;
-	pb->thing_word = HEADER_PROC_BIN;
-	pb->size = len;
-	pb->next = ohp->first;
-	ohp->first = (struct erl_off_heap_header*)pb;
-	pb->val = bptr;
-	pb->bytes = (byte*) bptr->orig_bytes;
-	pb->flags = 0;
+        listp = erts_build_proc_bin(ohp, hp, bptr);
 	hp += PROC_BIN_SIZE;
-
-	OH_OVERHEAD(ohp, pb->size / sizeof(Eterm));
-	listp = make_binary(pb);
     }
 
     /* Prepend the header */
@@ -4257,17 +4244,9 @@ write_port_control_result(int control_flags,
 	else {
 	    dbin = (ErlDrvBinary *) resp_bufp;
 	    if (dbin->orig_size > ERL_ONHEAP_BIN_LIMIT) {
-		ProcBin* pb = (ProcBin *) *hpp;
+                res = erts_build_proc_bin(ohp, *hpp, ErlDrvBinary2Binary(dbin));
 		*hpp += PROC_BIN_SIZE;
-		pb->thing_word = HEADER_PROC_BIN;
-		pb->size = dbin->orig_size;
-		pb->next = ohp->first;
-		ohp->first = (struct erl_off_heap_header *) pb;
-		pb->val = ErlDrvBinary2Binary(dbin);
-		pb->bytes = (byte*) dbin->orig_bytes;
-		pb->flags = 0;
-		OH_OVERHEAD(ohp, dbin->orig_size / sizeof(Eterm));
-		return make_binary(pb);
+                return res;
 	    }
 	    resp_bufp = dbin->orig_bytes;
 	    resp_size = dbin->orig_size;
@@ -6040,21 +6019,12 @@ driver_deliver_term(Port *prt, Eterm to, ErlDrvTermData* data, int len)
 		mess = make_binary(hbp);
 	    }
 	    else {
-		ProcBin* pbp;
+		Eterm* hp;
 		Binary* bp = erts_bin_nrml_alloc(size);
 		ASSERT(bufp);
 		sys_memcpy((void *) bp->orig_bytes, (void *) bufp, size);
-		pbp = (ProcBin *) erts_produce_heap(&factory,
-						    PROC_BIN_SIZE, HEAP_EXTRA);
-		pbp->thing_word = HEADER_PROC_BIN;
-		pbp->size = size;
-		pbp->next = factory.off_heap->first;
-		factory.off_heap->first = (struct erl_off_heap_header*)pbp;
-		pbp->val = bp;
-		pbp->bytes = (byte*) bp->orig_bytes;
-		pbp->flags = 0;
-		OH_OVERHEAD(factory.off_heap, pbp->size / sizeof(Eterm));
-		mess = make_binary(pbp);
+                hp = erts_produce_heap(&factory, PROC_BIN_SIZE, HEAP_EXTRA);
+                mess = erts_build_proc_bin(factory.off_heap, hp, bp);
 	    }
 	    ptr += 2;
 	    break;