File 1493-erts-Optimize-fun-calls.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1493-erts-Optimize-fun-calls.patch of Package erlang (Revision ab0a80da32d4196c3293bfd6d0ac4245)

Currently displaying revision ab0a80da32d4196c3293bfd6d0ac4245 , Show latest

From 0685f97a78f175d8c409429c9894592ecb0c7ac9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20H=C3=B6gberg?= <john@erlang.org>
Date: Mon, 27 Sep 2021 16:32:44 +0200
Subject: [PATCH 3/3] erts: Optimize fun calls

By making local and external funs share the same structure, we can
remove a substantial amount of code from the `call_fun` family of
instructions.

As a result fun calls are now about 15% faster with the interpreter
on my machine, 10% faster with the x64 JIT on that same machine,
and 15% faster with the AArch64 JIT on my M1 Mac. The improvement
is a bit less pronounced for funs with free variables, and a bit
more for those without (including external funs).
---
 erts/emulator/beam/beam_bif_load.c            |   3 +-
 erts/emulator/beam/beam_common.c              | 293 ++++++--------
 erts/emulator/beam/beam_common.h              |  77 ++--
 erts/emulator/beam/beam_debug.c               |   2 +-
 erts/emulator/beam/beam_load.c                |   9 +-
 erts/emulator/beam/bif.c                      |  38 +-
 erts/emulator/beam/bif.h                      |   2 +-
 erts/emulator/beam/code_ix.h                  |  14 +
 erts/emulator/beam/copy.c                     | 112 ++++--
 erts/emulator/beam/dist.c                     |   2 +-
 erts/emulator/beam/emu/beam_emu.c             |  18 +-
 erts/emulator/beam/emu/emu_load.c             |   8 +-
 erts/emulator/beam/emu/instrs.tab             |   6 +-
 erts/emulator/beam/emu/macros.tab             |   4 +-
 erts/emulator/beam/emu/trace_instrs.tab       |   2 +-
 erts/emulator/beam/erl_bif_info.c             | 214 +++++-----
 erts/emulator/beam/erl_bif_op.c               |   9 +-
 erts/emulator/beam/erl_bif_trace.c            |   6 +-
 erts/emulator/beam/erl_db_util.c              |  40 +-
 erts/emulator/beam/erl_fun.c                  | 183 ++++++---
 erts/emulator/beam/erl_fun.h                  |  70 +++-
 erts/emulator/beam/erl_gc.c                   |  68 +++-
 erts/emulator/beam/erl_map.c                  |  13 +-
 erts/emulator/beam/erl_message.c              |   9 +-
 erts/emulator/beam/erl_nif.c                  |   3 +-
 erts/emulator/beam/erl_printf_term.c          | 101 ++---
 erts/emulator/beam/erl_process_dump.c         |   2 +-
 erts/emulator/beam/erl_term.c                 |   3 +-
 erts/emulator/beam/erl_term.h                 |  28 +-
 erts/emulator/beam/export.c                   |  31 +-
 erts/emulator/beam/export.h                   |  21 +-
 erts/emulator/beam/external.c                 | 255 ++++++------
 erts/emulator/beam/global.h                   |   8 +-
 erts/emulator/beam/jit/arm/beam_asm.hpp       |  23 +-
 .../emulator/beam/jit/arm/beam_asm_global.cpp |   4 +-
 erts/emulator/beam/jit/arm/instr_bif.cpp      |   2 +-
 erts/emulator/beam/jit/arm/instr_call.cpp     |  10 +-
 erts/emulator/beam/jit/arm/instr_common.cpp   |  21 +-
 erts/emulator/beam/jit/arm/instr_fun.cpp      |  73 ++--
 erts/emulator/beam/jit/arm/instr_trace.cpp    |   2 +-
 erts/emulator/beam/jit/asm_load.c             |   4 +-
 erts/emulator/beam/jit/beam_jit_common.cpp    |   4 +-
 erts/emulator/beam/jit/x86/beam_asm.hpp       |  25 +-
 .../emulator/beam/jit/x86/beam_asm_global.cpp |   4 +-
 erts/emulator/beam/jit/x86/instr_bif.cpp      |   2 +-
 erts/emulator/beam/jit/x86/instr_call.cpp     |  12 +-
 erts/emulator/beam/jit/x86/instr_common.cpp   |  27 +-
 erts/emulator/beam/jit/x86/instr_fun.cpp      |  59 ++-
 erts/emulator/beam/jit/x86/instr_trace.cpp    |   2 +-
 erts/emulator/beam/utils.c                    | 371 ++++++++++--------
 erts/emulator/internal_doc/BeamAsm.md         |  10 +-
 erts/emulator/test/erts_debug_SUITE.erl       |   3 +-
 52 files changed, 1210 insertions(+), 1102 deletions(-)

diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index e982ef5a7d..744e8723ee 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -870,7 +870,8 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
             DBG_CHECK_EXPORT(ep, code_ix);
 
             if (ep->trampoline.not_loaded.deferred != 0) {
-                    ep->addresses[code_ix] = (void*)ep->trampoline.not_loaded.deferred;
+                    ep->dispatch.addresses[code_ix] =
+                        (void*)ep->trampoline.not_loaded.deferred;
                     ep->trampoline.not_loaded.deferred = 0;
             } else {
                 if (ep->bif_number != -1) {
diff --git a/erts/emulator/beam/beam_common.c b/erts/emulator/beam/beam_common.c
index c9b8dfb51d..2f713bb4d5 100644
--- a/erts/emulator/beam/beam_common.c
+++ b/erts/emulator/beam/beam_common.c
@@ -233,7 +233,7 @@ void erts_dirty_process_main(ErtsSchedulerData *esdp)
             if (ERTS_PROC_IS_EXITING(c_p)) {
                 sys_strcpy(fun_buf, "<exiting>");
             } else {
-                ErtsCodeMFA *cmfa = erts_find_function_from_pc(c_p->i);
+                const ErtsCodeMFA *cmfa = erts_find_function_from_pc(c_p->i);
                 if (cmfa) {
 		    dtrace_fun_decode(c_p, cmfa, NULL, fun_buf);
                 } else {
@@ -1709,161 +1709,126 @@ call_fun(Process* p,    /* Current process. */
          Eterm* reg,    /* Contents of registers. */
          Eterm args)    /* THE_NON_VALUE or pre-built list of arguments. */
 {
-    Eterm fun = reg[arity];
-    Eterm hdr;
-    int i;
-    Eterm* hp;
+    ErtsCodeIndex code_ix;
+    ErtsCodePtr code_ptr;
+    ErlFunThing *funp;
+    Eterm fun;
 
-    if (!is_boxed(fun)) {
-	goto badfun;
+    fun = reg[arity];
+
+    if (is_not_any_fun(fun)) {
+        p->current = NULL;
+        p->freason = EXC_BADFUN;
+        p->fvalue = fun;
+        return NULL;
     }
-    hdr = *boxed_val(fun);
 
-    if (is_fun_header(hdr)) {
-	ErlFunThing* funp = (ErlFunThing *) fun_val(fun);
-	ErlFunEntry* fe = funp->fe;
-	ErtsCodePtr code_ptr = fe->address;
-	Eterm* var_ptr;
-	unsigned num_free = funp->num_free;
-        const ErtsCodeMFA *mfa = erts_code_to_codemfa(code_ptr);
-	int actual_arity = mfa->arity;
+    funp = (ErlFunThing*)fun_val(fun);
 
-	if (actual_arity == arity+num_free) {
-	    DTRACE_LOCAL_CALL(p, mfa);
-	    if (num_free == 0) {
-		return code_ptr;
-	    } else {
-		var_ptr = funp->env;
-		reg += arity;
-		i = 0;
-		do {
-		    reg[i] = var_ptr[i];
-		    i++;
-		} while (i < num_free);
-		reg[i] = fun;
-		return code_ptr;
-	    }
-	    return code_ptr;
-	} else {
-	    /*
-	     * Something wrong here. First build a list of the arguments.
-	     */
+    code_ix = erts_active_code_ix();
+    code_ptr = (funp->entry.disp)->addresses[code_ix];
 
-	    if (is_non_value(args)) {
-		Uint sz = 2 * arity;
-		args = NIL;
-		if (HeapWordsLeft(p) < sz) {
-		    erts_garbage_collect(p, sz, reg, arity+1);
-		    fun = reg[arity];
-		}
-		hp = HEAP_TOP(p);
-		HEAP_TOP(p) += sz;
-		for (i = arity-1; i >= 0; i--) {
-		    args = CONS(hp, reg[i], args);
-		    hp += 2;
-		}
-	    }
+    if (ERTS_LIKELY(code_ptr != beam_unloaded_fun && funp->arity == arity)) {
+        for (int i = 0, num_free = funp->num_free; i < num_free; i++) {
+            reg[i + arity] = funp->env[i];
+        }
 
-	    if (actual_arity >= 0) {
-		/*
-		 * There is a fun defined, but the call has the wrong arity.
-		 */
-		hp = HAlloc(p, 3);
-		p->freason = EXC_BADARITY;
-		p->fvalue = TUPLE2(hp, fun, args);
-		return NULL;
-	    } else {
-		Export* ep;
-		Module* modp;
-		Eterm module;
-		ErtsCodeIndex code_ix = erts_active_code_ix();
-
-		/*
-		 * No arity. There is no module loaded that defines the fun,
-		 * either because the fun is newly created from the external
-		 * representation (the module has never been loaded),
-		 * or the module defining the fun has been unloaded.
-		 */
-
-		module = fe->module;
-
-		ERTS_THR_READ_MEMORY_BARRIER;
-		if (fe->pend_purge_address) {
-		    /*
-		     * The system is currently trying to purge the
-		     * module containing this fun. Suspend the process
-		     * and let it try again when the purge operation is
-		     * done (may succeed or not).
-		     */
-		    ep = erts_suspend_process_on_pending_purge_lambda(p, fe);
-		    ASSERT(ep);
-		}
-		else {
-		    if ((modp = erts_get_module(module, code_ix)) != 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
-			 * (or we will get into an infinite loop).
-			 */
-			goto badfun;
-		    }
+#ifdef USE_VM_CALL_PROBES
+        if (is_local_fun(funp)) {
+            DTRACE_LOCAL_CALL(p, erts_code_to_codemfa(code_ptr));
+        } else {
+            Export *ep = funp->entry.exp;
+            ASSERT(is_external_fun(funp) && funp->next == NULL);
+            DTRACE_GLOBAL_CALL(p, &ep->info.mfa);
+        }
+#endif
 
-		    /*
-		     * No current code for this module. Call the error_handler module
-		     * to attempt loading the module.
-		     */
-
-		    ep = erts_find_function(erts_proc_get_error_handler(p),
-					    am_undefined_lambda, 3, code_ix);
-		    if (ep == NULL) {	/* No error handler */
-			p->current = NULL;
-			p->freason = EXC_UNDEF;
-			return NULL;
-		    }
-		}
-		reg[0] = module;
-		reg[1] = fun;
-		reg[2] = args;
-		reg[3] = NIL;
-                return ep->addresses[code_ix];
-	    }
-	}
-    } else if (is_export_header(hdr)) {
-	Export *ep;
-	int actual_arity;
+        return code_ptr;
+    } else {
+        /* Something wrong here. First build a list of the arguments. */
+        if (is_non_value(args)) {
+            Uint sz = 2 * arity;
+            Eterm *hp;
 
-	ep = *((Export **) (export_val(fun) + 1));
-	actual_arity = ep->info.mfa.arity;
+            args = NIL;
 
-	if (arity == actual_arity) {
-            DTRACE_GLOBAL_CALL(p, &ep->info.mfa);
-            return ep->addresses[erts_active_code_ix()];
-	} else {
-	    /*
-	     * Wrong arity. First build a list of the arguments.
-	     */
+            if (HeapWordsLeft(p) < sz) {
+                erts_garbage_collect(p, sz, reg, arity+1);
 
-	    if (is_non_value(args)) {
-		args = NIL;
-		hp = HAlloc(p, arity*2);
-		for (i = arity-1; i >= 0; i--) {
-		    args = CONS(hp, reg[i], args);
-		    hp += 2;
-		}
-	    }
+                fun = reg[arity];
+                funp = (ErlFunThing*)fun_val(fun);
+            }
 
-	    hp = HAlloc(p, 3);
-	    p->freason = EXC_BADARITY;
-	    p->fvalue = TUPLE2(hp, fun, args);
-	    return NULL;
-	}
-    } else {
-    badfun:
-	p->current = NULL;
-	p->freason = EXC_BADFUN;
-	p->fvalue = fun;
-	return NULL;
+            hp = HEAP_TOP(p);
+            HEAP_TOP(p) += sz;
+
+            for (int i = arity - 1; i >= 0; i--) {
+                args = CONS(hp, reg[i], args);
+                hp += 2;
+            }
+        }
+
+        if (funp->arity != arity) {
+            /* There is a fun defined, but the call has the wrong arity. */
+            Eterm *hp = HAlloc(p, 3);
+            p->freason = EXC_BADARITY;
+            p->fvalue = TUPLE2(hp, fun, args);
+            return NULL;
+        } else {
+            ErlFunEntry *fe;
+            Eterm module;
+            Module *modp;
+            Export *ep;
+
+            /* There is no module loaded that defines the fun, either because
+             * the fun is newly created from the external representation (the
+             * module has never been loaded), or the module defining the fun
+             * has been unloaded. */
+            ASSERT(is_local_fun(funp) && code_ptr == beam_unloaded_fun);
+            fe = funp->entry.fun;
+            module = fe->module;
+
+            ERTS_THR_READ_MEMORY_BARRIER;
+            if (fe->pend_purge_address) {
+                /* The system is currently trying to purge the
+                 * module containing this fun. Suspend the process
+                 * and let it try again when the purge operation is
+                 * done (may succeed or not). */
+                ep = erts_suspend_process_on_pending_purge_lambda(p, fe);
+            } else {
+                if ((modp = erts_get_module(module, code_ix)) != 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
+                     * (or we will get into an infinite loop). */
+                    p->current = NULL;
+                    p->freason = EXC_BADFUN;
+                    p->fvalue = fun;
+                    return NULL;
+                }
+
+                /* No current code for this module. Call the error_handler
+                 * module to attempt loading the module. */
+
+                ep = erts_find_function(erts_proc_get_error_handler(p),
+                                        am_undefined_lambda, 3, code_ix);
+                if (ep == NULL) {
+                    /* No error handler */
+                    p->current = NULL;
+                    p->freason = EXC_UNDEF;
+                    return NULL;
+                }
+            }
+
+            ASSERT(ep);
+
+            reg[0] = module;
+            reg[1] = fun;
+            reg[2] = args;
+            reg[3] = NIL;
+
+            return ep->dispatch.addresses[code_ix];
+        }
     }
 }
 
@@ -1898,44 +1863,14 @@ apply_fun(Process* p, Eterm fun, Eterm args, Eterm* reg)
     return call_fun(p, arity, reg, args);
 }
 
-ErlFunThing*
-new_fun_thing(Process* p, ErlFunEntry* fe, int arity, int num_free)
-{
-    ErlFunThing* funp;
-
-    funp = (ErlFunThing*) p->htop;
-    p->htop += ERL_FUN_SIZE + num_free;
-    erts_refc_inc(&fe->refc, 2);
-
-    funp->thing_word = HEADER_FUN;
-    funp->next = MSO(p).first;
-    MSO(p).first = (struct erl_off_heap_header*) funp;
-    funp->fe = fe;
-    funp->num_free = num_free;
-    funp->creator = p->common.id;
-    funp->arity = arity;
-
-#ifdef DEBUG
-    {
-        const ErtsCodeMFA *mfa = erts_get_fun_mfa(fe);
-        ASSERT(funp->arity == mfa->arity - num_free);
-        ASSERT(arity == fe->arity);
-    }
-#endif
-
-    return funp;
-}
-
 int
 is_function2(Eterm Term, Uint arity)
 {
-    if (is_fun(Term)) {
-	ErlFunThing* funp = (ErlFunThing *) fun_val(Term);
-	return funp->arity == arity;
-    } else if (is_export(Term)) {
-	Export* exp = (Export *) (export_val(Term)[1]);
-	return exp->info.mfa.arity == arity;
+    if (is_any_fun(Term)) {
+        ErlFunThing *funp = (ErlFunThing*)fun_val(Term);
+        return funp->arity == arity;
     }
+
     return 0;
 }
 
diff --git a/erts/emulator/beam/beam_common.h b/erts/emulator/beam/beam_common.h
index 15bad673d0..8d453044e2 100644
--- a/erts/emulator/beam/beam_common.h
+++ b/erts/emulator/beam/beam_common.h
@@ -153,80 +153,81 @@ do {						\
 
 #ifdef USE_VM_CALL_PROBES
 
-#define DTRACE_LOCAL_CALL(p, mfa)					\
-    if (DTRACE_ENABLED(local_function_entry)) {				\
-        DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);		\
-        DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);			\
-        int depth = STACK_START(p) - STACK_TOP(p);			\
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);               \
-        DTRACE3(local_function_entry, process_name, mfa_buf, depth);	\
+#define DTRACE_LOCAL_CALL(p, cmfa)                                      \
+    if (DTRACE_ENABLED(local_function_entry)) {                         \
+        DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);             \
+        DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);                  \
+        int depth = STACK_START(p) - STACK_TOP(p);                      \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);              \
+        DTRACE3(local_function_entry, process_name, mfa_buf, depth);    \
     }
 
-#define DTRACE_GLOBAL_CALL(p, mfa)					\
-    if (DTRACE_ENABLED(global_function_entry)) {			\
-        DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);		\
-        DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);			\
-        int depth = STACK_START(p) - STACK_TOP(p);			\
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);               \
+#define DTRACE_GLOBAL_CALL(p, cmfa)                                     \
+    if (DTRACE_ENABLED(global_function_entry)) {	                    \
+        DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);             \
+        DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);                  \
+        int depth = STACK_START(p) - STACK_TOP(p);                      \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);              \
         DTRACE3(global_function_entry, process_name, mfa_buf, depth);	\
     }
 
-#define DTRACE_RETURN(p, mfa)                                    \
+#define DTRACE_RETURN(p, cmfa)                                  \
     if (DTRACE_ENABLED(function_return)) {                      \
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);     \
         DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);          \
         int depth = STACK_START(p) - STACK_TOP(p);              \
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);       \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);      \
         DTRACE3(function_return, process_name, mfa_buf, depth); \
     }
 
-#define DTRACE_BIF_ENTRY(p, mfa)                                    \
+#define DTRACE_BIF_ENTRY(p, cmfa)                                   \
     if (DTRACE_ENABLED(bif_entry)) {                                \
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);         \
         DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);              \
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);           \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);          \
         DTRACE2(bif_entry, process_name, mfa_buf);                  \
     }
 
-#define DTRACE_BIF_RETURN(p, mfa)                                   \
+#define DTRACE_BIF_RETURN(p, cmfa)                                  \
     if (DTRACE_ENABLED(bif_return)) {                               \
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);         \
         DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);              \
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);           \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);          \
         DTRACE2(bif_return, process_name, mfa_buf);                 \
     }
 
-#define DTRACE_NIF_ENTRY(p, mfa)                                        \
+#define DTRACE_NIF_ENTRY(p, cmfa)                                       \
     if (DTRACE_ENABLED(nif_entry)) {                                    \
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);             \
         DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);                  \
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);               \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);              \
         DTRACE2(nif_entry, process_name, mfa_buf);                      \
     }
 
-#define DTRACE_NIF_RETURN(p, mfa)                                       \
+#define DTRACE_NIF_RETURN(p, cmfa)                                      \
     if (DTRACE_ENABLED(nif_return)) {                                   \
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);             \
         DTRACE_CHARBUF(mfa_buf, DTRACE_TERM_BUF_SIZE);                  \
-        dtrace_fun_decode(p, mfa, process_name, mfa_buf);               \
+        dtrace_fun_decode(p, cmfa, process_name, mfa_buf);              \
         DTRACE2(nif_return, process_name, mfa_buf);                     \
     }
 
