Merge branch 'sverk/literal-memory-range'

* sverk/literal-memory-range:
  erts: Refactor line table in loaded beam code
  erts: Refactor header of loaded beam code
  fix check_process_code for separate literal area
  erts: Add support for fast erts_is_literal()
  erts: Refactor erl_mmap to allow several mapper instances
  erts: Add new allocator LITERAL
  erts: Fix strangeness in treatment of MSEG_ALIGN_BITS
  erts: Cleanup main carrier creation
  erts: Remove unused erts_have_erts_mmap
  erts: Refactor config test for posix_memalign

25 files changed, 1197 insertions, 773 deletions

diff --git a/erts/configure.in b/erts/configure.in
index 96ad58f941..a4700fc308 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -2093,8 +2093,7 @@ fi
 
 case X$erl_xcomp_posix_memalign in
      Xno) ;;
-     Xyes) AC_DEFINE(HAVE_POSIX_MEMALIGN,[1],
-                [Define to 1 if you have the `posix_memalign' function.]) ;;
+     Xyes) have_posix_memalign=yes ;;
      *)
 	AC_CHECK_FUNC(
 		[posix_memalign],
@@ -2109,15 +2108,19 @@ int main(void) {
       return error;
     return 0;
 }
-],AC_DEFINE(HAVE_POSIX_MEMALIGN,[1],
-    [Define to 1 if you have the `posix_memalign' function.])
+],have_posix_memalign=yes
 )
 		 else
-			AC_DEFINE(HAVE_POSIX_MEMALIGN,[1],
-		[Define to 1 if you have the `posix_memalign' function.])
+			have_posix_memalign=yes
 		 fi]);;
 esac
 
+if test $have_posix_memalign = yes; then
+   AC_DEFINE(HAVE_POSIX_MEMALIGN,[1],
+	     [Define to 1 if you have the `posix_memalign' function.])
+fi
+
+
 dnl writev on OS X snow leopard is broken for files > 4GB
 case $host_os in
         darwin10.8.0)
diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index 11508a1b39..2c275c4649 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -40,7 +40,7 @@
 static void set_default_trace_pattern(Eterm module);
 static Eterm check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp);
 static void delete_code(Module* modp);
-static void decrement_refc(BeamInstr* code);
+static void decrement_refc(BeamCodeHeader*);
 static int any_heap_ref_ptrs(Eterm* start, Eterm* end, char* mod_start, Uint mod_size);
 static int any_heap_refs(Eterm* start, Eterm* end, char* mod_start, Uint mod_size);
 
@@ -58,8 +58,8 @@ BIF_RETTYPE code_is_module_native_1(BIF_ALIST_1)
 	return am_undefined;
     }
     erts_rlock_old_code(code_ix);
-    res = (erts_is_module_native(modp->curr.code) ||
-           erts_is_module_native(modp->old.code)) ?
+    res = (erts_is_module_native(modp->curr.code_hdr) ||
+           erts_is_module_native(modp->old.code_hdr)) ?
 		am_true : am_false;
     erts_runlock_old_code(code_ix);
     return res;
@@ -81,7 +81,7 @@ BIF_RETTYPE code_make_stub_module_3(BIF_ALIST_3)
     modp = erts_get_module(BIF_ARG_1, erts_active_code_ix());
 
     if (modp && modp->curr.num_breakpoints > 0) {
-	ASSERT(modp->curr.code != NULL);
+	ASSERT(modp->curr.code_hdr != NULL);
 	erts_clear_module_break(modp);
 	ASSERT(modp->curr.num_breakpoints == 0);
     }
