File 1101-erts-Support-frame-pointers.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1101-erts-Support-frame-pointers.patch of Package erlang (Revision e92d0acc748e2811090970aa48727278)

Currently displaying revision e92d0acc748e2811090970aa48727278 , Show latest

From bc441592dd180b62e694d5b82cf580b18b3e5d59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20H=C3=B6gberg?= <john@erlang.org>
Date: Fri, 12 Mar 2021 11:56:07 +0100
Subject: [PATCH 01/20] erts: Support frame pointers

This vastly improves `perf` accuracy and makes it usable on
platforms that don't support `--call-graph=lbr`, such as most
cloud environments.
---
 erts/config.h.in                              |   3 +
 erts/configure                                |  16 +-
 erts/configure.in                             |  21 +-
 erts/emulator/Makefile.in                     |   2 +-
 erts/emulator/beam/beam_bif_load.c            |   7 +
 erts/emulator/beam/beam_bp.c                  | 194 +++++---
 erts/emulator/beam/beam_common.c              | 220 +++++----
 erts/emulator/beam/beam_common.h              |  23 +
 erts/emulator/beam/erl_bif_info.c             |   5 +-
 erts/emulator/beam/erl_db_util.c              |  11 +-
 erts/emulator/beam/erl_gc.c                   | 441 ++++++++++++------
 erts/emulator/beam/erl_gc.h                   |   6 +
 erts/emulator/beam/erl_nif.c                  |  21 +-
 erts/emulator/beam/erl_process.c              |  15 +-
 erts/emulator/beam/erl_process.h              |  24 +-
 erts/emulator/beam/erl_vm.h                   |  41 +-
 erts/emulator/beam/jit/x86/beam_asm.cpp       |  46 +-
 erts/emulator/beam/jit/x86/beam_asm.hpp       | 170 ++++---
 .../emulator/beam/jit/x86/beam_asm_global.cpp |  89 ++--
 .../emulator/beam/jit/x86/beam_asm_module.cpp |   3 +
 erts/emulator/beam/jit/x86/instr_arith.cpp    |  78 +++-
 erts/emulator/beam/jit/x86/instr_bif.cpp      | 435 ++++++++++-------
 erts/emulator/beam/jit/x86/instr_bs.cpp       |  10 +-
 erts/emulator/beam/jit/x86/instr_call.cpp     |  25 +-
 erts/emulator/beam/jit/x86/instr_common.cpp   |  53 ++-
 .../beam/jit/x86/instr_guard_bifs.cpp         |  27 +-
 erts/emulator/beam/jit/x86/instr_map.cpp      |  12 +-
 erts/emulator/beam/jit/x86/instr_msg.cpp      |   9 +-
 erts/emulator/beam/jit/x86/instr_trace.cpp    |  58 ++-
 erts/emulator/beam/jit/x86/ops.tab            |  16 +-
 erts/emulator/beam/utils.c                    |   1 +
 erts/emulator/internal_doc/BeamAsm.md         |  50 +-
 .../figures/beamasm-perf-annotate.png         | Bin 100853 -> 108415 bytes
 .../internal_doc/figures/perf-beamasm.png     | Bin 151978 -> 210188 bytes
 erts/emulator/test/hibernate_SUITE.erl        |   6 +-
 35 files changed, 1475 insertions(+), 663 deletions(-)

diff --git a/erts/config.h.in b/erts/config.h.in
index afdb89d5cc..30d1845bbf 100644
--- a/erts/config.h.in
+++ b/erts/config.h.in
@@ -31,6 +31,9 @@
    format (like some ARMs). */
 #undef DOUBLE_MIDDLE_ENDIAN
 
+/* Define if we need frame pointers on the Erlang stack */
+#undef ERLANG_FRAME_POINTERS
+
 /* Define if sbrk()/brk() wrappers can track malloc()s core memory use */
 #undef ERTS_BRK_WRAPPERS_CAN_TRACK_MALLOC
 
diff --git a/erts/configure b/erts/configure
index e6e25e726e..b96b41af77 100755
--- a/erts/configure
+++ b/erts/configure
@@ -22076,15 +22076,27 @@ fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext;;
   esac
 
-  if test X${enable_native_stack} = Xyes; then
+  case "$JIT_ARCH" in
+    x86)
+      if test X${enable_native_stack} = Xyes; then
 
 $as_echo "#define NATIVE_ERLANG_STACK /**/" >>confdefs.h
 
-  fi
+      fi
+      ;;
+    *)
+      ;;
+  esac
 fi
 
 case $OPSYS in
     linux*)
+        if test X${enable_native_stack} = Xyes; then
+
+$as_echo "#define ERLANG_FRAME_POINTERS /**/" >>confdefs.h
+
+        fi
+
 
 $as_echo "#define HAVE_LINUX_PERF_SUPPORT 1" >>confdefs.h
 
diff --git a/erts/configure.in b/erts/configure.in
index fd3190f0f1..ee62383db9 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -2960,19 +2960,30 @@ if test ${enable_jit} != no; then
       );;
   esac
 
-  if test X${enable_native_stack} = Xyes; then
-    AC_DEFINE(NATIVE_ERLANG_STACK, [],
-              [Define if we can use the native stack for Erlang code])
-  fi
+  case "$JIT_ARCH" in
+    x86)
+      if test X${enable_native_stack} = Xyes; then
+        AC_DEFINE(NATIVE_ERLANG_STACK, [],
+                  [Define if we can use the native stack for Erlang code])
+      fi
+      ;;
+    *)
+      ;;
+  esac
 fi
 
 dnl
 dnl Check if the `perf` profiler is supported. At the moment it assumes it
 dnl always works on Linux as we're not dependent on it; this is only used to
-dnl to control whether we generate `perf`-compatible memory maps.
+dnl to control whether we accept `perf`-related options.
 dnl
 case $OPSYS in
     linux*)
+        if test X${enable_native_stack} = Xyes; then
+          AC_DEFINE(ERLANG_FRAME_POINTERS, [],
+                    [Define if we need frame pointers on the Erlang stack])
+        fi
+
         AC_DEFINE(HAVE_LINUX_PERF_SUPPORT, 1,
                   [Define if the targeted system supports the `perf` profiler])
         ;;
diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index c3449c5f73..63103b05f3 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -56,7 +56,7 @@ JIT_ENABLED=no
 endif
 
 ifeq ($(FLAVOR),jit)
-OMIT_OMIT_FP=no
+OMIT_OMIT_FP=yes
 OPCODE_TABLES += \
     beam/jit/$(JIT_ARCH)/ops.tab \
     beam/jit/$(JIT_ARCH)/predicates.tab \
diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index ce0046c25a..e982ef5a7d 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -777,6 +777,12 @@ BIF_RETTYPE loaded_0(BIF_ALIST_0)
 
 BIF_RETTYPE call_on_load_function_1(BIF_ALIST_1)
 {
+#ifdef BEAMASM
+    /* This is implemented as an instruction. We've skipped providing a more
+     * helpful error message since it's undocumented and should never be called
+     * by the user. */
+    BIF_ERROR(BIF_P, BADARG);
+#else
     Module* modp = erts_get_module(BIF_ARG_1, erts_active_code_ix());
     const BeamCodeHeader *hdr;
 
@@ -792,6 +798,7 @@ BIF_RETTYPE call_on_load_function_1(BIF_ALIST_1)
     }
 
     BIF_ERROR(BIF_P, BADARG);
+#endif
 }
 
 BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 2142830ae8..9e8d815ad4 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -653,25 +653,53 @@ erts_clear_export_break(Module* modp, Export *ep)
  * being the function which is the caller, but rather the function
  * which we are about to return to.
  */
-static void fixup_cp_before_trace(Process *c_p, int *return_to_trace)
+static void fixup_cp_before_trace(Process *c_p,
+                                  Eterm cp_save[2],
+                                  int *return_to_trace)
 {
+    const ErtsFrameLayout frame_layout = erts_frame_layout;
     Eterm *cpp = c_p->stop;
 
+    if (frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+        ASSERT(is_CP(cpp[1]));
+        cp_save[1] = cpp[1];
+    }
+
+    ASSERT(is_CP(cpp[0]));
+    cp_save[0] = cpp[0];
+
     for (;;) {
-        ErtsCodePtr w = cp_val(*cpp);
+        ErtsCodePtr w;
+
+        erts_inspect_frame(cpp, &w);
+
         if (BeamIsReturnTrace(w)) {
-            cpp += 3;
+            cpp += CP_SIZE + 2;
+        } else if (BeamIsReturnTimeTrace(w)) {
+            cpp += CP_SIZE + 1;
         } else if (BeamIsReturnToTrace(w)) {
             *return_to_trace = 1;
-            cpp += 1;
-        } else if (BeamIsReturnTimeTrace(w)) {
-            cpp += 2;
+            cpp += CP_SIZE;
         } else {
-            break;
+            if (frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+                ASSERT(is_CP(cpp[1]));
+                c_p->stop[1] = cpp[1];
+            }
+
+            ASSERT(is_CP(cpp[0]));
+            c_p->stop[0] = cpp[0];
+
+            return;
         }
     }
-    c_p->stop[0] = (Eterm) cp_val(*cpp);
-    ASSERT(is_CP(*cpp));
+}
+
+static void restore_cp_after_trace(Process *c_p, const Eterm cp_save[2]) {
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+        c_p->stop[1] = cp_save[1];
+    }
+
+    c_p->stop[0] = cp_save[0];
 }
 
 BeamInstr
@@ -738,24 +766,41 @@ erts_generic_breakpoint(Process* c_p, ErtsCodeInfo *info, Eterm* reg)
         ErtsCodePtr w;
         Eterm* E;
 
-        prev_info= erts_trace_time_call(c_p, info, bp->time);
+        prev_info = erts_trace_time_call(c_p, info, bp->time);
+
         E = c_p->stop;
-        w = (ErtsCodePtr) E[0];
-	if (!(BeamIsReturnTrace(w) || BeamIsReturnToTrace(w) || BeamIsReturnTimeTrace(w))) {
-	    ASSERT(c_p->htop <= E && E <= c_p->hend);
-	    if (HeapWordsLeft(c_p) < 2) {
-		(void) erts_garbage_collect(c_p, 2, reg, info->mfa.arity);
-		ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-	    }
-	    E = c_p->stop;
 
-	    ASSERT(c_p->htop <= E && E <= c_p->hend);
+        erts_inspect_frame(E, &w);
 
-	    E -= 2;
-	    E[1] = prev_info ? make_cp(erts_codeinfo_to_code(prev_info)) : NIL;
-	    E[0] = (Eterm) beam_return_time_trace;
-	    c_p->stop = E;
-	}
+        if (!(BeamIsReturnTrace(w) ||
+              BeamIsReturnToTrace(w) ||
+              BeamIsReturnTimeTrace(w))) {
+            int need = CP_SIZE + 1;
+
+            ASSERT(c_p->htop <= E && E <= c_p->hend);
+
+            if (HeapWordsLeft(c_p) < need) {
+                (void) erts_garbage_collect(c_p, need,
+                                            reg, info->mfa.arity);
+                ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
+            }
+
+            E = c_p->stop;
+
+            ASSERT(c_p->htop <= E && E <= c_p->hend);
+
+            E -= 2;
+            E[1] = prev_info ? make_cp(erts_codeinfo_to_code(prev_info)) : NIL;
+            E[0] = make_cp(beam_return_time_trace);
+
+            if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+                E -= 1;
+                E[0] = make_cp(FRAME_POINTER(c_p));
+                FRAME_POINTER(c_p) = E;
+            }
+
+            c_p->stop = E;
+        }
     }
 
     if (bp_flags & ERTS_BPF_DEBUG) {
@@ -769,56 +814,91 @@ static ErtsTracer
 do_call_trace(Process* c_p, ErtsCodeInfo* info, Eterm* reg,
 	      int local, Binary* ms, ErtsTracer tracer)
 {
+    Eterm cp_save[2] = {0, 0};
     int return_to_trace = 0;
     Uint32 flags;
     Uint need = 0;
-    Eterm cp_save;
-    Eterm* E = c_p->stop;
+    Eterm* E;
 
-    cp_save = E[0];
+    fixup_cp_before_trace(c_p, cp_save, &return_to_trace);
 
-    fixup_cp_before_trace(c_p, &return_to_trace);
     ERTS_UNREQ_PROC_MAIN_LOCK(c_p);
     flags = erts_call_trace(c_p, info, ms, reg, local, &tracer);
     ERTS_REQ_PROC_MAIN_LOCK(c_p);
 
-    E[0] = cp_save;
+    restore_cp_after_trace(c_p, cp_save);
+
+    E = c_p->stop;
 
     ASSERT(!ERTS_PROC_IS_EXITING(c_p));
+
     if ((flags & MATCH_SET_RETURN_TO_TRACE) && !return_to_trace) {
-	need += 1;
+        need += CP_SIZE;
     }
+
     if (flags & MATCH_SET_RX_TRACE) {
-	need += 3 + size_object(tracer);
+        need += CP_SIZE + 2 + size_object(tracer);
     }
+
     if (need) {
-	ASSERT(c_p->htop <= E && E <= c_p->hend);
-	if (HeapWordsLeft(c_p) < need) {
-	    (void) erts_garbage_collect(c_p, need, reg, info->mfa.arity);
-	    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-	    E = c_p->stop;
-	}
-    }
-    if (flags & MATCH_SET_RETURN_TO_TRACE && !return_to_trace) {
-	E -= 1;
-	ASSERT(c_p->htop <= E && E <= c_p->hend);
-	E[0] = (Eterm) beam_return_to_trace;
-        c_p->stop = E;
-    }
-    if (flags & MATCH_SET_RX_TRACE) {
-	E -= 3;
-        c_p->stop = E;
-	ASSERT(c_p->htop <= E && E <= c_p->hend);
-	ASSERT(is_CP((Eterm) (UWord) (&info->mfa.module)));
-	ASSERT(IS_TRACER_VALID(tracer));
-        E[2] = copy_object(tracer, c_p);
-        E[1] = make_cp(&info->mfa.module);
-        E[0] = (Eterm) ((flags & MATCH_SET_EXCEPTION_TRACE) ?
-                        beam_exception_trace : beam_return_trace);
-	erts_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
-	ERTS_TRACE_FLAGS(c_p) |= F_EXCEPTION_TRACE;
-	erts_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
+        ASSERT(c_p->htop <= E && E <= c_p->hend);
+
+        if (HeapWordsLeft(c_p) < need) {
+            (void) erts_garbage_collect(c_p, need, reg, info->mfa.arity);
+            ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
+            E = c_p->stop;
+        }
+
+        if ((flags & MATCH_SET_RETURN_TO_TRACE) && !return_to_trace) {
+            E -= CP_SIZE;
+
+            if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+                E[0] = make_cp(beam_return_to_trace);
+            } else {
+                E[1] = make_cp(beam_return_to_trace);
+                E[0] = make_cp(FRAME_POINTER(c_p));
+                FRAME_POINTER(c_p) = E;
+            }
+
+            ASSERT(c_p->htop <= E && E <= c_p->hend);
+
+            c_p->stop = E;
+        }
+
+        if (flags & MATCH_SET_RX_TRACE) {
+            ErtsCodePtr trace_cp;
+
+            if (flags & MATCH_SET_EXCEPTION_TRACE) {
+                trace_cp = beam_exception_trace;
+            } else {
+                trace_cp = beam_return_trace;
+            }
+
+            E -= 2;
+            E[1] = copy_object(tracer, c_p);
+            E[0] = make_cp(&info->mfa.module);
+
+            E -= CP_SIZE;
+            if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+                E[0] = make_cp(trace_cp);
+            } else {
+                E[1] = make_cp(trace_cp);
+                E[0] = make_cp(FRAME_POINTER(c_p));
+                FRAME_POINTER(c_p) = E;
+            }
+
+            ASSERT(c_p->htop <= E && E <= c_p->hend);
+            ASSERT(is_CP((Eterm)(&info->mfa.module)));
+            ASSERT(IS_TRACER_VALID(tracer));
+
+            c_p->stop = E;
+
+            erts_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
+            ERTS_TRACE_FLAGS(c_p) |= F_EXCEPTION_TRACE;
+            erts_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
+        }
     }
+
     return tracer;
 }
 
