File 1206-jit-Provide-Erlang-line-information-to-gdb... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1206-jit-Provide-Erlang-line-information-to-gdb-and-perf.patch of Package erlang (Revision b47b3d0a87f21630280b8ed6f4d34508)

Currently displaying revision b47b3d0a87f21630280b8ed6f4d34508 , Show latest

From 0e72cfa412b522eb5ce74b035fd83cfc5da26b37 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20H=C3=B6gberg?= <john@erlang.org>
Date: Thu, 7 Oct 2021 19:09:35 +0200
Subject: [PATCH 6/9] jit: Provide Erlang line information to `gdb` and `perf`

This works, but proper source line integration requires that the
`.beam` files are compiled with absolute path information, e.g:

erlc "+{source,'`pwd`/test.erl'}" test.erl
---
 erts/emulator/Makefile.in                     |   2 +-
 erts/emulator/beam/beam_file.c                |   2 -
 erts/emulator/beam/jit/arm/beam_asm.hpp       |  26 +-
 .../emulator/beam/jit/arm/beam_asm_global.cpp |  13 +-
 .../emulator/beam/jit/arm/beam_asm_module.cpp |   3 +-
 erts/emulator/beam/jit/asm_load.c             |   7 +-
 erts/emulator/beam/jit/beam_asm.h             |   2 +-
 erts/emulator/beam/jit/beam_jit_common.cpp    | 174 ++++--
 erts/emulator/beam/jit/beam_jit_main.cpp      | 157 +----
 erts/emulator/beam/jit/beam_jit_metadata.cpp  | 541 ++++++++++++++++++
 erts/emulator/beam/jit/beam_jit_perf.cpp      | 256 ---------
 erts/emulator/beam/jit/x86/beam_asm.hpp       |  26 +-
 .../emulator/beam/jit/x86/beam_asm_global.cpp |   6 +-
 .../emulator/beam/jit/x86/beam_asm_module.cpp |   3 +-
 erts/emulator/test/jit_SUITE.erl              |  33 +-
 erts/etc/unix/jit-reader.c                    | 377 ++++++++----
 16 files changed, 1010 insertions(+), 618 deletions(-)
 create mode 100644 erts/emulator/beam/jit/beam_jit_metadata.cpp
 delete mode 100644 erts/emulator/beam/jit/beam_jit_perf.cpp

diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index 51b81e4d82..59751066ac 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -1022,7 +1022,7 @@ JIT_OBJS = \
     $(OBJDIR)/beam_asm_module.o \
     $(OBJDIR)/beam_jit_common.o \
     $(OBJDIR)/beam_jit_main.o \
-    $(OBJDIR)/beam_jit_perf.o \
+    $(OBJDIR)/beam_jit_metadata.o \
     $(OBJDIR)/process_main.o
 
 ifeq ($(JIT_ARCH), x86)
diff --git a/erts/emulator/beam/beam_file.c b/erts/emulator/beam/beam_file.c
index 183bb1696f..2f003ac0e7 100644
--- a/erts/emulator/beam/beam_file.c
+++ b/erts/emulator/beam/beam_file.c
@@ -504,8 +504,6 @@ static int parse_line_chunk(BeamFile *beam, IFF_Chunk *chunk) {
                 lines->location_size = sizeof(Sint32);
             }
 
-            LoadAssert(IS_VALID_LOCATION(name_index, val.word_value));
-
             lines->items[i].location = val.word_value;
             lines->items[i].name_index = name_index;
             i++;
diff --git a/erts/emulator/beam/jit/arm/beam_asm.hpp b/erts/emulator/beam/jit/arm/beam_asm.hpp
index 2e46ee8e34..b750ca9246 100644
--- a/erts/emulator/beam/jit/arm/beam_asm.hpp
+++ b/erts/emulator/beam/jit/arm/beam_asm.hpp
@@ -768,15 +768,16 @@ public:
     struct AsmRange {
         ErtsCodePtr start;
         ErtsCodePtr stop;
-        std::string name;
+        const std::string name;
 
-        /* Not used yet */
-        std::string file;
-        unsigned line;
-    };
+        struct LineData {
+            ErtsCodePtr start;
+            const std::string file;
+            unsigned line;
+        };
 
-    void update_gdb_jit_info(std::string modulename,
-                             std::vector<AsmRange> &functions);
+        const std::vector<LineData> lines;
+    };
 
     void embed(void *data, uint32_t size) {
         a.embed((char *)data, size);
@@ -1104,6 +1105,8 @@ public:
 
     void codegen(char *buff, size_t len);
 
+    void register_metadata(const BeamCodeHeader *header);
+
     ErtsCodePtr getCode(unsigned label);
     ErtsCodePtr getLambda(unsigned index);
 
@@ -1573,5 +1576,10 @@ protected:
     }
 };
 
-void beamasm_update_perf_info(std::string modulename,
-                              std::vector<BeamAssembler::AsmRange> &ranges);
+void beamasm_metadata_update(
+        std::string module_name,
+        ErtsCodePtr base_address,
+        size_t code_size,
+        const std::vector<BeamAssembler::AsmRange> &ranges);
+void beamasm_metadata_early_init();
+void beamasm_metadata_late_init();
diff --git a/erts/emulator/beam/jit/arm/beam_asm_global.cpp b/erts/emulator/beam/jit/arm/beam_asm_global.cpp
index efc94c49c7..20007763d7 100644
--- a/erts/emulator/beam/jit/arm/beam_asm_global.cpp
+++ b/erts/emulator/beam/jit/arm/beam_asm_global.cpp
@@ -71,7 +71,6 @@ BeamGlobalAssembler::BeamGlobalAssembler(JitAllocator *allocator)
         _codegen(allocator, &_ignored_exec, &_ignored_rw);
     }
 
-#ifndef WIN32
     std::vector<AsmRange> ranges;
 
     ranges.reserve(emitPtrs.size());
@@ -91,13 +90,13 @@ BeamGlobalAssembler::BeamGlobalAssembler(JitAllocator *allocator)
                           .name = code.labelEntry(labels[val.first])->name()});
     }
 
-    update_gdb_jit_info("global", ranges);
-    beamasm_update_perf_info("global", ranges);
-#endif
-
-    /* `this->get_xxx` are populated last to ensure that we crash if we use them
-     * instead of labels in global code. */
+    beamasm_metadata_update("global",
+                            (ErtsCodePtr)getBaseAddress(),
+                            code.codeSize(),
+                            ranges);
 
+    /* `this->get_xxx` are populated last to ensure that we crash if we use
+     * them instead of labels in global code. */
     for (auto val : labelNames) {
         ptrs[val.first] = (fptr)getCode(labels[val.first]);
     }
