OTP-8555 Send message from NIF

New NIF features:

Send messages from a NIF, or from thread created by NIF, to any local
process (enif_send)

Store terms between NIF calls (enif_alloc_env, enif_make_copy)

Create binary terms with user defined memory management
(enif_make_resource_binary)

19 files changed, 636 insertions, 281 deletions

diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 5cb1481a3a..857cb177c8 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -258,12 +258,10 @@ print_process_info(int to, void *to_arg, Process *p)
     }
 
     {
-       long s = 0;
        int frags = 0;
        ErlHeapFragment *m = p->mbuf;
        while (m != NULL) {
 	   frags++;
-	   s += m->size;
 	   m = m->next;
        }
        erts_print(to, to_arg, "Number of heap fragments: %d\n", frags);
diff --git a/erts/emulator/beam/copy.c b/erts/emulator/beam/copy.c
index 0a5050b1fe..521a1b1788 100644
--- a/erts/emulator/beam/copy.c
+++ b/erts/emulator/beam/copy.c
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 1996-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 1996-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
  * compliance with the License. You should have received a copy of the
  * Erlang Public License along with this software. If not, it can be
  * retrieved online at http://www.erlang.org/.
- * 
+ *
  * Software distributed under the License is distributed on an "AS IS"
  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  * the License for the specific language governing rights and limitations
  * under the License.
- * 
+ *
  * %CopyrightEnd%
  */
 
@@ -37,6 +37,8 @@ MA_STACK_DECLARE(dst);
 MA_STACK_DECLARE(offset);
 #endif
 
+static void move_one_frag(Eterm** hpp, Eterm* src, Uint src_sz, ErlOffHeap*);
+
 void
 init_copy(void)
 {
@@ -86,7 +88,7 @@ size_object(Eterm obj)
 	    obj = *ptr++;
 	    if (!IS_CONST(obj)) {
 		ESTACK_PUSH(s, obj);
-	    }
+	    }	    
 	    obj = *ptr;
 	    break;
 	case TAG_PRIMARY_BOXED:
@@ -99,7 +101,7 @@ size_object(Eterm obj)
 		    arity = header_arity(hdr);
 		    sum += arity + 1;
 		    if (arity == 0) { /* Empty tuple -- unusual. */
-			goto size_common;
+			goto pop_next;
 		    }
 		    while (arity-- > 1) {
 			obj = *++ptr;
@@ -115,7 +117,6 @@ size_object(Eterm obj)
 			ErlFunThing* funp = (ErlFunThing *) bptr;
 			unsigned eterms = 1 /* creator */ + funp->num_free;
 			unsigned sz = thing_arityval(hdr);
-
 			sum += 1 /* header */ + sz + eterms;
 			bptr += 1 /* header */ + sz;
 			while (eterms-- > 1) {
@@ -151,7 +152,7 @@ size_object(Eterm obj)
 			} else {
 			    sum += heap_bin_size(binary_size(obj)+extra_bytes);
 			}
-			goto size_common;
+			goto pop_next;
 		    }
 		    break;
 		case BIN_MATCHSTATE_SUBTAG:
@@ -159,18 +160,12 @@ size_object(Eterm obj)
 			     "size_object: matchstate term not allowed");
 		default:
 		    sum += thing_arityval(hdr) + 1;
-		    /* Fall through */
-		size_common:
-		    if (ESTACK_ISEMPTY(s)) {
-			DESTROY_ESTACK(s);
-			return sum;
-		    }
-		    obj = ESTACK_POP(s);
-		    break;
+		    goto pop_next;
 		}
 	    }
 	    break;
 	case TAG_PRIMARY_IMMED1:
+	pop_next:
 	    if (ESTACK_ISEMPTY(s)) {
 		DESTROY_ESTACK(s);
 		return sum;
@@ -979,3 +974,104 @@ copy_shallow(Eterm* ptr, Uint sz, Eterm** hpp, ErlOffHeap* off_heap)
     *hpp = hp;
     return make_tuple(ptr + offs); 
 }
+
+/* Move all terms in heap fragments into heap. The terms must be guaranteed to 
+ * be contained within the fragments. The source terms are destructed with
+ * move markers.
+ * Typically used to copy a multi-fragmented message (from NIF).
+ */
+void move_multi_frags(Eterm** hpp, ErlOffHeap* off_heap, ErlHeapFragment* first,
+		      Eterm* refs, unsigned nrefs)
+{
+    ErlHeapFragment* bp;
+    Eterm* hp_start = *hpp;
+    Eterm* hp_end;
+    Eterm* hp;
+    unsigned i;
+
+    for (bp=first; bp!=NULL; bp=bp->next) {
+	move_one_frag(hpp, bp->mem, bp->used_size, off_heap);
+	off_heap->overhead += bp->off_heap.overhead;
+    }
+    hp_end = *hpp;
+    for (hp=hp_start; hp<hp_end; ++hp) {
+	Eterm* ptr;
+	Eterm val;
+	Eterm gval = *hp;
+	switch (primary_tag(gval)) {
+	case TAG_PRIMARY_BOXED:
+	    ptr = boxed_val(gval);
+	    val = *ptr;
+	    if (IS_MOVED_BOXED(val)) {
+		ASSERT(is_boxed(val));
+		*hp = val;
+	    }
+	    break;
+	case TAG_PRIMARY_LIST:
+	    ptr = list_val(gval);
+	    val = *ptr;
+	    if (IS_MOVED_CONS(val)) {
+		*hp = ptr[1];
+	    }
+	    break;
+	case TAG_PRIMARY_HEADER:
+	    if (header_is_thing(gval)) {
+		hp += thing_arityval(gval);
+	    }
+	    break;
+	}
+    }
+    for (i=0; i<nrefs; ++i) {
+	refs[i] = follow_moved(refs[i]);
+    }
+}
+
+static void
+move_one_frag(Eterm** hpp, Eterm* src, Uint src_sz, ErlOffHeap* off_heap)
+{
+    union {
+	Uint *up;
+	ProcBin *pbp;
+	ErlFunThing *efp;
+	ExternalThing *etp;
+    } ohe;
+    Eterm* ptr = src;
+    Eterm* end = ptr + src_sz;
+    Eterm dummy_ref;
+    Eterm* hp = *hpp;
+
+    while (ptr != end) {
+	Eterm val;
+	ASSERT(ptr < end);
+	val = *ptr;
+	ASSERT(val != ERTS_HOLE_MARKER);
+	if (is_header(val)) {
+	    ASSERT(ptr + header_arity(val) < end);
+	    ohe.up = hp;
+	    MOVE_BOXED(ptr, val, hp, &dummy_ref);	    
+	    switch (val & _HEADER_SUBTAG_MASK) {
+	    case REFC_BINARY_SUBTAG:
+		ohe.pbp->next = off_heap->mso;
+		off_heap->mso = ohe.pbp;
+		break;
+	    case FUN_SUBTAG:
+		ohe.efp->next = off_heap->funs;
+		off_heap->funs = ohe.efp;
+		break;
+	    case EXTERNAL_PID_SUBTAG:
+	    case EXTERNAL_PORT_SUBTAG:
+	    case EXTERNAL_REF_SUBTAG:
+		ohe.etp->next = off_heap->externals;
+		off_heap->externals = ohe.etp;
+		break;
+	    }
+	}
+	else { /* must be a cons cell */
+	    ASSERT(ptr+1 < end);
+	    MOVE_CONS(ptr, val, hp, &dummy_ref);
+	    ptr += 2;
+	}
+    }
+    *hpp = hp;
+}
+
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index de60ca49fa..70d0e91a2c 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -1140,9 +1140,9 @@ process_info_aux(Process *BIF_P,
 			}
 			else {
 			    /* Make our copy of the message */
-			    ASSERT(size_object(msg) == hfp->size);
+			    ASSERT(size_object(msg) == hfp->used_size);
 			    msg = copy_struct(msg,
-					      hfp->size,
+					      hfp->used_size,
 					      &hp,
 					      &MSO(BIF_P));
 			}
@@ -2715,7 +2715,7 @@ BIF_RETTYPE port_info_2(BIF_ALIST_2)
 	erts_doforall_links(prt->nlinks, &one_link_size, &size);
 
 	for (bp = prt->bp; bp; bp = bp->next)
-	    size += sizeof(ErlHeapFragment) + (bp->size - 1)*sizeof(Eterm);
+	    size += sizeof(ErlHeapFragment) + (bp->alloc_size - 1)*sizeof(Eterm);
 
 	if (prt->linebuf)
 	    size += sizeof(LineBuf) + prt->linebuf->ovsiz;
diff --git a/erts/emulator/beam/erl_bif_port.c b/erts/emulator/beam/erl_bif_port.c
index 9b56ddd4f8..378c5e73fd 100644
--- a/erts/emulator/beam/erl_bif_port.c
+++ b/erts/emulator/beam/erl_bif_port.c
@@ -579,8 +579,8 @@ BIF_RETTYPE port_get_data_1(BIF_ALIST_1)
     if (prt->bp == NULL) {	/* MUST be CONST! */
 	res = prt->data;
     } else {
-	Eterm* hp = HAlloc(BIF_P, prt->bp->size);
-	res = copy_struct(prt->data, prt->bp->size, &hp, &MSO(BIF_P));
+	Eterm* hp = HAlloc(BIF_P, prt->bp->used_size);
+	res = copy_struct(prt->data, prt->bp->used_size, &hp, &MSO(BIF_P));
     }
     erts_smp_port_unlock(prt);
     BIF_RET(res);
