8 files changed, 768 insertions, 39 deletions

diff --git a/tools/perf/jvmti/jvmti_agent.c b/tools/perf/jvmti/jvmti_agent.c
index cbab139de5a4..6461e02ab940 100644
--- a/tools/perf/jvmti/jvmti_agent.c
+++ b/tools/perf/jvmti/jvmti_agent.c
@@ -374,20 +374,20 @@ jvmti_write_code(void *agent, char const *sym,
 
 int
 jvmti_write_debug_info(void *agent, uint64_t code, const char *file,
-                       jvmtiAddrLocationMap const *map,
-                       jvmtiLineNumberEntry *li, jint num)
+                       jvmti_line_info_t *li, int nr_lines)
 {
-        static const char *prev_str = "\xff";
         struct jr_code_debug_info rec;
         size_t sret, len, size, flen;
         size_t padding_count;
+        uint64_t addr;
+        const char *fn = file;
         FILE *fp = agent;
         int i;
 
         /*
          * no entry to write
          */
-        if (!num)
+        if (!nr_lines)
                 return 0;
 
         if (!fp) {
@@ -401,17 +401,18 @@ jvmti_write_debug_info(void *agent, uint64_t code, const char *file,
         size            = sizeof(rec);
         rec.p.timestamp = perf_get_timestamp();
         rec.code_addr   = (uint64_t)(uintptr_t)code;
-        rec.nr_entry    = num;
+        rec.nr_entry    = nr_lines;
 
         /*
          * on disk source line info layout:
          * uint64_t : addr
          * int      : line number
+         * int      : column discriminator
          * file[]   : source file name
          * padding  : pad to multiple of 8 bytes
          */
-        size += num * (sizeof(uint64_t) + sizeof(int));
-        size += flen + (num - 1) * 2;
+        size += nr_lines * sizeof(struct debug_entry);
+        size += flen * nr_lines;
         /*
          * pad to 8 bytes
          */
@@ -429,28 +430,27 @@ jvmti_write_debug_info(void *agent, uint64_t code, const char *file,
         if (sret != 1)
                 goto error;
 
-        for (i = 0; i < num; i++) {
-                uint64_t addr;
+        for (i = 0; i < nr_lines; i++) {
 
-                addr = (uint64_t)map[i].start_address;
+                addr = (uint64_t)li[i].pc;
                 len  = sizeof(addr);
                 sret = fwrite_unlocked(&addr, len, 1, fp);
                 if (sret != 1)
                         goto error;
 
-                len  = sizeof(int);
+                len  = sizeof(li[0].line_number);
                 sret = fwrite_unlocked(&li[i].line_number, len, 1, fp);
                 if (sret != 1)
                         goto error;
 
-                if (i == 0) {
-                        sret = fwrite_unlocked(file, flen, 1, fp);
-                } else {
-                        sret = fwrite_unlocked(prev_str, 2, 1, fp);
-                }
+                len  = sizeof(li[0].discrim);
+                sret = fwrite_unlocked(&li[i].discrim, len, 1, fp);
                 if (sret != 1)
                         goto error;
 
+                sret = fwrite_unlocked(fn, flen, 1, fp);
+                if (sret != 1)
+                        goto error;
         }
         if (padding_count)
                 sret = fwrite_unlocked(pad_bytes, padding_count, 1, fp);
diff --git a/tools/perf/jvmti/jvmti_agent.h b/tools/perf/jvmti/jvmti_agent.h
index 8251a1c5ee3f..bedf5d0ba9ff 100644
--- a/tools/perf/jvmti/jvmti_agent.h
+++ b/tools/perf/jvmti/jvmti_agent.h
@@ -11,16 +11,23 @@
 extern "C" {
 #endif
 
+typedef struct {
+        unsigned long   pc;
+        int             line_number;
+        int             discrim; /* discriminator -- 0 for now */
+} jvmti_line_info_t;
+
 void *jvmti_open(void);
 int   jvmti_close(void *agent);
 int   jvmti_write_code(void *agent, char const *symbol_name,
                        uint64_t vma, void const *code,
                        const unsigned int code_size);
+
 int   jvmti_write_debug_info(void *agent,
                              uint64_t code,
                              const char *file,
-                             jvmtiAddrLocationMap const *map,
-                             jvmtiLineNumberEntry *tab, jint nr);
+                             jvmti_line_info_t *li,
+                             int nr_lines);
 
 #if defined(__cplusplus)
 }
diff --git a/tools/perf/jvmti/libjvmti.c b/tools/perf/jvmti/libjvmti.c
index 92ffbe4ff160..ac12e4b91a92 100644
--- a/tools/perf/jvmti/libjvmti.c
+++ b/tools/perf/jvmti/libjvmti.c
@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include <err.h>
 #include <jvmti.h>
+#include <jvmticmlr.h>
 #include <limits.h>
 
 #include "jvmti_agent.h"
@@ -11,6 +12,100 @@
 static int has_line_numbers;
 void *jvmti_agent;
 
+static jvmtiError
+do_get_line_numbers(jvmtiEnv *jvmti, void *pc, jmethodID m, jint bci,
+                    jvmti_line_info_t *tab, jint *nr)
+{
+        jint i, lines = 0;
+        jint nr_lines = 0;
+        jvmtiLineNumberEntry *loc_tab = NULL;
+        jvmtiError ret;
+
+        ret = (*jvmti)->GetLineNumberTable(jvmti, m, &nr_lines, &loc_tab);
+        if (ret != JVMTI_ERROR_NONE)
+                return ret;
+
+        for (i = 0; i < nr_lines; i++) {
+                if (loc_tab[i].start_location < bci) {
+                        tab[lines].pc = (unsigned long)pc;
+                        tab[lines].line_number = loc_tab[i].line_number;
+                        tab[lines].discrim = 0; /* not yet used */
+                        lines++;
+                } else {
+                        break;
+                }
+        }
+        (*jvmti)->Deallocate(jvmti, (unsigned char *)loc_tab);
+        *nr = lines;
+        return JVMTI_ERROR_NONE;
+}
+
+static jvmtiError
+get_line_numbers(jvmtiEnv *jvmti, const void *compile_info, jvmti_line_info_t **tab, int *nr_lines)
+{
+        const jvmtiCompiledMethodLoadRecordHeader *hdr;
+        jvmtiCompiledMethodLoadInlineRecord *rec;
+        jvmtiLineNumberEntry *lne = NULL;
+        PCStackInfo *c;
+        jint nr, ret;
+        int nr_total = 0;
+        int i, lines_total = 0;
+
+        if (!(tab && nr_lines))
+                return JVMTI_ERROR_NULL_POINTER;
+
+        /*
+         * Phase 1 -- get the number of lines necessary
+         */
+        for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
+                if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
+                        rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
+                        for (i = 0; i < rec->numpcs; i++) {
+                                c = rec->pcinfo + i;
+                                nr = 0;
+                                /*
+                                 * unfortunately, need a tab to get the number of lines!
+                                 */
+                                ret = (*jvmti)->GetLineNumberTable(jvmti, c->methods[0], &nr, &lne);
+                                if (ret == JVMTI_ERROR_NONE) {
+                                        /* free what was allocated for nothing */
+                                        (*jvmti)->Deallocate(jvmti, (unsigned char *)lne);
+                                        nr_total += (int)nr;
+                                }
+                        }
+                }
+        }
+
+        if (nr_total == 0)
+                return JVMTI_ERROR_NOT_FOUND;
+
+        /*
+         * Phase 2 -- allocate big enough line table
+         */
+        *tab = malloc(nr_total * sizeof(**tab));
+        if (!*tab)
+                return JVMTI_ERROR_OUT_OF_MEMORY;
+
+        for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
+                if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
+                        rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
+                        for (i = 0; i < rec->numpcs; i++) {
+                                c = rec->pcinfo + i;
+                                nr = 0;
+                                ret = do_get_line_numbers(jvmti, c->pc,
+                                                          c->methods[0],
+                                                          c->bcis[0],
+                                                          *tab + lines_total,
+                                                          &nr);
+                                if (ret == JVMTI_ERROR_NONE)
+                                        lines_total += nr;
+                        }
+                }
+        }
+        *nr_lines = lines_total;
+        return JVMTI_ERROR_NONE;
+}
+
 static void JNICALL
 compiled_method_load_cb(jvmtiEnv *jvmti,
                         jmethodID method,
@@ -18,9 +113,9 @@ compiled_method_load_cb(jvmtiEnv *jvmti,
                         void const *code_addr,
                         jint map_length,
                         jvmtiAddrLocationMap const *map,
-                        void const *compile_info __unused)
+                        const void *compile_info)
 {
-        jvmtiLineNumberEntry *tab = NULL;
+        jvmti_line_info_t *line_tab = NULL;
         jclass decl_class;
         char *class_sign = NULL;
         char *func_name = NULL;
@@ -29,7 +124,7 @@ compiled_method_load_cb(jvmtiEnv *jvmti,
         char fn[PATH_MAX];
         uint64_t addr = (uint64_t)(uintptr_t)code_addr;
         jvmtiError ret;
-        jint nr_lines = 0;
+        int nr_lines = 0; /* in line_tab[] */
         size_t len;
 
         ret = (*jvmti)->GetMethodDeclaringClass(jvmti, method,
@@ -40,19 +135,19 @@ compiled_method_load_cb(jvmtiEnv *jvmti,
         }
 
         if (has_line_numbers && map && map_length) {
-
-                ret = (*jvmti)->GetLineNumberTable(jvmti, method, &nr_lines, &tab);
+                ret = get_line_numbers(jvmti, compile_info, &line_tab, &nr_lines);
                 if (ret != JVMTI_ERROR_NONE) {
                         warnx("jvmti: cannot get line table for method");
-                } else {
-                        ret = (*jvmti)->GetSourceFileName(jvmti, decl_class, &file_name);
-                        if (ret != JVMTI_ERROR_NONE) {
-                                warnx("jvmti: cannot get source filename ret=%d", ret);
-                                nr_lines = 0;
-                        }
+                        nr_lines = 0;
                 }
         }
 
+        ret = (*jvmti)->GetSourceFileName(jvmti, decl_class, &file_name);
+        if (ret != JVMTI_ERROR_NONE) {
+                warnx("jvmti: cannot get source filename ret=%d", ret);
+                goto error;
+        }
+
         ret = (*jvmti)->GetClassSignature(jvmti, decl_class,
                                           &class_sign, NULL);
         if (ret != JVMTI_ERROR_NONE) {
@@ -92,13 +187,14 @@ compiled_method_load_cb(jvmtiEnv *jvmti,
         /*
          * write source line info record if we have it
          */
-        if (jvmti_write_debug_info(jvmti_agent, addr, fn, map, tab, nr_lines))
+        if (jvmti_write_debug_info(jvmti_agent, addr, fn, line_tab, nr_lines))
                 warnx("jvmti: write_debug_info() failed");
 
         len = strlen(func_name) + strlen(class_sign) + strlen(func_sign) + 2;
         {
                 char str[len];
                 snprintf(str, len, "%s%s%s", class_sign, func_name, func_sign);
+
                 if (jvmti_write_code(jvmti_agent, str, addr, code_addr, code_size))
                         warnx("jvmti: write_code() failed");
         }
@@ -106,8 +202,8 @@ error:
         (*jvmti)->Deallocate(jvmti, (unsigned char *)func_name);
         (*jvmti)->Deallocate(jvmti, (unsigned char *)func_sign);
         (*jvmti)->Deallocate(jvmti, (unsigned char *)class_sign);
-        (*jvmti)->Deallocate(jvmti, (unsigned char *)tab);
         (*jvmti)->Deallocate(jvmti, (unsigned char *)file_name);
+        free(line_tab);
 }
 
 static void JNICALL
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
index 52a4a806ee2f..a34752d28488 100644
--- a/tools/perf/util/Build
+++ b/tools/perf/util/Build
@@ -108,8 +108,11 @@ libperf-$(CONFIG_LZMA) += lzma.o
 libperf-y += demangle-java.o
 libperf-$(CONFIG_LIBELF) += jitdump.o
 libperf-$(CONFIG_LIBELF) += genelf.o
+libperf-$(CONFIG_LIBELF) += genelf_debug.o
 
 CFLAGS_config.o   += -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+# avoid compiler warnings in 32-bit mode
+CFLAGS_genelf_debug.o  += -Wno-packed
 
 $(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
         $(call rule_mkdir)
diff --git a/tools/perf/util/genelf.c b/tools/perf/util/genelf.c
index 145f8116ef56..c1ef805c6a8f 100644
--- a/tools/perf/util/genelf.c
+++ b/tools/perf/util/genelf.c
@@ -156,7 +156,8 @@ gen_build_id(struct buildid_note *note, unsigned long load_addr, const void *cod
  */
 int
 jit_write_elf(int fd, uint64_t load_addr, const char *sym,
-              const void *code, int csize)
+              const void *code, int csize,
+              void *debug, int nr_debug_entries)
 {
         Elf *e;
         Elf_Data *d;
@@ -385,9 +386,15 @@ jit_write_elf(int fd, uint64_t load_addr, const char *sym,
         shdr->sh_size = sizeof(bnote);
         shdr->sh_entsize = 0;
 
-        if (elf_update(e, ELF_C_WRITE) < 0) {
-                warnx("elf_update 4 failed");
-                goto error;
+        if (debug && nr_debug_entries) {
+                retval = jit_add_debug_info(e, load_addr, debug, nr_debug_entries);
+                if (retval)
+                        goto error;
+        } else {
+                if (elf_update(e, ELF_C_WRITE) < 0) {
+                        warnx("elf_update 4 failed");
+                        goto error;
+                }
         }
 
         retval = 0;
diff --git a/tools/perf/util/genelf.h b/tools/perf/util/genelf.h
index d8e9ece13c8b..45bf9c6d3257 100644
--- a/tools/perf/util/genelf.h
+++ b/tools/perf/util/genelf.h
@@ -3,7 +3,11 @@
 
 /* genelf.c */
 extern int jit_write_elf(int fd, uint64_t code_addr, const char *sym,
-                         const void *code, int csize);
+                         const void *code, int csize,
+                         void *debug, int nr_debug_entries);
+/* genelf_debug.c */
+extern int jit_add_debug_info(Elf *e, uint64_t code_addr,
+                              void *debug, int nr_debug_entries);
 
 #if   defined(__arm__)
 #define GEN_ELF_ARCH    EM_ARM
diff --git a/tools/perf/util/genelf_debug.c b/tools/perf/util/genelf_debug.c
new file mode 100644
index 000000000000..5980f7d256b1
--- /dev/null
+++ b/tools/perf/util/genelf_debug.c
@@ -0,0 +1,610 @@
+/*
+ * genelf_debug.c
+ * Copyright (C) 2015, Google, Inc
+ *
+ * Contributed by:
+ *      Stephane Eranian <eranian@google.com>
+ *
+ * Released under the GPL v2.
+ *
+ * based on GPLv2 source code from Oprofile
+ * @remark Copyright 2007 OProfile authors
+ * @author Philippe Elie
+ */
+#include <sys/types.h>
+#include <stdio.h>
+#include <getopt.h>
+#include <stddef.h>
+#include <libelf.h>
+#include <string.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <err.h>
+#include <dwarf.h>
+
+#include "perf.h"
+#include "genelf.h"
+#include "../util/jitdump.h"
+
+#define BUFFER_EXT_DFL_SIZE     (4 * 1024)
+
+typedef uint32_t uword;
+typedef uint16_t uhalf;
+typedef int32_t  sword;
+typedef int16_t  shalf;
+typedef uint8_t  ubyte;
+typedef int8_t   sbyte;
+
+struct buffer_ext {
+        size_t cur_pos;
+        size_t max_sz;
+        void *data;
+};
+
+static void
+buffer_ext_dump(struct buffer_ext *be, const char *msg)
+{
+        size_t i;
+        warnx("DUMP for %s", msg);
+        for (i = 0 ; i < be->cur_pos; i++)
+                warnx("%4zu 0x%02x", i, (((char *)be->data)[i]) & 0xff);
+}
+
+static inline int
+buffer_ext_add(struct buffer_ext *be, void *addr, size_t sz)
+{
+        void *tmp;
+        size_t be_sz = be->max_sz;
+
+retry:
+        if ((be->cur_pos + sz) < be_sz) {
+                memcpy(be->data + be->cur_pos, addr, sz);
+                be->cur_pos += sz;
+                return 0;
+        }
+
+        if (!be_sz)
+                be_sz = BUFFER_EXT_DFL_SIZE;
+        else
+                be_sz <<= 1;
+
+        tmp = realloc(be->data, be_sz);
+        if (!tmp)
+                return -1;
+
+        be->data   = tmp;
+        be->max_sz = be_sz;
+
+        goto retry;
+}
+
+static void
+buffer_ext_init(struct buffer_ext *be)
+{
+        be->data = NULL;
+        be->cur_pos = 0;
+        be->max_sz = 0;
+}
+
+static inline size_t
+buffer_ext_size(struct buffer_ext *be)
+{
+        return be->cur_pos;
+}
+
+static inline void *
+buffer_ext_addr(struct buffer_ext *be)
+{
+        return be->data;
+}
+
+struct debug_line_header {
+        // Not counting this field
+        uword total_length;
+        // version number (2 currently)
+        uhalf version;
+        // relative offset from next field to
+        // program statement
+        uword prolog_length;
+        ubyte minimum_instruction_length;
+        ubyte default_is_stmt;
+        // line_base - see DWARF 2 specs
+        sbyte line_base;
+        // line_range - see DWARF 2 specs
+        ubyte line_range;
+        // number of opcode + 1
+        ubyte opcode_base;
+        /* follow the array of opcode args nr: ubytes [nr_opcode_base] */
+        /* follow the search directories index, zero terminated string
+         * terminated by an empty string.
+         */
+        /* follow an array of { filename, LEB128, LEB128, LEB128 }, first is
+         * the directory index entry, 0 means current directory, then mtime
+         * and filesize, last entry is followed by en empty string.
+         */
+        /* follow the first program statement */
+} __attribute__((packed));
+
+/* DWARF 2 spec talk only about one possible compilation unit header while
+ * binutils can handle two flavours of dwarf 2, 32 and 64 bits, this is not
+ * related to the used arch, an ELF 32 can hold more than 4 Go of debug
+ * information. For now we handle only DWARF 2 32 bits comp unit. It'll only
+ * become a problem if we generate more than 4GB of debug information.
+ */
+struct compilation_unit_header {
+        uword total_length;
+        uhalf version;
+        uword debug_abbrev_offset;
+        ubyte pointer_size;
+} __attribute__((packed));
+
+#define DW_LNS_num_opcode (DW_LNS_set_isa + 1)
+
+/* field filled at run time are marked with -1 */
+static struct debug_line_header const default_debug_line_header = {
+        .total_length = -1,
+        .version = 2,
+        .prolog_length = -1,
+        .minimum_instruction_length = 1,        /* could be better when min instruction size != 1 */
+        .default_is_stmt = 1,   /* we don't take care about basic block */
+        .line_base = -5,        /* sensible value for line base ... */
+        .line_range = -14,     /* ... and line range are guessed statically */
+        .opcode_base = DW_LNS_num_opcode
+};
+
+static ubyte standard_opcode_length[] =
+{
+        0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1
+};
+#if 0
+{
+        [DW_LNS_advance_pc]   = 1,
+        [DW_LNS_advance_line] = 1,
+        [DW_LNS_set_file] =  1,
+        [DW_LNS_set_column] = 1,
+        [DW_LNS_fixed_advance_pc] = 1,
+        [DW_LNS_set_isa] = 1,
+};
+#endif
+
+/* field filled at run time are marked with -1 */
+static struct compilation_unit_header default_comp_unit_header = {
+        .total_length = -1,
+        .version = 2,
+        .debug_abbrev_offset = 0,     /* we reuse the same abbrev entries for all comp unit */
+        .pointer_size = sizeof(void *)
+};
+
+static void emit_uword(struct buffer_ext *be, uword data)
+{
+        buffer_ext_add(be, &data, sizeof(uword));
+}
+
+static void emit_string(struct buffer_ext *be, const char *s)
+{
+        buffer_ext_add(be, (void *)s, strlen(s) + 1);
+}
+
+static void emit_unsigned_LEB128(struct buffer_ext *be,
+                                 unsigned long data)
+{
+        do {
+                ubyte cur = data & 0x7F;
+                data >>= 7;
+                if (data)
+                        cur |= 0x80;
+                buffer_ext_add(be, &cur, 1);
+        } while (data);
+}
+
+static void emit_signed_LEB128(struct buffer_ext *be, long data)
+{
+        int more = 1;
+        int negative = data < 0;
+        int size = sizeof(long) * CHAR_BIT;
+        while (more) {
+                ubyte cur = data & 0x7F;
+                data >>= 7;
+                if (negative)
+                        data |= - (1 << (size - 7));
+                if ((data == 0 && !(cur & 0x40)) ||
+                    (data == -1l && (cur & 0x40)))
+                        more = 0;
+                else
+                        cur |= 0x80;
+                buffer_ext_add(be, &cur, 1);
+        }
+}
+
+static void emit_extended_opcode(struct buffer_ext *be, ubyte opcode,
+                                 void *data, size_t data_len)
+{
+        buffer_ext_add(be, (char *)"", 1);
+
+        emit_unsigned_LEB128(be, data_len + 1);
+
+        buffer_ext_add(be, &opcode, 1);
+        buffer_ext_add(be, data, data_len);
+}
+
+static void emit_opcode(struct buffer_ext *be, ubyte opcode)
+{
+        buffer_ext_add(be, &opcode, 1);
+}
+
+static void emit_opcode_signed(struct buffer_ext  *be,
+                               ubyte opcode, long data)
+{
+        buffer_ext_add(be, &opcode, 1);
+        emit_signed_LEB128(be, data);
+}
+
+static void emit_opcode_unsigned(struct buffer_ext *be, ubyte opcode,
+                                 unsigned long data)
+{
+        buffer_ext_add(be, &opcode, 1);
+        emit_unsigned_LEB128(be, data);
+}
+
+static void emit_advance_pc(struct buffer_ext *be, unsigned long delta_pc)
+{
+        emit_opcode_unsigned(be, DW_LNS_advance_pc, delta_pc);
+}
+
+static void emit_advance_lineno(struct buffer_ext  *be, long delta_lineno)
+{
+        emit_opcode_signed(be, DW_LNS_advance_line, delta_lineno);
+}
+
+static void emit_lne_end_of_sequence(struct buffer_ext *be)
+{
+        emit_extended_opcode(be, DW_LNE_end_sequence, NULL, 0);
+}
+
+static void emit_set_file(struct buffer_ext *be, unsigned long idx)
+{
+        emit_opcode_unsigned(be, DW_LNS_set_file, idx);
+}
+
+static void emit_lne_define_filename(struct buffer_ext *be,
+                                     const char *filename)
+{
+        buffer_ext_add(be, (void *)"", 1);
+
+        /* LNE field, strlen(filename) + zero termination, 3 bytes for: the dir entry, timestamp, filesize */
+        emit_unsigned_LEB128(be, strlen(filename) + 5);
+        emit_opcode(be, DW_LNE_define_file);
+        emit_string(be, filename);
+        /* directory index 0=do not know */
+        emit_unsigned_LEB128(be, 0);
+        /* last modification date on file 0=do not know */
+        emit_unsigned_LEB128(be, 0);
+        /* filesize 0=do not know */
+        emit_unsigned_LEB128(be, 0);
+}
+
+static void emit_lne_set_address(struct buffer_ext *be,
+                                 void *address)
+{
+        emit_extended_opcode(be, DW_LNE_set_address, &address, sizeof(unsigned long));
+}
+
+static ubyte get_special_opcode(struct debug_entry *ent,
+                                unsigned int last_line,
+                                unsigned long last_vma)
+{
+        unsigned int temp;
+        unsigned long delta_addr;
+
+        /*
+         * delta from line_base
+         */
+        temp = (ent->lineno - last_line) - default_debug_line_header.line_base;
+
+        if (temp >= default_debug_line_header.line_range)
+                return 0;
+
+        /*
+         * delta of addresses
+         */
+        delta_addr = (ent->addr - last_vma) / default_debug_line_header.minimum_instruction_length;
+
+        /* This is not sufficient to ensure opcode will be in [0-256] but
+         * sufficient to ensure when summing with the delta lineno we will
+         * not overflow the unsigned long opcode */
+
+        if (delta_addr <= 256 / default_debug_line_header.line_range) {
+                unsigned long opcode = temp +
+                        (delta_addr * default_debug_line_header.line_range) +
+                        default_debug_line_header.opcode_base;
+
+                return opcode <= 255 ? opcode : 0;
+        }
+        return 0;
+}
+
+static void emit_lineno_info(struct buffer_ext *be,
+                             struct debug_entry *ent, size_t nr_entry,
+                             unsigned long code_addr)
+{
+        size_t i;
+
+        /*
+         * Machine state at start of a statement program
+         * address = 0
+         * file    = 1
+         * line    = 1
+         * column  = 0
+         * is_stmt = default_is_stmt as given in the debug_line_header
+         * basic block = 0
+         * end sequence = 0
+         */
+
+        /* start state of the state machine we take care of */
+        unsigned long last_vma = code_addr;
+        char const  *cur_filename = NULL;
+        unsigned long cur_file_idx = 0;
+        int last_line = 1;
+
+        emit_lne_set_address(be, (void *)code_addr);
+
+        for (i = 0; i < nr_entry; i++, ent = debug_entry_next(ent)) {
+                int need_copy = 0;
+                ubyte special_opcode;
+
+                /*
+                 * check if filename changed, if so add it
+                 */
+                if (!cur_filename || strcmp(cur_filename, ent->name)) {
+                        emit_lne_define_filename(be, ent->name);
+                        cur_filename = ent->name;
+                        emit_set_file(be, ++cur_file_idx);
+                        need_copy = 1;
+                }
+
+                special_opcode = get_special_opcode(ent, last_line, last_vma);
+                if (special_opcode != 0) {
+                        last_line = ent->lineno;
+                        last_vma  = ent->addr;
+                        emit_opcode(be, special_opcode);
+                } else {
+                        /*
+                         * lines differ, emit line delta
+                         */
+                        if (last_line != ent->lineno) {
+                                emit_advance_lineno(be, ent->lineno - last_line);
+                                last_line = ent->lineno;
+                                need_copy = 1;
+                        }
+                        /*
+                         * addresses differ, emit address delta
+                         */
+                        if (last_vma != ent->addr) {
+                                emit_advance_pc(be, ent->addr - last_vma);
+                                last_vma = ent->addr;
+                                need_copy = 1;
+                        }
+                        /*
+                         * add new row to matrix
+                         */
+                        if (need_copy)
+                                emit_opcode(be, DW_LNS_copy);
+                }
+        }
+}
+
+static void add_debug_line(struct buffer_ext *be,
+        struct debug_entry *ent, size_t nr_entry,
+        unsigned long code_addr)
+{
+        struct debug_line_header * dbg_header;
+        size_t old_size;
+
+        old_size = buffer_ext_size(be);
+
+        buffer_ext_add(be, (void *)&default_debug_line_header,
+                 sizeof(default_debug_line_header));
+
+        buffer_ext_add(be, &standard_opcode_length,  sizeof(standard_opcode_length));
+
+        // empty directory entry
+        buffer_ext_add(be, (void *)"", 1);
+
+        // empty filename directory
+        buffer_ext_add(be, (void *)"", 1);
+
+        dbg_header = buffer_ext_addr(be) + old_size;
+        dbg_header->prolog_length = (buffer_ext_size(be) - old_size) -
+                offsetof(struct debug_line_header, minimum_instruction_length);
+
+        emit_lineno_info(be, ent, nr_entry, code_addr);
+
+        emit_lne_end_of_sequence(be);
+
+        dbg_header = buffer_ext_addr(be) + old_size;
+        dbg_header->total_length = (buffer_ext_size(be) - old_size) -
+                offsetof(struct debug_line_header, version);
+}
+
+static void
+add_debug_abbrev(struct buffer_ext *be)
+{
+        emit_unsigned_LEB128(be, 1);
+        emit_unsigned_LEB128(be, DW_TAG_compile_unit);
+        emit_unsigned_LEB128(be, DW_CHILDREN_yes);
+        emit_unsigned_LEB128(be, DW_AT_stmt_list);
+        emit_unsigned_LEB128(be, DW_FORM_data4);
+        emit_unsigned_LEB128(be, 0);
+        emit_unsigned_LEB128(be, 0);
+        emit_unsigned_LEB128(be, 0);
+}
+
+static void
+add_compilation_unit(struct buffer_ext *be,
+                     size_t offset_debug_line)
+{
+        struct compilation_unit_header *comp_unit_header;
+        size_t old_size = buffer_ext_size(be);
+
+        buffer_ext_add(be, &default_comp_unit_header,
+                       sizeof(default_comp_unit_header));
+
+        emit_unsigned_LEB128(be, 1);
+        emit_uword(be, offset_debug_line);
+
+        comp_unit_header = buffer_ext_addr(be) + old_size;
+        comp_unit_header->total_length = (buffer_ext_size(be) - old_size) -
+                offsetof(struct compilation_unit_header, version);
+}
+
+static int
+jit_process_debug_info(uint64_t code_addr,
+                       void *debug, int nr_debug_entries,
+                       struct buffer_ext *dl,
+                       struct buffer_ext *da,
+                       struct buffer_ext *di)
+{
+        struct debug_entry *ent = debug;
+        int i;
+
+        for (i = 0; i < nr_debug_entries; i++) {
+                ent->addr = ent->addr - code_addr;
+                ent = debug_entry_next(ent);
+        }
+        add_compilation_unit(di, buffer_ext_size(dl));
+        add_debug_line(dl, debug, nr_debug_entries, 0);
+        add_debug_abbrev(da);
+        if (0) buffer_ext_dump(da, "abbrev");
+
+        return 0;
+}
+
+int
+jit_add_debug_info(Elf *e, uint64_t code_addr, void *debug, int nr_debug_entries)
+{
+        Elf_Data *d;
+        Elf_Scn *scn;
+        Elf_Shdr *shdr;
+        struct buffer_ext dl, di, da;
+        int ret;
+
+        buffer_ext_init(&dl);
+        buffer_ext_init(&di);
+        buffer_ext_init(&da);
+
+        ret = jit_process_debug_info(code_addr, debug, nr_debug_entries, &dl, &da, &di);
+        if (ret)
+                return -1;
+        /*
+         * setup .debug_line section
+         */
+        scn = elf_newscn(e);
+        if (!scn) {
+                warnx("cannot create section");
+                return -1;
+        }
+
+        d = elf_newdata(scn);
+        if (!d) {
+                warnx("cannot get new data");
+                return -1;
+        }
+
+        d->d_align = 1;
+        d->d_off = 0LL;
+        d->d_buf = buffer_ext_addr(&dl);
+        d->d_type = ELF_T_BYTE;
+        d->d_size = buffer_ext_size(&dl);
+        d->d_version = EV_CURRENT;
+
+        shdr = elf_getshdr(scn);
+        if (!shdr) {
+                warnx("cannot get section header");
+                return -1;
+        }
+
+        shdr->sh_name = 52; /* .debug_line */
+        shdr->sh_type = SHT_PROGBITS;
+        shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
+        shdr->sh_flags = 0;
+        shdr->sh_entsize = 0;
+
+        /*
+         * setup .debug_info section
+         */
+        scn = elf_newscn(e);
+        if (!scn) {
+                warnx("cannot create section");
+                return -1;
+        }
+
+        d = elf_newdata(scn);
+        if (!d) {
+                warnx("cannot get new data");
+                return -1;
+        }
+
+        d->d_align = 1;
+        d->d_off = 0LL;
+        d->d_buf = buffer_ext_addr(&di);
+        d->d_type = ELF_T_BYTE;
+        d->d_size = buffer_ext_size(&di);
+        d->d_version = EV_CURRENT;
+
+        shdr = elf_getshdr(scn);
+        if (!shdr) {
+                warnx("cannot get section header");
+                return -1;
+        }
+
+        shdr->sh_name = 64; /* .debug_info */
+        shdr->sh_type = SHT_PROGBITS;
+        shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
+        shdr->sh_flags = 0;
+        shdr->sh_entsize = 0;
+
+        /*
+         * setup .debug_abbrev section
+         */
+        scn = elf_newscn(e);
+        if (!scn) {
+                warnx("cannot create section");
+                return -1;
+        }
+
+        d = elf_newdata(scn);
+        if (!d) {
+                warnx("cannot get new data");
+                return -1;
+        }
+
+        d->d_align = 1;
+        d->d_off = 0LL;
+        d->d_buf = buffer_ext_addr(&da);
+        d->d_type = ELF_T_BYTE;
+        d->d_size = buffer_ext_size(&da);
+        d->d_version = EV_CURRENT;
+
+        shdr = elf_getshdr(scn);
+        if (!shdr) {
+                warnx("cannot get section header");
+                return -1;
+        }
+
+        shdr->sh_name = 76; /* .debug_info */
+        shdr->sh_type = SHT_PROGBITS;
+        shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
+        shdr->sh_flags = 0;
+        shdr->sh_entsize = 0;
+
+        /*
+         * now we update the ELF image with all the sections
+         */
+        if (elf_update(e, ELF_C_WRITE) < 0) {
+                warnx("elf_update debug failed");
+                return -1;
+        }
+        return 0;
+}
diff --git a/tools/perf/util/jitdump.c b/tools/perf/util/jitdump.c
index 9f7a01289efe..99fa5eee9fe0 100644
--- a/tools/perf/util/jitdump.c
+++ b/tools/perf/util/jitdump.c
@@ -63,7 +63,9 @@ jit_emit_elf(char *filename,
              const char *sym,
              uint64_t code_addr,
              const void *code,
-             int csize)
+             int csize,
+             void *debug,
+             int nr_debug_entries)
 {
         int ret, fd;
 
@@ -76,7 +78,7 @@ jit_emit_elf(char *filename,
                 return -1;
         }
 
-        ret = jit_write_elf(fd, code_addr, sym, (const void *)code, csize);
+        ret = jit_write_elf(fd, code_addr, sym, (const void *)code, csize, debug, nr_debug_entries);
 
         close(fd);
 
@@ -347,7 +349,7 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr)
 
         size = PERF_ALIGN(size, sizeof(u64));
         uaddr = (uintptr_t)code;
-        ret = jit_emit_elf(filename, sym, addr, (const void *)uaddr, csize);
+        ret = jit_emit_elf(filename, sym, addr, (const void *)uaddr, csize, jd->debug_data, jd->nr_debug_entries);
 
         if (jd->debug_data && jd->nr_debug_entries) {
                 free(jd->debug_data);