diff --git a/erts/emulator/beam/jit/arm/beam_asm_module.cpp b/erts/emulator/beam/jit/arm/beam_asm_module.cpp
index 628827eaa3..0b0937e4f9 100644
--- a/erts/emulator/beam/jit/arm/beam_asm_module.cpp
+++ b/erts/emulator/beam/jit/arm/beam_asm_module.cpp
@@ -91,11 +91,10 @@ BeamModuleAssembler::BeamModuleAssembler(BeamGlobalAssembler *_ga,
         for (unsigned int i = 1; i < num_labels; i++) {
             /* Large enough to hold most realistic function names. We will
              * truncate too long names, but as the label name is not important
-             * for the functioning of asmjit and this functionality is
+             * for the functioning of the JIT and this functionality is
              * probably only used by developers, we don't bother with dynamic
              * allocation. */
             char tmp[MAX_ATOM_SZ_LIMIT];
-            Label lbl;
 
             /* The named_labels are sorted, so no need for a search. */
             if ((unsigned int)e->label == i) {
diff --git a/erts/emulator/beam/jit/asm_load.c b/erts/emulator/beam/jit/asm_load.c
index f316ef1ed5..a819f3385c 100644
--- a/erts/emulator/beam/jit/asm_load.c
+++ b/erts/emulator/beam/jit/asm_load.c
@@ -687,8 +687,8 @@ static const BeamCodeLineTab *finish_line_table(LoaderState *stp,
     line_items_rw[i] = (void *)&module_base[module_size];
 
     for (i = 0; i < num_names; i++) {
-        fname_base_rw[i] = beamfile_get_literal(&stp->beam,
-                                                stp->beam.lines.names[i]);
+        fname_base_rw[i] =
+                beamfile_get_literal(&stp->beam, stp->beam.lines.names[i]);
     }
 
     if (stp->beam.lines.location_size == sizeof(Uint16)) {
@@ -983,6 +983,9 @@ void beam_load_finalize_code(LoaderState *stp,
         }
     }
 
+    /* Register debug / profiling info with external tools. */
+    beamasm_register_metadata(stp->ba, stp->code_hdr);
+
     /* Prevent literals and code from being freed. */
     (stp->load_hdr)->literal_area = NULL;
     stp->native_module_exec = NULL;
diff --git a/erts/emulator/beam/jit/beam_asm.h b/erts/emulator/beam/jit/beam_asm.h
index 98290657ff..d592decec0 100644
--- a/erts/emulator/beam/jit/beam_asm.h
+++ b/erts/emulator/beam/jit/beam_asm.h
@@ -39,7 +39,6 @@ extern int erts_jit_perf_support;
 #    endif
 
 void beamasm_init(void);
-void beamasm_init_perf(void);
 void *beamasm_new_assembler(Eterm mod,
                             int num_labels,
                             int num_functions,
@@ -50,6 +49,7 @@ void beamasm_codegen(void *ba,
                      const BeamCodeHeader *in_hdr,
                      const BeamCodeHeader **out_exec_hdr,
                      BeamCodeHeader **out_rw_hdr);
+void beamasm_register_metadata(void *ba, const BeamCodeHeader *hdr);
 void beamasm_purge_module(const void *native_module_exec,
                           void *native_module_rw);
 void beamasm_delete_assembler(void *ba);
diff --git a/erts/emulator/beam/jit/beam_jit_common.cpp b/erts/emulator/beam/jit/beam_jit_common.cpp
index 81ede87e4d..14824e5a43 100644
--- a/erts/emulator/beam/jit/beam_jit_common.cpp
+++ b/erts/emulator/beam/jit/beam_jit_common.cpp
@@ -241,66 +241,6 @@ void BeamModuleAssembler::codegen(JitAllocator *allocator,
                                   const void **executable_ptr,
                                   void **writable_ptr) {
     _codegen(allocator, executable_ptr, writable_ptr);
-
-#if !(defined(WIN32) || defined(__APPLE__) || defined(__MACH__) ||             \
-      defined(__DARWIN__))
-    if (functions.size()) {
-        char *buff = (char *)erts_alloc(ERTS_ALC_T_TMP, 1024);
-        std::vector<AsmRange> ranges;
-        std::string name = getAtom(mod);
-        ranges.reserve(functions.size() + 2);
-
-        /* Push info about the header */
-        ranges.push_back({.start = (ErtsCodePtr)getBaseAddress(),
-                          .stop = getCode(functions[0]),
-                          .name = name + "::codeHeader"});
-
-        for (unsigned i = 0; i < functions.size(); i++) {
-            ErtsCodePtr start, stop;
-            const ErtsCodeInfo *ci;
-            int n;
-
-            start = getCode(functions[i]);
-            ci = (const ErtsCodeInfo *)start;
-
-            n = erts_snprintf(buff,
-                              1024,
-                              "%T:%T/%d",
-                              ci->mfa.module,
-                              ci->mfa.function,
-                              ci->mfa.arity);
-            stop = ((const char *)erts_codeinfo_to_code(ci)) +
-                   BEAM_ASM_FUNC_PROLOGUE_SIZE;
-
-            /* We use a different symbol for CodeInfo and the Prologue
-               in order for the perf disassembly to be better. */
-            std::string name(buff, n);
-            ranges.push_back({.start = start,
-                              .stop = stop,
-                              .name = name + "-CodeInfoPrologue"});
-
-            /* The actual code */
-            start = stop;
-            if (i + 1 < functions.size()) {
-                stop = getCode(functions[i + 1]);
-            } else {
-                stop = getCode(code_end);
-            }
-
-            ranges.push_back({.start = start, .stop = stop, .name = name});
-        }
-
-        /* Push info about the footer */
-        ranges.push_back(
-                {.start = ranges.back().stop,
-                 .stop = (ErtsCodePtr)(code.baseAddress() + code.codeSize()),
-                 .name = name + "::codeFooter"});
-
-        update_gdb_jit_info(name, ranges);
-        beamasm_update_perf_info(name, ranges);
-        erts_free(ERTS_ALC_T_TMP, buff);
-    }
-#endif
 }
 
 void BeamModuleAssembler::codegen(char *buff, size_t len) {
@@ -313,6 +253,120 @@ void BeamModuleAssembler::codegen(char *buff, size_t len) {
                            CodeHolder::kCopyPadSectionBuffer);
 }
 
+void BeamModuleAssembler::register_metadata(const BeamCodeHeader *header) {
+#ifndef WIN32
+    const BeamCodeLineTab *line_table = header->line_table;
+
+    char name_buffer[MAX_ATOM_SZ_LIMIT];
+    std::string module_name = getAtom(mod);
+    std::vector<AsmRange> ranges;
+
+    ranges.reserve(functions.size() + 2);
+
+    ASSERT((ErtsCodePtr)getBaseAddress() == (ErtsCodePtr)header);
+
+    /* Push info about the header */
+    ranges.push_back({.start = (ErtsCodePtr)getBaseAddress(),
+                      .stop = getCode(functions[0]),
+                      .name = module_name + "::codeHeader"});
+
+    for (unsigned i = 0; i < functions.size(); i++) {
+        std::vector<AsmRange::LineData> lines;
+        ErtsCodePtr start, stop;
+        const ErtsCodeInfo *ci;
+        Sint n;
+
+        start = getCode(functions[i]);
+        ci = (const ErtsCodeInfo *)start;
+
+        stop = ((const char *)erts_codeinfo_to_code(ci)) +
+               BEAM_ASM_FUNC_PROLOGUE_SIZE;
+
+        n = erts_snprintf(name_buffer,
+                          1024,
+                          "%T:%T/%d",
+                          ci->mfa.module,
+                          ci->mfa.function,
+                          ci->mfa.arity);
+
+        /* We use a different symbol for CodeInfo and the Prologue
+         * in order for the perf disassembly to be better. */
+        std::string function_name(name_buffer, n);
+        ranges.push_back({.start = start,
+                          .stop = stop,
+                          .name = function_name + "-CodeInfoPrologue"});
+
+        /* The actual code */
+        start = stop;
+        if (i + 1 < functions.size()) {
+            stop = getCode(functions[i + 1]);
+        } else {
+            stop = getCode(code_end);
+        }
+
+        if (line_table) {
+            const void **line_cursor = line_table->func_tab[i];
+            const int loc_size = line_table->loc_size;
+
+            /* Register all lines belonging to this function. */
+            while ((intptr_t)line_cursor[0] < (intptr_t)stop) {
+                ptrdiff_t line_index;
+                Uint32 loc;
+
+                line_index = line_cursor - line_table->func_tab[0];
+
+                if (loc_size == 2) {
+                    loc = line_table->loc_tab.p2[line_index];
+                } else {
+                    ASSERT(loc_size == 4);
+                    loc = line_table->loc_tab.p4[line_index];
+                }
+
+                if (loc != LINE_INVALID_LOCATION) {
+                    Uint32 file;
+                    Eterm fname;
+                    int res;
+
+                    file = LOC_FILE(loc);
+                    fname = line_table->fname_ptr[file];
+
+                    ERTS_ASSERT(is_nil(fname) || is_list(fname));
+
+                    res = erts_unicode_list_to_buf(fname,
+                                                   (byte *)name_buffer,
+                                                   sizeof(name_buffer) / 4,
+                                                   &n);
+
+                    ERTS_ASSERT(res != -1);
+
+                    lines.push_back({.start = line_cursor[0],
+                                     .file = std::string(name_buffer, n),
+                                     .line = LOC_LINE(loc)});
+                }
+
+                line_cursor++;
+            }
+        }
+
+        ranges.push_back({.start = start,
+                          .stop = stop,
+                          .name = function_name,
+                          .lines = lines});
+    }
+
+    /* Push info about the footer */
+    ranges.push_back(
+            {.start = ranges.back().stop,
+             .stop = (ErtsCodePtr)(code.baseAddress() + code.codeSize()),
+             .name = module_name + "::codeFooter"});
+
+    beamasm_metadata_update(module_name,
+                            (ErtsCodePtr)code.baseAddress(),
+                            code.codeSize(),
+                            ranges);
+#endif
+}
+
 BeamCodeHeader *BeamModuleAssembler::getCodeHeader() {
     return (BeamCodeHeader *)getCode(codeHeader);
 }
diff --git a/erts/emulator/beam/jit/beam_jit_main.cpp b/erts/emulator/beam/jit/beam_jit_main.cpp
index 5c450013ff..bb2e292d7e 100644
--- a/erts/emulator/beam/jit/beam_jit_main.cpp
+++ b/erts/emulator/beam/jit/beam_jit_main.cpp
@@ -72,8 +72,6 @@ static BeamGlobalAssembler *bga;
 static BeamModuleAssembler *bma;
 static CpuInfo cpuinfo;
 
-static void beamasm_init_gdb_jit_info(void);
-
 /*
  * Enter all BIFs into the export table.
  *
@@ -234,8 +232,7 @@ void beamasm_init() {
     ERTS_CT_ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_RA);
 #endif
 
-    beamasm_init_perf();
-    beamasm_init_gdb_jit_info();
+    beamasm_metadata_early_init();
 
     /*
      * Ensure that commonly used fields in the PCB can be accessed with
@@ -300,7 +297,22 @@ void beamasm_init() {
          * itself. */
         const void *_ignored_exec;
         void *_ignored_rw;
-        bma->codegen(jit_allocator, &_ignored_exec, &_ignored_rw);
+
+        /* Register our global code with gdb/perf so it shows up nicely in
+         * stack traces. */
+        BeamCodeHeader *_ignored_code_hdr_rw = NULL;
+        const BeamCodeHeader *code_hdr_ro = NULL;
+        BeamCodeHeader load_header = {};
+
+        load_header.num_functions = operands.size();
+
+        bma->codegen(jit_allocator,
+                     &_ignored_exec,
+                     &_ignored_rw,
+                     &load_header,
+                     &code_hdr_ro,
+                     &_ignored_code_hdr_rw);
+        bma->register_metadata(code_hdr_ro);
     }
 
     for (auto op : operands) {
@@ -323,6 +335,8 @@ void beamasm_init() {
     beam_exit = (ErtsCodePtr)bga->get_process_exit();
 
     beam_unloaded_fun = (ErtsCodePtr)bga->get_unloaded_fun();
+
+    beamasm_metadata_late_init();
 }
 
 bool BeamAssembler::hasCpuFeature(uint32_t featureId) {
@@ -340,134 +354,6 @@ void process_main(ErtsSchedulerData *esdp) {
     pmain(esdp);
 }
 
-enum jit_actions : uint32_t {
-    JIT_NOACTION = 0,
-    JIT_REGISTER_FN,
-    JIT_UNREGISTER_FN,
-};
-
-struct jit_code_entry {
-    struct jit_code_entry *next_entry;
-    struct jit_code_entry *prev_entry;
-    const char *symfile_addr;
-    uint64_t symfile_size;
-};
-
-struct jit_descriptor {
-    uint32_t version;
-    jit_actions action_flag;
-    struct jit_code_entry *relevant_entry;
-    struct jit_code_entry *first_entry;
-    erts_mtx_t mutex;
-};
-
-extern "C"
-{
-    extern void ERTS_NOINLINE __jit_debug_register_code(void);
-
-    /* Make sure to specify the version statically, because the
-     * debugger may check the version before we can set it. */
-    struct jit_descriptor __jit_debug_descriptor = {1,
-                                                    JIT_NOACTION,
-                                                    NULL,
-                                                    NULL};
-} /* extern "C" */
-
-static void beamasm_init_gdb_jit_info(void) {
-    Sint symfile_size = sizeof(uint64_t) * 2;
-    uint64_t *symfile = (uint64_t *)malloc(symfile_size);
-    jit_code_entry *entry;
-
-    symfile[0] = 0;
-    symfile[1] = (uint64_t)beam_normal_exit;
-
-    entry = (jit_code_entry *)malloc(sizeof(jit_code_entry));
-
-    /* Add address description */
-    entry->symfile_addr = (char *)symfile;
-    entry->symfile_size = symfile_size;
-
-    /* Insert into linked list */
-    entry->next_entry = __jit_debug_descriptor.first_entry;
-    if (entry->next_entry) {
-        entry->next_entry->prev_entry = entry;
-    } else {
-        entry->prev_entry = nullptr;
-    }
-
-    /* register with dbg */
-    __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
-    __jit_debug_descriptor.first_entry = entry;
-    __jit_debug_descriptor.relevant_entry = entry;
-    __jit_debug_register_code();
-
-    erts_mtx_init(&__jit_debug_descriptor.mutex,
-                  "jit_debug_descriptor",
-                  NIL,
-                  (ERTS_LOCK_FLAGS_PROPERTY_STATIC |
-                   ERTS_LOCK_FLAGS_CATEGORY_GENERIC));
-}
-
-void BeamAssembler::update_gdb_jit_info(std::string modulename,
-                                        std::vector<AsmRange> &functions) {
-    Sint symfile_size = sizeof(uint64_t) * 3 + modulename.size() + 1;
-
-    for (auto fun : functions) {
-        symfile_size += sizeof(uint64_t) * 2;
-        symfile_size += fun.name.size() + 1;
-    }
-
-    char *symfile = (char *)malloc(symfile_size);
-    jit_code_entry *entry;
-
-    entry = (jit_code_entry *)malloc(sizeof(jit_code_entry));
-
-    /* Add address description */
-    entry->symfile_addr = symfile;
-    entry->symfile_size = symfile_size;
-
-    ((uint64_t *)symfile)[0] = functions.size();
-    ((uint64_t *)symfile)[1] = code.baseAddress();
-    ((uint64_t *)symfile)[2] = (uint64_t)code.codeSize();
-
-    symfile += sizeof(uint64_t) * 3;
-
-    sys_memcpy(symfile, modulename.c_str(), modulename.size() + 1);
-    symfile += modulename.size() + 1;
-
-    for (unsigned i = 0; i < functions.size(); i++) {
-        ((uint64_t *)symfile)[0] = (uint64_t)functions[i].start;
-        ((uint64_t *)symfile)[1] = (uint64_t)functions[i].stop;
-
-        ASSERT(functions[i].start <= functions[i].stop);
-
-        symfile += sizeof(uint64_t) * 2;
-
-        sys_memcpy(symfile,
-                   functions[i].name.c_str(),
-                   functions[i].name.size() + 1);
-        symfile += functions[i].name.size() + 1;
-    }
-
-    ASSERT(symfile_size == (symfile - entry->symfile_addr));
-
-    /* Insert into linked list */
-    erts_mtx_lock(&__jit_debug_descriptor.mutex);
-    entry->next_entry = __jit_debug_descriptor.first_entry;
-    if (entry->next_entry) {
-        entry->next_entry->prev_entry = entry;
-    } else {
-        entry->prev_entry = nullptr;
-    }
-
-    /* register with dbg */
-    __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
-    __jit_debug_descriptor.first_entry = entry;
-    __jit_debug_descriptor.relevant_entry = entry;
-    __jit_debug_register_code();
-    erts_mtx_unlock(&__jit_debug_descriptor.mutex);
-}
-
 extern "C"
 {
     int erts_beam_jump_table(void) {
@@ -615,6 +501,11 @@ extern "C"
                     out_rw_hdr);
     }
 
+    void beamasm_register_metadata(void *instance, const BeamCodeHeader *hdr) {
+        BeamModuleAssembler *ba = static_cast<BeamModuleAssembler *>(instance);
+        ba->register_metadata(hdr);
+    }
+
     Uint beamasm_get_header(void *instance, const BeamCodeHeader **hdr) {
         BeamModuleAssembler *ba = static_cast<BeamModuleAssembler *>(instance);
 
diff --git a/erts/emulator/beam/jit/beam_jit_metadata.cpp b/erts/emulator/beam/jit/beam_jit_metadata.cpp
new file mode 100644
index 0000000000..4a57aedf0b
--- /dev/null
+++ b/erts/emulator/beam/jit/beam_jit_metadata.cpp
@@ -0,0 +1,541 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2020-2021. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#include "beam_asm.hpp"
+
+extern "C"
+{
+#include "beam_common.h"
+}
+
+#if !(defined(WIN32) || defined(__APPLE__) || defined(__MACH__) ||             \
+      defined(__DARWIN__))
+#    define HAVE_GDB_SUPPORT
+#endif
+
+#ifdef HAVE_GDB_SUPPORT
+
+enum jit_actions : uint32_t {
+    JIT_NOACTION = 0,
+    JIT_REGISTER_FN,
+    JIT_UNREGISTER_FN,
+};
+
+struct jit_code_entry {
+    struct jit_code_entry *next_entry;
+    struct jit_code_entry *prev_entry;
+    const char *symfile_addr;
+    uint64_t symfile_size;
+};
+
+struct jit_descriptor {
+    uint32_t version;
+    jit_actions action_flag;
+    struct jit_code_entry *relevant_entry;
+    struct jit_code_entry *first_entry;
+    erts_mtx_t mutex;
+};
+
+extern "C"
+{
+    extern void ERTS_NOINLINE __jit_debug_register_code(void);
+
+    /* Make sure to specify the version statically, because the
+     * debugger may check the version before we can set it. */
+    struct jit_descriptor __jit_debug_descriptor = {1,
+                                                    JIT_NOACTION,
+                                                    NULL,
+                                                    NULL};
+} /* extern "C" */
+
+struct emulator_info {
+    /* 0 = regular, 1 = frame pointers */
+    int frame_layout;
+    const void *normal_exit;
+};
+
+struct module_info {
+    uint64_t base_address;
+    uint32_t range_count;
+    uint32_t code_size;
+    /* Module name, including null terminator. */
+    uint16_t name_length;
+    char name[];
+};
+
+struct range_info {
+    uint32_t start_offset;
+    uint32_t end_offset;
+    uint32_t line_count;
+    /* Range name, including null terminator. */
+    uint16_t name_length;
+    char name[];
+};
+
+struct line_info {
+    uint32_t start_offset;
+    uint32_t line_number;
+    /* File name, including null terminator. */
+    uint16_t file_length;
+    char file[];
+};
+
+enum debug_info_header {
+    DEBUG_INFO_HEADER_EMULATOR = 0,
+    DEBUG_INFO_HEADER_MODULE = 1,
+};
+
+struct debug_info {
+    enum debug_info_header header;
+    union {
+        struct emulator_info emu;
+        struct module_info mod;
+    } payload;
+};
+
+static void beamasm_init_early_gdb() {
+    erts_mtx_init(&__jit_debug_descriptor.mutex,
+                  "jit_debug_descriptor",
+                  NIL,
+                  (ERTS_LOCK_FLAGS_PROPERTY_STATIC |
+                   ERTS_LOCK_FLAGS_CATEGORY_GENERIC));
+}
+
+static void beamasm_init_late_gdb() {
+    auto debug_info = (struct debug_info *)malloc(sizeof(struct debug_info));
+    jit_code_entry *entry;
+
+    debug_info->header = DEBUG_INFO_HEADER_EMULATOR;
+    debug_info->payload.emu.frame_layout = erts_frame_layout;
+    debug_info->payload.emu.normal_exit = beam_normal_exit;
+
+    entry = (jit_code_entry *)malloc(sizeof(jit_code_entry));
+    entry->symfile_addr = (char *)debug_info;
+    entry->symfile_size = sizeof(struct debug_info);
+
+    /* Insert into linked list */
+    entry->next_entry = __jit_debug_descriptor.first_entry;
+    if (entry->next_entry) {
+        entry->next_entry->prev_entry = entry;
+    } else {
+        entry->prev_entry = nullptr;
+    }
+
+    /* Insert into linked list */
+    erts_mtx_lock(&__jit_debug_descriptor.mutex);
+    entry->next_entry = __jit_debug_descriptor.first_entry;
+    if (entry->next_entry) {
+        entry->next_entry->prev_entry = entry;
+    } else {
+        entry->prev_entry = nullptr;
+    }
+
+    /* Register with gdb */
+    __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
+    __jit_debug_descriptor.first_entry = entry;
+    __jit_debug_descriptor.relevant_entry = entry;
+    __jit_debug_register_code();
+    erts_mtx_unlock(&__jit_debug_descriptor.mutex);
+}
+
+static void beamasm_update_gdb_info(
+        std::string module_name,
+        ErtsCodePtr base_address,
+        size_t code_size,
+        const std::vector<BeamAssembler::AsmRange> &ranges) {
+    Sint symfile_size = sizeof(struct debug_info) + module_name.size() + 1;
+
+    for (const auto &range : ranges) {
+        symfile_size += sizeof(struct range_info) + range.name.size() + 1;
+
+        for (const auto &line : range.lines) {
+            symfile_size += sizeof(struct line_info) + line.file.size() + 1;
+        }
+    }
+
+    char *symfile = (char *)malloc(symfile_size);
+    jit_code_entry *entry;
+
+    entry = (jit_code_entry *)malloc(sizeof(jit_code_entry));
+    entry->symfile_addr = symfile;
+    entry->symfile_size = symfile_size;
+
+    auto debug_info = (struct debug_info *)symfile;
+    debug_info->header = DEBUG_INFO_HEADER_MODULE;
+
+    auto module_info = &debug_info->payload.mod;
+    module_info->base_address = (uint64_t)base_address;
+    module_info->code_size = (uint32_t)code_size;
+    module_info->range_count = ranges.size();
+    module_info->name_length = module_name.size() + 1;
+    sys_memcpy(module_info->name,
+               module_name.c_str(),
+               module_info->name_length);
+
+    symfile += sizeof(*debug_info) + module_info->name_length;
+
+    for (const auto &range : ranges) {
+        ASSERT(range.start >= base_address && range.start <= range.stop);
+
+        auto range_info = (struct range_info *)symfile;
+        range_info->start_offset = (char *)range.start - (char *)base_address;
+        range_info->end_offset = (char *)range.stop - (char *)base_address;
+        range_info->line_count = (uint32_t)range.lines.size();
+        range_info->name_length = (uint16_t)range.name.size() + 1;
+        sys_memcpy(range_info->name,
+                   range.name.c_str(),
+                   range_info->name_length);
+
+        symfile += sizeof(*range_info) + range_info->name_length;
+
+        for (const auto &line : range.lines) {
+            auto line_info = (struct line_info *)symfile;
+            line_info->start_offset = (char *)line.start - (char *)base_address;
+            line_info->line_number = (uint32_t)line.line;
+            line_info->file_length = (uint16_t)line.file.size() + 1;
+            sys_memcpy(line_info->file,
+                       line.file.c_str(),
+                       line_info->file_length);
+
+            symfile += sizeof(*line_info) + line_info->file_length;
+        }
+    }
+
+    ASSERT(symfile_size == (symfile - entry->symfile_addr));
+
+    /* Insert into linked list */
+    erts_mtx_lock(&__jit_debug_descriptor.mutex);
+    entry->next_entry = __jit_debug_descriptor.first_entry;
+    if (entry->next_entry) {
+        entry->next_entry->prev_entry = entry;
+    } else {
+        entry->prev_entry = nullptr;
+    }
+
+    /* register with gdb */
+    __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
+    __jit_debug_descriptor.first_entry = entry;
+    __jit_debug_descriptor.relevant_entry = entry;
+    __jit_debug_register_code();
+    erts_mtx_unlock(&__jit_debug_descriptor.mutex);
+}
+
+#endif /* HAVE_GDB_SUPPORT */
+
+#ifdef HAVE_LINUX_PERF_SUPPORT
+
+#    ifdef HAVE_ELF_H
+#        include <elf.h>
+#        define HAVE_LINUX_PERF_DUMP_SUPPORT 1
+
+class JitPerfDump {
+    FILE *file = nullptr;
+    Uint64 code_index = 0;
+
+    enum PerfDumpId {
+        JIT_CODE_LOAD = 0, /* record describing a jitted function */
+        JIT_CODE_MOVE = 1, /* record describing an already jitted function which
+                              is moved */
+        JIT_CODE_DEBUG_INFO = 2, /* record describing the debug information for
+                                    a jitted function */
+        JIT_CODE_CLOSE =
+                3, /* record marking the end of the jit runtime (optional) */
+        JIT_CODE_UNWINDING_INFO =
+                4 /* record describing a function unwinding information */
+    };
+
+    struct FileHeader {
+        Uint32 magic;
+        Uint32 version;
+        Uint32 total_size;
+        Uint32 elf_mach;
+        Uint32 pad1;
+        Uint32 pid;
+        Uint64 timestamp;
+        Uint64 flags;
+
+        FileHeader() {
+            magic = 0x4A695444; /* "JiTD" as numbers */
+            version = 1;
+            total_size = sizeof(FileHeader);
+            elf_mach = EM_X86_64;
+            pad1 = 0;
+            pid = getpid();
+            timestamp = erts_os_monotonic_time();
+            flags = 0;
+            ERTS_CT_ASSERT(sizeof(FileHeader) == 4 * 10);
+        }
+    };
+
+    struct RecordHeader {
+        Uint32 id;
+        Uint32 total_size;
+        Uint64 timestamp;
+    };
+
+public:
+    bool init() {
+        char name[MAXPATHLEN];
+        FileHeader header;
+
+        /* LLVM places this file in ~/.debug/jit/ maybe we should do that to? */
+
+        erts_snprintf(name, sizeof(name), "/tmp/jit-%d.dump", getpid());
+
+        file = fopen(name, "w+");
+
+        if (file) {
+            fwrite(&header, sizeof(header), 1, file);
+            /* inform perf of the location of the dump file */
+            void *addr = mmap(NULL,
+                              sizeof(header),
+                              PROT_READ | PROT_EXEC,
+                              MAP_PRIVATE,
+                              fileno(file),
+                              0);
+            if (addr == MAP_FAILED) {
+                int saved_errno = errno;
+                erts_dsprintf_buf_t *dsbuf = erts_create_logger_dsbuf();
+                erts_dsprintf(dsbuf,
+                              "perf: mmap of %s(%d) failed: %d\r\n",
+                              name,
+                              fileno(file),
+                              saved_errno);
+                erts_send_error_to_logger_nogl(dsbuf);
+                fclose(file);
+                file = nullptr;
+                return false;
+            }
+        } else {
+            int saved_errno = errno;
+            erts_dsprintf_buf_t *dsbuf = erts_create_logger_dsbuf();
+            erts_dsprintf(dsbuf,
+                          "perf: Failed to open %s (%d)",
+                          name,
+                          saved_errno);
+            erts_send_error_to_logger_nogl(dsbuf);
+            return false;
+        }
+        return true;
+    }
+
+    void update(const std::vector<BeamAssembler::AsmRange> &ranges) {
+        struct JitCodeLoadRecord {
+            RecordHeader header;
+            Uint32 pid;
+            Uint32 tid;
+            Uint64 vma;
+            Uint64 code_addr;
+            Uint64 code_size;
+            Uint64 code_index;
+            /* Null terminated M:F/A */
+            /* Native code */
+        } record;
+
+        record.header.id = JIT_CODE_LOAD;
+        record.pid = getpid();
+        record.tid = erts_thr_self();
+
+        for (const BeamAssembler::AsmRange &range : ranges) {
+            /* Line entries must be written first, if present. */
+            if (!range.lines.empty()) {
+                struct JitCodeDebugEntry {
+                    Uint64 line_addr;
+                    Uint32 line;
+                    Uint32 column;
+                    char name[];
+                } debug_entry;
+
+                struct JitCodeDebugInfoRecord {
+                    RecordHeader header;
+                    Uint64 code_addr;
+                    Uint64 nr_entry;
+                    struct JitCodeDebugEntry entries[];
+                } debug_info;
+
+                debug_info.header.id = JIT_CODE_DEBUG_INFO;
+                debug_info.header.total_size = sizeof(debug_info);
+                debug_info.header.timestamp = erts_os_monotonic_time();
+                debug_info.code_addr = (Uint64)range.start;
+                debug_info.nr_entry = range.lines.size() + 1;
+
+                for (const auto &line : range.lines) {
+                    debug_info.header.total_size += sizeof(debug_entry);
+                    debug_info.header.total_size += line.file.size() + 1;
+                }
+
+                /* Add a dummy line to terminate the function. Otherwise, the
+                 * line section will stop right before the final line. */
+                debug_info.header.total_size += sizeof(debug_entry);
+                debug_info.header.total_size += 1;
+
+                fwrite(&debug_info, sizeof(debug_info), 1, file);
+
+                for (const auto &line : range.lines) {
+                    debug_entry.line_addr = (Uint64)line.start;
+                    debug_entry.line = line.line;
+                    debug_entry.column = 0;
+
+                    fwrite(&debug_entry, sizeof(debug_entry), 1, file);
+                    fwrite(line.file.c_str(), line.file.size() + 1, 1, file);
+                }
+
+                debug_entry.line_addr = (Uint64)range.stop;
+                debug_entry.line = 0;
+                debug_entry.column = 0;
+
+                fwrite(&debug_entry, sizeof(debug_entry), 1, file);
+                fwrite("", 1, 1, file);
+            }
+
+            ptrdiff_t codeSize = (byte *)range.stop - (byte *)range.start;
+            size_t nameLen = range.name.size();
+
+            ASSERT(codeSize >= 0);
+
+            record.header.total_size = sizeof(record) + nameLen + 1 + codeSize;
+            record.vma = (Uint64)range.start;
+            record.code_addr = (Uint64)range.start;
+            record.code_size = (Uint64)codeSize;
+            record.code_index = ++code_index;
+            record.header.timestamp = erts_os_monotonic_time();
+
+            fwrite(&record, sizeof(record), 1, file);
+            fwrite(range.name.c_str(), nameLen + 1, 1, file);
+            fwrite(range.start, codeSize, 1, file);
+        }
+
+        fflush(file);
+    }
+};
+
+#    endif /* HAVE_LINUX_PERF_SUPPORT */
+
+class JitPerfMap {
+    FILE *file = nullptr;
+
+public:
+    bool init() {
+        char name[MAXPATHLEN];
+        snprintf(name, sizeof(name), "/tmp/perf-%i.map", getpid());
+        file = fopen(name, "w");
+        if (!file) {
+            int saved_errno = errno;
+            erts_dsprintf_buf_t *dsbuf = erts_create_logger_dsbuf();
+            erts_dsprintf(dsbuf,
+                          "perf: Failed to open %s (%d)",
+                          name,
+                          saved_errno);
+            erts_send_error_to_logger_nogl(dsbuf);
+            return false;
+        }
+        return true;
+    }
+
+    void update(const std::vector<BeamAssembler::AsmRange> &ranges) {
+        for (const auto &range : ranges) {
+            char *start = (char *)range.start, *stop = (char *)range.stop;
+            ptrdiff_t size = stop - start;
+            fprintf(file, "%p %tx $%s\n", start, size, range.name.c_str());
+        }
+        fflush(file);
+    }
+};
+
+class JitPerfSupport {
+    enum PerfModes { NONE = 0, MAP = (1 << 0), DUMP = (1 << 1) };
+
+    int modes;
+
+    erts_mtx_t mutex;
+#    ifdef HAVE_LINUX_PERF_DUMP_SUPPORT
+    JitPerfDump perf_dump;
+#    endif
+    JitPerfMap perf_map;
+
+public:
+    JitPerfSupport() : modes(NONE) {
+    }
+    void init() {
+        modes = JitPerfSupport::NONE;
+#    ifdef HAVE_LINUX_PERF_DUMP_SUPPORT
+        if ((erts_jit_perf_support & BEAMASM_PERF_DUMP) && perf_dump.init()) {
+            modes |= JitPerfSupport::DUMP;
+        }
+#    endif
+        if ((erts_jit_perf_support & BEAMASM_PERF_MAP) && perf_map.init()) {
+            modes |= JitPerfSupport::MAP;
+        }
+
+        erts_mtx_init(&mutex,
+                      "perf",
+                      NIL,
+                      ERTS_LOCK_FLAGS_PROPERTY_STATIC |
+                              ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
+    }
+
+    void update(const std::vector<BeamAssembler::AsmRange> &ranges) {
+        if (modes) {
+            erts_mtx_lock(&mutex);
+#    ifdef HAVE_LINUX_PERF_DUMP_SUPPORT
+            if (modes & DUMP) {
+                perf_dump.update(ranges);
+            }
+#    endif
+            if (modes & MAP) {
+                perf_map.update(ranges);
+            }
+            erts_mtx_unlock(&mutex);
+        }
+    }
+};
+
+static JitPerfSupport perf;
+#endif /* HAVE_LINUX_PERF_SUPPORT */
+
+void beamasm_metadata_early_init() {
+#ifdef HAVE_GDB_SUPPORT
+    beamasm_init_early_gdb();
+#endif
+
+#ifdef HAVE_LINUX_PERF_SUPPORT
+    perf.init();
+#endif
+}
+
+void beamasm_metadata_late_init() {
+#ifdef HAVE_GDB_SUPPORT
+    beamasm_init_late_gdb();
+#endif
+}
+
+void beamasm_metadata_update(
+        std::string module_name,
+        ErtsCodePtr base_address,
+        size_t code_size,
+        const std::vector<BeamAssembler::AsmRange> &ranges) {
+#ifdef HAVE_LINUX_PERF_SUPPORT
+    perf.update(ranges);
+#endif
+
+#ifdef HAVE_GDB_SUPPORT
+    beamasm_update_gdb_info(module_name, base_address, code_size, ranges);
+#endif
+}
diff --git a/erts/emulator/beam/jit/beam_jit_perf.cpp b/erts/emulator/beam/jit/beam_jit_perf.cpp
deleted file mode 100644
index 7fcf74febb..0000000000
--- a/erts/emulator/beam/jit/beam_jit_perf.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 2020-2021. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * %CopyrightEnd%
- */
-
-#include "beam_asm.hpp"
-
-#ifdef HAVE_LINUX_PERF_SUPPORT
-
-#    ifdef HAVE_ELF_H
-#        include <elf.h>
-#        define HAVE_LINUX_PERF_DUMP_SUPPORT 1
-
-class JitPerfDump {
-    FILE *file = nullptr;
-    Uint64 code_index = 0;
-
-    enum PerfDumpId {
-        JIT_CODE_LOAD = 0, /* record describing a jitted function */
-        JIT_CODE_MOVE = 1, /* record describing an already jitted function which
-                              is moved */
-        JIT_CODE_DEBUG_INFO = 2, /* record describing the debug information for
-                                    a jitted function */
-        JIT_CODE_CLOSE =
-                3, /* record marking the end of the jit runtime (optional) */
-        JIT_CODE_UNWINDING_INFO =
-                4 /* record describing a function unwinding information */
-    };
-
-    struct FileHeader {
-        Uint32 magic;
-        Uint32 version;
-        Uint32 total_size;
-        Uint32 elf_mach;
-        Uint32 pad1;
-        Uint32 pid;
-        Uint64 timestamp;
-        Uint64 flags;
-
-        FileHeader() {
-            magic = 0x4A695444; /* "JiTD" as numbers */
-            version = 1;
-            total_size = sizeof(FileHeader);
-            elf_mach = EM_X86_64;
-            pad1 = 0;
-            pid = getpid();
-            timestamp = erts_os_monotonic_time();
-            flags = 0;
-            ERTS_CT_ASSERT(sizeof(FileHeader) == 4 * 10);
-        }
-    };
-
-    struct RecordHeader {
-        Uint32 id;
-        Uint32 total_size;
-        Uint64 timestamp;
-    };
-
-public:
-    bool init() {
-        char name[MAXPATHLEN];
-        FileHeader header;
-
-        /* LLVM places this file in ~/.debug/jit/ maybe we should do that to? */
-
-        erts_snprintf(name, sizeof(name), "/tmp/jit-%d.dump", getpid());
-
-        file = fopen(name, "w+");
-
-        if (file) {
-            fwrite(&header, sizeof(header), 1, file);
-            /* inform perf of the location of the dump file */
-            void *addr = mmap(NULL,
-                              sizeof(header),
-                              PROT_READ | PROT_EXEC,
-                              MAP_PRIVATE,
-                              fileno(file),
-                              0);
-            if (addr == MAP_FAILED) {
-                int saved_errno = errno;
-                erts_dsprintf_buf_t *dsbuf = erts_create_logger_dsbuf();
-                erts_dsprintf(dsbuf,
-                              "perf: mmap of %s(%d) failed: %d\r\n",
-                              name,
-                              fileno(file),
-                              saved_errno);
-                erts_send_error_to_logger_nogl(dsbuf);
-                fclose(file);
-                file = nullptr;
-                return false;
-            }
-        } else {
-            int saved_errno = errno;
-            erts_dsprintf_buf_t *dsbuf = erts_create_logger_dsbuf();
-            erts_dsprintf(dsbuf,
-                          "perf: Failed to open %s (%d)",
-                          name,
-                          saved_errno);
-            erts_send_error_to_logger_nogl(dsbuf);
-            return false;
-        }
-        return true;
-    }
-
-    void update_perf_info(std::string modulename,
-                          std::vector<BeamAssembler::AsmRange> &ranges) {
-        struct JitCodeLoadRecord {
-            RecordHeader header;
-            Uint32 pid;
-            Uint32 tid;
-            Uint64 vma;
-            Uint64 code_addr;
-            Uint64 code_size;
-            Uint64 code_index;
-            /* Null terminated M:F/A */
-            /* Native code */
-        };
-        JitCodeLoadRecord record;
-        record.header.id = JIT_CODE_LOAD;
-        record.pid = getpid();
-        record.tid = erts_thr_self();
-        for (BeamAssembler::AsmRange &r : ranges) {
-            size_t nameLen = r.name.size();
-            ptrdiff_t codeSize = (char *)r.stop - (char *)r.start;
-            ASSERT(codeSize >= 0);
-            record.header.total_size = sizeof(record) + nameLen + 1 + codeSize;
-            record.vma = (Uint64)r.start;
-            record.code_addr = (Uint64)r.start;
-            record.code_size = (Uint64)codeSize;
-            record.code_index = ++code_index;
-            record.header.timestamp = erts_os_monotonic_time();
-
-            fwrite(&record, sizeof(record), 1, file);
-            fwrite(r.name.c_str(), nameLen + 1, 1, file);
-            fwrite(r.start, codeSize, 1, file);
-        }
-    }
-};
-
-#    endif
-
-class JitPerfMap {
-    FILE *file = nullptr;
-
-public:
-    bool init() {
-        char name[MAXPATHLEN];
-        snprintf(name, sizeof(name), "/tmp/perf-%i.map", getpid());
-        file = fopen(name, "w");
-        if (!file) {
-            int saved_errno = errno;
-            erts_dsprintf_buf_t *dsbuf = erts_create_logger_dsbuf();
-            erts_dsprintf(dsbuf,
-                          "perf: Failed to open %s (%d)",
-                          name,
-                          saved_errno);
-            erts_send_error_to_logger_nogl(dsbuf);
-            return false;
-        }
-        return true;
-    }
-    void update_perf_info(std::string modulename,
-                          std::vector<BeamAssembler::AsmRange> &ranges) {
-        for (BeamAssembler::AsmRange &r : ranges) {
-            char *start = (char *)r.start, *stop = (char *)r.stop;
-            ptrdiff_t size = stop - start;
-            fprintf(file, "%p %tx $%s\n", start, size, r.name.c_str());
-        }
-        fflush(file);
-    }
-};
-
-class JitPerfSupport {
-    enum PerfModes { NONE = 0, MAP = (1 << 0), DUMP = (1 << 1) };
-
-    int modes;
-
-    erts_mtx_t mutex;
-#    ifdef HAVE_LINUX_PERF_DUMP_SUPPORT
-    JitPerfDump perf_dump;
-#    endif
-    JitPerfMap perf_map;
-
-public:
-    JitPerfSupport() : modes(NONE) {
-    }
-    void init() {
-        modes = JitPerfSupport::NONE;
-#    ifdef HAVE_LINUX_PERF_DUMP_SUPPORT
-        if ((erts_jit_perf_support & BEAMASM_PERF_DUMP) && perf_dump.init()) {
-            modes |= JitPerfSupport::DUMP;
-        }
-#    endif
-        if ((erts_jit_perf_support & BEAMASM_PERF_MAP) && perf_map.init()) {
-            modes |= JitPerfSupport::MAP;
-        }
-
-        erts_mtx_init(&mutex,
-                      "perf",
-                      NIL,
-                      ERTS_LOCK_FLAGS_PROPERTY_STATIC |
-                              ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
-    }
-
-    void update_perf_info(std::string modulename,
-                          std::vector<BeamAssembler::AsmRange> &ranges) {
-        if (modes) {
-            erts_mtx_lock(&mutex);
-#    ifdef HAVE_LINUX_PERF_DUMP_SUPPORT
-            if (modes & DUMP) {
-                perf_dump.update_perf_info(modulename, ranges);
-            }
-#    endif
-            if (modes & MAP) {
-                perf_map.update_perf_info(modulename, ranges);
-            }
-            erts_mtx_unlock(&mutex);
-        }
-    }
-};
-
-static JitPerfSupport perf;
-
-void beamasm_init_perf() {
-    perf.init();
-}
-
-void beamasm_update_perf_info(std::string modulename,
-                              std::vector<BeamAssembler::AsmRange> &ranges) {
-    perf.update_perf_info(modulename, ranges);
-}
-#else
-void beamasm_init_perf() {
-}
-
-void beamasm_update_perf_info(std::string modulename,
-                              std::vector<BeamAssembler::AsmRange> &ranges) {
-    (void)modulename;
-    (void)ranges;
-}
-#endif
diff --git a/erts/emulator/beam/jit/x86/beam_asm.hpp b/erts/emulator/beam/jit/x86/beam_asm.hpp
index e2cb00395b..4b6199dd5e 100644
--- a/erts/emulator/beam/jit/x86/beam_asm.hpp
+++ b/erts/emulator/beam/jit/x86/beam_asm.hpp
@@ -857,15 +857,16 @@ public:
     struct AsmRange {
         ErtsCodePtr start;
         ErtsCodePtr stop;
-        std::string name;
+        const std::string name;
 
-        /* Not used yet */
-        std::string file;
-        unsigned line;
-    };
+        struct LineData {
+            ErtsCodePtr start;
+            const std::string file;
+            unsigned line;
+        };
 
-    void update_gdb_jit_info(std::string modulename,
-                             std::vector<AsmRange> &functions);
+        const std::vector<LineData> lines;
+    };
 };
 
 class BeamGlobalAssembler : public BeamAssembler {
@@ -1094,6 +1095,8 @@ public:
 
     void codegen(char *buff, size_t len);
 
+    void register_metadata(const BeamCodeHeader *header);
+
     ErtsCodePtr getCode(unsigned label);
     ErtsCodePtr getLambda(unsigned index);
 
@@ -1322,5 +1325,10 @@ protected:
     }
 };
 
-void beamasm_update_perf_info(std::string modulename,
-                              std::vector<BeamAssembler::AsmRange> &ranges);
+void beamasm_metadata_update(
+        std::string module_name,
+        ErtsCodePtr base_address,
+        size_t code_size,
+        const std::vector<BeamAssembler::AsmRange> &ranges);
+void beamasm_metadata_early_init();
+void beamasm_metadata_late_init();
diff --git a/erts/emulator/beam/jit/x86/beam_asm_global.cpp b/erts/emulator/beam/jit/x86/beam_asm_global.cpp
index 902c995227..3fea108adb 100644
--- a/erts/emulator/beam/jit/x86/beam_asm_global.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm_global.cpp
@@ -91,8 +91,10 @@ BeamGlobalAssembler::BeamGlobalAssembler(JitAllocator *allocator)
                           .name = code.labelEntry(labels[val.first])->name()});
     }
 
-    update_gdb_jit_info("global", ranges);
-    beamasm_update_perf_info("global", ranges);
+    beamasm_metadata_update("global",
+                            (ErtsCodePtr)getBaseAddress(),
+                            code.codeSize(),
+                            ranges);
 #endif
 
     /* `this->get_xxx` are populated last to ensure that we crash if we use them
diff --git a/erts/emulator/beam/jit/x86/beam_asm_module.cpp b/erts/emulator/beam/jit/x86/beam_asm_module.cpp
index 5edab64b0c..de7504c22e 100644
--- a/erts/emulator/beam/jit/x86/beam_asm_module.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm_module.cpp
@@ -89,11 +89,10 @@ BeamModuleAssembler::BeamModuleAssembler(BeamGlobalAssembler *_ga,
         for (unsigned int i = 1; i < num_labels; i++) {
             /* Large enough to hold most realistic function names. We will
              * truncate too long names, but as the label name is not important
-             * for the functioning of asmjit and this functionality is
+             * for the functioning of the JIT and this functionality is
              * probably only used by developers, we don't bother with dynamic
              * allocation. */
             char tmp[MAX_ATOM_SZ_LIMIT];
-            Label lbl;
 
             /* The named_labels are sorted, so no need for a search. */
             if ((unsigned int)e->label == i) {
diff --git a/erts/emulator/test/jit_SUITE.erl b/erts/emulator/test/jit_SUITE.erl
index d5acc11cf8..67de1b23dc 100644
--- a/erts/emulator/test/jit_SUITE.erl
+++ b/erts/emulator/test/jit_SUITE.erl
@@ -52,11 +52,13 @@ init_per_group(perf, Config) ->
             {skip, "perf not found"};
         _Perf ->
             PerfVsn = os:cmd("perf version"),
-            case re:run(PerfVsn, "perf version ([^.])",
+            case re:run(PerfVsn, "perf version (\\d+)\\.(\\d+)",
                         [{capture,all_but_first,list}]) of
-                {match,[Vsn]} ->
-                    case list_to_integer(Vsn) >= 5 of
-                        true ->
+                {match,[Major0,Minor0]} ->
+                    Major = list_to_integer(Major0),
+                    Minor = list_to_integer(Minor0),
+                    if
+                        Major > 5; Major =:= 5, Minor >= 11 ->
                             BuildIdDir = "--buildid-dir " ++
                                 filename:join(
                                   proplists:get_value(priv_dir, Config),
@@ -75,7 +77,7 @@ init_per_group(perf, Config) ->
                                 nomatch ->
                                     {skip, "could not run `"++ Cmd ++"`"}
                             end;
-                        false ->
+                        true ->
                             {skip,"too old perf version: " ++ PerfVsn}
                     end;
                 _ ->
@@ -157,20 +159,25 @@ annotate(Config) ->
 
     %% When doing "perf inject" the symbol of each function is changed
     %% from $lists:seq_loop/3 to lists:seq_loop/3. I don't know why that
-    %% is, seems like a very odd bug in perf... so we only include it
-    %% in our match if it exists
-    {match, Symbols} = re:run(Script, "\\$?lists:seq[^/]+/[0-9]+",
+    %% is, seems like a very odd bug in perf...
+    {match, Symbols} = re:run(Script, "lists:seq[^/]+/[0-9]+",
                               [global,{capture,first,list}]),
-    [Symbol|_] = lists:usort(Symbols),
+    [[Symbol]|_] = lists:usort(Symbols),
     JitFile = DataFile ++ ".jit.data",
-    "" = os:cmd("perf "++ BuildIdDir ++" inject -j -i " ++ DataFile ++ " -o " ++ JitFile),
+    "" = os:cmd("perf "++ BuildIdDir ++" inject --jit -i " ++ DataFile ++ " -o " ++ JitFile),
     Anno = os:cmd("perf "++ BuildIdDir ++" annotate --stdio -i " ++ JitFile ++ " " ++ Symbol ++ ""),
     case re:run(Anno,"Disassembly of section .text:") of
         {match,_} ->
-            ok;
+            case re:run(Anno, "lists\\.erl:\\d+") of
+                {match,_} ->
+                    ok;
+                nomatch ->
+                    ct:fail("Did not find source line annotation for ~ts.~n~ts",
+                            [Symbol, Anno])
+            end;
         nomatch ->
-            ct:log("Did not find disassembly test for ~ts.~n~ts",
-                   [Symbol, Anno])
+            ct:fail("Did not find disassembly for ~ts.~n~ts",
+                    [Symbol, Anno])
     end.
 
 get_tmp_asm_files() ->
diff --git a/erts/etc/unix/jit-reader.c b/erts/etc/unix/jit-reader.c
index 83481ba4f2..4b2714222a 100644
--- a/erts/etc/unix/jit-reader.c
+++ b/erts/etc/unix/jit-reader.c
@@ -22,66 +22,187 @@ static FILE *log = NULL;
 #define LOG(...)
 #endif
 
+typedef enum {
+    X64_RBP = 6,  /* Frame pointer iff native frames are enabled */
+    X64_RSP = 7,  /* Stack pointer when using native stack */
+    X64_R12 = 12, /* Stack pointer when using non-native stack */
+    X64_R13 = 13, /* Current process */
+    X64_RIP = 16
+} X64Register;
+
+typedef enum {
+    /* Return address only */
+    ERTS_FRAME_LAYOUT_RA,
+    /* Frame pointer, return address */
+    ERTS_FRAME_LAYOUT_FP_RA
+} ErtsFrameLayout;
+
+struct emulator_info {
+    /* 0 = regular, 1 = frame pointers */
+    int frame_layout;
+    const void *normal_exit;
+};
+
+struct module_info {
+    uint64_t base_address;
+    uint32_t range_count;
+    uint32_t code_size;
+    /* Module name, including null terminator. */
+    uint16_t name_length;
+    char name[];
+    /* array of range_info structures */
+};
+
+struct range_info {
+    uint32_t start_offset;
+    uint32_t end_offset;
+    uint32_t line_count;
+    /* Range name, including null terminator. */
+    uint16_t name_length;
+    char name[];
+    /* array of line_info structures */
+};
+
+struct line_info {
+    uint32_t start_offset;
+    uint32_t line_number;
+    /* File name, including null terminator. */
+    uint16_t file_length;
+    char file[];
+};
+
+enum debug_info_header {
+    DEBUG_INFO_HEADER_EMULATOR = 0,
+    DEBUG_INFO_HEADER_MODULE = 1,
+};
+
+struct debug_info {
+    enum debug_info_header header;
+    union {
+        struct emulator_info emu;
+        struct module_info mod;
+    } payload;
+};
 
 typedef struct range {
     GDB_CORE_ADDR start;
     GDB_CORE_ADDR end;
-    int global;
+#ifdef HARD_DEBUG
     char *name;
+#endif
 } range;
 
 typedef struct priv {
     range *ranges;
     int num_ranges;
-    uint64_t normal_exit;
+    ErtsFrameLayout frame_layout;
+    const void *normal_exit;
 } priv;
 
+static enum gdb_status read_module_info(struct gdb_reader_funcs *self,
+                                        struct gdb_symbol_callbacks *cb,
+                                        struct module_info *module_info) {
+    struct gdb_object *obj = cb->object_open(cb);
+    GDB_CORE_ADDR mod_start, mod_end;
+    char *symfile = (char*)module_info;
+    priv *priv = self->priv_data;
+
+    symfile += sizeof(*module_info) + module_info->name_length;
+
+    mod_start = module_info->base_address;
+    mod_end = mod_start + module_info->code_size;
+
+    priv->ranges = realloc(priv->ranges, (priv->num_ranges + 1) * sizeof(range));
+    priv->ranges[priv->num_ranges].start = mod_start;
+    priv->ranges[priv->num_ranges].end = mod_end;
+#ifdef HARD_DEBUG
+    priv->ranges[priv->num_ranges].name = strdup(module_info->name);
+#endif
+    priv->num_ranges += 1;
+
+    LOG("Add module `%s` (0x%lx, 0x%lx)\r\n",
+        module_info->name, mod_start, mod_end);
+
+    for (int range = 0; range < module_info->range_count; range++) {
+        struct range_info *range_info;
+        struct gdb_symtab *symtab;
+        GDB_CORE_ADDR begin, end;
+
+        range_info = (struct range_info *)symfile;
+        symfile += sizeof(*range_info) + range_info->name_length;
+
+        begin = mod_start + range_info->start_offset;
+        end = mod_start + range_info->end_offset;
+
+        LOG("Add range `%s` (0x%lx, 0x%lx), %u lines\r\n",
+            range_info->name,
+            begin, end,
+            range_info->line_count);
+
+        /* A bug in GDB < 9 forces us to open and close the symtab for each
+         * iteration. */
+        symtab = cb->symtab_open(cb, obj, module_info->name);
+        cb->block_open(cb, symtab, NULL, begin, end, range_info->name);
+        cb->symtab_close(cb, symtab);
+
+        for (int line = 0; line < range_info->line_count; line++) {
+            struct gdb_line_mapping line_mapping;
+            struct line_info *line_info;
+
+            line_info = (struct line_info *)symfile;
+            symfile += sizeof(*line_info) + line_info->file_length;
+
+            line_mapping.pc = mod_start + line_info->start_offset;
+            line_mapping.line = line_info->line_number;
+
+            LOG("\t%s:%u\r\n", line_info->file, line_info->line_number);
+
+            /* The symbol table must be opened and closed on every single line
+             * for file names to work properly, as there is no other way to
+             * tell GDB that a certain line belongs to a different file than
+             * the rest of the table. Sigh. */
+            symtab = cb->symtab_open(cb, obj, line_info->file);
+
+            cb->block_open(cb, symtab, NULL, line_mapping.pc, end,
+                           range_info->name);
+            cb->line_mapping_add(cb, symtab, 1, &line_mapping);
+            cb->symtab_close(cb, symtab);
+        }
+    }
+
+    cb->object_close(cb, obj);
+
+    return GDB_SUCCESS;
+}
+
+static enum gdb_status read_emulator_info(struct gdb_reader_funcs *self,
+                                          struct gdb_symbol_callbacks *cb,
+                                          struct emulator_info *emulator_info) {
+    priv *priv = self->priv_data;
+
+    priv->frame_layout = emulator_info->frame_layout;
+    priv->normal_exit = emulator_info->normal_exit;
+
+    LOG("initialize: frame layout = %i\r\n", priv->frame_layout);
+
+    return GDB_SUCCESS;
+}
 
 static enum gdb_status read_debug_info(struct gdb_reader_funcs *self,
                                        struct gdb_symbol_callbacks *cb,
                                        void *memory, long memory_sz) {
-    priv *priv = self->priv_data;
-    uint64_t num_functions = *(uint64_t*)memory;
-    if (num_functions == 0) {
-        /* Initialize */
-        priv->normal_exit = *(uint64_t*)(memory + sizeof(uint64_t));
-        LOG("initialize: normal_exit=%p\r\n",(void*)priv->normal_exit);
-    } else {
-        GDB_CORE_ADDR mod_start  = *(GDB_CORE_ADDR *)(memory + sizeof(uint64_t));
-        GDB_CORE_ADDR mod_end  = mod_start + *(uint64_t*)(memory + sizeof(uint64_t)*2);
-        char* module = memory + sizeof(uint64_t)*3;
-        char* curr = module + strlen(module) + 1;
-        int i;
-        struct gdb_object *obj = cb->object_open(cb);
-
-        priv->ranges = realloc(priv->ranges, sizeof(range) * ++priv->num_ranges);
-        priv->ranges[priv->num_ranges-1].start = mod_start;
-        priv->ranges[priv->num_ranges-1].end = mod_end;
-        priv->ranges[priv->num_ranges-1].name = strdup(module);
-        priv->ranges[priv->num_ranges-1].global = !strcmp(module, "global");
-
-        LOG("Add module %s (0x%lx, 0x%lx)\r\n", module, mod_start, mod_end);
-
-        for (i = 0; i < num_functions; i++) {
-            // get begin and end of code segment
-            // A bug in GDB < 9 forces us to open and close the symtab for each iteration
-            struct gdb_symtab *symtab = cb->symtab_open(cb, obj, module);
-            GDB_CORE_ADDR begin = *(GDB_CORE_ADDR*)curr;
-            GDB_CORE_ADDR end = *(GDB_CORE_ADDR*)(curr + sizeof(GDB_CORE_ADDR));
-            // get name of function
-            const char *name = (const char*)(curr + sizeof(GDB_CORE_ADDR) * 2);
-            curr += strlen(name) + 1 + sizeof(GDB_CORE_ADDR) * 2;
-
-            LOG("Add %s (0x%lx, 0x%lx)\r\n", name, begin, end);
-
-            // returned value has no use
-            cb->block_open(cb, symtab, NULL, begin, end, name);
-            cb->symtab_close(cb, symtab);
-        }
+    struct debug_info *debug_info = memory;
+
+    (void)memory_sz;
 
-        cb->object_close(cb, obj);
+    switch (debug_info->header) {
+    case DEBUG_INFO_HEADER_EMULATOR:
+        return read_emulator_info(self, cb, &debug_info->payload.emu);
+    case DEBUG_INFO_HEADER_MODULE:
+        return read_module_info(self, cb, &debug_info->payload.mod);
     }
-    return GDB_SUCCESS;
+
+    return GDB_FAIL;
 }
 
 static void regfree(struct gdb_reg_value *reg) {
@@ -89,132 +210,149 @@ static void regfree(struct gdb_reg_value *reg) {
 }
 
 static struct range *get_range(priv *priv, GDB_CORE_ADDR rip) {
-    int i;
-    for (i = 0; i < priv->num_ranges; i++)
-        if (rip >= priv->ranges[i].start && rip < priv->ranges[i].end)
+    for (int i = 0; i < priv->num_ranges; i++) {
+        if (rip >= priv->ranges[i].start && rip < priv->ranges[i].end) {
             return &priv->ranges[i];
+        }
+    }
+
     return NULL;
 }
 
-static enum gdb_status unwind(struct gdb_reader_funcs *self, struct gdb_unwind_callbacks *cb) {
-    int i;
-    priv *priv = self->priv_data;
-    GDB_CORE_ADDR rip = *(GDB_CORE_ADDR*)cb->reg_get(cb,16)->value;
-    GDB_CORE_ADDR rsp = *(GDB_CORE_ADDR*)cb->reg_get(cb,7)->value;
-    GDB_CORE_ADDR rbp = *(GDB_CORE_ADDR*)cb->reg_get(cb,6)->value;
-    struct range *range = get_range(priv, rip);
+static enum gdb_status unwind(struct gdb_reader_funcs *self,
+                              struct gdb_unwind_callbacks *cb) {
+    GDB_CORE_ADDR rbp, rsp, rip;
+    struct range *range;
+    priv *priv;
+
+    rbp = *(GDB_CORE_ADDR*)cb->reg_get(cb, X64_RBP)->value;
+    rsp = *(GDB_CORE_ADDR*)cb->reg_get(cb, X64_RSP)->value;
+    rip = *(GDB_CORE_ADDR*)cb->reg_get(cb, X64_RIP)->value;
+
+    priv = self->priv_data;
+    range = get_range(priv, rip);
 
     /* Check that rip points to one of the addresses that we handle */
     if (range) {
-        struct gdb_reg_value *prev_rsp = malloc(sizeof(struct gdb_reg_value) + sizeof(char*)),
-            *prev_rip = malloc(sizeof(struct gdb_reg_value) + sizeof(char*)),
-            *prev_rbp = malloc(sizeof(struct gdb_reg_value) + sizeof(char*));
-
-        LOG("UNWIND match %s: rip: 0x%lx rsp: 0x%lx rbp: 0x%lx \r\n", range->name, rip, rsp, rbp);
-        /* We use the normal frame-pointer logic to unwind the stack, which means
-           that rbp will point to where we stored the previous frames rbp. Also
-           the previous frames address will be at rbp + 1 and the previous frames
-           rsp will be rbp + 2.
-
-           0x00:                <- prev_rsp
-           0x80: prev call addr
-           0x10: prev rbp       <- curr rbp
-           0x18: current frame
-           0x20:                <- curr rip
-
-        */
-
-        for (i = 0; i < 16; i++) {
-            if (i != 16 && i != 7 && i != 6) {
-                struct gdb_reg_value *reg = malloc(sizeof(struct gdb_reg_value) + sizeof(char*));
-                reg->free = &regfree;
-                reg->defined = 1;
-                reg->size = sizeof(char*);
-                *(GDB_CORE_ADDR*)reg->value = *(GDB_CORE_ADDR*)cb->reg_get(cb,i)->value;
-                cb->reg_set(cb, i, reg);
-            }
-        }
+        struct gdb_reg_value *prev_rbp, *prev_rsp, *prev_rip;
+
+        prev_rbp = malloc(sizeof(struct gdb_reg_value) + sizeof(char*));
+        prev_rsp = malloc(sizeof(struct gdb_reg_value) + sizeof(char*));
+        prev_rip = malloc(sizeof(struct gdb_reg_value) + sizeof(char*));
+
+        LOG("UNWIND match %s: rbp: 0x%lx rsp: 0x%lx rip: 0x%lx  \r\n",
+            range->name, rbp, rsp, rip);
 
-        prev_rsp->free = &regfree;
-        prev_rsp->defined = 1;
-        prev_rsp->size = sizeof(char*);
         prev_rbp->free = &regfree;
         prev_rbp->defined = 1;
         prev_rbp->size = sizeof(char*);
+        prev_rsp->free = &regfree;
+        prev_rsp->defined = 1;
+        prev_rsp->size = sizeof(char*);
         prev_rip->free = &regfree;
         prev_rip->defined = 1;
         prev_rip->size = sizeof(char*);
 
-        if (range->global) {
-
-            cb->target_read(rbp + 1 * sizeof(char*), &prev_rip->value, sizeof(char*));
-            ((GDB_CORE_ADDR*)prev_rsp->value)[0] = rbp + sizeof(char*) * 2;
-            cb->target_read(rbp + 0 * sizeof(char*), &prev_rbp->value, sizeof(char*));
-
+        if (priv->frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
+            /* Frame pointers are enabled, which means that rbp will point to
+             * where we stored the previous frames rbp. Also the previous
+             * frames address will be at rbp + 8 and the previous frames rsp
+             * will be rbp + 16.
+             *
+             *  0x00:                <- prev_rsp
+             *  0x08: prev call addr
+             *  0x10: prev rbp       <- curr rbp
+             *  0x18: current frame
+             *  0x20:                <- curr rip */
+            cb->target_read(rbp + 1 * sizeof(char*), &prev_rip->value,
+                            sizeof(char*));
+            cb->target_read(rbp + 0 * sizeof(char*), &prev_rbp->value,
+                            sizeof(char*));
+            *(GDB_CORE_ADDR*)prev_rsp->value = rbp + sizeof(char*[2]);
         } else {
+            /* Normal frame layout, we need to scan the stack. */
+            cb->target_read(rsp, &prev_rip->value, sizeof(char*));
 
-            if (rip == priv->normal_exit) {
-                LOG("Normal exit\r\n");
-                ((GDB_CORE_ADDR*)prev_rsp->value)[0] = rsp;
-                ((GDB_CORE_ADDR*)prev_rbp->value)[0] = rbp;
-                ((GDB_CORE_ADDR*)prev_rip->value)[0] = rip;
-            } else {
+            for (rsp += sizeof(char*); ; rsp += sizeof(char*)) {
                 cb->target_read(rsp, &prev_rip->value, sizeof(char*));
 
-                for (rsp += sizeof(char*); ; rsp += sizeof(char*)) {
-                    cb->target_read(rsp, &prev_rip->value, sizeof(char*));
-                    LOG("rsp: 0x%lx rip: 0x%lx\r\n", rsp, *(GDB_CORE_ADDR*)prev_rip->value);
-                    /* Check if it is a cp */
-                    if ((*(GDB_CORE_ADDR*)prev_rip->value & 0x3) == 0) {
-                        break;
-                    }
+                LOG("rsp: 0x%lx rip: 0x%lx\r\n",
+                    rsp, *(GDB_CORE_ADDR*)prev_rip->value);
+
+                /* Check if it is a cp */
+                if ((*(GDB_CORE_ADDR*)prev_rip->value & 0x3) == 0) {
+                    break;
                 }
-                ((GDB_CORE_ADDR*)prev_rsp->value)[0] = rsp;
-                ((GDB_CORE_ADDR*)prev_rbp->value)[0] = rsp - sizeof(char*);
             }
+
+            *(GDB_CORE_ADDR*)prev_rsp->value = rsp;
+            *(GDB_CORE_ADDR*)prev_rbp->value = rsp - sizeof(char*);
+        }
+
+        if (*(GDB_CORE_ADDR*)prev_rip->value == (uintptr_t)priv->normal_exit) {
+            LOG("Normal exit\r\n");
+            *(GDB_CORE_ADDR*)prev_rsp->value = 0;
+            *(GDB_CORE_ADDR*)prev_rbp->value = 0;
+        } else {
+            LOG("UNWIND prev: rbp: 0x%lx rsp: 0x%lx rip: 0x%lx\r\n",
+                *(GDB_CORE_ADDR*)prev_rbp->value,
+                *(GDB_CORE_ADDR*)prev_rsp->value,
+                *(GDB_CORE_ADDR*)prev_rip->value);
         }
 
-        LOG("UNWIND prev: rip: 0x%lx rsp: 0x%lx rbp: 0x%lx\r\n",
-            *(GDB_CORE_ADDR*)prev_rip->value,
-            *(GDB_CORE_ADDR*)prev_rsp->value,
-            *(GDB_CORE_ADDR*)prev_rbp->value);
+        cb->reg_set(cb, X64_RIP, prev_rip);
+        cb->reg_set(cb, X64_RSP, prev_rsp);
+        cb->reg_set(cb, X64_RBP, prev_rbp);
 
-        cb->reg_set(cb, 16, prev_rip);
-        cb->reg_set(cb, 7, prev_rsp);
-        cb->reg_set(cb, 6, prev_rbp);
         return GDB_SUCCESS;
     }
-    LOG("UNWIND no match: rip: 0x%lx rsp: 0x%lx rbp: 0x%lx\r\n", rip, rsp, rbp);
+
+    LOG("UNWIND no match: rbp: 0x%lx rsp: 0x%lx rip: 0x%lx\r\n", rbp, rsp, rip);
     return GDB_FAIL;
 }
 
-static struct gdb_frame_id get_frame_id(struct gdb_reader_funcs *self, struct gdb_unwind_callbacks *cb){
-    priv *priv = self->priv_data;
+static struct gdb_frame_id get_frame_id(struct gdb_reader_funcs *self,
+                                        struct gdb_unwind_callbacks *cb){
     struct gdb_frame_id frame = {0, 0};
-    GDB_CORE_ADDR rip = *(GDB_CORE_ADDR*)cb->reg_get(cb,16)->value;
-    GDB_CORE_ADDR rbp = *(GDB_CORE_ADDR*)cb->reg_get(cb,6)->value;
-    GDB_CORE_ADDR rsp = *(GDB_CORE_ADDR*)cb->reg_get(cb,7)->value;
-    struct range *range = get_range(priv, rip);
+    GDB_CORE_ADDR rbp, rsp, rip;
+    struct range *range;
+    priv *priv;
+
+    rbp = *(GDB_CORE_ADDR*)cb->reg_get(cb, X64_RBP)->value;
+    rsp = *(GDB_CORE_ADDR*)cb->reg_get(cb, X64_RSP)->value;
+    rip = *(GDB_CORE_ADDR*)cb->reg_get(cb, X64_RIP)->value;
+
+    priv = self->priv_data;
+    range = get_range(priv, rip);
+
     LOG("FRAME: rip: 0x%lx rsp: 0x%lx rbp: 0x%lx \r\n", rip, rsp, rbp);
+
     if (range) {
         frame.code_address = rip;
-        if (range->global) {
+
+        if (priv->frame_layout == ERTS_FRAME_LAYOUT_FP_RA) {
             frame.stack_address = rbp + sizeof(char*);
         } else {
             GDB_CORE_ADDR prev_rip;
+
             for (rsp += sizeof(char*); ; rsp += sizeof(char*)) {
                 cb->target_read(rsp, &prev_rip, sizeof(char*));
+
                 LOG("rsp: 0x%lx rip: 0x%lx\r\n", rsp, prev_rip);
+
                 /* Check if it is a cp */
                 if ((prev_rip & 0x3) == 0) {
                     break;
                 }
             }
+
             frame.stack_address = rsp;
         }
     }
+
     LOG("FRAME: code_address: 0x%lx stack_address: 0x%lx\r\n",
         frame.code_address, frame.stack_address);
+
     return frame;
 }
 
@@ -225,6 +363,7 @@ static void destroy(struct gdb_reader_funcs *self){
 struct gdb_reader_funcs *gdb_init_reader(void){
     struct gdb_reader_funcs *funcs = malloc(sizeof(struct gdb_reader_funcs));
     priv *priv_data = malloc(sizeof(priv));
+
     priv_data->num_ranges = 1;
     priv_data->ranges = malloc(sizeof(range));
     priv_data->ranges[0].start = 0;
-- 
2.31.1

Places

File 1206-jit-Provide-Erlang-line-information-to-gdb-and-perf.patch of Package erlang (Revision b47b3d0a87f21630280b8ed6f4d34508)

Places