diff --git a/erts/emulator/beam/erl_bif_timer.c b/erts/emulator/beam/erl_bif_timer.c
index eb40c75110..4ae2f6ebf4 100644
--- a/erts/emulator/beam/erl_bif_timer.c
+++ b/erts/emulator/beam/erl_bif_timer.c
@@ -357,7 +357,7 @@ bif_timer_timeout(ErtsBifTimer* btm)
 						 rp,
 						 &rp_locks);
 		} else {
-		    Eterm old_size = bp->size;
+		    Eterm old_size = bp->used_size;
 		    bp = erts_resize_message_buffer(bp, old_size + wrap_size,
 						    &message, 1);
 		    hp = &bp->mem[0] + old_size;
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index fd7de98ac9..93a47eb76f 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -1547,10 +1547,9 @@ restart:
      */  
     context.save = NULL;
 error: /* Here is were we land when compilation failed. */
-    while (context.save != NULL) {
-	ErlHeapFragment *ll = context.save->next;
+    if (context.save != NULL) {
 	free_message_buffer(context.save);
-	context.save = ll;
+	context.save = NULL;
     }
     DMC_FREE(stack);
     DMC_FREE(text);
@@ -1567,15 +1566,11 @@ error: /* Here is were we land when compilation failed. */
 void erts_db_match_prog_destructor(Binary *bprog)
 {
     MatchProg *prog;
-    ErlHeapFragment *tmp, *ll;
     if (bprog == NULL)
 	return;
     prog = Binary2MatchProg(bprog);
-    tmp = prog->term_save; 
-    while (tmp != NULL) {
-	ll = tmp->next;
-	free_message_buffer(tmp);
-	tmp = ll;
+    if (prog->term_save != NULL) {
+	free_message_buffer(prog->term_save); 
     }
     if (prog->saved_program_buf != NULL)
 	free_message_buffer(prog->saved_program_buf);
@@ -4125,7 +4120,7 @@ static int match_compact(ErlHeapFragment *expr, DMCErrInfo *err_info)
     DMC_INIT_STACK(heap);
 
     p = expr->mem;
-    i = expr->size;
+    i = expr->used_size;
     while (i--) {
 	if (is_thing(*p)) {
 	    a = thing_arityval(*p);
@@ -4154,7 +4149,7 @@ static int match_compact(ErlHeapFragment *expr, DMCErrInfo *err_info)
     }
 
     p = expr->mem;
-    i = expr->size;
+    i = expr->used_size;
     while (i--) {
 	if (is_thing(*p)) {
 	    a = thing_arityval(*p);
diff --git a/erts/emulator/beam/erl_debug.c b/erts/emulator/beam/erl_debug.c
index 58d3f92f56..d7d6fcf0a2 100644
--- a/erts/emulator/beam/erl_debug.c
+++ b/erts/emulator/beam/erl_debug.c
@@ -261,7 +261,7 @@ static int verify_eterm(Process *p,Eterm element)
             return 1;
 
         for (mbuf = p->mbuf; mbuf; mbuf = mbuf->next) {
-            if (WITHIN(ptr, &mbuf->mem[0], &mbuf->mem[0] + mbuf->size)) {
+            if (WITHIN(ptr, &mbuf->mem[0], &mbuf->mem[0] + mbuf->used_size)) {
                 return 1;
             }
         }
@@ -308,7 +308,7 @@ void erts_check_stack(Process *p)
 	if (IN_HEAP(p, ptr))
 	    continue;
 	for (mbuf = p->mbuf; mbuf; mbuf = mbuf->next)
-	    if (WITHIN(ptr, &mbuf->mem[0], &mbuf->mem[0] + mbuf->size)) {
+	    if (WITHIN(ptr, &mbuf->mem[0], &mbuf->mem[0] + mbuf->used_size)) {
 		in_mbuf = 1;
 		break;
 	    }
@@ -746,7 +746,7 @@ static void print_process_memory(Process *p)
                     PTR_SIZE, "heap fragments",
                     dashes, dashes, dashes, dashes);
     while (bp) {
-	print_untagged_memory(bp->mem,bp->mem + bp->size);
+	print_untagged_memory(bp->mem,bp->mem + bp->used_size);
         bp = bp->next;
     }
 }
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 9ed566e66e..a19e090f1e 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -667,7 +667,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals, Uint lit_size)
 	    case TAG_PRIMARY_BOXED:
 		ptr = boxed_val(gval);
 		val = *ptr;
-                if (IS_MOVED(val)) {
+                if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
                     *g_ptr++ = val;
 		} else if (in_area(ptr, area, area_size)) {
@@ -679,7 +679,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals, Uint lit_size)
 	    case TAG_PRIMARY_LIST:
                 ptr = list_val(gval);
                 val = *ptr;
-                if (is_non_value(val)) { /* Moved */
+                if (IS_MOVED_CONS(val)) { /* Moved */
                     *g_ptr++ = ptr[1];
 		} else if (in_area(ptr, area, area_size)) {
                     MOVE_CONS(ptr,val,old_htop,g_ptr++);
@@ -913,7 +913,7 @@ do_minor(Process *p, int new_sz, Eterm* objv, int nobj)
 	    case TAG_PRIMARY_BOXED: {
 		ptr = boxed_val(gval);
                 val = *ptr;
-                if (IS_MOVED(val)) {
+                if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
                     *g_ptr++ = val;
                 } else if (in_area(ptr, heap, mature_size)) {
@@ -929,7 +929,7 @@ do_minor(Process *p, int new_sz, Eterm* objv, int nobj)
 	    case TAG_PRIMARY_LIST: {
                 ptr = list_val(gval);
                 val = *ptr;
-                if (is_non_value(val)) { /* Moved */
+                if (IS_MOVED_CONS(val)) { /* Moved */
                     *g_ptr++ = ptr[1];
                 } else if (in_area(ptr, heap, mature_size)) {
                     MOVE_CONS(ptr,val,old_htop,g_ptr++);
@@ -972,7 +972,7 @@ do_minor(Process *p, int new_sz, Eterm* objv, int nobj)
 	    case TAG_PRIMARY_BOXED: {
 		ptr = boxed_val(gval);
 		val = *ptr;
-		if (IS_MOVED(val)) {
+		if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
 		    *n_hp++ = val;
 		} else if (in_area(ptr, heap, mature_size)) {
@@ -987,7 +987,7 @@ do_minor(Process *p, int new_sz, Eterm* objv, int nobj)
 	    case TAG_PRIMARY_LIST: {
 		ptr = list_val(gval);
 		val = *ptr;
-		if (is_non_value(val)) {
+		if (IS_MOVED_CONS(val)) {
 		    *n_hp++ = ptr[1];
 		} else if (in_area(ptr, heap, mature_size)) {
 		    MOVE_CONS(ptr,val,old_htop,n_hp++);
@@ -1008,7 +1008,7 @@ do_minor(Process *p, int new_sz, Eterm* objv, int nobj)
 			Eterm* origptr = &(mb->orig);
 			ptr = boxed_val(*origptr);
 			val = *ptr;
-			if (IS_MOVED(val)) {
+			if (IS_MOVED_BOXED(val)) {
 			    *origptr = val;
 			    mb->base = binary_bytes(val);
 			} else if (in_area(ptr, heap, mature_size)) {
@@ -1161,7 +1161,7 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 	    case TAG_PRIMARY_BOXED: {
 		ptr = boxed_val(gval);
 		val = *ptr;
-		if (IS_MOVED(val)) {
+		if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
 		    *g_ptr++ = val;
 		} else if (in_area(ptr, src, src_size) || in_area(ptr, oh, oh_size)) {
@@ -1175,7 +1175,7 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 	    case TAG_PRIMARY_LIST: {
 		ptr = list_val(gval);
 		val = *ptr;
-		if (is_non_value(val)) {
+		if (IS_MOVED_CONS(val)) {
 		    *g_ptr++ = ptr[1];
 		} else if (in_area(ptr, src, src_size) || in_area(ptr, oh, oh_size)) {
 		    MOVE_CONS(ptr,val,n_htop,g_ptr++);
@@ -1216,7 +1216,7 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 	    case TAG_PRIMARY_BOXED: {
 		ptr = boxed_val(gval);
 		val = *ptr;
-		if (IS_MOVED(val)) {
+		if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
 		    *n_hp++ = val;
 		} else if (in_area(ptr, src, src_size) || in_area(ptr, oh, oh_size)) {
@@ -1229,7 +1229,7 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 	    case TAG_PRIMARY_LIST: {
 		ptr = list_val(gval);
 		val = *ptr;
-		if (is_non_value(val)) {
+		if (IS_MOVED_CONS(val)) {
 		    *n_hp++ = ptr[1];
 		} else if (in_area(ptr, src, src_size) || in_area(ptr, oh, oh_size)) {
 		    MOVE_CONS(ptr,val,n_htop,n_hp++);
@@ -1249,7 +1249,7 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 			origptr = &(mb->orig);
 			ptr = boxed_val(*origptr);
 			val = *ptr;
-			if (IS_MOVED(val)) {
+			if (IS_MOVED_BOXED(val)) {
 			    *origptr = val;
 			    mb->base = binary_bytes(*origptr);
 			} else if (in_area(ptr, src, src_size) ||
@@ -1392,17 +1392,12 @@ combined_message_size(Process* p)
 static void
 remove_message_buffers(Process* p)
 {
-    ErlHeapFragment* bp = MBUF(p);
-
-    MBUF(p) = NULL;
-    MBUF_SIZE(p) = 0;
-    while (bp != NULL) {
-	ErlHeapFragment* next_bp = bp->next;
-	free_message_buffer(bp);
-	bp = next_bp;
-    }
+    if (MBUF(p) != NULL) {
+	free_message_buffer(MBUF(p));
+	MBUF(p) = NULL;
+    }    
+    MBUF_SIZE(p) = 0;    
 }
-
 #ifdef HARDDEBUG
 
 /*
@@ -1433,12 +1428,12 @@ disallow_heap_frag_ref(Process* p, Eterm* n_htop, Eterm* objv, int nobj)
 	case TAG_PRIMARY_BOXED: {
 	    ptr = _unchecked_boxed_val(gval);
 	    val = *ptr;
-	    if (IS_MOVED(val)) {
+	    if (IS_MOVED_BOXED(val)) {
 		ASSERT(is_boxed(val));
 		objv++;
 	    } else {
  		for (qb = mbuf; qb != NULL; qb = qb->next) {
-		    if (in_area(ptr, qb->mem, qb->size*sizeof(Eterm))) {
+		    if (in_area(ptr, qb->mem, qb->alloc_size*sizeof(Eterm))) {
 			abort();
 		    }
 		}
@@ -1450,11 +1445,11 @@ disallow_heap_frag_ref(Process* p, Eterm* n_htop, Eterm* objv, int nobj)
 	case TAG_PRIMARY_LIST: {
 	    ptr = _unchecked_list_val(gval);
 	    val = *ptr;
-	    if (is_non_value(val)) {
+	    if (IS_MOVED_CONS(val)) {
 		objv++;
 	    } else {
 		for (qb = mbuf; qb != NULL; qb = qb->next) {
-		    if (in_area(ptr, qb->mem, qb->size*sizeof(Eterm))) {
+		    if (in_area(ptr, qb->mem, qb->alloc_size*sizeof(Eterm))) {
 			abort();
 		    }
 		}
@@ -1499,7 +1494,7 @@ disallow_heap_frag_ref_in_heap(Process* p)
 	    ptr = _unchecked_boxed_val(val);
 	    if (!in_area(ptr, heap, heap_size)) {
 		for (qb = MBUF(p); qb != NULL; qb = qb->next) {
-		    if (in_area(ptr, qb->mem, qb->size*sizeof(Eterm))) {
+		    if (in_area(ptr, qb->mem, qb->alloc_size*sizeof(Eterm))) {
 			abort();
 		    }
 		}
@@ -1509,7 +1504,7 @@ disallow_heap_frag_ref_in_heap(Process* p)
 	    ptr = _unchecked_list_val(val);
 	    if (!in_area(ptr, heap, heap_size)) {
 		for (qb = MBUF(p); qb != NULL; qb = qb->next) {
-		    if (in_area(ptr, qb->mem, qb->size*sizeof(Eterm))) {
+		    if (in_area(ptr, qb->mem, qb->alloc_size*sizeof(Eterm))) {
 			abort();
 		    }
 		}
@@ -1557,7 +1552,7 @@ disallow_heap_frag_ref_in_old_heap(Process* p)
 		    abort();
 		}
 		for (qb = MBUF(p); qb != NULL; qb = qb->next) {
-		    if (in_area(ptr, qb->mem, qb->size*sizeof(Eterm))) {
+		    if (in_area(ptr, qb->mem, qb->alloc_size*sizeof(Eterm))) {
 			abort();
 		    }
 		}
@@ -1570,7 +1565,7 @@ disallow_heap_frag_ref_in_old_heap(Process* p)
 		    abort();
 		}
 		for (qb = MBUF(p); qb != NULL; qb = qb->next) {
-		    if (in_area(ptr, qb->mem, qb->size*sizeof(Eterm))) {
+		    if (in_area(ptr, qb->mem, qb->alloc_size*sizeof(Eterm))) {
 			abort();
 		    }
 		}
@@ -1610,7 +1605,7 @@ sweep_rootset(Rootset* rootset, Eterm* htop, char* src, Uint src_size)
 	    case TAG_PRIMARY_BOXED: {
 		ptr = boxed_val(gval);
                 val = *ptr;
-                if (IS_MOVED(val)) {
+                if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
                     *g_ptr++ = val;
                 } else if (in_area(ptr, src, src_size)) {
@@ -1623,7 +1618,7 @@ sweep_rootset(Rootset* rootset, Eterm* htop, char* src, Uint src_size)
 	    case TAG_PRIMARY_LIST: {
                 ptr = list_val(gval);
                 val = *ptr;
-                if (is_non_value(val)) { /* Moved */
+                if (IS_MOVED_CONS(val)) {
                     *g_ptr++ = ptr[1];
                 } else if (in_area(ptr, src, src_size)) {
                     MOVE_CONS(ptr,val,htop,g_ptr++);
@@ -1657,7 +1652,7 @@ sweep_one_area(Eterm* n_hp, Eterm* n_htop, char* src, Uint src_size)
 	case TAG_PRIMARY_BOXED: {
 	    ptr = boxed_val(gval);
 	    val = *ptr;
-	    if (IS_MOVED(val)) {
+	    if (IS_MOVED_BOXED(val)) {
 		ASSERT(is_boxed(val));
 		*n_hp++ = val;
 	    } else if (in_area(ptr, src, src_size)) {
@@ -1670,7 +1665,7 @@ sweep_one_area(Eterm* n_hp, Eterm* n_htop, char* src, Uint src_size)
 	case TAG_PRIMARY_LIST: {
 	    ptr = list_val(gval);
 	    val = *ptr;
-	    if (is_non_value(val)) {
+	    if (IS_MOVED_CONS(val)) {
 		*n_hp++ = ptr[1];
 	    } else if (in_area(ptr, src, src_size)) {
 		MOVE_CONS(ptr,val,n_htop,n_hp++);
@@ -1690,7 +1685,7 @@ sweep_one_area(Eterm* n_hp, Eterm* n_htop, char* src, Uint src_size)
 		    origptr = &(mb->orig);
 		    ptr = boxed_val(*origptr);
 		    val = *ptr;
-		    if (IS_MOVED(val)) {
+		    if (IS_MOVED_BOXED(val)) {
 			*origptr = val;
 			mb->base = binary_bytes(*origptr);
 		    } else if (in_area(ptr, src, src_size)) {
@@ -1722,7 +1717,7 @@ sweep_one_heap(Eterm* heap_ptr, Eterm* heap_end, Eterm* htop, char* src, Uint sr
 	case TAG_PRIMARY_BOXED: {
 	    ptr = boxed_val(gval);
 	    val = *ptr;
-	    if (IS_MOVED(val)) {
+	    if (IS_MOVED_BOXED(val)) {
 		ASSERT(is_boxed(val));
 		*heap_ptr++ = val;
 	    } else if (in_area(ptr, src, src_size)) {
@@ -1735,7 +1730,7 @@ sweep_one_heap(Eterm* heap_ptr, Eterm* heap_end, Eterm* htop, char* src, Uint sr
 	case TAG_PRIMARY_LIST: {
 	    ptr = list_val(gval);
 	    val = *ptr;
-	    if (is_non_value(val)) {
+	    if (IS_MOVED_CONS(val)) {
 		*heap_ptr++ = ptr[1];
 	    } else if (in_area(ptr, src, src_size)) {
 		MOVE_CONS(ptr,val,htop,heap_ptr++);
@@ -1830,28 +1825,6 @@ collect_heap_frags(Process* p, Eterm* n_hstart, Eterm* n_htop,
     return n_htop;
 }
 
-#ifdef DEBUG
-static Eterm follow_moved(Eterm term)
-{
-    Eterm* ptr;
-    switch (primary_tag(term)) {
-    case TAG_PRIMARY_IMMED1:
-	break;
-    case TAG_PRIMARY_BOXED:
-	ptr = boxed_val(term);
-	if (IS_MOVED(*ptr)) term = *ptr;
-	break;
-    case TAG_PRIMARY_LIST:
-	ptr = list_val(term);
-	if (is_non_value(ptr[0])) term = ptr[1];
-	break;
-    default:
-	abort();
-    }
-    return term;
-}
-#endif
-
 static Uint
 setup_rootset(Process *p, Eterm *objv, int nobj, Rootset *rootset)
 {
@@ -2090,7 +2063,7 @@ sweep_proc_externals(Process *p, int fullsweep)
     while (ptr) {
         Eterm* ppt = (Eterm *) ptr;
 
-        if (IS_MOVED(*ppt)) {        /* Object is alive */
+        if (IS_MOVED_BOXED(*ppt)) {        /* Object is alive */
             ExternalThing* ro = external_thing_ptr(*ppt);
 
             *prev = ro;         /* Patch to moved pos */
@@ -2130,7 +2103,7 @@ sweep_proc_funs(Process *p, int fullsweep)
     while (ptr) {
         Eterm* ppt = (Eterm *) ptr;
 
-        if (IS_MOVED(*ppt)) {        /* Object is alive */
+        if (IS_MOVED_BOXED(*ppt)) {        /* Object is alive */
             ErlFunThing* ro = (ErlFunThing *) fun_val(*ppt);
 
             *prev = ro;         /* Patch to moved pos */
@@ -2244,7 +2217,7 @@ sweep_proc_bins(Process *p, int fullsweep)
     while (ptr) {
         Eterm* ppt = (Eterm *) ptr;
 
-        if (IS_MOVED(*ppt)) {        /* Object is alive */
+        if (IS_MOVED_BOXED(*ppt)) {        /* Object is alive */
 	    bin_vheap += ptr->size / sizeof(Eterm);
             ptr = (ProcBin*) binary_val(*ppt);		   
 	    link_live_proc_bin(&shrink,
@@ -2542,7 +2515,7 @@ within2(Eterm *ptr, Process *p, Eterm *real_htop)
         return 1;
     }
     while (bp != NULL) {
-        if (bp->mem <= ptr && ptr < bp->mem + bp->size) {
+        if (bp->mem <= ptr && ptr < bp->mem + bp->used_size) {
             return 1;
         }
         bp = bp->next;
@@ -2556,7 +2529,7 @@ within2(Eterm *ptr, Process *p, Eterm *real_htop)
 		hfp = erts_dist_ext_trailer(mp->data.dist_ext);
 	    else
 		hfp = NULL;
-	    if (hfp && hfp->mem <= ptr && ptr < hfp->mem + hfp->size)
+	    if (hfp && hfp->mem <= ptr && ptr < hfp->mem + hfp->used_size)
 		return 1;
 	}
         mp = mp->next;
diff --git a/erts/emulator/beam/erl_gc.h b/erts/emulator/beam/erl_gc.h
index af55b6363f..807ef8ae8d 100644
--- a/erts/emulator/beam/erl_gc.h
+++ b/erts/emulator/beam/erl_gc.h
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 2007-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 2007-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
  * compliance with the License. You should have received a copy of the
  * Erlang Public License along with this software. If not, it can be
  * retrieved online at http://www.erlang.org/.
- * 
+ *
  * Software distributed under the License is distributed on an "AS IS"
  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  * the License for the specific language governing rights and limitations
  * under the License.
- * 
+ *
  * %CopyrightEnd%
  */
 
@@ -22,11 +22,12 @@
 
 /* GC declarations shared by beam/erl_gc.c and hipe/hipe_gc.c */
 
-#ifdef DEBUG
+#if defined(DEBUG) && !ERTS_GLB_INLINE_INCL_FUNC_DEF
 #  define HARDDEBUG 1
 #endif
 
-#define IS_MOVED(x)	(!is_header((x)))
+#define IS_MOVED_BOXED(x)	(!is_header((x)))
+#define IS_MOVED_CONS(x)	(is_non_value((x)))
 
 #define MOVE_CONS(PTR,CAR,HTOP,ORIG)					\
 do {									\
@@ -69,4 +70,28 @@ extern Uint erts_test_long_gc_sleep;
 int within(Eterm *ptr, Process *p);
 #endif
 
+ERTS_GLB_INLINE Eterm follow_moved(Eterm term);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+ERTS_GLB_INLINE Eterm follow_moved(Eterm term)
+{
+    Eterm* ptr;
+    switch (primary_tag(term)) {
+    case TAG_PRIMARY_IMMED1:
+	break;
+    case TAG_PRIMARY_BOXED:
+	ptr = boxed_val(term);
+	if (IS_MOVED_BOXED(*ptr)) term = *ptr;
+	break;
+    case TAG_PRIMARY_LIST:
+	ptr = list_val(term);
+	if (IS_MOVED_CONS(ptr[0])) term = ptr[1];
+	break;
+    default:
+	ASSERT(!"strange tag in follow_moved");
+    }
+    return term;
+}
+#endif
+
 #endif /* __ERL_GC_H__ */
diff --git a/erts/emulator/beam/erl_message.c b/erts/emulator/beam/erl_message.c
index a056fce0c5..b63f3df7df 100644
--- a/erts/emulator/beam/erl_message.c
+++ b/erts/emulator/beam/erl_message.c
@@ -42,6 +42,15 @@ ERTS_SCHED_PREF_QUICK_ALLOC_IMPL(message,
 #undef HARD_DEBUG
 #endif
 
+
+
+
+static ERTS_INLINE int in_heapfrag(const Eterm* ptr, const ErlHeapFragment *bp)
+{
+    return ((unsigned)(ptr - bp->mem) < bp->used_size);
+}
+
+
 void
 init_message(void)
 {
@@ -81,9 +90,12 @@ erts_resize_message_buffer(ErlHeapFragment *bp, Uint size,
 #endif
     ErlHeapFragment* nbp;
 
+    /* ToDo: Make use of 'used_size' to avoid realloc
+	when shrinking just a few words */
+
 #ifdef DEBUG
     {
-	Uint off_sz = size < bp->size ? size : bp->size;
+	Uint off_sz = size < bp->used_size ? size : bp->used_size;
 	for (i = 0; i < brefs_size; i++) {
 	    Eterm *ptr;
 	    if (is_immed(brefs[i]))
@@ -95,12 +107,12 @@ erts_resize_message_buffer(ErlHeapFragment *bp, Uint size,
     }
 #endif
 
-    if (size == bp->size)
+    if (size == bp->used_size)
 	return bp;
 
 #ifdef HARD_DEBUG
     dbg_brefs = erts_alloc(ERTS_ALC_T_UNDEF, sizeof(Eterm *)*brefs_size);
-    dbg_bp = new_message_buffer(bp->size);
+    dbg_bp = new_message_buffer(bp->used_size);
     dbg_hp = dbg_bp->mem;
     dbg_tot_size = 0;
     for (i = 0; i < brefs_size; i++) {
@@ -109,15 +121,15 @@ erts_resize_message_buffer(ErlHeapFragment *bp, Uint size,
 	dbg_brefs[i] = copy_struct(brefs[i], dbg_size, &dbg_hp,
 				   &dbg_bp->off_heap);
     }
-    ASSERT(dbg_tot_size == (size < bp->size ? size : bp->size));
+    ASSERT(dbg_tot_size == (size < bp->used_size ? size : bp->used_size));
 #endif
 
     nbp = (ErlHeapFragment*) ERTS_HEAP_REALLOC(ERTS_ALC_T_HEAP_FRAG,
 					       (void *) bp,
-					       ERTS_HEAP_FRAG_SIZE(bp->size),
+					       ERTS_HEAP_FRAG_SIZE(bp->alloc_size),
 					       ERTS_HEAP_FRAG_SIZE(size));
     if (bp != nbp) {
-	Uint off_sz = size < nbp->size ? size : nbp->size;
+	Uint off_sz = size < nbp->used_size ? size : nbp->used_size;
 	Eterm *sp = &bp->mem[0];
 	Eterm *ep = sp + off_sz;
 	Sint offs = &nbp->mem[0] - sp;
@@ -135,7 +147,7 @@ erts_resize_message_buffer(ErlHeapFragment *bp, Uint size,
 	}
 #endif
     }
-    nbp->size = size;
+    nbp->alloc_size = size;
     nbp->used_size = size;
 
 #ifdef HARD_DEBUG
@@ -168,10 +180,15 @@ erts_cleanup_offheap(ErlOffHeap *offheap)
 void
 free_message_buffer(ErlHeapFragment* bp)
 {
-    erts_cleanup_offheap(&bp->off_heap);
-    ERTS_HEAP_FREE(ERTS_ALC_T_HEAP_FRAG,
-		   (void *) bp,
-		   ERTS_HEAP_FRAG_SIZE(bp->size));
+    ASSERT(bp != NULL);
+    do {
+	ErlHeapFragment* next_bp = bp->next;
+
+	erts_cleanup_offheap(&bp->off_heap);
+	ERTS_HEAP_FREE(ERTS_ALC_T_HEAP_FRAG, (void *) bp,
+		       ERTS_HEAP_FRAG_SIZE(bp->size));	
+	bp = next_bp;
+    }while (bp != NULL);
 }
 
 static ERTS_INLINE void
@@ -181,7 +198,7 @@ link_mbuf_to_proc(Process *proc, ErlHeapFragment *bp)
 	/* Link the message buffer */
 	bp->next = MBUF(proc);
 	MBUF(proc) = bp;
-	MBUF_SIZE(proc) += bp->size;
+	MBUF_SIZE(proc) += bp->used_size;
 	FLAGS(proc) |= F_FORCE_GC;
 
 	/* Move any binaries into the process */
@@ -242,7 +259,7 @@ erts_msg_distext2heap(Process *pp,
 	goto decode_error;
     if (is_not_nil(*tokenp)) {
 	ErlHeapFragment *heap_frag = erts_dist_ext_trailer(dist_extp);
-	tok_sz = heap_frag->size;
+	tok_sz = heap_frag->used_size;
 	sz += tok_sz;
     }
     if (pp)
@@ -283,12 +300,13 @@ erts_msg_distext2heap(Process *pp,
 	erts_cleanup_offheap(&heap_frag->off_heap);
     }
     erts_free_dist_ext_copy(dist_extp);
-    if (*bpp)
+    if (*bpp) {
 	free_message_buffer(*bpp);
+	*bpp = NULL;
+    }    
     else if (hp) {
 	HRelease(pp, hp_end, hp);
     }
-    *bpp = NULL;
     return THE_NON_VALUE;
  }
 
@@ -436,11 +454,10 @@ erts_queue_message(Process* receiver,
     ERL_MESSAGE_TERM(mp) = message;
     ERL_MESSAGE_TOKEN(mp) = seq_trace_token;
     mp->next = NULL;
+    mp->data.heap_frag = bp;
 
 #ifdef ERTS_SMP
     if (*receiver_locks & ERTS_PROC_LOCK_MAIN) {
-	mp->data.heap_frag = bp;
-
 	/*
 	 * We move 'in queue' to 'private queue' and place
 	 * message at the end of 'private queue' in order
@@ -453,11 +470,9 @@ erts_queue_message(Process* receiver,
 	LINK_MESSAGE_PRIVQ(receiver, mp);
     }
     else {
-	mp->data.heap_frag = bp;
 	LINK_MESSAGE(receiver, mp);
     }
 #else
-    mp->data.heap_frag = bp;
     LINK_MESSAGE(receiver, mp);
 #endif
 
@@ -530,32 +545,27 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 #ifdef HARD_DEBUG
     dbg_term_sz = size_object(term);
     dbg_token_sz = size_object(token);
-    ASSERT(bp->size == dbg_term_sz + dbg_token_sz);
-
-    dbg_bp = new_message_buffer(bp->size);
+    /*ASSERT(dbg_term_sz + dbg_token_sz == erts_msg_used_frag_sz(msg));
+      Copied size may be smaller due to removed SubBins's or garbage.
+      Copied size may be larger due to duplicated shared terms.
+    */
+    dbg_bp = new_message_buffer(dbg_term_sz + dbg_token_sz);
     dbg_hp = dbg_bp->mem;
     dbg_term = copy_struct(term, dbg_term_sz, &dbg_hp, &dbg_bp->off_heap);
     dbg_token = copy_struct(token, dbg_token_sz, &dbg_hp, &dbg_bp->off_heap);
     dbg_thp_start = *hpp;
 #endif
 
-    ASSERT(bp);
-    msg->data.attached = NULL;
+    if (bp->next != NULL) {
+	move_multi_frags(hpp, off_heap, bp, msg->m, 2);
+	goto copy_done;
+    }
 
     off_heap->overhead += bp->off_heap.overhead;
-    sz = bp->size;
+    sz = bp->used_size;
 
-#ifdef DEBUG
-    if (is_not_immed(term)) {
-	ASSERT(bp->mem <= ptr_val(term));
-	ASSERT(bp->mem + bp->size > ptr_val(term));
-    }
-
-    if (is_not_immed(token)) {
-	ASSERT(bp->mem <= ptr_val(token));
-	ASSERT(bp->mem + bp->size > ptr_val(token));
-    }
-#endif
+    ASSERT(is_immed(term) || in_heapfrag(ptr_val(term),bp));
+    ASSERT(is_immed(token) || in_heapfrag(ptr_val(token),bp));
 
     fhp = bp->mem;
     hp = *hpp;
@@ -574,8 +584,7 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 	    break;
 	case TAG_PRIMARY_LIST:
 	case TAG_PRIMARY_BOXED:
-	    ASSERT(bp->mem <= ptr_val(val));
-	    ASSERT(bp->mem + bp->size > ptr_val(val));
+	    ASSERT(in_heapfrag(ptr_val(val), bp));
 	    *hp++ = offset_ptr(val, offs);
 	    break;
 	case TAG_PRIMARY_HEADER:
@@ -609,6 +618,7 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 		cpy_sz = header_arity(val);
 
 	    cpy_words:
+		ASSERT(sz >= cpy_sz);
 		sz -= cpy_sz;
 		while (cpy_sz >= 8) {
 		    cpy_sz -= 8;
@@ -676,12 +686,11 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 	}
     }
 
-    ASSERT(bp->size == hp - *hpp);
+    ASSERT(bp->used_size == hp - *hpp);
     *hpp = hp;
 
     if (is_not_immed(token)) {
-	ASSERT(bp->mem <= ptr_val(token));
-	ASSERT(bp->mem + bp->size > ptr_val(token));
+	ASSERT(in_heapfrag(ptr_val(token), bp));
 	ERL_MESSAGE_TOKEN(msg) = offset_ptr(token, offs);
 #ifdef HARD_DEBUG
 	ASSERT(dbg_thp_start <= ptr_val(ERL_MESSAGE_TOKEN(msg)));
@@ -690,8 +699,7 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
     }
 
     if (is_not_immed(term)) {
-	ASSERT(bp->mem <= ptr_val(term));
-	ASSERT(bp->mem + bp->size > ptr_val(term));
+	ASSERT(in_heapfrag(ptr_val(term),bp));
 	ERL_MESSAGE_TERM(msg) = offset_ptr(term, offs);
 #ifdef HARD_DEBUG
 	ASSERT(dbg_thp_start <= ptr_val(ERL_MESSAGE_TERM(msg)));
@@ -699,10 +707,12 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 #endif
     }
 
+copy_done:
 
 #ifdef HARD_DEBUG
     {
 	int i, j;
+	ErlHeapFragment* frag;
 	{
 	    ProcBin *mso = off_heap->mso;
 	    i = j = 0;
@@ -710,10 +720,12 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 		mso = mso->next;
 		i++;
 	    }
-	    mso = bp->off_heap.mso;
-	    while (mso) {
-		mso = mso->next;
-		j++;
+	    for (frag=bp; frag; frag=frag->next) {
+		mso = frag->off_heap.mso;
+		while (mso) {
+		    mso = mso->next;
+		    j++;
+		}
 	    }
 	    ASSERT(i == j);
 	}
@@ -724,10 +736,12 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 		fun = fun->next;
 		i++;
 	    }
-	    fun = bp->off_heap.funs;
-	    while (fun) {
-		fun = fun->next;
-		j++;
+	    for (frag=bp; frag; frag=frag->next) {
+		fun = frag->off_heap.funs;
+		while (fun) {
+		    fun = fun->next;
+		    j++;
+		}
 	    }
 	    ASSERT(i == j);
 	}
@@ -738,10 +752,12 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 		external = external->next;
 		i++;
 	    }
-	    external = bp->off_heap.externals;
-	    while (external) {
-		external = external->next;
-		j++;
+	    for (frag=bp; frag; frag=frag->next) {
+		external = frag->off_heap.externals;
+		while (external) {
+		    external = external->next;
+		    j++;
+		}
 	    }
 	    ASSERT(i == j);
 	}
@@ -755,6 +771,7 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 #endif
     bp->off_heap.externals = NULL;
     free_message_buffer(bp);
+    msg->data.heap_frag = NULL;
 
 #ifdef HARD_DEBUG
     ASSERT(eq(ERL_MESSAGE_TERM(msg), dbg_term));
@@ -764,6 +781,7 @@ erts_move_msg_mbuf_to_heap(Eterm** hpp, ErlOffHeap* off_heap, ErlMessage *msg)
 
 }
 
+
 Uint
 erts_msg_attached_data_size_aux(ErlMessage *msg)
 {
@@ -789,7 +807,7 @@ erts_msg_attached_data_size_aux(ErlMessage *msg)
     if (is_not_nil(msg->m[1])) {
 	ErlHeapFragment *heap_frag;
 	heap_frag = erts_dist_ext_trailer(msg->data.dist_ext);
-	sz += heap_frag->size;
+	sz += heap_frag->used_size;
     }
     return sz;
 }
@@ -805,7 +823,7 @@ erts_move_msg_attached_data_to_heap(Eterm **hpp, ErlOffHeap *ohp, ErlMessage *ms
 	    ErlHeapFragment *heap_frag;
 	    heap_frag = erts_dist_ext_trailer(msg->data.dist_ext);
 	    ERL_MESSAGE_TOKEN(msg) = copy_struct(ERL_MESSAGE_TOKEN(msg),
-						 heap_frag->size,
+						 heap_frag->used_size,
 						 hpp,
 						 ohp);
 	    erts_cleanup_offheap(&heap_frag->off_heap);
@@ -1062,3 +1080,4 @@ erts_deliver_exit_message(Eterm from, Process *to, ErtsProcLocks *to_locksp,
 	erts_queue_message(to, to_locksp, bp, save, NIL);
     }
 }
+
diff --git a/erts/emulator/beam/erl_message.h b/erts/emulator/beam/erl_message.h
index 489dee7b37..f478572ac2 100644
--- a/erts/emulator/beam/erl_message.h
+++ b/erts/emulator/beam/erl_message.h
@@ -49,7 +49,7 @@ typedef struct erl_heap_fragment ErlHeapFragment;
 struct erl_heap_fragment {
     ErlHeapFragment* next;	/* Next heap fragment */
     ErlOffHeap off_heap;	/* Offset heap data. */
-    unsigned size;		/* Size in (half)words of mem */
+    unsigned alloc_size;	/* Size in (half)words of mem */
     unsigned used_size;         /* With terms to be moved to heap by GC */
     Eterm mem[1];		/* Data */
 };
@@ -199,7 +199,7 @@ do {									\
 #define ERTS_INIT_HEAP_FRAG(HEAP_FRAG_P, DATA_WORDS)	\
 do {							\
     (HEAP_FRAG_P)->next = NULL;				\
-    (HEAP_FRAG_P)->size = (DATA_WORDS);			\
+    (HEAP_FRAG_P)->alloc_size = (DATA_WORDS);		\
     (HEAP_FRAG_P)->used_size = (DATA_WORDS);            \
     (HEAP_FRAG_P)->off_heap.mso = NULL;			\
     (HEAP_FRAG_P)->off_heap.funs = NULL;		\
@@ -227,14 +227,25 @@ void erts_move_msg_attached_data_to_heap(Eterm **, ErlOffHeap *, ErlMessage *);
 Eterm erts_msg_distext2heap(Process *, ErtsProcLocks *, ErlHeapFragment **,
 			    Eterm *, ErtsDistExternal *);
 
+ERTS_GLB_INLINE Uint erts_msg_used_frag_sz(const ErlMessage *msg);
 ERTS_GLB_INLINE Uint erts_msg_attached_data_size(ErlMessage *msg);
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
+ERTS_GLB_INLINE Uint erts_msg_used_frag_sz(const ErlMessage *msg)
+{
+    const ErlHeapFragment *bp;
+    Uint sz = 0;
+    for (bp = msg->data.heap_frag; bp!=NULL; bp=bp->next) {
+	sz += bp->used_size;
+    }
+    return sz;
+}
+
 ERTS_GLB_INLINE Uint erts_msg_attached_data_size(ErlMessage *msg)
 {
     ASSERT(msg->data.attached);
     if (is_value(ERL_MESSAGE_TERM(msg)))
-	return msg->data.heap_frag->size;
+	return erts_msg_used_frag_sz(msg);
     else if (msg->data.dist_ext->heap_size < 0)
 	return erts_msg_attached_data_size_aux(msg);
     else {
@@ -242,7 +253,7 @@ ERTS_GLB_INLINE Uint erts_msg_attached_data_size(ErlMessage *msg)
 	if (is_not_nil(ERL_MESSAGE_TOKEN(msg))) {
 	    ErlHeapFragment *heap_frag;
 	    heap_frag = erts_dist_ext_trailer(msg->data.dist_ext);
-	    sz += heap_frag->size;
+	    sz += heap_frag->used_size;
 	}
 	return sz;
     }
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 7095ae03e7..75de00d4c1 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -48,7 +48,7 @@ struct erl_module_nif {
     struct enif_entry_t* entry;
     erts_refc_t rt_cnt;       /* number of resource types */
     erts_refc_t rt_dtor_cnt;  /* number of resource types with destructors */
-    int is_orphan;            /* if erlang module has been purged */
+    Module* mod;           /* Can be NULL if orphan with dtor-resources left */ 
 };
 
 #ifdef DEBUG
@@ -61,6 +61,10 @@ static void add_readonly_check(ErlNifEnv*, unsigned char* ptr, unsigned sz);
 #  define ADD_READONLY_CHECK(ENV,PTR,SIZE) ((void)0)
 #endif
 
+#ifdef DEBUG
+static int is_offheap(const ErlOffHeap* off_heap);
+#endif
+
 
 #define MIN_HEAP_FRAG_SZ 200
 static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need, Eterm* hp);
@@ -84,7 +88,8 @@ static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need, Eterm* hp)
 	HEAP_TOP(env->proc) = env->hp;	
     }
     else {
-	HRelease(env->proc, env->hp_end, env->hp);
+	env->heap_frag->used_size = hp - env->heap_frag->mem;
+	ASSERT(env->heap_frag->used_size <= env->heap_frag->alloc_size);
     }
     frag_sz = need + MIN_HEAP_FRAG_SZ;
     hp = erts_heap_alloc(env->proc, frag_sz);
@@ -143,8 +148,9 @@ void erts_post_nif(ErlNifEnv* env)
     }
     else {
 	ASSERT(env->hp_end != HEAP_LIMIT(env->proc));
-	ASSERT(env->hp_end - env->hp <= env->heap_frag->size);
-	HRelease(env->proc, env->hp_end, env->hp);
+	ASSERT(env->hp_end - env->hp <= env->heap_frag->alloc_size);
+	env->heap_frag->used_size = env->hp - env->heap_frag->mem;
+	ASSERT(env->heap_frag->used_size <= env->heap_frag->alloc_size);
     }
     free_tmp_objs(env);
 }
@@ -158,7 +164,7 @@ static void post_nif_noproc(ErlNifEnv* env)
 
 /* Flush out our cached heap pointers to allow an ordinary HAlloc
 */
-static void enable_halloc(ErlNifEnv* env)
+static void flush_env(ErlNifEnv* env)
 {
     if (env->heap_frag == NULL) {
 	ASSERT(env->hp_end == HEAP_LIMIT(env->proc));
@@ -168,14 +174,15 @@ static void enable_halloc(ErlNifEnv* env)
     }
     else {
 	ASSERT(env->hp_end != HEAP_LIMIT(env->proc));
-	ASSERT(env->hp_end - env->hp <= env->heap_frag->size);
-	HRelease(env->proc, env->hp_end, env->hp);
+	ASSERT(env->hp_end - env->hp <= env->heap_frag->alloc_size);
+	env->heap_frag->used_size = env->hp - env->heap_frag->mem;
+	ASSERT(env->heap_frag->used_size <= env->heap_frag->alloc_size);
     }
 }
 
-/* Restore cached heap pointers
+/* Restore cached heap pointers to allow alloc_heap again.
 */
-static void disable_halloc(ErlNifEnv* env)
+static void cache_env(ErlNifEnv* env)
 {
     if (env->heap_frag == NULL) {
 	ASSERT(env->hp_end == HEAP_LIMIT(env->proc));
@@ -185,34 +192,192 @@ static void disable_halloc(ErlNifEnv* env)
     }
     else {
 	ASSERT(env->hp_end != HEAP_LIMIT(env->proc));
-	ASSERT(env->hp_end - env->hp <= env->heap_frag->size);       
+	ASSERT(env->hp_end - env->hp <= env->heap_frag->alloc_size);       
 	env->heap_frag = MBUF(env->proc);
 	ASSERT(env->heap_frag != NULL);
 	env->hp = env->heap_frag->mem + env->heap_frag->used_size;
-	env->hp_end = env->heap_frag->mem + env->heap_frag->size;
+	env->hp_end = env->heap_frag->mem + env->heap_frag->alloc_size;
     }
 }
-
 void* enif_priv_data(ErlNifEnv* env)
 {
     return env->mod_nif->priv_data;
 }
 
-void* enif_alloc(ErlNifEnv* env, size_t size)
+void* enif_alloc(size_t size)
 {
     return erts_alloc_fnf(ERTS_ALC_T_NIF, (Uint) size);
 }
 
-void* enif_realloc(ErlNifEnv* env, void* ptr, size_t size)
+void* enif_realloc(void* ptr, size_t size)
 {
     return erts_realloc_fnf(ERTS_ALC_T_NIF, ptr, size);
 }
 
-void enif_free(ErlNifEnv* env, void* ptr)
+void enif_free(void* ptr)
 {
     erts_free(ERTS_ALC_T_NIF, ptr);
 }
 
+struct enif_msg_environment_t
+{
+    ErlNifEnv env;
+    Process phony_proc;
+};
+
+ErlNifEnv* enif_alloc_env(void)
+{
+    struct enif_msg_environment_t* msg_env =
+	erts_alloc_fnf(ERTS_ALC_T_NIF, sizeof(struct enif_msg_environment_t));
+    Eterm* phony_heap = (Eterm*) msg_env; /* dummy non-NULL ptr */
+	
+    msg_env->env.hp = phony_heap; 
+    msg_env->env.hp_end = phony_heap;
+    msg_env->env.heap_frag = NULL;
+    msg_env->env.mod_nif = NULL;
+    msg_env->env.tmp_obj_list = (struct enif_tmp_obj_t*) 1; /* invalid non-NULL */
+    msg_env->env.proc = &msg_env->phony_proc;
+    memset(&msg_env->phony_proc, 0, sizeof(Process));
+    HEAP_START(&msg_env->phony_proc) = phony_heap;
+    HEAP_TOP(&msg_env->phony_proc) = phony_heap;
+    HEAP_LIMIT(&msg_env->phony_proc) = phony_heap;
+    HEAP_END(&msg_env->phony_proc) = phony_heap;
+    MBUF(&msg_env->phony_proc) = NULL;
+    msg_env->phony_proc.id = ERTS_INVALID_PID;
+#ifdef FORCE_HEAP_FRAGS
+    msg_env->phony_proc.space_verified = 0;
+    msg_env->phony_proc.space_verified_from = NULL;
+#endif
+    return &msg_env->env;
+}
+void enif_free_env(ErlNifEnv* env)
+{
+    enif_clear_env(env);
+    erts_free(ERTS_ALC_T_NIF, env);
+}
+
+static ERTS_INLINE void clear_offheap(ErlOffHeap* oh)
+{
+    oh->mso = NULL;
+    oh->externals = NULL;
+    oh->funs = NULL;
+    oh->overhead = 0;
+}
+
+void enif_clear_env(ErlNifEnv* env)
+{
+    struct enif_msg_environment_t* menv = (struct enif_msg_environment_t*)env;
+    Process* p = &menv->phony_proc;
+    ASSERT(p == menv->env.proc);
+    ASSERT(p->id == ERTS_INVALID_PID);
+    ASSERT(MBUF(p) == menv->env.heap_frag);
+    if (MBUF(p) != NULL) {
+	erts_cleanup_offheap(&MSO(p));
+	clear_offheap(&MSO(p));
+	free_message_buffer(MBUF(p));
+	MBUF(p) = NULL;
+	menv->env.heap_frag = NULL;
+    }
+    ASSERT(HEAP_TOP(p) == HEAP_END(p));
+    menv->env.hp = menv->env.hp_end = HEAP_TOP(p);
+    
+    ASSERT(!is_offheap(&MSO(p)));
+}
+int enif_send(ErlNifEnv* env, const ErlNifPid* to_pid,
+	      ErlNifEnv* msg_env, ERL_NIF_TERM msg)
+{
+    struct enif_msg_environment_t* menv = (struct enif_msg_environment_t*)msg_env;
+    ErtsProcLocks rp_locks = 0;
+    Process* rp;
+    Process* c_p;
+    ErlHeapFragment* frags;
+#if defined(ERTS_ENABLE_LOCK_CHECK) && defined(ERTS_SMP)
+    ErtsProcLocks rp_had_locks;
+#endif
+    Eterm receiver = to_pid->pid;
+    int flush_me = 0;
+
+    if (env != NULL) {
+	c_p = env->proc;
+	if (receiver == c_p->id) {
+	    rp_locks = ERTS_PROC_LOCK_MAIN;
+	    flush_me = 1;
+	}
+    }
+    else {
+#ifdef ERTS_SMP
+	c_p = NULL;
+#else
+	erl_exit(ERTS_ABORT_EXIT,"enif_send: env==NULL on non-SMP VM");
+#endif
+    }    
+
+#if defined(ERTS_ENABLE_LOCK_CHECK) && defined(ERTS_SMP)
+    rp_had_locks = rp_locks;
+#endif
+    rp = erts_pid2proc_opt(c_p, ERTS_PROC_LOCK_MAIN,
+			   receiver, rp_locks, ERTS_P2P_FLG_SMP_INC_REFC);
+    if (rp == NULL) {
+	ASSERT(env == NULL || receiver != c_p->id);
+	return 0;
+    }
+    flush_env(msg_env);
+    frags = menv->env.heap_frag; 
+    ASSERT(frags == MBUF(&menv->phony_proc));
+    if (frags != NULL) {
+	/* Move all offheap's from phony proc to the first fragment.
+	   Quick and dirty, but erts_move_msg_mbuf_to_heap doesn't care. */
+	ASSERT(!is_offheap(&frags->off_heap));
+	frags->off_heap = MSO(&menv->phony_proc);
+	clear_offheap(&MSO(&menv->phony_proc));
+	menv->env.heap_frag = NULL; 
+	MBUF(&menv->phony_proc) = NULL;
+    }
+    ASSERT(!is_offheap(&MSO(&menv->phony_proc)));
+
+    if (flush_me) {	
+	flush_env(env); /* Needed for ERTS_HOLE_CHECK */ 
+    }
+    erts_queue_message(rp, &rp_locks, frags, msg, am_undefined);
+    if (rp_locks) {	
+	ERTS_SMP_LC_ASSERT(rp_locks == (rp_had_locks | (ERTS_PROC_LOCK_MSGQ | 
+							ERTS_PROC_LOCK_STATUS)));
+	erts_smp_proc_unlock(rp, (ERTS_PROC_LOCK_MSGQ | ERTS_PROC_LOCK_STATUS));
+    }
+    erts_smp_proc_dec_refc(rp);
+    if (flush_me) {
+	cache_env(env);
+    }
+    return 1;
+}
+
+ERL_NIF_TERM enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term)
+{
+    Uint sz;
+    Eterm* hp;
+    sz = size_object(src_term);
+    hp = alloc_heap(dst_env, sz);
+    return copy_struct(src_term, sz, &hp, &MSO(dst_env->proc));
+}
+
+
+#ifdef DEBUG
+static int is_offheap(const ErlOffHeap* oh)
+{
+    return oh->mso != NULL || oh->funs != NULL || oh->externals != NULL;
+}
+#endif
+
+ErlNifPid* enif_self(ErlNifEnv* caller_env, ErlNifPid* pid)
+{
+    pid->pid = caller_env->proc->id;
+    return pid;
+}
+int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid)
+{
+    return is_internal_pid(term) ? (pid->pid=term, 1) : 0;
+}
+
 int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_atom(term);
@@ -324,7 +489,7 @@ int enif_inspect_iolist_as_binary(ErlNifEnv* env, Eterm term, ErlNifBinary* bin)
     return 1;
 }
 
-int enif_alloc_binary(ErlNifEnv* env, unsigned size, ErlNifBinary* bin)
+int enif_alloc_binary(size_t size, ErlNifBinary* bin)
 {
     Binary* refbin;
 
@@ -343,7 +508,7 @@ int enif_alloc_binary(ErlNifEnv* env, unsigned size, ErlNifBinary* bin)
     return 1;
 }
 
-int enif_realloc_binary(ErlNifEnv* env, ErlNifBinary* bin, unsigned size)
+int enif_realloc_binary(ErlNifBinary* bin, size_t size)
 {
     if (bin->ref_bin != NULL) {
 	Binary* oldbin;
@@ -361,15 +526,15 @@ int enif_realloc_binary(ErlNifEnv* env, ErlNifBinary* bin, unsigned size)
     }
     else {
 	unsigned char* old_data = bin->data;
-	unsigned cpy_sz = (size < bin->size ? size : bin->size);  
-	enif_alloc_binary(env, size, bin);
+	size_t cpy_sz = (size < bin->size ? size : bin->size);  
+	enif_alloc_binary(size, bin);
 	sys_memcpy(bin->data, old_data, cpy_sz); 
     }
     return 1;
 }
 
 
-void enif_release_binary(ErlNifEnv* env, ErlNifBinary* bin)
+void enif_release_binary(ErlNifBinary* bin)
 {
     if (bin->ref_bin != NULL) {
 	Binary* refbin = bin->ref_bin;
@@ -385,21 +550,21 @@ void enif_release_binary(ErlNifEnv* env, ErlNifBinary* bin)
 #endif
 }
 
-unsigned char* enif_make_new_binary(ErlNifEnv* env, unsigned size,
+unsigned char* enif_make_new_binary(ErlNifEnv* env, size_t size,
 				    ERL_NIF_TERM* termp)
 {
-    enable_halloc(env);
+    flush_env(env);
     *termp = new_binary(env->proc, NULL, size);
-    disable_halloc(env);
+    cache_env(env);
     return binary_bytes(*termp);
 }
 
-int enif_is_identical(ErlNifEnv* env, Eterm lhs, Eterm rhs)
+int enif_is_identical(Eterm lhs, Eterm rhs)
 {
     return EQ(lhs,rhs);
 }
 
-int enif_compare(ErlNifEnv* env, Eterm lhs, Eterm rhs)
+int enif_compare(Eterm lhs, Eterm rhs)
 {
     return cmp(lhs,rhs);
 }
@@ -478,15 +643,15 @@ Eterm enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)
 	return bin_term;
     }
     else {
-	enable_halloc(env);
+	flush_env(env);
 	bin->bin_term = new_binary(env->proc, bin->data, bin->size);
-	disable_halloc(env);
+	cache_env(env);
 	return bin->bin_term;
     }
 }
 
 Eterm enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term,
-			   unsigned pos, unsigned size)
+			   size_t pos, size_t size)
 {
     ErlSubBin* sb;
     Eterm orig;
@@ -516,9 +681,11 @@ Eterm enif_make_badarg(ErlNifEnv* env)
     BIF_ERROR(env->proc, BADARG);
 }
 
-int enif_get_atom(ErlNifEnv* env, Eterm atom, char* buf, unsigned len)
+int enif_get_atom(ErlNifEnv* env, Eterm atom, char* buf, unsigned len,
+		  ErlNifCharEncoding encoding)
 {
     Atom* ap;
+    ASSERT(encoding == ERL_NIF_LATIN1);
     if (is_not_atom(atom)) {
 	return 0;
     }
@@ -566,10 +733,8 @@ int enif_get_long(ErlNifEnv* env, Eterm term, long* ip)
 #if SIZEOF_LONG == ERTS_SIZEOF_ETERM
     return term_to_Sint(term, ip);
 #elif SIZEOF_INT == ERTS_SIZEOF_ETERM
-    Uint u;
-    term_to_Sint(term, u);
-    *ip = (long) u;
-    return 1;
+    Sint i;
+    return term_to_Sint(term, &i) ? (*ip = (long) i, 1) : 0;
 #else
 #  error Unknown long word size 
 #endif     
@@ -581,10 +746,7 @@ int enif_get_ulong(ErlNifEnv* env, Eterm term, unsigned long* ip)
     return term_to_Uint(term, ip);
 #elif SIZEOF_INT == ERTS_SIZEOF_ETERM
     Uint u;
-    int r;
-    r = term_to_Uint(term, &u);
-    *ip = (unsigned long) u;
-    return r;
+    return term_to_Uint(term, &u) ? (*ip = (unsigned long) u, 1) : 0;
 #else
 #  error Unknown long word size 
 #endif     
@@ -601,9 +763,11 @@ int enif_get_double(ErlNifEnv* env, Eterm term, double* dp)
     return 1;
 }
 
-int enif_get_atom_length(ErlNifEnv* env, Eterm atom, unsigned* len)
+int enif_get_atom_length(ErlNifEnv* env, Eterm atom, unsigned* len,
+			 ErlNifCharEncoding enc)
 {
     Atom* ap;
+    ASSERT(enc == ERL_NIF_LATIN1);
     if (is_not_atom(atom)) return 0;
     ap = atom_tab(atom_val(atom));
     *len = ap->len;
@@ -674,14 +838,16 @@ ERL_NIF_TERM enif_make_atom_len(ErlNifEnv* env, const char* name, size_t len)
     return am_atom_put(name, len);
 }
 
-int enif_make_existing_atom(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom)
+int enif_make_existing_atom(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom,
+			    ErlNifCharEncoding enc)
 {
-    return enif_make_existing_atom_len(env, name, sys_strlen(name), atom);
+    return enif_make_existing_atom_len(env, name, sys_strlen(name), atom, enc);
 }
 
 int enif_make_existing_atom_len(ErlNifEnv* env, const char* name, size_t len,
-				ERL_NIF_TERM* atom)
+				ERL_NIF_TERM* atom, ErlNifCharEncoding encoding)
 {
+    ASSERT(encoding == ERL_NIF_LATIN1);
     return erts_atom_get(name, len, atom);
 }
 
@@ -841,7 +1007,8 @@ struct enif_resource_type_t
     ErlNifResourceDtor* dtor;      /* user destructor function */
     erts_refc_t refc;  /* num of resources of this type (HOTSPOT warning)
                           +1 for active erl_module_nif */
-    char name[1];
+    Eterm module;
+    Eterm name;
 };
 
 /* dummy node in circular list */
@@ -859,14 +1026,14 @@ typedef struct enif_resource_t
 #define SIZEOF_ErlNifResource(SIZE) (offsetof(ErlNifResource,data) + (SIZE))
 #define DATA_TO_RESOURCE(PTR) ((ErlNifResource*)((char*)(PTR) - offsetof(ErlNifResource,data)))
 
-static ErlNifResourceType* find_resource_type(const char* name)
+static ErlNifResourceType* find_resource_type(Eterm module, Eterm name)
 {
     ErlNifResourceType* type;
     for (type = resource_type_list.next;
 	 type != &resource_type_list;
 	 type = type->next) {
 
-	if (sys_strcmp(type->name, name) == 0) {
+	if (type->module == module && type->name == name) {
 	    return type;
 	}
     }
@@ -899,33 +1066,42 @@ static void steal_resource_type(ErlNifResourceType* type)
 
     if (type->dtor != NULL
 	&& erts_refc_dectest(&lib->rt_dtor_cnt, 0) == 0
-	&& lib->is_orphan) {
+	&& lib->mod == NULL) {
 	/* last type with destructor gone, close orphan lib */
 
 	close_lib(lib);
     }
     if (erts_refc_dectest(&lib->rt_cnt, 0) == 0
-	&& lib->is_orphan) {
+	&& lib->mod == NULL) {
 	erts_free(ERTS_ALC_T_NIF, lib);
     }
 }
 
 ErlNifResourceType*
-enif_open_resource_type(ErlNifEnv* env, const char* type_name, 
-			  ErlNifResourceDtor* dtor,
-			  enum ErlNifResourceFlags flags,
-			  enum ErlNifResourceFlags* tried)
+enif_open_resource_type(ErlNifEnv* env,
+			const char* module_str, 
+			const char* name_str, 
+			ErlNifResourceDtor* dtor,
+			ErlNifResourceFlags flags,
+			ErlNifResourceFlags* tried)
 {
-    ErlNifResourceType* type = find_resource_type(type_name);
-    enum ErlNifResourceFlags op = flags;
+    ErlNifResourceType* type = NULL;
+    ErlNifResourceFlags op = flags;
+    Eterm module_am, name_am;
+
     ASSERT(erts_smp_is_system_blocked(0));
+    ASSERT(module_str == NULL); /* for now... */
+    module_am = make_atom(env->mod_nif->mod->module);
+    name_am = enif_make_atom(env, name_str);
+
+    type = find_resource_type(module_am, name_am);
     if (type == NULL) {
 	if (flags & ERL_NIF_RT_CREATE) {
 	    type = erts_alloc(ERTS_ALC_T_NIF,
-			      sizeof(struct enif_resource_type_t) 
-			      + sys_strlen(type_name));
+			      sizeof(struct enif_resource_type_t)); 
 	    type->dtor = dtor;
-	    sys_strcpy(type->name, type_name);
+	    type->module = module_am;
+	    type->name = name_am;
 	    erts_refc_init(&type->refc, 1);
 	    type->owner = env->mod_nif;
 	    type->prev = &resource_type_list;
@@ -973,13 +1149,13 @@ static void nif_resource_dtor(Binary* bin)
     if (erts_refc_dectest(&type->refc, 0) == 0) {
 	ASSERT(type->next == NULL);
 	ASSERT(type->owner != NULL);
-	ASSERT(type->owner->is_orphan);
+	ASSERT(type->owner->mod == NULL);
 	steal_resource_type(type);
 	erts_free(ERTS_ALC_T_NIF, type);
     }
 }
 
-void* enif_alloc_resource(ErlNifEnv* env, ErlNifResourceType* type, unsigned size)
+void* enif_alloc_resource(ErlNifResourceType* type, size_t size)
 {
     Binary* bin = erts_create_magic_binary(SIZEOF_ErlNifResource(size), &nif_resource_dtor);
     ErlNifResource* resource = ERTS_MAGIC_BIN_DATA(bin);
@@ -992,7 +1168,7 @@ void* enif_alloc_resource(ErlNifEnv* env, ErlNifResourceType* type, unsigned siz
     return resource->data;
 }
 
-void enif_release_resource(ErlNifEnv* env, void* obj)
+void enif_release_resource(void* obj)
 {
     ErlNifResource* resource = DATA_TO_RESOURCE(obj);
     ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_DATA(resource);
@@ -1006,6 +1182,18 @@ void enif_release_resource(ErlNifEnv* env, void* obj)
     }
 }
 
+void enif_keep_resource(void* obj)
+{
+    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_DATA(resource);
+
+    ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(bin) == &nif_resource_dtor);
+#ifdef DEBUG
+    erts_refc_inc(&resource->nif_refc, 1);
+#endif
+    erts_refc_inc(&bin->binary.refc, 2);
+}
+
 ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)
 {
     ErlNifResource* resource = DATA_TO_RESOURCE(obj);
@@ -1014,15 +1202,30 @@ ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)
     return erts_mk_magic_binary_term(&hp, &MSO(env->proc), &bin->binary);
 }
 
+ERL_NIF_TERM enif_make_resource_binary(ErlNifEnv* env, void* obj,
+				       const void* data, size_t size)
+{
+    Eterm bin = enif_make_resource(env, obj);
+    ProcBin* pb = (ProcBin*) binary_val(bin);
+    pb->bytes = (byte*) data;
+    pb->size = size;
+    return bin;
+}
+
 int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type,
 		      void** objp)
 {
+    ProcBin* pb;
     Binary* mbin;
     ErlNifResource* resource;
     if (!ERTS_TERM_IS_MAGIC_BINARY(term)) {
 	return 0;
     }
-    mbin = ((ProcBin*) binary_val(term))->val;
+    pb = (ProcBin*) binary_val(term);
+    /*if (pb->size != 0) {	
+	return 0; / * Or should we allow "resource binaries" as handles? * /
+    }*/
+    mbin = pb->val;
     resource = (ErlNifResource*) ERTS_MAGIC_BIN_DATA(mbin);
     if (ERTS_MAGIC_BIN_DESTRUCTOR(mbin) != &nif_resource_dtor
 	|| resource->type != type) {	
@@ -1032,7 +1235,7 @@ int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* typ
     return 1;
 }
 
-unsigned enif_sizeof_resource(ErlNifEnv* env, void* obj)
+size_t enif_sizeof_resource(void* obj)
 {
     ErlNifResource* resource = DATA_TO_RESOURCE(obj);
     Binary* bin = &ERTS_MAGIC_BIN_FROM_DATA(resource)->binary;
@@ -1262,7 +1465,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
     lib->entry = entry;
     erts_refc_init(&lib->rt_cnt, 0);
     erts_refc_init(&lib->rt_dtor_cnt, 0);
-    lib->is_orphan = 0;
+    lib->mod = mod;
     env.mod_nif = lib;
     if (mod->nif != NULL) { /* Reload */
 	int k;
@@ -1376,7 +1579,7 @@ erts_unload_nif(struct erl_module_nif* lib)
     ErlNifResourceType* next;
     ASSERT(erts_smp_is_system_blocked(0));
     ASSERT(lib != NULL);
-    ASSERT(!lib->is_orphan);
+    ASSERT(lib->mod != NULL);
     for (rt = resource_type_list.next;
 	 rt != &resource_type_list;
 	 rt = next) {
@@ -1406,7 +1609,7 @@ erts_unload_nif(struct erl_module_nif* lib)
     else {
 	ASSERT(erts_refc_read(&lib->rt_cnt, 1) > 0);
     }
-    lib->is_orphan = 1;
+    lib->mod = NULL;   /* orphan lib */
 }	
 
 void erl_nif_init()
@@ -1415,7 +1618,8 @@ void erl_nif_init()
     resource_type_list.prev = &resource_type_list;
     resource_type_list.dtor = NULL;
     resource_type_list.owner = NULL;
-    resource_type_list.name[0] = '\0';
+    resource_type_list.module = THE_NON_VALUE;
+    resource_type_list.name = THE_NON_VALUE;
 }
 
 #ifdef READONLY_CHECK
diff --git a/erts/emulator/beam/erl_nif.h b/erts/emulator/beam/erl_nif.h
index a345837569..936f03bce1 100644
--- a/erts/emulator/beam/erl_nif.h
+++ b/erts/emulator/beam/erl_nif.h
@@ -23,14 +23,16 @@
 #ifndef __ERL_NIF_H__
 #define __ERL_NIF_H__
 
+
 #include "erl_drv_nif.h"
 
 /* Version history:
 ** 0.1: R13B03
 ** 1.0: R13B04
+** 2.0: R14A
 */
-#define ERL_NIF_MAJOR_VERSION 1
-#define ERL_NIF_MINOR_VERSION 1
+#define ERL_NIF_MAJOR_VERSION 2
+#define ERL_NIF_MINOR_VERSION 0
 
 #include <stdlib.h>
 
@@ -60,6 +62,10 @@
 #endif
 #include "erl_int_sizes_config.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #ifdef HALFWORD_HEAP_EMULATOR
 typedef unsigned int ERL_NIF_TERM;
 #else
@@ -93,7 +99,7 @@ typedef struct enif_entry_t
 
 typedef struct
 {
-    unsigned size;
+    size_t size;
     unsigned char* data;
 
     /* Internals (avert your eyes) */
@@ -103,17 +109,22 @@ typedef struct
 
 typedef struct enif_resource_type_t ErlNifResourceType;
 typedef void ErlNifResourceDtor(ErlNifEnv*, void*);
-enum ErlNifResourceFlags
+typedef enum
 {
     ERL_NIF_RT_CREATE = 1,
     ERL_NIF_RT_TAKEOVER = 2
-};
+}ErlNifResourceFlags;
 
 typedef enum
 {
     ERL_NIF_LATIN1 = 1
 }ErlNifCharEncoding;
 
+typedef struct
+{
+    ERL_NIF_TERM pid;  /* internal, may change */
+}ErlNifPid;
+
 typedef ErlDrvSysInfo ErlNifSysInfo;
 
 typedef struct ErlDrvTid_ *ErlNifTid;
@@ -146,8 +157,6 @@ extern TWinDynNifCallbacks WinDynNifCallbacks;
 #endif
 
 
-
-
 #if (defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_))
 #  define ERL_NIF_INIT_GLOB TWinDynNifCallbacks WinDynNifCallbacks;
 #  define ERL_NIF_INIT_DECL(MODNAME) __declspec(dllexport) ErlNifEntry* nif_init(TWinDynNifCallbacks* callbacks)
@@ -163,7 +172,18 @@ extern TWinDynNifCallbacks WinDynNifCallbacks;
 #endif
 
 
+#ifdef __cplusplus
+}
+#  define ERL_NIF_INIT_PROLOGUE extern "C" {
+#  define ERL_NIF_INIT_EPILOGUE }
+#else
+#  define ERL_NIF_INIT_PROLOGUE
+#  define ERL_NIF_INIT_EPILOGUE
+#endif
+
+
 #define ERL_NIF_INIT(NAME, FUNCS, LOAD, RELOAD, UPGRADE, UNLOAD) \
+ERL_NIF_INIT_PROLOGUE                   \
 ERL_NIF_INIT_GLOB                       \
 ERL_NIF_INIT_DECL(NAME)			\
 {					\
@@ -178,7 +198,9 @@ ERL_NIF_INIT_DECL(NAME)			\
     };                                  \
     ERL_NIF_INIT_BODY;                  \
     return &entry;			\
-}
+}                                       \
+ERL_NIF_INIT_EPILOGUE
+
 
 #endif /* __ERL_NIF_H__ */
 
diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index 44bcca9ca4..ef4e9580b0 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -23,29 +23,29 @@
 
 #ifdef ERL_NIF_API_FUNC_DECL
 ERL_NIF_API_FUNC_DECL(void*,enif_priv_data,(ErlNifEnv*));
-ERL_NIF_API_FUNC_DECL(void*,enif_alloc,(ErlNifEnv*, size_t size));
-ERL_NIF_API_FUNC_DECL(void,enif_free,(ErlNifEnv*, void* ptr));
+ERL_NIF_API_FUNC_DECL(void*,enif_alloc,(size_t size));
+ERL_NIF_API_FUNC_DECL(void,enif_free,(void* ptr));
 ERL_NIF_API_FUNC_DECL(int,enif_is_atom,(ErlNifEnv*, ERL_NIF_TERM term));
 ERL_NIF_API_FUNC_DECL(int,enif_is_binary,(ErlNifEnv*, ERL_NIF_TERM term));
 ERL_NIF_API_FUNC_DECL(int,enif_is_ref,(ErlNifEnv*, ERL_NIF_TERM term));
 ERL_NIF_API_FUNC_DECL(int,enif_inspect_binary,(ErlNifEnv*, ERL_NIF_TERM bin_term, ErlNifBinary* bin));
-ERL_NIF_API_FUNC_DECL(int,enif_alloc_binary,(ErlNifEnv*, unsigned size, ErlNifBinary* bin));
-ERL_NIF_API_FUNC_DECL(int,enif_realloc_binary,(ErlNifEnv*, ErlNifBinary* bin, unsigned size));
-ERL_NIF_API_FUNC_DECL(void,enif_release_binary,(ErlNifEnv*, ErlNifBinary* bin));
+ERL_NIF_API_FUNC_DECL(int,enif_alloc_binary,(size_t size, ErlNifBinary* bin));
+ERL_NIF_API_FUNC_DECL(int,enif_realloc_binary,(ErlNifBinary* bin, size_t size));
+ERL_NIF_API_FUNC_DECL(void,enif_release_binary,(ErlNifBinary* bin));
 ERL_NIF_API_FUNC_DECL(int,enif_get_int,(ErlNifEnv*, ERL_NIF_TERM term, int* ip));
 ERL_NIF_API_FUNC_DECL(int,enif_get_ulong,(ErlNifEnv*, ERL_NIF_TERM term, unsigned long* ip));
 ERL_NIF_API_FUNC_DECL(int,enif_get_double,(ErlNifEnv*, ERL_NIF_TERM term, double* dp));
 ERL_NIF_API_FUNC_DECL(int,enif_get_list_cell,(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM* head, ERL_NIF_TERM* tail));
 ERL_NIF_API_FUNC_DECL(int,enif_get_tuple,(ErlNifEnv* env, ERL_NIF_TERM tpl, int* arity, const ERL_NIF_TERM** array));
-ERL_NIF_API_FUNC_DECL(int,enif_is_identical,(ErlNifEnv* env, ERL_NIF_TERM lhs, ERL_NIF_TERM rhs));
-ERL_NIF_API_FUNC_DECL(int,enif_compare,(ErlNifEnv* env, ERL_NIF_TERM lhs, ERL_NIF_TERM rhs));
+ERL_NIF_API_FUNC_DECL(int,enif_is_identical,(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs));
+ERL_NIF_API_FUNC_DECL(int,enif_compare,(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_binary,(ErlNifEnv* env, ErlNifBinary* bin));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_badarg,(ErlNifEnv* env));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_int,(ErlNifEnv* env, int i));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_ulong,(ErlNifEnv* env, unsigned long i));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_double,(ErlNifEnv* env, double d));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_atom,(ErlNifEnv* env, const char* name));
-ERL_NIF_API_FUNC_DECL(int,enif_make_existing_atom,(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom));
+ERL_NIF_API_FUNC_DECL(int,enif_make_existing_atom,(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom, ErlNifCharEncoding));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_tuple,(ErlNifEnv* env, unsigned cnt, ...));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_list,(ErlNifEnv* env, unsigned cnt, ...));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_list_cell,(ErlNifEnv* env, ERL_NIF_TERM car, ERL_NIF_TERM cdr));
@@ -82,13 +82,13 @@ ERL_NIF_API_FUNC_DECL(int,enif_equal_tids,(ErlNifTid tid1, ErlNifTid tid2));
 ERL_NIF_API_FUNC_DECL(void,enif_thread_exit,(void *resp));
 ERL_NIF_API_FUNC_DECL(int,enif_thread_join,(ErlNifTid, void **respp));
 
-ERL_NIF_API_FUNC_DECL(void*,enif_realloc,(ErlNifEnv*, void* ptr, size_t size));
+ERL_NIF_API_FUNC_DECL(void*,enif_realloc,(void* ptr, size_t size));
 ERL_NIF_API_FUNC_DECL(void,enif_system_info,(ErlNifSysInfo *sip, size_t si_size));
 ERL_NIF_API_FUNC_DECL(int,enif_fprintf,(void/* FILE* */ *filep, const char *format, ...));
 ERL_NIF_API_FUNC_DECL(int,enif_inspect_iolist_as_binary,(ErlNifEnv*, ERL_NIF_TERM term, ErlNifBinary* bin));
-ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_sub_binary,(ErlNifEnv*, ERL_NIF_TERM bin_term, unsigned pos, unsigned size));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_sub_binary,(ErlNifEnv*, ERL_NIF_TERM bin_term, size_t pos, size_t size));
 ERL_NIF_API_FUNC_DECL(int,enif_get_string,(ErlNifEnv*, ERL_NIF_TERM list, char* buf, unsigned len, ErlNifCharEncoding));
-ERL_NIF_API_FUNC_DECL(int,enif_get_atom,(ErlNifEnv*, ERL_NIF_TERM atom, char* buf, unsigned len));
+ERL_NIF_API_FUNC_DECL(int,enif_get_atom,(ErlNifEnv*, ERL_NIF_TERM atom, char* buf, unsigned len, ErlNifCharEncoding));
 ERL_NIF_API_FUNC_DECL(int,enif_is_fun,(ErlNifEnv*, ERL_NIF_TERM term));
 ERL_NIF_API_FUNC_DECL(int,enif_is_pid,(ErlNifEnv*, ERL_NIF_TERM term));
 ERL_NIF_API_FUNC_DECL(int,enif_is_port,(ErlNifEnv*, ERL_NIF_TERM term));
@@ -99,20 +99,29 @@ ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_long,(ErlNifEnv*, long i));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_tuple_from_array,(ErlNifEnv*, const ERL_NIF_TERM arr[], unsigned cnt));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_list_from_array,(ErlNifEnv*, const ERL_NIF_TERM arr[], unsigned cnt));
 ERL_NIF_API_FUNC_DECL(int,enif_is_empty_list,(ErlNifEnv*, ERL_NIF_TERM term));
-ERL_NIF_API_FUNC_DECL(ErlNifResourceType*,enif_open_resource_type,(ErlNifEnv*, const char* type_name, void (*dtor)(ErlNifEnv*,void *), enum ErlNifResourceFlags flags, enum ErlNifResourceFlags* tried));
-ERL_NIF_API_FUNC_DECL(void*,enif_alloc_resource,(ErlNifEnv*, ErlNifResourceType* type, unsigned size));
-ERL_NIF_API_FUNC_DECL(void,enif_release_resource,(ErlNifEnv*, void* obj));
+ERL_NIF_API_FUNC_DECL(ErlNifResourceType*,enif_open_resource_type,(ErlNifEnv*, const char* module_str, const char* name_str, void (*dtor)(ErlNifEnv*,void *), ErlNifResourceFlags flags, ErlNifResourceFlags* tried));
+ERL_NIF_API_FUNC_DECL(void*,enif_alloc_resource,(ErlNifResourceType* type, size_t size));
+ERL_NIF_API_FUNC_DECL(void,enif_release_resource,(void* obj));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_resource,(ErlNifEnv*, void* obj));
 ERL_NIF_API_FUNC_DECL(int,enif_get_resource,(ErlNifEnv*, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp));
-ERL_NIF_API_FUNC_DECL(unsigned,enif_sizeof_resource,(ErlNifEnv*, void* obj));
-ERL_NIF_API_FUNC_DECL(unsigned char*,enif_make_new_binary,(ErlNifEnv*,unsigned size,ERL_NIF_TERM* termp));
+ERL_NIF_API_FUNC_DECL(size_t,enif_sizeof_resource,(void* obj));
+ERL_NIF_API_FUNC_DECL(unsigned char*,enif_make_new_binary,(ErlNifEnv*,size_t size,ERL_NIF_TERM* termp));
 ERL_NIF_API_FUNC_DECL(int,enif_is_list,(ErlNifEnv*, ERL_NIF_TERM term));
 ERL_NIF_API_FUNC_DECL(int,enif_is_tuple,(ErlNifEnv*, ERL_NIF_TERM term));
-ERL_NIF_API_FUNC_DECL(int,enif_get_atom_length,(ErlNifEnv*, ERL_NIF_TERM atom, unsigned* len));
+ERL_NIF_API_FUNC_DECL(int,enif_get_atom_length,(ErlNifEnv*, ERL_NIF_TERM atom, unsigned* len, ErlNifCharEncoding));
 ERL_NIF_API_FUNC_DECL(int,enif_get_list_length,(ErlNifEnv* env, ERL_NIF_TERM term, unsigned* len));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_make_atom_len,(ErlNifEnv* env, const char* name, size_t len));
-ERL_NIF_API_FUNC_DECL(int, enif_make_existing_atom_len,(ErlNifEnv* env, const char* name, size_t len, ERL_NIF_TERM* atom));
+ERL_NIF_API_FUNC_DECL(int, enif_make_existing_atom_len,(ErlNifEnv* env, const char* name, size_t len, ERL_NIF_TERM* atom, ErlNifCharEncoding));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_string_len,(ErlNifEnv* env, const char* string, size_t len, ErlNifCharEncoding));
+ERL_NIF_API_FUNC_DECL(ErlNifEnv*,enif_alloc_env,(void));
+ERL_NIF_API_FUNC_DECL(void,enif_free_env,(ErlNifEnv* env));
+ERL_NIF_API_FUNC_DECL(void,enif_clear_env,(ErlNifEnv* env));
+ERL_NIF_API_FUNC_DECL(int,enif_send,(ErlNifEnv* env, const ErlNifPid* to_pid, ErlNifEnv* msg_env, ERL_NIF_TERM msg));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_copy,(ErlNifEnv* dst_env, ERL_NIF_TERM src_term));
+ERL_NIF_API_FUNC_DECL(ErlNifPid*,enif_self,(ErlNifEnv* caller_env, ErlNifPid* pid));
+ERL_NIF_API_FUNC_DECL(int,enif_get_local_pid,(ErlNifEnv* env, ERL_NIF_TERM, ErlNifPid* pid));
+ERL_NIF_API_FUNC_DECL(void,enif_keep_resource,(void* obj));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_resource_binary,(ErlNifEnv*,void* obj,const void* data, size_t size));
 
 /*
 ** Add last to keep compatibility on Windows!!!
@@ -212,6 +221,15 @@ ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_string_len,(ErlNifEnv* env, const c
 #  define enif_make_atom_len ERL_NIF_API_FUNC_MACRO(enif_make_atom_len)
 #  define enif_make_existing_atom_len ERL_NIF_API_FUNC_MACRO(enif_make_existing_atom_len)
 #  define enif_make_string_len ERL_NIF_API_FUNC_MACRO(enif_make_string_len)
+#  define enif_alloc_env ERL_NIF_API_FUNC_MACRO(enif_alloc_env)
+#  define enif_free_env ERL_NIF_API_FUNC_MACRO(enif_free_env)
+#  define enif_clear_env ERL_NIF_API_FUNC_MACRO(enif_clear_env)
+#  define enif_send ERL_NIF_API_FUNC_MACRO(enif_send)
+#  define enif_make_copy ERL_NIF_API_FUNC_MACRO(enif_make_copy)
+#  define enif_self ERL_NIF_API_FUNC_MACRO(enif_self)
+#  define enif_get_local_pid ERL_NIF_API_FUNC_MACRO(enif_get_local_pid)
+#  define enif_keep_resource ERL_NIF_API_FUNC_MACRO(enif_keep_resource)
+#  define enif_make_resource_binary ERL_NIF_API_FUNC_MACRO(enif_make_resource_binary)
 #endif
 
 #ifndef enif_make_list1
@@ -233,9 +251,7 @@ ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_string_len,(ErlNifEnv* env, const c
 #  define enif_make_tuple7(ENV,E1,E2,E3,E4,E5,E6,E7) enif_make_tuple(ENV,7,E1,E2,E3,E4,E5,E6,E7)
 #  define enif_make_tuple8(ENV,E1,E2,E3,E4,E5,E6,E7,E8) enif_make_tuple(ENV,8,E1,E2,E3,E4,E5,E6,E7,E8)
 #  define enif_make_tuple9(ENV,E1,E2,E3,E4,E5,E6,E7,E8,E9) enif_make_tuple(ENV,9,E1,E2,E3,E4,E5,E6,E7,E8,E9)
-#endif
 
-#ifndef enif_get_data
-#  define enif_get_data enif_priv_data /* deprecated */
+#  define enif_make_pid(ENV, PID) ((const ERL_NIF_TERM)((PID)->pid))
 #endif
 
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 11ca85a41c..e329bfd2d1 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -7187,8 +7187,6 @@ erts_debug_verify_clean_empty_process(Process* p)
 void
 erts_cleanup_empty_process(Process* p)
 {
-    ErlHeapFragment* mbufp;
-
     /* We only check fields that are known to be used... */
 
     erts_cleanup_offheap(&p->off_heap);
@@ -7199,13 +7197,10 @@ erts_cleanup_empty_process(Process* p)
     p->off_heap.externals = NULL;
     p->off_heap.overhead = 0;
 
-    mbufp = p->mbuf;
-    while (mbufp) {
-	ErlHeapFragment *next = mbufp->next;
-	free_message_buffer(mbufp);
-	mbufp = next;
+    if (p->mbuf != NULL) {
+	free_message_buffer(p->mbuf);
+	p->mbuf = NULL;
     }
-    p->mbuf = NULL;
 #if defined(ERTS_ENABLE_LOCK_COUNT) && defined(ERTS_SMP)
     erts_lcnt_proc_lock_destroy(p);
 #endif
@@ -7221,7 +7216,6 @@ static void
 delete_process(Process* p)
 {
     ErlMessage* mp;
-    ErlHeapFragment* bp;
 
     VERBOSE(DEBUG_PROCESSES, ("Removing process: %T\n",p->id));
 
@@ -7271,11 +7265,8 @@ delete_process(Process* p)
     /*
      * Free all pending message buffers.
      */
-    bp = p->mbuf;
-    while (bp != NULL) {
-	ErlHeapFragment* next_bp = bp->next;
-	free_message_buffer(bp);
-	bp = next_bp;
+    if (p->mbuf != NULL) {	
+	free_message_buffer(p->mbuf);
     }
 
     erts_erase_dicts(p);
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index cbcdec4ba7..e2cb523cf5 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -765,7 +765,7 @@ ERTS_GLB_INLINE void erts_heap_frag_shrink(Process* p, Eterm* hp)
 {
     ErlHeapFragment* hf = MBUF(p);
 
-    ASSERT(hf!=NULL && (hp - hf->mem < (unsigned long)hf->size));
+    ASSERT(hf!=NULL && (hp - hf->mem < (unsigned long)hf->alloc_size));
 
     hf->used_size = hp - hf->mem;
 }	
diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index eeeeb7ccfd..cd63401581 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -84,6 +84,7 @@
 
 #define ErtsHAllocLockCheck(P) \
   ERTS_SMP_LC_ASSERT((ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks((P))) \
+      	             || ((P)->id == ERTS_INVALID_PID) \
 		     || ((P)->scheduler_data \
 			 && (P) == (P)->scheduler_data->match_pseudo_process) \
 		     || erts_is_system_blocked(0))
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index d5d63631ff..19dd3d6f97 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -881,6 +881,8 @@ Eterm copy_object(Eterm, Process*);
 Uint size_object(Eterm);
 Eterm copy_struct(Eterm, Uint, Eterm**, ErlOffHeap*);
 Eterm copy_shallow(Eterm*, Uint, Eterm**, ErlOffHeap*);
+void move_multi_frags(Eterm** hpp, ErlOffHeap*, ErlHeapFragment* first,
+		      Eterm* refs, unsigned nrefs);
 
 #ifdef HYBRID
 #define RRMA_DEFAULT_SIZE 256
@@ -1078,6 +1080,7 @@ Eterm erts_heap_sizes(Process* p);
 void erts_offset_off_heap(ErlOffHeap *, Sint, Eterm*, Eterm*);
 void erts_offset_heap_ptr(Eterm*, Uint, Sint, Eterm*, Eterm*);
 void erts_offset_heap(Eterm*, Uint, Sint, Eterm*, Eterm*);
+void erts_free_heap_frags(Process* p);
 
 #ifdef HYBRID
 int erts_global_garbage_collect(Process*, int, Eterm*, int);
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 51c12a0b69..445a8eebd9 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -32,6 +32,7 @@
 #include "erl_binary.h"
 #include "erl_bits.h"
 #include "packet_parser.h"
+#include "erl_gc.h"
 #define ERTS_WANT_DB_INTERNAL__
 #include "erl_db.h"
 #include "erl_threads.h"
@@ -125,7 +126,7 @@ erts_heap_alloc(Process* p, Uint need)
 
     n = need;
     bp = MBUF(p);
-    if (bp != NULL && need <= (bp->size - bp->used_size)) {
+    if (bp != NULL && need <= (bp->alloc_size - bp->used_size)) {
 	Eterm* ret = bp->mem + bp->used_size;
 	bp->used_size += need;
 	return ret;
@@ -158,7 +159,7 @@ erts_heap_alloc(Process* p, Uint need)
 
     bp->next = MBUF(p);
     MBUF(p) = bp;
-    bp->size = n;
+    bp->alloc_size = n;
     bp->used_size = n;
     MBUF_SIZE(p) += n;
     bp->off_heap.mso = NULL;