diff --git a/erts/emulator/beam/beam_common.c b/erts/emulator/beam/beam_common.c
index bc784f7cae..b7b5ea824e 100644
--- a/erts/emulator/beam/beam_common.c
+++ b/erts/emulator/beam/beam_common.c
@@ -402,21 +402,24 @@ Eterm error_atom[NUMBER_EXIT_CODES] = {
  * This is needed to generate correct stacktraces when throwing errors from
  * instructions that return like an ordinary function, such as call_nif. */
 ErtsCodePtr erts_printable_return_address(Process* p, Eterm *E) {
-    Eterm *ptr = E;
+    Eterm *stack_bottom = STACK_START(p);
+    Eterm *scanner = E;
 
-    ASSERT(is_CP(*ptr));
+    ASSERT(is_CP(scanner[0]));
 
-    while (ptr < STACK_START(p)) {
-        ErtsCodePtr cp = cp_val(*ptr);
+    while (scanner < stack_bottom) {
+        ErtsCodePtr return_address;
 
-        if (BeamIsReturnTrace(cp)) {
-            ptr += 3;
-        } else if (BeamIsReturnTimeTrace(cp)) {
-            ptr += 2;
-        } else if (BeamIsReturnToTrace(cp)) {
-            ptr += 1;
+        erts_inspect_frame(scanner, &return_address);
+
+        if (BeamIsReturnTrace(return_address)) {
+            scanner += CP_SIZE + 2;
+        } else if (BeamIsReturnTimeTrace(return_address)) {
+            scanner += CP_SIZE + 1;
+        } else if (BeamIsReturnToTrace(return_address)) {
+            scanner += CP_SIZE;
         } else {
-            return cp;
+            return return_address;
         }
     }
 
@@ -536,7 +539,11 @@ handle_error(Process* c_p, ErtsCodePtr pc, Eterm* reg,
              *
              * Therefore, we need to bump the stack pointer as if this were an
              * ordinary return. */
-            ASSERT(is_CP(c_p->stop[0]));
+
+            if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+                FRAME_POINTER(c_p) = (Eterm*)cp_val(c_p->stop[0]);
+            }
+
             c_p->stop += CP_SIZE;
 #else
             /* To avoid keeping stale references. */
@@ -562,8 +569,9 @@ handle_error(Process* c_p, ErtsCodePtr pc, Eterm* reg,
 static ErtsCodePtr
 next_catch(Process* c_p, Eterm *reg) {
     int active_catches = c_p->catches > 0;
+    ErtsCodePtr return_to_trace_address = NULL;
     int have_return_to_trace = 0;
-    Eterm *ptr, *prev, *return_to_trace_ptr = NULL;
+    Eterm *ptr, *prev;
 
     ptr = prev = c_p->stop;
     ASSERT(ptr <= STACK_START(c_p));
@@ -579,52 +587,74 @@ next_catch(Process* c_p, Eterm *reg) {
     }
 
     while (ptr < STACK_START(c_p)) {
-	if (is_catch(*ptr)) {
-	    if (active_catches) goto found_catch;
-	    ptr++;
-	}
-	else if (is_CP(*ptr)) {
-	    prev = ptr;
-	    if (BeamIsReturnTrace(cp_val(*prev))) {
-		if (cp_val(*prev) == beam_exception_trace) {
-                    ErtsCodeMFA *mfa = (ErtsCodeMFA*)cp_val(ptr[1]);
-		    erts_trace_exception(c_p, mfa,
-					 reg[1], reg[2],
-                                         ERTS_TRACER_FROM_ETERM(ptr+2));
-		}
-		/* Skip MFA, tracer, and CP. */
-                ptr += 3;
-	    } else if (BeamIsReturnToTrace(cp_val(*prev))) {
-		have_return_to_trace = !0; /* Record next cp */
-		return_to_trace_ptr = NULL;
-		/* Skip CP. */
-		ptr += 1;
-	    } else if (BeamIsReturnTimeTrace(cp_val(*prev))) {
-		/* Skip prev_info and CP. */
-		ptr += 2;
-	    } else {
-		if (have_return_to_trace) {
-		    /* Record this cp as possible return_to trace cp */
-		    have_return_to_trace = 0;
-		    return_to_trace_ptr = ptr;
-		} else return_to_trace_ptr = NULL;
-		ptr++;
-	    }
-	} else ptr++;
+        Eterm val = ptr[0];
+
+        if (is_catch(val)) {
+            if (active_catches) {
+                goto found_catch;
+            }
+
+            ptr++;
+        } else if (is_CP(val)) {
+            ErtsCodePtr return_address;
+            const Eterm *frame;
+
+            prev = ptr;
+            frame = erts_inspect_frame(ptr, &return_address);
+
+            if (BeamIsReturnTrace(return_address)) {
+                if (return_address == beam_exception_trace) {
+                    ErtsTracer *tracer;
+                    ErtsCodeMFA *mfa;
+
+                    mfa = (ErtsCodeMFA*)cp_val(frame[0]);
+                    tracer = ERTS_TRACER_FROM_ETERM(&frame[1]);
+
+                    ASSERT_MFA(mfa);
+                    erts_trace_exception(c_p, mfa, reg[1], reg[2], tracer);
+                }
+
+                ptr += CP_SIZE + 2;
+            } else if (BeamIsReturnTimeTrace(return_address)) {
+                ptr += CP_SIZE + 1;
+            } else if (BeamIsReturnToTrace(return_address)) {
+                have_return_to_trace = 1; /* Record next cp */
+                return_to_trace_address = NULL;
+
+                ptr += CP_SIZE;
+            } else {
+                /* This is an ordinary call frame: if the previous frame was a
+                 * return_to trace we should record this CP as a return_to
+                 * candidate. */
+                if (have_return_to_trace) {
+                    return_to_trace_address = return_address;
+                    have_return_to_trace = 0;
+                } else {
+                    return_to_trace_address = NULL;
+                }
+
+                ptr += CP_SIZE;
+            }
+        } else {
+            ptr++;
+        }
     }
+
     return NULL;
 
  found_catch:
     ASSERT(ptr < STACK_START(c_p));
     c_p->stop = prev;
-    if (IS_TRACED_FL(c_p, F_TRACE_RETURN_TO) && return_to_trace_ptr) {
-	/* The stackframe closest to the catch contained an
-	 * return_to_trace entry, so since the execution now
-	 * continues after the catch, a return_to trace message
-	 * would be appropriate.
-	 */
-	erts_trace_return_to(c_p, cp_val(*return_to_trace_ptr));
+
+    if (IS_TRACED_FL(c_p, F_TRACE_RETURN_TO) && return_to_trace_address) {
+        /* The stackframe closest to the catch contained an
+         * return_to_trace entry, so since the execution now
+         * continues after the catch, a return_to trace message
+         * would be appropriate.
+         */
+        erts_trace_return_to(c_p, return_to_trace_address);
     }
+
     return catch_pc(*ptr);
 }
 
@@ -749,35 +779,39 @@ gather_stacktrace(Process* p, struct StackTrace* s, int depth)
 
     while (ptr < STACK_START(p) && depth > 0) {
         if (is_CP(*ptr)) {
-            ErtsCodePtr cp = cp_val(*ptr);
-
-            if (BeamIsReturnTrace(cp)) {
-                ptr += 3;
-            } else if (BeamIsReturnTimeTrace(cp)) {
-                ptr += 2;
-            } else if (BeamIsReturnToTrace(cp)) {
-                ptr += 1;
+            ErtsCodePtr return_address;
+
+            erts_inspect_frame(ptr, &return_address);
+
+            if (BeamIsReturnTrace(return_address)) {
+                ptr += CP_SIZE + 2;
+            } else if (BeamIsReturnTimeTrace(return_address)) {
+                ptr += CP_SIZE + 1;
+            } else if (BeamIsReturnToTrace(return_address)) {
+                ptr += CP_SIZE;
             } else {
-                if (cp != prev) {
-		    void *adjusted_cp;
+                if (return_address != prev) {
+                    ErtsCodePtr adjusted_address;
 
                     /* Record non-duplicates only */
-                    prev = cp;
+                    prev = return_address;
+
 #ifdef BEAMASM
-		    /*
-		     * Some instructions (e.g. call) are shorter than one word,
-		     * so we will need to subtract one byte from the pointer
-		     * to avoid ending up before the start of the instruction.
-		     */
-		    adjusted_cp = ((char *) cp) - 1;
+                    /* Some instructions (e.g. call) are shorter than one word,
+                     * so we will need to subtract one byte from the pointer
+                     * to avoid ending up before the start of the
+                     * instruction. */
+                    adjusted_address = ((char*)return_address) - 1;
 #else
-		    /* Subtract one word from the pointer. */
-		    adjusted_cp = ((char *) cp) - sizeof(UWord);
+                    /* Subtract one word from the pointer. */
+                    adjusted_address = ((char*)return_address) - sizeof(UWord);
 #endif
-                    s->trace[s->depth++] = adjusted_cp;
+
+                    s->trace[s->depth++] = adjusted_address;
                     depth--;
                 }
-                ptr++;
+
+                ptr += CP_SIZE;
             }
         } else {
             ptr++;
@@ -1351,7 +1385,7 @@ apply_bif_error_adjustment(Process *p, Export *ep,
      * error handling code.
      */
     if (need == 0) {
-        need = 1; /* i_apply_only */
+        need = CP_SIZE; /* i_apply_only */
     }
 
     if (HeapWordsLeft(p) < need) {
@@ -1365,7 +1399,17 @@ apply_bif_error_adjustment(Process *p, Export *ep,
          * Push the continuation pointer for the current function to the stack.
          */
         p->stop -= need;
-        p->stop[0] = make_cp(I);
+
+        switch (erts_frame_layout) {
+        case ERTS_FRAME_LAYOUT_RA:
+            p->stop[0] = make_cp(I);
+            break;
+        case ERTS_FRAME_LAYOUT_FP_RA:
+            p->stop[0] = make_cp(FRAME_POINTER(p));
+            p->stop[1] = make_cp(I);
+            FRAME_POINTER(p) = &p->stop[0];
+            break;
+        }
     } else {
         /*
          * Called from an i_apply_last_* instruction.
@@ -1377,7 +1421,17 @@ apply_bif_error_adjustment(Process *p, Export *ep,
          * and then add a dummy stackframe for the i_apply_last* instruction
          * to discard.
          */
-        p->stop[0] = make_cp(I);
+        switch (erts_frame_layout) {
+        case ERTS_FRAME_LAYOUT_RA:
+            p->stop[0] = make_cp(I);
+            break;
+        case ERTS_FRAME_LAYOUT_FP_RA:
+            p->stop[0] = make_cp(FRAME_POINTER(p));
+            p->stop[1] = make_cp(I);
+            FRAME_POINTER(p) = &p->stop[0];
+            break;
+        }
+
         p->stop -= need;
     }
 }
@@ -1596,8 +1650,18 @@ erts_hibernate(Process* c_p, Eterm* reg)
     c_p->arg_reg[0] = module;
     c_p->arg_reg[1] = function;
     c_p->arg_reg[2] = args;
-    c_p->stop = c_p->hend - CP_SIZE;  /* Keep first continuation pointer */
-    ASSERT(c_p->stop[0] == make_cp(beam_normal_exit));
+    c_p->stop = c_p->hend - CP_SIZE; /* Keep first continuation pointer */
+
+    switch(erts_frame_layout) {
+    case ERTS_FRAME_LAYOUT_RA:
+        ASSERT(c_p->stop[0] == make_cp(beam_normal_exit));
+        break;
+    case ERTS_FRAME_LAYOUT_FP_RA:
+        ASSERT(c_p->stop[0] == make_cp(NULL));
+        ASSERT(c_p->stop[1] == make_cp(beam_normal_exit));
+        break;
+    }
+
     c_p->catches = 0;
     c_p->i = beam_apply;
 
diff --git a/erts/emulator/beam/beam_common.h b/erts/emulator/beam/beam_common.h
index 52140c8a3e..c8bf7bd4e3 100644
--- a/erts/emulator/beam/beam_common.h
+++ b/erts/emulator/beam/beam_common.h
@@ -294,4 +294,27 @@ extern ErtsCodePtr beam_return_trace;      /* OpCode(i_return_trace) */
 extern ErtsCodePtr beam_exception_trace;   /* OpCode(i_exception_trace) */
 extern ErtsCodePtr beam_return_time_trace; /* OpCode(i_return_time_trace) */
 
+/** @brief Inspects an Erlang stack frame, returning the base of the data
+ *         (first Y register).
+ * @param[in] frame The frame to inspect. Must point at a CP.
+ * @param[out] return_address The return address of \p frame */
+ERTS_GLB_INLINE
+const Eterm *erts_inspect_frame(Eterm *frame, ErtsCodePtr *return_address);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+ERTS_GLB_INLINE
+const Eterm *erts_inspect_frame(Eterm *frame, ErtsCodePtr *return_address) {
+    ASSERT(is_CP(frame[0]));
+
+    if (ERTS_LIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_RA)) {
+        *return_address = (ErtsCodePtr)cp_val(frame[0]);
+        return &frame[1];
+    }
+
+    ASSERT(cp_val(frame[0]) == NULL || frame < (Eterm*)cp_val(frame[0]));
+    *return_address = (ErtsCodePtr)cp_val(frame[1]);
+    return &frame[2];
+}
+#endif /* ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
 #endif /* _BEAM_COMMON_H_ */
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 93ce1aace9..db299e053d 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -103,9 +103,9 @@ static char erts_system_version[] = ("Erlang/OTP " ERLANG_OTP_RELEASE
 				     " [async-threads:%d]"
 #ifdef BEAMASM
 #ifdef NATIVE_ERLANG_STACK
-				     " [jit]"
+				     " [jit:ns%s]"
 #else
-				     " [jit:no-native-stack]"
+				     " [jit%s]"
 #endif
 #endif
 #ifdef ET_DEBUG
@@ -493,6 +493,7 @@ erts_print_system_version(fmtfn_t to, void *arg, Process *c_p)
 		      , total, online
 		      , dirty_cpu, dirty_cpu_onln, dirty_io
 		      , erts_async_max_threads
+              , (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA ? ":fp" : "")
 	);
 }
 
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index 35521538ae..abda2c3aed 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -2642,7 +2642,16 @@ restart:
 	    break;
         case matchCaller:
             ASSERT(c_p == self);
-            t = c_p->stop[0];
+
+            /* Note that we can't use `erts_inspect_frame` here as the top of
+             * the stack could point at something other than a frame. */
+            if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+                t = c_p->stop[0];
+            } else {
+                ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+                t = c_p->stop[1];
+            }
+
             if (is_not_CP(t)) {
                 *esp++ = am_undefined;
             } else if (!(cp = erts_find_function_from_pc(cp_val(t)))) {
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index cb21f14071..ef8a5b6f76 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -113,6 +113,7 @@ typedef struct {
     int num_roots;		/* Number of root arrays. */
 } Rootset;
 
+static void copy_erlang_stack(Process *p, Eterm *new_heap, SWord new_sz);
 static Uint setup_rootset(Process*, Eterm*, int, Rootset*);
 static void cleanup_rootset(Rootset *rootset);
 static Eterm *full_sweep_heaps(Process *p,
@@ -148,12 +149,15 @@ static int adjust_after_fullsweep(Process *p, int need, Eterm *objv, int nobj);
 static void shrink_new_heap(Process *p, Uint new_sz, Eterm *objv, int nobj);
 static void grow_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj);
 static void sweep_off_heap(Process *p, int fullsweep);
-static void offset_heap(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_size);
-static void offset_heap_ptr(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_size);
-static void offset_rootset(Process *p, Sint offs, char* area, Uint area_size,
-			   Eterm* objv, int nobj);
-static void offset_off_heap(Process* p, Sint offs, char* area, Uint area_size);
-static void offset_mqueue(Process *p, Sint offs, char* area, Uint area_size);
+static void offset_heap(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_sz);
+static void offset_stack(Eterm *stack, Uint sz,
+                         Sint heap_offset, Sint stack_offset,
+                         char* area, Uint area_sz);
+static void offset_heap_ptr(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_sz);
+static void offset_rootset(Process *p, Sint heap_offs, Sint stack_offs,
+                           char* area, Uint area_sz, Eterm* objv, int nobj);
+static void offset_off_heap(Process* p, Sint offs, char* area, Uint area_sz);
+static void offset_mqueue(Process *p, Sint offs, char* area, Uint area_sz);
 static int reached_max_heap_size(Process *p, Uint total_heap_size,
                                  Uint extra_heap_size, Uint extra_old_heap_size);
 static void init_gc_info(ErtsGCInfo *gcip);
@@ -477,7 +481,7 @@ delay_garbage_collection(Process *p, ErlHeapFragment *live_hf_end, int need, int
 {
     ErlHeapFragment *hfrag;
     Eterm *orig_heap, *orig_hend, *orig_htop, *orig_stop;
-    Eterm *stop, *hend;
+    Eterm *hend;
     Uint hsz, ssz;
     int reds_left;
 
@@ -514,10 +518,11 @@ delay_garbage_collection(Process *p, ErlHeapFragment *live_hf_end, int need, int
     hsz = ssz + need + ERTS_DELAY_GC_EXTRA_FREE + S_RESERVED;
 
     hfrag = new_message_buffer(hsz);
+
+    copy_erlang_stack(p, &hfrag->mem[0], hsz);
+
     p->heap = p->htop = &hfrag->mem[0];
     p->hend = hend = &hfrag->mem[hsz];
-    p->stop = stop = hend - ssz;
-    sys_memcpy((void *) stop, (void *) orig_stop, ssz * sizeof(Eterm));
 
     if (p->abandoned_heap) {
 	/*
@@ -915,7 +920,7 @@ garbage_collect_hibernate(Process* p, int check_long_gc)
     Eterm* htop;
     Uint actual_size;
     char* area;
-    Uint area_size;
+    Uint area_sz;
     Sint offs;
     int reds;
 
@@ -954,7 +959,17 @@ garbage_collect_hibernate(Process* p, int check_long_gc)
 
     /* Only allow one continuation pointer. */
     ASSERT(p->stop == p->hend - CP_SIZE);
-    ASSERT(p->stop[0] == make_cp(beam_normal_exit));
+
+    switch (erts_frame_layout) {
+    case ERTS_FRAME_LAYOUT_RA:
+        ASSERT(p->stop[0] == make_cp(beam_normal_exit));
+        break;
+    case ERTS_FRAME_LAYOUT_FP_RA:
+        ASSERT(p->stop[0] == make_cp(NULL));
+        ASSERT(p->stop[1] == make_cp(beam_normal_exit));
+        ASSERT(FRAME_POINTER(p) == &p->stop[0]);
+        break;
+    }
 
     /*
      * Do it.
@@ -1018,14 +1033,24 @@ garbage_collect_hibernate(Process* p, int check_long_gc)
 
     p->hend = heap + heap_size;
     p->stop = p->hend - CP_SIZE;
-    p->stop[0] = make_cp(beam_normal_exit);
+ 
+    switch (erts_frame_layout) {
+    case ERTS_FRAME_LAYOUT_RA:
+        p->stop[0] = make_cp(beam_normal_exit);
+        break;
+    case ERTS_FRAME_LAYOUT_FP_RA:
+        p->stop[0] = make_cp(NULL);
+        p->stop[1] = make_cp(beam_normal_exit);
+        FRAME_POINTER(p) = &p->stop[0];
+        break;
+    }
 
     offs = heap - p->heap;
     area = (char *) p->heap;
-    area_size = ((char *) p->htop) - area;
-    offset_heap(heap, actual_size, offs, area, area_size);
+    area_sz = ((char *) p->htop) - area;
+    offset_heap(heap, actual_size, offs, area, area_sz);
     p->high_water = heap + (p->high_water - p->heap);
-    offset_rootset(p, offs, area, area_size, p->arg_reg, p->arity);
+    offset_rootset(p, offs, 0, area, area_sz, p->arg_reg, p->arity);
     p->htop = heap + actual_size;
     p->heap = heap;
     p->heap_sz = heap_size;
@@ -1060,11 +1085,6 @@ erts_garbage_collect_hibernate(Process* p)
     BUMP_REDS(p, reds);
 }
 
-#define fullsweep_nstack(p,n_htop)		        	(n_htop)
-#define GENSWEEP_NSTACK(p,old_htop,n_htop)	        	do{}while(0)
-#define offset_nstack(p,offs,area,area_size)	        	do{}while(0)
-#define sweep_literals_nstack(p,old_htop,area,area_size)	(old_htop)
-
 int
 erts_garbage_collect_literals(Process* p, Eterm* literals,
 			      Uint byte_lit_size,
@@ -1078,7 +1098,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
     Rootset rootset;            /* Rootset for GC (stack, dictionary, etc). */
     Roots* roots;
     char* area;
-    Uint area_size;
+    Uint area_sz;
     Eterm* old_htop;
     Uint n;
     Uint ygen_usage = 0;
@@ -1170,7 +1190,8 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
     offs = temp_lit - literals;
     offset_heap(temp_lit, lit_size, offs, (char *) literals, byte_lit_size);
     offset_heap(p->heap, p->htop - p->heap, offs, (char *) literals, byte_lit_size);
-    offset_rootset(p, offs, (char *) literals, byte_lit_size, p->arg_reg, p->arity);
+    offset_rootset(p, offs, 0, (char *) literals, byte_lit_size,
+                   p->arg_reg, p->arity);
     if (oh) {
 	oh = (struct erl_off_heap_header *) ((Eterm *)(void *) oh + offs);
     }
@@ -1182,10 +1203,10 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
      */
 
     area = (char *) temp_lit;
-    area_size = byte_lit_size;
+    area_sz = byte_lit_size;
     n = setup_rootset(p, p->arg_reg, p->arity, &rootset);
     roots = rootset.roots;
-    old_htop = sweep_literals_nstack(p, p->old_htop, area, area_size);
+    old_htop = p->old_htop;
     while (n--) {
         Eterm* g_ptr = roots->v;
         Uint g_sz = roots->sz;
@@ -1204,7 +1225,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
                 if (IS_MOVED_BOXED(val)) {
 		    ASSERT(is_boxed(val));
                     *g_ptr = val;
-		} else if (ErtsInArea(ptr, area, area_size)) {
+		} else if (ErtsInArea(ptr, area, area_sz)) {
                     move_boxed(ptr,val,&old_htop,g_ptr);
 		}
 		break;
@@ -1213,7 +1234,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
                 val = *ptr;
                 if (IS_MOVED_CONS(val)) { /* Moved */
                     *g_ptr = ptr[1];
-		} else if (ErtsInArea(ptr, area, area_size)) {
+		} else if (ErtsInArea(ptr, area, area_sz)) {
                     move_cons(ptr,val,&old_htop,g_ptr);
                 }
 		break;
@@ -1230,10 +1251,10 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
      * Now we'll have to go through all heaps updating all other references.
      */
 
-    old_htop = sweep_literals_to_old_heap(p->heap, p->htop, old_htop, area, area_size);
+    old_htop = sweep_literals_to_old_heap(p->heap, p->htop, old_htop, area, area_sz);
     old_htop = sweep_literal_area(p->old_heap, old_htop,
 				  (char *) p->old_heap, sizeof(Eterm)*old_heap_size,
-				  area, area_size);
+				  area, area_sz);
     ASSERT(p->old_htop <= old_htop && old_htop <= p->old_hend);
     p->old_htop = old_htop;
 
@@ -1489,6 +1510,65 @@ minor_collection(Process* p, ErlHeapFragment *live_hf_end,
     return -1;
 }
 
+/* Copies the Erlang stack to the end of the new heap, adjusting continuation
+ * pointers as needed. */
+static ERTS_INLINE void copy_erlang_stack(Process *p,
+                                          Eterm *new_heap,
+                                          SWord new_sz) {
+    const ErtsFrameLayout frame_layout = erts_frame_layout;
+
+    Eterm *prev_stack_top, *prev_stack_end;
+    Eterm *new_stack_top;
+    SWord stack_size;
+
+    ASSERT(new_heap != HEAP_START(p));
+
+    prev_stack_top = STACK_TOP(p);
+    prev_stack_end = STACK_START(p);
+
+    stack_size = prev_stack_end - prev_stack_top;
+    new_stack_top = &new_heap[new_sz - stack_size];
+
+#if defined(DEBUG) && defined(ERLANG_FRAME_POINTERS)
+    erts_validate_stack(p, FRAME_POINTER(p), prev_stack_top);
+#endif
+
+    if (frame_layout == ERTS_FRAME_LAYOUT_RA) {
+        sys_memcpy(new_stack_top, prev_stack_top, stack_size * sizeof(Eterm));
+    } else {
+        Eterm *new_p, *old_p;
+        SWord stack_offset;
+
+        ASSERT(frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+
+        old_p = prev_stack_top;
+        new_p = new_stack_top;
+
+        stack_offset = new_stack_top - prev_stack_top;
+
+        while (old_p < prev_stack_end) {
+            Eterm val = old_p[0];
+
+            if (is_CP(val)) {
+                Eterm *frame_ptr = (Eterm*)cp_val(val);
+
+                if (old_p < frame_ptr && frame_ptr < prev_stack_end) {
+                    val = offset_ptr(val, stack_offset);
+                }
+            }
+
+            new_p[0] = val;
+
+            new_p++;
+            old_p++;
+        }
+
+        FRAME_POINTER(p) += stack_offset;
+    }
+
+    p->stop = new_stack_top;
+}
+
 static void
 do_minor(Process *p, ErlHeapFragment *live_hf_end,
 	 char *mature, Uint mature_size,
@@ -1528,7 +1608,6 @@ do_minor(Process *p, ErlHeapFragment *live_hf_end,
 	n_htop = collect_live_heap_frags(p, live_hf_end, n_htop);
     }
 
-    GENSWEEP_NSTACK(p, old_htop, n_htop);
     while (n--) {
         Eterm* g_ptr = roots->v;
         Uint g_sz = roots->sz;
@@ -1676,10 +1755,7 @@ do_minor(Process *p, ErlHeapFragment *live_hf_end,
     disallow_heap_frag_ref_in_old_heap(p);
 #endif
 
-    /* Copy stack to end of new heap */
-    n = p->hend - p->stop;
-    sys_memcpy(n_heap + new_sz - n, p->stop, n * sizeof(Eterm));
-    p->stop = n_heap + new_sz - n;
+    copy_erlang_stack(p, n_heap, new_sz);
 
 #ifdef HARDDEBUG
     disallow_heap_frag_ref_in_heap(p, n_heap, n_htop);
@@ -1718,7 +1794,7 @@ major_collection(Process* p, ErlHeapFragment *live_hf_end,
     Eterm* n_htop;
     char* oh = (char *) OLD_HEAP(p);
     Uint oh_size = (char *) OLD_HTOP(p) - oh;
-    Uint new_sz, stk_sz;
+    Uint new_sz;
     int adjusted;
 
     VERBOSE(DEBUG_SHCOPY, ("[pid=%T] MAJOR GC: %p %p %p %p\n", p->common.id,
@@ -1769,10 +1845,7 @@ major_collection(Process* p, ErlHeapFragment *live_hf_end,
     n_htop = full_sweep_heaps(p, live_hf_end, 0, n_heap, n_htop, oh, oh_size,
                               objv, nobj);
 
-    /* Move the stack to the end of the heap */
-    stk_sz = HEAP_END(p) - p->stop;
-    sys_memcpy(n_heap + new_sz - stk_sz, p->stop, stk_sz * sizeof(Eterm));
-    p->stop = n_heap + new_sz - stk_sz;
+    copy_erlang_stack(p, n_heap, new_sz);
 
 #ifdef HARDDEBUG
     disallow_heap_frag_ref_in_heap(p, n_heap, n_htop);
@@ -1924,7 +1997,7 @@ adjust_after_fullsweep(Process *p, int need, Eterm *objv, int nobj)
     int adjusted = 0;
     Uint wanted, sz, need_after;
     Uint stack_size = STACK_SZ_ON_HEAP(p);
-    
+
     /*
      * Resize the heap if needed.
      */
@@ -1934,7 +2007,7 @@ adjust_after_fullsweep(Process *p, int need, Eterm *objv, int nobj)
         /* Too small - grow to match requested need */
         sz = next_heap_size(p, need_after, 0);
         grow_new_heap(p, sz, objv, nobj);
-	adjusted = 1;
+        adjusted = 1;
     } else if (3 * HEAP_SIZE(p) < 4 * need_after){
         /* Need more than 75% of current, postpone to next GC.*/
         FLAGS(p) |= F_HEAP_GROW;
@@ -2538,7 +2611,7 @@ setup_rootset(Process *p, Eterm *objv, int nobj, Rootset *rootset)
 	roots[n].sz = ERTS_RECV_MARKER_BLOCK_SIZE;
 	n++;
     }
-    
+
     /*
      * If a NIF or BIF has saved arguments, they need to be added
      */
@@ -2623,100 +2696,116 @@ void cleanup_rootset(Rootset* rootset)
     }
 }
 
-static void
-grow_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj)
+static void resize_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj)
 {
-    Eterm* new_heap;
-    Uint heap_size = HEAP_TOP(p) - HEAP_START(p);
-    Uint stack_size = p->hend - p->stop;
-    Sint offs;
+    Eterm *new_stack, *prev_stack;
+    Eterm *new_heap, *prev_heap;
+    Sint heap_offs, stack_offs;
+    Uint heap_used, stack_used;
+    Uint prev_sz;
+    Uint area_sz;
+    char* area;
 
-    ASSERT(HEAP_SIZE(p) < new_sz);
-    new_heap = (Eterm *) ERTS_HEAP_REALLOC(ERTS_ALC_T_HEAP,
-					   (void *) HEAP_START(p),
-					   sizeof(Eterm)*(HEAP_SIZE(p)),
-					   sizeof(Eterm)*new_sz);
-
-    if ((offs = new_heap - HEAP_START(p)) == 0) { /* No move. */
-        HEAP_END(p) = new_heap + new_sz;
-        sys_memmove(p->hend - stack_size, p->stop, stack_size * sizeof(Eterm));
-        p->stop = p->hend - stack_size;
-    } else {
-	char* area = (char *) HEAP_START(p);
-	Uint area_size = (char *) HEAP_TOP(p) - area;
-        Eterm* prev_stop = p->stop;
+    prev_heap = HEAP_START(p);
+    prev_sz = HEAP_SIZE(p);
 
-        offset_heap(new_heap, heap_size, offs, area, area_size);
+    stack_used = STACK_START(p) - STACK_TOP(p);
+    prev_stack = &prev_heap[prev_sz - stack_used];
 
-        HIGH_WATER(p) = new_heap + (HIGH_WATER(p) - HEAP_START(p));
+    if (new_sz <= prev_sz) {
+        /* When shrinking, we need to move the stack prior to reallocating as
+         * the upper part of the stack will disappear. */
+        sys_memmove(prev_stack - (prev_sz - new_sz),
+                    prev_stack, stack_used * sizeof(Eterm));
+    }
 
-        HEAP_END(p) = new_heap + new_sz;
-        prev_stop = new_heap + (p->stop - p->heap);
-        p->stop = p->hend - stack_size;
-        sys_memmove(p->stop, prev_stop, stack_size * sizeof(Eterm));
+    new_heap = ERTS_HEAP_REALLOC(ERTS_ALC_T_HEAP, prev_heap,
+                                 prev_sz * sizeof(Eterm),
+                                 new_sz * sizeof(Eterm));
+    new_stack = &new_heap[new_sz - stack_used];
 
-        offset_rootset(p, offs, area, area_size, objv, nobj);
-        HEAP_TOP(p) = new_heap + heap_size;
-        HEAP_START(p) = new_heap;
+    if (new_sz > prev_sz) {
+        /* We've grown and the previous stack has either remained in place or
+         * been copied over to its _previous position_ as part of reallocation,
+         * so we need to copy it to its new position at the end of the heap.
+         *
+         * Note that its pointers are still unchanged, so offset calculation
+         * should still use `prev_stack` as set above.*/
+        sys_memmove(new_stack,
+                    &new_heap[prev_sz - stack_used],
+                    stack_used * sizeof(Eterm));
     }
 
+    heap_used = HEAP_TOP(p) - HEAP_START(p);
+
+    heap_offs = new_heap - prev_heap;
+    stack_offs = new_stack - prev_stack;
+
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+        FRAME_POINTER(p) += stack_offs;
+    }
+
+    HEAP_TOP(p) = &new_heap[heap_used];
+    HEAP_START(p) = new_heap;
+
+    STACK_START(p) = &new_heap[new_sz];
+    STACK_TOP(p) = new_stack;
+
+    HIGH_WATER(p) = &new_heap[HIGH_WATER(p) - prev_heap];
+    HEAP_END(p) = &new_heap[new_sz];
+
+    HEAP_SIZE(p) = new_sz;
+
+    area = (char *) prev_heap;
+    area_sz = prev_sz * sizeof(Eterm);
+
+    if (new_heap == prev_heap) {
+        offset_stack(new_stack, stack_used, heap_offs, stack_offs,
+                     area, area_sz);
+    } else {
+        offset_heap(new_heap, heap_used, heap_offs, area, area_sz);
+        offset_rootset(p, heap_offs, stack_offs, area, area_sz, objv, nobj);
+    }
+}
+
+static void
+grow_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj)
+{
+#ifdef USE_VM_PROBES
+    Uint prev_sz = HEAP_SIZE(p);
+#endif
+
+    ASSERT(HEAP_SIZE(p) < new_sz);
+    resize_new_heap(p, new_sz, objv, nobj);
+
 #ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_heap_grow)) {
 	DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, pidbuf);
-	DTRACE3(process_heap_grow, pidbuf, HEAP_SIZE(p), new_sz);
+	DTRACE3(process_heap_grow, pidbuf, prev_sz, new_sz);
     }
 #endif
-
-    HEAP_SIZE(p) = new_sz;
 }
 
 static void
 shrink_new_heap(Process *p, Uint new_sz, Eterm *objv, int nobj)
 {
-    Eterm* new_heap;
-    Uint heap_size = HEAP_TOP(p) - HEAP_START(p);
-    Sint offs;
-    Uint stack_size = p->hend - p->stop;
-
-    ASSERT(new_sz < p->heap_sz);
-    sys_memmove(p->heap + new_sz - stack_size, p->stop, stack_size *
-                                                        sizeof(Eterm));
-    new_heap = (Eterm *) ERTS_HEAP_REALLOC(ERTS_ALC_T_HEAP,
-					   (void*)p->heap,
-					   sizeof(Eterm)*(HEAP_SIZE(p)),
-					   sizeof(Eterm)*new_sz);
-    p->hend = new_heap + new_sz;
-    p->stop = p->hend - stack_size;
-
-    if ((offs = new_heap - HEAP_START(p)) != 0) {
-	char* area = (char *) HEAP_START(p);
-	Uint area_size = (char *) HEAP_TOP(p) - area;
-
-        /*
-         * Normally, we don't expect a shrunk heap to move, but you never
-         * know on some strange embedded systems...
-         */
-
-        offset_heap(new_heap, heap_size, offs, area, area_size);
+#ifdef USE_VM_PROBES
+    Uint prev_sz = HEAP_SIZE(p);
+#endif
 
-        HIGH_WATER(p) = new_heap + (HIGH_WATER(p) - HEAP_START(p));
-        offset_rootset(p, offs, area, area_size, objv, nobj);
-        HEAP_TOP(p) = new_heap + heap_size;
-        HEAP_START(p) = new_heap;
-    }
+    ASSERT(HEAP_SIZE(p) > new_sz);
+    resize_new_heap(p, new_sz, objv, nobj);
 
 #ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_heap_shrink)) {
 	DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, pidbuf);
-	DTRACE3(process_heap_shrink, pidbuf, HEAP_SIZE(p), new_sz);
+	DTRACE3(process_heap_shrink, pidbuf, prev_sz, new_sz);
     }
 #endif
-
-    HEAP_SIZE(p) = new_sz;
 }
 
 static Uint64
@@ -3101,19 +3190,57 @@ offset_heap(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_size)
     }
 }
 
-/*
- * Offset pointers to heap from stack.
- */
+/* Offset on-stack pointers to stack and heap. */
+static void
+offset_stack(Eterm *stack, Uint sz,
+             Sint heap_offset, Sint stack_offset,
+             char* area, Uint area_sz) {
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA || stack_offset == 0) {
+        /* No need to update self-references, just update pointers to the
+         * heap. */
+        offset_heap_ptr(stack, sz, heap_offset, area, area_sz);
+    } else {
+        Sint i = 0;
 
-static void 
-offset_heap_ptr(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_size)
+        ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+
+        while (i < sz) {
+            Eterm val = stack[i];
+
+            switch (primary_tag(val)) {
+            case TAG_PRIMARY_HEADER:
+                if (ErtsInArea(val, area, area_sz)) {
+                    stack[i] = offset_ptr(val, stack_offset);
+                }
+
+                i++;
+                break;
+            case TAG_PRIMARY_LIST:
+            case TAG_PRIMARY_BOXED:
+                if (ErtsInArea(ptr_val(val), area, area_sz)) {
+                    stack[i] = offset_ptr(val, heap_offset);
+                }
+
+                i++;
+                break;
+            default:
+                i++;
+                break;
+            }
+        }
+    }
+}
+
+/* Offset pointers to heap from a root set. */
+static void
+offset_heap_ptr(Eterm* hp, Uint sz, Sint offs, char* area, Uint area_sz)
 {
     while (sz--) {
 	Eterm val = *hp;
 	switch (primary_tag(val)) {
 	case TAG_PRIMARY_LIST:
 	case TAG_PRIMARY_BOXED:
-	    if (ErtsInArea(ptr_val(val), area, area_size)) {
+	    if (ErtsInArea(ptr_val(val), area, area_sz)) {
 		*hp = offset_ptr(val, offs);
 	    }
 	    hp++;
@@ -3189,43 +3316,46 @@ offset_mqueue(Process *p, Sint offs, char* area, Uint area_size)
 }
 
 static void ERTS_INLINE
-offset_one_rootset(Process *p, Sint offs, char* area, Uint area_size,
-                   Eterm* objv, int nobj)
+offset_one_rootset(Process *p, Sint heap_offs, Sint stack_offs,
+                   char* area, Uint area_sz, Eterm* objv, int nobj)
 {
     Eterm *v;
     Uint sz;
     if (p->dictionary)  {
-	offset_heap(ERTS_PD_START(p->dictionary),
-		    ERTS_PD_SIZE(p->dictionary),
-		    offs, area, area_size);
+        offset_heap(ERTS_PD_START(p->dictionary),
+                    ERTS_PD_SIZE(p->dictionary),
+                    heap_offs, area, area_sz);
     }
 
-    offset_heap_ptr(&p->fvalue, 1, offs, area, area_size);
-    offset_heap_ptr(&p->ftrace, 1, offs, area, area_size);
-    offset_heap_ptr(&p->seq_trace_token, 1, offs, area, area_size);
+    offset_heap_ptr(&p->fvalue, 1, heap_offs, area, area_sz);
+    offset_heap_ptr(&p->ftrace, 1, heap_offs, area, area_sz);
+    offset_heap_ptr(&p->seq_trace_token, 1, heap_offs, area, area_sz);
 #ifdef USE_VM_PROBES
-    offset_heap_ptr(&p->dt_utag, 1, offs, area, area_size);
+    offset_heap_ptr(&p->dt_utag, 1, heap_offs, area, area_sz);
 #endif
-    offset_heap_ptr(&p->group_leader, 1, offs, area, area_size);
-    if (p->sig_qs.recv_mrk_blk)
-	offset_heap_ptr(&p->sig_qs.recv_mrk_blk->ref[0],
-			ERTS_RECV_MARKER_BLOCK_SIZE, offs, area, area_size);
-    offset_mqueue(p, offs, area, area_size);
-    offset_heap_ptr(p->stop, (STACK_START(p) - p->stop), offs, area, area_size);
-    offset_nstack(p, offs, area, area_size);
+    offset_heap_ptr(&p->group_leader, 1, heap_offs, area, area_sz);
+    if (p->sig_qs.recv_mrk_blk) {
+        offset_heap_ptr(&p->sig_qs.recv_mrk_blk->ref[0],
+                        ERTS_RECV_MARKER_BLOCK_SIZE, heap_offs,
+                        area, area_sz);
+    }
+    offset_mqueue(p, heap_offs, area, area_sz);
+    offset_stack(p->stop, (STACK_START(p) - p->stop), heap_offs, stack_offs,
+                 area, area_sz);
     if (nobj > 0) {
-	offset_heap_ptr(objv, nobj, offs, area, area_size);
+        offset_heap_ptr(objv, nobj, heap_offs, area, area_sz);
+    }
+    offset_off_heap(p, heap_offs, area, area_sz);
+    if (erts_setup_nfunc_rootset(p, &v, &sz)) {
+        offset_heap_ptr(v, sz, heap_offs, area, area_sz);
     }
-    offset_off_heap(p, offs, area, area_size);
-    if (erts_setup_nfunc_rootset(p, &v, &sz))
-	offset_heap_ptr(v, sz, offs, area, area_size);
 }
 
 static void
-offset_rootset(Process *p, Sint offs, char* area, Uint area_size,
-	       Eterm* objv, int nobj)
+offset_rootset(Process *p, Sint heap_offs, Sint stack_offs,
+               char* area, Uint area_sz, Eterm* objv, int nobj)
 {
-    offset_one_rootset(p, offs, area, area_size, objv, nobj);
+    offset_one_rootset(p, heap_offs, stack_offs, area, area_sz, objv, nobj);
 }
 
 static void
@@ -3574,6 +3704,47 @@ erts_max_heap_size(Eterm arg, Uint *max_heap_size, Uint *max_heap_flags)
     return 1;
 }
 
+#ifdef DEBUG
+void erts_validate_stack(Process *p, Eterm *frame_ptr, Eterm *stack_top) {
+    Eterm *stack_bottom = HEAP_END(p);
+    Eterm *next_fp = frame_ptr;
+    Eterm *scanner = stack_top;
+
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+        return;
+    }
+
+    ASSERT(next_fp);
+    do {
+        ASSERT(next_fp >= stack_top && next_fp <= stack_bottom);
+
+        /* We may not skip any frames. */
+        while (scanner < next_fp) {
+            ASSERT(is_not_CP(scanner[0]));
+            scanner++;
+        }
+
+        /* {Next frame, Return address} or vice versa */
+        ASSERT(is_CP(scanner[0]) && is_CP(scanner[1]));
+        next_fp = (Eterm*)cp_val(scanner[0]);
+
+        /* Call tracing may store raw pointers on the stack. This is explicitly
+         * handled in all routines that deal with the stack. */
+        if (BeamIsReturnTrace((ErtsCodePtr)scanner[1])) {
+            /* Skip MFA and tracer. */
+            ASSERT_MFA((ErtsCodeMFA*)cp_val(scanner[2]));
+            ASSERT(IS_TRACER_VALID(scanner[3]));
+            scanner += 2;
+        } else if (BeamIsReturnTimeTrace((ErtsCodePtr)scanner[1])) {
+            /* Skip prev_info. */
+            scanner += 1;
+        }
+
+        scanner += CP_SIZE;
+    } while(next_fp);
+}
+#endif
+
 #if defined(DEBUG) || defined(ERTS_OFFHEAP_DEBUG)
 
 int
diff --git a/erts/emulator/beam/erl_gc.h b/erts/emulator/beam/erl_gc.h
index ef0f8e9978..7f86573a41 100644
--- a/erts/emulator/beam/erl_gc.h
+++ b/erts/emulator/beam/erl_gc.h
@@ -189,4 +189,10 @@ void erts_copy_one_frag(Eterm** hpp, ErlOffHeap* off_heap,
 int erts_dbg_within_proc(Eterm *ptr, Process *p, Eterm* real_htop);
 #endif
 
+#ifdef DEBUG
+/* Validates the frame chain, ensuring that it always points within the stack
+ * and that no frames are skipped. */
+void erts_validate_stack(Process *p, Eterm *frame_ptr, Eterm *stack_top);
+#endif
+
 #endif /* __ERL_GC_H__ */
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 70b18b9ff1..0d7127c5ee 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -58,6 +58,7 @@
 #include "erl_utils.h"
 #include "erl_io_queue.h"
 #include "erl_proc_sig_queue.h"
+#include "beam_common.h"
 #undef ERTS_WANT_NFUNC_SCHED_INTERNALS__
 #define ERTS_WANT_NFUNC_SCHED_INTERNALS__
 #include "erl_nfunc_sched.h"
@@ -335,6 +336,7 @@ schedule(ErlNifEnv* env, NativeFunPtr direct_fp, NativeFunPtr indirect_fp,
 {
     ErtsNativeFunc *ep;
     Process *c_p, *dirty_shadow_proc;
+    ErtsCodePtr caller;
 
     execution_state(env, &c_p, NULL);
     ASSERT(c_p);
@@ -346,9 +348,11 @@ schedule(ErlNifEnv* env, NativeFunPtr direct_fp, NativeFunPtr indirect_fp,
 
     ERTS_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(c_p));
 
+    erts_inspect_frame(c_p->stop, &caller);
+
     ep = erts_nfunc_schedule(c_p, dirty_shadow_proc,
 				  c_p->current,
-                                  cp_val(c_p->stop[0]),
+                                  caller,
                              #ifdef BEAMASM
 				  op_call_nif_WWW,
                              #else
@@ -552,22 +556,15 @@ struct enif_msg_environment_t
     Process phony_proc;
 };
 
-#if S_REDZONE == 0
-/*
- * Arrays of size zero are not allowed (although some compilers do
- * allow it). Be sure to set the array size to 1 if there is no
- * redzone to ensure that the code can be compiled with any compiler.
- */
-static Eterm phony_heap[1];
-#else
-static Eterm phony_heap[S_REDZONE];
-#endif
+static Eterm phony_heap[32];
 
 static ERTS_INLINE void
 setup_nif_env(struct enif_msg_environment_t* msg_env,
               struct erl_module_nif* mod,
               Process* tracee)
 {
+    ASSERT(sizeof(phony_heap) > (S_REDZONE * sizeof(Eterm)));
+
     msg_env->env.hp = &phony_heap[0];
     msg_env->env.hp_end = &phony_heap[0];
     msg_env->env.heap_frag = NULL;
@@ -4318,7 +4315,7 @@ typedef struct {
         /* data */
 #ifdef BEAMASM
         BeamInstr prologue[BEAM_ASM_FUNC_PROLOGUE_SIZE / sizeof(UWord)];
-        BeamInstr call_nif[10];
+        BeamInstr call_nif[7];
 #else
         BeamInstr call_nif[4];
 #endif
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index b798754764..33ea954d67 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -12012,7 +12012,7 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
     p->high_water = p->heap;
     p->gen_gcs = 0;
     p->hend = p->heap + sz;
-    p->stop = p->hend - 1;     /* Reserve place for continuation pointer */
+    p->stop = p->hend - CP_SIZE; /* Reserve place for continuation pointer. */
     p->htop = p->heap;
     p->heap_sz = sz;
     p->abandoned_heap = NULL;
@@ -12030,7 +12030,18 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
     p->current = &p->u.initial;
 
     p->i = beam_apply;
-    p->stop[0] = make_cp(beam_normal_exit);
+
+    switch (erts_frame_layout) {
+    case ERTS_FRAME_LAYOUT_RA:
+        p->stop[0] = make_cp(beam_normal_exit);
+        break;
+    case ERTS_FRAME_LAYOUT_FP_RA:
+        p->stop[0] = make_cp(NULL);
+        p->stop[1] = make_cp(beam_normal_exit);
+
+        FRAME_POINTER(p) = &p->stop[0];
+        break;
+    }
 
     p->arg_reg = p->def_arg_reg;
     p->max_arg_reg = sizeof(p->def_arg_reg)/sizeof(p->def_arg_reg[0]);
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index b98f497af0..44aaa72bf5 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -955,6 +955,21 @@ typedef struct ErtsProcSysTaskQs_ ErtsProcSysTaskQs;
     (ASSERT((p)->htop <= (p)->stop),                                           \
      MAX((p)->htop, (p)->stop - S_REDZONE))
 
+#ifdef ERLANG_FRAME_POINTERS
+/* The current frame pointer on the Erlang stack. */
+#  define FRAME_POINTER(p)  (p)->frame_pointer
+#else
+/* We define this to a trapping lvalue when frame pointers are unsupported to
+ * provoke crashes when used without checking `erts_frame_layout`. The checks
+ * will not have a runtime cost in this case since said variable is hardcoded
+ * to `ERTS_FRAME_LAYOUT_RA`. */
+#  define FRAME_POINTER(p)  (((volatile Eterm**)0xbadf00d)[0])
+
+#  ifndef erts_frame_layout
+#    error "erts_frame_layout has not been hardcoded to ERTS_FRAME_LAYOUT_RA"
+#  endif
+#endif
+
 #  define HEAP_END(p)       (p)->hend
 #  define HEAP_SIZE(p)      (p)->heap_sz
 #  define STACK_START(p)    (p)->hend
@@ -994,8 +1009,13 @@ struct process {
      * shorter instruction can be used to access them.
      */
 
-    Eterm* htop;		/* Heap top */
-    Eterm* stop;		/* Stack top */
+    Eterm *htop;                /* Heap top */
+    Eterm *stop;                /* Stack top */
+
+#ifdef ERLANG_FRAME_POINTERS
+    Eterm *frame_pointer;       /* Frame pointer */
+#endif
+
     Sint fcalls;		/* Number of reductions left to execute.
 				 * Only valid for the current process.
 				 */
diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index 50e3fdc9f2..99946a4189 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -27,9 +27,17 @@
  */
 /* #define FORCE_HEAP_FRAGS */
 
-/* valgrind can't handle stack switching, so we will turn off native stack. */
+/* `valgrind` can't handle stack switching, so we will turn off native
+ * stack. */
 #ifdef VALGRIND
 #undef NATIVE_ERLANG_STACK
+#undef ERLANG_FRAME_POINTERS
+#endif
+
+/* Frame pointer support costs an extra word per process even when unused, so
+ * it's worth disabling for compact builds. */
+#ifdef CODE_MODEL_SMALL
+#undef ERLANG_FRAME_POINTERS
 #endif
 
 #if defined(DEBUG) && !defined(CHECK_FOR_HOLES) && !defined(__WIN32__)
@@ -54,7 +62,23 @@
 #define VH_DEFAULT_SIZE  32768     /* default virtual (bin) heap min size (words) */
 #define H_DEFAULT_MAX_SIZE 0       /* default max heap size is off */
 
-#define CP_SIZE 1
+typedef enum {
+    /* Return address only */
+    ERTS_FRAME_LAYOUT_RA,
+    /* Frame pointer, return address */
+    ERTS_FRAME_LAYOUT_FP_RA
+} ErtsFrameLayout;
+
+ERTS_GLB_INLINE
+const int erts_cp_size(void);
+
+#if defined(BEAMASM) && defined(ERLANG_FRAME_POINTERS)
+extern ErtsFrameLayout ERTS_WRITE_UNLIKELY(erts_frame_layout);
+#   define CP_SIZE erts_cp_size()
+#else
+#   define erts_frame_layout ERTS_FRAME_LAYOUT_RA
+#   define CP_SIZE 1
+#endif
 
 /* In the JIT we're not guaranteed to have allocated a word for the CP when
  * allocating a stack frame (it's still reserved however), as the `call` and
@@ -291,4 +315,17 @@ extern void** beam_ops;
 
 #endif /* BEAMASM */
 
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+ERTS_GLB_INLINE
+const int erts_cp_size()
+{
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+        return 1;
+    }
+
+    ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+    return 2;
+}
+#endif
+
 #endif	/* __ERL_VM_H__ */
diff --git a/erts/emulator/beam/jit/x86/beam_asm.cpp b/erts/emulator/beam/jit/x86/beam_asm.cpp
index 4368cc9479..534d09d5da 100644
--- a/erts/emulator/beam/jit/x86/beam_asm.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm.cpp
@@ -28,6 +28,10 @@ extern "C"
 #include "export.h"
 }
 
+#ifdef ERLANG_FRAME_POINTERS
+ErtsFrameLayout ERTS_WRITE_UNLIKELY(erts_frame_layout);
+#endif
+
 /* Global configuration variables (under the `+J` prefix) */
 #ifdef HAVE_LINUX_PERF_SUPPORT
 int erts_jit_perf_support;
@@ -201,6 +205,18 @@ void beamasm_init() {
     ERTS_DECL_AM(erts_beamasm);
     mod_name = AM_erts_beamasm;
 
+    /* erts_frame_layout is hardcoded to ERTS_FRAME_LAYOUT_RA when Erlang
+     * frame pointers are disabled or unsupported. */
+#if defined(ERLANG_FRAME_POINTERS)
+    if (erts_jit_perf_support & BEAMASM_PERF_MAP) {
+        erts_frame_layout = ERTS_FRAME_LAYOUT_FP_RA;
+    } else {
+        erts_frame_layout = ERTS_FRAME_LAYOUT_RA;
+    }
+#else
+    ERTS_CT_ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
+#endif
+
     beamasm_init_perf();
     beamasm_init_gdb_jit_info();
 
@@ -209,13 +225,16 @@ void beamasm_init() {
      * short instructions. Before removing any of these assertions, please
      * consider the effect it will have on code size and/or performance.
      */
-
     ERTS_CT_ASSERT(offsetof(Process, htop) < 128);
     ERTS_CT_ASSERT(offsetof(Process, stop) < 128);
     ERTS_CT_ASSERT(offsetof(Process, fcalls) < 128);
     ERTS_CT_ASSERT(offsetof(Process, freason) < 128);
     ERTS_CT_ASSERT(offsetof(Process, fvalue) < 128);
 
+#ifdef ERLANG_FRAME_POINTERS
+    ERTS_CT_ASSERT(offsetof(Process, frame_pointer) < 128);
+#endif
+
     cpuinfo = CpuInfo::host();
 
     jit_allocator = pick_allocator();
@@ -423,6 +442,12 @@ void BeamGlobalAssembler::emit_process_main() {
     {
         Label not_exiting = a.newLabel();
 
+#ifdef ERLANG_FRAME_POINTERS
+        /* Kill the current frame pointer to avoid confusing `perf` and similar
+         * tools. */
+        a.sub(frame_pointer, frame_pointer);
+#endif
+
 #ifdef DEBUG
         Label check_i = a.newLabel();
         /* Check that ARG3 is set to a valid CP. */
@@ -434,6 +459,14 @@ void BeamGlobalAssembler::emit_process_main() {
 
         a.mov(x86::qword_ptr(c_p, offsetof(Process, i)), ARG3);
 
+#if defined(JIT_HARD_DEBUG) && defined(ERLANG_FRAME_POINTERS)
+        a.mov(ARG1, c_p);
+        a.mov(ARG2, x86::qword_ptr(c_p, offsetof(Process, frame_pointer)));
+        a.mov(ARG3, x86::qword_ptr(c_p, offsetof(Process, stop)));
+
+        runtime_call<3>(erts_validate_stack);
+#endif
+
 #ifdef WIN32
         a.mov(ARG1d, x86::dword_ptr(c_p, offsetof(Process, state.value)));
 #else
@@ -497,6 +530,15 @@ void BeamGlobalAssembler::emit_process_main() {
         }
         a.bind(schedule);
 
+#ifdef ERLANG_FRAME_POINTERS
+        if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+            /* Kill the current frame pointer so that misc jobs that execute
+             * during `erts_schedule` aren't attributed to the function we
+             * were scheduled out of. */
+            a.sub(frame_pointer, frame_pointer);
+        }
+#endif
+
         mov_imm(ARG1, 0);
         a.mov(ARG2, c_p);
 #if defined(DEBUG) || defined(ERTS_ENABLE_LOCK_CHECK)
diff --git a/erts/emulator/beam/jit/x86/beam_asm.hpp b/erts/emulator/beam/jit/x86/beam_asm.hpp
index 9e1254fec1..f1867fd04d 100644
--- a/erts/emulator/beam/jit/x86/beam_asm.hpp
+++ b/erts/emulator/beam/jit/x86/beam_asm.hpp
@@ -69,16 +69,18 @@ protected:
      * when running on the runtime stack. */
     const x86::Gp E = x86::rsp;
 
-    /* Cached copy of Erlang stack pointer used to speed up stack switches when
-     * we know that the runtime doesn't read or modify the Erlang stack.
-     *
-     * If we find ourselves pressed for registers in the future, we could save
-     * this in the same slot as `registers` as that can be trivially recomputed
-     * from the top of the runtime stack. */
-    const x86::Gp E_saved = x86::r12;
+#    ifdef ERLANG_FRAME_POINTERS
+    /* Current frame pointer, used when we emit native stack frames (e.g. to
+     * better support `perf`). */
+    const x86::Gp frame_pointer = x86::rbp;
+#    endif
 
+    /* When we're not using frame pointers, we can keep the Erlang stack in
+     * RBP when running on the runtime stack, which is slightly faster than
+     * reading and writing from c_p->stop. */
+    const x86::Gp E_saved = x86::rbp;
 #else
-    const x86::Gp E = x86::r12;
+    const x86::Gp E = x86::rbp;
 #endif
 
     const x86::Gp c_p = x86::r13;
@@ -90,7 +92,7 @@ protected:
      * This is set to ERTS_SAVE_CALLS_CODE_IX when save_calls is active, which
      * routes us to a common handler routine that calls save_calls before
      * jumping to the actual code. */
-    const x86::Gp active_code_ix = x86::rbp;
+    const x86::Gp active_code_ix = x86::r12;
 
 #ifdef ERTS_MSACC_EXTENDED_STATES
     const x86::Mem erts_msacc_cache = getSchedulerRegRef(
@@ -593,14 +595,6 @@ protected:
         return x86::qword_ptr(RET, CodeIndex, 3, offsetof(Export, addresses));
     }
 
-    /* Discards a continuation pointer, including the frame pointer if
-     * applicable. */
-    void emit_discard_cp() {
-        emit_assert_erlang_stack();
-
-        a.add(x86::rsp, imm(CP_SIZE * sizeof(Eterm)));
-    }
-
     void emit_assert_runtime_stack() {
 #ifdef JIT_HARD_DEBUG
         Label crash = a.newLabel(), next = a.newLabel();
@@ -655,6 +649,36 @@ protected:
         eCodeIndex = (1 << 3)
     };
 
+    void emit_enter_frame() {
+#ifdef NATIVE_ERLANG_STACK
+        if (ERTS_UNLIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA)) {
+#    ifdef ERLANG_FRAME_POINTERS
+            a.push(frame_pointer);
+            a.mov(frame_pointer, E);
+#    endif
+        } else {
+            ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
+        }
+#endif
+    }
+
+    void emit_leave_frame() {
+#ifdef NATIVE_ERLANG_STACK
+        if (ERTS_UNLIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA)) {
+            a.leave();
+        } else {
+            ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
+        }
+#endif
+    }
+
+    void emit_unwind_frame() {
+        emit_assert_erlang_stack();
+
+        emit_leave_frame();
+        a.add(x86::rsp, imm(sizeof(UWord)));
+    }
+
     template<int Spec = 0>
     void emit_enter_runtime() {
         emit_assert_erlang_stack();
@@ -662,46 +686,65 @@ protected:
         ERTS_CT_ASSERT((Spec & (Update::eReductions | Update::eStack |
                                 Update::eHeap)) == Spec);
 
-#ifdef NATIVE_ERLANG_STACK
-        if (!(Spec & Update::eStack)) {
-            a.mov(E_saved, E);
-        }
-#endif
+        if (ERTS_LIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_RA)) {
+            if ((Spec & (Update::eHeap | Update::eStack)) ==
+                (Update::eHeap | Update::eStack)) {
+                /* To update both heap and stack we use sse instructions like
+                 * gcc -O3 does. Basically it is this function run through
+                 * gcc -O3:
+                 *
+                 *    struct a { long a; long b; long c; };
+                 *    void test(long a, long b, long c, struct a *s) {
+                 *      s->a = a;
+                 *      s->b = b;
+                 *      s->c = c;
+                 *    } */
+                ERTS_CT_ASSERT((offsetof(Process, stop) -
+                                offsetof(Process, htop)) == sizeof(Eterm *));
+                a.movq(x86::xmm0, HTOP);
+                a.movq(x86::xmm1, E);
+                a.punpcklqdq(x86::xmm0, x86::xmm1);
+                a.movups(x86::xmmword_ptr(c_p, offsetof(Process, htop)),
+                         x86::xmm0);
+            } else if (Spec & Update::eHeap) {
+                a.mov(x86::qword_ptr(c_p, offsetof(Process, htop)), HTOP);
+            } else if (Spec & Update::eStack) {
+                a.mov(x86::qword_ptr(c_p, offsetof(Process, stop)), E);
+            }
 
-        if ((Spec & (Update::eHeap | Update::eStack)) ==
-            (Update::eHeap | Update::eStack)) {
-            /* To update both heap and stack we use sse instructions like gcc
-               -O3 does. Basically it is this function run through gcc -O3:
-
-               struct a { long a; long b; long c; };
-
-               void test(long a, long b, long c, struct a *s) {
-                 s->a = a;
-                 s->b = b;
-                 s->c = c;
-               }
-            */
-            ERTS_CT_ASSERT(offsetof(Process, stop) - offsetof(Process, htop) ==
-                           8);
-            a.movq(x86::xmm0, HTOP);
-            a.movq(x86::xmm1, E);
-            if (Spec & Update::eReductions) {
-                a.mov(x86::qword_ptr(c_p, offsetof(Process, fcalls)), FCALLS);
+#ifdef NATIVE_ERLANG_STACK
+            if (!(Spec & Update::eStack)) {
+                a.mov(E_saved, E);
             }
-            a.punpcklqdq(x86::xmm0, x86::xmm1);
-            a.movups(x86::xmmword_ptr(c_p, offsetof(Process, htop)), x86::xmm0);
+#endif
         } else {
-            if ((Spec & Update::eStack)) {
+#ifdef ERLANG_FRAME_POINTERS
+            ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+
+            if (Spec & Update::eStack) {
+                ERTS_CT_ASSERT((offsetof(Process, frame_pointer) -
+                                offsetof(Process, stop)) == sizeof(Eterm *));
+                a.movq(x86::xmm0, E);
+                a.movq(x86::xmm1, frame_pointer);
+                a.punpcklqdq(x86::xmm0, x86::xmm1);
+                a.movups(x86::xmmword_ptr(c_p, offsetof(Process, stop)),
+                         x86::xmm0);
+            } else {
+                /* We can skip updating the frame pointer whenever the process
+                 * doesn't have to inspect the stack. We still need to update
+                 * the stack pointer to switch stacks, though, since we don't
+                 * have enough spare callee-save registers. */
                 a.mov(x86::qword_ptr(c_p, offsetof(Process, stop)), E);
             }
 
             if (Spec & Update::eHeap) {
                 a.mov(x86::qword_ptr(c_p, offsetof(Process, htop)), HTOP);
             }
+#endif
+        }
 
-            if (Spec & Update::eReductions) {
-                a.mov(x86::qword_ptr(c_p, offsetof(Process, fcalls)), FCALLS);
-            }
+        if (Spec & Update::eReductions) {
+            a.mov(x86::qword_ptr(c_p, offsetof(Process, fcalls)), FCALLS);
         }
 
 #ifdef NATIVE_ERLANG_STACK
@@ -724,13 +767,25 @@ protected:
         ERTS_CT_ASSERT((Spec & (Update::eReductions | Update::eStack |
                                 Update::eHeap | Update::eCodeIndex)) == Spec);
 
+        if (ERTS_LIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_RA)) {
+            if (Spec & Update::eStack) {
+                a.mov(E, x86::qword_ptr(c_p, offsetof(Process, stop)));
+            } else {
 #ifdef NATIVE_ERLANG_STACK
-        if (!(Spec & Update::eStack)) {
-            a.mov(E, E_saved);
-        }
+                a.mov(E, E_saved);
 #endif
-        if ((Spec & Update::eStack)) {
+            }
+        } else {
+#ifdef ERLANG_FRAME_POINTERS
+            ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+
             a.mov(E, x86::qword_ptr(c_p, offsetof(Process, stop)));
+
+            if (Spec & Update::eStack) {
+                a.mov(frame_pointer,
+                      x86::qword_ptr(c_p, offsetof(Process, frame_pointer)));
+            }
+#endif
         }
 
         if (Spec & Update::eHeap) {
@@ -901,6 +956,7 @@ class BeamGlobalAssembler : public BeamAssembler {
     _(call_light_bif_shared)                                                   \
     _(call_nif_early)                                                          \
     _(call_nif_shared)                                                         \
+    _(call_nif_yield_helper)                                                   \
     _(catch_end_shared)                                                        \
     _(dispatch_bif)                                                            \
     _(dispatch_nif)                                                            \
@@ -912,8 +968,6 @@ class BeamGlobalAssembler : public BeamAssembler {
     _(generic_bp_global)                                                       \
     _(generic_bp_local)                                                        \
     _(debug_bp)                                                                \
-    _(handle_error_shared_prologue)                                            \
-    _(handle_error_shared)                                                     \
     _(handle_element_error)                                                    \
     _(handle_hd_error)                                                         \
     _(i_band_body_shared)                                                      \
@@ -946,6 +1000,8 @@ class BeamGlobalAssembler : public BeamAssembler {
     _(plus_body_shared)                                                        \
     _(plus_guard_shared)                                                       \
     _(process_main)                                                            \
+    _(raise_exception)                                                         \
+    _(raise_exception_shared)                                                  \
     _(times_body_shared)                                                       \
     _(times_guard_shared)                                                      \
     _(unary_minus_body_shared)                                                 \
@@ -985,8 +1041,6 @@ class BeamGlobalAssembler : public BeamAssembler {
 
     x86::Mem emit_i_length_common(Label fail, int state_size);
 
-    void emit_handle_error();
-
 public:
     BeamGlobalAssembler(JitAllocator *allocator);
 
@@ -1169,9 +1223,9 @@ protected:
                            const ArgVal &Fail,
                            const ArgVal &Flags);
 
-    void emit_handle_error();
-    void emit_handle_error(const ErtsCodeMFA *exp);
-    void emit_handle_error(Label I, const ErtsCodeMFA *exp);
+    void emit_raise_exception();
+    void emit_raise_exception(const ErtsCodeMFA *exp);
+    void emit_raise_exception(Label I, const ErtsCodeMFA *exp);
     void emit_validate(const ArgVal &arity);
     void emit_bs_skip_bits(const ArgVal &Fail, const ArgVal &Ctx);
 
diff --git a/erts/emulator/beam/jit/x86/beam_asm_global.cpp b/erts/emulator/beam/jit/x86/beam_asm_global.cpp
index 1c6479186a..3c14d5fea2 100644
--- a/erts/emulator/beam/jit/x86/beam_asm_global.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm_global.cpp
@@ -103,23 +103,11 @@ BeamGlobalAssembler::BeamGlobalAssembler(JitAllocator *allocator)
     }
 }
 
-void BeamGlobalAssembler::emit_handle_error() {
-    /* Move return address into ARG2 so we know where we crashed.
-     *
-     * This bluntly assumes that we haven't pushed anything to the (Erlang)
-     * stack in the fragments that jump here. */
-
-#ifdef NATIVE_ERLANG_STACK
-    a.mov(ARG2, x86::qword_ptr(E));
-#else
-    a.pop(ARG2);
-#endif
-    a.jmp(labels[handle_error_shared]);
-}
-
 /* ARG3 = (HTOP + bytes needed) !!
  * ARG4 = Live registers */
 void BeamGlobalAssembler::emit_garbage_collect() {
+    emit_enter_frame();
+
     /* Convert ARG3 to words needed and move it to the correct argument slot */
     a.sub(ARG3, HTOP);
     a.shr(ARG3, imm(3));
@@ -127,7 +115,13 @@ void BeamGlobalAssembler::emit_garbage_collect() {
 
     /* Save our return address in c_p->i so we can tell where we crashed if we
      * do so during GC. */
-    a.mov(RET, x86::qword_ptr(x86::rsp));
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+        a.mov(RET, x86::qword_ptr(x86::rsp));
+    } else {
+        ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+        a.mov(RET, x86::qword_ptr(x86::rsp, 8));
+    }
+
     a.mov(x86::qword_ptr(c_p, offsetof(Process, i)), RET);
 
     emit_enter_runtime<Update::eStack | Update::eHeap>();
@@ -139,6 +133,7 @@ void BeamGlobalAssembler::emit_garbage_collect() {
     a.sub(FCALLS, RET);
 
     emit_leave_runtime<Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
     a.ret();
 }
@@ -149,11 +144,10 @@ void BeamGlobalAssembler::emit_garbage_collect() {
  *
  * Assumes that c_p->current points into the MFA of an export entry. */
 void BeamGlobalAssembler::emit_bif_export_trap() {
-    int export_offset = offsetof(Export, info.mfa);
-
     a.mov(RET, x86::qword_ptr(c_p, offsetof(Process, current)));
-    a.sub(RET, export_offset);
+    a.sub(RET, imm(offsetof(Export, info.mfa)));
 
+    emit_leave_frame();
     a.jmp(emit_setup_export_call(RET));
 }
 
@@ -197,6 +191,7 @@ void BeamGlobalAssembler::emit_export_trampoline() {
         a.mov(ARG3, x86::qword_ptr(c_p, offsetof(Process, i)));
         a.mov(ARG4, x86::qword_ptr(RET, func_offset));
 
+        emit_enter_frame();
         a.jmp(labels[call_bif_shared]);
     }
 
@@ -205,6 +200,7 @@ void BeamGlobalAssembler::emit_export_trampoline() {
 
     a.bind(error_handler);
     {
+        emit_enter_frame();
         emit_enter_runtime<Update::eReductions | Update::eStack |
                            Update::eHeap>();
 
@@ -219,6 +215,8 @@ void BeamGlobalAssembler::emit_export_trampoline() {
 
         a.test(RET, RET);
         a.je(labels[error_action_code]);
+
+        emit_leave_frame();
         a.jmp(emit_setup_export_call(RET));
     }
 }
@@ -227,13 +225,13 @@ void BeamGlobalAssembler::emit_export_trampoline() {
  * Get the error address implicitly by calling the shared fragment and using
  * the return address as the error address.
  */
-void BeamModuleAssembler::emit_handle_error() {
-    emit_handle_error(nullptr);
+void BeamModuleAssembler::emit_raise_exception() {
+    emit_raise_exception(nullptr);
 }
 
-void BeamModuleAssembler::emit_handle_error(const ErtsCodeMFA *exp) {
+void BeamModuleAssembler::emit_raise_exception(const ErtsCodeMFA *exp) {
     mov_imm(ARG4, (Uint)exp);
-    safe_fragment_call(ga->get_handle_error_shared_prologue());
+    safe_fragment_call(ga->get_raise_exception());
 
     /*
      * It is important that error address is not equal to a line
@@ -244,7 +242,8 @@ void BeamModuleAssembler::emit_handle_error(const ErtsCodeMFA *exp) {
     last_error_offset = getOffset() & -8;
 }
 
-void BeamModuleAssembler::emit_handle_error(Label I, const ErtsCodeMFA *exp) {
+void BeamModuleAssembler::emit_raise_exception(Label I,
+                                               const ErtsCodeMFA *exp) {
     a.lea(ARG2, x86::qword_ptr(I));
     mov_imm(ARG4, (Uint)exp);
 
@@ -252,36 +251,58 @@ void BeamModuleAssembler::emit_handle_error(Label I, const ErtsCodeMFA *exp) {
     /* The CP must be reserved for try/catch to work, so we'll fake a call with
      * the return address set to the error address. */
     a.push(ARG2);
+
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+#    ifdef ERLANG_FRAME_POINTERS
+        a.push(frame_pointer);
+#    endif
+    } else {
+        ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
+    }
 #endif
 
-    abs_jmp(ga->get_handle_error_shared());
+    abs_jmp(ga->get_raise_exception_shared());
 }
 
-/* This is an alias for handle_error */
+/* Raises the exception currently set up in the process structure. `freason`
+ * and `current` must be set prior to jumping here.
+ *
+ * Assumes that the stack is well-formed with a frame pointer if those are
+ * enabled. */
 void BeamGlobalAssembler::emit_error_action_code() {
     mov_imm(ARG2, 0);
     mov_imm(ARG4, 0);
 
-    a.jmp(labels[handle_error_shared]);
+    a.jmp(labels[raise_exception_shared]);
 }
 
-void BeamGlobalAssembler::emit_handle_error_shared_prologue() {
-    /*
-     * We must align the return address to make it a proper tagged CP.
-     * This is safe because we will never actually return to the
-     * return address.
-     */
+/* Helper function for throwing exceptions from global fragments.
+ *
+ * Assumes that the next item on the _machine stack_ is a return address: we
+ * must not jump here while in a frame. */
+void BeamGlobalAssembler::emit_raise_exception() {
+    /* We must align the return address to make it a proper tagged CP, in case
+     * we were called with `safe_fragment_call`. This is safe because we will
+     * never actually return to the return address. */
     a.pop(ARG2);
     a.and_(ARG2, imm(-8));
 
 #ifdef NATIVE_ERLANG_STACK
     a.push(ARG2);
+
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+#    ifdef ERLANG_FRAME_POINTERS
+        a.push(frame_pointer);
+#    endif
+    } else {
+        ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
+    }
 #endif
 
-    a.jmp(labels[handle_error_shared]);
+    a.jmp(labels[raise_exception_shared]);
 }
 
-void BeamGlobalAssembler::emit_handle_error_shared() {
+void BeamGlobalAssembler::emit_raise_exception_shared() {
     Label crash = a.newLabel();
 
     emit_enter_runtime<Update::eStack | Update::eHeap>();
diff --git a/erts/emulator/beam/jit/x86/beam_asm_module.cpp b/erts/emulator/beam/jit/x86/beam_asm_module.cpp
index 0da710d878..1f63fd1719 100644
--- a/erts/emulator/beam/jit/x86/beam_asm_module.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm_module.cpp
@@ -134,9 +134,11 @@ BeamModuleAssembler::BeamModuleAssembler(BeamGlobalAssembler *ga,
         a.ret();
 
         a.align(kAlignCode, 16);
+        ASSERT(a.offset() - code.labelOffsetFromBase(genericBPTramp) == 16 * 1);
         abs_jmp(ga->get_call_nif_early());
 
         a.align(kAlignCode, 16);
+        ASSERT(a.offset() - code.labelOffsetFromBase(genericBPTramp) == 16 * 2);
         aligned_call(ga->get_generic_bp_local());
         a.ret();
 
@@ -347,6 +349,7 @@ void BeamGlobalAssembler::emit_i_func_info_shared() {
 
     a.mov(x86::qword_ptr(c_p, offsetof(Process, freason)), EXC_FUNCTION_CLAUSE);
     a.mov(x86::qword_ptr(c_p, offsetof(Process, current)), ARG1);
+
     a.jmp(labels[error_action_code]);
 }
 
diff --git a/erts/emulator/beam/jit/x86/instr_arith.cpp b/erts/emulator/beam/jit/x86/instr_arith.cpp
index 5615230551..3bd98604c6 100644
--- a/erts/emulator/beam/jit/x86/instr_arith.cpp
+++ b/erts/emulator/beam/jit/x86/instr_arith.cpp
@@ -35,7 +35,7 @@ void BeamModuleAssembler::emit_bif_arg_error(std::vector<ArgVal> args,
     comment("handle_error");
     for (unsigned i = 0; i < args.size(); i++)
         mov_arg(ArgVal(ArgVal::x, i), args[i]);
-    emit_handle_error(mfa);
+    emit_raise_exception(mfa);
 }
 
 void BeamModuleAssembler::emit_is_small(Label fail, x86::Gp Reg) {
@@ -69,6 +69,7 @@ void BeamModuleAssembler::emit_is_both_small(Label fail, x86::Gp A, x86::Gp B) {
 void BeamGlobalAssembler::emit_increment_body_shared() {
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime();
 
     a.mov(ARG1, c_p);
@@ -76,16 +77,16 @@ void BeamGlobalAssembler::emit_increment_body_shared() {
     runtime_call<3>(erts_mixed_plus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
-
     a.ret();
 
     a.bind(error);
     {
         mov_imm(ARG4, 0);
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
@@ -120,6 +121,7 @@ void BeamGlobalAssembler::emit_plus_body_shared() {
 
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime();
 
     /* Save original arguments for the error path. */
@@ -130,10 +132,10 @@ void BeamGlobalAssembler::emit_plus_body_shared() {
     runtime_call<3>(erts_mixed_plus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
-
     a.ret();
 
     a.bind(error);
@@ -145,11 +147,12 @@ void BeamGlobalAssembler::emit_plus_body_shared() {
         a.mov(getXRef(1), ARG2);
 
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
 void BeamGlobalAssembler::emit_plus_guard_shared() {
+    emit_enter_frame();
     emit_enter_runtime();
 
     a.mov(ARG1, c_p);
@@ -157,6 +160,7 @@ void BeamGlobalAssembler::emit_plus_guard_shared() {
     runtime_call<3>(erts_mixed_plus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     /* Set ZF if the addition failed. */
     emit_test_the_non_value(RET);
@@ -200,6 +204,7 @@ void BeamGlobalAssembler::emit_minus_body_shared() {
 
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime();
 
     /* Save original arguments for the error path. */
@@ -210,10 +215,10 @@ void BeamGlobalAssembler::emit_minus_body_shared() {
     runtime_call<3>(erts_mixed_minus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
-
     a.ret();
 
     a.bind(error);
@@ -225,11 +230,12 @@ void BeamGlobalAssembler::emit_minus_body_shared() {
         a.mov(getXRef(1), ARG2);
 
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
 void BeamGlobalAssembler::emit_minus_guard_shared() {
+    emit_enter_frame();
     emit_enter_runtime();
 
     a.mov(ARG1, c_p);
@@ -237,6 +243,7 @@ void BeamGlobalAssembler::emit_minus_guard_shared() {
     runtime_call<3>(erts_mixed_minus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     /* Set ZF if the addition failed. */
     emit_test_the_non_value(RET);
@@ -288,6 +295,7 @@ void BeamGlobalAssembler::emit_unary_minus_body_shared() {
 
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime();
 
     /* Save original arguments for the error path. */
@@ -297,10 +305,10 @@ void BeamGlobalAssembler::emit_unary_minus_body_shared() {
     runtime_call<2>(erts_unary_minus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
-
     a.ret();
 
     a.bind(error);
@@ -310,11 +318,12 @@ void BeamGlobalAssembler::emit_unary_minus_body_shared() {
         a.mov(getXRef(0), ARG1);
 
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
 void BeamGlobalAssembler::emit_unary_minus_guard_shared() {
+    emit_enter_frame();
     emit_enter_runtime();
 
     a.mov(ARG1, c_p);
@@ -322,6 +331,7 @@ void BeamGlobalAssembler::emit_unary_minus_guard_shared() {
     runtime_call<2>(erts_unary_minus);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     /* Set ZF if the negation failed. */
     emit_test_the_non_value(RET);
@@ -368,6 +378,8 @@ void BeamModuleAssembler::emit_i_unary_minus(const ArgVal &Src,
 void BeamGlobalAssembler::emit_int_div_rem_guard_shared() {
     Label exit = a.newLabel(), generic = a.newLabel();
 
+    emit_enter_frame();
+
     a.cmp(ARG4, imm(SMALL_ZERO));
     a.je(exit);
 
@@ -431,7 +443,10 @@ void BeamGlobalAssembler::emit_int_div_rem_guard_shared() {
     /* Return with a potential error in ZF. It will be set if we came here from
      * the guard against SMALL_ZERO or if we're returning THE_NON_VALUE. */
     a.bind(exit);
-    a.ret();
+    {
+        emit_leave_frame();
+        a.ret();
+    }
 }
 
 /* ARG1 = LHS, ARG4 (!) = RHS, ARG5 = error MFA
@@ -442,7 +457,9 @@ void BeamGlobalAssembler::emit_int_div_rem_guard_shared() {
  * Quotient is returned in RAX, remainder in RDX. */
 void BeamGlobalAssembler::emit_int_div_rem_body_shared() {
     Label div_zero = a.newLabel(), generic_div = a.newLabel(),
-          generic_error = a.newLabel(), error = a.newLabel();
+          generic_error = a.newLabel();
+
+    emit_enter_frame();
 
     a.cmp(ARG4, imm(SMALL_ZERO));
     a.je(div_zero);
@@ -478,6 +495,7 @@ void BeamGlobalAssembler::emit_int_div_rem_body_shared() {
     a.cmp(ARG6, imm(1));
     a.short_().jge(generic_div);
 
+    emit_leave_frame();
     a.ret();
 
     a.bind(generic_div);
@@ -497,6 +515,7 @@ void BeamGlobalAssembler::emit_int_div_rem_body_shared() {
         runtime_call<5>(erts_int_div_rem);
 
         emit_leave_runtime();
+        emit_leave_frame();
 
         a.test(RET, RET);
 
@@ -510,6 +529,8 @@ void BeamGlobalAssembler::emit_int_div_rem_body_shared() {
 
     a.bind(div_zero);
     {
+        emit_leave_frame();
+
         /* Set up a badarith exception and place the original arguments in
          * x-registers. */
         a.mov(x86::qword_ptr(c_p, offsetof(Process, freason)),
@@ -519,7 +540,7 @@ void BeamGlobalAssembler::emit_int_div_rem_body_shared() {
         a.mov(getXRef(1), ARG4);
 
         a.mov(ARG4, ARG5);
-        a.short_().jmp(error);
+        a.jmp(labels[raise_exception]);
     }
 
     a.bind(generic_error);
@@ -532,12 +553,8 @@ void BeamGlobalAssembler::emit_int_div_rem_body_shared() {
 
         /* Read saved MFA. */
         a.mov(ARG4, TMP_MEM3q);
-
-        /* Fall through to `error` */
+        a.jmp(labels[raise_exception]);
     }
-
-    a.bind(error);
-    emit_handle_error_shared_prologue();
 }
 
 void BeamModuleAssembler::emit_div_rem(const ArgVal &Fail,
@@ -647,6 +664,8 @@ void BeamModuleAssembler::emit_i_m_div(const ArgVal &Fail,
 void BeamGlobalAssembler::emit_times_guard_shared() {
     Label generic = a.newLabel();
 
+    emit_enter_frame();
+
     /* Are both smalls? */
     a.mov(ARG2d, ARG1d);
     a.and_(ARG2d, ARG4d);
@@ -663,6 +682,7 @@ void BeamGlobalAssembler::emit_times_guard_shared() {
 
     a.or_(RET, imm(_TAG_IMMED1_SMALL)); /* Always sets ZF to false */
 
+    emit_leave_frame();
     a.ret();
 
     a.bind(generic);
@@ -675,6 +695,7 @@ void BeamGlobalAssembler::emit_times_guard_shared() {
         runtime_call<3>(erts_mixed_times);
 
         emit_leave_runtime();
+        emit_leave_frame();
 
         emit_test_the_non_value(RET); /* Sets ZF for use in caller */
 
@@ -693,6 +714,8 @@ void BeamGlobalAssembler::emit_times_body_shared() {
 
     Label generic = a.newLabel(), error = a.newLabel();
 
+    emit_enter_frame();
+
     /* Are both smalls? */
     a.mov(ARG2d, ARG1d);
     a.and_(ARG2d, ARG4d);
@@ -709,6 +732,7 @@ void BeamGlobalAssembler::emit_times_body_shared() {
 
     a.or_(RET, imm(_TAG_IMMED1_SMALL));
 
+    emit_leave_frame();
     a.ret();
 
     a.bind(generic);
@@ -725,10 +749,10 @@ void BeamGlobalAssembler::emit_times_body_shared() {
         runtime_call<3>(erts_mixed_times);
 
         emit_leave_runtime();
+        emit_leave_frame();
 
         emit_test_the_non_value(RET);
         a.short_().je(error);
-
         a.ret();
     }
 
@@ -741,7 +765,7 @@ void BeamGlobalAssembler::emit_times_body_shared() {
         a.mov(getXRef(1), ARG2);
 
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
@@ -769,6 +793,7 @@ void BeamModuleAssembler::emit_i_times(const ArgVal &Fail,
  * Result is returned in RET. Error is indicated by ZF. */
 template<typename T>
 void BeamGlobalAssembler::emit_bitwise_fallback_guard(T(*func_ptr)) {
+    emit_enter_frame();
     emit_enter_runtime();
 
     a.mov(ARG1, c_p);
@@ -777,6 +802,7 @@ void BeamGlobalAssembler::emit_bitwise_fallback_guard(T(*func_ptr)) {
     runtime_call<3>(func_ptr);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.ret();
@@ -790,6 +816,7 @@ void BeamGlobalAssembler::emit_bitwise_fallback_body(T(*func_ptr),
                                                      const ErtsCodeMFA *mfa) {
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime();
 
     /* Save original arguments for the error path. */
@@ -802,10 +829,10 @@ void BeamGlobalAssembler::emit_bitwise_fallback_body(T(*func_ptr),
     runtime_call<3>(func_ptr);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
-
     a.ret();
 
     a.bind(error);
@@ -817,7 +844,7 @@ void BeamGlobalAssembler::emit_bitwise_fallback_body(T(*func_ptr),
         a.mov(getXRef(1), ARG2);
 
         a.mov(ARG4, imm(mfa));
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
@@ -964,6 +991,8 @@ void BeamModuleAssembler::emit_i_bxor(const ArgVal &Fail,
  *
  * Result is returned in RET. Error is indicated by ZF. */
 void BeamGlobalAssembler::emit_i_bnot_guard_shared() {
+    emit_enter_frame();
+
     /* Undo the speculative inversion in module code */
     a.xor_(RET, imm(~_TAG_IMMED1_MASK));
 
@@ -974,6 +1003,7 @@ void BeamGlobalAssembler::emit_i_bnot_guard_shared() {
     runtime_call<2>(erts_bnot);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.ret();
@@ -987,6 +1017,8 @@ void BeamGlobalAssembler::emit_i_bnot_body_shared() {
 
     Label error = a.newLabel();
 
+    emit_enter_frame();
+
     /* Undo the speculative inversion in module code */
     a.xor_(RET, imm(~_TAG_IMMED1_MASK));
 
@@ -1000,10 +1032,10 @@ void BeamGlobalAssembler::emit_i_bnot_body_shared() {
     runtime_call<2>(erts_bnot);
 
     emit_leave_runtime();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
-
     a.ret();
 
     a.bind(error);
@@ -1013,7 +1045,7 @@ void BeamGlobalAssembler::emit_i_bnot_body_shared() {
         a.mov(getXRef(0), ARG1);
 
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error_shared_prologue();
+        a.jmp(labels[raise_exception]);
     }
 }
 
diff --git a/erts/emulator/beam/jit/x86/instr_bif.cpp b/erts/emulator/beam/jit/x86/instr_bif.cpp
index ae329e3f0c..5c61620e08 100644
--- a/erts/emulator/beam/jit/x86/instr_bif.cpp
+++ b/erts/emulator/beam/jit/x86/instr_bif.cpp
@@ -34,6 +34,7 @@ extern "C"
  *
  * Result is returned in RET, error is indicated by ZF. */
 void BeamGlobalAssembler::emit_i_bif_guard_shared() {
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions>();
 
     a.mov(ARG1, c_p);
@@ -42,6 +43,7 @@ void BeamGlobalAssembler::emit_i_bif_guard_shared() {
     runtime_call(ARG4, 3);
 
     emit_leave_runtime<Update::eReductions>();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.ret();
@@ -53,6 +55,7 @@ void BeamGlobalAssembler::emit_i_bif_guard_shared() {
 void BeamGlobalAssembler::emit_i_bif_body_shared() {
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions>();
 
     /* Save current BIF and argument vector for the error path. */
@@ -68,6 +71,7 @@ void BeamGlobalAssembler::emit_i_bif_body_shared() {
     a.short_().je(error);
 
     emit_leave_runtime<Update::eReductions>();
+    emit_leave_frame();
 
     a.ret();
 
@@ -87,9 +91,10 @@ void BeamGlobalAssembler::emit_i_bif_body_shared() {
         runtime_call<1>(ubif2mfa);
 
         emit_leave_runtime<Update::eReductions>();
+        emit_leave_frame();
 
         a.mov(ARG4, RET);
-        a.jmp(labels[handle_error_shared_prologue]);
+        a.jmp(labels[raise_exception]);
     }
 }
 
@@ -238,6 +243,8 @@ x86::Mem BeamGlobalAssembler::emit_i_length_common(Label fail, int state_size) {
     trap_state = getXRef(0);
     trap_state.setIndex(ARG2, 3);
 
+    emit_enter_frame();
+
     /* Save arguments for error/trapping path. */
     a.mov(TMP_MEM1q, ARG2);
     a.mov(TMP_MEM2q, ARG3);
@@ -249,6 +256,7 @@ x86::Mem BeamGlobalAssembler::emit_i_length_common(Label fail, int state_size) {
     runtime_call<2>(erts_trapping_length_1);
 
     emit_leave_runtime<Update::eReductions>();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(trap);
@@ -268,7 +276,7 @@ x86::Mem BeamGlobalAssembler::emit_i_length_common(Label fail, int state_size) {
         a.add(ARG2, imm(state_size));
 
         /* We'll find our way back through the entry address (ARG3). */
-        emit_discard_cp();
+        a.add(x86::rsp, imm(sizeof(UWord)));
 
         a.mov(x86::qword_ptr(c_p, offsetof(Process, current)), imm(0));
         a.mov(x86::qword_ptr(c_p, offsetof(Process, arity)), ARG2);
@@ -298,7 +306,7 @@ void BeamGlobalAssembler::emit_i_length_body_shared() {
         a.mov(getXRef(0), ARG1);
 
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error();
+        a.jmp(labels[raise_exception]);
     }
 }
 
@@ -312,7 +320,7 @@ void BeamGlobalAssembler::emit_i_length_guard_shared() {
 
     a.bind(error);
     {
-        mov_imm(RET, 0);
+        a.sub(RET, RET);
         a.ret();
     }
 }
@@ -334,7 +342,7 @@ void BeamModuleAssembler::emit_i_length(const ArgVal &Fail,
         safe_fragment_call(ga->get_i_length_guard_shared());
         a.je(labels[Fail.getValue()]);
     } else {
-        fragment_call(ga->get_i_length_body_shared());
+        safe_fragment_call(ga->get_i_length_body_shared());
     }
 
     mov_arg(Dst, RET);
@@ -380,10 +388,9 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
 
     x86::Gp I = HTOP, exp = FCALLS;
 
-    Label error = a.newLabel(), trace = a.newLabel(), trap = a.newLabel(),
-          yield = a.newLabel(), call_save_calls = a.newLabel(),
-          call_bif = a.newLabel(), gc_after_bif_call = a.newLabel(),
-          check_bif_return = a.newLabel();
+    Label trace = a.newLabel(), yield = a.newLabel();
+
+    emit_enter_frame();
 
     /* Check if we should trace this bif call */
     a.cmp(x86::dword_ptr(ARG4, offsetof(Export, is_bif_traced)), imm(0));
@@ -393,6 +400,9 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
     a.jle(yield);
 
     {
+        Label call_bif = a.newLabel(), call_save_calls = a.newLabel(),
+              check_bif_return = a.newLabel(), gc_after_bif_call = a.newLabel();
+
         emit_enter_runtime<Update::eReductions | Update::eStack |
                            Update::eHeap>();
 
@@ -420,54 +430,56 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
             a.bind(skip_msacc);
         }
 #endif
+
         /* Check if we need to call save_calls */
         a.cmp(active_code_ix, imm(ERTS_SAVE_CALLS_CODE_IX));
         a.je(call_save_calls);
-        a.bind(call_bif);
 
-        a.mov(ARG1, x86::qword_ptr(c_p, offsetof(Process, mbuf)));
-        a.mov(TMP_MEM1q, ARG1);
+        a.bind(call_bif);
+        {
+            a.mov(ARG1, x86::qword_ptr(c_p, offsetof(Process, mbuf)));
+            a.mov(TMP_MEM1q, ARG1);
 
-        /* ARG3 and RET have been set earlier. */
-        a.mov(ARG1, c_p);
-        load_x_reg_array(ARG2);
+            /* ARG3 and RET have been set earlier. */
+            a.mov(ARG1, c_p);
+            load_x_reg_array(ARG2);
 
 #if defined(DEBUG) || defined(ERTS_ENABLE_LOCK_CHECK)
-        a.mov(ARG4, RET);
-        runtime_call<4>(debug_call_light_bif);
+            a.mov(ARG4, RET);
+            runtime_call<4>(debug_call_light_bif);
 #else
-        runtime_call(RET, 3);
+            runtime_call(RET, 3);
 #endif
 
 #ifdef ERTS_MSACC_EXTENDED_STATES
-        {
             Label skip_msacc = a.newLabel();
 
             a.cmp(erts_msacc_cache, imm(0));
             a.short_().je(skip_msacc);
-
-            /* update cache if it was changed in the bif.
-               TMP_MEM1q is already taken to save ARG1 above */
-            a.mov(TMP_MEM2q, RET);
-            a.lea(ARG1, erts_msacc_cache);
-            runtime_call<1>(erts_msacc_update_cache);
-            a.mov(RET, TMP_MEM2q);
-
-            /* set state to emulator if msacc has been enabled */
-            a.cmp(erts_msacc_cache, imm(0));
-            a.short_().je(skip_msacc);
-            a.mov(ARG1, erts_msacc_cache);
-            a.mov(ARG2, imm(ERTS_MSACC_STATE_EMULATOR));
-            a.mov(ARG3, imm(1));
-            runtime_call<3>(erts_msacc_set_state_m__);
-            a.mov(RET, TMP_MEM2q);
-
+            {
+                /* update cache if it was changed in the bif.
+                TMP_MEM1q is already taken to save ARG1 above */
+                a.mov(TMP_MEM2q, RET);
+                a.lea(ARG1, erts_msacc_cache);
+                runtime_call<1>(erts_msacc_update_cache);
+                a.mov(RET, TMP_MEM2q);
+
+                /* set state to emulator if msacc has been enabled */
+                a.cmp(erts_msacc_cache, imm(0));
+                a.short_().je(skip_msacc);
+                a.mov(ARG1, erts_msacc_cache);
+                a.mov(ARG2, imm(ERTS_MSACC_STATE_EMULATOR));
+                a.mov(ARG3, imm(1));
+                runtime_call<3>(erts_msacc_set_state_m__);
+                a.mov(RET, TMP_MEM2q);
+            }
             a.bind(skip_msacc);
-        }
 #endif
+        }
 
         /* ERTS_IS_GC_DESIRED_INTERNAL */
         {
+            /* ERTS_IS_GC_DESIRED_INTERNAL */
             a.mov(ARG2, x86::qword_ptr(c_p, offsetof(Process, stop)));
             a.mov(ARG3, RET);
             a.mov(ARG5, x86::qword_ptr(c_p, offsetof(Process, htop)));
@@ -490,104 +502,79 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
             a.jl(gc_after_bif_call);
         }
 
-        /*
-           ARG2 is set to E
-           ARG3 is set to bif return
-           ARG5 is set to HTOP
+        /* ! FALL THROUGH ! */
 
-           HTOP is exp
-           E_saved|E is I
-        */
         a.bind(check_bif_return);
-        emit_test_the_non_value(ARG3);
-
-        /* NOTE: Short won't reach if JIT_HARD_DEBUG is defined. */
-        a.je(trap);
-
-        a.mov(HTOP, ARG5);
-#ifdef NATIVE_ERLANG_STACK
-        a.mov(E_saved, ARG2);
-#else
-        a.mov(E, ARG2);
-#endif
-
-        /* We must update the active code index in case another process has
-         * loaded new code, as the result of this BIF may be observable on both
-         * ends.
-         *
-         * It doesn't matter whether the BIF modifies anything; if process A
-         * loads new code and calls erlang:monotonic_time/0 soon after, we'd
-         * break the illusion of atomic upgrades if process B still ran old code
-         * after seeing a later timestamp from its own call to
-         * erlang:monotonic_time/0. */
-
-        emit_leave_runtime<Update::eReductions | Update::eCodeIndex>();
-
-        a.mov(getXRef(0), ARG3);
-        a.ret();
-
-        a.bind(call_save_calls);
         {
-            /* Stash the bif function pointer */
-            a.mov(TMP_MEM1q, RET);
-
-            /* Setup the arguments to call */
-            a.mov(ARG1, c_p);
-            a.mov(ARG2, exp);
-            runtime_call<2>(save_calls);
-
-            /* Restore RET and ARG3 to the values expected
-               by the bif call */
-            a.mov(RET, TMP_MEM1q);
-            a.mov(ARG3, I);
-            a.jmp(call_bif);
-        }
+            Label trap = a.newLabel(), error = a.newLabel();
 
-        a.bind(trap);
-        {
-            a.cmp(x86::qword_ptr(c_p, offsetof(Process, freason)), imm(TRAP));
-            a.short_().jne(error);
+            emit_test_the_non_value(ARG3);
+            a.short_().je(trap);
 
-            emit_leave_runtime<Update::eHeap | Update::eStack |
-                               Update::eReductions | Update::eCodeIndex>();
+            /* We must update the active code index in case another process has
+             * loaded new code, as the result of this BIF may be observable on
+             * both ends.
+             *
+             * It doesn't matter whether the BIF modifies anything; if process
+             * A loads new code and calls erlang:monotonic_time/0 soon after,
+             * we'd break the illusion of atomic upgrades if process B still
+             * ran old code after seeing a later timestamp from its own call to
+             * erlang:monotonic_time/0. */
+            emit_leave_runtime<Update::eReductions | Update::eStack |
+                               Update::eHeap | Update::eCodeIndex>();
+            emit_leave_frame();
+
+            a.mov(getXRef(0), ARG3);
+            a.ret();
+
+            a.bind(trap);
+            {
+                /* raise_exception_shared expects the entry address in ARG2 and
+                 * MFA in ARG4. We have to set these up *before* leaving the
+                 * runtime as we've saved our arguments in callee-save
+                 * registers that will be clobbered by `emit_leave_runtime` */
+                a.mov(ARG2, I);
+                a.lea(ARG4, x86::qword_ptr(exp, offsetof(Export, info.mfa)));
+
+                emit_leave_runtime<Update::eReductions | Update::eStack |
+                                   Update::eHeap | Update::eCodeIndex>();
+
+                a.cmp(x86::qword_ptr(c_p, offsetof(Process, freason)),
+                      imm(TRAP));
+                a.short_().jne(error);
 
 #if !defined(NATIVE_ERLANG_STACK)
-            a.pop(getCPRef());
+                a.pop(getCPRef());
 #endif
 
-            /* Trap out, our return address is on the Erlang stack.
-             *
-             * The BIF_TRAP macros all set up c_p->arity and c_p->current, so
-             * we can use a simplified context switch. */
-            a.mov(ARG3, x86::qword_ptr(c_p, offsetof(Process, i)));
-            a.jmp(labels[context_switch_simplified]);
-        }
-
-        a.bind(error);
-        {
-            a.mov(ARG4, exp);
-            a.mov(RET, I);
-
-            /* Update::eCodeIndex clobbers ARG1 + ARG2 */
-            emit_leave_runtime<Update::eHeap | Update::eStack |
-                               Update::eReductions | Update::eCodeIndex>();
-
-            /* handle_error_shared needs the entry address in ARG2 */
-            a.mov(ARG2, RET);
+                /* Trap out, our return address is on the Erlang stack.
+                 *
+                 * The BIF_TRAP macros all set up c_p->arity and c_p->current,
+                 * so we can use a simplified context switch. */
+                a.mov(ARG3, x86::qword_ptr(c_p, offsetof(Process, i)));
+                a.jmp(labels[context_switch_simplified]);
+            }
 
+            a.bind(error);
+            {
 #if !defined(NATIVE_ERLANG_STACK)
-            /* Discard the continuation pointer as it will never be used. */
-            emit_discard_cp();
+                /* Discard the continuation pointer as it will never be
+                 * used. */
+                emit_unwind_frame();
 #endif
 
-            /* get_handle_error expects current PC in ARG2 and MFA in ARG4. */
-            a.lea(ARG4, x86::qword_ptr(ARG4, offsetof(Export, info.mfa)));
-
-            /* Overwrite the return address with the entry address to ensure
-             * that only the entry address ends up in the stack trace. */
-            a.mov(x86::qword_ptr(E), ARG2);
-
-            a.jmp(labels[handle_error_shared]);
+                /* Overwrite the return address with the entry address to
+                 * ensure that only the entry address ends up in the stack
+                 * trace. */
+                if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+                    a.mov(x86::qword_ptr(E), ARG2);
+                } else {
+                    ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+                    a.mov(x86::qword_ptr(E, 8), ARG2);
+                }
+
+                a.jmp(labels[raise_exception_shared]);
+            }
         }
 
         a.bind(gc_after_bif_call);
@@ -603,15 +590,32 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
             a.mov(ARG2, x86::qword_ptr(c_p, offsetof(Process, stop)));
             a.jmp(check_bif_return);
         }
+
+        a.bind(call_save_calls);
+        {
+            /* Stash the bif function pointer. */
+            a.mov(TMP_MEM1q, RET);
+
+            /* Setup the arguments to call. */
+            a.mov(ARG1, c_p);
+            a.mov(ARG2, exp);
+            runtime_call<2>(save_calls);
+
+            /* Restore RET and ARG3 to the values expected by the bif call. */
+            a.mov(RET, TMP_MEM1q);
+            a.mov(ARG3, I);
+            a.jmp(call_bif);
+        }
     }
 
     a.bind(trace);
     {
-        /* Call the export entry instead of the BIF. If we use the
-         * native stack as the Erlang stack our return address is
-         * already on the Erlang stack. Otherwise we will have to move
-         * the return address from the native stack to the Erlang
-         * stack. */
+        /* Tail call the export entry instead of the BIF. If we use the native
+         * stack as the Erlang stack our return address is already on the
+         * Erlang stack. Otherwise we will have to move the return address from
+         * the native stack to the Erlang stack. */
+
+        emit_leave_frame();
 
 #if !defined(NATIVE_ERLANG_STACK)
         /* The return address must be on the Erlang stack. */
@@ -630,7 +634,7 @@ void BeamGlobalAssembler::emit_call_light_bif_shared() {
         a.mov(x86::qword_ptr(c_p, offsetof(Process, current)), ARG4);
 
         /* We'll find our way back through ARG3 (entry address). */
-        emit_discard_cp();
+        emit_unwind_frame();
 
         a.jmp(labels[context_switch_simplified]);
     }
@@ -696,6 +700,9 @@ void BeamGlobalAssembler::emit_bif_nif_epilogue(void) {
 
     comment("Do return and dispatch to it");
     a.mov(getXRef(0), RET);
+
+    emit_leave_frame();
+
 #ifdef NATIVE_ERLANG_STACK
     a.ret();
 #else
@@ -745,7 +752,7 @@ void BeamGlobalAssembler::emit_bif_nif_epilogue(void) {
 
         a.mov(ARG2, RET);
         a.mov(ARG4, x86::qword_ptr(c_p, offsetof(Process, current)));
-        a.jmp(labels[handle_error_shared]);
+        a.jmp(labels[raise_exception_shared]);
     }
 }
 
@@ -831,11 +838,22 @@ void BeamGlobalAssembler::emit_dispatch_bif(void) {
 void BeamModuleAssembler::emit_call_bif(const ArgVal &Func) {
     int mfa_offset = -(int)sizeof(ErtsCodeMFA);
 
-    a.lea(ARG2, x86::qword_ptr(currLabel, mfa_offset));
-    a.lea(ARG3, x86::qword_ptr(currLabel));
-    mov_arg(ARG4, Func);
+    Label entry = a.newLabel();
+
+    /* This is _always_ the first instruction in a function and replaces the
+     * yield test that would otherwise add a frame, so we must add a frame
+     * here. */
+    emit_enter_frame();
+
+    /* Yield entry point; must be after entering frame. */
+    a.bind(entry);
+    {
+        a.lea(ARG2, x86::qword_ptr(currLabel, mfa_offset));
+        a.lea(ARG3, x86::qword_ptr(entry));
+        mov_arg(ARG4, Func);
 
-    abs_jmp(ga->get_call_bif_shared());
+        abs_jmp(ga->get_call_bif_shared());
+    }
 }
 
 void BeamModuleAssembler::emit_call_bif_mfa(const ArgVal &M,
@@ -879,11 +897,14 @@ void BeamGlobalAssembler::emit_call_nif_early() {
 
     emit_leave_runtime();
 
-    /* We won't return to the original code. */
-    emit_discard_cp();
+    /* We won't return to the original code. We KNOW that the stack points at
+     * a return address. */
+    a.add(x86::rsp, imm(8));
 
     /* Emulate `emit_call_nif`, loading the current (phony) instruction
-     * pointer into ARG2. */
+     * pointer into ARG2. We push a (redundant) frame pointer to match the
+     * corresponding `emit_leave_frame` in `call_nif_shared`. */
+    emit_enter_frame();
     a.mov(ARG3, RET);
     a.jmp(labels[call_nif_shared]);
 }
@@ -938,42 +959,71 @@ void BeamGlobalAssembler::emit_dispatch_nif(void) {
     a.jmp(labels[call_nif_shared]);
 }
 
+void BeamGlobalAssembler::emit_call_nif_yield_helper() {
+    Label yield = a.newLabel();
+
+    a.dec(FCALLS);
+    a.short_().jl(yield);
+    a.jmp(labels[call_nif_shared]);
+
+    a.bind(yield);
+    {
+        int mfa_offset = -(int)sizeof(ErtsCodeMFA);
+        int arity_offset = mfa_offset + (int)offsetof(ErtsCodeMFA, arity);
+
+        a.mov(ARG1, x86::qword_ptr(ARG3, arity_offset));
+        a.mov(x86::qword_ptr(c_p, offsetof(Process, arity)), ARG1);
+
+        a.lea(ARG1, x86::qword_ptr(ARG3, mfa_offset));
+        a.mov(x86::qword_ptr(c_p, offsetof(Process, current)), ARG1);
+
+        /* Yield to `dispatch` rather than `entry` to avoid pushing too many
+         * frames to the stack. See `emit_call_nif` for details. */
+        a.add(ARG3, imm(BEAM_ASM_FUNC_PROLOGUE_SIZE + sizeof(UWord[4])));
+        a.jmp(labels[context_switch_simplified]);
+    }
+}
+
 /* WARNING: This stub is memcpy'd, so all code herein must be explicitly
  * position-independent. */
 void BeamModuleAssembler::emit_call_nif(const ArgVal &Func,
                                         const ArgVal &NifMod,
                                         const ArgVal &DirtyFunc) {
-    Label dispatch = a.newLabel();
-    uint64_t val;
-
-    /* The start of this function has to mimic the layout of ErtsNativeFunc. */
-    a.jmp(dispatch); /* call_op */
-
-    a.align(kAlignCode, 8);
-    /* ErtsNativeFunc.dfunc */
-    val = Func.getValue();
-    a.embed(&val, sizeof(val));
-    /* ErtsNativeFunc.m */
-    val = NifMod.getValue();
-    a.embed(&val, sizeof(val));
-    /* ErtsNativeFunc.func */
-    val = DirtyFunc.getValue();
-    a.embed(&val, sizeof(val));
-
-    /* The real code starts here */
-    a.bind(dispatch);
-    {
-        Label yield = a.newLabel();
+    Label entry = a.newLabel(), dispatch = a.newLabel();
 
-        a.lea(ARG3, x86::qword_ptr(currLabel));
+#ifdef DEBUG
+    size_t entry_offset = a.offset();
+#endif
 
-        a.dec(FCALLS);
-        a.jl(yield);
+    ASSERT(BEAM_ASM_FUNC_PROLOGUE_SIZE ==
+           (a.offset() - code.labelOffsetFromBase(currLabel)));
 
-        pic_jmp(ga->get_call_nif_shared());
+    /* The start of this function must mimic the layout of ErtsNativeFunc.
+     *
+     * We jump here on the very first entry, pushing a stack frame if
+     * applicable. */
+    a.bind(entry);
+    {
+        emit_enter_frame();
+        a.short_().jmp(dispatch); /* call_op */
+
+        a.align(kAlignCode, 8);
+        /* ErtsNativeFunc.dfunc */
+        a.embedUInt64(Func.getValue());
+        /* ErtsNativeFunc.m */
+        a.embedUInt64(NifMod.getValue());
+        /* ErtsNativeFunc.func */
+        a.embedUInt64(DirtyFunc.getValue());
+    }
 
-        a.bind(yield);
-        pic_jmp(ga->get_context_switch());
+    /* `emit_call_nif_yield_helper` relies on this to compute the address of
+     * `dispatch` */
+    ASSERT(a.offset() == entry_offset + sizeof(UWord[4]));
+
+    a.bind(dispatch);
+    {
+        a.lea(ARG3, x86::qword_ptr(currLabel));
+        pic_jmp(ga->get_call_nif_yield_helper());
     }
 }
 
@@ -996,15 +1046,18 @@ void BeamGlobalAssembler::emit_i_load_nif_shared() {
 
     a.cmp(RET, RET_NIF_yield);
     a.short_().je(yield);
+
+    /* We entered the frame in module code. */
+    emit_leave_frame();
+
     a.cmp(RET, RET_NIF_success);
     a.short_().jne(error);
-
     a.ret();
 
     a.bind(error);
     {
         a.mov(ARG4, imm(&bif_mfa));
-        emit_handle_error();
+        a.jmp(labels[raise_exception]);
     }
 
     a.bind(yield);
@@ -1014,10 +1067,49 @@ void BeamGlobalAssembler::emit_i_load_nif_shared() {
     }
 }
 
+static ErtsCodePtr get_on_load_address(Process *c_p, Eterm module) {
+    const Module *modp = erts_get_module(module, erts_active_code_ix());
+
+    if (modp && modp->on_load) {
+        const BeamCodeHeader *hdr = (modp->on_load)->code_hdr;
+
+        if (hdr) {
+            return erts_codeinfo_to_code(hdr->on_load);
+        }
+    }
+
+    c_p->freason = BADARG;
+
+    return NULL;
+}
+
+/* Implements the internal and undocumented erlang:call_on_load_function/1,
+ * which is tricky to implement in the face of frame pointers. */
+void BeamModuleAssembler::emit_i_call_on_load_function() {
+    static ErtsCodeMFA mfa = {am_erlang, am_call_on_load_function, 1};
+    Label next = a.newLabel();
+
+    emit_enter_runtime();
+
+    a.mov(ARG1, c_p);
+    a.mov(ARG2, getXRef(0));
+    runtime_call<2>(get_on_load_address);
+
+    emit_leave_runtime();
+
+    a.test(RET, RET);
+    a.jne(next);
+
+    emit_raise_exception(&mfa);
+
+    a.bind(next);
+    erlang_call(RET, ARG1);
+}
+
 #ifdef NATIVE_ERLANG_STACK
 
 void BeamModuleAssembler::emit_i_load_nif() {
-    Label entry = a.newLabel(), next = a.newLabel();
+    Label entry = a.newLabel(), yield = a.newLabel(), next = a.newLabel();
 
     /* i_load_nif is a rewrite of a call_ext instruction, so we'll body-call
      * ourselves to ensure the stack is consistent with that. This greatly
@@ -1028,8 +1120,13 @@ void BeamModuleAssembler::emit_i_load_nif() {
     align_erlang_cp();
     a.bind(entry);
     {
-        a.lea(ARG2, x86::qword_ptr(entry));
-        abs_jmp(ga->get_i_load_nif_shared());
+        emit_enter_frame();
+
+        a.bind(yield);
+        {
+            a.lea(ARG2, x86::qword_ptr(yield));
+            abs_jmp(ga->get_i_load_nif_shared());
+        }
     }
 
     a.bind(next);
@@ -1059,7 +1156,7 @@ void BeamModuleAssembler::emit_i_load_nif() {
     a.cmp(RET, imm(RET_NIF_success));
     a.je(next);
 
-    emit_handle_error(currLabel, &mfa);
+    emit_raise_exception(currLabel, &mfa);
 
     a.bind(schedule);
     {
diff --git a/erts/emulator/beam/jit/x86/instr_bs.cpp b/erts/emulator/beam/jit/x86/instr_bs.cpp
index 7df0b84cae..1b3f675e8e 100644
--- a/erts/emulator/beam/jit/x86/instr_bs.cpp
+++ b/erts/emulator/beam/jit/x86/instr_bs.cpp
@@ -165,7 +165,7 @@ void BeamModuleAssembler::emit_i_bs_init_fail_heap(const ArgVal &Size,
         {
             mov_arg(ARG2, Size);
             safe_fragment_call(ga->get_bs_size_check_shared());
-            emit_handle_error();
+            emit_raise_exception();
         }
 
         a.bind(next);
@@ -267,7 +267,7 @@ void BeamModuleAssembler::emit_i_bs_init_bits_fail_heap(const ArgVal &NumBits,
         {
             mov_arg(ARG2, NumBits);
             safe_fragment_call(ga->get_bs_size_check_shared());
-            emit_handle_error();
+            emit_raise_exception();
         }
 
         a.bind(next);
@@ -1456,7 +1456,7 @@ void BeamModuleAssembler::emit_bs_add(const ArgVal &Fail,
             mov_arg(ARG2, Src1);
             mov_arg(ARG3, Src2);
             safe_fragment_call(ga->get_bs_add_shared());
-            emit_handle_error();
+            emit_raise_exception();
         }
 
         a.bind(next);
@@ -1500,7 +1500,7 @@ void BeamModuleAssembler::emit_i_bs_append(const ArgVal &Fail,
     } else {
         a.short_().jne(next);
         /* The error has been prepared in `erts_bs_append` */
-        emit_handle_error();
+        emit_raise_exception();
         a.bind(next);
     }
 
@@ -1536,7 +1536,7 @@ void BeamModuleAssembler::emit_i_bs_private_append(const ArgVal &Fail,
     } else {
         a.short_().jne(next);
         /* The error has been prepared in `erts_bs_private_append` */
-        emit_handle_error();
+        emit_raise_exception();
         a.bind(next);
     }
 
diff --git a/erts/emulator/beam/jit/x86/instr_call.cpp b/erts/emulator/beam/jit/x86/instr_call.cpp
index b79ef5567c..06957a68f2 100644
--- a/erts/emulator/beam/jit/x86/instr_call.cpp
+++ b/erts/emulator/beam/jit/x86/instr_call.cpp
@@ -46,6 +46,8 @@ void BeamModuleAssembler::emit_return() {
     emit_validate(ArgVal(ArgVal::u, 1));
 #endif
 
+    emit_leave_frame();
+
 #if !defined(NATIVE_ERLANG_STACK)
     a.mov(ARG3, getCPRef());
     a.mov(getCPRef(), imm(NIL));
@@ -76,10 +78,14 @@ void BeamModuleAssembler::emit_i_call_last(const ArgVal &CallDest,
                                            const ArgVal &Deallocate) {
     emit_deallocate(Deallocate);
 
+    emit_leave_frame();
+
     a.jmp(labels[CallDest.getValue()]);
 }
 
 void BeamModuleAssembler::emit_i_call_only(const ArgVal &CallDest) {
+    emit_leave_frame();
+
     a.jmp(labels[CallDest.getValue()]);
 }
 
@@ -116,6 +122,8 @@ void BeamModuleAssembler::emit_i_call_ext(const ArgVal &Exp) {
 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);
+
+    emit_leave_frame();
     a.jmp(destination);
 }
 
@@ -125,6 +133,8 @@ void BeamModuleAssembler::emit_i_call_ext_last(const ArgVal &Exp,
 
     make_move_patch(RET, imports[Exp.getValue()].patches);
     x86::Mem destination = emit_setup_export_call(RET);
+
+    emit_leave_frame();
     a.jmp(destination);
 }
 
@@ -155,7 +165,7 @@ x86::Mem BeamModuleAssembler::emit_variable_apply(bool includeI) {
 
     a.test(RET, RET);
     a.short_().jne(dispatch);
-    emit_handle_error(entry, &apply3_mfa);
+    emit_raise_exception(entry, &apply3_mfa);
     a.bind(dispatch);
 
     return emit_setup_export_call(RET);
@@ -173,6 +183,8 @@ void BeamModuleAssembler::emit_i_apply_last(const ArgVal &Deallocate) {
 
 void BeamModuleAssembler::emit_i_apply_only() {
     x86::Mem dest = emit_variable_apply(true);
+
+    emit_leave_frame();
     a.jmp(dest);
 }
 
@@ -205,7 +217,7 @@ x86::Mem BeamModuleAssembler::emit_fixed_apply(const ArgVal &Arity,
     a.test(RET, RET);
     a.short_().jne(dispatch);
 
-    emit_handle_error(entry, &apply3_mfa);
+    emit_raise_exception(entry, &apply3_mfa);
     a.bind(dispatch);
 
     return emit_setup_export_call(RET);
@@ -221,6 +233,8 @@ void BeamModuleAssembler::emit_apply_last(const ArgVal &Arity,
     emit_deallocate(Deallocate);
 
     x86::Mem dest = emit_fixed_apply(Arity, true);
+
+    emit_leave_frame();
     a.jmp(dest);
 }
 
@@ -247,7 +261,7 @@ x86::Gp BeamModuleAssembler::emit_apply_fun() {
     a.mov(RET, TMP_MEM1q);
 
     a.short_().jne(dispatch);
-    emit_handle_error();
+    emit_raise_exception();
     a.bind(dispatch);
 
     return ARG2;
@@ -268,6 +282,7 @@ void BeamModuleAssembler::emit_i_apply_fun_last(const ArgVal &Deallocate) {
 void BeamModuleAssembler::emit_i_apply_fun_only() {
     x86::Gp dest = emit_apply_fun();
 
+    emit_leave_frame();
     a.jmp(dest);
 }
 
@@ -295,7 +310,7 @@ x86::Gp BeamModuleAssembler::emit_call_fun(const ArgVal &Fun) {
     a.mov(RET, TMP_MEM1q);
 
     a.short_().jne(dispatch);
-    emit_handle_error();
+    emit_raise_exception();
     a.bind(dispatch);
 
     return ARG2;
@@ -313,5 +328,7 @@ void BeamModuleAssembler::emit_i_call_fun_last(const ArgVal &Fun,
     emit_deallocate(Deallocate);
 
     x86::Gp dest = emit_call_fun(Fun);
+
+    emit_leave_frame();
     a.jmp(dest);
 }
diff --git a/erts/emulator/beam/jit/x86/instr_common.cpp b/erts/emulator/beam/jit/x86/instr_common.cpp
index 4ca7a10629..d32adcb5a3 100644
--- a/erts/emulator/beam/jit/x86/instr_common.cpp
+++ b/erts/emulator/beam/jit/x86/instr_common.cpp
@@ -93,7 +93,7 @@ using namespace asmjit;
 
 void BeamModuleAssembler::emit_error(int reason) {
     a.mov(x86::qword_ptr(c_p, offsetof(Process, freason)), imm(reason));
-    emit_handle_error();
+    emit_raise_exception();
 }
 
 void BeamModuleAssembler::emit_gc_test_preserve(const ArgVal &Need,
@@ -204,14 +204,19 @@ void BeamModuleAssembler::emit_allocate(const ArgVal &NeedStack,
 void BeamModuleAssembler::emit_deallocate(const ArgVal &Deallocate) {
     ASSERT(Deallocate.getType() == ArgVal::TYPE::u);
     ASSERT(Deallocate.getValue() <= 1023);
-    ArgVal dealloc = Deallocate;
+
+    if (ERTS_LIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_RA)) {
+        ArgVal dealloc = Deallocate;
 
 #if !defined(NATIVE_ERLANG_STACK)
-    dealloc = dealloc + CP_SIZE;
+        dealloc = dealloc + CP_SIZE;
 #endif
 
-    if (dealloc.getValue() > 0) {
-        a.add(E, imm(dealloc.getValue() * sizeof(Eterm)));
+        if (dealloc.getValue() > 0) {
+            a.add(E, imm(dealloc.getValue() * sizeof(Eterm)));
+        }
+    } else {
+        ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
     }
 }
 
@@ -1414,6 +1419,8 @@ void BeamGlobalAssembler::emit_arith_compare_shared() {
     atom_compare = a.newLabel();
     generic_compare = a.newLabel();
 
+    emit_enter_frame();
+
     /* Are both floats?
      *
      * This is done first as relative comparisons on atoms doesn't make much
@@ -1447,6 +1454,7 @@ void BeamGlobalAssembler::emit_arith_compare_shared() {
     a.setae(x86::al);
     a.dec(x86::al);
 
+    emit_leave_frame();
     a.ret();
 
     a.bind(atom_compare);
@@ -1470,6 +1478,7 @@ void BeamGlobalAssembler::emit_arith_compare_shared() {
         /* !! erts_cmp_atoms returns int, not Sint !! */
         a.test(RETd, RETd);
 
+        emit_leave_frame();
         a.ret();
     }
 
@@ -1486,6 +1495,7 @@ void BeamGlobalAssembler::emit_arith_compare_shared() {
 
         a.test(RET, RET);
 
+        emit_leave_frame();
         a.ret();
     }
 }
@@ -1642,6 +1652,8 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
     Label not_throw = a.newLabel(), not_error = a.newLabel(),
           after_gc = a.newLabel();
 
+    emit_enter_frame();
+
     /* Load thrown value / reason into ARG2 for add_stacktrace */
     a.mov(ARG2, getXRef(2));
 
@@ -1652,6 +1664,7 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
     /* Thrown value, return it in x0 */
     a.mov(getXRef(0), ARG2);
 
+    emit_leave_frame();
     a.ret();
 
     a.bind(not_throw);
@@ -1700,6 +1713,7 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
         a.mov(getXRef(0), RET);
     }
 
+    emit_leave_frame();
     a.ret();
 }
 
@@ -1750,7 +1764,7 @@ void BeamModuleAssembler::emit_raise(const ArgVal &Trace, const ArgVal &Value) {
 
     emit_leave_runtime();
 
-    emit_handle_error();
+    emit_raise_exception();
 }
 
 void BeamModuleAssembler::emit_build_stacktrace() {
@@ -1780,7 +1794,7 @@ void BeamModuleAssembler::emit_raw_raise() {
 
     a.test(RET, RET);
     a.short_().jne(next);
-    emit_handle_error();
+    emit_raise_exception();
     a.bind(next);
     a.mov(getXRef(0), imm(am_badarg));
 }
@@ -1788,14 +1802,21 @@ void BeamModuleAssembler::emit_raw_raise() {
 void BeamGlobalAssembler::emit_i_test_yield_shared() {
     int mfa_offset = -(int)sizeof(ErtsCodeMFA) - BEAM_ASM_FUNC_PROLOGUE_SIZE;
 
+    if (erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+        /* Subtract the size of an `emit_enter_frame` sequence. */
+        mfa_offset -= 4;
+    } else {
+        ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
+    }
+
+    a.add(x86::rsp, imm(8));
+
     /* Yield address is in ARG3. */
     a.lea(ARG2, x86::qword_ptr(ARG3, mfa_offset));
     a.mov(x86::qword_ptr(c_p, offsetof(Process, current)), ARG2);
     a.mov(ARG2, x86::qword_ptr(ARG2, offsetof(ErtsCodeMFA, arity)));
     a.mov(x86::qword_ptr(c_p, offsetof(Process, arity)), ARG2);
 
-    emit_discard_cp();
-
     a.jmp(labels[context_switch_simplified]);
 }
 
@@ -1804,14 +1825,26 @@ void BeamModuleAssembler::emit_i_test_yield() {
 
     /* When present, this is guaranteed to be the first instruction after the
      * breakpoint trampoline. */
-
     ASSERT(a.offset() % 8 == 0);
+
+    emit_enter_frame();
+
     a.bind(entry);
     a.dec(FCALLS);
     a.short_().jg(next);
     a.lea(ARG3, x86::qword_ptr(entry));
     a.call(funcYield);
     a.bind(next);
+
+#if defined(JIT_HARD_DEBUG) && defined(ERLANG_FRAME_POINTERS)
+    a.mov(ARG1, c_p);
+    a.mov(ARG2, x86::rbp);
+    a.mov(ARG3, x86::rsp);
+
+    emit_enter_runtime<Update::eStack>();
+    runtime_call<3>(erts_validate_stack);
+    emit_leave_runtime<Update::eStack>();
+#endif
 }
 
 void BeamModuleAssembler::emit_i_yield() {
diff --git a/erts/emulator/beam/jit/x86/instr_guard_bifs.cpp b/erts/emulator/beam/jit/x86/instr_guard_bifs.cpp
index 1084a1c0e9..60eec7b99a 100644
--- a/erts/emulator/beam/jit/x86/instr_guard_bifs.cpp
+++ b/erts/emulator/beam/jit/x86/instr_guard_bifs.cpp
@@ -49,7 +49,7 @@ void BeamGlobalAssembler::emit_handle_hd_error() {
     a.mov(getXRef(0), RET);
     a.mov(x86::qword_ptr(c_p, offsetof(Process, freason)), imm(BADARG));
     a.mov(ARG4, imm(&mfa));
-    a.jmp(labels[handle_error_shared_prologue]);
+    a.jmp(labels[raise_exception]);
 }
 
 /*
@@ -88,19 +88,20 @@ void BeamGlobalAssembler::emit_handle_element_error() {
     a.mov(getXRef(1), ARG2);
     a.mov(x86::qword_ptr(c_p, offsetof(Process, freason)), imm(BADARG));
     a.mov(ARG4, imm(&mfa));
-    a.jmp(labels[handle_error_shared_prologue]);
+
+    a.jmp(labels[raise_exception]);
 }
 
-/*
- * ARG1 = Position (1-based)
+/* ARG1 = Position (1-based)
  * ARG2 = Tuple
  * ARG3 = 0 if if in body, otherwise address of failure label.
  *
- * Will return with a value in RET only if the element operation succeeds.
- */
+ * Will return with a value in RET only if the element operation succeeds. */
 void BeamGlobalAssembler::emit_bif_element_shared() {
     Label error = a.newLabel();
 
+    emit_enter_frame();
+
     a.mov(RETd, ARG1d);
     a.and_(RETb, imm(_TAG_IMMED1_MASK));
     a.cmp(RETb, imm(_TAG_IMMED1_SMALL));
@@ -127,20 +128,20 @@ void BeamGlobalAssembler::emit_bif_element_shared() {
 
     a.inc(ARG4);
     a.mov(RET, x86::qword_ptr(ARG5, ARG4, 3));
-    a.test(RETd, RETd);
+
+    emit_leave_frame();
     a.ret();
 
     a.bind(error);
     {
-        Label exception = a.newLabel();
+        emit_leave_frame();
 
         a.test(ARG3, ARG3);
-        a.short_().je(exception);
-        emit_discard_cp();
-        a.jmp(ARG3);
+        a.je(labels[handle_element_error]);
 
-        a.bind(exception);
-        a.jmp(labels[handle_element_error]);
+        /* Discard return address and jump to fail label. */
+        a.add(x86::rsp, imm(8));
+        a.jmp(ARG3);
     }
 }
 
diff --git a/erts/emulator/beam/jit/x86/instr_map.cpp b/erts/emulator/beam/jit/x86/instr_map.cpp
index a1fb7394d9..4ef6c83337 100644
--- a/erts/emulator/beam/jit/x86/instr_map.cpp
+++ b/erts/emulator/beam/jit/x86/instr_map.cpp
@@ -50,6 +50,7 @@ void BeamModuleAssembler::emit_ensure_map(const ArgVal &map) {
 }
 
 void BeamGlobalAssembler::emit_new_map_shared() {
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -57,6 +58,7 @@ void BeamGlobalAssembler::emit_new_map_shared() {
     runtime_call<5>(erts_gc_new_map);
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
     a.ret();
 }
@@ -78,6 +80,7 @@ void BeamModuleAssembler::emit_new_map(const ArgVal &Dst,
 }
 
 void BeamGlobalAssembler::emit_i_new_small_map_lit_shared() {
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -85,6 +88,7 @@ void BeamGlobalAssembler::emit_i_new_small_map_lit_shared() {
     runtime_call<5>(erts_gc_new_small_map_lit);
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
     a.ret();
 }
@@ -188,6 +192,7 @@ void BeamModuleAssembler::emit_i_get_map_element_hash(const ArgVal &Fail,
 
 /* ARG3 = live registers, ARG4 = update vector size, ARG5 = update vector. */
 void BeamGlobalAssembler::emit_update_map_assoc_shared() {
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -195,6 +200,7 @@ void BeamGlobalAssembler::emit_update_map_assoc_shared() {
     runtime_call<5>(erts_gc_update_map_assoc);
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
     a.ret();
 }
@@ -223,6 +229,7 @@ void BeamModuleAssembler::emit_update_map_assoc(
  *
  * Result is returned in RET, error is indicated by ZF. */
 void BeamGlobalAssembler::emit_update_map_exact_guard_shared() {
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -230,6 +237,7 @@ void BeamGlobalAssembler::emit_update_map_exact_guard_shared() {
     runtime_call<5>(erts_gc_update_map_exact);
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.ret();
@@ -241,6 +249,7 @@ void BeamGlobalAssembler::emit_update_map_exact_guard_shared() {
 void BeamGlobalAssembler::emit_update_map_exact_body_shared() {
     Label error = a.newLabel();
 
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -248,6 +257,7 @@ void BeamGlobalAssembler::emit_update_map_exact_body_shared() {
     runtime_call<5>(erts_gc_update_map_exact);
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
     emit_test_the_non_value(RET);
     a.short_().je(error);
@@ -257,7 +267,7 @@ void BeamGlobalAssembler::emit_update_map_exact_body_shared() {
     a.bind(error);
     {
         mov_imm(ARG4, 0);
-        emit_handle_error();
+        a.jmp(labels[raise_exception]);
     }
 }
 
diff --git a/erts/emulator/beam/jit/x86/instr_msg.cpp b/erts/emulator/beam/jit/x86/instr_msg.cpp
index e9110e174b..a9200fc873 100644
--- a/erts/emulator/beam/jit/x86/instr_msg.cpp
+++ b/erts/emulator/beam/jit/x86/instr_msg.cpp
@@ -150,6 +150,8 @@ void BeamGlobalAssembler::emit_i_loop_rec_shared() {
     x86::Mem await_addr = TMP_MEM1q, message_ptr = TMP_MEM2q,
              get_out = TMP_MEM3d;
 
+    emit_enter_frame();
+
     a.or_(x86::dword_ptr(c_p, offsetof(Process, flags)), imm(F_DELAY_GC));
     a.mov(x86::qword_ptr(c_p, offsetof(Process, i)), ARG1);
     a.mov(await_addr, ARG2);
@@ -214,7 +216,7 @@ void BeamGlobalAssembler::emit_i_loop_rec_shared() {
          * Note that the message queue lock is still held in this case. */
         a.and_(x86::dword_ptr(c_p, offsetof(Process, flags)), imm(~F_DELAY_GC));
 
-        emit_discard_cp();
+        emit_unwind_frame();
         a.jmp(await_addr);
     }
 
@@ -226,7 +228,7 @@ void BeamGlobalAssembler::emit_i_loop_rec_shared() {
         a.mov(x86::qword_ptr(c_p, offsetof(Process, arity)), imm(0));
         a.mov(x86::qword_ptr(c_p, offsetof(Process, current)), imm(0));
 
-        emit_discard_cp();
+        emit_unwind_frame();
         a.jmp(labels[do_schedule]);
     }
 
@@ -260,6 +262,7 @@ void BeamGlobalAssembler::emit_i_loop_rec_shared() {
         a.mov(ARG1, x86::qword_ptr(ARG1, offsetof(ErtsMessage, m[0])));
         a.mov(getXRef(0), ARG1);
 
+        emit_leave_frame();
         a.ret();
     }
 }
@@ -363,7 +366,7 @@ void BeamModuleAssembler::emit_wait_timeout_locked(const ArgVal &Src,
     a.short_().jl(next);
 #endif
 
-    emit_handle_error(currLabel, (ErtsCodeMFA *)nullptr);
+    emit_raise_exception(currLabel, (ErtsCodeMFA *)nullptr);
 
     a.bind(wait);
     emit_wait_locked(Dest);
diff --git a/erts/emulator/beam/jit/x86/instr_trace.cpp b/erts/emulator/beam/jit/x86/instr_trace.cpp
index a1b87624c7..f04f3493a8 100644
--- a/erts/emulator/beam/jit/x86/instr_trace.cpp
+++ b/erts/emulator/beam/jit/x86/instr_trace.cpp
@@ -31,6 +31,7 @@ extern "C"
  *
  * RET = export entry */
 void BeamGlobalAssembler::emit_generic_bp_global() {
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -40,6 +41,10 @@ void BeamGlobalAssembler::emit_generic_bp_global() {
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
+    /* This is technically a tail call so we must leave the current frame
+     * before jumping. Note that we might not leave the frame we entered
+     * earlier this function, but one added by `erts_generic_breakpoint`. */
+    emit_leave_frame();
     a.jmp(RET);
 }
 
@@ -81,6 +86,7 @@ void BeamGlobalAssembler::emit_generic_bp_local() {
     }
 #endif
 
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     a.mov(ARG1, c_p);
@@ -90,6 +96,10 @@ void BeamGlobalAssembler::emit_generic_bp_local() {
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
+    /* This doesn't necessarily leave the frame entered above: see the
+     * corresponding comment in `generic_bp_global` */
+    emit_leave_frame();
+
 #ifdef NATIVE_ERLANG_STACK
     a.push(TMP_MEM1q);
     a.push(TMP_MEM2q);
@@ -110,6 +120,7 @@ void BeamGlobalAssembler::emit_debug_bp() {
 
     emit_assert_erlang_stack();
 
+    emit_enter_frame();
     emit_enter_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
 
     /* Read and adjust the return address we saved in generic_bp_local. */
@@ -123,13 +134,13 @@ void BeamGlobalAssembler::emit_debug_bp() {
     runtime_call<4>(call_error_handler);
 
     emit_leave_runtime<Update::eReductions | Update::eStack | Update::eHeap>();
+    emit_leave_frame();
 
-    /* Skip two frames so we can make a direct jump to the error handler. This
-     * makes it so that if we are to do a call_nif_early, we skip that and call
-     * the error handler's code instead, mirroring the way the interpreter
-     * works. */
-    emit_discard_cp();
-    emit_discard_cp();
+    /* Skip two return addresses so we can make a direct jump to the error
+     * handler. This makes it so that if we are to do a call_nif_early, we skip
+     * that and call the error handler's code instead, mirroring the way the
+     * interpreter works. */
+    a.add(x86::rsp, imm(16));
 
     a.test(RET, RET);
     a.je(error);
@@ -139,7 +150,7 @@ void BeamGlobalAssembler::emit_debug_bp() {
     a.bind(error);
     {
         a.mov(ARG2, TMP_MEM1q);
-        a.jmp(labels[handle_error_shared]);
+        a.jmp(labels[raise_exception]);
     }
 }
 
@@ -190,27 +201,28 @@ void BeamModuleAssembler::emit_i_return_time_trace() {
 
 static void i_return_to_trace(Process *c_p) {
     if (IS_TRACED_FL(c_p, F_TRACE_RETURN_TO)) {
-        Uint *cpp = (Uint *)c_p->stop;
-        while (is_not_CP(*cpp)) {
-            cpp++;
-        }
+        ErtsCodePtr return_to_address;
+        Uint *cpp;
+
+        cpp = (Uint *)c_p->stop;
+        ASSERT(is_CP(cpp[0]));
+
         for (;;) {
-            ErtsCodePtr w = cp_val(*cpp);
-            if (BeamIsReturnTrace(w)) {
-                do
-                    ++cpp;
-                while (is_not_CP(*cpp));
-                cpp += 2;
-            } else if (BeamIsReturnToTrace(w)) {
-                do
-                    ++cpp;
-                while (is_not_CP(*cpp));
+            erts_inspect_frame(cpp, &return_to_address);
+
+            if (BeamIsReturnTrace(return_to_address)) {
+                cpp += CP_SIZE + 2;
+            } else if (BeamIsReturnTimeTrace(return_to_address)) {
+                cpp += CP_SIZE + 1;
+            } else if (BeamIsReturnToTrace(return_to_address)) {
+                cpp += CP_SIZE;
             } else {
                 break;
             }
         }
+
         ERTS_UNREQ_PROC_MAIN_LOCK(c_p);
-        erts_trace_return_to(c_p, cp_val(*cpp));
+        erts_trace_return_to(c_p, return_to_address);
         ERTS_REQ_PROC_MAIN_LOCK(c_p);
     }
 }
@@ -250,5 +262,5 @@ void BeamModuleAssembler::emit_i_hibernate() {
     abs_jmp(ga->get_do_schedule());
 
     a.bind(error);
-    emit_handle_error(&BIF_TRAP_EXPORT(BIF_hibernate_3)->info.mfa);
+    emit_raise_exception(&BIF_TRAP_EXPORT(BIF_hibernate_3)->info.mfa);
 }
diff --git a/erts/emulator/beam/jit/x86/ops.tab b/erts/emulator/beam/jit/x86/ops.tab
index d6af3818a1..0449b9410c 100644
--- a/erts/emulator/beam/jit/x86/ops.tab
+++ b/erts/emulator/beam/jit/x86/ops.tab
@@ -527,6 +527,21 @@ call_ext_only u==2 u$func:erlang:load_nif/2 => \
 i_load_nif
 %hot
 
+#
+# The call_on_load_function/1 BIF is an instruction.
+#
+
+call_ext u==1 u$func:erlang:call_on_load_function/1 => \
+    i_call_on_load_function
+call_ext_last u==1 u$func:erlang:call_on_load_function/1 D => \
+    i_call_on_load_function | deallocate D | return
+call_ext_only u==1 u$func:erlang:call_on_load_function/1 => \
+    i_call_on_load_function | return
+
+%cold
+i_call_on_load_function
+%hot
+
 #
 # apply/2 is an instruction, not a BIF.
 #
@@ -643,7 +658,6 @@ bif1 Fail=f Bif=u$bif:erlang:tl/1 Src Dst => \
 bif1 Fail Bif=u$bif:erlang:get/1 Src=s Dst=d => get(Src, Dst)
 
 bif2 Fail u$bif:erlang:element/2 S1=ixy S2 Dst => bif_element Fail S1 S2 Dst
-
 bif_element j? s s d
 
 bif1 Fail Bif S1 Dst | never_fails(Bif) => nofail_bif1 S1 Bif Dst
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 7df04420da..022588feca 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -60,6 +60,7 @@
 #include "erl_nfunc_sched.h"
 #include "erl_proc_sig_queue.h"
 #include "erl_unicode.h"
+#include "beam_common.h"
 
 /* *******************************
  * ** Yielding C Fun (YCF) Note **
diff --git a/erts/emulator/internal_doc/BeamAsm.md b/erts/emulator/internal_doc/BeamAsm.md
index 4988126e62..5934413788 100644
--- a/erts/emulator/internal_doc/BeamAsm.md
+++ b/erts/emulator/internal_doc/BeamAsm.md
@@ -47,8 +47,10 @@ liveness of values and the physical registers are statically allocated to keep
 the necessary process state. At the moment this is the static register allocation:
 
     rbx: ErtsSchedulerRegisters struct (contains x/float registers and some metadata)
-    rbp: Active code index
-    r12: Optional Save slot for the Erlang stack pointer when executing C code
+    rbp: Current frame pointer when `perf` support is enabled, otherwise this
+         is an optional save slot for the Erlang stack pointer when executing C
+         code.
+    r12: Active code index
     r13: Current running process
     r14: Remaining reductions
     r15: Erlang heap pointer
@@ -132,6 +134,23 @@ handlers even when we lack a stack frame. This is merely a reservation and has
 no effect on how the stack works, and all values stored there must be valid
 Erlang terms in case of a garbage collection.
 
+## Frame pointers
+
+To aid debuggers and sampling profilers, we support running Erlang code with
+native frame pointers. As of writing this only enabled together with `perf`
+support (`+JPperf true`) to save stack space, but we may add a flag to
+explicitly enable it in the future.
+
+When enabled, continuation pointers (CP) have both a return address _and_ a
+frame pointer that points at the previous CP. CPs must form a valid chain at
+all times, and it's illegal to have "half" a CP when the stack is inspected.
+
+Frame pointers are pushed when entering an Erlang function and popped before
+leaving it, including on tail calls as the callee will immediately push the
+frame pointer on entry. This has a slight overhead but saves us the headache of
+having multiple entry points for each function depending on whether it's tail-
+or body-called, which would get very tricky once breakpoints enter the picture.
+
 ## Running C code
 
 As Erlang stacks can be very small, we have to switch over to a different stack
@@ -288,14 +307,18 @@ You can run perf on BeamAsm like this:
 
     perf record erl +JPperf true
 
-and then look at the results using `perf report` as you normally would with perf.
+and then look at the results using `perf report` as you normally would with
+perf.
+
+Frame pointers are enabled when the `+JPperf true` option is passed, so you can
+use `perf record --call-graph=fp` to get more context. This will give you
+accurate call graphs for pure Erlang code, but in rare cases it fails to track
+transitions from Erlang to C code and back. [`perf record --call-graph=lbr`](https://lwn.net/Articles/680985/)
+may work better in those cases, but it's worse at tracking in general.
 
-If you want to get some context to you calls you cann use the [lbr](https://lwn.net/Articles/680985/)
-call-graph option to `perf record`. Using `lbr` is not perfect (for instance you
-do not get any syscalls in the context), but it work well enough.
 For example, you can run perf to analyze dialyzer building a PLT like this:
 
-     ERL_FLAGS="+JPperf true +S 1" perf record --call-graph lbr \
+     ERL_FLAGS="+JPperf true +S 1" perf record --call-graph=fp \
        dialyzer --build_plt -Wunknown --apps compiler crypto erts kernel stdlib \
        syntax_tools asn1 edoc et ftp inets mnesia observer public_key \
        sasl runtime_tools snmp ssl tftp wx xmerl tools
@@ -315,10 +338,10 @@ By expanding it and looking at its parents we can see that it is the function
 at it in the source code to see if you can figure out why so much time is spent there.
 
 After `eq` we see the function `erl_types:t_has_var/1` where we spend almost
-6% of the entire execution in. A while further down you can see `copy_struct` which
-is the function used to copy terms. If we expand it to view the parents we find that
-it is mostly `ets:lookup_element/3` that contributes to this time via the Erlang
-function `dialyzer_plt:ets_table_lookup/2`.
+5% of the entire execution in. A while further down you can see `copy_struct_x`
+which is the function used to copy terms. If we expand it to view the parents
+we find that it is mostly `ets:lookup_element/3` that contributes to this time
+via the Erlang function `dialyzer_plt:ets_table_lookup/2`.
 
 ### Flame Graph
 
@@ -328,7 +351,7 @@ be more easily shared with others and manipulated to give a graph tailor-made fo
 your needs. For instance, if we run dialyzer with all schedulers:
 
     ## Run dialyzer with multiple schedulers
-    ERL_FLAGS="+JPperf true" perf record --call-graph lbr \
+    ERL_FLAGS="+JPperf true" perf record --call-graph=fp \
       dialyzer --build_plt -Wunknown --apps compiler crypto erts kernel stdlib \
       syntax_tools asn1 edoc et ftp inets mnesia observer public_key \
       sasl runtime_tools snmp ssl tftp wx xmerl tools --statistics
@@ -372,7 +395,7 @@ the annotate functionality in the `perf report` gui) you need to use a monotonic
 clock when calling `perf record`, i.e. `perf record -k mono`. So for a dialyzer
 run you would do this:
 
-    ERL_FLAGS="+JPperf true +S 1" perf record -k mono --call-graph lbr \
+    ERL_FLAGS="+JPperf true +S 1" perf record -k mono --call-graph=fp \
       dialyzer --build_plt -Wunknown --apps compiler crypto erts kernel stdlib \
       syntax_tools asn1 edoc et ftp inets mnesia observer public_key \
       sasl runtime_tools snmp ssl tftp wx xmerl tools
@@ -419,7 +442,6 @@ There are three major reasons why when building Erlang/OTP you would not get the
 
 * You are not building x86 64-bit
 * You do not have a C++ compiler that supports C++-17
-* You do not have an OS that supports executable *and* writable memory
 
 If you run `./configure --enable-jit` configure will abort when it discovers that
 your system cannot build the JIT.
diff --git a/erts/emulator/test/hibernate_SUITE.erl b/erts/emulator/test/hibernate_SUITE.erl
index 3f13ad421a..95bd425575 100644
--- a/erts/emulator/test/hibernate_SUITE.erl
+++ b/erts/emulator/test/hibernate_SUITE.erl
@@ -55,7 +55,7 @@ basic(Config) when is_list(Config) ->
 maximum_hibernate_heap_size(Term) ->
     %% When hibernating, a few extra words will be allocated to hold the
     %% continuation pointer as well as scratch space for the interpreter/jit.
-    erts_debug:size(Term) + 4.
+    erts_debug:size(Term) + 8.
 
 hibernate_wake_up(0, _, _) -> ok;
 hibernate_wake_up(N, MaxHeapSz, Child) ->
@@ -188,7 +188,7 @@ min_heap_size(Config) when is_list(Config) ->
     {heap_size,HeapSz} = process_info(Child, heap_size),
     io:format("Heap size: ~p\n", [HeapSz]),
     if
-        HeapSz < 20 -> ok
+        HeapSz =< 20 -> ok
     end,
     Child ! wake_up,
     receive
@@ -334,7 +334,7 @@ no_heap(Config) when is_list(Config) ->
                           wait_until(fun () -> is_hibernated(H) end),
                           [{heap_size, Size}, {total_heap_size, Size}]
                               = process_info(H, [heap_size, total_heap_size]),
-                          true = Size =< 4,
+                          true = Size =< maximum_hibernate_heap_size(0),
                           receive after 10 -> ok end,
                           H ! again
                   end, lists:seq(1, 100)),
-- 
2.26.2

Places

File 1101-erts-Support-frame-pointers.patch of Package erlang (Revision e92d0acc748e2811090970aa48727278)

Places