-#define DTRACE_GLOBAL_CALL_FROM_EXPORT(p,e)                                        \
-    do {                                                                           \
-        if (DTRACE_ENABLED(global_function_entry)) {                               \
-            ErtsCodePtr fp__ = (((Export *) (e))->addresses[erts_active_code_ix()]); \
-            DTRACE_GLOBAL_CALL((p), erts_code_to_codemfa(fp__));                   \
-        }                                                                          \
+#define DTRACE_GLOBAL_CALL_FROM_EXPORT(p,e)                               \
+    do {                                                                  \
+        if (DTRACE_ENABLED(global_function_entry)) {                      \
+            ErtsDispatchable *disp__ = &(e)->dispatch;                    \
+            ErtsCodePtr fp__ = disp__->addresses[erts_active_code_ix()];  \
+            DTRACE_GLOBAL_CALL((p), erts_code_to_codemfa(fp__));          \
+        }                                                                 \
     } while(0)
 
-#define DTRACE_RETURN_FROM_PC(p, i)                                                      \
-    do {                                                                                 \
-        const ErtsCodeMFA* cmfa;                                                         \
-        if (DTRACE_ENABLED(function_return) && (cmfa = erts_find_function_from_pc(i))) { \
-            DTRACE_RETURN((p), cmfa);                                                    \
-        }                                                                                \
-    } while(0)
+#define DTRACE_RETURN_FROM_PC(p, i)                                     \
+    if (DTRACE_ENABLED(function_return)) {                              \
+        const ErtsCodeMFA* cmfa  = erts_find_function_from_pc(i);       \
+        if (cmfa) {                                                     \
+            DTRACE_RETURN((p), cmfa);                                   \
+        }                                                               \
+    }
 
 #else /* USE_VM_PROBES */
 #define DTRACE_LOCAL_CALL(p, mfa)        do {} while (0)
@@ -257,10 +258,6 @@ Export* fixed_apply(Process* p, Eterm* reg, Uint arity,
 Export* apply(Process* p, Eterm* reg, ErtsCodePtr I, Uint offs);
 ErtsCodePtr call_fun(Process* p, int arity, Eterm* reg, Eterm args);
 ErtsCodePtr apply_fun(Process* p, Eterm fun, Eterm args, Eterm* reg);
-ErlFunThing* new_fun_thing(Process* p,
-                           ErlFunEntry* fe,
-                           int arity,
-                           int num_free);
 int is_function2(Eterm Term, Uint arity);
 Eterm erts_gc_new_map(Process* p, Eterm* reg, Uint live,
                       Uint n, const Eterm* data);
diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index e995ca28db..6716ef92bd 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -299,7 +299,7 @@ erts_debug_disassemble_1(BIF_ALIST_1)
 	     * But this code_ptr will point to the start of the Export,
 	     * not the function's func_info instruction. BOOM !?
 	     */
-	    cmfa = erts_code_to_codemfa(ep->addresses[code_ix]);
+	    cmfa = erts_code_to_codemfa(ep->dispatch.addresses[code_ix]);
 	} else if (modp == NULL || (code_hdr = modp->curr.code_hdr) == NULL) {
 	    BIF_RET(am_undef);
 	} else {
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index e2de7e751f..bd38bb4eb0 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -235,7 +235,7 @@ erts_finish_loading(Binary* magic, Process* c_p,
 
                     erts_clear_export_break(mod_tab_p, ep);
 
-                    ep->addresses[code_ix] =
+                    ep->dispatch.addresses[code_ix] =
                         (ErtsCodePtr)ep->trampoline.breakpoint.address;
                     ep->trampoline.breakpoint.address = 0;
 
@@ -630,7 +630,12 @@ erts_release_literal_area(ErtsLiteralArea* literal_area)
             }
         case FUN_SUBTAG:
             {
-                ErlFunEntry* fe = ((ErlFunThing*)oh)->fe;
+                /* We _KNOW_ that this is a local fun, otherwise it would not
+                 * be part of the off-heap list. */
+                ErlFunEntry* fe = ((ErlFunThing*)oh)->entry.fun;
+
+                ASSERT(is_local_fun((ErlFunThing*)oh));
+
                 if (erts_refc_dectest(&fe->refc, 0) == 0) {
                     erts_erase_fun_entry(fe);
                 }
diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index a38aa6d022..ba2bf6df4c 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -45,6 +45,7 @@
 #include "erl_map.h"
 #include "erl_msacc.h"
 #include "erl_proc_sig_queue.h"
+#include "erl_fun.h"
 #include "ryu.h"
 #include "jit/beam_asm.h"
 
@@ -1390,7 +1391,7 @@ BIF_RETTYPE raise_3(BIF_ALIST_3)
 	switch (arityval(tp[0])) {
 	case 2:
 	    /* {Fun,Args} */
-	    if (is_fun(tp[1])) {
+	    if (is_any_fun(tp[1])) {
 		must_copy = 1;
 	    } else {
 		goto error;
@@ -1402,7 +1403,7 @@ BIF_RETTYPE raise_3(BIF_ALIST_3)
 	     * {Fun,Args,Location}
 	     * {M,F,A}
 	     */
-	    if (is_fun(tp[1])) {
+	    if (is_any_fun(tp[1])) {
 		location = tp[3];
 	    } else if (is_atom(tp[1]) && is_atom(tp[2])) {
 		must_copy = 1;
@@ -4376,21 +4377,28 @@ BIF_RETTYPE ref_to_list_1(BIF_ALIST_1)
 
 BIF_RETTYPE make_fun_3(BIF_ALIST_3)
 {
-    Eterm* hp;
+    ErlFunThing *funp;
+    Eterm *hp;
+    Export *ep;
     Sint arity;
 
-    if (is_not_atom(BIF_ARG_1) || is_not_atom(BIF_ARG_2) || is_not_small(BIF_ARG_3)) {
-    error:
-	BIF_ERROR(BIF_P, BADARG);
+    if (is_not_atom(BIF_ARG_1) ||
+        is_not_atom(BIF_ARG_2) ||
+        is_not_small(BIF_ARG_3)) {
+        BIF_ERROR(BIF_P, BADARG);
     }
+
     arity = signed_val(BIF_ARG_3);
     if (arity < 0) {
-	goto error;
+        BIF_ERROR(BIF_P, BADARG);
     }
-    hp = HAlloc(BIF_P, 2);
-    hp[0] = HEADER_EXPORT;
-    hp[1] = (Eterm) erts_export_get_or_make_stub(BIF_ARG_1, BIF_ARG_2, (Uint) arity);
-    BIF_RET(make_export(hp));
+
+    hp = HAlloc(BIF_P, ERL_FUN_SIZE);
+
+    ep = erts_export_get_or_make_stub(BIF_ARG_1, BIF_ARG_2, (Uint) arity);
+    funp = erts_new_export_fun_thing(&hp, ep, arity);
+
+    BIF_RET(make_fun(funp));
 }
 
 BIF_RETTYPE fun_to_list_1(BIF_ALIST_1)
@@ -4398,8 +4406,10 @@ BIF_RETTYPE fun_to_list_1(BIF_ALIST_1)
     Process* p = BIF_P;
     Eterm fun = BIF_ARG_1;
 
-    if (is_not_any_fun(fun))
-	BIF_ERROR(p, BADARG);
+    if (is_not_any_fun(fun)) {
+        BIF_ERROR(p, BADARG);
+    }
+
     BIF_RET(term2list_dsprintf(p, fun));
 }
 
@@ -5402,7 +5412,7 @@ void erts_init_trap_export(Export *ep, Eterm m, Eterm f, Uint a,
     }
 
 #ifdef BEAMASM
-    ep->addresses[ERTS_SAVE_CALLS_CODE_IX] = beam_save_calls;
+    ep->dispatch.addresses[ERTS_SAVE_CALLS_CODE_IX] = beam_save_calls;
 #endif
 
     ep->bif_number = -1;
diff --git a/erts/emulator/beam/bif.h b/erts/emulator/beam/bif.h
index 5f68ba2ad3..e285126780 100644
--- a/erts/emulator/beam/bif.h
+++ b/erts/emulator/beam/bif.h
@@ -327,7 +327,7 @@ extern ErtsCodePtr beam_bif_export_trap;
 
 #define ERTS_BIF_PREP_TRAP(Export, Proc, Arity)                               \
     do {                                                                      \
-        (Proc)->i = (Export)->addresses[erts_active_code_ix()];               \
+        (Proc)->i = (Export)->dispatch.addresses[erts_active_code_ix()];      \
         (Proc)->arity = (Arity);                                              \
         (Proc)->freason = TRAP;                                               \
     } while(0);
diff --git a/erts/emulator/beam/code_ix.h b/erts/emulator/beam/code_ix.h
index 6e328e4a76..8412ff8304 100644
--- a/erts/emulator/beam/code_ix.h
+++ b/erts/emulator/beam/code_ix.h
@@ -63,6 +63,20 @@ struct process;
 
 
 #define ERTS_NUM_CODE_IX 3
+
+#ifdef BEAMASM
+#define ERTS_ADDRESSV_SIZE (ERTS_NUM_CODE_IX + 1)
+#define ERTS_SAVE_CALLS_CODE_IX (ERTS_ADDRESSV_SIZE - 1)
+#else
+#define ERTS_ADDRESSV_SIZE ERTS_NUM_CODE_IX
+#endif
+
+/* This structure lets `Export` entries and `ErlFunEntry` share dispatch code,
+ * which greatly improves the performance of fun calls. */
+typedef struct ErtsDispatchable_ {
+    ErtsCodePtr addresses[ERTS_ADDRESSV_SIZE];
+} ErtsDispatchable;
+
 typedef unsigned ErtsCodeIndex;
 
 typedef struct ErtsCodeMFA_ {
diff --git a/erts/emulator/beam/copy.c b/erts/emulator/beam/copy.c
index 23335fe595..cdcaec1038 100644
--- a/erts/emulator/beam/copy.c
+++ b/erts/emulator/beam/copy.c
@@ -849,9 +849,15 @@ Eterm copy_struct_x(Eterm obj, Uint sz, Eterm** hpp, ErlOffHeap* off_heap,
 			*htop++ = *objp++;
 		    }
 		    funp = (ErlFunThing *) tp;
-		    funp->next = off_heap->first;
-		    off_heap->first = (struct erl_off_heap_header*) funp;
-		    erts_refc_inc(&funp->fe->refc, 2);
+
+                    if (is_local_fun(funp)) {
+                        funp->next = off_heap->first;
+                        off_heap->first = (struct erl_off_heap_header*) funp;
+                        erts_refc_inc(&funp->entry.fun->refc, 2);
+                    } else {
+                        ASSERT(is_external_fun(funp) && funp->next == NULL);
+                    }
+
 		    *argp = make_fun(tp);
 		}
 		break;
@@ -1577,9 +1583,15 @@ Uint copy_shared_perform_x(Eterm obj, Uint size, erts_shcopy_t *info,
 			*hp++ = HEAP_ELEM_TO_BE_FILLED;
 		    }
 		}
-		funp->next = off_heap->first;
-		off_heap->first = (struct erl_off_heap_header*) funp;
-		erts_refc_inc(&funp->fe->refc, 2);
+
+                if (is_local_fun(funp)) {
+                    funp->next = off_heap->first;
+                    off_heap->first = (struct erl_off_heap_header*) funp;
+                    erts_refc_inc(&funp->entry.fun->refc, 2);
+                } else {
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
+                }
+
 		goto cleanup_next;
 	    }
 	    case MAP_SUBTAG:
@@ -1924,12 +1936,18 @@ copy_shallow_x(Eterm* ERTS_RESTRICT ptr, Uint sz, Eterm** hpp, ErlOffHeap* off_h
 		}
 		goto off_heap_common;
 
-	    case FUN_SUBTAG:
-		{
-		    ErlFunThing* funp = (ErlFunThing *) (tp-1);
-		    erts_refc_inc(&funp->fe->refc, 2);
-		}
-		goto off_heap_common;
+            case FUN_SUBTAG:
+                {
+                    ErlFunThing* funp = (ErlFunThing *) (tp-1);
+
+                    if (is_local_fun(funp)) {
+                        erts_refc_inc(&funp->entry.fun->refc, 2);
+                        goto off_heap_common;
+                    } else {
+                        ASSERT(is_external_fun(funp) && funp->next == NULL);
+                        goto default_copy;
+                    }
+                }
 	    case EXTERNAL_PID_SUBTAG:
 	    case EXTERNAL_PORT_SUBTAG:
 	    case EXTERNAL_REF_SUBTAG:
@@ -1963,6 +1981,7 @@ copy_shallow_x(Eterm* ERTS_RESTRICT ptr, Uint sz, Eterm** hpp, ErlOffHeap* off_h
 		}
 		/* Fall through... */
 	    }
+            default_copy:
 	    default:
 		{
 		    int tari = header_arity(val);
@@ -2054,34 +2073,49 @@ move_one_frag(Eterm** hpp, ErlHeapFragment* frag, ErlOffHeap* off_heap, int lite
     Eterm* hp = *hpp;
 
     while (ptr != end) {
-	Eterm val;
-	ASSERT(ptr < end);
-	val = *ptr;
-	ASSERT(val != ERTS_HOLE_MARKER);
-	if (is_header(val)) {
-	    struct erl_off_heap_header* hdr = (struct erl_off_heap_header*)hp;
-	    ASSERT(ptr + header_arity(val) < end);
-	    ptr = move_boxed(ptr, val, &hp, &dummy_ref);
-	    switch (val & _HEADER_SUBTAG_MASK) {
-	    case REF_SUBTAG:
-		if (!is_magic_ref_thing(hdr))
-		    break;
-	    case REFC_BINARY_SUBTAG:
-	    case FUN_SUBTAG:
-	    case EXTERNAL_PID_SUBTAG:
-	    case EXTERNAL_PORT_SUBTAG:
-	    case EXTERNAL_REF_SUBTAG:
-		hdr->next = off_heap->first;
-		off_heap->first = hdr;
-		break;
-	    }
-	}
-	else { /* must be a cons cell */
-	    ASSERT(ptr+1 < end);
-	    move_cons(ptr, val, &hp, &dummy_ref);
-	    ptr += 2;
-	}
+        Eterm val;
+        ASSERT(ptr < end);
+        val = *ptr;
+        ASSERT(val != ERTS_HOLE_MARKER);
+
+        if (is_header(val)) {
+            struct erl_off_heap_header* hdr = (struct erl_off_heap_header*)hp;
+
+            ASSERT(ptr + header_arity(val) < end);
+            ptr = move_boxed(ptr, val, &hp, &dummy_ref);
+
+            switch (val & _HEADER_SUBTAG_MASK) {
+            case REF_SUBTAG:
+                if (!is_magic_ref_thing(hdr)) {
+                    break;
+                }
+            case REFC_BINARY_SUBTAG:
+            case EXTERNAL_PID_SUBTAG:
+            case EXTERNAL_PORT_SUBTAG:
+            case EXTERNAL_REF_SUBTAG:
+                hdr->next = off_heap->first;
+                off_heap->first = hdr;
+                break;
+            case FUN_SUBTAG:
+                {
+                    ErlFunThing *funp = (ErlFunThing*)hdr;
+
+                    if (is_local_fun(funp)) {
+                        hdr->next = off_heap->first;
+                        off_heap->first = hdr;
+                    } else {
+                        ASSERT(is_external_fun(funp) && funp->next == NULL);
+                    }
+                }
+                break;
+            }
+        } else { /* must be a cons cell */
+            ASSERT(ptr+1 < end);
+            move_cons(ptr, val, &hp, &dummy_ref);
+            ptr += 2;
+        }
     }
+
     *hpp = hp;
     OH_OVERHEAD(off_heap, frag->off_heap.overhead);
     frag->off_heap.first = NULL;
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index e8392cd486..7bdbd6673e 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -4638,7 +4638,7 @@ BIF_RETTYPE setnode_2(BIF_ALIST_2)
 	goto error;
 
     /* Check that all trap functions are defined !! */
-    if (dmonitor_node_trap->addresses[0] == NULL) {
+    if (dmonitor_node_trap->dispatch.addresses[0] == NULL) {
 	goto error;
     }
 
diff --git a/erts/emulator/beam/emu/beam_emu.c b/erts/emulator/beam/emu/beam_emu.c
index b16e23c61e..b1ba6d8e51 100644
--- a/erts/emulator/beam/emu/beam_emu.c
+++ b/erts/emulator/beam/emu/beam_emu.c
@@ -420,7 +420,7 @@ void process_main(ErtsSchedulerData *esdp)
             if (ERTS_PROC_IS_EXITING(c_p)) {
                 sys_strcpy(fun_buf, "<exiting>");
             } else {
-                ErtsCodeMFA *cmfa = erts_find_function_from_pc(c_p->i);
+                const ErtsCodeMFA *cmfa = erts_find_function_from_pc(c_p->i);
                 if (cmfa) {
                     dtrace_fun_decode(c_p, cmfa,
                                       NULL, fun_buf);
@@ -453,16 +453,12 @@ void process_main(ErtsSchedulerData *esdp)
      * can get the module, function, and arity for the function being
      * called from I[-3], I[-2], and I[-1] respectively.
      */
- context_switch_fun:
-    /* Add one for the environment of the fun */
-    c_p->arity = erts_code_to_codemfa(I)->arity + 1;
-    goto context_switch2;
-
  context_switch:
-    c_p->arity = erts_code_to_codemfa(I)->arity;
-
- context_switch2: 		/* Entry for fun calls. */
-    c_p->current = erts_code_to_codemfa(I);
+    {
+        const ErtsCodeMFA *mfa = erts_code_to_codemfa(I);
+        c_p->arity = mfa->arity;
+        c_p->current = mfa;
+    }
 
  context_switch3:
 
@@ -541,7 +537,7 @@ void process_main(ErtsSchedulerData *esdp)
         HEAVY_SWAPIN;
 
         if (error_handler) {
-            I = error_handler->addresses[erts_active_code_ix()];
+            I = error_handler->dispatch.addresses[erts_active_code_ix()];
             Goto(*I);
         }
     }
diff --git a/erts/emulator/beam/emu/emu_load.c b/erts/emulator/beam/emu/emu_load.c
index 6ca9f28f4c..418721894a 100644
--- a/erts/emulator/beam/emu/emu_load.c
+++ b/erts/emulator/beam/emu/emu_load.c
@@ -632,7 +632,8 @@ void beam_load_finalize_code(LoaderState* stp, struct erl_module_instance* inst_
                 erts_refc_dectest(&fun_entry->refc, 1);
             }
 
-            fun_entry->address = stp->codev + stp->labels[lambda->label].value;
+            erts_set_fun_code(fun_entry,
+                              stp->codev + stp->labels[lambda->label].value);
         }
 
         lp = stp->lambda_patches;
@@ -688,7 +689,7 @@ void beam_load_finalize_code(LoaderState* stp, struct erl_module_instance* inst_
              */
             ep->trampoline.not_loaded.deferred = (BeamInstr) address;
         } else {
-            ep->addresses[erts_staging_code_ix()] = address;
+            ep->dispatch.addresses[erts_staging_code_ix()] = address;
         }
     }
 
@@ -701,7 +702,8 @@ void beam_load_finalize_code(LoaderState* stp, struct erl_module_instance* inst_
             Export *ep = erts_export_put(entry->module,
                                          entry->name,
                                          entry->arity);
-            const BeamInstr *addr = ep->addresses[erts_staging_code_ix()];
+            const BeamInstr *addr =
+                ep->dispatch.addresses[erts_staging_code_ix()];
 
             if (!ErtsInArea(addr, stp->codev, stp->ci * sizeof(BeamInstr))) {
                 erts_exit(ERTS_ABORT_EXIT,
diff --git a/erts/emulator/beam/emu/instrs.tab b/erts/emulator/beam/emu/instrs.tab
index 74f75ff1ce..7ff36b8473 100644
--- a/erts/emulator/beam/emu/instrs.tab
+++ b/erts/emulator/beam/emu/instrs.tab
@@ -243,7 +243,7 @@ APPLY(I, Deallocate, Next) {
         save_calls(c_p, ep);
     }
 
-    $Next = ep->addresses[erts_active_code_ix()];
+    $Next = ep->dispatch.addresses[erts_active_code_ix()];
 }
 
 HANDLE_APPLY_ERROR() {
@@ -290,7 +290,7 @@ FIXED_APPLY(Arity, I, Deallocate, Next) {
         save_calls(c_p, ep);
     }
 
-    $Next = ep->addresses[erts_active_code_ix()];
+    $Next = ep->dispatch.addresses[erts_active_code_ix()];
 }
 
 apply(Arity) {
@@ -546,7 +546,7 @@ i_make_fun3(FunP, Dst, Arity, NumFree) {
     int i, num_free = $NumFree;
     //| -no_next
     SWAPOUT;
-    funp = new_fun_thing(c_p, fe, $Arity, num_free);
+    funp = erts_new_local_fun_thing(c_p, fe, $Arity, num_free);
     SWAPIN;
     I = $NEXT_INSTRUCTION;
     for (i = 0; i < num_free; i++) {
diff --git a/erts/emulator/beam/emu/macros.tab b/erts/emulator/beam/emu/macros.tab
index f7aa49634a..efbd9b73b7 100644
--- a/erts/emulator/beam/emu/macros.tab
+++ b/erts/emulator/beam/emu/macros.tab
@@ -170,7 +170,7 @@ DISPATCH_EXPORT(Export) {
 
     DTRACE_GLOBAL_CALL_FROM_EXPORT(c_p, ep);
 
-    SET_I(ep->addresses[erts_active_code_ix()]);
+    SET_I(ep->dispatch.addresses[erts_active_code_ix()]);
     CHECK_ARGS(I);
     dis_next = *I;
 
@@ -198,7 +198,7 @@ DISPATCH_FUN(I) {
         FCALLS--;
         Goto(dis_next);
     } else {
-        goto context_switch_fun;
+        goto context_switch;
     }
 }
 
diff --git a/erts/emulator/beam/emu/trace_instrs.tab b/erts/emulator/beam/emu/trace_instrs.tab
index 630a9eb2d9..f3263318d9 100644
--- a/erts/emulator/beam/emu/trace_instrs.tab
+++ b/erts/emulator/beam/emu/trace_instrs.tab
@@ -165,7 +165,7 @@ i_debug_breakpoint() {
     HEAVY_SWAPIN;
 
     if (breakpoint_handler) {
-        I = breakpoint_handler->addresses[erts_active_code_ix()];
+        I = breakpoint_handler->dispatch.addresses[erts_active_code_ix()];
         Goto(*I);
     }
 
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 8e29f126a9..b6f925bc52 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -3528,126 +3528,93 @@ fun_info_2(BIF_ALIST_2)
     Process* p = BIF_P;
     Eterm fun = BIF_ARG_1;
     Eterm what = BIF_ARG_2;
+
+    const ErtsCodeMFA *mfa;
+    ErlFunThing *funp;
+    ErlFunEntry *fe;
     Eterm* hp;
     Eterm val;
 
-    if (is_fun(fun)) {
-	ErlFunThing* funp = (ErlFunThing *) fun_val(fun);
+    if (is_not_any_fun(fun)) {
+        BIF_ERROR(p, BADARG);
+    }
 
-	switch (what) {
-	case am_type:
-	    hp = HAlloc(p, 3);
-	    val = am_local;
-	    break;
-	case am_pid:
-	    hp = HAlloc(p, 3);
-	    val = funp->creator;
-	    break;
-	case am_module:
-	    hp = HAlloc(p, 3);
-	    val = funp->fe->module;
-	    break;
-	case am_new_index:
-	    hp = HAlloc(p, 3);
-	    val = make_small(funp->fe->index);
-	    break;
-	case am_new_uniq:
-	    val = new_binary(p, funp->fe->uniq, 16);
-	    hp = HAlloc(p, 3);
-	    break;
-	case am_index:
-	    hp = HAlloc(p, 3);
-	    val = make_small(funp->fe->old_index);
-	    break;
-	case am_uniq:
-	    hp = HAlloc(p, 3);
-	    val = make_small(funp->fe->old_uniq);
-	    break;
-	case am_env:
-	    {
-		Uint num_free = funp->num_free;
-		int i;
-
-		hp = HAlloc(p, 3 + 2*num_free);
-		val = NIL;
-		for (i = num_free-1; i >= 0; i--) {
-		    val = CONS(hp, funp->env[i], val);
-		    hp += 2;
-		}
-	    }
-	    break;
-	case am_refc:
-	    val = erts_make_integer(erts_atomic_read_nob(&funp->fe->refc), p);
-	    hp = HAlloc(p, 3);
-	    break;
-	case am_arity:
-	    hp = HAlloc(p, 3);
-	    val = make_small(funp->arity);
-	    break;
-	case am_name:
-            {
-                const ErtsCodeMFA *mfa = erts_get_fun_mfa(funp->fe);
-                hp = HAlloc(p, 3);
-                val = mfa->function;
-            }
-            break;
-	default:
-	    goto error;
-	}
-    } else if (is_export(fun)) {
-	Export* exp = (Export *) ((UWord) (export_val(fun))[1]);
-	switch (what) {
-	case am_type:
-	    hp = HAlloc(p, 3);
-	    val = am_external;
-	    break;
-	case am_pid:
-	    hp = HAlloc(p, 3);
-	    val = am_undefined;
-	    break;
-	case am_module:
-	    hp = HAlloc(p, 3);
-	    val = exp->info.mfa.module;
-	    break;
-	case am_new_index:
-	    hp = HAlloc(p, 3);
-	    val = am_undefined;
-	    break;
-	case am_new_uniq:
-	    hp = HAlloc(p, 3);
-	    val = am_undefined;
-	    break;
-	case am_index:
-	    hp = HAlloc(p, 3);
-	    val = am_undefined;
-	    break;
-	case am_uniq:
-	    hp = HAlloc(p, 3);
-	    val = am_undefined;
-	    break;
-	case am_env:
-	    hp = HAlloc(p, 3);
-	    val = NIL;
-	    break;
-	case am_refc:
-	    hp = HAlloc(p, 3);
-	    val = am_undefined;
-	    break;
-	case am_arity:
-	    hp = HAlloc(p, 3);
-	    val = make_small(exp->info.mfa.arity);
-	    break;
-	case am_name:
-	    hp = HAlloc(p, 3);
-	    val = exp->info.mfa.function;
-	    break;
-	default:
-	    goto error;
-	}
+    funp = (ErlFunThing *) fun_val(fun);
+
+    if (is_local_fun(funp)) {
+        fe = funp->entry.fun;
+        mfa = erts_get_fun_mfa(fe);
     } else {
-    error:
-	BIF_ERROR(p, BADARG);
+        ASSERT(is_external_fun(funp) && funp->next == NULL);
+        mfa = &(funp->entry.exp)->info.mfa;
+        fe = NULL;
     }
+
+    switch (what) {
+    case am_type:
+        val = is_local_fun(funp) ? am_local : am_external;
+        hp = HAlloc(p, 3);
+        break;
+    case am_pid:
+        val = is_local_fun(funp) ? funp->creator : am_undefined;
+        hp = HAlloc(p, 3);
+        break;
+    case am_module:
+        val = mfa->module;
+        hp = HAlloc(p, 3);
+        break;
+    case am_new_index:
+        val = is_local_fun(funp) ? make_small(fe->index) : am_undefined;
+        hp = HAlloc(p, 3);
+        break;
+    case am_new_uniq:
+        val = is_local_fun(funp) ? new_binary(p, fe->uniq, 16) :
+                                   am_undefined;
+        hp = HAlloc(p, 3);
+        break;
+    case am_index:
+        val = is_local_fun(funp) ? make_small(fe->old_index) : am_undefined;
+        hp = HAlloc(p, 3);
+        break;
+    case am_uniq:
+        val = is_local_fun(funp) ? make_small(fe->old_uniq) : am_undefined;
+        hp = HAlloc(p, 3);
+        break;
+    case am_env:
+        {
+            Uint num_free = funp->num_free;
+            int i;
+
+            hp = HAlloc(p, 3 + 2 * num_free);
+            val = NIL;
+
+            for (i = num_free - 1; i >= 0; i--) {
+                val = CONS(hp, funp->env[i], val);
+                hp += 2;
+            }
+        }
+        break;
+    case am_refc:
+        if (is_local_fun(funp)) {
+            val = erts_make_integer(erts_atomic_read_nob(&fe->refc), p);
+        } else {
+            val = am_undefined;
+        }
+
+        hp = HAlloc(p, 3);
+        break;
+    case am_arity:
+        val = make_small(funp->arity);
+        hp = HAlloc(p, 3);
+        break;
+    case am_name:
+        hp = HAlloc(p, 3);
+        val = mfa->function;
+        break;
+    default:
+        BIF_ERROR(p, BADARG);
+    }
+
     return TUPLE2(hp, what, val);
 }
 
@@ -3658,25 +3625,26 @@ fun_info_mfa_1(BIF_ALIST_1)
     Eterm fun = BIF_ARG_1;
     Eterm* hp;
 
-    if (is_fun(fun)) {
+    if (is_any_fun(fun)) {
         const ErtsCodeMFA *mfa;
         ErlFunThing* funp;
 
         funp = (ErlFunThing *) fun_val(fun);
-        mfa = erts_get_fun_mfa(funp->fe);
+
+        if (is_local_fun(funp)) {
+            mfa = erts_get_fun_mfa(funp->entry.fun);
+        } else {
+            ASSERT(is_external_fun(funp) && funp->next == NULL);
+            mfa = &(funp->entry.exp)->info.mfa;
+        }
 
         hp = HAlloc(p, 4);
         BIF_RET(TUPLE3(hp,
-                       (funp->fe)->module,
+                       mfa->module,
                        mfa->function,
                        make_small(funp->arity)));
-    } else if (is_export(fun)) {
-	Export* exp = (Export *) ((UWord) (export_val(fun))[1]);
-	hp = HAlloc(p, 4);
-	BIF_RET(TUPLE3(hp,exp->info.mfa.module,
-                       exp->info.mfa.function,
-                       make_small(exp->info.mfa.arity)));
     }
+
     BIF_ERROR(p, BADARG);
 }
 
diff --git a/erts/emulator/beam/erl_bif_op.c b/erts/emulator/beam/erl_bif_op.c
index a594ec1493..d925acf3da 100644
--- a/erts/emulator/beam/erl_bif_op.c
+++ b/erts/emulator/beam/erl_bif_op.c
@@ -251,19 +251,14 @@ Eterm erl_is_function(Process* p, Eterm arg1, Eterm arg2)
 	goto error;
     }
 
-    if (is_fun(arg1)) {
+    if (is_any_fun(arg1)) {
 	ErlFunThing* funp = (ErlFunThing *) fun_val(arg1);
 
 	if (funp->arity == (Uint) arity) {
 	    BIF_RET(am_true);
 	}
-    } else if (is_export(arg1)) {
-	Export* exp = (Export *) (export_val(arg1)[1]);
-
-	if (exp->info.mfa.arity == (Uint) arity) {
-	    BIF_RET(am_true);
-	}
     }
+
     BIF_RET(am_false);
 }
 
diff --git a/erts/emulator/beam/erl_bif_trace.c b/erts/emulator/beam/erl_bif_trace.c
index fc30c7457c..e6d11966fb 100644
--- a/erts/emulator/beam/erl_bif_trace.c
+++ b/erts/emulator/beam/erl_bif_trace.c
@@ -1459,7 +1459,8 @@ erts_set_trace_pattern(Process*p, ErtsCodeMFA *mfa, int specified,
                 ep->info.op = BeamOpCodeAddr(op_i_func_info_IaaI);
 #endif
                 ep->trampoline.common.op = BeamOpCodeAddr(op_trace_jump_W);
-                ep->trampoline.trace.address = (BeamInstr) ep->addresses[code_ix];
+                ep->trampoline.trace.address =
+                    (BeamInstr) ep->dispatch.addresses[code_ix];
             }
 
             erts_set_export_trace(ci_rw, match_prog_set, 0);
@@ -1687,7 +1688,8 @@ uninstall_exp_breakpoints(BpFunctions* f)
 
         if (erts_is_export_trampoline_active(ep, code_ix)) {
             ASSERT(BeamIsOpCode(ep->trampoline.common.op, op_trace_jump_W));
-            ep->addresses[code_ix] = (ErtsCodePtr)ep->trampoline.trace.address;
+            ep->dispatch.addresses[code_ix] =
+                (ErtsCodePtr)ep->trampoline.trace.address;
         }
     }
 }
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index df977fea61..87a66b6085 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -3425,29 +3425,33 @@ void db_cleanup_offheap_comp(DbTerm* obj)
 
     for (u.hdr = obj->first_oh; u.hdr; u.hdr = u.hdr->next) {
         erts_align_offheap(&u, &tmp);
-	switch (thing_subtag(u.hdr->thing_word)) {
-	case REFC_BINARY_SUBTAG:
+        switch (thing_subtag(u.hdr->thing_word)) {
+        case REFC_BINARY_SUBTAG:
             erts_bin_release(u.pb->val);
-	    break;
-	case FUN_SUBTAG:
-	    if (erts_refc_dectest(&u.fun->fe->refc, 0) == 0) {
-		erts_erase_fun_entry(u.fun->fe);
-	    }
-	    break;
-	case REF_SUBTAG:
-	    ASSERT(is_magic_ref_thing(u.hdr));
+            break;
+        case FUN_SUBTAG:
+            /* We _KNOW_ that this is a local fun, otherwise it would not
+             * be part of the off-heap list. */
+            ASSERT(is_local_fun(u.fun));
+            if (erts_refc_dectest(&u.fun->entry.fun->refc, 0) == 0) {
+                erts_erase_fun_entry(u.fun->entry.fun);
+            }
+            break;
+        case REF_SUBTAG:
+            ASSERT(is_magic_ref_thing(u.hdr));
             erts_bin_release((Binary *)u.mref->mb);
-	    break;
-	default:
-	    ASSERT(is_external_header(u.hdr->thing_word));
-	    erts_deref_node_entry(u.ext->node, make_boxed(u.ep));
-	    break;
-	}
+            break;
+        default:
+            ASSERT(is_external_header(u.hdr->thing_word));
+            erts_deref_node_entry(u.ext->node, make_boxed(u.ep));
+            break;
+        }
     }
+
 #ifdef DEBUG_CLONE
     if (obj->debug_clone != NULL) {
-	erts_free(ERTS_ALC_T_DB_TERM, obj->debug_clone);
-	obj->debug_clone = NULL;
+        erts_free(ERTS_ALC_T_DB_TERM, obj->debug_clone);
+        obj->debug_clone = NULL;
     }
 #endif
 }
diff --git a/erts/emulator/beam/erl_fun.c b/erts/emulator/beam/erl_fun.c
index 4267cbed63..7c288d8c14 100644
--- a/erts/emulator/beam/erl_fun.c
+++ b/erts/emulator/beam/erl_fun.c
@@ -29,6 +29,15 @@
 #include "hash.h"
 #include "beam_common.h"
 
+/* Container structure for fun entries, allowing us to start `ErlFunEntry` with
+ * a field other than its `HashBucket`. */
+typedef struct erl_fun_entry_container {
+    /* !! MUST BE THE FIRST FIELD !! */
+    HashBucket bucket;
+
+    ErlFunEntry entry;
+} ErlFunEntryContainer;
+
 static Hash erts_fun_table;
 
 static erts_rwmtx_t erts_fun_table_lock;
@@ -38,10 +47,10 @@ static erts_rwmtx_t erts_fun_table_lock;
 #define erts_fun_write_lock()	erts_rwmtx_rwlock(&erts_fun_table_lock)
 #define erts_fun_write_unlock()	erts_rwmtx_rwunlock(&erts_fun_table_lock)
 
-static HashValue fun_hash(ErlFunEntry* obj);
-static int fun_cmp(ErlFunEntry* obj1, ErlFunEntry* obj2);
-static ErlFunEntry* fun_alloc(ErlFunEntry* template);
-static void fun_free(ErlFunEntry* obj);
+static HashValue fun_hash(ErlFunEntryContainer* obj);
+static int fun_cmp(ErlFunEntryContainer* obj1, ErlFunEntryContainer* obj2);
+static ErlFunEntryContainer* fun_alloc(ErlFunEntryContainer* template);
+static void fun_free(ErlFunEntryContainer* obj);
 
 void
 erts_init_fun_table(void)
@@ -92,34 +101,38 @@ ErlFunEntry*
 erts_put_fun_entry2(Eterm mod, int old_uniq, int old_index,
                     const byte* uniq, int index, int arity)
 {
-    ErlFunEntry template;
-    ErlFunEntry* fe;
+    ErlFunEntryContainer template;
+    ErlFunEntryContainer *fc;
+    ErlFunEntry *tp;
     erts_aint_t refc;
 
+    tp = &template.entry;
+
     /* All fields are copied from the template when inserting a new entry. */
     ASSERT(is_atom(mod));
-    template.old_index = old_index;
-    template.old_uniq = old_uniq;
-    template.index = index;
-    template.module = mod;
-    template.arity = arity;
-    sys_memcpy(template.uniq, uniq, sizeof(template.uniq));
+    tp->old_index = old_index;
+    tp->old_uniq = old_uniq;
+    tp->index = index;
+    tp->module = mod;
+    tp->arity = arity;
+
+    sys_memcpy(tp->uniq, uniq, sizeof(tp->uniq));
 
     erts_fun_write_lock();
-    fe = (ErlFunEntry *) hash_put(&erts_fun_table, (void*) &template);
-    refc = erts_refc_inctest(&fe->refc, 0);
+    fc = (ErlFunEntryContainer*)hash_put(&erts_fun_table, (void*)&template);
+    refc = erts_refc_inctest(&fc->entry.refc, 0);
     if (refc < 2) {
         /* New or pending delete */
-        erts_refc_inc(&fe->refc, 1);
+        erts_refc_inc(&fc->entry.refc, 1);
     }
     erts_fun_write_unlock();
 
-    return fe;
+    return &fc->entry;
 }
 
 const ErtsCodeMFA *erts_get_fun_mfa(const ErlFunEntry *fe) {
     static const ErtsCodeMFA unloaded_mfa = {NIL, NIL, ERTS_UINT_MAX};
-    ErtsCodePtr address = fe->address;
+    ErtsCodePtr address = fe->dispatch.addresses[0];
 
     if (address != beam_unloaded_fun) {
         return erts_find_function_from_pc(address);
@@ -128,14 +141,25 @@ const ErtsCodeMFA *erts_get_fun_mfa(const ErlFunEntry *fe) {
     return &unloaded_mfa;
 }
 
+void erts_set_fun_code(ErlFunEntry *fe, ErtsCodePtr address) {
+    int i;
+
+    for (i = 0; i < ERTS_ADDRESSV_SIZE; i++) {
+        fe->dispatch.addresses[i] = address;
+    }
+}
+
 int erts_is_fun_loaded(const ErlFunEntry* fe) {
-    return fe->address != beam_unloaded_fun;
+    return fe->dispatch.addresses[0] != beam_unloaded_fun;
 }
 
 static void
 erts_erase_fun_entry_unlocked(ErlFunEntry* fe)
 {
-    hash_erase(&erts_fun_table, (void *) fe);
+    ErlFunEntryContainer *fc = ErtsContainerStruct(fe, ErlFunEntryContainer,
+                                                   entry);
+
+    hash_erase(&erts_fun_table, (void *) fc);
 }
 
 void
@@ -160,17 +184,21 @@ erts_erase_fun_entry(ErlFunEntry* fe)
     erts_fun_write_unlock();
 }
 
-static void fun_purge_foreach(ErlFunEntry *fe, struct erl_module_instance* modp)
+static void fun_purge_foreach(ErlFunEntryContainer *fc,
+                              struct erl_module_instance* modp)
 {
     const char *fun_addr, *mod_start;
+    ErlFunEntry *fe = &fc->entry;
 
-    fun_addr = (const char*)fe->address;
+    fun_addr = (const char*)fe->dispatch.addresses[0];
     mod_start = (const char*)modp->code_hdr;
 
     if (ErtsInArea(fun_addr, mod_start, modp->code_length)) {
-        fe->pend_purge_address = fe->address;
+        fe->pend_purge_address = fe->dispatch.addresses[0];
         ERTS_THR_WRITE_MEMORY_BARRIER;
-        fe->address = beam_unloaded_fun;
+
+        erts_set_fun_code(fe, beam_unloaded_fun);
+
         erts_purge_state_add_fun(fe);
     }
 }
@@ -191,8 +219,8 @@ erts_fun_purge_abort_prepare(ErlFunEntry **funs, Uint no)
     for (ix = 0; ix < no; ix++) {
         ErlFunEntry *fe = funs[ix];
 
-        if (fe->address == beam_unloaded_fun) {
-            fe->address = fe->pend_purge_address;
+        if (fe->dispatch.addresses[0] == beam_unloaded_fun) {
+            erts_set_fun_code(fe, fe->pend_purge_address);
         }
     }
 }
@@ -221,19 +249,75 @@ erts_fun_purge_complete(ErlFunEntry **funs, Uint no)
     ERTS_THR_WRITE_MEMORY_BARRIER;
 }
 
+
+ErlFunThing *erts_new_export_fun_thing(Eterm **hpp, Export *exp, int arity)
+{
+    ErlFunThing *funp;
+
+    funp = (ErlFunThing*)(*hpp);
+    *hpp += ERL_FUN_SIZE;
+
+    funp->thing_word = HEADER_FUN;
+    funp->next = NULL;
+    funp->entry.exp = exp;
+    funp->num_free = 0;
+    funp->creator = am_external;
+    funp->arity = arity;
+
+#ifdef DEBUG
+    {
+        const ErtsCodeMFA *mfa = &exp->info.mfa;
+        ASSERT(arity == mfa->arity);
+    }
+#endif
+
+    return funp;
+}
+
+ErlFunThing *erts_new_local_fun_thing(Process *p, ErlFunEntry *fe,
+                                      int arity, int num_free)
+{
+    ErlFunThing *funp;
+
+    funp = (ErlFunThing*) p->htop;
+    p->htop += ERL_FUN_SIZE + num_free;
+    erts_refc_inc(&fe->refc, 2);
+
+    funp->thing_word = HEADER_FUN;
+    funp->next = MSO(p).first;
+    MSO(p).first = (struct erl_off_heap_header*) funp;
+    funp->entry.fun = fe;
+    funp->num_free = num_free;
+    funp->creator = p->common.id;
+    funp->arity = arity;
+
+#ifdef DEBUG
+    {
+        const ErtsCodeMFA *mfa = erts_get_fun_mfa(fe);
+        ASSERT(funp->arity == mfa->arity - num_free);
+        ASSERT(arity == fe->arity);
+    }
+#endif
+
+    return funp;
+}
+
+
 struct dump_fun_foreach_args {
     fmtfn_t to;
     void *to_arg;
 };
 
 static void
-dump_fun_foreach(ErlFunEntry *fe, struct dump_fun_foreach_args *args)
+dump_fun_foreach(ErlFunEntryContainer *fc, struct dump_fun_foreach_args *args)
 {
+    ErlFunEntry *fe = &fc->entry;
+
     erts_print(args->to, args->to_arg, "=fun\n");
     erts_print(args->to, args->to_arg, "Module: %T\n", fe->module);
     erts_print(args->to, args->to_arg, "Uniq: %d\n", fe->old_uniq);
     erts_print(args->to, args->to_arg, "Index: %d\n",fe->old_index);
-    erts_print(args->to, args->to_arg, "Address: %p\n", fe->address);
+    erts_print(args->to, args->to_arg, "Address: %p\n", fe->dispatch.addresses[0]);
     erts_print(args->to, args->to_arg, "Refc: %ld\n", erts_refc_read(&fe->refc, 1));
 }
 
@@ -251,39 +335,48 @@ erts_dump_fun_entries(fmtfn_t to, void *to_arg)
 }
 
 static HashValue
-fun_hash(ErlFunEntry* obj)
+fun_hash(ErlFunEntryContainer* obj)
 {
-    return (HashValue) (obj->old_uniq ^ obj->index ^ atom_val(obj->module));
+    ErlFunEntry *fe = &obj->entry;
+
+    return (HashValue) (fe->old_uniq ^ fe->index ^ atom_val(fe->module));
 }
 
 static int
-fun_cmp(ErlFunEntry* obj1, ErlFunEntry* obj2)
+fun_cmp(ErlFunEntryContainer* obj1, ErlFunEntryContainer* obj2)
 {
-    return !(obj1->old_index == obj2->old_index &&
-             obj1->old_uniq == obj2->old_uniq &&
-             obj1->module == obj2->module &&
-             obj1->index == obj2->index &&
-             obj1->arity == obj2->arity &&
-             !sys_memcmp(obj1->uniq, obj2->uniq, sizeof(obj1->uniq)));
+    ErlFunEntry* fe1 = &obj1->entry;
+    ErlFunEntry* fe2 = &obj2->entry;
+
+    return !(fe1->old_index == fe2->old_index &&
+             fe1->old_uniq == fe2->old_uniq &&
+             fe1->module == fe2->module &&
+             fe1->index == fe2->index &&
+             fe1->arity == fe2->arity &&
+             !sys_memcmp(fe1->uniq, fe2->uniq, sizeof(fe1->uniq)));
 }
 
-static ErlFunEntry*
-fun_alloc(ErlFunEntry* template)
+static ErlFunEntryContainer*
+fun_alloc(ErlFunEntryContainer* template)
 {
-    ErlFunEntry* obj = (ErlFunEntry *) erts_alloc(ERTS_ALC_T_FUN_ENTRY,
-                                                  sizeof(ErlFunEntry));
+    ErlFunEntryContainer* obj;
+
+    obj = (ErlFunEntryContainer *) erts_alloc(ERTS_ALC_T_FUN_ENTRY,
+                                              sizeof(ErlFunEntryContainer));
+
+    sys_memcpy(obj, template, sizeof(ErlFunEntryContainer));
+
+    erts_refc_init(&obj->entry.refc, -1);
 
-    sys_memcpy(obj, template, sizeof(ErlFunEntry));
+    erts_set_fun_code(&obj->entry, beam_unloaded_fun);
 
-    erts_refc_init(&obj->refc, -1);
-    obj->address = beam_unloaded_fun;
-    obj->pend_purge_address = NULL;
+    obj->entry.pend_purge_address = NULL;
 
     return obj;
 }
 
 static void
-fun_free(ErlFunEntry* obj)
+fun_free(ErlFunEntryContainer* obj)
 {
     erts_free(ERTS_ALC_T_FUN_ENTRY, (void *) obj);
 }
diff --git a/erts/emulator/beam/erl_fun.h b/erts/emulator/beam/erl_fun.h
index 1f5e8669d7..c226c27a31 100644
--- a/erts/emulator/beam/erl_fun.h
+++ b/erts/emulator/beam/erl_fun.h
@@ -27,9 +27,10 @@
  * Fun entry.
  */
 typedef struct erl_fun_entry {
-    HashBucket bucket;
-
-    ErtsCodePtr address;            /* Pointer to code for actual function */
+    /* We start with an `ErtsDispatchable`, similar to export entries, so that
+     * we can mostly use the same code for both. This greatly reduces the
+     * complexity of instructions like `call_fun` and `is_function2`. */
+    ErtsDispatchable dispatch;
 
     /* These fields identify the function and must not be altered after fun
      * creation. */
@@ -45,26 +46,49 @@ typedef struct erl_fun_entry {
     ErtsCodePtr pend_purge_address; /* Address during a pending purge */
 } ErlFunEntry;
 
-/*
- * This structure represents a 'fun' (lambda). It is stored on
- * process heaps. It has variable size depending on the size
- * of the environment.
- */
+/* This structure represents a 'fun' (lambda), whether local or external. It is
+ * stored on process heaps, and has variable size depending on the size of the
+ * environment. */
 
 typedef struct erl_fun_thing {
-    Eterm thing_word;		/* Subtag FUN_SUBTAG. */
-    ErlFunEntry* fe;		/* Pointer to fun entry. */
-    struct erl_off_heap_header* next;
-    Uint arity;			/* The arity of the fun. */
-    Uint num_free;		/* Number of free variables (in env). */
-  /* -- The following may be compound Erlang terms ---------------------- */
-    Eterm creator;		/* Pid of creator process (contains node). */
-    Eterm env[1];		/* Environment (free variables). */
+    Eterm thing_word;       /* Subtag FUN_SUBTAG. */
+
+    union {
+        /* Both `ErlFunEntry` and `Export` begin with an `ErtsDispatchable`, so
+         * code that doesn't really care which (e.g. calls) can use this
+         * pointer to improve performance. */
+        ErtsDispatchable *disp;
+
+        /* Pointer to function entry, valid iff `creator != am_external`.*/
+        ErlFunEntry *fun;
+
+        /* Pointer to export entry, valid iff `creator == am_external`.*/
+        Export *exp;
+    } entry;
+
+    /* Next off-heap object, must be NULL when this is an external fun. */
+    struct erl_off_heap_header *next;
+
+    Uint arity;             /* The _apparent_ arity of the fun. */
+    Uint num_free;          /* Number of free variables (in env). */
+
+    /* -- The following may be compound Erlang terms ---------------------- */
+    Eterm creator;          /* Pid of creator process (contains node). */
+    Eterm env[1];           /* Environment (free variables). */
 } ErlFunThing;
 
+#define is_local_fun(FunThing) ((FunThing)->creator != am_external)
+#define is_external_fun(FunThing) ((FunThing)->creator == am_external)
+
 /* ERL_FUN_SIZE does _not_ include space for the environment */
 #define ERL_FUN_SIZE ((sizeof(ErlFunThing)/sizeof(Eterm))-1)
 
+ErlFunThing *erts_new_export_fun_thing(Eterm **hpp, Export *exp, int arity);
+ErlFunThing *erts_new_local_fun_thing(Process *p,
+                                      ErlFunEntry *fe,
+                                      int arity,
+                                      int num_free);
+
 void erts_init_fun_table(void);
 void erts_fun_info(fmtfn_t, void *);
 int erts_fun_table_sz(void);
@@ -75,6 +99,11 @@ ErlFunEntry* erts_put_fun_entry2(Eterm mod, int old_uniq, int old_index,
 
 const ErtsCodeMFA *erts_get_fun_mfa(const ErlFunEntry *fe);
 
+void erts_set_fun_code(ErlFunEntry *fe, ErtsCodePtr address);
+
+ERTS_GLB_INLINE
+ErtsCodePtr erts_get_fun_code(ErlFunEntry *fe, ErtsCodeIndex ix);
+
 int erts_is_fun_loaded(const ErlFunEntry* fe);
 
 void erts_erase_fun_entry(ErlFunEntry* fe);
@@ -87,4 +116,13 @@ void erts_fun_purge_abort_finalize(ErlFunEntry **funs, Uint no);
 void erts_fun_purge_complete(ErlFunEntry **funs, Uint no);
 void erts_dump_fun_entries(fmtfn_t, void *);
 
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE
+ErtsCodePtr erts_get_fun_code(ErlFunEntry *fe, ErtsCodeIndex ix) {
+    return fe->dispatch.addresses[ix];
+}
+
+#endif
+
 #endif
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 55d3379905..7128761534 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -1278,16 +1278,14 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
      */
 
     while (oh) {
-	if (IS_MOVED_BOXED(oh->thing_word)) {
-	    struct erl_off_heap_header* ptr;
+        if (IS_MOVED_BOXED(oh->thing_word)) {
+            struct erl_off_heap_header* ptr;
 
-            /*
-	     * This off-heap object has been copied to the heap.
-	     * We must increment its reference count and
-	     * link it into the MSO list for the process.
-	     */
+            /* This off-heap object has been copied to the heap.
+             * We must increment its reference count and
+             * link it into the MSO list for the process.*/
 
-	    ptr = (struct erl_off_heap_header*) boxed_val(oh->thing_word);
+            ptr = (struct erl_off_heap_header*) boxed_val(oh->thing_word);
             switch (thing_subtag(ptr->thing_word)) {
             case REFC_BINARY_SUBTAG:
                 {
@@ -1297,7 +1295,10 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
                 }
             case FUN_SUBTAG:
                 {
-                    ErlFunEntry* fe = ((ErlFunThing*)ptr)->fe;
+                    /* We _KNOW_ that this is a local fun, otherwise it would
+                     * not be part of the off-heap list. */
+                    ErlFunEntry* fe = ((ErlFunThing*)ptr)->entry.fun;
+                    ASSERT(is_local_fun((ErlFunThing*)ptr));
                     erts_refc_inc(&fe->refc, 2);
                     break;
                 }
@@ -1319,10 +1320,12 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
                     break;
                 }
             }
-	    *prev = ptr;
-	    prev = &ptr->next;
-	}
-	oh = oh->next;
+
+            *prev = ptr;
+            prev = &ptr->next;
+        }
+
+        oh = oh->next;
     }
 
     if (prev) {
@@ -2494,13 +2497,25 @@ erts_copy_one_frag(Eterm** hpp, ErlOffHeap* off_heap,
 		if (!is_magic_ref_thing(fhp - 1))
 		    goto the_default;
 	    case REFC_BINARY_SUBTAG:
-	    case FUN_SUBTAG:
 	    case EXTERNAL_PID_SUBTAG:
 	    case EXTERNAL_PORT_SUBTAG:
 	    case EXTERNAL_REF_SUBTAG:
 		oh = (struct erl_off_heap_header*) (hp-1);
 		cpy_sz = thing_arityval(val);
 		goto cpy_words;
+            case FUN_SUBTAG:
+            {
+                ErlFunThing *funp = (ErlFunThing*) (fhp - 1);
+
+                if (is_local_fun(funp)) {
+                    oh = (struct erl_off_heap_header*) (hp - 1);
+                } else {
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
+                }
+
+                cpy_sz = thing_arityval(val);
+                goto cpy_words;
+            }
 	    default:
 	    the_default:
 		cpy_sz = header_arity(val);
@@ -3026,10 +3041,17 @@ sweep_off_heap(Process *p, int fullsweep)
 		}
 	    case FUN_SUBTAG:
 		{
-		    ErlFunEntry* fe = ((ErlFunThing*)ptr)->fe;
-		    if (erts_refc_dectest(&fe->refc, 0) == 0) {
-			erts_erase_fun_entry(fe);
-		    }
+                    ErlFunThing* funp = ((ErlFunThing*)ptr);
+
+                    if (is_local_fun(funp)) {
+                        ErlFunEntry* fe = funp->entry.fun;
+
+                        if (erts_refc_dectest(&fe->refc, 0) == 0) {
+                            erts_erase_fun_entry(fe);
+                        }
+                    } else {
+                        ASSERT(is_external_fun(funp) && funp->next == NULL);
+                    }
 		    break;
 		}
 	    case REF_SUBTAG:
@@ -3851,8 +3873,14 @@ erts_check_off_heap2(Process *p, Eterm *htop)
 	case REFC_BINARY_SUBTAG:
 	    refc = erts_refc_read(&u.pb->val->intern.refc, 1);
 	    break;
-	case FUN_SUBTAG:
-	    refc = erts_refc_read(&u.fun->fe->refc, 1);
+        case FUN_SUBTAG:
+            if (is_local_fun(u.fun)) {
+                refc = erts_refc_read(&u.fun->entry.fun->refc, 1);
+            } else {
+                /* Export fun, fake a valid refc. */
+                ASSERT(is_external_fun(u.fun) && u.fun->next == NULL);
+                refc = 1;
+            }
 	    break;
 	case EXTERNAL_PID_SUBTAG:
 	case EXTERNAL_PORT_SUBTAG:
diff --git a/erts/emulator/beam/erl_map.c b/erts/emulator/beam/erl_map.c
index 395c4d9ca9..153d536020 100644
--- a/erts/emulator/beam/erl_map.c
+++ b/erts/emulator/beam/erl_map.c
@@ -3147,10 +3147,17 @@ BIF_RETTYPE erts_internal_term_type_1(BIF_ALIST_1) {
             switch (hdr & _TAG_HEADER_MASK) {
                 case ARITYVAL_SUBTAG:
                     BIF_RET(ERTS_MAKE_AM("tuple"));
-                case EXPORT_SUBTAG:
-                    BIF_RET(ERTS_MAKE_AM("export"));
                 case FUN_SUBTAG:
-                    BIF_RET(ERTS_MAKE_AM("fun"));
+                    {
+                        ErlFunThing *funp = (ErlFunThing *)fun_val(obj);
+
+                        if (is_local_fun(funp)) {
+                            BIF_RET(ERTS_MAKE_AM("fun"));
+                        } else {
+                            ASSERT(is_external_fun(funp) && funp->next == NULL);
+                            BIF_RET(ERTS_MAKE_AM("export"));
+                        }
+                    }
                 case MAP_SUBTAG:
                     switch (MAP_HEADER_TYPE(hdr)) {
                         case MAP_HEADER_TAG_FLATMAP_HEAD :
diff --git a/erts/emulator/beam/erl_message.c b/erts/emulator/beam/erl_message.c
index 86b1b6f6a4..d4327d93a8 100644
--- a/erts/emulator/beam/erl_message.c
+++ b/erts/emulator/beam/erl_message.c
@@ -171,9 +171,12 @@ erts_cleanup_offheap(ErlOffHeap *offheap)
             erts_bin_release(u.pb->val);
 	    break;
 	case FUN_SUBTAG:
-	    if (erts_refc_dectest(&u.fun->fe->refc, 0) == 0) {
-		erts_erase_fun_entry(u.fun->fe);		    
-	    }
+            /* We _KNOW_ that this is a local fun, otherwise it would not
+             * be part of the off-heap list. */
+            ASSERT(is_local_fun(u.fun));
+            if (erts_refc_dectest(&u.fun->entry.fun->refc, 0) == 0) {
+                erts_erase_fun_entry(u.fun->entry.fun);
+            }
 	    break;
 	case REF_SUBTAG:
 	    ASSERT(is_magic_ref_thing(u.hdr));
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index bec276a393..4637db1c33 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1166,7 +1166,7 @@ int enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)
 
 int enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)
 {
-    return is_fun(term);
+    return is_any_fun(term);
 }
 
 int enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)
@@ -1214,7 +1214,6 @@ ErlNifTermType enif_term_type(ErlNifEnv* env, ERL_NIF_TERM term) {
         return ERL_NIF_TERM_TYPE_BITSTRING;
     case FLOAT_DEF:
         return ERL_NIF_TERM_TYPE_FLOAT;
-    case EXPORT_DEF:
     case FUN_DEF:
         return ERL_NIF_TERM_TYPE_FUN;
     case BIG_DEF:
diff --git a/erts/emulator/beam/erl_printf_term.c b/erts/emulator/beam/erl_printf_term.c
index 47bbf588be..7fbaeb710a 100644
--- a/erts/emulator/beam/erl_printf_term.c
+++ b/erts/emulator/beam/erl_printf_term.c
@@ -644,58 +644,61 @@ print_term(fmtfn_t fn, void* arg, Eterm obj, long *dcount) {
 		}
 	    }
 	    break;
-	case EXPORT_DEF:
-	    {
-		Export* ep = *((Export **) (export_val(wobj) + 1));
-		long tdcount;
-		int tres;
-
-		PRINT_STRING(res, fn, arg, "fun ");
-
-		/* We pass a temporary 'dcount' and adjust the real one later to ensure
-		 * that the fun doesn't get split up between the module and function
-		 * name. */
-		tdcount = MAX_ATOM_SZ_LIMIT;
-		tres = print_atom_name(fn, arg, ep->info.mfa.module, &tdcount);
-		if (tres < 0) {
-		    res = tres;
-		    goto L_done;
-		}
-		*dcount -= (MAX_ATOM_SZ_LIMIT - tdcount);
-		res += tres;
+        case FUN_DEF:
+            {
+                ErlFunThing *funp = (ErlFunThing *) fun_val(wobj);
+
+                if (is_local_fun(funp)) {
+                    ErlFunEntry *fe = funp->entry.fun;
+                    Atom *ap = atom_tab(atom_val(fe->module));
+
+                    PRINT_STRING(res, fn, arg, "#Fun<");
+                    PRINT_BUF(res, fn, arg, ap->name, ap->len);
+                    PRINT_CHAR(res, fn, arg, '.');
+                    PRINT_SWORD(res, fn, arg, 'd', 0, 1,
+                            (ErlPfSWord) fe->old_index);
+                    PRINT_CHAR(res, fn, arg, '.');
+                    PRINT_SWORD(res, fn, arg, 'd', 0, 1,
+                            (ErlPfSWord) fe->old_uniq);
+                    PRINT_CHAR(res, fn, arg, '>');
+                } else {
+                    Export* ep = funp->entry.exp;
+                    long tdcount;
+                    int tres;
+
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
+
+                    PRINT_STRING(res, fn, arg, "fun ");
+
+                    /* We pass a temporary 'dcount' and adjust the real one
+                     * later to ensure that the fun doesn't get split up
+                     * between the module and function name. */
+                    tdcount = MAX_ATOM_SZ_LIMIT;
+                    tres = print_atom_name(fn, arg, ep->info.mfa.module, &tdcount);
+                    if (tres < 0) {
+                        res = tres;
+                        goto L_done;
+                    }
+                    *dcount -= (MAX_ATOM_SZ_LIMIT - tdcount);
+                    res += tres;
 
-		PRINT_CHAR(res, fn, arg, ':');
+                    PRINT_CHAR(res, fn, arg, ':');
 
-		tdcount = MAX_ATOM_SZ_LIMIT;
-		tres = print_atom_name(fn, arg, ep->info.mfa.function, &tdcount);
-		if (tres < 0) {
-		    res = tres;
-		    goto L_done;
-		}
-		*dcount -= (MAX_ATOM_SZ_LIMIT - tdcount);
-		res += tres;
-
-		PRINT_CHAR(res, fn, arg, '/');
-		PRINT_SWORD(res, fn, arg, 'd', 0, 1,
-			    (ErlPfSWord) ep->info.mfa.arity);
-	    }
-	    break;
-	case FUN_DEF:
-	    {
-		ErlFunThing *funp = (ErlFunThing *) fun_val(wobj);
-		Atom *ap = atom_tab(atom_val(funp->fe->module));
+                    tdcount = MAX_ATOM_SZ_LIMIT;
+                    tres = print_atom_name(fn, arg, ep->info.mfa.function, &tdcount);
+                    if (tres < 0) {
+                        res = tres;
+                        goto L_done;
+                    }
+                    *dcount -= (MAX_ATOM_SZ_LIMIT - tdcount);
+                    res += tres;
 
-		PRINT_STRING(res, fn, arg, "#Fun<");
-		PRINT_BUF(res, fn, arg, ap->name, ap->len);
-		PRINT_CHAR(res, fn, arg, '.');
-		PRINT_SWORD(res, fn, arg, 'd', 0, 1,
-			    (ErlPfSWord) funp->fe->old_index);
-		PRINT_CHAR(res, fn, arg, '.');
-		PRINT_SWORD(res, fn, arg, 'd', 0, 1,
-			    (ErlPfSWord) funp->fe->old_uniq);
-		PRINT_CHAR(res, fn, arg, '>');
-	    }
-	    break;
+                    PRINT_CHAR(res, fn, arg, '/');
+                    PRINT_SWORD(res, fn, arg, 'd', 0, 1,
+                            (ErlPfSWord) ep->info.mfa.arity);
+                }
+            }
+            break;
 	case MAP_DEF: {
             Eterm *head = boxed_val(wobj);
 
diff --git a/erts/emulator/beam/erl_process_dump.c b/erts/emulator/beam/erl_process_dump.c
index 58fb386f44..3f452e3b63 100644
--- a/erts/emulator/beam/erl_process_dump.c
+++ b/erts/emulator/beam/erl_process_dump.c
@@ -708,7 +708,7 @@ dump_externally(fmtfn_t to, void *to_arg, Eterm term)
     byte* s; 
     byte* p;
 
-    if (is_fun(term)) {
+    if (is_any_fun(term)) {
 	/*
 	 * The fun's environment used to cause trouble. There were
 	 * two kind of problems:
diff --git a/erts/emulator/beam/erl_term.c b/erts/emulator/beam/erl_term.c
index fb48584616..12e89437db 100644
--- a/erts/emulator/beam/erl_term.c
+++ b/erts/emulator/beam/erl_term.c
@@ -121,7 +121,7 @@ ET_DEFINE_CHECKED(Uint,arityval,Eterm,is_sane_arity_value);
 ET_DEFINE_CHECKED(Uint,thing_arityval,Eterm,is_thing);
 ET_DEFINE_CHECKED(Uint,thing_subtag,Eterm,is_thing);
 ET_DEFINE_CHECKED(Eterm*,binary_val,Wterm,is_binary);
-ET_DEFINE_CHECKED(Eterm*,fun_val,Wterm,is_fun);
+ET_DEFINE_CHECKED(Eterm*,fun_val,Wterm,is_any_fun);
 ET_DEFINE_CHECKED(int,bignum_header_is_neg,Eterm,_is_bignum_header);
 ET_DEFINE_CHECKED(Eterm,bignum_header_neg,Eterm,_is_bignum_header);
 ET_DEFINE_CHECKED(Uint,bignum_header_arity,Eterm,_is_bignum_header);
@@ -144,7 +144,6 @@ ET_DEFINE_CHECKED(struct erl_node_*,external_port_node,Wterm,is_external_port);
 ET_DEFINE_CHECKED(Uint,external_ref_data_words,Wterm,is_external_ref);
 ET_DEFINE_CHECKED(Uint32*,external_ref_data,Wterm,is_external_ref);
 ET_DEFINE_CHECKED(struct erl_node_*,external_ref_node,Eterm,is_external_ref);
-ET_DEFINE_CHECKED(Eterm*,export_val,Wterm,is_export);
 ET_DEFINE_CHECKED(Uint,external_thing_data_words,ExternalThing*,is_thing_ptr);
 
 ET_DEFINE_CHECKED(Eterm,make_cp,ErtsCodePtr,_is_legal_cp);
diff --git a/erts/emulator/beam/erl_term.h b/erts/emulator/beam/erl_term.h
index 8b2b82e527..a2027f0ec0 100644
--- a/erts/emulator/beam/erl_term.h
+++ b/erts/emulator/beam/erl_term.h
@@ -129,7 +129,6 @@ struct erl_node_; /* Declared in erl_node_tables.h */
 #define REF_SUBTAG		(0x4 << _TAG_PRIMARY_SIZE) /* REF */
 #define FUN_SUBTAG		(0x5 << _TAG_PRIMARY_SIZE) /* FUN */
 #define FLOAT_SUBTAG		(0x6 << _TAG_PRIMARY_SIZE) /* FLOAT */
-#define EXPORT_SUBTAG		(0x7 << _TAG_PRIMARY_SIZE) /* FLOAT */
 #define _BINARY_XXX_MASK	(0x3 << _TAG_PRIMARY_SIZE)
 #define REFC_BINARY_SUBTAG	(0x8 << _TAG_PRIMARY_SIZE) /* BINARY */
 #define HEAP_BINARY_SUBTAG	(0x9 << _TAG_PRIMARY_SIZE) /* BINARY */
@@ -146,7 +145,6 @@ struct erl_node_; /* Declared in erl_node_tables.h */
 #define _TAG_HEADER_POS_BIG        (TAG_PRIMARY_HEADER|POS_BIG_SUBTAG)
 #define _TAG_HEADER_NEG_BIG        (TAG_PRIMARY_HEADER|NEG_BIG_SUBTAG)
 #define _TAG_HEADER_FLOAT          (TAG_PRIMARY_HEADER|FLOAT_SUBTAG)
-#define _TAG_HEADER_EXPORT         (TAG_PRIMARY_HEADER|EXPORT_SUBTAG)
 #define _TAG_HEADER_REF            (TAG_PRIMARY_HEADER|REF_SUBTAG)
 #define _TAG_HEADER_REFC_BIN       (TAG_PRIMARY_HEADER|REFC_BINARY_SUBTAG)
 #define _TAG_HEADER_HEAP_BIN       (TAG_PRIMARY_HEADER|HEAP_BINARY_SUBTAG)
@@ -374,30 +372,16 @@ _ET_DECLARE_CHECKED(Eterm*,binary_val,Wterm)
 /* process binaries stuff (special case of binaries) */
 #define HEADER_PROC_BIN	_make_header(PROC_BIN_SIZE-1,_TAG_HEADER_REFC_BIN)
 
-/* fun & export objects */
-#define is_any_fun(x)   (is_fun((x)) || is_export((x)))
-#define is_not_any_fun(x) (!is_any_fun((x)))
-
 /* fun objects */
-#define HEADER_FUN		_make_header(ERL_FUN_SIZE-2,_TAG_HEADER_FUN)
-#define is_fun_header(x)	((x) == HEADER_FUN)
-#define make_fun(x)		make_boxed((Eterm*)(x))
-#define is_fun(x)		(is_boxed((x)) && is_fun_header(*boxed_val((x))))
-#define is_not_fun(x)		(!is_fun((x)))
+#define HEADER_FUN              _make_header(ERL_FUN_SIZE-2,_TAG_HEADER_FUN)
+#define is_fun_header(x)        ((x) == HEADER_FUN)
+#define make_fun(x)             make_boxed((Eterm*)(x))
+#define is_any_fun(x)           (is_boxed((x)) && is_fun_header(*boxed_val((x))))
+#define is_not_any_fun(x)       (!is_any_fun((x)))
 #define _unchecked_fun_val(x)   _unchecked_boxed_val((x))
 _ET_DECLARE_CHECKED(Eterm*,fun_val,Wterm)
 #define fun_val(x)		_ET_APPLY(fun_val,(x))
 
-/* export access methods */
-#define make_export(x)	 make_boxed((x))
-#define is_export(x)     (is_boxed((x)) && is_export_header(*boxed_val((x))))
-#define is_not_export(x) (!is_export((x)))
-#define _unchecked_export_val(x)   _unchecked_boxed_val(x)
-_ET_DECLARE_CHECKED(Eterm*,export_val,Wterm)
-#define export_val(x)	_ET_APPLY(export_val,(x))
-#define is_export_header(x)	((x) == HEADER_EXPORT)
-#define HEADER_EXPORT   _make_header(1,_TAG_HEADER_EXPORT)
-
 /* bignum access methods */
 #define make_pos_bignum_header(sz)	_make_header((sz),_TAG_HEADER_POS_BIG)
 #define make_neg_bignum_header(sz)	_make_header((sz),_TAG_HEADER_NEG_BIG)
@@ -1398,7 +1382,6 @@ _ET_DECLARE_CHECKED(Uint,loader_y_reg_index,Uint)
 #define EXTERNAL_PID_DEF	0x6
 #define PORT_DEF		0x7
 #define EXTERNAL_PORT_DEF	0x8
-#define EXPORT_DEF		0x9
 #define FUN_DEF			0xa
 #define REF_DEF			0xb
 #define EXTERNAL_REF_DEF	0xc
@@ -1468,7 +1451,6 @@ ERTS_GLB_INLINE unsigned tag_val_def(Wterm x)
 	    case (_TAG_HEADER_NEG_BIG >> _TAG_PRIMARY_SIZE):	return BIG_DEF;
 	    case (_TAG_HEADER_REF >> _TAG_PRIMARY_SIZE):	return REF_DEF;
 	    case (_TAG_HEADER_FLOAT >> _TAG_PRIMARY_SIZE):	return FLOAT_DEF;
-	    case (_TAG_HEADER_EXPORT >> _TAG_PRIMARY_SIZE):     return EXPORT_DEF;
 	    case (_TAG_HEADER_FUN >> _TAG_PRIMARY_SIZE):	return FUN_DEF;
 	    case (_TAG_HEADER_EXTERNAL_PID >> _TAG_PRIMARY_SIZE):	return EXTERNAL_PID_DEF;
 	    case (_TAG_HEADER_EXTERNAL_PORT >> _TAG_PRIMARY_SIZE):	return EXTERNAL_PORT_DEF;
diff --git a/erts/emulator/beam/export.c b/erts/emulator/beam/export.c
index 40f2483937..78f84502fc 100644
--- a/erts/emulator/beam/export.c
+++ b/erts/emulator/beam/export.c
@@ -293,7 +293,7 @@ erts_export_put(Eterm mod, Eterm func, unsigned int arity)
     res = ee->ep;
 
 #ifdef BEAMASM
-    res->addresses[ERTS_SAVE_CALLS_CODE_IX] = beam_save_calls;
+    res->dispatch.addresses[ERTS_SAVE_CALLS_CODE_IX] = beam_save_calls;
 #endif
 
     return res;
@@ -336,7 +336,8 @@ erts_export_get_or_make_stub(Eterm mod, Eterm func, unsigned int arity)
 		ep = entry->ep;
 
 #ifdef BEAMASM
-                ep->addresses[ERTS_SAVE_CALLS_CODE_IX] = beam_save_calls;
+                ep->dispatch.addresses[ERTS_SAVE_CALLS_CODE_IX] =
+                    beam_save_calls;
 #endif
 
 		ASSERT(ep);
@@ -395,10 +396,6 @@ void export_start_staging(void)
     ErtsCodeIndex src_ix = erts_active_code_ix();
     IndexTable* dst = &export_tables[dst_ix];
     IndexTable* src = &export_tables[src_ix];
-    struct export_entry* src_entry;
-#ifdef DEBUG
-    struct export_entry* dst_entry;
-#endif
     int i;
 
     ASSERT(dst_ix != src_ix);
@@ -409,13 +406,23 @@ void export_start_staging(void)
      * Insert all entries in src into dst table
      */
     for (i = 0; i < src->entries; i++) {
-	src_entry = (struct export_entry*) erts_index_lookup(src, i);
-        src_entry->ep->addresses[dst_ix] = src_entry->ep->addresses[src_ix];
-#ifdef DEBUG
-	dst_entry = (struct export_entry*) 
+        struct export_entry* src_entry;
+        ErtsDispatchable *disp;
+
+        src_entry = (struct export_entry*) erts_index_lookup(src, i);
+        disp = &src_entry->ep->dispatch;
+
+        disp->addresses[dst_ix] = disp->addresses[src_ix];
+
+#ifndef DEBUG
+        index_put_entry(dst, src_entry);
+#else /* DEBUG */
+        {
+            struct export_entry* dst_entry =
+                (struct export_entry*)index_put_entry(dst, src_entry);
+            ASSERT(entry_to_blob(src_entry) == entry_to_blob(dst_entry));
+        }
 #endif
-	    index_put_entry(dst, src_entry);
-	ASSERT(entry_to_blob(src_entry) == entry_to_blob(dst_entry));
     }
     export_staging_unlock();
 
diff --git a/erts/emulator/beam/export.h b/erts/emulator/beam/export.h
index 9a5ebd22f6..f6b09e465c 100644
--- a/erts/emulator/beam/export.h
+++ b/erts/emulator/beam/export.h
@@ -32,30 +32,25 @@
 #ifdef BEAMASM
 #define OP_PAD BeamInstr __pad[1];
 #define DISPATCH_SIZE 1
-#define ERTS_ADDRESSV_SIZE (ERTS_NUM_CODE_IX + 1)
-#define ERTS_SAVE_CALLS_CODE_IX (ERTS_ADDRESSV_SIZE - 1)
 #else
 #define OP_PAD
 #define DISPATCH_SIZE 0
-#define ERTS_ADDRESSV_SIZE ERTS_NUM_CODE_IX
 #endif
 
 typedef struct export_
 {
-    /* Pointer to code for function.
-     *
-     * !! THIS WAS DELIBERATELY RENAMED TO CAUSE ERRORS WHEN MERGING !!
+    /* !! WARNING !!
      *
      * The JIT has a special calling convention for export entries, assuming
      * the entry itself is in a certain register. Blindly setting `c_p->i` to
-     * one of these addresses will crash the emulator when the entry is traced,
-     * which is unlikely to be caught in our tests.
+     * one of the addresses in `dispatch` will crash the emulator when the
+     * entry is traced, which is unlikely to be caught in our tests.
      *
      * Use the `BIF_TRAP` macros if at all possible, and be _very_ careful when
-     * accessing these directly.
+     * accessing this field directly.
      *
-     * See `BeamAssembler::emit_setup_export_call` for details. */
-    ErtsCodePtr addresses[ERTS_ADDRESSV_SIZE];
+     * See `BeamAssembler::emit_setup_dispatchable_call` for details. */
+    ErtsDispatchable dispatch;
 
     /* Index into bif_table[], or -1 if not a BIF. */
     int bif_number;
@@ -167,7 +162,7 @@ ERTS_GLB_INLINE void erts_activate_export_trampoline(Export *ep, int code_ix) {
     trampoline_address = (ErtsCodePtr)&ep->trampoline.raw[0];
 #endif
 
-    ep->addresses[code_ix] = trampoline_address;
+    ep->dispatch.addresses[code_ix] = trampoline_address;
 }
 
 ERTS_GLB_INLINE int erts_is_export_trampoline_active(Export *ep, int code_ix) {
@@ -180,7 +175,7 @@ ERTS_GLB_INLINE int erts_is_export_trampoline_active(Export *ep, int code_ix) {
     trampoline_address = (ErtsCodePtr)&ep->trampoline.raw[0];
 #endif
 
-    return ep->addresses[code_ix] == trampoline_address;
+    return ep->dispatch.addresses[code_ix] == trampoline_address;
 }
 
 ERTS_GLB_INLINE Export*
diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c
index aa034b4108..1e1eadf913 100644
--- a/erts/emulator/beam/external.c
+++ b/erts/emulator/beam/external.c
@@ -3683,45 +3683,49 @@ enc_term_int(TTBEncodeContext* ctx, ErtsAtomCacheMap *acmp, Eterm obj, byte* ep,
 		}
 	    }
 	    break;
-	case EXPORT_DEF:
-	    {
-		Export* exp = *((Export **) (export_val(obj) + 1));
-                *ep++ = EXPORT_EXT;
-                ep = enc_atom(acmp, exp->info.mfa.module, ep, dflags);
-                ep = enc_atom(acmp, exp->info.mfa.function, ep, dflags);
-                ep = enc_term(acmp, make_small(exp->info.mfa.arity),
-                              ep, dflags, off_heap);
-		break;
-	    }
-	    break;
-	case FUN_DEF:
-	    {
-		ErlFunThing* funp = (ErlFunThing *) fun_val(obj);
-		int ei;
-
-                *ep++ = NEW_FUN_EXT;
-                WSTACK_PUSH2(s, ENC_PATCH_FUN_SIZE,
-                             (UWord) ep); /* Position for patching in size */
-                ep += 4;
-                *ep = funp->arity;
-                ep += 1;
-                sys_memcpy(ep, funp->fe->uniq, 16);
-                ep += 16;
-                put_int32(funp->fe->index, ep);
-                ep += 4;
-                put_int32(funp->num_free, ep);
-                ep += 4;
-                ep = enc_atom(acmp, funp->fe->module, ep, dflags);
-                ep = enc_term(acmp, make_small(funp->fe->old_index), ep, dflags, off_heap);
-                ep = enc_term(acmp, make_small(funp->fe->old_uniq), ep, dflags, off_heap);
-                ep = enc_pid(acmp, funp->creator, ep, dflags);
-
-		for (ei = funp->num_free-1; ei >= 0; ei--) {
-		    WSTACK_PUSH2(s, ENC_TERM, (UWord) funp->env[ei]);
-		}
-	    }
-	    break;
-	}
+        case FUN_DEF:
+            {
+                ErlFunThing* funp = (ErlFunThing *) fun_val(obj);
+
+                if (is_local_fun(funp)) {
+                    ErlFunEntry* fe = funp->entry.fun;
+                    int ei;
+
+                    *ep++ = NEW_FUN_EXT;
+                    WSTACK_PUSH2(s, ENC_PATCH_FUN_SIZE,
+                                (UWord) ep); /* Position for patching in size */
+                    ep += 4;
+                    *ep = funp->arity;
+                    ep += 1;
+                    sys_memcpy(ep, fe->uniq, 16);
+                    ep += 16;
+                    put_int32(fe->index, ep);
+                    ep += 4;
+                    put_int32(funp->num_free, ep);
+                    ep += 4;
+                    ep = enc_atom(acmp, fe->module, ep, dflags);
+                    ep = enc_term(acmp, make_small(fe->old_index), ep, dflags, off_heap);
+                    ep = enc_term(acmp, make_small(fe->old_uniq), ep, dflags, off_heap);
+                    ep = enc_pid(acmp, funp->creator, ep, dflags);
+
+                    for (ei = funp->num_free-1; ei >= 0; ei--) {
+                        WSTACK_PUSH2(s, ENC_TERM, (UWord) funp->env[ei]);
+                    }
+                } else {
+                    Export *exp = funp->entry.exp;
+
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
+
+                    *ep++ = EXPORT_EXT;
+                    ep = enc_atom(acmp, exp->info.mfa.module, ep, dflags);
+                    ep = enc_atom(acmp, exp->info.mfa.function, ep, dflags);
+                    ep = enc_term(acmp, make_small(exp->info.mfa.arity),
+                                 ep, dflags, off_heap);
+
+                }
+            }
+            break;
+        }
     }
     DESTROY_WSTACK(s);
     if (ctx) {
@@ -4584,42 +4588,45 @@ dec_term_atom_common:
 		}
 		break;
 	    }
-	case EXPORT_EXT:
-	    {
-		Eterm mod;
-		Eterm name;
-		Eterm temp;
-		Sint arity;
-
-		if ((ep = dec_atom(edep, ep, &mod)) == NULL) {
-		    goto error;
-		}
-		if ((ep = dec_atom(edep, ep, &name)) == NULL) {
-		    goto error;
-		}
-		factory->hp = hp;
-		ep = dec_term(edep, factory, ep, &temp, NULL, 0);
-		hp = factory->hp;
-		if (ep == NULL) {
-		    goto error;
-		}
-		if (!is_small(temp)) {
-		    goto error;
-		}
-		arity = signed_val(temp);
-		if (arity < 0) {
-		    goto error;
-		}
-		if (edep && (edep->flags & ERTS_DIST_EXT_BTT_SAFE)) {
-		    if (!erts_active_export_entry(mod, name, arity))
-			goto error;
+        case EXPORT_EXT:
+            {
+                ErlFunThing *funp;
+                Export *export;
+                Eterm mod;
+                Eterm name;
+                Eterm temp;
+                Sint arity;
+
+                if ((ep = dec_atom(edep, ep, &mod)) == NULL) {
+                    goto error;
                 }
-		*objp = make_export(hp);
-		*hp++ = HEADER_EXPORT;
-		*hp++ = (Eterm) erts_export_get_or_make_stub(mod, name, arity);
-		break;
-	    }
-	    break;
+                if ((ep = dec_atom(edep, ep, &name)) == NULL) {
+                    goto error;
+                }
+                factory->hp = hp;
+                ep = dec_term(edep, factory, ep, &temp, NULL, 0);
+                if (ep == NULL) {
+                    goto error;
+                }
+                if (!is_small(temp)) {
+                    goto error;
+                }
+                arity = signed_val(temp);
+                if (arity < 0) {
+                    goto error;
+                }
+                if (edep && (edep->flags & ERTS_DIST_EXT_BTT_SAFE)) {
+                    if (!erts_active_export_entry(mod, name, arity)) {
+                        goto error;
+                    }
+                }
+
+                export = erts_export_get_or_make_stub(mod, name, arity);
+                funp = erts_new_export_fun_thing(&factory->hp, export, arity);
+                hp = factory->hp;
+                *objp = make_fun(funp);
+            }
+            break;
 	case MAP_EXT:
 	    {
 		Uint32 size,n;
@@ -4732,8 +4739,9 @@ dec_term_atom_common:
 		funp->next = factory->off_heap->first;
 		factory->off_heap->first = (struct erl_off_heap_header*)funp;
 
-		funp->fe = erts_put_fun_entry2(module, old_uniq, old_index,
-					       uniq, index, arity);
+                funp->entry.fun = erts_put_fun_entry2(module, old_uniq,
+                                                      old_index, uniq,
+                                                      index, arity);
 		funp->arity = arity;
 		hp = factory->hp;
 
@@ -5258,52 +5266,55 @@ encode_size_struct_int(TTBSizeContext* ctx, ErtsAtomCacheMap *acmp, Eterm obj,
             }
 	    break;
         }
-	case FUN_DEF:
-	    {
-		ErlFunThing* funp = (ErlFunThing *) fun_val(obj);
-
-                result += 20+1+1+4;	/* New ID + Tag */
-                result += 4; /* Length field (number of free variables */
-                result += encode_size_struct2(acmp, funp->creator, dflags);
-                result += encode_size_struct2(acmp, funp->fe->module, dflags);
-                result += 2 * (1+4);	/* Index, Uniq */
-		if (funp->num_free > 1) {
-		    WSTACK_PUSH2(s, (UWord) (funp->env + 1),
-				    (UWord) TERM_ARRAY_OP(funp->num_free-1));
-		}
-		if (funp->num_free != 0) {
-		    obj = funp->env[0];
-		    continue; /* big loop */
-		}
-		break;
-	    }
-
-	case EXPORT_DEF:
-	    {
-		Export* ep = *((Export **) (export_val(obj) + 1));
-                Uint tmp_result = result;
-		result += 1;
-		result += encode_size_struct2(acmp, ep->info.mfa.module, dflags);
-		result += encode_size_struct2(acmp, ep->info.mfa.function, dflags);
-		result += encode_size_struct2(acmp, make_small(ep->info.mfa.arity), dflags);
-                if (dflags & DFLAG_PENDING_CONNECT) {
-                    Uint csz;
-		    ASSERT(ctx);
-
-                    /*
-                     * Fallback is 1 + 1 + Module size + Function size, that is,
-                     * the hopefull index + hopefull encoding is larger...
-                     */
-                    ASSERT(dflags & DFLAG_EXPORT_PTR_TAG);
-                    csz = tmp_result - ctx->last_result;
-                    /* potentially multiple elements leading up to hopefull entry */
-                    vlen += (csz/MAX_SYSIOVEC_IOVLEN + 1
-			     + 1); /* hopefull entry */
-                    result += 4; /* hopefull index */
-                    ctx->last_result = result;
+        case FUN_DEF:
+            {
+                ErlFunThing *funp = (ErlFunThing *) fun_val(obj);
+
+                if (is_local_fun(funp)) {
+                    result += 20+1+1+4;	/* New ID + Tag */
+                    result += 4; /* Length field (number of free variables */
+                    result += encode_size_struct2(acmp, funp->creator, dflags);
+                    result += encode_size_struct2(acmp, funp->entry.fun->module, dflags);
+                    result += 2 * (1+4);	/* Index, Uniq */
+                    if (funp->num_free > 1) {
+                        WSTACK_PUSH2(s, (UWord) (funp->env + 1),
+                                    (UWord) TERM_ARRAY_OP(funp->num_free-1));
+                    }
+                    if (funp->num_free != 0) {
+                        obj = funp->env[0];
+                        continue; /* big loop */
+                    }
+                } else {
+                    Export* ep = funp->entry.exp;
+                    Uint tmp_result = result;
+
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
+
+                    result += 1;
+                    result += encode_size_struct2(acmp, ep->info.mfa.module, dflags);
+                    result += encode_size_struct2(acmp, ep->info.mfa.function, dflags);
+                    result += encode_size_struct2(acmp, make_small(ep->info.mfa.arity), dflags);
+
+                    if (dflags & DFLAG_PENDING_CONNECT) {
+                        Uint csz;
+                        ASSERT(ctx);
+
+                        /* Fallback is 1 + 1 + Module size + Function size,
+                         * that is, the hopeful index + hopeful encoding is
+                         * larger... */
+                        ASSERT(dflags & DFLAG_EXPORT_PTR_TAG);
+                        csz = tmp_result - ctx->last_result;
+
+                        /* Potentially multiple elements leading up to hopeful
+                         * entry */
+                        vlen += (csz/MAX_SYSIOVEC_IOVLEN + 1
+                                 + 1); /* hopeful entry */
+                        result += 4; /* hopeful index */
+                        ctx->last_result = result;
+                    }
                 }
-	    }
-	    break;
+                break;
+        }
 
 	default:
 	    erts_exit(ERTS_ERROR_EXIT,"Internal data structure error (in encode_size_struct_int) %x\n",
@@ -5619,7 +5630,7 @@ init_done:
 	    break;
 	case EXPORT_EXT:
 	    terms += 3;
-	    heap_size += 2;
+	    heap_size += ERL_FUN_SIZE;
 	    break;
 	case NEW_FUN_EXT:
 	    {
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 904d394fca..cc958223bc 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1732,8 +1732,10 @@ int erts_beam_jump_table(void);
 ERTS_GLB_INLINE void dtrace_pid_str(Eterm pid, char *process_buf);
 ERTS_GLB_INLINE void dtrace_proc_str(Process *process, char *process_buf);
 ERTS_GLB_INLINE void dtrace_port_str(Port *port, char *port_buf);
-ERTS_GLB_INLINE void dtrace_fun_decode(Process *process, ErtsCodeMFA *mfa,
-				       char *process_buf, char *mfa_buf);
+ERTS_GLB_INLINE void dtrace_fun_decode(Process *process,
+                                       const ErtsCodeMFA *mfa,
+                                       char *process_buf,
+                                       char *mfa_buf);
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
 
@@ -1766,7 +1768,7 @@ dtrace_port_str(Port *port, char *port_buf)
 }
 
 ERTS_GLB_INLINE void
-dtrace_fun_decode(Process *process, ErtsCodeMFA *mfa,
+dtrace_fun_decode(Process *process, const ErtsCodeMFA *mfa,
                   char *process_buf, char *mfa_buf)
 {
     if (process_buf) {
diff --git a/erts/emulator/beam/jit/arm/beam_asm.hpp b/erts/emulator/beam/jit/arm/beam_asm.hpp
index fbd42ba962..c886e37365 100644
--- a/erts/emulator/beam/jit/arm/beam_asm.hpp
+++ b/erts/emulator/beam/jit/arm/beam_asm.hpp
@@ -376,21 +376,26 @@ protected:
         }
     }
 
-    /* Returns the current code address for the export entry in `Src`
+    /* Returns the current code address for the `Export` or `ErlFunEntry` in
+     * `Src`.
      *
-     * Export tracing, save_calls, etc is implemented by shared fragments that
-     * assume that the export entry is in ARG1, so we have to copy it over if it
-     * isn't already. */
-    arm::Mem emit_setup_export_call(const arm::Gp &Src) {
-        return emit_setup_export_call(Src, active_code_ix);
+     * Export tracing, save_calls, etc are implemented by shared fragments that
+     * assume that the respective entry is in ARG1, so we have to copy it over
+     * if it isn't already. */
+    arm::Mem emit_setup_dispatchable_call(const arm::Gp &Src) {
+        return emit_setup_dispatchable_call(Src, active_code_ix);
     }
 
-    arm::Mem emit_setup_export_call(const arm::Gp &Src,
-                                    const arm::Gp &CodeIndex) {
+    arm::Mem emit_setup_dispatchable_call(const arm::Gp &Src,
+                                          const arm::Gp &CodeIndex) {
         if (ARG1 != Src) {
             a.mov(ARG1, Src);
         }
-        ERTS_CT_ASSERT(offsetof(Export, addresses) == 0);
+
+        ERTS_CT_ASSERT(offsetof(ErlFunEntry, dispatch) == 0);
+        ERTS_CT_ASSERT(offsetof(Export, dispatch) == 0);
+        ERTS_CT_ASSERT(offsetof(ErtsDispatchable, addresses) == 0);
+
         return arm::Mem(ARG1, CodeIndex, arm::lsl(3));
     }
 
diff --git a/erts/emulator/beam/jit/arm/beam_asm_global.cpp b/erts/emulator/beam/jit/arm/beam_asm_global.cpp
index 723d2199a0..efc94c49c7 100644
--- a/erts/emulator/beam/jit/arm/beam_asm_global.cpp
+++ b/erts/emulator/beam/jit/arm/beam_asm_global.cpp
@@ -151,7 +151,7 @@ void BeamGlobalAssembler::emit_bif_export_trap() {
 
     emit_leave_erlang_frame();
 
-    branch(emit_setup_export_call(ARG1));
+    branch(emit_setup_dispatchable_call(ARG1));
 }
 
 /* Handles export breakpoints, error handler, jump tracing, and so on.
@@ -232,7 +232,7 @@ void BeamGlobalAssembler::emit_export_trampoline() {
 
         a.cbz(ARG1, labels[process_exit]);
 
-        branch(emit_setup_export_call(ARG1));
+        branch(emit_setup_dispatchable_call(ARG1));
     }
 }
 
diff --git a/erts/emulator/beam/jit/arm/instr_bif.cpp b/erts/emulator/beam/jit/arm/instr_bif.cpp
index 199a517e0d..6e6310fe4d 100644
--- a/erts/emulator/beam/jit/arm/instr_bif.cpp
+++ b/erts/emulator/beam/jit/arm/instr_bif.cpp
@@ -535,7 +535,7 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
     a.bind(trace);
     {
         /* Call the export entry instead of the BIF. */
-        branch(emit_setup_export_call(ARG4));
+        branch(emit_setup_dispatchable_call(ARG4));
     }
 
     a.bind(yield);
diff --git a/erts/emulator/beam/jit/arm/instr_call.cpp b/erts/emulator/beam/jit/arm/instr_call.cpp
index a141ef5fd1..8afd37fcf1 100644
--- a/erts/emulator/beam/jit/arm/instr_call.cpp
+++ b/erts/emulator/beam/jit/arm/instr_call.cpp
@@ -88,20 +88,20 @@ void BeamGlobalAssembler::emit_dispatch_save_calls() {
     a.mov(TMP1, imm(&the_active_code_index));
     a.ldr(TMP1.w(), arm::Mem(TMP1));
 
-    branch(emit_setup_export_call(ARG1, TMP1));
+    branch(emit_setup_dispatchable_call(ARG1, TMP1));
 }
 
 void BeamModuleAssembler::emit_i_call_ext(const ArgVal &Exp) {
     mov_arg(ARG1, Exp);
 
-    arm::Mem target = emit_setup_export_call(ARG1);
+    arm::Mem target = emit_setup_dispatchable_call(ARG1);
     erlang_call(target);
 }
 
 void BeamModuleAssembler::emit_i_call_ext_only(const ArgVal &Exp) {
     mov_arg(ARG1, Exp);
 
-    arm::Mem target = emit_setup_export_call(ARG1);
+    arm::Mem target = emit_setup_dispatchable_call(ARG1);
     emit_leave_erlang_frame();
     branch(target);
 }
@@ -142,7 +142,7 @@ arm::Mem BeamModuleAssembler::emit_variable_apply(bool includeI) {
     emit_raise_exception(entry, &apply3_mfa);
 
     a.bind(dispatch);
-    return emit_setup_export_call(ARG1);
+    return emit_setup_dispatchable_call(ARG1);
 }
 
 void BeamModuleAssembler::emit_i_apply() {
@@ -195,7 +195,7 @@ arm::Mem BeamModuleAssembler::emit_fixed_apply(const ArgVal &Arity,
 
     a.bind(dispatch);
 
-    return emit_setup_export_call(ARG1);
+    return emit_setup_dispatchable_call(ARG1);
 }
 
 void BeamModuleAssembler::emit_apply(const ArgVal &Arity) {
diff --git a/erts/emulator/beam/jit/arm/instr_common.cpp b/erts/emulator/beam/jit/arm/instr_common.cpp
index adc8112a2e..17f1c4ba2f 100644
--- a/erts/emulator/beam/jit/arm/instr_common.cpp
+++ b/erts/emulator/beam/jit/arm/instr_common.cpp
@@ -747,8 +747,6 @@ void BeamModuleAssembler::emit_is_function(const ArgVal &Fail,
     arm::Gp boxed_ptr = emit_ptr_val(TMP1, src.reg);
     a.ldur(TMP1, emit_boxed_val(boxed_ptr));
     a.cmp(TMP1, imm(HEADER_FUN));
-    a.cond_eq().b(next);
-    a.cmp(TMP1, imm(HEADER_EXPORT));
     a.cond_ne().b(resolve_beam_label(Fail, disp1MB));
 
     a.bind(next);
@@ -785,9 +783,6 @@ void BeamModuleAssembler::emit_is_function2(const ArgVal &Fail,
         return;
     }
 
-    Label next = a.newLabel();
-    Label fun = a.newLabel();
-
     auto src = load_source(Src, TMP1);
 
     emit_is_boxed(resolve_beam_label(Fail, dispUnknown), src.reg);
@@ -795,24 +790,10 @@ void BeamModuleAssembler::emit_is_function2(const ArgVal &Fail,
     arm::Gp boxed_ptr = emit_ptr_val(TMP1, src.reg);
     a.ldur(TMP2, emit_boxed_val(boxed_ptr));
     a.cmp(TMP2, imm(HEADER_FUN));
-    a.cond_eq().b(fun);
-    a.cmp(TMP2, imm(HEADER_EXPORT));
     a.cond_ne().b(resolve_beam_label(Fail, disp1MB));
 
-    comment("Check arity of export fun");
-    a.ldur(TMP2, emit_boxed_val(boxed_ptr, sizeof(Eterm)));
-    a.ldr(TMP2, arm::Mem(TMP2, offsetof(Export, info.mfa.arity)));
+    a.ldur(TMP2, emit_boxed_val(boxed_ptr, offsetof(ErlFunThing, arity)));
     emit_branch_if_ne(TMP2, arity, resolve_beam_label(Fail, dispUnknown));
-    a.b(next);
-
-    comment("Check arity of fun");
-    a.bind(fun);
-    {
-        a.ldur(TMP2, emit_boxed_val(boxed_ptr, offsetof(ErlFunThing, arity)));
-        emit_branch_if_ne(TMP2, arity, resolve_beam_label(Fail, dispUnknown));
-    }
-
-    a.bind(next);
 }
 
 void BeamModuleAssembler::emit_is_integer(const ArgVal &Fail,
diff --git a/erts/emulator/beam/jit/arm/instr_fun.cpp b/erts/emulator/beam/jit/arm/instr_fun.cpp
index bd04162ba2..345a83cf3d 100644
--- a/erts/emulator/beam/jit/arm/instr_fun.cpp
+++ b/erts/emulator/beam/jit/arm/instr_fun.cpp
@@ -28,7 +28,7 @@
  * ARG3 = arity
  * ARG4 = fun thing
  * ARG5 = address of the call_fun instruction that got us here. Note that we
- *        can't use LR (x30) for this because tail calls point elsehwere. */
+ *        can't use LR (x30) for this because tail calls point elsewhere. */
 void BeamGlobalAssembler::emit_unloaded_fun() {
     Label error = a.newLabel();
 
@@ -49,7 +49,7 @@ void BeamGlobalAssembler::emit_unloaded_fun() {
 
     a.cbz(ARG1, error);
 
-    a.ldr(TMP1, emit_setup_export_call(ARG1));
+    a.ldr(TMP1, emit_setup_dispatchable_call(ARG1));
     a.br(TMP1);
 
     a.bind(error);
@@ -60,13 +60,13 @@ void BeamGlobalAssembler::emit_unloaded_fun() {
     }
 }
 
-/* Handles errors for `call_fun` and `i_lambda_trampoline`. Assumes that we're
- * running on the Erlang stack with a valid stack frame.
+/* Handles errors for `call_fun`. Assumes that we're running on the Erlang
+ * stack with a valid stack frame.
  *
  * ARG3 = arity
  * ARG4 = fun thing
  * ARG5 = address of the call_fun instruction that got us here. Note that we
- *        can't use LR (x30) for this because tail calls point elsehwere. */
+ *        can't use LR (x30) for this because tail calls point elsewhere. */
 void BeamGlobalAssembler::emit_handle_call_fun_error() {
     Label bad_arity = a.newLabel(), bad_fun = a.newLabel();
 
@@ -76,12 +76,9 @@ void BeamGlobalAssembler::emit_handle_call_fun_error() {
     a.ldur(TMP1, emit_boxed_val(fun_thing));
     a.cmp(TMP1, imm(HEADER_FUN));
     a.cond_eq().b(bad_arity);
-    a.cmp(TMP1, imm(HEADER_EXPORT));
-    a.cond_eq().b(bad_arity);
 
     a.bind(bad_fun);
     {
-        /* Not a fun. This is only reachable through `call_fun` */
         mov_imm(TMP1, EXC_BADFUN);
         a.str(TMP1, arm::Mem(c_p, offsetof(Process, freason)));
         a.str(ARG4, arm::Mem(c_p, offsetof(Process, fvalue)));
@@ -93,9 +90,6 @@ void BeamGlobalAssembler::emit_handle_call_fun_error() {
 
     a.bind(bad_arity);
     {
-        /* Bad arity. This is reachable through `call_fun` when we have an
-         * export fun, and `i_lambda_trampoline` when we have a local one. */
-
         a.stp(ARG4, ARG5, TMP_MEM1q);
 
         emit_enter_runtime<Update::eHeap | Update::eStack | Update::eXRegs>();
@@ -141,8 +135,8 @@ void BeamGlobalAssembler::emit_handle_call_fun_error() {
     }
 }
 
-/* `call_fun` instructions land here to check arity and set up their
- * environment before jumping to the actual implementation.
+/* `call_fun` instructions land here to set up their environment before jumping
+ * to the actual implementation.
  *
  * Keep in mind that this runs in the limbo between caller and callee. It must
  * not clobber LR (x30).
@@ -157,15 +151,18 @@ void BeamModuleAssembler::emit_i_lambda_trampoline(const ArgVal &Index,
     const ssize_t env_offset = offsetof(ErlFunThing, env) - TAG_PRIMARY_BOXED;
     const ssize_t fun_arity = Arity.getValue() - NumFree.getValue();
     const ssize_t total_arity = Arity.getValue();
-    Label error = a.newLabel();
 
     auto &lambda = lambdas[Index.getValue()];
+
+    if (NumFree.getValue() == 0) {
+        /* No free variables, let the lambda jump directly to our target. */
+        lambda.trampoline = rawLabels[Lbl.getValue()];
+        return;
+    }
+
     lambda.trampoline = a.newLabel();
     a.bind(lambda.trampoline);
 
-    a.cmp(ARG3, imm(fun_arity));
-    a.cond_ne().b(error);
-
     if (NumFree.getValue() == 1) {
         auto first = init_destination(ArgVal(ArgVal::XReg, fun_arity), TMP1);
 
@@ -196,12 +193,6 @@ void BeamModuleAssembler::emit_i_lambda_trampoline(const ArgVal &Index,
     }
 
     a.b(resolve_beam_label(Lbl, disp128MB));
-
-    a.bind(error);
-    {
-        emit_enter_erlang_frame();
-        a.b(resolve_fragment(ga->get_handle_call_fun_error(), disp128MB));
-    }
 }
 
 void BeamModuleAssembler::emit_i_make_fun3(const ArgVal &Fun,
@@ -214,14 +205,14 @@ void BeamModuleAssembler::emit_i_make_fun3(const ArgVal &Fun,
 
     ASSERT(num_free == env.size());
 
+    a.mov(ARG1, c_p);
     mov_arg(ARG2, Fun);
     mov_arg(ARG3, Arity);
     mov_arg(ARG4, NumFree);
 
     emit_enter_runtime<Update::eHeap>();
 
-    a.mov(ARG1, c_p);
-    runtime_call<4>(new_fun_thing);
+    runtime_call<4>(erts_new_local_fun_thing);
 
     emit_leave_runtime<Update::eHeap>();
 
@@ -343,14 +334,16 @@ void BeamModuleAssembler::emit_i_apply_fun_only() {
  *   ARG3 = arity
  *   ARG4 = fun thing */
 arm::Gp BeamModuleAssembler::emit_call_fun() {
-    Label exported = a.newLabel(), next = a.newLabel();
+    Label next = a.newLabel();
+
+    /* Speculatively untag the ErlFunThing. */
+    emit_untag_ptr(TMP2, ARG4);
 
     /* Load the error fragment into TMP3 so we can CSEL ourselves there on
      * error. */
     a.adr(TMP3, resolve_fragment(ga->get_handle_call_fun_error(), disp1MB));
 
-    /* The `handle_call_fun_error` and `i_lambda_trampoline` fragments expect
-     * current PC in ARG5. */
+    /* The `handle_call_fun_error` fragment expects current PC in ARG5. */
     a.adr(ARG5, next);
 
     /* As emit_is_boxed(), but explicitly sets ZF so we can rely on that for
@@ -358,26 +351,18 @@ arm::Gp BeamModuleAssembler::emit_call_fun() {
     a.tst(ARG4, imm(_TAG_PRIMARY_MASK - TAG_PRIMARY_BOXED));
     a.cond_ne().b(next);
 
-    arm::Gp fun_thing = emit_ptr_val(TMP2, ARG4);
-    a.ldur(TMP1, emit_boxed_val(fun_thing));
-    a.cmp(TMP1, imm(HEADER_EXPORT));
-    a.cond_eq().b(exported);
+    /* Load header word and `ErlFunThing->entry`. We can safely do this before
+     * testing the header because boxed terms are guaranteed to be at least two
+     * words long. */
+    a.ldp(TMP1, ARG1, arm::Mem(TMP2));
+
     a.cmp(TMP1, imm(HEADER_FUN));
     a.cond_ne().b(next);
 
-    a.ldur(TMP1, emit_boxed_val(fun_thing, offsetof(ErlFunThing, fe)));
-    a.ldr(TMP1, arm::Mem(TMP1, offsetof(ErlFunEntry, address)));
-    a.b(next);
-
-    a.bind(exported);
-    {
-        a.ldur(ARG1, emit_boxed_val(fun_thing, sizeof(Eterm)));
+    a.ldr(TMP2, arm::Mem(TMP2, offsetof(ErlFunThing, arity)));
+    a.cmp(TMP2, ARG3);
 
-        a.ldr(TMP1, arm::Mem(ARG1, offsetof(Export, info.mfa.arity)));
-        a.cmp(TMP1, ARG3);
-
-        a.ldr(TMP1, emit_setup_export_call(ARG1));
-    }
+    a.ldr(TMP1, emit_setup_dispatchable_call(ARG1));
 
     /* Assumes that ZF is set on success and clear on error, overwriting our
      * destination with the error fragment's address. */
diff --git a/erts/emulator/beam/jit/arm/instr_trace.cpp b/erts/emulator/beam/jit/arm/instr_trace.cpp
index ff32ebed31..3db2dbd960 100644
--- a/erts/emulator/beam/jit/arm/instr_trace.cpp
+++ b/erts/emulator/beam/jit/arm/instr_trace.cpp
@@ -121,7 +121,7 @@ void BeamGlobalAssembler::emit_debug_bp() {
     a.cbz(ARG1, error);
 
     emit_leave_erlang_frame();
-    branch(emit_setup_export_call(ARG1));
+    branch(emit_setup_dispatchable_call(ARG1));
 
     a.bind(error);
     {
diff --git a/erts/emulator/beam/jit/asm_load.c b/erts/emulator/beam/jit/asm_load.c
index 744fb9bcfe..77b771926d 100644
--- a/erts/emulator/beam/jit/asm_load.c
+++ b/erts/emulator/beam/jit/asm_load.c
@@ -942,7 +942,7 @@ void beam_load_finalize_code(LoaderState *stp,
              * code callable. */
             ep->trampoline.not_loaded.deferred = (BeamInstr)address;
         } else {
-            ep->addresses[staging_ix] = address;
+            ep->dispatch.addresses[staging_ix] = address;
         }
     }
 
@@ -983,7 +983,7 @@ void beam_load_finalize_code(LoaderState *stp,
                 erts_refc_dectest(&fun_entry->refc, 1);
             }
 
-            fun_entry->address = beamasm_get_lambda(stp->ba, i);
+            erts_set_fun_code(fun_entry, beamasm_get_lambda(stp->ba, i));
 
             beamasm_patch_lambda(stp->ba,
                                  stp->native_module_rw,
diff --git a/erts/emulator/beam/jit/beam_jit_common.cpp b/erts/emulator/beam/jit/beam_jit_common.cpp
index 043a4739db..9d362cfc6c 100644
--- a/erts/emulator/beam/jit/beam_jit_common.cpp
+++ b/erts/emulator/beam/jit/beam_jit_common.cpp
@@ -1099,7 +1099,9 @@ Export *beam_jit_handle_unloaded_fun(Process *c_p,
     Export *ep;
 
     funp = (ErlFunThing *)fun_val(fun_thing);
-    fe = funp->fe;
+    ASSERT(is_local_fun(funp));
+
+    fe = funp->entry.fun;
     module = fe->module;
 
     ERTS_THR_READ_MEMORY_BARRIER;
diff --git a/erts/emulator/beam/jit/x86/beam_asm.hpp b/erts/emulator/beam/jit/x86/beam_asm.hpp
index dee1edebb5..3017e6bbb9 100644
--- a/erts/emulator/beam/jit/x86/beam_asm.hpp
+++ b/erts/emulator/beam/jit/x86/beam_asm.hpp
@@ -500,22 +500,29 @@ protected:
         }
     }
 
-    /* Returns the current code address for the export entry in `Src`
+    /* Returns the current code address for the `Export` or `ErlFunEntry` in
+     * `Src`.
      *
-     * Export tracing, save_calls, etc is implemented by shared fragments that
-     * assume that the export entry is in RET, so we have to copy it over if it
-     * isn't already. */
-    x86::Mem emit_setup_export_call(const x86::Gp &Src) {
-        return emit_setup_export_call(Src, active_code_ix);
+     * Export tracing, save_calls, etc are implemented by shared fragments that
+     * assume that the respective entry is in RET, so we have to copy it over
+     * if it isn't already. */
+    x86::Mem emit_setup_dispatchable_call(const x86::Gp &Src) {
+        return emit_setup_dispatchable_call(Src, active_code_ix);
     }
 
-    x86::Mem emit_setup_export_call(const x86::Gp &Src,
-                                    const x86::Gp &CodeIndex) {
+    x86::Mem emit_setup_dispatchable_call(const x86::Gp &Src,
+                                          const x86::Gp &CodeIndex) {
         if (RET != Src) {
             a.mov(RET, Src);
         }
 
-        return x86::qword_ptr(RET, CodeIndex, 3, offsetof(Export, addresses));
+        ERTS_CT_ASSERT(offsetof(ErlFunEntry, dispatch) == 0);
+        ERTS_CT_ASSERT(offsetof(Export, dispatch) == 0);
+
+        return x86::qword_ptr(RET,
+                              CodeIndex,
+                              3,
+                              offsetof(ErtsDispatchable, addresses));
     }
 
     void emit_assert_runtime_stack() {
diff --git a/erts/emulator/beam/jit/x86/beam_asm_global.cpp b/erts/emulator/beam/jit/x86/beam_asm_global.cpp
index f388aefa3b..902c995227 100644
--- a/erts/emulator/beam/jit/x86/beam_asm_global.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm_global.cpp
@@ -148,7 +148,7 @@ void BeamGlobalAssembler::emit_bif_export_trap() {
     a.sub(RET, imm(offsetof(Export, info.mfa)));
 
     emit_leave_frame();
-    a.jmp(emit_setup_export_call(RET));
+    a.jmp(emit_setup_dispatchable_call(RET));
 }
 
 /* Handles export breakpoints, error handler, jump tracing, and so on.
@@ -218,7 +218,7 @@ void BeamGlobalAssembler::emit_export_trampoline() {
         a.je(labels[process_exit]);
 
         emit_leave_frame();
-        a.jmp(emit_setup_export_call(RET));
+        a.jmp(emit_setup_dispatchable_call(RET));
     }
 }
 
diff --git a/erts/emulator/beam/jit/x86/instr_bif.cpp b/erts/emulator/beam/jit/x86/instr_bif.cpp
index e435a9e4fd..6c8160a7de 100644
--- a/erts/emulator/beam/jit/x86/instr_bif.cpp
+++ b/erts/emulator/beam/jit/x86/instr_bif.cpp
@@ -622,7 +622,7 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
         a.pop(getCPRef());
 #endif
 
-        x86::Mem destination = emit_setup_export_call(ARG4);
+        x86::Mem destination = emit_setup_dispatchable_call(ARG4);
         a.jmp(destination);
     }
 
diff --git a/erts/emulator/beam/jit/x86/instr_call.cpp b/erts/emulator/beam/jit/x86/instr_call.cpp
index 466b184295..49eabfdaef 100644
--- a/erts/emulator/beam/jit/x86/instr_call.cpp
+++ b/erts/emulator/beam/jit/x86/instr_call.cpp
@@ -116,18 +116,18 @@ void BeamGlobalAssembler::emit_dispatch_save_calls() {
     a.mov(ARG1, imm(&the_active_code_index));
     a.mov(ARG1d, x86::dword_ptr(ARG1));
 
-    a.jmp(emit_setup_export_call(RET, ARG1));
+    a.jmp(emit_setup_dispatchable_call(RET, ARG1));
 }
 
 void BeamModuleAssembler::emit_i_call_ext(const ArgVal &Exp) {
     make_move_patch(RET, imports[Exp.getValue()].patches);
-    x86::Mem destination = emit_setup_export_call(RET);
+    x86::Mem destination = emit_setup_dispatchable_call(RET);
     erlang_call(destination, ARG1);
 }
 
 void BeamModuleAssembler::emit_i_call_ext_only(const ArgVal &Exp) {
     make_move_patch(RET, imports[Exp.getValue()].patches);
-    x86::Mem destination = emit_setup_export_call(RET);
+    x86::Mem destination = emit_setup_dispatchable_call(RET);
 
     emit_leave_frame();
     a.jmp(destination);
@@ -138,7 +138,7 @@ void BeamModuleAssembler::emit_i_call_ext_last(const ArgVal &Exp,
     emit_deallocate(Deallocate);
 
     make_move_patch(RET, imports[Exp.getValue()].patches);
-    x86::Mem destination = emit_setup_export_call(RET);
+    x86::Mem destination = emit_setup_dispatchable_call(RET);
 
     emit_leave_frame();
     a.jmp(destination);
@@ -174,7 +174,7 @@ x86::Mem BeamModuleAssembler::emit_variable_apply(bool includeI) {
     emit_raise_exception(entry, &apply3_mfa);
     a.bind(dispatch);
 
-    return emit_setup_export_call(RET);
+    return emit_setup_dispatchable_call(RET);
 }
 
 void BeamModuleAssembler::emit_i_apply() {
@@ -226,7 +226,7 @@ x86::Mem BeamModuleAssembler::emit_fixed_apply(const ArgVal &Arity,
     emit_raise_exception(entry, &apply3_mfa);
     a.bind(dispatch);
 
-    return emit_setup_export_call(RET);
+    return emit_setup_dispatchable_call(RET);
 }
 
 void BeamModuleAssembler::emit_apply(const ArgVal &Arity) {
diff --git a/erts/emulator/beam/jit/x86/instr_common.cpp b/erts/emulator/beam/jit/x86/instr_common.cpp
index e0dd4d792b..1cd9c902f7 100644
--- a/erts/emulator/beam/jit/x86/instr_common.cpp
+++ b/erts/emulator/beam/jit/x86/instr_common.cpp
@@ -851,8 +851,6 @@ void BeamModuleAssembler::emit_is_float(const ArgVal &Fail, const ArgVal &Src) {
 
 void BeamModuleAssembler::emit_is_function(const ArgVal &Fail,
                                            const ArgVal &Src) {
-    Label next = a.newLabel();
-
     mov_arg(RET, Src);
 
     emit_is_boxed(labels[Fail.getValue()], RET);
@@ -860,12 +858,7 @@ void BeamModuleAssembler::emit_is_function(const ArgVal &Fail,
     x86::Gp boxed_ptr = emit_ptr_val(RET, RET);
     a.mov(RETd, emit_boxed_val(boxed_ptr, 0, sizeof(Uint32)));
     a.cmp(RET, imm(HEADER_FUN));
-    a.short_().je(next);
-    ERTS_CT_ASSERT(HEADER_EXPORT < 256);
-    a.cmp(RETb, imm(HEADER_EXPORT));
     a.jne(labels[Fail.getValue()]);
-
-    a.bind(next);
 }
 
 void BeamModuleAssembler::emit_is_function2(const ArgVal &Fail,
@@ -897,8 +890,6 @@ void BeamModuleAssembler::emit_is_function2(const ArgVal &Fail,
         return;
     }
 
-    Label next = a.newLabel(), fun = a.newLabel();
-
     mov_arg(ARG1, Src);
 
     emit_is_boxed(labels[Fail.getValue()], ARG1);
@@ -906,26 +897,10 @@ void BeamModuleAssembler::emit_is_function2(const ArgVal &Fail,
     x86::Gp boxed_ptr = emit_ptr_val(ARG1, ARG1);
     a.mov(RETd, emit_boxed_val(boxed_ptr, 0, sizeof(Uint32)));
     a.cmp(RETd, imm(HEADER_FUN));
-    a.short_().je(fun);
-    ERTS_CT_ASSERT(HEADER_EXPORT < 256);
-    a.cmp(RETb, imm(HEADER_EXPORT));
     a.jne(labels[Fail.getValue()]);
 
-    comment("Check arity of export fun");
-    a.mov(ARG2, emit_boxed_val(boxed_ptr, sizeof(Eterm)));
-    a.cmp(x86::qword_ptr(ARG2, offsetof(Export, info.mfa.arity)), imm(arity));
+    a.cmp(emit_boxed_val(boxed_ptr, offsetof(ErlFunThing, arity)), imm(arity));
     a.jne(labels[Fail.getValue()]);
-    a.short_().jmp(next);
-
-    comment("Check arity of fun");
-    a.bind(fun);
-    {
-        a.cmp(emit_boxed_val(boxed_ptr, offsetof(ErlFunThing, arity)),
-              imm(arity));
-        a.jne(labels[Fail.getValue()]);
-    }
-
-    a.bind(next);
 }
 
 void BeamModuleAssembler::emit_is_integer(const ArgVal &Fail,
diff --git a/erts/emulator/beam/jit/x86/instr_fun.cpp b/erts/emulator/beam/jit/x86/instr_fun.cpp
index 1c8c1a22d9..27600cf128 100644
--- a/erts/emulator/beam/jit/x86/instr_fun.cpp
+++ b/erts/emulator/beam/jit/x86/instr_fun.cpp
@@ -46,7 +46,7 @@ void BeamGlobalAssembler::emit_unloaded_fun() {
     a.jz(error);
 
     emit_leave_frame();
-    a.jmp(emit_setup_export_call(RET));
+    a.jmp(emit_setup_dispatchable_call(RET));
 
     a.bind(error);
     {
@@ -58,7 +58,7 @@ void BeamGlobalAssembler::emit_unloaded_fun() {
     }
 }
 
-/* Handles errors for `call_fun` and `i_lambda_trampoline`.
+/* Handles errors for `call_fun`.
  *
  * ARG3 = arity
  * ARG4 = fun thing
@@ -71,15 +71,11 @@ void BeamGlobalAssembler::emit_handle_call_fun_error() {
     emit_is_boxed(bad_fun, ARG4);
 
     x86::Gp fun_thing = emit_ptr_val(RET, ARG4);
-    a.mov(RET, emit_boxed_val(fun_thing));
-    a.cmp(RET, imm(HEADER_EXPORT));
-    a.short_().je(bad_arity);
-    a.cmp(RET, imm(HEADER_FUN));
+    a.cmp(emit_boxed_val(fun_thing), imm(HEADER_FUN));
     a.short_().je(bad_arity);
 
     a.bind(bad_fun);
     {
-        /* Not a fun: this is only reachable through `call_fun` */
         a.mov(x86::qword_ptr(c_p, offsetof(Process, freason)), imm(EXC_BADFUN));
         a.mov(x86::qword_ptr(c_p, offsetof(Process, fvalue)), ARG4);
 
@@ -92,9 +88,6 @@ void BeamGlobalAssembler::emit_handle_call_fun_error() {
 
     a.bind(bad_arity);
     {
-        /* Bad arity: this is reachable through `call_fun` when we have an
-         * export fun, and `i_lambda_trampoline` when we have a local one. */
-
         /* Stash our fun and current PC. Note that we don't move the fun to
          * {x,0} straight away as that would clobber the first argument. */
         a.mov(TMP_MEM1q, ARG4);
@@ -150,8 +143,8 @@ void BeamGlobalAssembler::emit_handle_call_fun_error() {
     }
 }
 
-/* `call_fun` instructions land here to check arity and set up their
- * environment before jumping to the actual implementation.
+/* `call_fun` instructions land here to set up their environment before jumping
+ * to the actual implementation.
  *
  * Keep in mind that this runs in the limbo between caller and callee, so we
  * must not enter a frame here.
@@ -165,16 +158,19 @@ void BeamModuleAssembler::emit_i_lambda_trampoline(const ArgVal &Index,
                                                    const ArgVal &NumFree) {
     const ssize_t effective_arity = Arity.getValue() - NumFree.getValue();
     const ssize_t num_free = NumFree.getValue();
-    Label error = a.newLabel();
     ssize_t i;
 
     auto &lambda = lambdas[Index.getValue()];
+
+    if (NumFree.getValue() == 0) {
+        /* No free variables, let the lambda jump directly to our target. */
+        lambda.trampoline = labels[Lbl.getValue()];
+        return;
+    }
+
     lambda.trampoline = a.newLabel();
     a.bind(lambda.trampoline);
 
-    a.cmp(ARG3, imm(effective_arity));
-    a.short_().jne(error);
-
     emit_ptr_val(ARG4, ARG4);
 
     for (i = 0; i < num_free - 1; i += 2) {
@@ -192,9 +188,6 @@ void BeamModuleAssembler::emit_i_lambda_trampoline(const ArgVal &Index,
     }
 
     a.jmp(labels[Lbl.getValue()]);
-
-    a.bind(error);
-    abs_jmp(ga->get_handle_call_fun_error());
 }
 
 void BeamModuleAssembler::emit_i_make_fun3(const ArgVal &Fun,
@@ -205,14 +198,14 @@ void BeamModuleAssembler::emit_i_make_fun3(const ArgVal &Fun,
     size_t num_free = env.size();
     ASSERT(NumFree.getValue() == num_free);
 
+    make_move_patch(ARG2, lambdas[Fun.getValue()].patches);
     mov_arg(ARG3, Arity);
     mov_arg(ARG4, NumFree);
 
     emit_enter_runtime<Update::eHeap>();
 
     a.mov(ARG1, c_p);
-    make_move_patch(ARG2, lambdas[Fun.getValue()].patches);
-    runtime_call<4>(new_fun_thing);
+    runtime_call<4>(erts_new_local_fun_thing);
 
     emit_leave_runtime<Update::eHeap>();
 
@@ -326,14 +319,16 @@ void BeamModuleAssembler::emit_i_apply_fun_only() {
  *   ARG3 = arity
  *   ARG4 = fun thing */
 x86::Gp BeamModuleAssembler::emit_call_fun() {
-    Label exported = a.newLabel(), next = a.newLabel();
+    Label next = a.newLabel();
+
+    /* Speculatively strip the literal tag when needed. */
+    x86::Gp fun_thing = emit_ptr_val(RET, ARG4);
 
     /* Load the error fragment into ARG2 so we can CMOV ourselves there on
      * error. */
     a.mov(ARG2, ga->get_handle_call_fun_error());
 
-    /* The `handle_call_fun_error` and `i_lambda_trampoline` fragments expect
-     * current PC in ARG5. */
+    /* The `handle_call_fun_error` fragment expects current PC in ARG5. */
     a.lea(ARG5, x86::qword_ptr(next));
 
     /* As emit_is_boxed(), but explicitly sets ZF so we can rely on that for
@@ -341,23 +336,13 @@ x86::Gp BeamModuleAssembler::emit_call_fun() {
     a.test(ARG4d, imm(_TAG_PRIMARY_MASK - TAG_PRIMARY_BOXED));
     a.short_().jne(next);
 
-    x86::Gp fun_thing = emit_ptr_val(RET, ARG4);
-    a.cmp(emit_boxed_val(fun_thing), imm(HEADER_EXPORT));
-    a.short_().je(exported);
     a.cmp(emit_boxed_val(fun_thing), imm(HEADER_FUN));
     a.short_().jne(next);
 
-    a.mov(ARG1, emit_boxed_val(fun_thing, offsetof(ErlFunThing, fe)));
-    a.mov(ARG1, x86::qword_ptr(ARG1, offsetof(ErlFunEntry, address)));
-    a.short_().jmp(next);
-
-    a.bind(exported);
-    {
-        a.mov(RET, emit_boxed_val(fun_thing, sizeof(Eterm)));
-        a.mov(ARG1, emit_setup_export_call(RET));
+    a.cmp(emit_boxed_val(fun_thing, offsetof(ErlFunThing, arity)), ARG3);
 
-        a.cmp(x86::qword_ptr(RET, offsetof(Export, info.mfa.arity)), ARG3);
-    }
+    a.mov(RET, emit_boxed_val(fun_thing, offsetof(ErlFunThing, entry)));
+    a.mov(ARG1, emit_setup_dispatchable_call(RET));
 
     /* Assumes that ZF is set on success and clear on error, overwriting our
      * destination with the error fragment's address. */
diff --git a/erts/emulator/beam/jit/x86/instr_trace.cpp b/erts/emulator/beam/jit/x86/instr_trace.cpp
index 128fbbe615..40b5b91ea3 100644
--- a/erts/emulator/beam/jit/x86/instr_trace.cpp
+++ b/erts/emulator/beam/jit/x86/instr_trace.cpp
@@ -148,7 +148,7 @@ void BeamGlobalAssembler::emit_debug_bp() {
     a.test(RET, RET);
     a.je(error);
 
-    a.jmp(emit_setup_export_call(RET));
+    a.jmp(emit_setup_dispatchable_call(RET));
 
     a.bind(error);
     {
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 41bc23e15d..043d2e4f8c 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -939,37 +939,43 @@ tail_recur:
 	    hash = hash*FUNNY_NUMBER4 + sz;
 	    break;
 	}
-    case EXPORT_DEF:
-	{
-	    Export* ep = *((Export **) (export_val(term) + 1));
+    case FUN_DEF:
+        {
+            ErlFunThing* funp = (ErlFunThing *) fun_val(term);
 
-	    hash = hash * FUNNY_NUMBER11 + ep->info.mfa.arity;
-	    hash = hash*FUNNY_NUMBER1 +
-		(atom_tab(atom_val(ep->info.mfa.module))->slot.bucket.hvalue);
-	    hash = hash*FUNNY_NUMBER1 +
-		(atom_tab(atom_val(ep->info.mfa.function))->slot.bucket.hvalue);
-	    break;
-	}
+            if (is_local_fun(funp)) {
 
-    case FUN_DEF:
-	{
-	    ErlFunThing* funp = (ErlFunThing *) fun_val(term);
-	    Uint num_free = funp->num_free;
-
-	    hash = hash * FUNNY_NUMBER10 + num_free;
-	    hash = hash*FUNNY_NUMBER1 +
-		(atom_tab(atom_val(funp->fe->module))->slot.bucket.hvalue);
-	    hash = hash*FUNNY_NUMBER2 + funp->fe->index;
-	    hash = hash*FUNNY_NUMBER2 + funp->fe->old_uniq;
-	    if (num_free > 0) {
-		if (num_free > 1) {
-		    WSTACK_PUSH3(stack, (UWord) &funp->env[1], (num_free-1), MAKE_HASH_TERM_ARRAY_OP);
-		}
-		term = funp->env[0];
-		goto tail_recur;
-	    }
-	    break;
-	}
+                ErlFunEntry* fe = funp->entry.fun;
+                Uint num_free = funp->num_free;
+
+                hash = hash * FUNNY_NUMBER10 + num_free;
+                hash = hash*FUNNY_NUMBER1 +
+                        (atom_tab(atom_val(fe->module))->slot.bucket.hvalue);
+                hash = hash*FUNNY_NUMBER2 + fe->index;
+                hash = hash*FUNNY_NUMBER2 + fe->old_uniq;
+
+                if (num_free > 0) {
+                    if (num_free > 1) {
+                        WSTACK_PUSH3(stack, (UWord) &funp->env[1],
+                                     (num_free-1), MAKE_HASH_TERM_ARRAY_OP);
+                    }
+
+                    term = funp->env[0];
+                    goto tail_recur;
+                }
+            } else {
+                const ErtsCodeMFA *mfa = &funp->entry.exp->info.mfa;
+
+                ASSERT(is_external_fun(funp) && funp->next == NULL);
+
+                hash = hash * FUNNY_NUMBER11 + mfa->arity;
+                hash = hash*FUNNY_NUMBER1 +
+                       (atom_tab(atom_val(mfa->module))->slot.bucket.hvalue);
+                hash = hash*FUNNY_NUMBER1 +
+                        (atom_tab(atom_val(mfa->function))->slot.bucket.hvalue);
+            }
+            break;
+        }
     case PID_DEF:
 	/* only 15 bits... */
 	UINT32_HASH_RET(internal_pid_number(term),FUNNY_NUMBER5,FUNNY_NUMBER6);
@@ -1671,43 +1677,50 @@ make_hash2_helper(Eterm term_param, const int can_trap, Eterm* state_mref_write_
                 goto hash2_common;
             }
             break;
-	    case EXPORT_SUBTAG:
-	    {
-		Export* ep = *((Export **) (export_val(term) + 1));
-		UINT32_HASH_2
-		    (ep->info.mfa.arity,
-		     atom_tab(atom_val(ep->info.mfa.module))->slot.bucket.hvalue,
-		     HCONST);
-		UINT32_HASH
-		    (atom_tab(atom_val(ep->info.mfa.function))->slot.bucket.hvalue,
-		     HCONST_14);
-		goto hash2_common;
-	    }
 
-	    case FUN_SUBTAG:
-	    {
-		ErlFunThing* funp = (ErlFunThing *) fun_val(term);
-                ErtsMakeHash2Context_FUN_SUBTAG ctx = {
-                    .num_free = funp->num_free,
-                    .bptr = NULL};
-		UINT32_HASH_2
-		    (ctx.num_free,
-		     atom_tab(atom_val(funp->fe->module))->slot.bucket.hvalue,
-		     HCONST);
-		UINT32_HASH_2
-		    (funp->fe->index, funp->fe->old_uniq, HCONST);
-		if (ctx.num_free == 0) {
-		    goto hash2_common;
-		} else {
-		    ctx.bptr = funp->env + ctx.num_free - 1;
-		    while (ctx.num_free-- > 1) {
-			term = *ctx.bptr--;
-			ESTACK_PUSH(s, term);
+            case FUN_SUBTAG:
+            {
+                ErlFunThing* funp = (ErlFunThing *) fun_val(term);
+
+                if (is_local_fun(funp)) {
+                    ErlFunEntry* fe = funp->entry.fun;
+                    ErtsMakeHash2Context_FUN_SUBTAG ctx = {
+                        .num_free = funp->num_free,
+                        .bptr = NULL};
+
+                    UINT32_HASH_2
+                        (ctx.num_free,
+                         atom_tab(atom_val(fe->module))->slot.bucket.hvalue,
+                         HCONST);
+                    UINT32_HASH_2
+                        (fe->index, fe->old_uniq, HCONST);
+                    if (ctx.num_free == 0) {
+                        goto hash2_common;
+                    } else {
+                        ctx.bptr = funp->env + ctx.num_free - 1;
+                        while (ctx.num_free-- > 1) {
+                            term = *ctx.bptr--;
+                            ESTACK_PUSH(s, term);
                         TRAP_LOCATION(fun_subtag);
-		    }
-		    term = *ctx.bptr;
-		}
-	    }
+                        }
+                        term = *ctx.bptr;
+                    }
+                } else {
+                    Export *ep = funp->entry.exp;
+
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
+
+                    UINT32_HASH_2
+                        (ep->info.mfa.arity,
+                         atom_tab(atom_val(ep->info.mfa.module))->slot.bucket.hvalue,
+                         HCONST);
+                    UINT32_HASH
+                        (atom_tab(atom_val(ep->info.mfa.function))->slot.bucket.hvalue,
+                         HCONST_14);
+
+                    goto hash2_common;
+                }
+            }
 	    break;
 	    case REFC_BINARY_SUBTAG:
 	    case HEAP_BINARY_SUBTAG:
@@ -2216,32 +2229,34 @@ make_internal_hash(Eterm term, Uint32 salt)
                 goto pop_next;
             }
             break;
-	    case EXPORT_SUBTAG:
-	    {
-		Export* ep = *((Export **) (export_val(term) + 1));
-                /* Assumes Export entries never move */
-                POINTER_HASH(ep, HCONST_14);
-		goto pop_next;
-	    }
+            case FUN_SUBTAG:
+            {
+                ErlFunThing* funp = (ErlFunThing *) fun_val(term);
+
+                if (is_local_fun(funp)) {
+                    ErlFunEntry* fe = funp->entry.fun;
+                    Uint num_free = funp->num_free;
+                    UINT32_HASH_2(num_free, fe->module, HCONST_20);
+                    UINT32_HASH_2(fe->index, fe->old_uniq, HCONST_21);
+                    if (num_free == 0) {
+                        goto pop_next;
+                    } else {
+                        Eterm* bptr = funp->env + num_free - 1;
+                        while (num_free-- > 1) {
+                            term = *bptr--;
+                            ESTACK_PUSH(s, term);
+                        }
+                        term = *bptr;
+                    }
+                } else {
+                    ASSERT(is_external_fun(funp) && funp->next == NULL);
 
-	    case FUN_SUBTAG:
-	    {
-		ErlFunThing* funp = (ErlFunThing *) fun_val(term);
-		Uint num_free = funp->num_free;
-                UINT32_HASH_2(num_free, funp->fe->module, HCONST_20);
-                UINT32_HASH_2(funp->fe->index, funp->fe->old_uniq, HCONST_21);
-		if (num_free == 0) {
-		    goto pop_next;
-		} else {
-		    Eterm* bptr = funp->env + num_free - 1;
-		    while (num_free-- > 1) {
-			term = *bptr--;
-			ESTACK_PUSH(s, term);
-		    }
-		    term = *bptr;
-		}
-	    }
-	    break;
+                    /* Assumes Export entries never move */
+                    POINTER_HASH(funp->entry.exp, HCONST_14);
+                    goto pop_next;
+                }
+            }
+            break;
 	    case REFC_BINARY_SUBTAG:
 	    case HEAP_BINARY_SUBTAG:
 	    case SUB_BINARY_SUBTAG:
@@ -2852,35 +2867,46 @@ tailrecur_ne:
 		    }
 		    break; /* not equal */
 		}
-	    case EXPORT_SUBTAG:
-		{
-		    if (is_export(b)) {
-			Export* a_exp = *((Export **) (export_val(a) + 1));
-			Export* b_exp = *((Export **) (export_val(b) + 1));
-			if (a_exp == b_exp) goto pop_next;
-		    }
-		    break; /* not equal */
-		}
-	    case FUN_SUBTAG:
-		{
-		    ErlFunThing* f1;
-		    ErlFunThing* f2;
+            case FUN_SUBTAG:
+                {
+                    ErlFunThing* f1;
+                    ErlFunThing* f2;
 
-		    if (!is_fun(b))
-			goto not_equal;
-		    f1 = (ErlFunThing *) fun_val(a);
-		    f2 = (ErlFunThing *) fun_val(b);
-		    if (f1->fe->module != f2->fe->module ||
-			f1->fe->index != f2->fe->index ||
-			f1->fe->old_uniq != f2->fe->old_uniq ||
-			f1->num_free != f2->num_free) {
-			goto not_equal;
-		    }
-		    if ((sz = f1->num_free) == 0) goto pop_next;
-		    aa = f1->env;
-		    bb = f2->env;
-		    goto term_array;
-		}
+                    if (is_not_any_fun(b)) {
+                        goto not_equal;
+                    }
+
+                    f1 = (ErlFunThing *) fun_val(a);
+                    f2 = (ErlFunThing *) fun_val(b);
+
+                    if (is_local_fun(f1) && is_local_fun(f2)) {
+                        ErlFunEntry *fe1, *fe2;
+
+                        fe1 = f1->entry.fun;
+                        fe2 = f2->entry.fun;
+
+                        if (fe1->module != fe2->module ||
+                            fe1->index != fe2->index ||
+                            fe1->old_uniq != fe2->old_uniq ||
+                            f1->num_free != f2->num_free) {
+                            goto not_equal;
+                        }
+
+                        if ((sz = f1->num_free) == 0) {
+                            goto pop_next;
+                        }
+
+                        aa = f1->env;
+                        bb = f2->env;
+                        goto term_array;
+                    } else if (is_external_fun(f1) && is_external_fun(f2)) {
+                        if (f1->entry.exp == f2->entry.exp) {
+                            goto pop_next;
+                        }
+                    }
+
+                    goto not_equal;
+                }
 
 	    case EXTERNAL_PID_SUBTAG: {
 		ExternalThing *ap;
@@ -3475,58 +3501,69 @@ tailrecur_ne:
 		    goto mixed_types;
 		}
 		ON_CMP_GOTO(big_comp(a, b));
-	    case (_TAG_HEADER_EXPORT >> _TAG_PRIMARY_SIZE):
-		if (!is_export(b)) {
-		    a_tag = EXPORT_DEF;
-		    goto mixed_types;
-		} else {
-		    Export* a_exp = *((Export **) (export_val(a) + 1));
-		    Export* b_exp = *((Export **) (export_val(b) + 1));
 
-		    if ((j = erts_cmp_atoms(a_exp->info.mfa.module,
-                                            b_exp->info.mfa.module)) != 0) {
-			RETURN_NEQ(j);
-		    }
-		    if ((j = erts_cmp_atoms(a_exp->info.mfa.function,
-                                            b_exp->info.mfa.function)) != 0) {
-			RETURN_NEQ(j);
-		    }
-		    ON_CMP_GOTO((Sint) a_exp->info.mfa.arity - (Sint) b_exp->info.mfa.arity);
-		}
-		break;
-	    case (_TAG_HEADER_FUN >> _TAG_PRIMARY_SIZE):
-		if (!is_fun(b)) {
-		    a_tag = FUN_DEF;
-		    goto mixed_types;
-		} else {
-		    ErlFunThing* f1 = (ErlFunThing *) fun_val(a);
-		    ErlFunThing* f2 = (ErlFunThing *) fun_val(b);
-		    Sint diff;
+            case (_TAG_HEADER_FUN >> _TAG_PRIMARY_SIZE):
+                if (is_not_any_fun(b)) {
+                    a_tag = FUN_DEF;
+                    goto mixed_types;
+                } else {
+                    ErlFunThing* f1 = (ErlFunThing *) fun_val(a);
+                    ErlFunThing* f2 = (ErlFunThing *) fun_val(b);
 
-                    diff = erts_cmp_atoms((f1->fe)->module, (f2->fe)->module);
-		    if (diff != 0) {
-			RETURN_NEQ(diff);
-		    }
-		    diff = f1->fe->index - f2->fe->index;
-		    if (diff != 0) {
-			RETURN_NEQ(diff);
-		    }
-		    diff = f1->fe->old_uniq - f2->fe->old_uniq;
-		    if (diff != 0) {
-			RETURN_NEQ(diff);
-		    }
-		    diff = f1->num_free - f2->num_free;
-		    if (diff != 0) {
-			RETURN_NEQ(diff);
-		    }
-		    i = f1->num_free;
-		    if (i == 0) goto pop_next;
-		    aa = f1->env;
-		    bb = f2->env;
-		    goto term_array;
-		}
-	    case (_TAG_HEADER_EXTERNAL_PID >> _TAG_PRIMARY_SIZE):
-		if (!is_pid(b)) {
+                    if (is_local_fun(f1) && is_local_fun(f2)) {
+                        ErlFunEntry* fe1 = f1->entry.fun;
+                        ErlFunEntry* fe2 = f2->entry.fun;
+
+                        Sint diff;
+
+                        diff = erts_cmp_atoms(fe1->module, (fe2)->module);
+
+                        if (diff != 0) {
+                            RETURN_NEQ(diff);
+                        }
+
+                        diff = fe1->index - fe2->index;
+                        if (diff != 0) {
+                            RETURN_NEQ(diff);
+                        }
+
+                        diff = fe1->old_uniq - fe2->old_uniq;
+                        if (diff != 0) {
+                            RETURN_NEQ(diff);
+                        }
+
+                        diff = f1->num_free - f2->num_free;
+                        if (diff != 0) {
+                            RETURN_NEQ(diff);
+                        }
+
+                        i = f1->num_free;
+                        if (i == 0) goto pop_next;
+                        aa = f1->env;
+                        bb = f2->env;
+                        goto term_array;
+                    } else if (is_external_fun(f1) && is_external_fun(f2)) {
+                        Export* a_exp = f1->entry.exp;
+                        Export* b_exp = f2->entry.exp;
+
+                        if ((j = erts_cmp_atoms(a_exp->info.mfa.module,
+                                                b_exp->info.mfa.module)) != 0) {
+                            RETURN_NEQ(j);
+                        }
+                        if ((j = erts_cmp_atoms(a_exp->info.mfa.function,
+                                                b_exp->info.mfa.function)) != 0) {
+                            RETURN_NEQ(j);
+                        }
+
+                        ON_CMP_GOTO((Sint) a_exp->info.mfa.arity -
+                                     (Sint) b_exp->info.mfa.arity);
+                    } else {
+                        /* External funs compare greater than local ones. */
+                        RETURN_NEQ(is_external_fun(f1) - is_external_fun(f2));
+                    }
+                }
+            case (_TAG_HEADER_EXTERNAL_PID >> _TAG_PRIMARY_SIZE):
+                if (!is_pid(b)) {
                     a_tag = EXTERNAL_PID_DEF;
                     goto mixed_types;
                 }
diff --git a/erts/emulator/internal_doc/BeamAsm.md b/erts/emulator/internal_doc/BeamAsm.md
index fa5a308a03..44f2c758c5 100644
--- a/erts/emulator/internal_doc/BeamAsm.md
+++ b/erts/emulator/internal_doc/BeamAsm.md
@@ -258,11 +258,11 @@ means that all remote calls _must_ place the export entry in said register,
 even when we don't know beforehand that the call is remote, such as when
 calling a fun.
 
-This is pretty easy to do in assembler and the `emit_setup_export_call` helper
-handles it nicely for us, but we can't set registers when trapping out from C
-code. When trapping to an export entry from C code one must set `c_p->current`
-to the `ErtsCodeMFA` inside the export entry in question, and then set `c_p->i`
-to `beam_bif_export_trap`.
+This is pretty easy to do in assembler and the `emit_setup_dispatchable_call`
+helper handles it nicely for us, but we can't set registers when trapping out
+from C code. When trapping to an export entry from C code one must set
+`c_p->current` to the `ErtsCodeMFA` inside the export entry in question, and
+then set `c_p->i` to `beam_bif_export_trap`.
 
 The `BIF_TRAP` macros handle this for you, so you generally don't need to
 think about it.
diff --git a/erts/emulator/test/erts_debug_SUITE.erl b/erts/emulator/test/erts_debug_SUITE.erl
index 2c1e83dbdf..b0edb45af4 100644
--- a/erts/emulator/test/erts_debug_SUITE.erl
+++ b/erts/emulator/test/erts_debug_SUITE.erl
@@ -86,7 +86,8 @@ test_size(Config) when is_list(Config) ->
 
     FunSz1 = do_test_size(fun() -> ConsCell1 end) - do_test_size(ConsCell1),
 
-    2 = do_test_size(fun lists:sort/1),
+    %% External funs are the same size as local ones without environment
+    FunSz0 = do_test_size(fun lists:sort/1),
 
     Arch = 8 * erlang:system_info({wordsize, external}),
     case {Arch, do_test_size(mk_ext_pid({a@b, 1}, 17, 42))} of
-- 
2.31.1

Places

File 1493-erts-Optimize-fun-calls.patch of Package erlang (Revision ab0a80da32d4196c3293bfd6d0ac4245)

Places