@@ -281,7 +281,7 @@ finish_loading_1(BIF_ALIST_1)
     exceptions = 0;
     for (i = 0; i < n; i++) {
 	p[i].exception = 0;
-	if (p[i].modp->curr.code && p[i].modp->old.code) {
+	if (p[i].modp->curr.code_hdr && p[i].modp->old.code_hdr) {
 	    p[i].exception = 1;
 	    exceptions++;
 	}
@@ -417,7 +417,7 @@ check_old_code_1(BIF_ALIST_1)
     modp = erts_get_module(BIF_ARG_1, code_ix);
     if (modp != NULL) {
 	erts_rlock_old_code(code_ix);
-	if (modp->old.code != NULL) {
+	if (modp->old.code_hdr) {
 	    res = am_true;
 	}
 	erts_runlock_old_code(code_ix);
@@ -441,7 +441,7 @@ erts_check_process_code(Process *c_p, Eterm module, int allow_gc, int *redsp)
     if (!modp)
 	return am_false;
     erts_rlock_old_code(code_ix);
-    res = modp->old.code ? check_process_code(c_p, modp, allow_gc, redsp) : am_false;
+    res = modp->old.code_hdr ? check_process_code(c_p, modp, allow_gc, redsp) : am_false;
     erts_runlock_old_code(code_ix);
 
     return res;
@@ -525,7 +525,7 @@ BIF_RETTYPE delete_module_1(BIF_ALIST_1)
 	if (!modp) {
 	    res = am_undefined;
 	}
-	else if (modp->old.code != 0) {
+	else if (modp->old.code_hdr) {
 	    erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
 	    erts_dsprintf(dsbufp, "Module %T must be purged before loading\n",
 			  BIF_ARG_1);
@@ -563,8 +563,8 @@ BIF_RETTYPE module_loaded_1(BIF_ALIST_1)
     }
     code_ix = erts_active_code_ix();
     if ((modp = erts_get_module(BIF_ARG_1, code_ix)) != NULL) {
-	if (modp->curr.code != NULL
-	    && modp->curr.code[MI_ON_LOAD_FUNCTION_PTR] == 0) {
+	if (modp->curr.code_hdr
+	    && modp->curr.code_hdr->on_load_function_ptr == NULL) {
 	    res = am_true;
 	}
     }
@@ -611,8 +611,8 @@ BIF_RETTYPE call_on_load_function_1(BIF_ALIST_1)
 {
     Module* modp = erts_get_module(BIF_ARG_1, erts_active_code_ix());
 
-    if (modp && modp->curr.code) {
-	BIF_TRAP_CODE_PTR_0(BIF_P, modp->curr.code[MI_ON_LOAD_FUNCTION_PTR]);
+    if (modp && modp->curr.code_hdr) {
+	BIF_TRAP_CODE_PTR_0(BIF_P, modp->curr.code_hdr->on_load_function_ptr);
     }
     else {
 	BIF_ERROR(BIF_P, BADARG);
@@ -623,7 +623,6 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
 {
     ErtsCodeIndex code_ix;
     Module* modp;
-    Eterm on_load;
 
     if (!erts_try_seize_code_write_permission(BIF_P)) {
 	ERTS_BIF_YIELD2(bif_export[BIF_finish_after_on_load_2],
@@ -638,14 +637,14 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
     code_ix = erts_active_code_ix();
     modp = erts_get_module(BIF_ARG_1, code_ix);
 
-    if (!modp || modp->curr.code == 0) {
+    if (!modp || !modp->curr.code_hdr) {
     error:
 	erts_smp_thr_progress_unblock();
         erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	erts_release_code_write_permission();
 	BIF_ERROR(BIF_P, BADARG);
     }
-    if ((on_load = modp->curr.code[MI_ON_LOAD_FUNCTION_PTR]) == 0) {
+    if (modp->curr.code_hdr->on_load_function_ptr == NULL) {
 	goto error;
     }
     if (BIF_ARG_2 != am_false && BIF_ARG_2 != am_true) {
@@ -667,7 +666,7 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
 		ep->code[4] = 0;
 	    }
 	}
-	modp->curr.code[MI_ON_LOAD_FUNCTION_PTR] = 0;
+	modp->curr.code_hdr->on_load_function_ptr = NULL;
 	set_default_trace_pattern(BIF_ARG_1);
     } else if (BIF_ARG_2 == am_false) {
 	BeamInstr* code;
@@ -679,13 +678,16 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
 	 * the current code; the old code is not touched.
 	 */
 	erts_total_code_size -= modp->curr.code_length;
-	code = modp->curr.code;
-	end = (BeamInstr *)((char *)code + modp->curr.code_length);
+	code = (BeamInstr*) modp->curr.code_hdr;
+	end = (BeamInstr *) ((char *)code + modp->curr.code_length);
 	erts_cleanup_funs_on_purge(code, end);
 	beam_catches_delmod(modp->curr.catches, code, modp->curr.code_length,
 			    erts_active_code_ix());
-	erts_free(ERTS_ALC_T_CODE, (void *) code);
-	modp->curr.code = NULL;
+        if (modp->curr.code_hdr->literals_start) {
+            erts_free(ERTS_ALC_T_LITERAL, modp->curr.code_hdr->literals_start);
+        }
+	erts_free(ERTS_ALC_T_CODE, modp->curr.code_hdr);
+	modp->curr.code_hdr = NULL;
 	modp->curr.code_length = 0;
 	modp->curr.catches = BEAM_CATCHES_NIL;
 	erts_remove_from_ranges(code);
@@ -725,8 +727,8 @@ static Eterm
 check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
 {
     BeamInstr* start;
-    char* mod_start;
-    Uint mod_size;
+    char* literals;
+    Uint lit_bsize;
     BeamInstr* end;
     Eterm* sp;
     struct erl_off_heap_header* oh;
@@ -737,10 +739,8 @@ check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
     /*
      * Pick up limits for the module.
      */
-    start = modp->old.code;
+    start = (BeamInstr*) modp->old.code_hdr;
     end = (BeamInstr *)((char *)start + modp->old.code_length);
-    mod_start = (char *) start;
-    mod_size = modp->old.code_length;
 
     /*
      * Check if current instruction or continuation pointer points into module.
@@ -831,22 +831,24 @@ check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
      * See if there are constants inside the module referenced by the process.
      */
     done_gc = 0;
+    literals = (char*) modp->old.code_hdr->literals_start;
+    lit_bsize = (char*) modp->old.code_hdr->literals_end - literals;
     for (;;) {
 	ErlMessage* mp;
 
-	if (any_heap_ref_ptrs(&rp->fvalue, &rp->fvalue+1, mod_start, mod_size)) {
+	if (any_heap_ref_ptrs(&rp->fvalue, &rp->fvalue+1, literals, lit_bsize)) {
 	    rp->freason = EXC_NULL;
 	    rp->fvalue = NIL;
 	    rp->ftrace = NIL;
 	}
-	if (any_heap_ref_ptrs(rp->stop, rp->hend, mod_start, mod_size)) {
+	if (any_heap_ref_ptrs(rp->stop, rp->hend, literals, lit_bsize)) {
 	    goto need_gc;
 	}
-	if (any_heap_refs(rp->heap, rp->htop, mod_start, mod_size)) {
+	if (any_heap_refs(rp->heap, rp->htop, literals, lit_bsize)) {
 	    goto need_gc;
 	}
 
-	if (any_heap_refs(rp->old_heap, rp->old_htop, mod_start, mod_size)) {
+	if (any_heap_refs(rp->old_heap, rp->old_htop, literals, lit_bsize)) {
 	    goto need_gc;
 	}
 
@@ -854,13 +856,13 @@ check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
 	    Eterm* start = rp->dictionary->data;
 	    Eterm* end = start + rp->dictionary->used;
 
-	    if (any_heap_ref_ptrs(start, end, mod_start, mod_size)) {
+	    if (any_heap_ref_ptrs(start, end, literals, lit_bsize)) {
 		goto need_gc;
 	    }
 	}
 
 	for (mp = rp->msg.first; mp != NULL; mp = mp->next) {
-	    if (any_heap_ref_ptrs(mp->m, mp->m+2, mod_start, mod_size)) {
+	    if (any_heap_ref_ptrs(mp->m, mp->m+2, literals, lit_bsize)) {
 		goto need_gc;
 	    }
 	}
@@ -870,8 +872,6 @@ check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
 	if (done_gc) {
 	    return am_true;
 	} else {
-	    Eterm* literals;
-	    Uint lit_size;
 	    struct erl_off_heap_header* oh;
 
 	    if (!allow_gc)
@@ -887,12 +887,9 @@ check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
 	    done_gc = 1;
 	    FLAGS(rp) |= F_NEED_FULLSWEEP;
 	    *redsp += erts_garbage_collect(rp, 0, rp->arg_reg, rp->arity);
-	    literals = (Eterm *) modp->old.code[MI_LITERALS_START];
-	    lit_size = (Eterm *) modp->old.code[MI_LITERALS_END] - literals;
-	    oh = (struct erl_off_heap_header *)
-		modp->old.code[MI_LITERALS_OFF_HEAP];
-	    *redsp += lit_size / 10; /* Need, better value... */
-	    erts_garbage_collect_literals(rp, literals, lit_size, oh);
+	    oh = modp->old.code_hdr->literals_off_heap;
+	    *redsp += lit_bsize / 64; /* Need, better value... */
+	    erts_garbage_collect_literals(rp, (Eterm*)literals, lit_bsize, oh);
 	}
     }
     return am_false;
@@ -990,7 +987,7 @@ BIF_RETTYPE purge_module_1(BIF_ALIST_1)
 	/*
 	 * Any code to purge?
 	 */
-	if (modp->old.code == 0) {
+	if (!modp->old.code_hdr) {
 	    ERTS_BIF_PREP_ERROR(ret, BIF_P, BADARG);
 	}
 	else {
@@ -1013,14 +1010,17 @@ BIF_RETTYPE purge_module_1(BIF_ALIST_1)
 	     */
 	    ASSERT(erts_total_code_size >= modp->old.code_length);
 	    erts_total_code_size -= modp->old.code_length;
-	    code = modp->old.code;
+	    code = (BeamInstr*) modp->old.code_hdr;
 	    end = (BeamInstr *)((char *)code + modp->old.code_length);
 	    erts_cleanup_funs_on_purge(code, end);
 	    beam_catches_delmod(modp->old.catches, code, modp->old.code_length,
 				code_ix);
-	    decrement_refc(code);
+	    decrement_refc(modp->old.code_hdr);
+            if (modp->old.code_hdr->literals_start) {
+                erts_free(ERTS_ALC_T_LITERAL, modp->old.code_hdr->literals_start);
+            }
 	    erts_free(ERTS_ALC_T_CODE, (void *) code);
-	    modp->old.code = NULL;
+	    modp->old.code_hdr = NULL;
 	    modp->old.code_length = 0;
 	    modp->old.catches = BEAM_CATCHES_NIL;
 	    erts_remove_from_ranges(code);
@@ -1037,10 +1037,9 @@ BIF_RETTYPE purge_module_1(BIF_ALIST_1)
 }
 
 static void
-decrement_refc(BeamInstr* code)
+decrement_refc(BeamCodeHeader* code_hdr)
 {
-    struct erl_off_heap_header* oh =
-	(struct erl_off_heap_header *) code[MI_LITERALS_OFF_HEAP];
+    struct erl_off_heap_header* oh = code_hdr->literals_off_heap;
 
     while (oh) {
 	Binary* bptr;
@@ -1089,7 +1088,7 @@ delete_code(Module* modp)
     ASSERT(modp->curr.num_breakpoints == 0);
     ASSERT(modp->curr.num_traced_exports == 0);
     modp->old = modp->curr;
-    modp->curr.code = NULL;
+    modp->curr.code_hdr = NULL;
     modp->curr.code_length = 0;
     modp->curr.catches = BEAM_CATCHES_NIL;
     modp->curr.nif = NULL;
@@ -1106,9 +1105,9 @@ beam_make_current_old(Process *c_p, ErtsProcLocks c_p_locks, Eterm module)
      * if not, delete old code; error if old code already exists.
      */
 
-    if (modp->curr.code != NULL && modp->old.code != NULL)  {
+    if (modp->curr.code_hdr && modp->old.code_hdr)  {
 	return am_not_purged;
-    } else if (modp->old.code == NULL) { /* Make the current version old. */
+    } else if (!modp->old.code_hdr) { /* Make the current version old. */
 	delete_code(modp);
     }
     return NIL;
diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 016d0aaa32..2a8663d7ee 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -152,8 +152,8 @@ erts_bp_match_functions(BpFunctions* f, Eterm mfa[3], int specified)
     num_modules = 0;
     for (current = 0; current < max_modules; current++) {
 	modp = module_code(current, code_ix);
-	if (modp->curr.code) {
-	    max_funcs += modp->curr.code[MI_NUM_FUNCTIONS];
+	if (modp->curr.code_hdr) {
+	    max_funcs += modp->curr.code_hdr->num_functions;
 	    module[num_modules++] = modp;
 	}
     }
@@ -161,9 +161,9 @@ erts_bp_match_functions(BpFunctions* f, Eterm mfa[3], int specified)
     f->matching = (BpFunction *) Alloc(max_funcs*sizeof(BpFunction));
     i = 0;
     for (current = 0; current < num_modules; current++) {
-	BeamInstr** code_base = (BeamInstr **) module[current]->curr.code;
+	BeamCodeHeader* code_hdr = module[current]->curr.code_hdr;
 	BeamInstr* code;
-	Uint num_functions = (Uint)(UWord) code_base[MI_NUM_FUNCTIONS];
+	Uint num_functions = (Uint)(UWord) code_hdr->num_functions;
 	Uint fi;
 
 	if (specified > 0) {
@@ -177,7 +177,7 @@ erts_bp_match_functions(BpFunctions* f, Eterm mfa[3], int specified)
 	    BeamInstr* pc;
 	    int wi;
 
-	    code = code_base[MI_FUNCTIONS+fi];
+	    code = code_hdr->functions[fi];
 	    ASSERT(code[0] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
 	    pc = code+5;
 	    if (erts_is_native_break(pc)) {
@@ -547,21 +547,21 @@ erts_clear_all_breaks(BpFunctions* f)
 
 int 
 erts_clear_module_break(Module *modp) {
-    BeamInstr** code_base;
+    BeamCodeHeader* code_hdr;
     Uint n;
     Uint i;
 
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(modp);
-    code_base = (BeamInstr **) modp->curr.code;
-    if (code_base == NULL) {
+    code_hdr = modp->curr.code_hdr;
+    if (!code_hdr) {
 	return 0;
     }
-    n = (Uint)(UWord) code_base[MI_NUM_FUNCTIONS];
+    n = (Uint)(UWord) code_hdr->num_functions;
     for (i = 0; i < n; ++i) {
 	BeamInstr* pc;
 
-	pc = code_base[MI_FUNCTIONS+i] + 5;
+	pc = code_hdr->functions[i] + 5;
 	if (erts_is_native_break(pc)) {
 	    continue;
 	}
@@ -573,7 +573,7 @@ erts_clear_module_break(Module *modp) {
     for (i = 0; i < n; ++i) {
 	BeamInstr* pc;
 
-	pc = code_base[MI_FUNCTIONS+i] + 5;
+	pc = code_hdr->functions[i] + 5;
 	if (erts_is_native_break(pc)) {
 	    continue;
 	}
@@ -1204,17 +1204,17 @@ int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
 BeamInstr *
 erts_find_local_func(Eterm mfa[3]) {
     Module *modp;
-    BeamInstr** code_base;
+    BeamCodeHeader* code_hdr;
     BeamInstr* code_ptr;
     Uint i,n;
 
     if ((modp = erts_get_module(mfa[0], erts_active_code_ix())) == NULL)
 	return NULL;
-    if ((code_base = (BeamInstr **) modp->curr.code) == NULL)
+    if ((code_hdr = modp->curr.code_hdr) == NULL)
 	return NULL;
-    n = (BeamInstr) code_base[MI_NUM_FUNCTIONS];
+    n = (BeamInstr) code_hdr->num_functions;
     for (i = 0; i < n; ++i) {
-	code_ptr = code_base[MI_FUNCTIONS+i];
+	code_ptr = code_hdr->functions[i];
 	ASSERT(((BeamInstr) BeamOp(op_i_func_info_IaaI)) == code_ptr[0]);
 	ASSERT(mfa[0] == ((Eterm) code_ptr[2]) ||
 	       is_nil((Eterm) code_ptr[2]));
diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index 0e921d761c..e989310789 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -208,7 +208,7 @@ erts_debug_disassemble_1(BIF_ALIST_1)
     Eterm bin;
     Eterm mfa;
     BeamInstr* funcinfo = NULL;	/* Initialized to eliminate warning. */
-    BeamInstr* code_base;
+    BeamCodeHeader* code_hdr;
     BeamInstr* code_ptr = NULL;	/* Initialized to eliminate warning. */
     BeamInstr instr;
     BeamInstr uaddr;
@@ -258,12 +258,12 @@ erts_debug_disassemble_1(BIF_ALIST_1)
 	     */
 	    code_ptr = ((BeamInstr *) ep->addressv[code_ix]) - 5;
 	    funcinfo = code_ptr+2;
-	} else if (modp == NULL || (code_base = modp->curr.code) == NULL) {
+	} else if (modp == NULL || (code_hdr = modp->curr.code_hdr) == NULL) {
 	    BIF_RET(am_undef);
 	} else {
-	    n = code_base[MI_NUM_FUNCTIONS];
+	    n = code_hdr->num_functions;
 	    for (i = 0; i < n; i++) {
-		code_ptr = (BeamInstr *) code_base[MI_FUNCTIONS+i];
+		code_ptr = code_hdr->functions[i];
 		if (code_ptr[3] == name && code_ptr[4] == arity) {
 		    funcinfo = code_ptr+2;
 		    break;
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index faf496a030..f15b98eb58 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -6080,7 +6080,7 @@ call_fun(Process* p,		/* Current process. */
 		 */
 		module = fe->module;
 		if ((modp = erts_get_module(module, code_ix)) != NULL
-		    && modp->curr.code != NULL) {
+		    && modp->curr.code_hdr != NULL) {
 		    /*
 		     * There is a module loaded, but obviously the fun is not
 		     * defined in it. We must not call the error_handler
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index a9d47eb7b0..1c598601c6 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -80,7 +80,7 @@ ErlDrvBinary* erts_gzinflate_buffer(char*, int);
 
 typedef struct {
     Uint value;			/* Value of label (NULL if not known yet). */
-    Uint patches;		/* Index (into code buffer) to first location
+    Sint patches;		/* Index (into code buffer) to first location
 				 * which must be patched with the value of this label.
 				 */
 #ifdef ERTS_SMP
@@ -284,9 +284,10 @@ typedef struct LoaderState {
     int specific_op;		/* Specific opcode (-1 if not found). */
     int num_functions;		/* Number of functions in module. */
     int num_labels;		/* Number of labels. */
-    int code_buffer_size;	/* Size of code buffer in words.  */
-    BeamInstr* code;		/* Loaded code. */
-    int ci;			/* Current index into loaded code. */
+    BeamCodeHeader* hdr;	/* Loaded code header */
+    BeamInstr* codev;	        /* Loaded code buffer */
+    int        codev_size;      /* Size of code buffer in words. */
+    int ci;			/* Current index into loaded code buffer. */
     Label* labels;
     StringPatch* string_patches; /* Linked list of position into string table to patch. */
     BeamInstr catches;		/* Linked list of catch_yf instructions. */
@@ -480,7 +481,7 @@ static void free_literal_fragment(ErlHeapFragment*);
 static void loader_state_dtor(Binary* magic);
 static Eterm insert_new_code(Process *c_p, ErtsProcLocks c_p_locks,
 			     Eterm group_leader, Eterm module,
-			     BeamInstr* code, Uint size);
+			     BeamCodeHeader* code, Uint size);
 static int init_iff_file(LoaderState* stp, byte* code, Uint size);
 static int scan_iff_file(LoaderState* stp, Uint* chunk_types,
 			 Uint num_types, Uint num_mandatory);
@@ -526,15 +527,15 @@ static void new_string_patch(LoaderState* stp, int pos);
 static Uint new_literal(LoaderState* stp, Eterm** hpp, Uint heap_size);
 static int genopargcompare(GenOpArg* a, GenOpArg* b);
 static Eterm get_module_info(Process* p, ErtsCodeIndex code_ix,
-                             BeamInstr* code, Eterm module, Eterm what);
+                             BeamCodeHeader*, Eterm module, Eterm what);
 static Eterm exported_from_module(Process* p, ErtsCodeIndex code_ix,
                                   Eterm mod);
-static Eterm functions_in_module(Process* p, BeamInstr* code);
-static Eterm attributes_for_module(Process* p, BeamInstr* code);
-static Eterm compilation_info_for_module(Process* p, BeamInstr* code);
-static Eterm md5_of_module(Process* p, BeamInstr* code);
-static Eterm has_native(BeamInstr* code);
-static Eterm native_addresses(Process* p, BeamInstr* code);
+static Eterm functions_in_module(Process* p, BeamCodeHeader*);
+static Eterm attributes_for_module(Process* p, BeamCodeHeader*);
+static Eterm compilation_info_for_module(Process* p, BeamCodeHeader*);
+static Eterm md5_of_module(Process* p, BeamCodeHeader*);
+static Eterm has_native(BeamCodeHeader*);
+static Eterm native_addresses(Process* p, BeamCodeHeader*);
 int patch_funentries(Eterm Patchlist);
 int patch(Eterm Addresses, Uint fe);
 static int safe_mul(UWord a, UWord b, UWord* resp);
@@ -601,6 +602,7 @@ extern void check_allocated_block(Uint type, void *blk);
 #define CHKBLK(TYPE,BLK) /* nothing */
 #endif
 
+
 Eterm
 erts_prepare_loading(Binary* magic, Process *c_p, Eterm group_leader,
 		     Eterm* modp, byte* code, Uint unloaded_size)
@@ -641,20 +643,27 @@ erts_prepare_loading(Binary* magic, Process *c_p, Eterm group_leader,
     /*
      * Initialize code area.
      */
-    stp->code_buffer_size = 2048 + stp->num_functions;
-    stp->code = (BeamInstr *) erts_alloc(ERTS_ALC_T_CODE,
-				    sizeof(BeamInstr) * stp->code_buffer_size);
+    stp->codev_size = 2048 + stp->num_functions;
+    stp->hdr = (BeamCodeHeader*) erts_alloc(ERTS_ALC_T_CODE,
+                                            (offsetof(BeamCodeHeader,functions)
+                                             + sizeof(BeamInstr) * stp->codev_size));
 
-    stp->code[MI_NUM_FUNCTIONS] = stp->num_functions;
-    stp->ci = MI_FUNCTIONS + stp->num_functions + 1;
+    stp->hdr->num_functions = stp->num_functions;
 
-    stp->code[MI_ATTR_PTR] = 0;
-    stp->code[MI_ATTR_SIZE] = 0;
-    stp->code[MI_ATTR_SIZE_ON_HEAP] = 0;
-    stp->code[MI_COMPILE_PTR] = 0;
-    stp->code[MI_COMPILE_SIZE] = 0;
-    stp->code[MI_COMPILE_SIZE_ON_HEAP] = 0;
-    stp->code[MI_MD5_PTR] = 0;
+    /* Let the codev array start at functions[0] in order to index
+     * both function pointers and the loaded code itself that follows.
+     */
+    stp->codev = (BeamInstr*) &stp->hdr->functions;
+    stp->ci = stp->num_functions + 1;
+
+    stp->hdr->attr_ptr = NULL;
+    stp->hdr->attr_size = 0;
+    stp->hdr->attr_size_on_heap = 0;
+    stp->hdr->compile_ptr = NULL;
+    stp->hdr->compile_size = 0;
+    stp->hdr->compile_size_on_heap = 0;
+    stp->hdr->literals_start = NULL;
+    stp->hdr->md5_ptr = NULL;
 
     /*
      * Read the atom table.
@@ -776,7 +785,7 @@ erts_finish_loading(Binary* magic, Process* c_p,
 
     CHKBLK(ERTS_ALC_T_CODE,stp->code);
     retval = insert_new_code(c_p, c_p_locks, stp->group_leader, stp->module,
-			     stp->code, stp->loaded_size);
+			     stp->hdr, stp->loaded_size);
     if (retval != NIL) {
 	goto load_error;
     }
@@ -799,7 +808,8 @@ erts_finish_loading(Binary* magic, Process* c_p,
     debug_dump_code(stp->code,stp->ci);
 #endif
 #endif
-    stp->code = NULL;		/* Prevent code from being freed. */
+    stp->hdr = NULL;		/* Prevent code from being freed. */
+    stp->codev = NULL;
     *modp = stp->module;
 
     /*
@@ -831,7 +841,8 @@ erts_alloc_loader_state(void)
     stp->specific_op = -1;
     stp->genop = NULL;
     stp->atom = NULL;
-    stp->code = NULL;
+    stp->hdr = NULL;
+    stp->codev = NULL;
     stp->labels = NULL;
     stp->import = NULL;
     stp->export = NULL;
@@ -870,7 +881,7 @@ erts_module_for_prepared_code(Binary* magic)
 	return NIL;
     }
     stp = ERTS_MAGIC_BIN_DATA(magic);
-    if (stp->code != 0) {
+    if (stp->hdr != 0) {
 	return stp->module;
     } else {
 	return NIL;
@@ -920,9 +931,13 @@ loader_state_dtor(Binary* magic)
 	driver_free_binary(stp->bin);
 	stp->bin = 0;
     }
-    if (stp->code != 0) {
-	erts_free(ERTS_ALC_T_CODE, stp->code);
-	stp->code = 0;
+    if (stp->hdr != 0) {
+        if (stp->hdr->literals_start) {
+            erts_free(ERTS_ALC_T_LITERAL, stp->hdr->literals_start);
+        }
+	erts_free(ERTS_ALC_T_CODE, stp->hdr);
+	stp->hdr = 0;
+        stp->codev = 0;
     }
     if (stp->labels != 0) {
 	erts_free(ERTS_ALC_T_PREPARED_CODE, (void *) stp->labels);
@@ -995,7 +1010,7 @@ loader_state_dtor(Binary* magic)
 
 static Eterm
 insert_new_code(Process *c_p, ErtsProcLocks c_p_locks,
-		Eterm group_leader, Eterm module, BeamInstr* code,
+		Eterm group_leader, Eterm module, BeamCodeHeader* code_hdr,
 		Uint size)
 {
     Module* modp;
@@ -1016,7 +1031,7 @@ insert_new_code(Process *c_p, ErtsProcLocks c_p_locks,
 
     erts_total_code_size += size;
     modp = erts_put_module(module);
-    modp->curr.code = code;
+    modp->curr.code_hdr = code_hdr;
     modp->curr.code_length = size;
     modp->curr.catches = BEAM_CATCHES_NIL; /* Will be filled in later. */
 
@@ -1024,7 +1039,7 @@ insert_new_code(Process *c_p, ErtsProcLocks c_p_locks,
      * Update ranges (used for finding a function from a PC value).
      */
 
-    erts_update_ranges(code, size);
+    erts_update_ranges((BeamInstr*)modp->curr.code_hdr, size);
     return NIL;
 }
 
@@ -1373,7 +1388,7 @@ read_export_table(LoaderState* stp)
 	if (value == 0) {
 	    LoadError2(stp, "export table entry %d: label %d not resolved", i, n);
 	}
-	stp->export[i].address = address = stp->code + value;
+	stp->export[i].address = address = stp->codev + value;
 
 	/*
 	 * Find out if there is a BIF with the same name.
@@ -1392,7 +1407,7 @@ read_export_table(LoaderState* stp)
 	 * any other functions that walk through all local functions.
 	 */
 
-	if (stp->labels[n].patches) {
+	if (stp->labels[n].patches >= 0) {
 	    LoadError3(stp, "there are local calls to the stub for "
 		       "the BIF %T:%T/%d",
 		       stp->module, func, arity);
@@ -1735,7 +1750,7 @@ read_code_header(LoaderState* stp)
 				       stp->num_labels * sizeof(Label));
     for (i = 0; i < stp->num_labels; i++) {
 	stp->labels[i].value = 0;
-	stp->labels[i].patches = 0;
+	stp->labels[i].patches = -1;
 #ifdef ERTS_SMP
 	stp->labels[i].looprec_targeted = 0;
 #endif
@@ -1754,13 +1769,14 @@ read_code_header(LoaderState* stp)
     } else {}
 
 #define CodeNeed(w) do {						\
-    ASSERT(ci <= code_buffer_size);					\
-    if (code_buffer_size < ci+(w)) {					\
-        code_buffer_size = 2*ci+(w);					\
-	stp->code = code =						\
-	    (BeamInstr *) erts_realloc(ERTS_ALC_T_CODE,			\
-				     (void *) code,			\
-				     code_buffer_size * sizeof(BeamInstr));	\
+    ASSERT(ci <= codev_size);					        \
+    if (codev_size < ci+(w)) {					        \
+        codev_size = 2*ci+(w);	                                        \
+	stp->hdr = (BeamCodeHeader*) erts_realloc(ERTS_ALC_T_CODE,	\
+            (void *) stp->hdr,	                                        \
+            (offsetof(BeamCodeHeader,functions)                         \
+             + codev_size * sizeof(BeamInstr)));                        \
+        code = stp->codev = (BeamInstr*) &stp->hdr->functions;          \
     } 									\
 } while (0)
     
@@ -1776,7 +1792,7 @@ load_code(LoaderState* stp)
     int arg;			/* Number of current argument. */
     int num_specific;		/* Number of specific ops for current. */
     BeamInstr* code;
-    int code_buffer_size;
+    int codev_size;
     int specific;
     Uint last_label = 0;	/* Number of last label. */
     Uint function_number = 0;
@@ -1793,15 +1809,15 @@ load_code(LoaderState* stp)
 	FUNC_INFO_SZ = 5
     };
 
-    code = stp->code;
-    code_buffer_size = stp->code_buffer_size;
+    code = stp->codev;
+    codev_size = stp->codev_size;
     ci = stp->ci;
 
     for (;;) {
 	int new_op;
 	GenOp* tmp_op;
 
-	ASSERT(ci <= code_buffer_size);
+	ASSERT(ci <= codev_size);
 
     get_next_instr:
 	GetByte(stp, new_op);
@@ -2416,8 +2432,7 @@ load_code(LoaderState* stp)
 	switch (stp->specific_op) {
 	case op_i_func_info_IaaI:
 	    {
-		Uint offset;
-
+		Sint offset;
 		if (function_number >= stp->num_functions) {
 		    LoadError1(stp, "too many functions in module (header said %d)",
 			       stp->num_functions); 
@@ -2459,15 +2474,15 @@ load_code(LoaderState* stp)
 		stp->arity = code[ci-1];
 
 		ASSERT(stp->labels[last_label].value == ci - FUNC_INFO_SZ);
-		offset = MI_FUNCTIONS + function_number;
-		code[offset] = stp->labels[last_label].patches;
+		stp->hdr->functions[function_number] = (BeamInstr*) stp->labels[last_label].patches;
+		offset = function_number;
 		stp->labels[last_label].patches = offset;
 		function_number++;
 		if (stp->arity > MAX_ARG) {
 		    LoadError1(stp, "too many arguments: %d", stp->arity);
 		}
 #ifdef DEBUG
-		ASSERT(stp->labels[0].patches == 0); /* Should not be referenced. */
+		ASSERT(stp->labels[0].patches < 0); /* Should not be referenced. */
 		for (i = 1; i < stp->num_labels; i++) {
 		    ASSERT(stp->labels[i].patches < ci);
 		}
@@ -2537,7 +2552,7 @@ load_code(LoaderState* stp)
 	     * End of code found.
 	     */
 	case op_int_code_end:
-	    stp->code_buffer_size = code_buffer_size;
+	    stp->codev_size = codev_size;
 	    stp->ci = ci;
 	    stp->function = THE_NON_VALUE;
 	    stp->genop = NULL;
@@ -4347,8 +4362,8 @@ gen_has_map_fields(LoaderState* stp, GenOpArg Fail, GenOpArg Src,
 static int
 freeze_code(LoaderState* stp)
 {
-    BeamInstr* code = stp->code;
-    Uint *literal_end = NULL;
+    BeamCodeHeader* code_hdr = stp->hdr;
+    BeamInstr* codev = (BeamInstr*) &stp->hdr->functions;
     int i;
     byte* str_table;
     unsigned strtab_size = stp->chunks[STR_CHUNK].size;
@@ -4373,77 +4388,75 @@ freeze_code(LoaderState* stp)
     if (stp->line_instr == 0) {
 	line_size = 0;
     } else {
-	line_size = (MI_LINE_FUNC_TAB + (stp->num_functions + 1) +
-		     (stp->current_li+1) + stp->num_fnames) *
-	    sizeof(Eterm) + (stp->current_li+1) * stp->loc_size;
+	line_size = (offsetof(BeamCodeLineTab,func_tab)
+                     + (stp->num_functions + 1) * sizeof(BeamInstr**) /* func_tab */
+                     + (stp->current_li + 1) * sizeof(BeamInstr*)     /* line items */
+                     + stp->num_fnames * sizeof(Eterm)                /* fname table */
+                     + (stp->current_li + 1) * stp->loc_size);        /* loc_tab */
     }
-    size = (stp->ci * sizeof(BeamInstr)) +
-	(stp->total_literal_size * sizeof(Eterm)) +
+    size = offsetof(BeamCodeHeader,functions) + (stp->ci * sizeof(BeamInstr)) +
 	strtab_size + attr_size + compile_size + MD5_SIZE + line_size;
 
     /*
      * Move the code to its final location.
      */
 
-    code = (BeamInstr *) erts_realloc(ERTS_ALC_T_CODE, (void *) code, size);
-    CHKBLK(ERTS_ALC_T_CODE,code);
+    code_hdr = (BeamCodeHeader*) erts_realloc(ERTS_ALC_T_CODE, (void *) code_hdr, size);
+    codev = (BeamInstr*) &code_hdr->functions;
+    CHKBLK(ERTS_ALC_T_CODE,code_hdr);
     /*
      * Place a pointer to the op_int_code_end instruction in the
      * function table in the beginning of the file.
      */
 
-    code[MI_FUNCTIONS+stp->num_functions] = (BeamInstr) (code + stp->ci - 1);
-    CHKBLK(ERTS_ALC_T_CODE,code);
+    code_hdr->functions[stp->num_functions] = (codev + stp->ci - 1);
+    CHKBLK(ERTS_ALC_T_CODE,code_hdr);
 
     /*
      * Store the pointer to the on_load function.
      */
 
     if (stp->on_load) {
-	code[MI_ON_LOAD_FUNCTION_PTR] = (BeamInstr) (code + stp->on_load);
+	code_hdr->on_load_function_ptr = codev + stp->on_load;
     } else {
-	code[MI_ON_LOAD_FUNCTION_PTR] = 0;
+	code_hdr->on_load_function_ptr = NULL;
     }
-    CHKBLK(ERTS_ALC_T_CODE,code);
+    CHKBLK(ERTS_ALC_T_CODE,code_hdr);
 
-    literal_end = (Uint *) (code+stp->ci);
     /*
-     * Place the literal heap directly after the code and fix up all
-     * instructions that refer to it.
+     * Place the literals in their own allocated heap (for fast range check)
+     * and fix up all instructions that refer to it.
      */
     {
-	Uint* ptr;
-	Uint* low;
-	Uint* high;
+	Eterm* ptr;
 	LiteralPatch* lp;
         ErlOffHeap code_off_heap;
 
         ERTS_INIT_OFF_HEAP(&code_off_heap);
 
-	low = (Uint *) (code+stp->ci);
-	high = low + stp->total_literal_size;
-	code[MI_LITERALS_START] = (BeamInstr) low;
-	code[MI_LITERALS_END] = (BeamInstr) high;
-	ptr = low;
+        ptr = (Eterm*)erts_alloc(ERTS_ALC_T_LITERAL,
+                                 stp->total_literal_size*sizeof(Eterm));
+	code_hdr->literals_start = ptr;
+	code_hdr->literals_end = ptr + stp->total_literal_size;
 	for (i = 0; i < stp->num_literals; i++) {
             if (stp->literals[i].heap_frags) {
                 move_multi_frags(&ptr, &code_off_heap, stp->literals[i].heap_frags,
                                  &stp->literals[i].term, 1);
+                ASSERT(erts_is_literal(ptr_val(stp->literals[i].term)));
             }
             else ASSERT(is_immed(stp->literals[i].term));
 	}
-        code[MI_LITERALS_OFF_HEAP] = (BeamInstr) code_off_heap.first;
+	code_hdr->literals_off_heap = code_off_heap.first;
 	lp = stp->literal_patches;
 	while (lp != 0) {
 	    BeamInstr* op_ptr;
 	    Literal* lit;
 
-	    op_ptr = code + lp->pos;
+	    op_ptr = codev + lp->pos;
 	    lit = &stp->literals[op_ptr[0]];
 	    op_ptr[0] = lit->term;
 	    lp = lp->next;
 	}
-	literal_end += stp->total_literal_size;
     }
     CHKBLK(ERTS_ALC_T_CODE,code);
 
@@ -4451,52 +4464,49 @@ freeze_code(LoaderState* stp)
      * If there is line information, place it here.
      */
     if (stp->line_instr == 0) {
-	code[MI_LINE_TABLE] = (BeamInstr) 0;
-	str_table = (byte *) literal_end;
+	code_hdr->line_table = NULL;
+	str_table = (byte *) (codev + stp->ci);
     } else {
-	Eterm* line_tab = (Eterm *) literal_end;
-	Eterm* p;
-	int ftab_size = stp->num_functions;
-	int num_instrs = stp->current_li;
-	Eterm* first_line_item;
+	BeamCodeLineTab* const line_tab = (BeamCodeLineTab *) (codev+stp->ci);
+	const int ftab_size = stp->num_functions;
+        const int num_instrs = stp->current_li;
+        const BeamInstr** const line_items =
+            (const BeamInstr**) &line_tab->func_tab[ftab_size + 1];
 
-	code[MI_LINE_TABLE] = (BeamInstr) line_tab;
-	p = line_tab + MI_LINE_FUNC_TAB;
+	code_hdr->line_table = line_tab;
 
-	first_line_item = (p + ftab_size + 1);
 	for (i = 0; i < ftab_size; i++) {
-	     *p++ = (Eterm) (BeamInstr) (first_line_item + stp->func_line[i]);
+            line_tab->func_tab[i] = line_items + stp->func_line[i];
 	}
-	*p++ = (Eterm) (BeamInstr) (first_line_item + num_instrs);
-	ASSERT(p == first_line_item);
+	line_tab->func_tab[i] = line_items + num_instrs;
+
 	for (i = 0; i < num_instrs; i++) {
-		*p++ = (Eterm) (BeamInstr) (code + stp->line_instr[i].pos);
+            line_items[i] = codev + stp->line_instr[i].pos;
 	}
-	*p++ = (Eterm) (BeamInstr) (code + stp->ci - 1);
+	line_items[i] = codev + stp->ci - 1;
 
-	line_tab[MI_LINE_FNAME_PTR] = (Eterm) (BeamInstr) p;
-	memcpy(p, stp->fname, stp->num_fnames*sizeof(Eterm));
-	p += stp->num_fnames;
+	line_tab->fname_ptr = (Eterm*) &line_items[i + 1];
+	memcpy(line_tab->fname_ptr, stp->fname, stp->num_fnames*sizeof(Eterm));
 
-	line_tab[MI_LINE_LOC_TAB] = (Eterm) (BeamInstr) p;
-	line_tab[MI_LINE_LOC_SIZE] = stp->loc_size;
+	line_tab->loc_size = stp->loc_size;
 	if (stp->loc_size == 2) {
-	    Uint16* locp = (Uint16 *) p;
-	    for (i = 0; i < num_instrs; i++) {
+            Uint16* locp = (Uint16 *) &line_tab->fname_ptr[stp->num_fnames];
+            line_tab->loc_tab.p2 = locp;
+            for (i = 0; i < num_instrs; i++) {
 		*locp++ = (Uint16) stp->line_instr[i].loc;
-	    }
-	    *locp++ = LINE_INVALID_LOCATION;
-	    str_table = (byte *) locp;
+            }
+            *locp++ = LINE_INVALID_LOCATION;
+            str_table = (byte *) locp;
 	} else {
-	    Uint32* locp = (Uint32 *) p;
-	    ASSERT(stp->loc_size == 4);
+	    Uint32* locp = (Uint32 *) &line_tab->fname_ptr[stp->num_fnames];
+            ASSERT(stp->loc_size == 4);
+            line_tab->loc_tab.p4 = locp;
 	    for (i = 0; i < num_instrs; i++) {
 		*locp++ = stp->line_instr[i].loc;
 	    }
 	    *locp++ = LINE_INVALID_LOCATION;
-	    str_table = (byte *) locp;
+            str_table = (byte *) locp;
 	}
-
 	CHKBLK(ERTS_ALC_T_CODE,code);
     }
 
@@ -4508,13 +4518,13 @@ freeze_code(LoaderState* stp)
     if (attr_size) {
 	byte* attr = str_table + strtab_size;
 	sys_memcpy(attr, stp->chunks[ATTR_CHUNK].start, stp->chunks[ATTR_CHUNK].size);
-	code[MI_ATTR_PTR] = (BeamInstr) attr;
-	code[MI_ATTR_SIZE] = (BeamInstr) stp->chunks[ATTR_CHUNK].size;
+	code_hdr->attr_ptr = attr;
+	code_hdr->attr_size = (BeamInstr) stp->chunks[ATTR_CHUNK].size;
 	decoded_size = erts_decode_ext_size(attr, attr_size);
 	if (decoded_size < 0) {
  	    LoadError0(stp, "bad external term representation of module attributes");
  	}
-	code[MI_ATTR_SIZE_ON_HEAP] = decoded_size;
+	code_hdr->attr_size_on_heap = decoded_size;
     }
     CHKBLK(ERTS_ALC_T_CODE,code);
     if (compile_size) {
@@ -4524,9 +4534,9 @@ freeze_code(LoaderState* stp)
 	       stp->chunks[COMPILE_CHUNK].size);
 
 	CHKBLK(ERTS_ALC_T_CODE,code);
-	code[MI_COMPILE_PTR] = (BeamInstr) compile_info;
+	code_hdr->compile_ptr = compile_info;
 	CHKBLK(ERTS_ALC_T_CODE,code);
-	code[MI_COMPILE_SIZE] = (BeamInstr) stp->chunks[COMPILE_CHUNK].size;
+	code_hdr->compile_size = (BeamInstr) stp->chunks[COMPILE_CHUNK].size;
 	CHKBLK(ERTS_ALC_T_CODE,code);
 	decoded_size = erts_decode_ext_size(compile_info, compile_size);
 	CHKBLK(ERTS_ALC_T_CODE,code);
@@ -4534,7 +4544,7 @@ freeze_code(LoaderState* stp)
  	    LoadError0(stp, "bad external term representation of compilation information");
  	}
 	CHKBLK(ERTS_ALC_T_CODE,code);
-	code[MI_COMPILE_SIZE_ON_HEAP] = decoded_size;
+	code_hdr->compile_size_on_heap = decoded_size;
     }
     CHKBLK(ERTS_ALC_T_CODE,code);
     {
@@ -4542,7 +4552,7 @@ freeze_code(LoaderState* stp)
 	CHKBLK(ERTS_ALC_T_CODE,code);
 	sys_memcpy(md5_sum, stp->mod_md5, MD5_SIZE);
 	CHKBLK(ERTS_ALC_T_CODE,code);
-	code[MI_MD5_PTR] = (BeamInstr) md5_sum;
+	code_hdr->md5_ptr = md5_sum;
 	CHKBLK(ERTS_ALC_T_CODE,code);
     }
     CHKBLK(ERTS_ALC_T_CODE,code);
@@ -4551,7 +4561,7 @@ freeze_code(LoaderState* stp)
      * Make sure that we have not overflowed the allocated code space.
      */
     ASSERT(str_table + strtab_size + attr_size + compile_size + MD5_SIZE ==
-	   ((byte *) code) + size);
+	   ((byte *) code_hdr) + size);
 
     /*
      * Patch all instructions that refer to the string table.
@@ -4563,46 +4573,47 @@ freeze_code(LoaderState* stp)
 	    BeamInstr* op_ptr;
 	    byte* strp;
 
-	    op_ptr = code + sp->pos;
+	    op_ptr = codev + sp->pos;
 	    strp = str_table + op_ptr[0];
 	    op_ptr[0] = (BeamInstr) strp;
 	    sp = sp->next;
 	}
     }
-    CHKBLK(ERTS_ALC_T_CODE,code);
+    CHKBLK(ERTS_ALC_T_CODE,code_hdr);
 
     /*
      * Resolve all labels.
      */
 
     for (i = 0; i < stp->num_labels; i++) {
-	Uint this_patch;
-	Uint next_patch;
+	Sint this_patch;
+	Sint next_patch;
 	Uint value = stp->labels[i].value;
 	
-	if (value == 0 && stp->labels[i].patches != 0) {
+	if (value == 0 && stp->labels[i].patches >= 0) {
 	    LoadError1(stp, "label %d not resolved", i);
 	}
 	ASSERT(value < stp->ci);
 	this_patch = stp->labels[i].patches;
-	while (this_patch != 0) {
+	while (this_patch >= 0) {
 	    ASSERT(this_patch < stp->ci);
-	    next_patch = code[this_patch];
+	    next_patch = codev[this_patch];
 	    ASSERT(next_patch < stp->ci);
-	    code[this_patch] = (BeamInstr) (code + value);
+	    codev[this_patch] = (BeamInstr) (codev + value);
 	    this_patch = next_patch;
 	}
     }
-    CHKBLK(ERTS_ALC_T_CODE,code);
+    CHKBLK(ERTS_ALC_T_CODE,code_hdr);
 
     /*
      * Save the updated code pointer and code size.
      */
 
-    stp->code = code;
+    stp->hdr = code_hdr;
+    stp->codev = codev;
     stp->loaded_size = size;
 
-    CHKBLK(ERTS_ALC_T_CODE,code);
+    CHKBLK(ERTS_ALC_T_CODE,code_hdr);
     return 1;
 
  load_error:
@@ -4610,7 +4621,8 @@ freeze_code(LoaderState* stp)
      * Make sure that the caller frees the newly reallocated block, and
      * not the old one (in case it has moved).
      */
-    stp->code = code;
+    stp->hdr = code_hdr;
+    stp->codev = codev;
     return 0;
 }
 
@@ -4621,7 +4633,7 @@ final_touch(LoaderState* stp)
     int on_load = stp->on_load;
     unsigned catches;
     Uint index;
-    BeamInstr* code = stp->code;
+    BeamInstr* codev = stp->codev;
     Module* modp;
 
     /*
@@ -4631,10 +4643,10 @@ final_touch(LoaderState* stp)
     index = stp->catches;
     catches = BEAM_CATCHES_NIL;
     while (index != 0) {
-	BeamInstr next = code[index];
-	code[index] = BeamOpCode(op_catch_yf);
-	catches = beam_catches_cons((BeamInstr *)code[index+2], catches);
-	code[index+2] = make_catch(catches);
+	BeamInstr next = codev[index];
+	codev[index] = BeamOpCode(op_catch_yf);
+	catches = beam_catches_cons((BeamInstr *)codev[index+2], catches);
+	codev[index+2] = make_catch(catches);
 	index = next;
     }
     modp = erts_put_module(stp->module);
@@ -4685,8 +4697,8 @@ final_touch(LoaderState* stp)
 	current = stp->import[i].patches;
 	while (current != 0) {
 	    ASSERT(current < stp->ci);
-	    next = stp->code[current];
-	    stp->code[current] = import;
+	    next = stp->codev[current];
+	    stp->codev[current] = import;
 	    current = next;
 	}
     }
@@ -4699,7 +4711,7 @@ final_touch(LoaderState* stp)
 	for (i = 0; i < stp->num_lambdas; i++) {
 	    unsigned entry_label = stp->lambdas[i].label;
 	    ErlFunEntry* fe = stp->lambdas[i].fe;
-	    BeamInstr* code_ptr = (BeamInstr *) (stp->code + stp->labels[entry_label].value);
+	    BeamInstr* code_ptr = stp->codev + stp->labels[entry_label].value;
 
 	    if (fe->address[0] != 0) {
 		/*
@@ -5323,7 +5335,7 @@ new_label(LoaderState* stp)
 					 (void *) stp->labels,
 					 stp->num_labels * sizeof(Label));
     stp->labels[num].value = 0;
-    stp->labels[num].patches = 0;
+    stp->labels[num].patches = -1;
     return num;
 }
 
@@ -5383,7 +5395,7 @@ erts_module_info_0(Process* p, Eterm module)
 {
     Module* modp;
     ErtsCodeIndex code_ix = erts_active_code_ix();
-    BeamInstr* code;
+    BeamCodeHeader* code_hdr;
     Eterm *hp;
     Eterm list = NIL;
     Eterm tup;
@@ -5397,13 +5409,13 @@ erts_module_info_0(Process* p, Eterm module)
 	return THE_NON_VALUE;
     }
 
-    code = modp->curr.code;
-    if (code == NULL) {
+    code_hdr = modp->curr.code_hdr;
+    if (code_hdr == NULL) {
         return THE_NON_VALUE;
     }
 
 #define BUILD_INFO(What) \
-    tup = get_module_info(p, code_ix, code, module, What); \
+    tup = get_module_info(p, code_ix, code_hdr, module, What); \
     hp = HAlloc(p, 5); \
     tup = TUPLE2(hp, What, tup); \
     hp += 3; \
@@ -5426,7 +5438,7 @@ erts_module_info_1(Process* p, Eterm module, Eterm what)
 {
     Module* modp;
     ErtsCodeIndex code_ix = erts_active_code_ix();
-    BeamInstr* code;
+    BeamCodeHeader* code_hdr;
 
     if (is_not_atom(module)) {
         return THE_NON_VALUE;
@@ -5437,34 +5449,34 @@ erts_module_info_1(Process* p, Eterm module, Eterm what)
         return THE_NON_VALUE;
     }
 
-    code = modp->curr.code;
-    if (code == NULL) {
+    code_hdr = modp->curr.code_hdr;
+    if (code_hdr == NULL) {
         return THE_NON_VALUE;
     }
 
-    return get_module_info(p, code_ix, code, module, what);
+    return get_module_info(p, code_ix, code_hdr, module, what);
 }
 
 static Eterm
-get_module_info(Process* p, ErtsCodeIndex code_ix, BeamInstr* code,
+get_module_info(Process* p, ErtsCodeIndex code_ix, BeamCodeHeader* code_hdr,
                 Eterm module, Eterm what)
 {
     if (what == am_module) {
 	return module;
     } else if (what == am_md5) {
-	return md5_of_module(p, code);
+	return md5_of_module(p, code_hdr);
     } else if (what == am_exports) {
 	return exported_from_module(p, code_ix, module);
     } else if (what == am_functions) {
-	return functions_in_module(p, code);
+	return functions_in_module(p, code_hdr);
     } else if (what == am_attributes) {
-	return attributes_for_module(p, code);
+	return attributes_for_module(p, code_hdr);
     } else if (what == am_compile) {
-	return compilation_info_for_module(p, code);
+	return compilation_info_for_module(p, code_hdr);
     } else if (what == am_native_addresses) {
-	return native_addresses(p, code);
+	return native_addresses(p, code_hdr);
     } else if (what == am_native) {
-	return has_native(code);
+	return has_native(code_hdr);
     }
     return THE_NON_VALUE;
 }
@@ -5476,7 +5488,7 @@ get_module_info(Process* p, ErtsCodeIndex code_ix, BeamInstr* code,
 
 Eterm
 functions_in_module(Process* p, /* Process whose heap to use. */
-		    BeamInstr* code)
+		    BeamCodeHeader* code_hdr)
 {
     int i;
     Uint num_functions;
@@ -5485,12 +5497,12 @@ functions_in_module(Process* p, /* Process whose heap to use. */
     Eterm* hp_end;
     Eterm result = NIL;
 
-    num_functions = code[MI_NUM_FUNCTIONS];
+    num_functions = code_hdr->num_functions;
     need = 5*num_functions;
     hp = HAlloc(p, need);
     hp_end = hp + need;
     for (i = num_functions-1; i >= 0 ; i--) {
-	BeamInstr* func_info = (BeamInstr *) code[MI_FUNCTIONS+i];
+	BeamInstr* func_info = code_hdr->functions[i];
 	Eterm name = (Eterm) func_info[3];
 	int arity = (int) func_info[4];
 	Eterm tuple;
@@ -5516,11 +5528,11 @@ functions_in_module(Process* p, /* Process whose heap to use. */
  */
 
 static Eterm
-has_native(BeamInstr *code)
+has_native(BeamCodeHeader *code_hdr)
 {
     Eterm result = am_false;
 #ifdef HIPE
-    if (erts_is_module_native(code)) {
+    if (erts_is_module_native(code_hdr)) {
         result = am_true;
     }
 #endif
@@ -5528,15 +5540,15 @@ has_native(BeamInstr *code)
 }
 
 int
-erts_is_module_native(BeamInstr* code)
+erts_is_module_native(BeamCodeHeader* code_hdr)
 {
     Uint i, num_functions;
 
     /* Check NativeAdress of first real function in module */
-    if (code != NULL) {
-        num_functions = code[MI_NUM_FUNCTIONS];
+    if (code_hdr != NULL) {
+        num_functions = code_hdr->num_functions;
         for (i=0; i<num_functions; i++) {
-            BeamInstr* func_info = (BeamInstr *) code[MI_FUNCTIONS+i];
+            BeamInstr* func_info = (BeamInstr *) code_hdr->functions[i];
             Eterm name = (Eterm) func_info[3];
             if (is_atom(name)) {
                 return func_info[1] != 0;
@@ -5553,7 +5565,7 @@ erts_is_module_native(BeamInstr* code)
  */
 
 static Eterm
-native_addresses(Process* p, BeamInstr* code)
+native_addresses(Process* p, BeamCodeHeader* code_hdr)
 {
     int i;
     Eterm* hp;
@@ -5562,12 +5574,12 @@ native_addresses(Process* p, BeamInstr* code)
     Eterm* hp_end;
     Eterm result = NIL;
 
-    num_functions = code[MI_NUM_FUNCTIONS];
+    num_functions = code_hdr->num_functions;
     need = (6+BIG_UINT_HEAP_SIZE)*num_functions;
     hp = HAlloc(p, need);
     hp_end = hp + need;
     for (i = num_functions-1; i >= 0 ; i--) {
-	BeamInstr* func_info = (BeamInstr *) code[MI_FUNCTIONS+i];
+	BeamInstr* func_info = code_hdr->functions[i];
 	Eterm name = (Eterm) func_info[3];
 	int arity = (int) func_info[4];
 	Eterm tuple;
@@ -5633,15 +5645,15 @@ exported_from_module(Process* p, /* Process whose heap to use. */
 
 Eterm
 attributes_for_module(Process* p, /* Process whose heap to use. */
-                      BeamInstr* code)
+                      BeamCodeHeader* code_hdr)
 {
     byte* ext;
     Eterm result = NIL;
 
-    ext = (byte *) code[MI_ATTR_PTR];
+    ext = code_hdr->attr_ptr;
     if (ext != NULL) {
 	ErtsHeapFactory factory;
-	erts_factory_proc_prealloc_init(&factory, p, code[MI_ATTR_SIZE_ON_HEAP]);
+	erts_factory_proc_prealloc_init(&factory, p, code_hdr->attr_size_on_heap);
 	result = erts_decode_ext(&factory, &ext);
 	if (is_value(result)) {
 	    erts_factory_close(&factory);
@@ -5656,15 +5668,15 @@ attributes_for_module(Process* p, /* Process whose heap to use. */
 
 Eterm
 compilation_info_for_module(Process* p, /* Process whose heap to use. */
-                            BeamInstr* code)
+                            BeamCodeHeader* code_hdr)
 {
     byte* ext;
     Eterm result = NIL;
 
-    ext = (byte *) code[MI_COMPILE_PTR];
+    ext = code_hdr->compile_ptr;
     if (ext != NULL) {
 	ErtsHeapFactory factory;
-	erts_factory_proc_prealloc_init(&factory, p, code[MI_COMPILE_SIZE_ON_HEAP]);
+	erts_factory_proc_prealloc_init(&factory, p, code_hdr->compile_size_on_heap);
 	result = erts_decode_ext(&factory, &ext);
 	if (is_value(result)) {
 	    erts_factory_close(&factory);
@@ -5679,9 +5691,9 @@ compilation_info_for_module(Process* p, /* Process whose heap to use. */
 
 Eterm
 md5_of_module(Process* p, /* Process whose heap to use. */
-              BeamInstr* code)
+              BeamCodeHeader* code_hdr)
 {
-    return new_binary(p, (byte *) code[MI_MD5_PTR], MD5_SIZE);
+    return new_binary(p, code_hdr->md5_ptr, MD5_SIZE);
 }
 
 /*
@@ -5892,7 +5904,7 @@ static byte*
 stub_copy_info(LoaderState* stp,
 	       int chunk,	/* Chunk: ATTR_CHUNK or COMPILE_CHUNK */
 	       byte* info,	/* Where to store info. */
-	       BeamInstr* ptr_word,	/* Where to store pointer into info. */
+	       byte** ptr_word,	/* Where to store pointer into info. */
 	       BeamInstr* size_word,	/* Where to store size into info. */
 	       BeamInstr* size_on_heap_word) /* Where to store size on heap. */
 {
@@ -5900,7 +5912,7 @@ stub_copy_info(LoaderState* stp,
     Uint size = stp->chunks[chunk].size;
     if (size != 0) {
 	memcpy(info, stp->chunks[chunk].start, size);
-	*ptr_word = (BeamInstr) info;
+	*ptr_word = info;
 	decoded_size = erts_decode_ext_size(info, size);
 	if (decoded_size < 0) {
  	    return 0;
@@ -6155,11 +6167,10 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
     BeamInstr Patchlist;
     Eterm MD5Bin;
     Eterm* tp;
-    BeamInstr* code = NULL;
-    BeamInstr* ptrs;
+    BeamCodeHeader* code_hdr;
+    BeamInstr* code_base;
     BeamInstr* fp;
     byte* info;
-    Uint ci;
     int n;
     int code_size;
     int rval;
@@ -6237,39 +6248,39 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
      * Allocate memory for the stub module.
      */
 
-    code_size = ((WORDS_PER_FUNCTION+1)*n + MI_FUNCTIONS + 2) * sizeof(BeamInstr);
-    code_size += stp->chunks[ATTR_CHUNK].size;
-    code_size += stp->chunks[COMPILE_CHUNK].size;
-    code_size += MD5_SIZE;
-    code = erts_alloc_fnf(ERTS_ALC_T_CODE, code_size);
-    if (!code) {
+    code_size = (offsetof(BeamCodeHeader,functions)
+                 + ((n+1) * sizeof(BeamInstr*))
+                 + (WORDS_PER_FUNCTION*n + 1) * sizeof(BeamInstr)
+                 + stp->chunks[ATTR_CHUNK].size
+                 + stp->chunks[COMPILE_CHUNK].size
+                 + MD5_SIZE);
+    code_hdr = erts_alloc_fnf(ERTS_ALC_T_CODE, code_size);
+    if (!code_hdr) {
 	goto error;
     }
 
     /*
-     * Initialize code area.
+     * Initialize code header.
      */
 
-    code[MI_NUM_FUNCTIONS] = n;
-    code[MI_ATTR_PTR] = 0;
-    code[MI_ATTR_SIZE] = 0;
-    code[MI_ATTR_SIZE_ON_HEAP] = 0;
-    code[MI_COMPILE_PTR] = 0;
-    code[MI_COMPILE_SIZE] = 0;
-    code[MI_COMPILE_SIZE_ON_HEAP] = 0;
-    code[MI_LITERALS_START] = 0;
-    code[MI_LITERALS_END] = 0;
-    code[MI_LITERALS_OFF_HEAP] = 0;
-    code[MI_ON_LOAD_FUNCTION_PTR] = 0;
-    code[MI_MD5_PTR] = 0;
-    ci = MI_FUNCTIONS + n + 1;
+    code_hdr->num_functions = n;
+    code_hdr->attr_ptr = NULL;
+    code_hdr->attr_size = 0;
+    code_hdr->attr_size_on_heap = 0;
+    code_hdr->compile_ptr = NULL;
+    code_hdr->compile_size = 0;
+    code_hdr->compile_size_on_heap = 0;
+    code_hdr->literals_start = NULL;
+    code_hdr->literals_end = NULL;
+    code_hdr->literals_off_heap = 0;
+    code_hdr->on_load_function_ptr = NULL;
+    code_hdr->md5_ptr = NULL;
 
     /*
      * Make stubs for all functions.
      */
 
-    ptrs = code + MI_FUNCTIONS;
-    fp = code + ci;
+    fp = code_base = (BeamInstr*) &code_hdr->functions[n+1];
     for (i = 0; i < n; i++) {
 	Eterm* listp;
 	Eterm tuple;
@@ -6312,7 +6323,7 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
 	 * Set the pointer and make the stub. Put a return instruction
 	 * as the body until we know what kind of trap we should put there.
 	 */
-	ptrs[i] = (BeamInstr) fp;
+	code_hdr->functions[i] = fp;
 #ifdef HIPE
 	op = (Eterm) BeamOpCode(op_hipe_trap_call); /* Might be changed later. */
 #else
@@ -6325,7 +6336,7 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
      * Insert the last pointer and the int_code_end instruction.
      */
 
-    ptrs[i] = (BeamInstr) fp;
+    code_hdr->functions[i] = fp;
     *fp++ = (BeamInstr) BeamOp(op_int_code_end);
 
     /*
@@ -6334,16 +6345,16 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
 
     info = (byte *) fp;
     info = stub_copy_info(stp, ATTR_CHUNK, info,
-			  code+MI_ATTR_PTR,
-			  code+MI_ATTR_SIZE,
-			  code+MI_ATTR_SIZE_ON_HEAP);
+			  &code_hdr->attr_ptr,
+			  &code_hdr->attr_size,
+			  &code_hdr->attr_size_on_heap);
     if (info == NULL) {
 	goto error;
     }
     info = stub_copy_info(stp, COMPILE_CHUNK, info,
-			  code+MI_COMPILE_PTR,
-			  code+MI_COMPILE_SIZE,
-			  code+MI_COMPILE_SIZE_ON_HEAP);
+			  &code_hdr->compile_ptr,
+			  &code_hdr->compile_size,
+			  &code_hdr->compile_size_on_heap);
     if (info == NULL) {
 	goto error;
     }
@@ -6352,7 +6363,7 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
       byte *md5 = NULL;
       if ((md5 = erts_get_aligned_binary_bytes(MD5Bin, &tmp)) != NULL) {
         sys_memcpy(info, md5, MD5_SIZE);
-        code[MI_MD5_PTR] = (BeamInstr) info;
+        code_hdr->md5_ptr = info;
       }
       erts_free_aligned_binary_bytes(tmp);
     }
@@ -6361,7 +6372,7 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
      * Insert the module in the module table.
      */
 
-    rval = insert_new_code(p, 0, p->group_leader, Mod, code, code_size);
+    rval = insert_new_code(p, 0, p->group_leader, Mod, code_hdr, code_size);
     if (rval != NIL) {
 	goto error;
     }
@@ -6370,7 +6381,7 @@ erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info)
      * Export all stub functions and insert the correct type of HiPE trap.
      */
 
-    fp = code + ci;
+    fp = code_base;
     for (i = 0; i < n; i++) {
 	stub_final_touch(stp, fp);
 	fp += WORDS_PER_FUNCTION;
diff --git a/erts/emulator/beam/beam_load.h b/erts/emulator/beam/beam_load.h
index eedb5ee4cd..22ab71c868 100644
--- a/erts/emulator/beam/beam_load.h
+++ b/erts/emulator/beam/beam_load.h
@@ -24,7 +24,6 @@
 #include "beam_opcodes.h"
 #include "erl_process.h"
 
-int erts_is_module_native(BeamInstr* code);
 Eterm beam_make_current_old(Process *c_p, ErtsProcLocks c_p_locks,
 			    Eterm module);
 
@@ -61,72 +60,81 @@ extern BeamInstr* em_call_nif;
 
 /* Total code size in bytes */
 extern Uint erts_total_code_size;
-/*
- * Index into start of code chunks which contains additional information
- * about the loaded module.
- *
- * First number of functions.
- */
-
-#define MI_NUM_FUNCTIONS     0
-
-/*
- * The attributes retrieved by Mod:module_info(attributes).
- */
-
-#define MI_ATTR_PTR          1
-#define MI_ATTR_SIZE	     2
-#define MI_ATTR_SIZE_ON_HEAP 3
-
-/*
- * The compilation information retrieved by Mod:module_info(compile).
- */
-
-#define MI_COMPILE_PTR          4
-#define MI_COMPILE_SIZE         5
-#define MI_COMPILE_SIZE_ON_HEAP 6
-
-/*
- * Literal area (constant pool).
- */
-#define MI_LITERALS_START	7
-#define MI_LITERALS_END		8
-#define MI_LITERALS_OFF_HEAP	9
-
-/*
- * Pointer to the on_load function (or NULL if none).
- */
-#define MI_ON_LOAD_FUNCTION_PTR 10
-
-/*
- * Pointer to the line table (or NULL if none).
- */
-#define MI_LINE_TABLE 11
 
-/*
- * Pointer to the module MD5 sum (16 bytes)
- */
-#define MI_MD5_PTR 12
+typedef struct BeamCodeLineTab_ BeamCodeLineTab;
 
 /*
- * Start of function pointer table.  This table contains pointers to
- * all functions in the module plus an additional pointer just beyond
- * the end of the last function.
- *
- * The actual loaded code (for the first function) start just beyond
- * this table.
+ * Header of code chunks which contains additional information
+ * about the loaded module.
  */
-
-#define MI_FUNCTIONS         13
+typedef struct beam_code_header {
+    /*
+     * Number of functions.
+     */
+    UWord num_functions;
+
+    /*
+     * The attributes retrieved by Mod:module_info(attributes).
+     */
+    byte* attr_ptr;
+    UWord attr_size;
+    UWord attr_size_on_heap;
+
+    /*
+     * The compilation information retrieved by Mod:module_info(compile).
+     */
+    byte* compile_ptr;
+    UWord compile_size;
+    UWord compile_size_on_heap;
+
+    /*
+     * Literal area (constant pool).
+     */
+    Eterm* literals_start;
+    Eterm* literals_end;
+    struct erl_off_heap_header* literals_off_heap;
+
+    /*
+     * Pointer to the on_load function (or NULL if none).
+     */
+    BeamInstr* on_load_function_ptr;
+
+    /*
+     * Pointer to the line table (or NULL if none).
+     */
+    BeamCodeLineTab* line_table;
+
+    /*
+     * Pointer to the module MD5 sum (16 bytes)
+     */
+    byte* md5_ptr;
+
+    /*
+     * Start of function pointer table.  This table contains pointers to
+     * all functions in the module plus an additional pointer just beyond
+     * the end of the last function.
+     *
+     * The actual loaded code (for the first function) start just beyond
+     * this table.
+     */
+    BeamInstr* functions[1];
+
+}BeamCodeHeader;
+
+int erts_is_module_native(BeamCodeHeader* code);
 
 /*
  * Layout of the line table.
  */
-
-#define MI_LINE_FNAME_PTR 0
-#define MI_LINE_LOC_TAB 1
-#define MI_LINE_LOC_SIZE 2
-#define MI_LINE_FUNC_TAB 3
+struct BeamCodeLineTab_ {
+    Eterm* fname_ptr;
+    int loc_size;
+    union {
+        Uint16* p2;
+        Uint32* p4;
+    }loc_tab;
+    const BeamInstr** func_tab[1];
+};
 
 #define LINE_INVALID_LOCATION (0)
 
diff --git a/erts/emulator/beam/beam_ranges.c b/erts/emulator/beam/beam_ranges.c
index 19079ba150..5a2b66727a 100644
--- a/erts/emulator/beam/beam_ranges.c
+++ b/erts/emulator/beam/beam_ranges.c
@@ -37,8 +37,8 @@ typedef struct {
 #define RANGE_END(R) ((BeamInstr*)erts_smp_atomic_read_nob(&(R)->end))
 
 static Range* find_range(BeamInstr* pc);
-static void lookup_loc(FunctionInfo* fi, BeamInstr* pc,
-		       BeamInstr* modp, int idx);
+static void lookup_loc(FunctionInfo* fi, const BeamInstr* pc,
+		       BeamCodeHeader*, int idx);
 
 /*
  * The following variables keep a sorted list of address ranges for
@@ -241,6 +241,7 @@ erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info)
     BeamInstr** high;
     BeamInstr** mid;
     Range* rp;
+    BeamCodeHeader* hdr;
 
     fi->current = NULL;
     fi->needed = 5;
@@ -249,9 +250,10 @@ erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info)
     if (rp == 0) {
 	return;
     }
+    hdr = (BeamCodeHeader*) rp->start;
 
-    low = (BeamInstr **) (rp->start + MI_FUNCTIONS);
-    high = low + rp->start[MI_NUM_FUNCTIONS];
+    low = hdr->functions;
+    high = low + hdr->num_functions;
     while (low < high) {
 	mid = low + (high-low) / 2;
 	if (pc < mid[0]) {
@@ -259,10 +261,9 @@ erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info)
 	} else if (pc < mid[1]) {
 	    fi->current = mid[0]+2;
 	    if (full_info) {
-		BeamInstr** fp = (BeamInstr **) (rp->start +
-						 MI_FUNCTIONS);
+		BeamInstr** fp = hdr->functions;
 		int idx = mid - fp;
-		lookup_loc(fi, pc, rp->start, idx);
+		lookup_loc(fi, pc, hdr, idx);
 	    }
 	    return;
 	} else {
@@ -295,39 +296,34 @@ find_range(BeamInstr* pc)
 }
 
 static void
-lookup_loc(FunctionInfo* fi, BeamInstr* orig_pc, BeamInstr* modp, int idx)
+lookup_loc(FunctionInfo* fi, const BeamInstr* pc,
+           BeamCodeHeader* code_hdr, int idx)
 {
-    Eterm* line = (Eterm *) modp[MI_LINE_TABLE];
-    Eterm* low;
-    Eterm* high;
-    Eterm* mid;
-    Eterm pc;
+    BeamCodeLineTab* lt = code_hdr->line_table;
+    const BeamInstr** low;
+    const BeamInstr** high;
+    const BeamInstr** mid;
 
-    if (line == 0) {
+    if (lt == NULL) {
 	return;
     }
 
-    pc = (Eterm) (BeamInstr) orig_pc;
-    fi->fname_ptr = (Eterm *) (BeamInstr) line[MI_LINE_FNAME_PTR];
-    low = (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB+idx];
-    high = (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB+idx+1];
+    fi->fname_ptr = lt->fname_ptr;
+    low = lt->func_tab[idx];
+    high = lt->func_tab[idx+1];
     while (high > low) {
 	mid = low + (high-low) / 2;
 	if (pc < mid[0]) {
 	    high = mid;
 	} else if (pc < mid[1]) {
 	    int file;
-	    int index = mid - (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB];
+	    int index = mid - lt->func_tab[0];
 
-	    if (line[MI_LINE_LOC_SIZE] == 2) {
-		Uint16* loc_table =
-		    (Uint16 *) (BeamInstr) line[MI_LINE_LOC_TAB];
-		fi->loc = loc_table[index];
+	    if (lt->loc_size == 2) {
+		fi->loc = lt->loc_tab.p2[index];
 	    } else {
-		Uint32* loc_table =
-		    (Uint32 *) (BeamInstr) line[MI_LINE_LOC_TAB];
-		ASSERT(line[MI_LINE_LOC_SIZE] == 4);
-		fi->loc = loc_table[index];
+		ASSERT(lt->loc_size == 4);
+		fi->loc = lt->loc_tab.p4[index];
 	    }
 	    if (fi->loc == LINE_INVALID_LOCATION) {
 		return;
diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 4ce9d24479..d90aed203e 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -381,7 +381,7 @@ loaded(int to, void *to_arg)
     int i;
     int old = 0;
     int cur = 0;
-    BeamInstr* code;
+    BeamCodeHeader* code;
     Module* modp;
     ErtsCodeIndex code_ix;
 
@@ -439,30 +439,30 @@ loaded(int to, void *to_arg)
 		erts_print(to, to_arg, "\n");
 		erts_print(to, to_arg, "Current size: %d\n",
 			   modp->curr.code_length);
-		code = modp->curr.code;
-		if (code != NULL && code[MI_ATTR_PTR]) {
+		code = modp->curr.code_hdr;
+		if (code != NULL && code->attr_ptr) {
 		    erts_print(to, to_arg, "Current attributes: ");
-		    dump_attributes(to, to_arg, (byte *) code[MI_ATTR_PTR],
-				    code[MI_ATTR_SIZE]);
+		    dump_attributes(to, to_arg, code->attr_ptr,
+				    code->attr_size);
 		}
-		if (code != NULL && code[MI_COMPILE_PTR]) {
+		if (code != NULL && code->compile_ptr) {
 		    erts_print(to, to_arg, "Current compilation info: ");
-		    dump_attributes(to, to_arg, (byte *) code[MI_COMPILE_PTR],
-				    code[MI_COMPILE_SIZE]);
+		    dump_attributes(to, to_arg, code->compile_ptr,
+				    code->compile_size);
 		}
 
 		if (modp->old.code_length != 0) {
 		    erts_print(to, to_arg, "Old size: %d\n", modp->old.code_length);
-		    code = modp->old.code;
-		    if (code[MI_ATTR_PTR]) {
+		    code = modp->old.code_hdr;
+		    if (code->attr_ptr) {
 			erts_print(to, to_arg, "Old attributes: ");
-			dump_attributes(to, to_arg, (byte *) code[MI_ATTR_PTR],
-					code[MI_ATTR_SIZE]);
+			dump_attributes(to, to_arg, code->attr_ptr,
+					code->attr_size);
 		    }
-		    if (code[MI_COMPILE_PTR]) {
+		    if (code->compile_ptr) {
 			erts_print(to, to_arg, "Old compilation info: ");
-			dump_attributes(to, to_arg, (byte *) code[MI_COMPILE_PTR],
-					code[MI_COMPILE_SIZE]);
+			dump_attributes(to, to_arg, code->compile_ptr,
+					code->compile_size);
 		    }
 		}
 	    }
diff --git a/erts/emulator/beam/erl_alloc.c b/erts/emulator/beam/erl_alloc.c
index d68f22d573..3e300f88ea 100644
--- a/erts/emulator/beam/erl_alloc.c
+++ b/erts/emulator/beam/erl_alloc.c
@@ -130,6 +130,7 @@ static ErtsAllocatorState_t binary_alloc_state;
 static ErtsAllocatorState_t ets_alloc_state;
 static ErtsAllocatorState_t driver_alloc_state;
 static ErtsAllocatorState_t fix_alloc_state;
+static ErtsAllocatorState_t literal_alloc_state;
 
 typedef struct {
     erts_smp_atomic32_t refc;
@@ -211,6 +212,7 @@ typedef struct {
     struct au_init ets_alloc;
     struct au_init driver_alloc;
     struct au_init fix_alloc;
+    struct au_init literal_alloc;
 } erts_alc_hndl_args_init_t;
 
 #define ERTS_AU_INIT__ {0, 0, 1, GOODFIT, DEFAULT_ALLCTR_INIT, {1,1,1,1}}
@@ -272,9 +274,9 @@ set_default_ll_alloc_opts(struct au_init *ip)
     ip->init.util.name_prefix	= "ll_";
     ip->init.util.alloc_no	= ERTS_ALC_A_LONG_LIVED;
 #ifndef SMALL_MEMORY
-    ip->init.util.mmbcs 	= 2*1024*1024 - 40; /* Main carrier size */
+    ip->init.util.mmbcs 	= 2*1024*1024; /* Main carrier size */
 #else
-    ip->init.util.mmbcs 	= 1*1024*1024 - 40; /* Main carrier size */
+    ip->init.util.mmbcs 	= 1*1024*1024; /* Main carrier size */
 #endif
     ip->init.util.ts 		= ERTS_ALC_MTA_LONG_LIVED;
     ip->init.util.asbcst	= 0;
@@ -285,6 +287,51 @@ set_default_ll_alloc_opts(struct au_init *ip)
 }
 
 static void
+set_default_literal_alloc_opts(struct au_init *ip)
+{
+    SET_DEFAULT_ALLOC_OPTS(ip);
+    ip->enable			= AU_ALLOC_DEFAULT_ENABLE(1);
+    ip->thr_spec		= 0;
+    ip->atype			= BESTFIT;
+    ip->init.bf.ao		= 1;
+    ip->init.util.ramv		= 0;
+    ip->init.util.mmsbc		= 0;
+    ip->init.util.sbct		= ~((UWord) 0);
+    ip->init.util.name_prefix	= "literal_";
+    ip->init.util.alloc_no	= ERTS_ALC_A_LITERAL;
+#ifndef SMALL_MEMORY
+    ip->init.util.mmbcs 	= 2*1024*1024; /* Main carrier size */
+#else
+    ip->init.util.mmbcs 	= 1*1024*1024; /* Main carrier size */
+#endif
+    ip->init.util.ts 		= ERTS_ALC_MTA_LITERAL;
+    ip->init.util.asbcst	= 0;
+    ip->init.util.rsbcst	= 0;
+    ip->init.util.rsbcmt	= 0;
+    ip->init.util.rmbcmt	= 0;
+    ip->init.util.acul		= 0;
+
+#if defined(ARCH_32)
+# if HAVE_ERTS_MSEG
+    ip->init.util.mseg_alloc   = &erts_alcu_literal_32_mseg_alloc;
+    ip->init.util.mseg_realloc = &erts_alcu_literal_32_mseg_realloc;
+    ip->init.util.mseg_dealloc = &erts_alcu_literal_32_mseg_dealloc;
+# endif
+    ip->init.util.sys_alloc    = &erts_alcu_literal_32_sys_alloc;
+    ip->init.util.sys_realloc  = &erts_alcu_literal_32_sys_realloc;
+    ip->init.util.sys_dealloc  = &erts_alcu_literal_32_sys_dealloc;
+#elif defined(ARCH_64)
+# ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
+    ip->init.util.mseg_alloc    = &erts_alcu_literal_64_mseg_alloc;
+    ip->init.util.mseg_realloc  = &erts_alcu_literal_64_mseg_realloc;
+    ip->init.util.mseg_dealloc  = &erts_alcu_literal_64_mseg_dealloc;
+# endif
+#else
+# error Unknown architecture
+#endif
+}
+
+static void
 set_default_temp_alloc_opts(struct au_init *ip)
 {
     SET_DEFAULT_ALLOC_OPTS(ip);
@@ -577,6 +624,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     set_default_driver_alloc_opts(&init.driver_alloc);
     set_default_fix_alloc_opts(&init.fix_alloc,
 			       fix_type_sizes);
+    set_default_literal_alloc_opts(&init.literal_alloc);
 
     if (argc && argv)
 	handle_args(argc, argv, &init);
@@ -604,6 +652,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     init.ets_alloc.thr_spec = 0;
     init.driver_alloc.thr_spec = 0;
     init.fix_alloc.thr_spec = 0;
+    init.literal_alloc.thr_spec = 0;
 #endif
 
     /* Make adjustments for carrier migration support */
@@ -616,6 +665,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     adjust_carrier_migration_support(&init.ets_alloc);
     adjust_carrier_migration_support(&init.driver_alloc);
     adjust_carrier_migration_support(&init.fix_alloc);
+    adjust_carrier_migration_support(&init.literal_alloc);
 
     if (init.erts_alloc_config) {
 	/* Adjust flags that erts_alloc_config won't like */
@@ -630,6 +680,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 	init.ets_alloc.thr_spec = 0;
 	init.driver_alloc.thr_spec = 0;
 	init.fix_alloc.thr_spec = 0;
+        init.literal_alloc.thr_spec = 0;
 
 	/* No carrier migration */
 	init.temp_alloc.init.util.acul = 0;
@@ -641,6 +692,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 	init.ets_alloc.init.util.acul = 0;
 	init.driver_alloc.init.util.acul = 0;
 	init.fix_alloc.init.util.acul = 0;
+        init.literal_alloc.init.util.acul = 0;
     }
 
 #ifdef ERTS_SMP
@@ -657,6 +709,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     adjust_tpref(&init.ets_alloc, erts_no_schedulers);
     adjust_tpref(&init.driver_alloc, erts_no_schedulers);
     adjust_tpref(&init.fix_alloc, erts_no_schedulers);
+    adjust_tpref(&init.literal_alloc, erts_no_schedulers);
 
 #else
     /* No thread specific if not smp */
@@ -675,6 +728,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     refuse_af_strategy(&init.ets_alloc);
     refuse_af_strategy(&init.driver_alloc);
     refuse_af_strategy(&init.fix_alloc);
+    refuse_af_strategy(&init.literal_alloc);
 
 #ifdef ERTS_SMP 
     if (!init.temp_alloc.thr_spec)
@@ -685,6 +739,9 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 #if HAVE_ERTS_MSEG
     init.mseg.nos = erts_no_schedulers;
     erts_mseg_init(&init.mseg);
+# if defined(ARCH_64) && defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+    erts_mmap_init(&erts_literal_mmapper, &init.mseg.literal_mmap);
+# endif
 #endif
 
     erts_alcu_init(&init.alloc_util);
@@ -718,6 +775,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     set_au_allocator(ERTS_ALC_A_ETS, &init.ets_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_DRIVER, &init.driver_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_FIXED_SIZE, &init.fix_alloc, ncpu);
+    set_au_allocator(ERTS_ALC_A_LITERAL, &init.literal_alloc, ncpu);
 
     for (i = ERTS_ALC_A_MIN; i <= ERTS_ALC_A_MAX; i++) {
 	if (!erts_allctrs[i].alloc)
@@ -770,6 +828,9 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     start_au_allocator(ERTS_ALC_A_FIXED_SIZE,
 		       &init.fix_alloc,
 		       &fix_alloc_state);
+    start_au_allocator(ERTS_ALC_A_LITERAL,
+                       &init.literal_alloc,
+                       &literal_alloc_state);
 
     erts_mtrace_install_wrapper_functions();
     extra_block_size += erts_instr_init(init.instr.stat, init.instr.map);
@@ -952,7 +1013,7 @@ start_au_allocator(ErtsAlcType_t alctr_n,
     }
 
     for (i = 0; i < size; i++) {
-	void *as;
+	Allctr_t *as;
 	atype = init->atype;
 
 	if (!init->thr_spec)
@@ -989,22 +1050,22 @@ start_au_allocator(ErtsAlcType_t alctr_n,
 
 	switch (atype) {
 	case GOODFIT:
-	    as = (void *) erts_gfalc_start((GFAllctr_t *) as0,
+	    as = erts_gfalc_start((GFAllctr_t *) as0,
 					   &init->init.gf,
 					   &init->init.util);
 	    break;
 	case BESTFIT:
-	    as = (void *) erts_bfalc_start((BFAllctr_t *) as0,
+	    as = erts_bfalc_start((BFAllctr_t *) as0,
 					   &init->init.bf,
 					   &init->init.util);
 	    break;
 	case AFIT:
-	    as = (void *) erts_afalc_start((AFAllctr_t *) as0,
+	    as = erts_afalc_start((AFAllctr_t *) as0,
 					   &init->init.af,
 					   &init->init.util);
 	    break;
     	case AOFIRSTFIT:
-	    as = (void *) erts_aoffalc_start((AOFFAllctr_t *) as0,
+	    as = erts_aoffalc_start((AOFFAllctr_t *) as0,
 					     &init->init.aoff,
 					     &init->init.util);
 	    break;
@@ -1406,25 +1467,25 @@ handle_args(int *argc, char **argv, erts_alc_hndl_args_init_t *init)
 		    }
 		    else if (has_prefix("scs", argv[i]+3)) {
 #if HAVE_ERTS_MSEG
-			init->mseg.mmap.scs =
+			init->mseg.dflt_mmap.scs =
 #endif
 			    get_mb_value(argv[i]+6, argv, &i);
 		    }
 		    else if (has_prefix("sco", argv[i]+3)) {
 #if HAVE_ERTS_MSEG
-			init->mseg.mmap.sco =
+			init->mseg.dflt_mmap.sco =
 #endif
 			    get_bool_value(argv[i]+6, argv, &i);
 		    }
 		    else if (has_prefix("scrpm", argv[i]+3)) {
 #if HAVE_ERTS_MSEG
-			init->mseg.mmap.scrpm =
+			init->mseg.dflt_mmap.scrpm =
 #endif
 			    get_bool_value(argv[i]+8, argv, &i);
 		    }
 		    else if (has_prefix("scrfsd", argv[i]+3)) {
 #if HAVE_ERTS_MSEG
-			init->mseg.mmap.scrfsd =
+			init->mseg.dflt_mmap.scrfsd =
 #endif
 			    get_amount_value(argv[i]+9, argv, &i);
 		    }
@@ -2629,7 +2690,7 @@ erts_allocator_info(int to, void *arg)
 	    erts_mseg_info(i, &to, arg, 0, NULL, NULL);
 	}
 	erts_print(to, arg, "=allocator:mseg_alloc.erts_mmap\n");
-	erts_mmap_info(&to, arg, NULL, NULL, &emis);
+	erts_mmap_info(&erts_dflt_mmapper, &to, arg, NULL, NULL, &emis);
     }
 #endif
 
@@ -2981,7 +3042,8 @@ reply_alloc_info(void *vair)
 
 		    ai_list = erts_bld_cons(hpp, szp,
 					    ainfo, ai_list);
-		    ainfo = (air->only_sz ? NIL : erts_mmap_info(NULL, NULL, hpp, szp, &emis));
+		    ainfo = (air->only_sz ? NIL :
+                             erts_mmap_info(&erts_dflt_mmapper, NULL, NULL, hpp, szp, &emis));
 		    ainfo = erts_bld_tuple3(hpp, szp,
                                             alloc_atom,
                                             erts_bld_atom(hpp,szp,"erts_mmap"),
diff --git a/erts/emulator/beam/erl_alloc.h b/erts/emulator/beam/erl_alloc.h
index f540bae20d..a0d8561e84 100644
--- a/erts/emulator/beam/erl_alloc.h
+++ b/erts/emulator/beam/erl_alloc.h
@@ -30,6 +30,7 @@
 #ifdef USE_THREADS
 #include "erl_threads.h"
 #endif
+#include "erl_mmap.h"
 
 #ifdef DEBUG
 #  undef ERTS_ALC_WANT_INLINE
@@ -204,6 +205,7 @@ void erts_free(ErtsAlcType_t type, void *ptr);
 void *erts_alloc_fnf(ErtsAlcType_t type, Uint size);
 void *erts_realloc_fnf(ErtsAlcType_t type, void *ptr, Uint size);
 int erts_is_allctr_wrapper_prelocked(void);
+int erts_is_literal(void* ptr);
 
 #endif /* #if !ERTS_ALC_DO_INLINE */
 
@@ -281,6 +283,28 @@ int erts_is_allctr_wrapper_prelocked(void)
 	&& !!erts_tsd_get(erts_allctr_prelock_tsd_key);  /* by me  */
 }
 
+ERTS_ALC_INLINE
+int erts_is_literal(void* ptr)
+{
+#if defined(ARCH_32)
+    Uint ix = (UWord)ptr >> ERTS_MMAP_SUPERALIGNED_BITS;
+
+    return erts_literal_vspace_map[ix / ERTS_VSPACE_WORD_BITS]
+                  & ((UWord)1 << (ix % ERTS_VSPACE_WORD_BITS));
+
+#elif defined(ARCH_64)
+# if defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+    extern char* erts_literals_start;
+    extern UWord erts_literals_size;
+    return ErtsInArea(ptr, erts_literals_start, erts_literals_size);
+# else
+#  error Do the tag thing
+# endif
+#else
+# error No ARCH_xx
+#endif
+}
+
 #endif /* #if ERTS_ALC_DO_INLINE || defined(ERTS_ALC_INTERNAL__) */
 
 #define ERTS_ALC_GET_THR_IX() ((int) erts_get_scheduler_id())
diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index 4804fb407d..7d519c1be4 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -86,6 +86,7 @@ allocator	LONG_LIVED	true		ll_alloc
 allocator	EHEAP		true		eheap_alloc
 allocator	ETS		true		ets_alloc
 allocator	FIXED_SIZE	true		fix_alloc
+allocator	LITERAL 	true		literal_alloc
 
 +else # Non smp build
 
@@ -96,6 +97,7 @@ allocator	LONG_LIVED	false		ll_alloc
 allocator	EHEAP		false		eheap_alloc
 allocator	ETS		false		ets_alloc
 allocator	FIXED_SIZE	false		fix_alloc
+allocator	LITERAL 	false		literal_alloc
 
 +endif
 
@@ -343,6 +345,7 @@ type	DDLL_PROCESS	STANDARD	SYSTEM		ddll_processes
 type	MONITOR_LH	STANDARD	PROCESSES	monitor_lh
 type	NLINK_LH	STANDARD	PROCESSES	nlink_lh
 type	CODE		LONG_LIVED	CODE		code
+type	LITERAL		LITERAL 	CODE		literal
 type	DB_HEIR_DATA	STANDARD	ETS		db_heir_data
 type	DB_MS_PSDO_PROC	LONG_LIVED	ETS		db_match_pseudo_proc
 type	SCHDLR_DATA	LONG_LIVED	SYSTEM		scheduler_data
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index db4c30b9eb..f34916f1ab 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -751,12 +751,77 @@ internal_free(void *ptr)
 
 #endif
 
+#ifdef ARCH_32
+
+/*
+ * Bit vector for the entire 32-bit virtual address space
+ * with one bit for each super aligned memory segment.
+ */
+
+#define VSPACE_MAP_BITS  (1 << (32 - ERTS_MMAP_SUPERALIGNED_BITS))
+#define VSPACE_MAP_SZ    (VSPACE_MAP_BITS / ERTS_VSPACE_WORD_BITS)
+
+static ERTS_INLINE void set_bit(UWord* map, Uint ix)
+{
+    ASSERT(ix / ERTS_VSPACE_WORD_BITS < VSPACE_MAP_SZ);
+    map[ix / ERTS_VSPACE_WORD_BITS]
+        |= ((UWord)1 << (ix % ERTS_VSPACE_WORD_BITS));
+}
+
+static ERTS_INLINE void clr_bit(UWord* map, Uint ix)
+{
+    ASSERT(ix / ERTS_VSPACE_WORD_BITS < VSPACE_MAP_SZ);
+    map[ix / ERTS_VSPACE_WORD_BITS]
+        &= ~((UWord)1 << (ix % ERTS_VSPACE_WORD_BITS));
+}
+
+static ERTS_INLINE int is_bit_set(UWord* map, Uint ix)
+{
+    ASSERT(ix / ERTS_VSPACE_WORD_BITS < VSPACE_MAP_SZ);
+    return map[ix / ERTS_VSPACE_WORD_BITS]
+        & ((UWord)1 << (ix % ERTS_VSPACE_WORD_BITS));
+}
+
+UWord erts_literal_vspace_map[VSPACE_MAP_SZ];
+
+static void set_literal_range(void* start, Uint size)
+{
+    Uint ix = (UWord)start >> ERTS_MMAP_SUPERALIGNED_BITS;
+    Uint n = size >> ERTS_MMAP_SUPERALIGNED_BITS;
+
+    ASSERT(!((UWord)start & ERTS_INV_SUPERALIGNED_MASK));
+    ASSERT(!((UWord)size & ERTS_INV_SUPERALIGNED_MASK));
+    ASSERT(n);
+    while (n--) {
+        ASSERT(!is_bit_set(erts_literal_vspace_map, ix));
+        set_bit(erts_literal_vspace_map, ix);
+        ix++;
+    }
+}
+
+static void clear_literal_range(void* start, Uint size)
+{
+    Uint ix = (UWord)start >> ERTS_MMAP_SUPERALIGNED_BITS;
+    Uint n = size >> ERTS_MMAP_SUPERALIGNED_BITS;
+
+    ASSERT(!((UWord)start & ERTS_INV_SUPERALIGNED_MASK));
+    ASSERT(!((UWord)size & ERTS_INV_SUPERALIGNED_MASK));
+    ASSERT(n);
+    while (n--) {
+        ASSERT(is_bit_set(erts_literal_vspace_map, ix));
+        clr_bit(erts_literal_vspace_map, ix);
+        ix++;
+    }
+}
+
+#endif /* ARCH_32 */
+
 /* mseg ... */
 
 #if HAVE_ERTS_MSEG
 
-static ERTS_INLINE void *
-alcu_mseg_alloc(Allctr_t *allctr, Uint *size_p, Uint flags)
+void*
+erts_alcu_mseg_alloc(Allctr_t *allctr, Uint *size_p, Uint flags)
 {
     void *res;
     UWord size = (UWord) *size_p;
@@ -766,8 +831,9 @@ alcu_mseg_alloc(Allctr_t *allctr, Uint *size_p, Uint flags)
     return res;
 }
 
-static ERTS_INLINE void *
-alcu_mseg_realloc(Allctr_t *allctr, void *seg, Uint old_size, Uint *new_size_p)
+void*
+erts_alcu_mseg_realloc(Allctr_t *allctr, void *seg,
+                       Uint old_size, Uint *new_size_p)
 {
     void *res;
     UWord new_size = (UWord) *new_size_p;
@@ -778,17 +844,103 @@ alcu_mseg_realloc(Allctr_t *allctr, void *seg, Uint old_size, Uint *new_size_p)
     return res;
 }
 
-static ERTS_INLINE void
-alcu_mseg_dealloc(Allctr_t *allctr, void *seg, Uint size, Uint flags)
+void
+erts_alcu_mseg_dealloc(Allctr_t *allctr, void *seg, Uint size, Uint flags)
 {
     erts_mseg_dealloc_opt(allctr->alloc_no, seg, (UWord) size, flags, &allctr->mseg_opt);
     INC_CC(allctr->calls.mseg_dealloc);
 }
 
-#endif
 
-static ERTS_INLINE void *
-alcu_sys_alloc(Allctr_t *allctr, Uint size, int superalign)
+#if defined(ARCH_32)
+
+void*
+erts_alcu_literal_32_mseg_alloc(Allctr_t *allctr, Uint *size_p, Uint flags)
+{
+    void* res;
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
+                   && !allctr->t && allctr->thread_safe);
+
+    res = erts_alcu_mseg_alloc(allctr, size_p, flags);
+    if (res)
+        set_literal_range(res, *size_p);
+    return res;
+}
+
+void*
+erts_alcu_literal_32_mseg_realloc(Allctr_t *allctr, void *seg,
+                               Uint old_size, Uint *new_size_p)
+{
+    void* res;
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
+                   && !allctr->t && allctr->thread_safe);
+
+    if (seg && old_size)
+        clear_literal_range(seg, old_size);
+    res = erts_alcu_mseg_realloc(allctr, seg, old_size, new_size_p);
+    if (res)
+        set_literal_range(res, *new_size_p);
+    return res;
+}
+
+void
+erts_alcu_literal_32_mseg_dealloc(Allctr_t *allctr, void *seg, Uint size,
+                               Uint flags)
+{
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
+                   && !allctr->t && allctr->thread_safe);
+
+    erts_alcu_mseg_dealloc(allctr, seg, size, flags);
+
+    clear_literal_range(seg, size);
+}
+
+#elif defined(ARCH_64) && defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+
+void*
+erts_alcu_literal_64_mseg_alloc(Allctr_t *allctr, Uint *size_p, Uint flags)
+{
+    void* res;
+    UWord size = (UWord) *size_p;
+    Uint32 mmap_flags = ERTS_MMAPFLG_SUPERCARRIER_ONLY;
+    if (flags & ERTS_MSEG_FLG_2POW)
+        mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
+
+    res = erts_mmap(&erts_literal_mmapper, mmap_flags, &size);
+    *size_p = (Uint)size;
+    INC_CC(allctr->calls.mseg_alloc);
+    return res;
+}
+
+void*
+erts_alcu_literal_64_mseg_realloc(Allctr_t *allctr, void *seg,
+                               Uint old_size, Uint *new_size_p)
+{
+    void *res;
+    UWord new_size = (UWord) *new_size_p;
+    res = erts_mremap(&erts_literal_mmapper, ERTS_MSEG_FLG_NONE, seg, old_size, &new_size);
+    *new_size_p = (Uint) new_size;
+    INC_CC(allctr->calls.mseg_realloc);
+    return res;
+}
+
+void
+erts_alcu_literal_64_mseg_dealloc(Allctr_t *allctr, void *seg, Uint size,
+                               Uint flags)
+{
+    Uint32 mmap_flags = ERTS_MMAPFLG_SUPERCARRIER_ONLY;
+    if (flags & ERTS_MSEG_FLG_2POW)
+        mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
+
+    erts_munmap(&erts_literal_mmapper, mmap_flags, seg, (UWord)size);
+    INC_CC(allctr->calls.mseg_dealloc);
+}
+#endif /* ARCH_64 && ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION */
+
+#endif /* HAVE_ERTS_MSEG */
+
+void*
+erts_alcu_sys_alloc(Allctr_t *allctr, Uint size, int superalign)
 {
     void *res;
 #if ERTS_SA_MB_CARRIERS && ERTS_HAVE_ERTS_SYS_ALIGNED_ALLOC
@@ -803,8 +955,8 @@ alcu_sys_alloc(Allctr_t *allctr, Uint size, int superalign)
     return res;
 }
 
-static ERTS_INLINE void *
-alcu_sys_realloc(Allctr_t *allctr, void *ptr, Uint size, Uint old_size, int superalign)
+void*
+erts_alcu_sys_realloc(Allctr_t *allctr, void *ptr, Uint size, Uint old_size, int superalign)
 {
     void *res;
 
@@ -824,8 +976,8 @@ alcu_sys_realloc(Allctr_t *allctr, void *ptr, Uint size, Uint old_size, int supe
     return res;
 }
 
-static ERTS_INLINE void
-alcu_sys_free(Allctr_t *allctr, void *ptr, int superalign)
+void
+erts_alcu_sys_dealloc(Allctr_t *allctr, void *ptr, Uint size, int superalign)
 {
 #if ERTS_SA_MB_CARRIERS && ERTS_HAVE_ERTS_SYS_ALIGNED_ALLOC
     if (superalign)
@@ -838,6 +990,49 @@ alcu_sys_free(Allctr_t *allctr, void *ptr, int superalign)
 	erts_mtrace_crr_free(allctr->alloc_no, ERTS_ALC_A_SYSTEM, ptr);
 }
 
+#ifdef ARCH_32
+
+void*
+erts_alcu_literal_32_sys_alloc(Allctr_t *allctr, Uint size, int superalign)
+{
+    void* res;
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
+                   && !allctr->t && allctr->thread_safe);
+
+    res = erts_alcu_sys_alloc(allctr, size, 1);
+    if (res)
+        set_literal_range(res, size);
+    return res;
+}
+
+void*
+erts_alcu_literal_32_sys_realloc(Allctr_t *allctr, void *ptr, Uint size, Uint old_size, int superalign)
+{
+    void* res;
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
+                   && !allctr->t && allctr->thread_safe);
+
+    if (ptr && old_size)
+        clear_literal_range(ptr, old_size);
+    res = erts_alcu_sys_realloc(allctr, ptr, size, old_size, 1);
+    if (res)
+        set_literal_range(res, size);
+    return res;
+}
+
+void
+erts_alcu_literal_32_sys_dealloc(Allctr_t *allctr, void *ptr, Uint size, int superalign)
+{
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
+                   && !allctr->t && allctr->thread_safe);
+
+    erts_alcu_sys_dealloc(allctr, ptr, size, 1);
+
+    clear_literal_range(ptr, size);
+}
+
+#endif /* ARCH_32 */
+
 static Uint
 get_next_mbc_size(Allctr_t *allctr)
 {
@@ -3519,6 +3714,8 @@ create_carrier(Allctr_t *allctr, Uint umem_sz, UWord flags)
 	return NULL;
 #endif
     }
+    flags |= allctr->crr_set_flgs;
+    flags &= ~allctr->crr_clr_flgs;
 
     ASSERT((flags & CFLG_SBC && !(flags & CFLG_MBC))
 	   || (flags & CFLG_MBC && !(flags & CFLG_SBC)));
@@ -3534,7 +3731,21 @@ create_carrier(Allctr_t *allctr, Uint umem_sz, UWord flags)
 	return NULL;
     }
 
-    blk_sz = UMEMSZ2BLKSZ(allctr, umem_sz);
+    if (flags & CFLG_MAIN_CARRIER) {
+        ASSERT(flags & CFLG_MBC);
+        ASSERT(flags & CFLG_NO_CPOOL);
+        ASSERT(umem_sz == allctr->main_carrier_size);
+        ERTS_UNDEF(blk_sz, 0);
+
+        if (allctr->main_carrier_size < allctr->min_mbc_size)
+            allctr->main_carrier_size = allctr->min_mbc_size;
+        crr_sz = bcrr_sz = allctr->main_carrier_size;
+    }
+    else {
+        ERTS_UNDEF(bcrr_sz, 0);
+	ERTS_UNDEF(crr_sz, 0);
+        blk_sz = UMEMSZ2BLKSZ(allctr, umem_sz);
+    }
 
 #ifdef ERTS_SMP
     allctr->cpool.disable_abandon = ERTS_ALC_CPOOL_MAX_DISABLE_ABANDON;
@@ -3580,13 +3791,15 @@ create_carrier(Allctr_t *allctr, Uint umem_sz, UWord flags)
 	mseg_flags = ERTS_MSEG_FLG_NONE;
     }
     else {
-	crr_sz = (*allctr->get_next_mbc_size)(allctr);
-	if (crr_sz < MBC_HEADER_SIZE(allctr) + blk_sz)
-	    crr_sz = MBC_HEADER_SIZE(allctr) + blk_sz;
-	mseg_flags = ERTS_MSEG_FLG_2POW;
+        if (!(flags & CFLG_MAIN_CARRIER)) {
+            crr_sz = (*allctr->get_next_mbc_size)(allctr);
+            if (crr_sz < MBC_HEADER_SIZE(allctr) + blk_sz)
+                crr_sz = MBC_HEADER_SIZE(allctr) + blk_sz;
+        }
+        mseg_flags = ERTS_MSEG_FLG_2POW;
     }
 
-    crr = (Carrier_t *) alcu_mseg_alloc(allctr, &crr_sz, mseg_flags);
+    crr = (Carrier_t *) allctr->mseg_alloc(allctr, &crr_sz, mseg_flags);
     if (!crr) {
 	have_tried_mseg = 1;
 	if (!(have_tried_sys_alloc || flags & CFLG_FORCE_MSEG))
@@ -3618,23 +3831,22 @@ create_carrier(Allctr_t *allctr, Uint umem_sz, UWord flags)
     if (flags & CFLG_SBC) {
 	bcrr_sz = blk_sz + SBC_HEADER_SIZE;
     }
-    else {
+    else if (!(flags & CFLG_MAIN_CARRIER)) {
 	bcrr_sz = MBC_HEADER_SIZE(allctr) + blk_sz;
-	if (!(flags & CFLG_MAIN_CARRIER)
-	    && bcrr_sz < allctr->smallest_mbc_size)
-	    bcrr_sz = allctr->smallest_mbc_size;
+	if (bcrr_sz < allctr->smallest_mbc_size)
+            bcrr_sz = allctr->smallest_mbc_size;
     }
 
     crr_sz = (flags & CFLG_FORCE_SIZE
 	      ? UNIT_CEILING(bcrr_sz)
 	      : SYS_ALLOC_CARRIER_CEILING(bcrr_sz));
 
-    crr = (Carrier_t *) alcu_sys_alloc(allctr, crr_sz, flags & CFLG_MBC);
+    crr = (Carrier_t *) allctr->sys_alloc(allctr, crr_sz, flags & CFLG_MBC);
 	
     if (!crr) {
 	if (crr_sz > UNIT_CEILING(bcrr_sz)) {
 	    crr_sz = UNIT_CEILING(bcrr_sz);
-	    crr = (Carrier_t *) alcu_sys_alloc(allctr, crr_sz, flags & CFLG_MBC);
+	    crr = (Carrier_t *) allctr->sys_alloc(allctr, crr_sz, flags & CFLG_MBC);
 	}
 	if (!crr) {
 #if HAVE_ERTS_MSEG
@@ -3733,7 +3945,7 @@ resize_carrier(Allctr_t *allctr, Block_t *old_blk, Uint umem_sz, UWord flags)
 
 	    new_crr_sz = new_blk_sz + SBC_HEADER_SIZE;
 	    new_crr_sz = ERTS_SACRR_UNIT_CEILING(new_crr_sz);
-	    new_crr = (Carrier_t *) alcu_mseg_realloc(allctr,
+	    new_crr = (Carrier_t *) allctr->mseg_realloc(allctr,
 						      old_crr,
 						      old_crr_sz,
 						      &new_crr_sz);
@@ -3758,7 +3970,7 @@ resize_carrier(Allctr_t *allctr, Block_t *old_blk, Uint umem_sz, UWord flags)
 		       (void *) BLK2UMEM(old_blk),
 		       MIN(new_blk_sz, old_blk_sz) - ABLK_HDR_SZ);
 	    unlink_carrier(&allctr->sbc_list, old_crr);
-	    alcu_mseg_dealloc(allctr, old_crr, old_crr_sz, ERTS_MSEG_FLG_NONE);
+            allctr->mseg_dealloc(allctr, old_crr, old_crr_sz, ERTS_MSEG_FLG_NONE);
 	}
 	else {
 	    /* Old carrier unchanged; restore stat */
@@ -3775,7 +3987,7 @@ resize_carrier(Allctr_t *allctr, Block_t *old_blk, Uint umem_sz, UWord flags)
 			  ? UNIT_CEILING(new_bcrr_sz)
 			  : SYS_ALLOC_CARRIER_CEILING(new_bcrr_sz));
 
-	    new_crr = (Carrier_t *) alcu_sys_realloc(allctr,
+	    new_crr = (Carrier_t *) allctr->sys_realloc(allctr,
 						     (void *) old_crr,
 						     new_crr_sz,
 						     old_crr_sz,
@@ -3796,7 +4008,7 @@ resize_carrier(Allctr_t *allctr, Block_t *old_blk, Uint umem_sz, UWord flags)
 	    else if (new_crr_sz > UNIT_CEILING(new_bcrr_sz)) {
 		new_crr_sz = new_blk_sz + SBC_HEADER_SIZE;
 		new_crr_sz = UNIT_CEILING(new_crr_sz);
-		new_crr = (Carrier_t *) alcu_sys_realloc(allctr,
+		new_crr = (Carrier_t *) allctr->sys_realloc(allctr,
 							 (void *) old_crr,
 							 new_crr_sz,
 							 old_crr_sz,
@@ -3819,7 +4031,7 @@ resize_carrier(Allctr_t *allctr, Block_t *old_blk, Uint umem_sz, UWord flags)
 		       (void *) BLK2UMEM(old_blk),
 		       MIN(new_blk_sz, old_blk_sz) - ABLK_HDR_SZ);
 	    unlink_carrier(&allctr->sbc_list, old_crr);
-	    alcu_sys_free(allctr, old_crr, 0);
+	    allctr->sys_dealloc(allctr, old_crr, CARRIER_SZ(old_crr), 0);
 	}
 	else {
 	    /* Old carrier unchanged; restore... */
@@ -3835,13 +4047,13 @@ dealloc_carrier(Allctr_t *allctr, Carrier_t *crr, int superaligned)
 {
 #if HAVE_ERTS_MSEG
     if (IS_MSEG_CARRIER(crr))
-	alcu_mseg_dealloc(allctr, crr, CARRIER_SZ(crr),
+	allctr->mseg_dealloc(allctr, crr, CARRIER_SZ(crr),
 			  (superaligned
 			   ? ERTS_MSEG_FLG_2POW
 			   : ERTS_MSEG_FLG_NONE));
     else
 #endif
-	alcu_sys_free(allctr, crr, superaligned);
+	allctr->sys_dealloc(allctr, crr, CARRIER_SZ(crr), superaligned);
 }
 
 static void
@@ -5839,17 +6051,52 @@ erts_alcu_start(Allctr_t *allctr, AllctrInit_t *init)
 					    + ABLK_HDR_SZ)
 			       - ABLK_HDR_SZ);
 
+    if (init->sys_alloc) {
+        ASSERT(init->sys_realloc && init->sys_dealloc);
+        allctr->sys_alloc   = init->sys_alloc;
+        allctr->sys_realloc = init->sys_realloc;
+        allctr->sys_dealloc = init->sys_dealloc;
+    }
+    else {
+        ASSERT(!init->sys_realloc && !init->sys_dealloc);
+        allctr->sys_alloc   = &erts_alcu_sys_alloc;
+        allctr->sys_realloc = &erts_alcu_sys_realloc;
+        allctr->sys_dealloc = &erts_alcu_sys_dealloc;
+    }
+#if HAVE_ERTS_MSEG
+    if (init->mseg_alloc) {
+        ASSERT(init->mseg_realloc && init->mseg_dealloc);
+        allctr->mseg_alloc   = init->mseg_alloc;
+        allctr->mseg_realloc = init->mseg_realloc;
+        allctr->mseg_dealloc = init->mseg_dealloc;
+    }
+    else {
+        ASSERT(!init->mseg_realloc && !init->mseg_dealloc);
+        allctr->mseg_alloc   = &erts_alcu_mseg_alloc;
+        allctr->mseg_realloc = &erts_alcu_mseg_realloc;
+        allctr->mseg_dealloc = &erts_alcu_mseg_dealloc;
+    }
+    /* If a custom carrier alloc function is specified, make sure it's used */
+    if (init->mseg_alloc && !init->sys_alloc) {
+        allctr->crr_set_flgs = CFLG_FORCE_MSEG;
+        allctr->crr_clr_flgs = CFLG_FORCE_SYS_ALLOC;
+    }
+    else if (!init->mseg_alloc && init->sys_alloc) {
+        allctr->crr_set_flgs = CFLG_FORCE_SYS_ALLOC;
+        allctr->crr_clr_flgs = CFLG_FORCE_MSEG;
+    }
+#endif
+
     if (allctr->main_carrier_size) {
 	Block_t *blk;
 
 	blk = create_carrier(allctr,
 			     allctr->main_carrier_size,
-			     CFLG_MBC
+                             (ERTS_SUPER_ALIGNED_MSEG_ONLY
+                              ? CFLG_FORCE_MSEG : CFLG_FORCE_SYS_ALLOC)
+                             | CFLG_MBC
 			     | CFLG_FORCE_SIZE
 			     | CFLG_NO_CPOOL
-#if !ERTS_SUPER_ALIGNED_MSEG_ONLY
-			     | CFLG_FORCE_SYS_ALLOC
-#endif
 			     | CFLG_MAIN_CARRIER);
 	if (!blk) {
 #ifdef USE_THREADS
diff --git a/erts/emulator/beam/erl_alloc_util.h b/erts/emulator/beam/erl_alloc_util.h
index 792f8c63ac..16ad673d26 100644
--- a/erts/emulator/beam/erl_alloc_util.h
+++ b/erts/emulator/beam/erl_alloc_util.h
@@ -24,6 +24,12 @@
 #define ERTS_ALCU_VSN_STR "3.0"
 
 #include "erl_alloc_types.h"
+#ifdef USE_THREADS
+#define ERL_THREADS_EMU_INTERNAL__
+#include "erl_threads.h"
+#endif
+
+#include "erl_mseg.h"
 
 #define ERTS_AU_PREF_ALLOC_BITS 11
 #define ERTS_AU_MAX_PREF_ALLOC_INSTANCES (1 << ERTS_AU_PREF_ALLOC_BITS)
@@ -60,6 +66,15 @@ typedef struct {
 
     void *fix;
     size_t *fix_type_size;
+
+#if HAVE_ERTS_MSEG
+    void* (*mseg_alloc)(Allctr_t*, Uint *size_p, Uint flags);
+    void* (*mseg_realloc)(Allctr_t*, void *seg, Uint old_size, Uint *new_size_p);
+    void  (*mseg_dealloc)(Allctr_t*, void *seg, Uint size, Uint flags);
+#endif
+    void* (*sys_alloc)(Allctr_t *allctr, Uint size, int superalign);
+    void* (*sys_realloc)(Allctr_t *allctr, void *ptr, Uint size, Uint old_size, int superalign);
+    void  (*sys_dealloc)(Allctr_t *allctr, void *ptr, Uint size, int superalign);
 } AllctrInit_t;
 
 typedef struct {
@@ -173,20 +188,44 @@ void    erts_alcu_check_delayed_dealloc(Allctr_t *, int, int *, ErtsThrPrgrVal *
 #endif
 erts_aint32_t erts_alcu_fix_alloc_shrink(Allctr_t *, erts_aint32_t);
 
+#ifdef ARCH_32
+extern UWord erts_literal_vspace_map[];
+# define ERTS_VSPACE_WORD_BITS (sizeof(UWord)*8)
+#endif
+
+void* erts_alcu_mseg_alloc(Allctr_t*, Uint *size_p, Uint flags);
+void* erts_alcu_mseg_realloc(Allctr_t*, void *seg, Uint old_size, Uint *new_size_p);
+void  erts_alcu_mseg_dealloc(Allctr_t*, void *seg, Uint size, Uint flags);
+
+#if HAVE_ERTS_MSEG
+# if defined(ARCH_32)
+void* erts_alcu_literal_32_mseg_alloc(Allctr_t*, Uint *size_p, Uint flags);
+void* erts_alcu_literal_32_mseg_realloc(Allctr_t*, void *seg, Uint old_size, Uint *new_size_p);
+void  erts_alcu_literal_32_mseg_dealloc(Allctr_t*, void *seg, Uint size, Uint flags);
+
+# elif defined(ARCH_64) && defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+void* erts_alcu_literal_64_mseg_alloc(Allctr_t*, Uint *size_p, Uint flags);
+void* erts_alcu_literal_64_mseg_realloc(Allctr_t*, void *seg, Uint old_size, Uint *new_size_p);
+void  erts_alcu_literal_64_mseg_dealloc(Allctr_t*, void *seg, Uint size, Uint flags);
+# endif
+#endif /* HAVE_ERTS_MSEG */
+
+void* erts_alcu_sys_alloc(Allctr_t*, Uint size, int superalign);
+void* erts_alcu_sys_realloc(Allctr_t*, void *ptr, Uint size, Uint old_size, int superalign);
+void  erts_alcu_sys_dealloc(Allctr_t*, void *ptr, Uint size, int superalign);
+#ifdef ARCH_32
+void* erts_alcu_literal_32_sys_alloc(Allctr_t*, Uint size, int superalign);
+void* erts_alcu_literal_32_sys_realloc(Allctr_t*, void *ptr, Uint size, Uint old_size, int superalign);
+void  erts_alcu_literal_32_sys_dealloc(Allctr_t*, void *ptr, Uint size, int superalign);
 #endif
 
+#endif /* !ERL_ALLOC_UTIL__ */
+
 #if defined(GET_ERL_ALLOC_UTIL_IMPL) && !defined(ERL_ALLOC_UTIL_IMPL__)
 #define ERL_ALLOC_UTIL_IMPL__
 
 #define ERTS_ALCU_FLG_FAIL_REALLOC_MOVE		(((Uint32) 1) << 0)
 
-#ifdef USE_THREADS
-#define ERL_THREADS_EMU_INTERNAL__
-#include "erl_threads.h"
-#endif
-
-#include "erl_mseg.h"
-
 #undef ERTS_ALLOC_UTIL_HARD_DEBUG
 #ifdef DEBUG
 #  if 0
@@ -220,7 +259,7 @@ erts_aint32_t erts_alcu_fix_alloc_shrink(Allctr_t *, erts_aint32_t);
 
 #if ERTS_HAVE_MSEG_SUPER_ALIGNED \
     || (!HAVE_ERTS_MSEG && ERTS_HAVE_ERTS_SYS_ALIGNED_ALLOC)
-#  ifndef MSEG_ALIGN_BITS
+#  ifdef MSEG_ALIGN_BITS
 #    define ERTS_SUPER_ALIGN_BITS MSEG_ALIGN_BITS
 #  else
 #    define ERTS_SUPER_ALIGN_BITS 18
@@ -498,6 +537,8 @@ struct Allctr_t_ {
     Uint		min_mbc_size;
     Uint		min_mbc_first_free_size;
     Uint		min_block_size;
+    UWord               crr_set_flgs;
+    UWord               crr_clr_flgs;
 
     /* Carriers */
     CarrierList_t	mbc_list;
@@ -543,6 +584,15 @@ struct Allctr_t_ {
     void		(*remove_mbc)	        (Allctr_t *, Carrier_t *);
     UWord		(*largest_fblk_in_mbc)  (Allctr_t *, Carrier_t *);
 
+#if HAVE_ERTS_MSEG
+    void*               (*mseg_alloc)(Allctr_t*, Uint *size_p, Uint flags);
+    void*               (*mseg_realloc)(Allctr_t*, void *seg, Uint old_size, Uint *new_size_p);
+    void                (*mseg_dealloc)(Allctr_t*, void *seg, Uint size, Uint flags);
+#endif
+    void*               (*sys_alloc)(Allctr_t *allctr, Uint size, int superalign);
+    void*               (*sys_realloc)(Allctr_t *allctr, void *ptr, Uint size, Uint old_size, int superalign);
+    void                (*sys_dealloc)(Allctr_t *allctr, void *ptr, Uint size, int superalign);
+
     void		(*init_atoms)		(void);
 
 #ifdef ERTS_ALLOC_UTIL_HARD_DEBUG
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 9a132ee007..a73ad826db 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -3441,7 +3441,7 @@ BIF_RETTYPE erts_debug_get_internal_state_1(BIF_ALIST_1)
 	    BIF_RET(res);
 	}
         else if (ERTS_IS_ATOM_STR("mmap", BIF_ARG_1)) {
-            BIF_RET(erts_mmap_debug_info(BIF_P));
+            BIF_RET(erts_mmap_debug_info(&erts_dflt_mmapper, BIF_P));
         }
 	else if (ERTS_IS_ATOM_STR("unique_monotonic_integer_state", BIF_ARG_1)) {
 	    BIF_RET(erts_debug_get_unique_monotonic_integer_state(BIF_P));
@@ -4321,7 +4321,7 @@ static void os_info_init(void)
     os_flavor(buf, 1024);
     flav = erts_atom_put((byte *) buf, strlen(buf), ERTS_ATOM_ENC_LATIN1, 1);
     erts_free(ERTS_ALC_T_TMP, (void *) buf);
-    hp = erts_alloc(ERTS_ALC_T_LL_TEMP_TERM, (3+4)*sizeof(Eterm));
+    hp = erts_alloc(ERTS_ALC_T_LITERAL, (3+4)*sizeof(Eterm));
     os_type_tuple = TUPLE2(hp, type, flav);
     hp += 3;
     os_version(&major, &minor, &build);
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 29579f74e6..9a3f32c803 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -645,10 +645,10 @@ erts_garbage_collect_hibernate(Process* p)
 
 void
 erts_garbage_collect_literals(Process* p, Eterm* literals,
-			      Uint lit_size,
+			      Uint byte_lit_size,
 			      struct erl_off_heap_header* oh)
 {
-    Uint byte_lit_size = sizeof(Eterm)*lit_size;
+    Uint lit_size = byte_lit_size / sizeof(Eterm);
     Uint old_heap_size;
     Eterm* temp_lit;
     Sint offs;
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index add4a66f90..01414f326d 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -2230,17 +2230,17 @@ int enif_map_iterator_get_pair(ErlNifEnv *env,
  ***************************************************************************/
 
 
-static BeamInstr** get_func_pp(BeamInstr* mod_code, Eterm f_atom, unsigned arity)
+static BeamInstr** get_func_pp(BeamCodeHeader* mod_code, Eterm f_atom, unsigned arity)
 {
-    int n = (int) mod_code[MI_NUM_FUNCTIONS];
+    int n = (int) mod_code->num_functions;
     int j;
     for (j = 0; j < n; ++j) {
-	BeamInstr* code_ptr = (BeamInstr*) mod_code[MI_FUNCTIONS+j];
+	BeamInstr* code_ptr = (BeamInstr*) mod_code->functions[j];
 	ASSERT(code_ptr[0] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
 	if (f_atom == ((Eterm) code_ptr[3])
 	    && arity == ((unsigned) code_ptr[4])) {
 
-	    return (BeamInstr**) &mod_code[MI_FUNCTIONS+j];
+	    return (BeamInstr**) &mod_code->functions[j];
 	}
     }
     return NULL;
@@ -2423,8 +2423,8 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
     if (init_func != NULL)
       handle = init_func;
 
-    if (!in_area(caller, mod->curr.code, mod->curr.code_length)) {
-	ASSERT(in_area(caller, mod->old.code, mod->old.code_length));
+    if (!in_area(caller, mod->curr.code_hdr, mod->curr.code_length)) {
+	ASSERT(in_area(caller, mod->old.code_hdr, mod->old.code_length));
 
 	ret = load_nif_error(BIF_P, "old_code", "Calling load_nif from old "
 			     "module '%T' not allowed", mod_atom);
@@ -2478,7 +2478,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 	for (i=0; i < entry->num_of_funcs && ret==am_ok; i++) {
 	    BeamInstr** code_pp;
 	    if (!erts_atom_get(f->name, sys_strlen(f->name), &f_atom, ERTS_ATOM_ENC_LATIN1)
-		|| (code_pp = get_func_pp(mod->curr.code, f_atom, f->arity))==NULL) {
+		|| (code_pp = get_func_pp(mod->curr.code_hdr, f_atom, f->arity))==NULL) {
 		ret = load_nif_error(BIF_P,bad_lib,"Function not found %T:%s/%u",
 				     mod_atom, f->name, f->arity);
 	    }
@@ -2621,7 +2621,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 	{
 	    BeamInstr* code_ptr;
 	    erts_atom_get(f->name, sys_strlen(f->name), &f_atom, ERTS_ATOM_ENC_LATIN1);
-	    code_ptr = *get_func_pp(mod->curr.code, f_atom, f->arity);
+	    code_ptr = *get_func_pp(mod->curr.code_hdr, f_atom, f->arity);
 
 	    if (code_ptr[1] == 0) {
 		code_ptr[5+0] = (BeamInstr) BeamOp(op_call_nif);
diff --git a/erts/emulator/beam/module.c b/erts/emulator/beam/module.c
index 86dd3b5aac..f6794c012f 100644
--- a/erts/emulator/beam/module.c
+++ b/erts/emulator/beam/module.c
@@ -74,8 +74,8 @@ static Module* module_alloc(Module* tmpl)
     erts_smp_atomic_add_nob(&tot_module_bytes, sizeof(Module));
 
     obj->module = tmpl->module;
-    obj->curr.code = 0;
-    obj->old.code = 0;
+    obj->curr.code_hdr = 0;
+    obj->old.code_hdr = 0;
     obj->curr.code_length = 0;
     obj->old.code_length = 0;
     obj->slot.index = -1;
diff --git a/erts/emulator/beam/module.h b/erts/emulator/beam/module.h
index c8a6351b04..e66d628ca9 100644
--- a/erts/emulator/beam/module.h
+++ b/erts/emulator/beam/module.h
@@ -26,7 +26,7 @@
 #endif
 
 struct erl_module_instance {
-    BeamInstr* code;
+    BeamCodeHeader* code_hdr;
     int code_length;		/* Length of loaded code in bytes. */
     unsigned catches;
     struct erl_module_nif* nif;
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 34011147d9..46577bd07f 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -1045,6 +1045,9 @@ extern int erts_use_kernel_poll;
 #define put_int8(i, s) do {((unsigned char*)(s))[0] = (i) & 0xff;} while (0)
 
 
+#define ErtsInArea(PTR,START,NBYTES) \
+    ((UWord)((char*)(PTR) - (char*)(START)) < (NBYTES))
+
 /*
  * Use DEBUGF as you would use printf, but use double parentheses:
  *
diff --git a/erts/emulator/hipe/hipe_bif0.c b/erts/emulator/hipe/hipe_bif0.c
index cc68e1f74d..c6ea8a5132 100644
--- a/erts/emulator/hipe/hipe_bif0.c
+++ b/erts/emulator/hipe/hipe_bif0.c
@@ -488,7 +488,7 @@ static void *const_term_alloc(void *tmpl)
     alloc_size = size + (offsetof(struct const_term, mem)/sizeof(Eterm));
     hipe_constants_size += alloc_size;
 
-    p = (struct const_term*)erts_alloc(ERTS_ALC_T_HIPE, alloc_size * sizeof(Eterm));
+    p = (struct const_term*)erts_alloc(ERTS_ALC_T_LITERAL, alloc_size * sizeof(Eterm));
 
     /* I have absolutely no idea if having a private 'off_heap'
        works or not. _Some_ off_heap object is required for
@@ -574,15 +574,15 @@ static void print_mfa(Eterm mod, Eterm fun, unsigned int ari)
 static Uint *hipe_find_emu_address(Eterm mod, Eterm name, unsigned int arity)
 {
     Module *modp;
-    Uint *code_base;
+    BeamCodeHeader* code_hdr;
     int i, n;
 
     modp = erts_get_module(mod, erts_active_code_ix());
-    if (modp == NULL || (code_base = modp->curr.code) == NULL)
+    if (modp == NULL || (code_hdr = modp->curr.code_hdr) == NULL)
 	return NULL;
-    n = code_base[MI_NUM_FUNCTIONS];
+    n = code_hdr->num_functions;
     for (i = 0; i < n; ++i) {
-	Uint *code_ptr = (Uint*)code_base[MI_FUNCTIONS+i];
+	Uint *code_ptr = (Uint*)code_hdr->functions[i];
 	ASSERT(code_ptr[0] == BeamOpCode(op_i_func_info_IaaI));
 	if (code_ptr[3] == name && code_ptr[4] == arity)
 	    return code_ptr+5;
diff --git a/erts/emulator/sys/common/erl_mmap.c b/erts/emulator/sys/common/erl_mmap.c
index e6d0e1e281..03ca080c14 100644
--- a/erts/emulator/sys/common/erl_mmap.c
+++ b/erts/emulator/sys/common/erl_mmap.c
@@ -51,23 +51,22 @@
 #endif
 
 /*
- * `mmap_state.sa.bot` and `mmap_state.sua.top` are read only after
+ * `mm->sa.bot` and `mm->sua.top` are read only after
  * initialization, but the other pointers are not; i.e., only
  * ERTS_MMAP_IN_SUPERCARRIER() is allowed without the mutex held.
  */
 #define ERTS_MMAP_IN_SUPERCARRIER(PTR)					\
-    (((UWord) (PTR)) - ((UWord) mmap_state.sa.bot)			\
-     < ((UWord) mmap_state.sua.top) - ((UWord) mmap_state.sa.bot))
+    (((UWord) (PTR)) - ((UWord) mm->sa.bot)			\
+     < ((UWord) mm->sua.top) - ((UWord) mm->sa.bot))
 #define ERTS_MMAP_IN_SUPERALIGNED_AREA(PTR)				\
-    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mmap_state.mtx)),	\
-     (((UWord) (PTR)) - ((UWord) mmap_state.sa.bot)			\
-      < ((UWord) mmap_state.sa.top) - ((UWord) mmap_state.sa.bot)))
+    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mm->mtx)),	\
+     (((UWord) (PTR)) - ((UWord) mm->sa.bot)			\
+      < ((UWord) mm->sa.top) - ((UWord) mm->sa.bot)))
 #define ERTS_MMAP_IN_SUPERUNALIGNED_AREA(PTR)				\
-    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mmap_state.mtx)),	\
-     (((UWord) (PTR)) - ((UWord) mmap_state.sua.bot)			\
-      < ((UWord) mmap_state.sua.top) - ((UWord) mmap_state.sua.bot)))
+    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mm->mtx)),	\
+     (((UWord) (PTR)) - ((UWord) mm->sua.bot)			\
+      < ((UWord) mm->sua.top) - ((UWord) mm->sua.bot)))
 
-int erts_have_erts_mmap;
 UWord erts_page_inv_mask;
 
 #if defined(DEBUG) || defined(ERTS_MMAP_DEBUG)
@@ -197,10 +196,10 @@ static ErtsMMapOp mmap_ops[ERTS_MMAP_OP_RINGBUF_SZ];
 
 #define ERTS_MMAP_OP_LCK(RES, IN_SZ, OUT_SZ)			\
     do {							\
-	erts_smp_mtx_lock(&mmap_state.mtx);			\
+	erts_smp_mtx_lock(&mm->mtx);			\
 	ERTS_MMAP_OP_START((IN_SZ));				\
 	ERTS_MMAP_OP_END((RES), (OUT_SZ));			\
-	erts_smp_mtx_unlock(&mmap_state.mtx);			\
+	erts_smp_mtx_unlock(&mm->mtx);			\
     } while (0)
 
 #define ERTS_MUNMAP_OP(PTR, SZ)					\
@@ -219,9 +218,9 @@ static ErtsMMapOp mmap_ops[ERTS_MMAP_OP_RINGBUF_SZ];
 
 #define ERTS_MUNMAP_OP_LCK(PTR, SZ)				\
     do {							\
-	erts_smp_mtx_lock(&mmap_state.mtx);			\
+	erts_smp_mtx_lock(&mm->mtx);			\
 	ERTS_MUNMAP_OP((PTR), (SZ));				\
-	erts_smp_mtx_unlock(&mmap_state.mtx);			\
+	erts_smp_mtx_unlock(&mm->mtx);			\
     } while (0)
 
 #define ERTS_MREMAP_OP_START(OLD_PTR, OLD_SZ, IN_SZ)		\
@@ -247,10 +246,10 @@ static ErtsMMapOp mmap_ops[ERTS_MMAP_OP_RINGBUF_SZ];
 
 #define ERTS_MREMAP_OP_LCK(RES, OLD_PTR, OLD_SZ, IN_SZ, OUT_SZ)	\
     do {							\
-	erts_smp_mtx_lock(&mmap_state.mtx);			\
+	erts_smp_mtx_lock(&mm->mtx);			\
 	ERTS_MREMAP_OP_START((OLD_PTR), (OLD_SZ), (IN_SZ));	\
 	ERTS_MREMAP_OP_END((RES), (OUT_SZ));			\
-	erts_smp_mtx_unlock(&mmap_state.mtx);			\
+	erts_smp_mtx_unlock(&mm->mtx);			\
     } while (0)
 
 #define ERTS_MMAP_OP_ABORT()					\
@@ -294,7 +293,7 @@ typedef struct {
     Uint nseg;
 }ErtsFreeSegMap;
 
-static struct {
+struct ErtsMemMapper_ {
     int (*reserve_physical)(char *, UWord);
     void (*unreserve_physical)(char *, UWord);
     int supercarrier;
@@ -346,54 +345,62 @@ static struct {
 	    UWord used;
 	} os;
     } size;
-} mmap_state;
+};
+
+ErtsMemMapper erts_dflt_mmapper;
+
+#if defined(ARCH_64) && defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+ErtsMemMapper erts_literal_mmapper;
+char* erts_literals_start;
+UWord erts_literals_size;
+#endif
 
 #define ERTS_MMAP_SIZE_SC_SA_INC(SZ) 						\
     do {									\
-	mmap_state.size.supercarrier.used.total += (SZ);			\
-	mmap_state.size.supercarrier.used.sa += (SZ);				\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total		\
-			 <= mmap_state.size.supercarrier.total);		\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sa			\
-			 <= mmap_state.size.supercarrier.used.total);		\
+	mm->size.supercarrier.used.total += (SZ);			\
+	mm->size.supercarrier.used.sa += (SZ);				\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.total		\
+			 <= mm->size.supercarrier.total);		\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.sa			\
+			 <= mm->size.supercarrier.used.total);		\
     } while (0)
 #define ERTS_MMAP_SIZE_SC_SA_DEC(SZ) 						\
     do {									\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total >= (SZ));	\
-	mmap_state.size.supercarrier.used.total -= (SZ);			\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sa >= (SZ));		\
-	mmap_state.size.supercarrier.used.sa -= (SZ);				\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.total >= (SZ));	\
+	mm->size.supercarrier.used.total -= (SZ);			\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.sa >= (SZ));		\
+	mm->size.supercarrier.used.sa -= (SZ);				\
     } while (0)
 #define ERTS_MMAP_SIZE_SC_SUA_INC(SZ) 						\
     do {									\
-	mmap_state.size.supercarrier.used.total += (SZ);			\
-	mmap_state.size.supercarrier.used.sua += (SZ);				\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total		\
-			 <= mmap_state.size.supercarrier.total);		\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sua			\
-			 <= mmap_state.size.supercarrier.used.total);		\
+	mm->size.supercarrier.used.total += (SZ);			\
+	mm->size.supercarrier.used.sua += (SZ);				\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.total		\
+			 <= mm->size.supercarrier.total);		\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.sua			\
+			 <= mm->size.supercarrier.used.total);		\
     } while (0)
 #define ERTS_MMAP_SIZE_SC_SUA_DEC(SZ) 						\
     do {									\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total >= (SZ));	\
-	mmap_state.size.supercarrier.used.total -= (SZ);			\
-	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sua >= (SZ));	\
-	mmap_state.size.supercarrier.used.sua -= (SZ);				\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.total >= (SZ));	\
+	mm->size.supercarrier.used.total -= (SZ);			\
+	ERTS_MMAP_ASSERT(mm->size.supercarrier.used.sua >= (SZ));	\
+	mm->size.supercarrier.used.sua -= (SZ);				\
     } while (0)
 #define ERTS_MMAP_SIZE_OS_INC(SZ)						\
     do {									\
-	ERTS_MMAP_ASSERT(mmap_state.size.os.used + (SZ) >= (SZ));		\
-	mmap_state.size.os.used += (SZ);					\
+	ERTS_MMAP_ASSERT(mm->size.os.used + (SZ) >= (SZ));		\
+	mm->size.os.used += (SZ);					\
     } while (0)
 #define ERTS_MMAP_SIZE_OS_DEC(SZ) 						\
     do {									\
-	ERTS_MMAP_ASSERT(mmap_state.size.os.used >= (SZ));			\
-	mmap_state.size.os.used -= (SZ);					\
+	ERTS_MMAP_ASSERT(mm->size.os.used >= (SZ));			\
+	mm->size.os.used -= (SZ);					\
     } while (0)
 
 
 static void
-add_free_desc_area(char *start, char *end)
+add_free_desc_area(ErtsMemMapper* mm, char *start, char *end)
 {
     ERTS_MMAP_ASSERT(end == (void *) 0 || end > start);
     if (sizeof(ErtsFreeSegDesc) <= ((UWord) end) - ((UWord) start)) {
@@ -403,7 +410,7 @@ add_free_desc_area(char *start, char *end)
 
 	no = 1;
 	prev_desc = (ErtsFreeSegDesc *) start;
-	prev_desc->start = mmap_state.desc.free_list;
+	prev_desc->start = mm->desc.free_list;
 	desc = (ErtsFreeSegDesc *) (start + sizeof(ErtsFreeSegDesc));
 	desc_end = start + 2*sizeof(ErtsFreeSegDesc);
 
@@ -414,59 +421,59 @@ add_free_desc_area(char *start, char *end)
 	    desc_end += sizeof(ErtsFreeSegDesc);
 	    no++;
 	}
-	mmap_state.desc.free_list = (char *) prev_desc;
-	mmap_state.no.free_seg_descs += no;
+	mm->desc.free_list = (char *) prev_desc;
+	mm->no.free_seg_descs += no;
     }
 }
 
 static ErtsFreeSegDesc *
-add_unused_free_desc_area(void)
+add_unused_free_desc_area(ErtsMemMapper* mm)
 {
     char *ptr;
-    if (!mmap_state.desc.unused_start)
+    if (!mm->desc.unused_start)
 	return NULL;
 
-    ERTS_MMAP_ASSERT(mmap_state.desc.unused_end);
+    ERTS_MMAP_ASSERT(mm->desc.unused_end);
     ERTS_MMAP_ASSERT(ERTS_PAGEALIGNED_SIZE
-		     <= mmap_state.desc.unused_end - mmap_state.desc.unused_start);
+		     <= mm->desc.unused_end - mm->desc.unused_start);
 
-    ptr = mmap_state.desc.unused_start + ERTS_PAGEALIGNED_SIZE;
-    add_free_desc_area(mmap_state.desc.unused_start, ptr);
+    ptr = mm->desc.unused_start + ERTS_PAGEALIGNED_SIZE;
+    add_free_desc_area(mm, mm->desc.unused_start, ptr);
 
-    if ((mmap_state.desc.unused_end - ptr) >= ERTS_PAGEALIGNED_SIZE)
-	mmap_state.desc.unused_start = ptr;
+    if ((mm->desc.unused_end - ptr) >= ERTS_PAGEALIGNED_SIZE)
+	mm->desc.unused_start = ptr;
     else
-	mmap_state.desc.unused_end = mmap_state.desc.unused_start = NULL;
+	mm->desc.unused_end = mm->desc.unused_start = NULL;
 
-    ERTS_MMAP_ASSERT(mmap_state.desc.free_list);
-    return (ErtsFreeSegDesc *) mmap_state.desc.free_list;
+    ERTS_MMAP_ASSERT(mm->desc.free_list);
+    return (ErtsFreeSegDesc *) mm->desc.free_list;
 }
 
 static ERTS_INLINE ErtsFreeSegDesc *
-alloc_desc(void)
+alloc_desc(ErtsMemMapper* mm)
 {
     ErtsFreeSegDesc *res;
-    res = (ErtsFreeSegDesc *) mmap_state.desc.free_list;
+    res = (ErtsFreeSegDesc *) mm->desc.free_list;
     if (!res) {
-	res = add_unused_free_desc_area();
+	res = add_unused_free_desc_area(mm);
 	if (!res)
 	    return NULL;
     }
-    mmap_state.desc.free_list = res->start;
-    ASSERT(mmap_state.no.free_segs.curr < mmap_state.no.free_seg_descs);
-    mmap_state.no.free_segs.curr++;
-    if (mmap_state.no.free_segs.max < mmap_state.no.free_segs.curr)
-	mmap_state.no.free_segs.max = mmap_state.no.free_segs.curr;
+    mm->desc.free_list = res->start;
+    ASSERT(mm->no.free_segs.curr < mm->no.free_seg_descs);
+    mm->no.free_segs.curr++;
+    if (mm->no.free_segs.max < mm->no.free_segs.curr)
+	mm->no.free_segs.max = mm->no.free_segs.curr;
     return res;
 }
 
 static ERTS_INLINE void
-free_desc(ErtsFreeSegDesc *desc)
+free_desc(ErtsMemMapper* mm, ErtsFreeSegDesc *desc)
 {
-    desc->start = mmap_state.desc.free_list;
-    mmap_state.desc.free_list = (char *) desc;
-    ERTS_MMAP_ASSERT(mmap_state.no.free_segs.curr > 0);
-    mmap_state.no.free_segs.curr--;
+    desc->start = mm->desc.free_list;
+    mm->desc.free_list = (char *) desc;
+    ERTS_MMAP_ASSERT(mm->no.free_segs.curr > 0);
+    mm->no.free_segs.curr--;
 }
 
 static ERTS_INLINE ErtsFreeSegDesc* anode_to_desc(RBTNode* anode)
@@ -1233,7 +1240,7 @@ Eterm build_free_seg_list(Process* p, ErtsFreeSegMap* map)
 #    define ERTS_MMAP_FD		(-1)
 #  else
 #    define ERTS_MMAP_FLAGS		(MAP_PRIVATE)
-#    define ERTS_MMAP_FD		mmap_state.mmap_fd
+#    define ERTS_MMAP_FD		mm->mmap_fd
 #  endif
 #endif
 
@@ -1378,11 +1385,12 @@ static void unreserve_noop(char *ptr, UWord size)
 }
 
 static UWord
-alloc_desc_insert_free_seg(ErtsFreeSegMap *map, char* start, char* end)
+alloc_desc_insert_free_seg(ErtsMemMapper* mm,
+                           ErtsFreeSegMap *map, char* start, char* end)
 {
     char *ptr;
     ErtsFreeSegMap *da_map;
-    ErtsFreeSegDesc *desc = alloc_desc();
+    ErtsFreeSegDesc *desc = alloc_desc(mm);
     if (desc) {
 	insert_free_seg(map, desc, start, end);
 	return 0;
@@ -1395,13 +1403,13 @@ alloc_desc_insert_free_seg(ErtsFreeSegMap *map, char* start, char* end)
      */
 
 #if ERTS_HAVE_OS_MMAP
-    if (!mmap_state.no_os_mmap) {
-        ptr = os_mmap(mmap_state.desc.new_area_hint, ERTS_PAGEALIGNED_SIZE, 0);
+    if (!mm->no_os_mmap) {
+        ptr = os_mmap(mm->desc.new_area_hint, ERTS_PAGEALIGNED_SIZE, 0);
         if (ptr) {
-            mmap_state.desc.new_area_hint = ptr+ERTS_PAGEALIGNED_SIZE;
+            mm->desc.new_area_hint = ptr+ERTS_PAGEALIGNED_SIZE;
             ERTS_MMAP_SIZE_OS_INC(ERTS_PAGEALIGNED_SIZE);
-            add_free_desc_area(ptr, ptr+ERTS_PAGEALIGNED_SIZE);
-            desc = alloc_desc();
+            add_free_desc_area(mm, ptr, ptr+ERTS_PAGEALIGNED_SIZE);
+            desc = alloc_desc(mm);
             ERTS_MMAP_ASSERT(desc);
             insert_free_seg(map, desc, start, end);
             return 0;
@@ -1412,20 +1420,20 @@ alloc_desc_insert_free_seg(ErtsFreeSegMap *map, char* start, char* end)
     /*
      * ...then try to find a good place in the supercarrier...
      */
-    da_map = &mmap_state.sua.map;
+    da_map = &mm->sua.map;
     desc = lookup_free_seg(da_map, ERTS_PAGEALIGNED_SIZE);
     if (desc) {
-	if (mmap_state.reserve_physical(desc->start, ERTS_PAGEALIGNED_SIZE))
+	if (mm->reserve_physical(desc->start, ERTS_PAGEALIGNED_SIZE))
 	    ERTS_MMAP_SIZE_SC_SUA_INC(ERTS_PAGEALIGNED_SIZE);
 	else
 	    desc = NULL;
 	
     }
     else {
-	da_map = &mmap_state.sa.map;
+	da_map = &mm->sa.map;
 	desc = lookup_free_seg(da_map, ERTS_PAGEALIGNED_SIZE);
 	if (desc) {
-	    if (mmap_state.reserve_physical(desc->start, ERTS_PAGEALIGNED_SIZE))
+	    if (mm->reserve_physical(desc->start, ERTS_PAGEALIGNED_SIZE))
 		ERTS_MMAP_SIZE_SC_SA_INC(ERTS_PAGEALIGNED_SIZE);
 	    else
 		desc = NULL;
@@ -1433,15 +1441,15 @@ alloc_desc_insert_free_seg(ErtsFreeSegMap *map, char* start, char* end)
     }
     if (desc) {
 	char *da_end = desc->start + ERTS_PAGEALIGNED_SIZE;
-	add_free_desc_area(desc->start, da_end);
+	add_free_desc_area(mm, desc->start, da_end);
 	if (da_end != desc->end)
 	    resize_free_seg(da_map, desc, da_end, desc->end);
 	else {
 	    delete_free_seg(da_map, desc);
-	    free_desc(desc);
+	    free_desc(mm, desc);
 	}
 
-	desc = alloc_desc();
+	desc = alloc_desc(mm);
 	ERTS_MMAP_ASSERT(desc);
 	insert_free_seg(map, desc, start, end);
 	return 0;
@@ -1454,10 +1462,10 @@ alloc_desc_insert_free_seg(ErtsFreeSegMap *map, char* start, char* end)
     ptr = start + ERTS_PAGEALIGNED_SIZE;
     ERTS_MMAP_ASSERT(ptr <= end);
 
-    add_free_desc_area(start, ptr);
+    add_free_desc_area(mm, start, ptr);
 
     if (ptr != end) {
-	desc = alloc_desc();
+	desc = alloc_desc(mm);
 	ERTS_MMAP_ASSERT(desc);
 	insert_free_seg(map, desc, ptr, end);
     }
@@ -1466,46 +1474,46 @@ alloc_desc_insert_free_seg(ErtsFreeSegMap *map, char* start, char* end)
 }
 
 void *
-erts_mmap(Uint32 flags, UWord *sizep)
+erts_mmap(ErtsMemMapper* mm, Uint32 flags, UWord *sizep)
 {
     char *seg;
     UWord asize = ERTS_PAGEALIGNED_CEILING(*sizep);
 
     /* Map in premapped supercarrier */
-    if (mmap_state.supercarrier && !(ERTS_MMAPFLG_OS_ONLY & flags)) {
+    if (mm->supercarrier && !(ERTS_MMAPFLG_OS_ONLY & flags)) {
 	char *end;
 	ErtsFreeSegDesc *desc;
 	Uint32 superaligned = (ERTS_MMAPFLG_SUPERALIGNED & flags);
 
-	erts_smp_mtx_lock(&mmap_state.mtx);
+	erts_smp_mtx_lock(&mm->mtx);
 
 	ERTS_MMAP_OP_START(*sizep);
 
 	if (!superaligned) {
-	    desc = lookup_free_seg(&mmap_state.sua.map, asize);
+	    desc = lookup_free_seg(&mm->sua.map, asize);
 	    if (desc) {
 		seg = desc->start;
 		end = seg+asize;
-		if (!mmap_state.reserve_physical(seg, asize))
+		if (!mm->reserve_physical(seg, asize))
 		    goto supercarrier_reserve_failure;
 		if (desc->end == end) {
-		    delete_free_seg(&mmap_state.sua.map, desc);
-		    free_desc(desc);
+		    delete_free_seg(&mm->sua.map, desc);
+		    free_desc(mm, desc);
 		}
 		else {
 		    ERTS_MMAP_ASSERT(end < desc->end);
-		    resize_free_seg(&mmap_state.sua.map, desc, end, desc->end);
+		    resize_free_seg(&mm->sua.map, desc, end, desc->end);
 		}
 		ERTS_MMAP_SIZE_SC_SUA_INC(asize);
 		goto supercarrier_success;
 	    }
 
-	    if (asize <= mmap_state.sua.bot - mmap_state.sa.top) {
-		if (!mmap_state.reserve_physical(mmap_state.sua.bot - asize,
+	    if (asize <= mm->sua.bot - mm->sa.top) {
+		if (!mm->reserve_physical(mm->sua.bot - asize,
 						 asize))
 		    goto supercarrier_reserve_failure;
-		mmap_state.sua.bot -= asize;
-		seg = mmap_state.sua.bot;
+		mm->sua.bot -= asize;
+		seg = mm->sua.bot;
 		ERTS_MMAP_SIZE_SC_SUA_INC(asize);
 		goto supercarrier_success;
 	    }
@@ -1513,84 +1521,84 @@ erts_mmap(Uint32 flags, UWord *sizep)
 
 	asize = ERTS_SUPERALIGNED_CEILING(asize);
 
-	desc = lookup_free_seg(&mmap_state.sa.map, asize);
+	desc = lookup_free_seg(&mm->sa.map, asize);
 	if (desc) {
 	    char *start = seg = desc->start;
 	    seg = (char *) ERTS_SUPERALIGNED_CEILING(seg);
 	    end = seg+asize;
-	    if (!mmap_state.reserve_physical(start, (UWord) (end - start)))
+	    if (!mm->reserve_physical(start, (UWord) (end - start)))
 		goto supercarrier_reserve_failure;
 	    ERTS_MMAP_SIZE_SC_SA_INC(asize);
 	    if (desc->end == end) {
 		if (start != seg)
-		    resize_free_seg(&mmap_state.sa.map, desc, start, seg);
+		    resize_free_seg(&mm->sa.map, desc, start, seg);
 		else {
-		    delete_free_seg(&mmap_state.sa.map, desc);
-		    free_desc(desc);
+		    delete_free_seg(&mm->sa.map, desc);
+		    free_desc(mm, desc);
 		}
 	    }
 	    else {
 		ERTS_MMAP_ASSERT(end < desc->end);
-		resize_free_seg(&mmap_state.sa.map, desc, end, desc->end);
+		resize_free_seg(&mm->sa.map, desc, end, desc->end);
 		if (start != seg) {
 		    UWord ad_sz;
-		    ad_sz = alloc_desc_insert_free_seg(&mmap_state.sua.map,
+		    ad_sz = alloc_desc_insert_free_seg(mm, &mm->sua.map,
 						       start, seg);
 		    start += ad_sz;
 		    if (start != seg)
-			mmap_state.unreserve_physical(start, (UWord) (seg - start));
+			mm->unreserve_physical(start, (UWord) (seg - start));
 		}
 	    }
 	    goto supercarrier_success;
 	}
 
 	if (superaligned) {
-	    char *start = mmap_state.sa.top;
+	    char *start = mm->sa.top;
 	    seg = (char *) ERTS_SUPERALIGNED_CEILING(start);
 
-	    if (asize + (seg - start) <= mmap_state.sua.bot - start) {
+	    if (asize + (seg - start) <= mm->sua.bot - start) {
 		end = seg + asize;
-		if (!mmap_state.reserve_physical(start, (UWord) (end - start)))
+		if (!mm->reserve_physical(start, (UWord) (end - start)))
 		    goto supercarrier_reserve_failure;
-		mmap_state.sa.top = end;
+		mm->sa.top = end;
 		ERTS_MMAP_SIZE_SC_SA_INC(asize);
 		if (start != seg) {
 		    UWord ad_sz;
-		    ad_sz = alloc_desc_insert_free_seg(&mmap_state.sua.map,
+		    ad_sz = alloc_desc_insert_free_seg(mm, &mm->sua.map,
 						       start, seg);
 		    start += ad_sz;
 		    if (start != seg)
-			mmap_state.unreserve_physical(start, (UWord) (seg - start));
+			mm->unreserve_physical(start, (UWord) (seg - start));
 		}
 		goto supercarrier_success;
 	    }
 
-	    desc = lookup_free_seg(&mmap_state.sua.map, asize + ERTS_SUPERALIGNED_SIZE);
+	    desc = lookup_free_seg(&mm->sua.map, asize + ERTS_SUPERALIGNED_SIZE);
 	    if (desc) {
 		char *org_start = desc->start;
 		char *org_end = desc->end;
 
 		seg = (char *) ERTS_SUPERALIGNED_CEILING(org_start);
 		end = seg + asize;
-		if (!mmap_state.reserve_physical(seg, (UWord) (org_end - seg)))
+		if (!mm->reserve_physical(seg, (UWord) (org_end - seg)))
 		    goto supercarrier_reserve_failure;
 		ERTS_MMAP_SIZE_SC_SUA_INC(asize);
 		if (org_start != seg) {
 		    ERTS_MMAP_ASSERT(org_start < seg);
-		    resize_free_seg(&mmap_state.sua.map, desc, org_start, seg);
+		    resize_free_seg(&mm->sua.map, desc, org_start, seg);
 		    desc = NULL;
 		}
 		if (end != org_end) {
 		    UWord ad_sz = 0;
 		    ERTS_MMAP_ASSERT(end < org_end);
 		    if (desc)
-			resize_free_seg(&mmap_state.sua.map, desc, end, org_end);
+			resize_free_seg(&mm->sua.map, desc, end, org_end);
 		    else
-			ad_sz = alloc_desc_insert_free_seg(&mmap_state.sua.map,
+			ad_sz = alloc_desc_insert_free_seg(mm, &mm->sua.map,
 							   end, org_end);
 		    end += ad_sz;
 		    if (end != org_end)
-			mmap_state.unreserve_physical(end,
+			mm->unreserve_physical(end,
 						      (UWord) (org_end - end));
 		}
 		goto supercarrier_success;
@@ -1598,12 +1606,12 @@ erts_mmap(Uint32 flags, UWord *sizep)
 	}
 
 	ERTS_MMAP_OP_ABORT();
-	erts_smp_mtx_unlock(&mmap_state.mtx);
+	erts_smp_mtx_unlock(&mm->mtx);
     }
 
 #if ERTS_HAVE_OS_MMAP
     /* Map using OS primitives */
-    if (!(ERTS_MMAPFLG_SUPERCARRIER_ONLY & flags) && !mmap_state.no_os_mmap) {
+    if (!(ERTS_MMAPFLG_SUPERCARRIER_ONLY & flags) && !mm->no_os_mmap) {
 	if (!(ERTS_MMAPFLG_SUPERALIGNED & flags)) {
 	    seg = os_mmap(NULL, asize, 0);
 	    if (!seg)
@@ -1661,25 +1669,25 @@ supercarrier_success:
 #endif
 
     ERTS_MMAP_OP_END(seg, asize);
-    erts_smp_mtx_unlock(&mmap_state.mtx);
+    erts_smp_mtx_unlock(&mm->mtx);
 
     *sizep = asize;
     return (void *) seg;
 
 supercarrier_reserve_failure:
-    erts_smp_mtx_unlock(&mmap_state.mtx);
+    erts_smp_mtx_unlock(&mm->mtx);
     *sizep = 0;
     return NULL;
 }
 
 void
-erts_munmap(Uint32 flags, void *ptr, UWord size)
+erts_munmap(ErtsMemMapper* mm, Uint32 flags, void *ptr, UWord size)
 {
     ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(ptr));
     ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(size));
 
     if (!ERTS_MMAP_IN_SUPERCARRIER(ptr)) {
-	ERTS_MMAP_ASSERT(!mmap_state.no_os_mmap);
+	ERTS_MMAP_ASSERT(!mm->no_os_mmap);
 #if ERTS_HAVE_OS_MMAP
 	ERTS_MUNMAP_OP_LCK(ptr, size);
 	ERTS_MMAP_SIZE_OS_DEC(size);
@@ -1692,45 +1700,45 @@ erts_munmap(Uint32 flags, void *ptr, UWord size)
 	ErtsFreeSegDesc *prev, *next, *desc;
 	UWord ad_sz = 0;
 
-	ERTS_MMAP_ASSERT(mmap_state.supercarrier);
+	ERTS_MMAP_ASSERT(mm->supercarrier);
 
 	start = (char *) ptr;
 	end = start + size;
 
-	erts_smp_mtx_lock(&mmap_state.mtx);
+	erts_smp_mtx_lock(&mm->mtx);
 
 	ERTS_MUNMAP_OP(ptr, size);
 
 	if (ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)) {
 
-	    map = &mmap_state.sa.map;
+	    map = &mm->sa.map;
 	    adjacent_free_seg(map, start, end, &prev, &next);
 
 	    ERTS_MMAP_SIZE_SC_SA_DEC(size);
-	    if (end == mmap_state.sa.top) {
+	    if (end == mm->sa.top) {
 		ERTS_MMAP_ASSERT(!next);
 		if (prev) {
 		    start = prev->start;
 		    delete_free_seg(map, prev);
-		    free_desc(prev);
+		    free_desc(mm, prev);
 		}
-		mmap_state.sa.top = start;
+		mm->sa.top = start;
 		goto supercarrier_success;
 	    }
 	}
 	else {
-	    map = &mmap_state.sua.map;
+	    map = &mm->sua.map;
 	    adjacent_free_seg(map, start, end, &prev, &next);
 
 	    ERTS_MMAP_SIZE_SC_SUA_DEC(size);
-	    if (start == mmap_state.sua.bot) {
+	    if (start == mm->sua.bot) {
 		ERTS_MMAP_ASSERT(!prev);
 		if (next) {
 		    end = next->end;
 		    delete_free_seg(map, next);
-		    free_desc(next);
+		    free_desc(mm, next);
 		}
-		mmap_state.sua.bot = end;
+		mm->sua.bot = end;
 		goto supercarrier_success;
 	    }
 	}
@@ -1742,7 +1750,7 @@ erts_munmap(Uint32 flags, void *ptr, UWord size)
 	    end = next->end;
 	    if (prev) {
 		delete_free_seg(map, next);
-		free_desc(next);
+		free_desc(mm, next);
 		goto save_prev;
 	    }
 	    desc = next;
@@ -1756,7 +1764,7 @@ erts_munmap(Uint32 flags, void *ptr, UWord size)
 	if (desc)
 	    resize_free_seg(map, desc, start, end);
 	else
-	    ad_sz = alloc_desc_insert_free_seg(map, start, end);
+	    ad_sz = alloc_desc_insert_free_seg(mm, map, start, end);
 	
     supercarrier_success: {
 	    UWord unres_sz;
@@ -1764,30 +1772,32 @@ erts_munmap(Uint32 flags, void *ptr, UWord size)
 	    ERTS_MMAP_ASSERT(size >= ad_sz);
 	    unres_sz = size - ad_sz;
 	    if (unres_sz)
-		mmap_state.unreserve_physical(((char *) ptr) + ad_sz, unres_sz);
+		mm->unreserve_physical(((char *) ptr) + ad_sz, unres_sz);
 
-            erts_smp_mtx_unlock(&mmap_state.mtx);
+            erts_smp_mtx_unlock(&mm->mtx);
 	}
     }
 }
 
 static void *
-remap_move(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
+remap_move(ErtsMemMapper* mm,
+           Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 {
     UWord size = *sizep;
-    void *new_ptr = erts_mmap(flags, &size);
+    void *new_ptr = erts_mmap(mm, flags, &size);
     if (!new_ptr)
 	return NULL;
     *sizep = size;
     if (old_size < size)
 	size = old_size;
     sys_memcpy(new_ptr, ptr, (size_t) size);
-    erts_munmap(flags, ptr, old_size);
+    erts_munmap(mm, flags, ptr, old_size);
     return new_ptr;
 }
 
 void *
-erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
+erts_mremap(ErtsMemMapper* mm,
+            Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 {
     void *new_ptr;
     Uint32 superaligned;
@@ -1799,11 +1809,11 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 
     if (!ERTS_MMAP_IN_SUPERCARRIER(ptr)) {
 
-	ERTS_MMAP_ASSERT(!mmap_state.no_os_mmap);
+	ERTS_MMAP_ASSERT(!mm->no_os_mmap);
 
-	if (!(ERTS_MMAPFLG_OS_ONLY & flags) && mmap_state.supercarrier) {
-	    new_ptr = remap_move(ERTS_MMAPFLG_SUPERCARRIER_ONLY|flags, ptr,
-				 old_size, sizep);
+	if (!(ERTS_MMAPFLG_OS_ONLY & flags) && mm->supercarrier) {
+	    new_ptr = remap_move(mm, ERTS_MMAPFLG_SUPERCARRIER_ONLY|flags,
+                                 ptr, old_size, sizep);
 	    if (new_ptr)
 		return new_ptr;
 	}
@@ -1850,7 +1860,7 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 #endif
 #if ERTS_HAVE_OS_MREMAP
 	if (superaligned)
-	    return remap_move(flags, new_ptr, old_size, sizep);
+	    return remap_move(mm, flags, new_ptr, old_size, sizep);
 	else {
 	    new_ptr = os_mremap(ptr, old_size, asize, 0);
 	    if (!new_ptr)
@@ -1872,10 +1882,10 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 	ErtsFreeSegDesc *prev, *next;
 	UWord ad_sz = 0;
 
-	ERTS_MMAP_ASSERT(mmap_state.supercarrier);
+	ERTS_MMAP_ASSERT(mm->supercarrier);
 
 	if (ERTS_MMAPFLG_OS_ONLY & flags)
-	    return remap_move(flags, ptr, old_size, sizep);
+	    return remap_move(mm, flags, ptr, old_size, sizep);
 
 	superaligned = (ERTS_MMAPFLG_SUPERALIGNED & flags);
 
@@ -1883,19 +1893,19 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 		 ? ERTS_SUPERALIGNED_CEILING(*sizep)
 		 : ERTS_PAGEALIGNED_CEILING(*sizep));
 
-	erts_smp_mtx_lock(&mmap_state.mtx);
+	erts_smp_mtx_lock(&mm->mtx);
 
 	if (ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)
-	    ? (!superaligned && lookup_free_seg(&mmap_state.sua.map, asize))
-	    : (superaligned && lookup_free_seg(&mmap_state.sa.map, asize))) {
-	    erts_smp_mtx_unlock(&mmap_state.mtx);
+	    ? (!superaligned && lookup_free_seg(&mm->sua.map, asize))
+	    : (superaligned && lookup_free_seg(&mm->sa.map, asize))) {
+	    erts_smp_mtx_unlock(&mm->mtx);
 	    /*
 	     * Segment currently in wrong area (due to a previous memory
 	     * shortage), move it to the right area.
 	     * (remap_move() will succeed)
 	     */
-	    return remap_move(ERTS_MMAPFLG_SUPERCARRIER_ONLY|flags, ptr,
-			      old_size, sizep);
+	    return remap_move(mm, ERTS_MMAPFLG_SUPERCARRIER_ONLY|flags,
+                              ptr, old_size, sizep);
 	}
 
 	ERTS_MREMAP_OP_START(ptr, old_size, *sizep);
@@ -1917,18 +1927,18 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 	    UWord unres_sz;
 	    new_ptr = ptr;
 	    if (!ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)) {
-		map = &mmap_state.sua.map;
+		map = &mm->sua.map;
 		ERTS_MMAP_SIZE_SC_SUA_DEC(old_size - asize);
 	    }
 	    else {
-		if (end == mmap_state.sa.top) {
-		    mmap_state.sa.top = new_end;
-		    mmap_state.unreserve_physical(((char *) ptr) + asize,
+		if (end == mm->sa.top) {
+		    mm->sa.top = new_end;
+		    mm->unreserve_physical(((char *) ptr) + asize,
 						  old_size - asize);
 		    goto supercarrier_resize_success;
 		}
 		ERTS_MMAP_SIZE_SC_SA_DEC(old_size - asize);
-		map = &mmap_state.sa.map;
+		map = &mm->sa.map;
 	    }
 	    
 	    adjacent_free_seg(map, start, end, &prev, &next);
@@ -1936,11 +1946,11 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 	    if (next)
 		resize_free_seg(map, next, new_end, next->end);
 	    else
-		ad_sz = alloc_desc_insert_free_seg(map, new_end, end);
+		ad_sz = alloc_desc_insert_free_seg(mm, map, new_end, end);
 	    ERTS_MMAP_ASSERT(old_size - asize >= ad_sz);
 	    unres_sz = old_size - asize - ad_sz;
 	    if (unres_sz)
-		mmap_state.unreserve_physical(((char *) ptr) + asize + ad_sz,
+		mm->unreserve_physical(((char *) ptr) + asize + ad_sz,
 					      unres_sz);
 	    goto supercarrier_resize_success;
 	}
@@ -1950,17 +1960,17 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 	    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(old_size));
 	    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(asize));
 
-	    adjacent_free_seg(&mmap_state.sua.map, start, end, &prev, &next);
+	    adjacent_free_seg(&mm->sua.map, start, end, &prev, &next);
 
 	    if (next && new_end <= next->end) {
-		if (!mmap_state.reserve_physical(((char *) ptr) + old_size,
+		if (!mm->reserve_physical(((char *) ptr) + old_size,
 						 asize - old_size))
 		    goto supercarrier_reserve_failure;
 		if (new_end < next->end)
-		    resize_free_seg(&mmap_state.sua.map, next, new_end, next->end);
+		    resize_free_seg(&mm->sua.map, next, new_end, next->end);
 		else {
-		    delete_free_seg(&mmap_state.sua.map, next);
-		    free_desc(next);
+		    delete_free_seg(&mm->sua.map, next);
+		    free_desc(mm, next);
 		}
 		new_ptr = ptr;
 		ERTS_MMAP_SIZE_SC_SUA_INC(asize - old_size);
@@ -1969,28 +1979,28 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 	}
 	else { /* Superaligned area */
 
-	    if (end == mmap_state.sa.top) {
-		if (new_end <= mmap_state.sua.bot) {
-		    if (!mmap_state.reserve_physical(((char *) ptr) + old_size,
+	    if (end == mm->sa.top) {
+		if (new_end <= mm->sua.bot) {
+		    if (!mm->reserve_physical(((char *) ptr) + old_size,
 						     asize - old_size))
 			goto supercarrier_reserve_failure;
-		    mmap_state.sa.top = new_end;
+		    mm->sa.top = new_end;
 		    new_ptr = ptr;
 		    ERTS_MMAP_SIZE_SC_SA_INC(asize - old_size);
 		    goto supercarrier_resize_success;
 		}
 	    }
 	    else {
-		adjacent_free_seg(&mmap_state.sa.map, start, end, &prev, &next);
+		adjacent_free_seg(&mm->sa.map, start, end, &prev, &next);
 		if (next && new_end <= next->end) {
-		    if (!mmap_state.reserve_physical(((char *) ptr) + old_size,
+		    if (!mm->reserve_physical(((char *) ptr) + old_size,
 						     asize - old_size))
 			goto supercarrier_reserve_failure;
 		    if (new_end < next->end)
-			resize_free_seg(&mmap_state.sa.map, next, new_end, next->end);
+			resize_free_seg(&mm->sa.map, next, new_end, next->end);
 		    else {
-			delete_free_seg(&mmap_state.sa.map, next);
-			free_desc(next);
+			delete_free_seg(&mm->sa.map, next);
+			free_desc(mm, next);
 		    }
 		    new_ptr = ptr;
 		    ERTS_MMAP_SIZE_SC_SA_INC(asize - old_size);
@@ -2000,12 +2010,12 @@ erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
 	}
 
 	ERTS_MMAP_OP_ABORT();
-	erts_smp_mtx_unlock(&mmap_state.mtx);
+	erts_smp_mtx_unlock(&mm->mtx);
 
 	/* Failed to resize... */
     }
 
-    return remap_move(flags, ptr, old_size, sizep);
+    return remap_move(mm, flags, ptr, old_size, sizep);
 
 supercarrier_resize_success:
 
@@ -2022,25 +2032,24 @@ supercarrier_resize_success:
 #endif
 
     ERTS_MREMAP_OP_END(new_ptr, asize);
-    erts_smp_mtx_unlock(&mmap_state.mtx);
+    erts_smp_mtx_unlock(&mm->mtx);
 
     *sizep = asize;
     return new_ptr;
 
 supercarrier_reserve_failure:
     ERTS_MREMAP_OP_END(NULL, old_size);
-    erts_smp_mtx_unlock(&mmap_state.mtx);
+    erts_smp_mtx_unlock(&mm->mtx);
     *sizep = old_size;
     return NULL;
     
 }
 
-int erts_mmap_in_supercarrier(void *ptr)
+int erts_mmap_in_supercarrier(ErtsMemMapper* mm, void *ptr)
 {
     return ERTS_MMAP_IN_SUPERCARRIER(ptr);
 }
 
-
 static struct {
     Eterm total;
     Eterm total_sa;
@@ -2103,8 +2112,9 @@ static void hard_dbg_mseg_init(void);
 #endif
 
 void
-erts_mmap_init(ErtsMMapInit *init)
+erts_mmap_init(ErtsMemMapper* mm, ErtsMMapInit *init)
 {
+    static int is_first_call = 1;
     int virtual_map = 0;
     char *start = NULL, *end = NULL;
     UWord pagesize;
@@ -2131,20 +2141,20 @@ erts_mmap_init(ErtsMMapInit *init)
 
     ERTS_MMAP_OP_RINGBUF_INIT();
 
-    erts_have_erts_mmap = 0;
-
-    mmap_state.supercarrier = 0;
-    mmap_state.reserve_physical = reserve_noop;
-    mmap_state.unreserve_physical = unreserve_noop;
+    mm->supercarrier = 0;
+    mm->reserve_physical = reserve_noop;
+    mm->unreserve_physical = unreserve_noop;
 
 #if HAVE_MMAP && !defined(MAP_ANON)
-    mmap_state.mmap_fd = open("/dev/zero", O_RDWR);
-    if (mmap_state.mmap_fd < 0)
+    mm->mmap_fd = open("/dev/zero", O_RDWR);
+    if (mm->mmap_fd < 0)
 	erl_exit(-1, "erts_mmap: Failed to open /dev/zero\n");
 #endif
 
-    erts_smp_mtx_init(&mmap_state.mtx, "erts_mmap");
-    erts_mtx_init(&am.init_mutex, "mmap_init_atoms");
+    erts_smp_mtx_init(&mm->mtx, "erts_mmap");
+    if (is_first_call) {
+        erts_mtx_init(&am.init_mutex, "mmap_init_atoms");
+    }
 
 #ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
     if (init->virtual_range.start) {
@@ -2160,8 +2170,8 @@ erts_mmap_init(ErtsMMapInit *init)
 	sz = start - ptr;
 	if (sz)
 	    os_munmap(end, sz);
-	mmap_state.reserve_physical = os_reserve_physical;
-	mmap_state.unreserve_physical = os_unreserve_physical;
+	mm->reserve_physical = os_reserve_physical;
+	mm->unreserve_physical = os_unreserve_physical;
 	virtual_map = 1;
     }
     else
@@ -2179,8 +2189,8 @@ erts_mmap_init(ErtsMMapInit *init)
 #ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
 	if (!init->scrpm) {
 	    start = os_mmap_virtual(NULL, sz);
-	    mmap_state.reserve_physical = os_reserve_physical;
-	    mmap_state.unreserve_physical = os_unreserve_physical;
+	    mm->reserve_physical = os_reserve_physical;
+	    mm->unreserve_physical = os_unreserve_physical;
 	    virtual_map = 1;
 	}
 	else
@@ -2206,34 +2216,32 @@ erts_mmap_init(ErtsMMapInit *init)
 	}
 #endif
     }
-    if (!mmap_state.no_os_mmap)
-	erts_have_erts_mmap |= ERTS_HAVE_ERTS_OS_MMAP;
 #endif
 
-    mmap_state.no.free_seg_descs = 0;
-    mmap_state.no.free_segs.curr = 0;
-    mmap_state.no.free_segs.max = 0;
+    mm->no.free_seg_descs = 0;
+    mm->no.free_segs.curr = 0;
+    mm->no.free_segs.max = 0;
 
-    mmap_state.size.supercarrier.total = 0;
-    mmap_state.size.supercarrier.used.total = 0;
-    mmap_state.size.supercarrier.used.sa = 0;
-    mmap_state.size.supercarrier.used.sua = 0;
-    mmap_state.size.os.used = 0;
+    mm->size.supercarrier.total = 0;
+    mm->size.supercarrier.used.total = 0;
+    mm->size.supercarrier.used.sa = 0;
+    mm->size.supercarrier.used.sua = 0;
+    mm->size.os.used = 0;
 
-    mmap_state.desc.new_area_hint = NULL;
+    mm->desc.new_area_hint = NULL;
 
     if (!start) {
-	mmap_state.sa.bot = NULL;
-	mmap_state.sua.top = NULL;
-	mmap_state.sa.bot = NULL;
-	mmap_state.sua.top = NULL;
-	mmap_state.no_os_mmap = 0;
-        mmap_state.supercarrier = 0;
+	mm->sa.bot = NULL;
+	mm->sua.top = NULL;
+	mm->sa.bot = NULL;
+	mm->sua.top = NULL;
+	mm->no_os_mmap = 0;
+        mm->supercarrier = 0;
     }
     else {
 	size_t desc_size;
 
-	mmap_state.no_os_mmap = init->sco;
+	mm->no_os_mmap = init->sco;
 
 	desc_size = init->scrfsd;
 	if (desc_size < 100)
@@ -2244,66 +2252,73 @@ erts_mmap_init(ErtsMMapInit *init)
 	     + ERTS_PAGEALIGNED_SIZE) > end - start)
 	    erl_exit(-1, "erts_mmap: No space for segments in super carrier\n");
 
-	mmap_state.sa.bot = start;
-	mmap_state.sa.bot += desc_size;
-	mmap_state.sa.bot = (char *) ERTS_SUPERALIGNED_CEILING(mmap_state.sa.bot);
-	mmap_state.sa.top = mmap_state.sa.bot;
-	mmap_state.sua.top = end;
-	mmap_state.sua.bot = mmap_state.sua.top;
+	mm->sa.bot = start;
+	mm->sa.bot += desc_size;
+	mm->sa.bot = (char *) ERTS_SUPERALIGNED_CEILING(mm->sa.bot);
+	mm->sa.top = mm->sa.bot;
+	mm->sua.top = end;
+	mm->sua.bot = mm->sua.top;
 
-	mmap_state.size.supercarrier.used.total += (UWord) (mmap_state.sa.bot - start);
+	mm->size.supercarrier.used.total += (UWord) (mm->sa.bot - start);
 
-	mmap_state.desc.free_list = NULL;
-        mmap_state.desc.reserved = 0;
+	mm->desc.free_list = NULL;
+        mm->desc.reserved = 0;
 
 	if (end == (void *) 0) {
 	    /*
 	     * Very unlikely, but we need a guarantee
-	     * that `mmap_state.sua.top` always will
+	     * that `mm->sua.top` always will
 	     * compare as larger than all segment pointers
 	     * into the super carrier...
 	     */
-	    mmap_state.sua.top -= ERTS_PAGEALIGNED_SIZE;
-	    mmap_state.size.supercarrier.used.total += ERTS_PAGEALIGNED_SIZE;
+	    mm->sua.top -= ERTS_PAGEALIGNED_SIZE;
+	    mm->size.supercarrier.used.total += ERTS_PAGEALIGNED_SIZE;
 #ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
-	    if (!virtual_map || os_reserve_physical(mmap_state.sua.top, ERTS_PAGEALIGNED_SIZE))
+	    if (!virtual_map || os_reserve_physical(mm->sua.top, ERTS_PAGEALIGNED_SIZE))
 #endif
-		add_free_desc_area(mmap_state.sua.top, end);
-            mmap_state.desc.reserved += (end - mmap_state.sua.top) / sizeof(ErtsFreeSegDesc);
+		add_free_desc_area(mm, mm->sua.top, end);
+            mm->desc.reserved += (end - mm->sua.top) / sizeof(ErtsFreeSegDesc);
 	}
 
-	mmap_state.size.supercarrier.total = (UWord) (mmap_state.sua.top - start);
+	mm->size.supercarrier.total = (UWord) (mm->sua.top - start);
 
 	/*
 	 * Area before (and after) super carrier
 	 * will be used for free segment descritors.
 	 */
 #ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
-	if (virtual_map && !os_reserve_physical(start, mmap_state.sa.bot - start))
+	if (virtual_map && !os_reserve_physical(start, mm->sa.bot - start))
 	    erl_exit(-1, "erts_mmap: Failed to reserve physical memory for descriptors\n");
 #endif
-	mmap_state.desc.unused_start = start;
-	mmap_state.desc.unused_end = mmap_state.sa.bot;
-        mmap_state.desc.reserved += ((mmap_state.desc.unused_end - start)
+	mm->desc.unused_start = start;
+	mm->desc.unused_end = mm->sa.bot;
+        mm->desc.reserved += ((mm->desc.unused_end - start)
                                      / sizeof(ErtsFreeSegDesc));
 
-	init_free_seg_map(&mmap_state.sa.map, SA_SZ_ADDR_ORDER);
-	init_free_seg_map(&mmap_state.sua.map, SZ_REVERSE_ADDR_ORDER);
+	init_free_seg_map(&mm->sa.map, SA_SZ_ADDR_ORDER);
+	init_free_seg_map(&mm->sua.map, SZ_REVERSE_ADDR_ORDER);
 
-	mmap_state.supercarrier = 1;
-	erts_have_erts_mmap |= ERTS_HAVE_ERTS_SUPERCARRIER_MMAP;
+	mm->supercarrier = 1;
 
-	mmap_state.desc.new_area_hint = end;
+	mm->desc.new_area_hint = end;
 
     }
 
 #if !ERTS_HAVE_OS_MMAP
-    mmap_state.no_os_mmap = 1;
+    mm->no_os_mmap = 1;
 #endif
 
 #ifdef HARD_DEBUG_MSEG
     hard_dbg_mseg_init();
 #endif
+
+#if defined(ARCH_64) && defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+   if (mm == &erts_literal_mmapper) {
+       erts_literals_start = erts_literal_mmapper.sa.bot;
+       erts_literals_size  = erts_literal_mmapper.sua.top - erts_literals_start;
+    }
+#endif
+    is_first_call = 0;
 }
 
 
@@ -2313,7 +2328,8 @@ add_2tup(Uint **hpp, Uint *szp, Eterm *lp, Eterm el1, Eterm el2)
     *lp = erts_bld_cons(hpp, szp, erts_bld_tuple(hpp, szp, 2, el1, el2), *lp);
 }
 
-Eterm erts_mmap_info(int *print_to_p,
+Eterm erts_mmap_info(ErtsMemMapper* mm,
+                     int *print_to_p,
                      void *print_to_arg,
                      Eterm** hpp, Uint* szp,
                      struct erts_mmap_info_struct* emis)
@@ -2328,29 +2344,29 @@ Eterm erts_mmap_info(int *print_to_p,
     Eterm res = THE_NON_VALUE;
 
     if (!hpp) {
-        erts_smp_mtx_lock(&mmap_state.mtx);
-        emis->sizes[0] = mmap_state.size.supercarrier.total;
-        emis->sizes[1] = mmap_state.sa.top  - mmap_state.sa.bot;
-        emis->sizes[2] = mmap_state.sua.top - mmap_state.sua.bot;
-        emis->sizes[3] = mmap_state.size.supercarrier.used.total;
-        emis->sizes[4] = mmap_state.size.supercarrier.used.sa;
-        emis->sizes[5] = mmap_state.size.supercarrier.used.sua;
+        erts_smp_mtx_lock(&mm->mtx);
+        emis->sizes[0] = mm->size.supercarrier.total;
+        emis->sizes[1] = mm->sa.top  - mm->sa.bot;
+        emis->sizes[2] = mm->sua.top - mm->sua.bot;
+        emis->sizes[3] = mm->size.supercarrier.used.total;
+        emis->sizes[4] = mm->size.supercarrier.used.sa;
+        emis->sizes[5] = mm->size.supercarrier.used.sua;
 
-        emis->segs[0] = mmap_state.no.free_segs.curr;
-        emis->segs[1] = mmap_state.no.free_segs.max;
-        emis->segs[2] = mmap_state.no.free_seg_descs;
-        emis->segs[3] = mmap_state.desc.reserved;
-        emis->segs[4] = mmap_state.sa.map.nseg;
-        emis->segs[5] = mmap_state.sua.map.nseg;
+        emis->segs[0] = mm->no.free_segs.curr;
+        emis->segs[1] = mm->no.free_segs.max;
+        emis->segs[2] = mm->no.free_seg_descs;
+        emis->segs[3] = mm->desc.reserved;
+        emis->segs[4] = mm->sa.map.nseg;
+        emis->segs[5] = mm->sua.map.nseg;
 
-        emis->os_used = mmap_state.size.os.used;
-        erts_smp_mtx_unlock(&mmap_state.mtx);
+        emis->os_used = mm->size.os.used;
+        erts_smp_mtx_unlock(&mm->mtx);
     }
 
     if (print_to_p) {
         int to = *print_to_p;
 	void *arg = print_to_arg;
-        if (mmap_state.supercarrier) {
+        if (mm->supercarrier) {
             const char* prefix = "supercarrier ";
             erts_print(to, arg, "%stotal size: %bpu\n", prefix, emis->sizes[0]);
             erts_print(to, arg, "%stotal sa size: %bpu\n", prefix, emis->sizes[1]);
@@ -2365,7 +2381,7 @@ Eterm erts_mmap_info(int *print_to_p,
             erts_print(to, arg, "%ssa free segs: %bpu\n", prefix, emis->segs[4]);
             erts_print(to, arg, "%ssua free segs: %bpu\n", prefix, emis->segs[5]);
         }
-        if (!mmap_state.no_os_mmap) {
+        if (!mm->no_os_mmap) {
             erts_print(to, arg, "os mmap size used: %bpu\n", emis->os_used);
         }
     }
@@ -2377,7 +2393,7 @@ Eterm erts_mmap_info(int *print_to_p,
         }
 
         lix = 0;
-        if (mmap_state.supercarrier) {
+        if (mm->supercarrier) {
             group[0] = erts_bld_atom_uword_2tup_list(hpp, szp,
                                                      sizeof(size_tags)/sizeof(Eterm),
                                                      size_tags, emis->sizes);
@@ -2389,7 +2405,7 @@ Eterm erts_mmap_info(int *print_to_p,
             lix++;
         }
 
-        if (!mmap_state.no_os_mmap) {
+        if (!mm->no_os_mmap) {
             group[0] = erts_bld_atom_uword_2tup_list(hpp, szp,
                                                       1, &am.used, &emis->os_used);
             list[lix] = erts_bld_2tup_list(hpp, szp, 1, group_tags, group);
@@ -2401,25 +2417,26 @@ Eterm erts_mmap_info(int *print_to_p,
     return res;
 }
 
-Eterm erts_mmap_info_options(char *prefix,
+Eterm erts_mmap_info_options(ErtsMemMapper* mm,
+                             char *prefix,
                              int *print_to_p,
                              void *print_to_arg,
                              Uint **hpp,
                              Uint *szp)
 {
-    const UWord scs = mmap_state.sua.top - mmap_state.sa.bot;
-    const Eterm sco = mmap_state.no_os_mmap ? am_true : am_false;
-    const Eterm scrpm = (mmap_state.reserve_physical == reserve_noop) ? am_true : am_false;
+    const UWord scs = mm->sua.top - mm->sa.bot;
+    const Eterm sco = mm->no_os_mmap ? am_true : am_false;
+    const Eterm scrpm = (mm->reserve_physical == reserve_noop) ? am_true : am_false;
     Eterm res = THE_NON_VALUE;
 
     if (print_to_p) {
         int to = *print_to_p;
 	void *arg = print_to_arg;
         erts_print(to, arg, "%sscs: %bpu\n", prefix, scs);
-        if (mmap_state.supercarrier) {
+        if (mm->supercarrier) {
             erts_print(to, arg, "%ssco: %T\n", prefix, sco);
             erts_print(to, arg, "%sscrpm: %T\n", prefix, scrpm);
-            erts_print(to, arg, "%sscrfsd: %beu\n", prefix, mmap_state.desc.reserved);
+            erts_print(to, arg, "%sscrfsd: %beu\n", prefix, mm->desc.reserved);
         }
     }
 
@@ -2429,9 +2446,9 @@ Eterm erts_mmap_info_options(char *prefix,
         }
 
         res = NIL;
-        if (mmap_state.supercarrier) {
+        if (mm->supercarrier) {
             add_2tup(hpp, szp, &res, am.scrfsd,
-                     erts_bld_uint(hpp,szp, mmap_state.desc.reserved));
+                     erts_bld_uint(hpp,szp, mm->desc.reserved));
             add_2tup(hpp, szp, &res, am.scrpm, scrpm);
             add_2tup(hpp, szp, &res, am.sco, sco);
         }
@@ -2441,9 +2458,9 @@ Eterm erts_mmap_info_options(char *prefix,
 }
 
 
-Eterm erts_mmap_debug_info(Process* p)
+Eterm erts_mmap_debug_info(ErtsMemMapper* mm, Process* p)
 {
-    if (mmap_state.supercarrier) {
+    if (mm->supercarrier) {
         ERTS_DECL_AM(sabot);
         ERTS_DECL_AM(satop);
         ERTS_DECL_AM(suabot);
@@ -2454,14 +2471,14 @@ Eterm erts_mmap_debug_info(Process* p)
         Eterm *hp, *hp_end;
         Uint may_need;
 
-        erts_smp_mtx_lock(&mmap_state.mtx);
-        values[0] = (UWord)mmap_state.sa.bot;
-        values[1] = (UWord)mmap_state.sa.top;
-        values[2] = (UWord)mmap_state.sua.bot;
-        values[3] = (UWord)mmap_state.sua.top;
-        sa_list = build_free_seg_list(p, &mmap_state.sa.map);
-        sua_list = build_free_seg_list(p, &mmap_state.sua.map);
-        erts_smp_mtx_unlock(&mmap_state.mtx);
+        erts_smp_mtx_lock(&mm->mtx);
+        values[0] = (UWord)mm->sa.bot;
+        values[1] = (UWord)mm->sa.top;
+        values[2] = (UWord)mm->sua.bot;
+        values[3] = (UWord)mm->sua.top;
+        sa_list = build_free_seg_list(p, &mm->sa.map);
+        sua_list = build_free_seg_list(p, &mm->sua.map);
+        erts_smp_mtx_unlock(&mm->mtx);
 
         may_need = 4*(2+3+2) + 2*(2+3);
         hp = HAlloc(p, may_need);
diff --git a/erts/emulator/sys/common/erl_mmap.h b/erts/emulator/sys/common/erl_mmap.h
index 66619c5161..61d912fd28 100644
--- a/erts/emulator/sys/common/erl_mmap.h
+++ b/erts/emulator/sys/common/erl_mmap.h
@@ -30,9 +30,6 @@
 #define ERTS_MMAPFLG_SUPERCARRIER_ONLY		(((Uint32) 1) << 1)
 #define ERTS_MMAPFLG_SUPERALIGNED		(((Uint32) 1) << 2)
 
-#define ERTS_HAVE_ERTS_OS_MMAP			(1 << 0)
-#define ERTS_HAVE_ERTS_SUPERCARRIER_MMAP	(1 << 1)
-extern int erts_have_erts_mmap;
 extern UWord erts_page_inv_mask;
 
 typedef struct {
@@ -53,23 +50,29 @@ typedef struct {
 #define ERTS_MMAP_INIT_DEFAULT_INITER \
     {{NULL, NULL}, {NULL, NULL}, 0, 1, (1 << 16), 1}
 
-void *erts_mmap(Uint32 flags, UWord *sizep);
-void erts_munmap(Uint32 flags, void *ptr, UWord size);
-void *erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep);
-int erts_mmap_in_supercarrier(void *ptr);
-void erts_mmap_init(ErtsMMapInit*);
+#define ERTS_MMAP_INIT_LITERAL_INITER \
+    {{NULL, NULL}, {NULL, NULL}, 1024*1024*1024, 1, (1 << 16), 0}
+
+typedef struct ErtsMemMapper_ ErtsMemMapper;
+
+void *erts_mmap(ErtsMemMapper*, Uint32 flags, UWord *sizep);
+void erts_munmap(ErtsMemMapper*, Uint32 flags, void *ptr, UWord size);
+void *erts_mremap(ErtsMemMapper*, Uint32 flags, void *ptr, UWord old_size, UWord *sizep);
+int erts_mmap_in_supercarrier(ErtsMemMapper*, void *ptr);
+void erts_mmap_init(ErtsMemMapper*, ErtsMMapInit*);
 struct erts_mmap_info_struct
 {
     UWord sizes[6];
     UWord segs[6];
     UWord os_used;
 };
-Eterm erts_mmap_info(int *print_to_p, void *print_to_arg,
+Eterm erts_mmap_info(ErtsMemMapper*, int *print_to_p, void *print_to_arg,
                      Eterm** hpp, Uint* szp, struct erts_mmap_info_struct*);
-Eterm erts_mmap_info_options(char *prefix, int *print_to_p, void *print_to_arg,
+Eterm erts_mmap_info_options(ErtsMemMapper*,
+                             char *prefix, int *print_to_p, void *print_to_arg,
                              Uint **hpp, Uint *szp);
 struct process;
-Eterm erts_mmap_debug_info(struct process*);
+Eterm erts_mmap_debug_info(ErtsMemMapper*, struct process*);
 
 #define ERTS_SUPERALIGNED_SIZE \
     (1 << ERTS_MMAP_SUPERALIGNED_BITS)
@@ -121,6 +124,11 @@ Eterm erts_mmap_debug_info(struct process*);
 #  define ERTS_HAVE_OS_MMAP 1
 #endif
 
+extern ErtsMemMapper erts_dflt_mmapper;
+#if defined(ARCH_64) && defined(ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION)
+extern ErtsMemMapper erts_literal_mmapper;
+#endif
+
 /*#define HARD_DEBUG_MSEG*/
 #ifdef HARD_DEBUG_MSEG
 #  define HARD_DBG_INSERT_MSEG hard_dbg_insert_mseg
diff --git a/erts/emulator/sys/common/erl_mseg.c b/erts/emulator/sys/common/erl_mseg.c
index 7eb8a4a460..20695899eb 100644
--- a/erts/emulator/sys/common/erl_mseg.c
+++ b/erts/emulator/sys/common/erl_mseg.c
@@ -291,7 +291,7 @@ mseg_create(ErtsMsegAllctr_t *ma, Uint flags, UWord *sizep)
     if (MSEG_FLG_IS_2POW(flags))
 	mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
 
-    seg = erts_mmap(mmap_flags, sizep);
+    seg = erts_mmap(&erts_dflt_mmapper, mmap_flags, sizep);
 
 #ifdef ERTS_PRINT_ERTS_MMAP
     erts_fprintf(stderr, "%p = erts_mmap(%s, {%bpu, %bpu});\n", seg,
@@ -311,7 +311,7 @@ mseg_destroy(ErtsMsegAllctr_t *ma, Uint flags, void *seg_p, UWord size) {
     if (MSEG_FLG_IS_2POW(flags))
 	 mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
 
-    erts_munmap(mmap_flags, seg_p, size);
+    erts_munmap(&erts_dflt_mmapper, mmap_flags, seg_p, size);
 #ifdef ERTS_PRINT_ERTS_MMAP
     erts_fprintf(stderr, "erts_munmap(%s, %p, %bpu);\n",
 		 (mmap_flags & ERTS_MMAPFLG_SUPERALIGNED) ? "sa" : "sua",
@@ -332,7 +332,7 @@ mseg_recreate(ErtsMsegAllctr_t *ma, Uint flags, void *old_seg, UWord old_size, U
     if (MSEG_FLG_IS_2POW(flags))
 	mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
 
-    new_seg = erts_mremap(mmap_flags, old_seg, old_size, sizep);
+    new_seg = erts_mremap(&erts_dflt_mmapper, mmap_flags, old_seg, old_size, sizep);
 
 #ifdef ERTS_PRINT_ERTS_MMAP
     erts_fprintf(stderr, "%p = erts_mremap(%s, %p, %bpu, {%bpu, %bpu});\n",
@@ -997,7 +997,8 @@ info_options(ErtsMsegAllctr_t *ma,
 {
     Eterm res;
 
-    res = erts_mmap_info_options(prefix, print_to_p, print_to_arg, hpp, szp);
+    res = erts_mmap_info_options(&erts_dflt_mmapper,
+                                 prefix, print_to_p, print_to_arg, hpp, szp);
 
     if (print_to_p) {
 	int to = *print_to_p;
@@ -1401,7 +1402,7 @@ erts_mseg_init(ErtsMsegInit_t *init)
 
     erts_mtx_init(&init_atoms_mutex, "mseg_init_atoms");
 
-    erts_mmap_init(&init->mmap);
+    erts_mmap_init(&erts_dflt_mmapper, &init->dflt_mmap);
 
     if (!IS_2POW(GET_PAGE_SIZE))
 	erl_exit(ERTS_ABORT_EXIT, "erts_mseg: Unexpected page_size %beu\n", GET_PAGE_SIZE);
diff --git a/erts/emulator/sys/common/erl_mseg.h b/erts/emulator/sys/common/erl_mseg.h
index 656484702d..2acd8f8505 100644
--- a/erts/emulator/sys/common/erl_mseg.h
+++ b/erts/emulator/sys/common/erl_mseg.h
@@ -42,16 +42,6 @@
 
 #if ERTS_HAVE_MSEG_SUPER_ALIGNED
 #  define MSEG_ALIGN_BITS ERTS_MMAP_SUPERALIGNED_BITS
-#else
-/* If we don't use super aligned multiblock carriers
- * we will mmap with page size alignment (and thus use corresponding
- * align bits).
- *
- * Current implementation needs this to be a constant and
- * only uses this for user dev testing so setting page size
- * to 4096 (12 bits) is fine.
- */
-#  define MSEG_ALIGN_BITS       (12)
 #endif
 
 #if HAVE_ERTS_MSEG
@@ -69,7 +59,8 @@ typedef struct {
     Uint rmcbf;
     Uint mcs;
     Uint nos;
-    ErtsMMapInit mmap;
+    ErtsMMapInit dflt_mmap;
+    ErtsMMapInit literal_mmap;
 } ErtsMsegInit_t;
 
 #define ERTS_MSEG_INIT_DEFAULT_INITIALIZER				\
@@ -78,7 +69,8 @@ typedef struct {
     20,			/* rmcbf: Relative max cache bad fit	*/	\
     10,			/* mcs:   Max cache size		*/	\
     1000,		/* cci:   Cache check interval		*/	\
-    ERTS_MMAP_INIT_DEFAULT_INITER					\
+    ERTS_MMAP_INIT_DEFAULT_INITER,					\
+    ERTS_MMAP_INIT_LITERAL_INITER                                       \
 }
 
 typedef struct {