root/tools/perf/util/genelf_debug.c

DEFINITIONS

1. buffer_ext_dump
2. buffer_ext_add
3. buffer_ext_init
4. buffer_ext_size
5. buffer_ext_addr
6. emit_uword
7. emit_string
8. emit_unsigned_LEB128
9. emit_signed_LEB128
10. emit_extended_opcode
11. emit_opcode
12. emit_opcode_signed
13. emit_opcode_unsigned
14. emit_advance_pc
15. emit_advance_lineno
16. emit_lne_end_of_sequence
17. emit_set_file
18. emit_lne_define_filename
19. emit_lne_set_address
20. get_special_opcode
21. emit_lineno_info
22. add_debug_line
23. add_debug_abbrev
24. add_compilation_unit
25. jit_process_debug_info
26. jit_add_debug_info

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * genelf_debug.c
   4  * Copyright (C) 2015, Google, Inc
   5  *
   6  * Contributed by:
   7  *      Stephane Eranian <eranian@google.com>
   8  *
   9  * based on GPLv2 source code from Oprofile
  10  * @remark Copyright 2007 OProfile authors
  11  * @author Philippe Elie
  12  */
  13 #include <linux/compiler.h>
  14 #include <sys/types.h>
  15 #include <stdio.h>
  16 #include <getopt.h>
  17 #include <stddef.h>
  18 #include <libelf.h>
  19 #include <string.h>
  20 #include <stdlib.h>
  21 #include <inttypes.h>
  22 #include <limits.h>
  23 #include <fcntl.h>
  24 #include <err.h>
  25 #include <dwarf.h>
  26 
  27 #include "genelf.h"
  28 #include "../util/jitdump.h"
  29 
  30 #define BUFFER_EXT_DFL_SIZE     (4 * 1024)
  31 
  32 typedef uint32_t uword;
  33 typedef uint16_t uhalf;
  34 typedef int32_t  sword;
  35 typedef int16_t  shalf;
  36 typedef uint8_t  ubyte;
  37 typedef int8_t   sbyte;
  38 
  39 struct buffer_ext {
  40         size_t cur_pos;
  41         size_t max_sz;
  42         void *data;
  43 };
  44 
  45 static void
  46 buffer_ext_dump(struct buffer_ext *be, const char *msg)
  47 {
  48         size_t i;
  49         warnx("DUMP for %s", msg);
  50         for (i = 0 ; i < be->cur_pos; i++)
  51                 warnx("%4zu 0x%02x", i, (((char *)be->data)[i]) & 0xff);
  52 }
  53 
  54 static inline int
  55 buffer_ext_add(struct buffer_ext *be, void *addr, size_t sz)
  56 {
  57         void *tmp;
  58         size_t be_sz = be->max_sz;
  59 
  60 retry:
  61         if ((be->cur_pos + sz) < be_sz) {
  62                 memcpy(be->data + be->cur_pos, addr, sz);
  63                 be->cur_pos += sz;
  64                 return 0;
  65         }
  66 
  67         if (!be_sz)
  68                 be_sz = BUFFER_EXT_DFL_SIZE;
  69         else
  70                 be_sz <<= 1;
  71 
  72         tmp = realloc(be->data, be_sz);
  73         if (!tmp)
  74                 return -1;
  75 
  76         be->data   = tmp;
  77         be->max_sz = be_sz;
  78 
  79         goto retry;
  80 }
  81 
  82 static void
  83 buffer_ext_init(struct buffer_ext *be)
  84 {
  85         be->data = NULL;
  86         be->cur_pos = 0;
  87         be->max_sz = 0;
  88 }
  89 
  90 static inline size_t
  91 buffer_ext_size(struct buffer_ext *be)
  92 {
  93         return be->cur_pos;
  94 }
  95 
  96 static inline void *
  97 buffer_ext_addr(struct buffer_ext *be)
  98 {
  99         return be->data;
 100 }
 101 
 102 struct debug_line_header {
 103         // Not counting this field
 104         uword total_length;
 105         // version number (2 currently)
 106         uhalf version;
 107         // relative offset from next field to
 108         // program statement
 109         uword prolog_length;
 110         ubyte minimum_instruction_length;
 111         ubyte default_is_stmt;
 112         // line_base - see DWARF 2 specs
 113         sbyte line_base;
 114         // line_range - see DWARF 2 specs
 115         ubyte line_range;
 116         // number of opcode + 1
 117         ubyte opcode_base;
 118         /* follow the array of opcode args nr: ubytes [nr_opcode_base] */
 119         /* follow the search directories index, zero terminated string
 120          * terminated by an empty string.
 121          */
 122         /* follow an array of { filename, LEB128, LEB128, LEB128 }, first is
 123          * the directory index entry, 0 means current directory, then mtime
 124          * and filesize, last entry is followed by en empty string.
 125          */
 126         /* follow the first program statement */
 127 } __packed;
 128 
 129 /* DWARF 2 spec talk only about one possible compilation unit header while
 130  * binutils can handle two flavours of dwarf 2, 32 and 64 bits, this is not
 131  * related to the used arch, an ELF 32 can hold more than 4 Go of debug
 132  * information. For now we handle only DWARF 2 32 bits comp unit. It'll only
 133  * become a problem if we generate more than 4GB of debug information.
 134  */
 135 struct compilation_unit_header {
 136         uword total_length;
 137         uhalf version;
 138         uword debug_abbrev_offset;
 139         ubyte pointer_size;
 140 } __packed;
 141 
 142 #define DW_LNS_num_opcode (DW_LNS_set_isa + 1)
 143 
 144 /* field filled at run time are marked with -1 */
 145 static struct debug_line_header const default_debug_line_header = {
 146         .total_length = -1,
 147         .version = 2,
 148         .prolog_length = -1,
 149         .minimum_instruction_length = 1,        /* could be better when min instruction size != 1 */
 150         .default_is_stmt = 1,   /* we don't take care about basic block */
 151         .line_base = -5,        /* sensible value for line base ... */
 152         .line_range = -14,     /* ... and line range are guessed statically */
 153         .opcode_base = DW_LNS_num_opcode
 154 };
 155 
 156 static ubyte standard_opcode_length[] =
 157 {
 158         0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1
 159 };
 160 #if 0
 161 {
 162         [DW_LNS_advance_pc]   = 1,
 163         [DW_LNS_advance_line] = 1,
 164         [DW_LNS_set_file] =  1,
 165         [DW_LNS_set_column] = 1,
 166         [DW_LNS_fixed_advance_pc] = 1,
 167         [DW_LNS_set_isa] = 1,
 168 };
 169 #endif
 170 
 171 /* field filled at run time are marked with -1 */
 172 static struct compilation_unit_header default_comp_unit_header = {
 173         .total_length = -1,
 174         .version = 2,
 175         .debug_abbrev_offset = 0,     /* we reuse the same abbrev entries for all comp unit */
 176         .pointer_size = sizeof(void *)
 177 };
 178 
 179 static void emit_uword(struct buffer_ext *be, uword data)
 180 {
 181         buffer_ext_add(be, &data, sizeof(uword));
 182 }
 183 
 184 static void emit_string(struct buffer_ext *be, const char *s)
 185 {
 186         buffer_ext_add(be, (void *)s, strlen(s) + 1);
 187 }
 188 
 189 static void emit_unsigned_LEB128(struct buffer_ext *be,
 190                                  unsigned long data)
 191 {
 192         do {
 193                 ubyte cur = data & 0x7F;
 194                 data >>= 7;
 195                 if (data)
 196                         cur |= 0x80;
 197                 buffer_ext_add(be, &cur, 1);
 198         } while (data);
 199 }
 200 
 201 static void emit_signed_LEB128(struct buffer_ext *be, long data)
 202 {
 203         int more = 1;
 204         int negative = data < 0;
 205         int size = sizeof(long) * CHAR_BIT;
 206         while (more) {
 207                 ubyte cur = data & 0x7F;
 208                 data >>= 7;
 209                 if (negative)
 210                         data |= - (1 << (size - 7));
 211                 if ((data == 0 && !(cur & 0x40)) ||
 212                     (data == -1l && (cur & 0x40)))
 213                         more = 0;
 214                 else
 215                         cur |= 0x80;
 216                 buffer_ext_add(be, &cur, 1);
 217         }
 218 }
 219 
 220 static void emit_extended_opcode(struct buffer_ext *be, ubyte opcode,
 221                                  void *data, size_t data_len)
 222 {
 223         buffer_ext_add(be, (char *)"", 1);
 224 
 225         emit_unsigned_LEB128(be, data_len + 1);
 226 
 227         buffer_ext_add(be, &opcode, 1);
 228         buffer_ext_add(be, data, data_len);
 229 }
 230 
 231 static void emit_opcode(struct buffer_ext *be, ubyte opcode)
 232 {
 233         buffer_ext_add(be, &opcode, 1);
 234 }
 235 
 236 static void emit_opcode_signed(struct buffer_ext  *be,
 237                                ubyte opcode, long data)
 238 {
 239         buffer_ext_add(be, &opcode, 1);
 240         emit_signed_LEB128(be, data);
 241 }
 242 
 243 static void emit_opcode_unsigned(struct buffer_ext *be, ubyte opcode,
 244                                  unsigned long data)
 245 {
 246         buffer_ext_add(be, &opcode, 1);
 247         emit_unsigned_LEB128(be, data);
 248 }
 249 
 250 static void emit_advance_pc(struct buffer_ext *be, unsigned long delta_pc)
 251 {
 252         emit_opcode_unsigned(be, DW_LNS_advance_pc, delta_pc);
 253 }
 254 
 255 static void emit_advance_lineno(struct buffer_ext  *be, long delta_lineno)
 256 {
 257         emit_opcode_signed(be, DW_LNS_advance_line, delta_lineno);
 258 }
 259 
 260 static void emit_lne_end_of_sequence(struct buffer_ext *be)
 261 {
 262         emit_extended_opcode(be, DW_LNE_end_sequence, NULL, 0);
 263 }
 264 
 265 static void emit_set_file(struct buffer_ext *be, unsigned long idx)
 266 {
 267         emit_opcode_unsigned(be, DW_LNS_set_file, idx);
 268 }
 269 
 270 static void emit_lne_define_filename(struct buffer_ext *be,
 271                                      const char *filename)
 272 {
 273         buffer_ext_add(be, (void *)"", 1);
 274 
 275         /* LNE field, strlen(filename) + zero termination, 3 bytes for: the dir entry, timestamp, filesize */
 276         emit_unsigned_LEB128(be, strlen(filename) + 5);
 277         emit_opcode(be, DW_LNE_define_file);
 278         emit_string(be, filename);
 279         /* directory index 0=do not know */
 280         emit_unsigned_LEB128(be, 0);
 281         /* last modification date on file 0=do not know */
 282         emit_unsigned_LEB128(be, 0);
 283         /* filesize 0=do not know */
 284         emit_unsigned_LEB128(be, 0);
 285 }
 286 
 287 static void emit_lne_set_address(struct buffer_ext *be,
 288                                  void *address)
 289 {
 290         emit_extended_opcode(be, DW_LNE_set_address, &address, sizeof(unsigned long));
 291 }
 292 
 293 static ubyte get_special_opcode(struct debug_entry *ent,
 294                                 unsigned int last_line,
 295                                 unsigned long last_vma)
 296 {
 297         unsigned int temp;
 298         unsigned long delta_addr;
 299 
 300         /*
 301          * delta from line_base
 302          */
 303         temp = (ent->lineno - last_line) - default_debug_line_header.line_base;
 304 
 305         if (temp >= default_debug_line_header.line_range)
 306                 return 0;
 307 
 308         /*
 309          * delta of addresses
 310          */
 311         delta_addr = (ent->addr - last_vma) / default_debug_line_header.minimum_instruction_length;
 312 
 313         /* This is not sufficient to ensure opcode will be in [0-256] but
 314          * sufficient to ensure when summing with the delta lineno we will
 315          * not overflow the unsigned long opcode */
 316 
 317         if (delta_addr <= 256 / default_debug_line_header.line_range) {
 318                 unsigned long opcode = temp +
 319                         (delta_addr * default_debug_line_header.line_range) +
 320                         default_debug_line_header.opcode_base;
 321 
 322                 return opcode <= 255 ? opcode : 0;
 323         }
 324         return 0;
 325 }
 326 
 327 static void emit_lineno_info(struct buffer_ext *be,
 328                              struct debug_entry *ent, size_t nr_entry,
 329                              unsigned long code_addr)
 330 {
 331         size_t i;
 332 
 333         /*
 334          * Machine state at start of a statement program
 335          * address = 0
 336          * file    = 1
 337          * line    = 1
 338          * column  = 0
 339          * is_stmt = default_is_stmt as given in the debug_line_header
 340          * basic block = 0
 341          * end sequence = 0
 342          */
 343 
 344         /* start state of the state machine we take care of */
 345         unsigned long last_vma = code_addr;
 346         char const  *cur_filename = NULL;
 347         unsigned long cur_file_idx = 0;
 348         int last_line = 1;
 349 
 350         emit_lne_set_address(be, (void *)code_addr);
 351 
 352         for (i = 0; i < nr_entry; i++, ent = debug_entry_next(ent)) {
 353                 int need_copy = 0;
 354                 ubyte special_opcode;
 355 
 356                 /*
 357                  * check if filename changed, if so add it
 358                  */
 359                 if (!cur_filename || strcmp(cur_filename, ent->name)) {
 360                         emit_lne_define_filename(be, ent->name);
 361                         cur_filename = ent->name;
 362                         emit_set_file(be, ++cur_file_idx);
 363                         need_copy = 1;
 364                 }
 365 
 366                 special_opcode = get_special_opcode(ent, last_line, last_vma);
 367                 if (special_opcode != 0) {
 368                         last_line = ent->lineno;
 369                         last_vma  = ent->addr;
 370                         emit_opcode(be, special_opcode);
 371                 } else {
 372                         /*
 373                          * lines differ, emit line delta
 374                          */
 375                         if (last_line != ent->lineno) {
 376                                 emit_advance_lineno(be, ent->lineno - last_line);
 377                                 last_line = ent->lineno;
 378                                 need_copy = 1;
 379                         }
 380                         /*
 381                          * addresses differ, emit address delta
 382                          */
 383                         if (last_vma != ent->addr) {
 384                                 emit_advance_pc(be, ent->addr - last_vma);
 385                                 last_vma = ent->addr;
 386                                 need_copy = 1;
 387                         }
 388                         /*
 389                          * add new row to matrix
 390                          */
 391                         if (need_copy)
 392                                 emit_opcode(be, DW_LNS_copy);
 393                 }
 394         }
 395 }
 396 
 397 static void add_debug_line(struct buffer_ext *be,
 398         struct debug_entry *ent, size_t nr_entry,
 399         unsigned long code_addr)
 400 {
 401         struct debug_line_header * dbg_header;
 402         size_t old_size;
 403 
 404         old_size = buffer_ext_size(be);
 405 
 406         buffer_ext_add(be, (void *)&default_debug_line_header,
 407                  sizeof(default_debug_line_header));
 408 
 409         buffer_ext_add(be, &standard_opcode_length,  sizeof(standard_opcode_length));
 410 
 411         // empty directory entry
 412         buffer_ext_add(be, (void *)"", 1);
 413 
 414         // empty filename directory
 415         buffer_ext_add(be, (void *)"", 1);
 416 
 417         dbg_header = buffer_ext_addr(be) + old_size;
 418         dbg_header->prolog_length = (buffer_ext_size(be) - old_size) -
 419                 offsetof(struct debug_line_header, minimum_instruction_length);
 420 
 421         emit_lineno_info(be, ent, nr_entry, code_addr);
 422 
 423         emit_lne_end_of_sequence(be);
 424 
 425         dbg_header = buffer_ext_addr(be) + old_size;
 426         dbg_header->total_length = (buffer_ext_size(be) - old_size) -
 427                 offsetof(struct debug_line_header, version);
 428 }
 429 
 430 static void
 431 add_debug_abbrev(struct buffer_ext *be)
 432 {
 433         emit_unsigned_LEB128(be, 1);
 434         emit_unsigned_LEB128(be, DW_TAG_compile_unit);
 435         emit_unsigned_LEB128(be, DW_CHILDREN_yes);
 436         emit_unsigned_LEB128(be, DW_AT_stmt_list);
 437         emit_unsigned_LEB128(be, DW_FORM_data4);
 438         emit_unsigned_LEB128(be, 0);
 439         emit_unsigned_LEB128(be, 0);
 440         emit_unsigned_LEB128(be, 0);
 441 }
 442 
 443 static void
 444 add_compilation_unit(struct buffer_ext *be,
 445                      size_t offset_debug_line)
 446 {
 447         struct compilation_unit_header *comp_unit_header;
 448         size_t old_size = buffer_ext_size(be);
 449 
 450         buffer_ext_add(be, &default_comp_unit_header,
 451                        sizeof(default_comp_unit_header));
 452 
 453         emit_unsigned_LEB128(be, 1);
 454         emit_uword(be, offset_debug_line);
 455 
 456         comp_unit_header = buffer_ext_addr(be) + old_size;
 457         comp_unit_header->total_length = (buffer_ext_size(be) - old_size) -
 458                 offsetof(struct compilation_unit_header, version);
 459 }
 460 
 461 static int
 462 jit_process_debug_info(uint64_t code_addr,
 463                        void *debug, int nr_debug_entries,
 464                        struct buffer_ext *dl,
 465                        struct buffer_ext *da,
 466                        struct buffer_ext *di)
 467 {
 468         struct debug_entry *ent = debug;
 469         int i;
 470 
 471         for (i = 0; i < nr_debug_entries; i++) {
 472                 ent->addr = ent->addr - code_addr;
 473                 ent = debug_entry_next(ent);
 474         }
 475         add_compilation_unit(di, buffer_ext_size(dl));
 476         add_debug_line(dl, debug, nr_debug_entries, 0);
 477         add_debug_abbrev(da);
 478         if (0) buffer_ext_dump(da, "abbrev");
 479 
 480         return 0;
 481 }
 482 
 483 int
 484 jit_add_debug_info(Elf *e, uint64_t code_addr, void *debug, int nr_debug_entries)
 485 {
 486         Elf_Data *d;
 487         Elf_Scn *scn;
 488         Elf_Shdr *shdr;
 489         struct buffer_ext dl, di, da;
 490         int ret;
 491 
 492         buffer_ext_init(&dl);
 493         buffer_ext_init(&di);
 494         buffer_ext_init(&da);
 495 
 496         ret = jit_process_debug_info(code_addr, debug, nr_debug_entries, &dl, &da, &di);
 497         if (ret)
 498                 return -1;
 499         /*
 500          * setup .debug_line section
 501          */
 502         scn = elf_newscn(e);
 503         if (!scn) {
 504                 warnx("cannot create section");
 505                 return -1;
 506         }
 507 
 508         d = elf_newdata(scn);
 509         if (!d) {
 510                 warnx("cannot get new data");
 511                 return -1;
 512         }
 513 
 514         d->d_align = 1;
 515         d->d_off = 0LL;
 516         d->d_buf = buffer_ext_addr(&dl);
 517         d->d_type = ELF_T_BYTE;
 518         d->d_size = buffer_ext_size(&dl);
 519         d->d_version = EV_CURRENT;
 520 
 521         shdr = elf_getshdr(scn);
 522         if (!shdr) {
 523                 warnx("cannot get section header");
 524                 return -1;
 525         }
 526 
 527         shdr->sh_name = 52; /* .debug_line */
 528         shdr->sh_type = SHT_PROGBITS;
 529         shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
 530         shdr->sh_flags = 0;
 531         shdr->sh_entsize = 0;
 532 
 533         /*
 534          * setup .debug_info section
 535          */
 536         scn = elf_newscn(e);
 537         if (!scn) {
 538                 warnx("cannot create section");
 539                 return -1;
 540         }
 541 
 542         d = elf_newdata(scn);
 543         if (!d) {
 544                 warnx("cannot get new data");
 545                 return -1;
 546         }
 547 
 548         d->d_align = 1;
 549         d->d_off = 0LL;
 550         d->d_buf = buffer_ext_addr(&di);
 551         d->d_type = ELF_T_BYTE;
 552         d->d_size = buffer_ext_size(&di);
 553         d->d_version = EV_CURRENT;
 554 
 555         shdr = elf_getshdr(scn);
 556         if (!shdr) {
 557                 warnx("cannot get section header");
 558                 return -1;
 559         }
 560 
 561         shdr->sh_name = 64; /* .debug_info */
 562         shdr->sh_type = SHT_PROGBITS;
 563         shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
 564         shdr->sh_flags = 0;
 565         shdr->sh_entsize = 0;
 566 
 567         /*
 568          * setup .debug_abbrev section
 569          */
 570         scn = elf_newscn(e);
 571         if (!scn) {
 572                 warnx("cannot create section");
 573                 return -1;
 574         }
 575 
 576         d = elf_newdata(scn);
 577         if (!d) {
 578                 warnx("cannot get new data");
 579                 return -1;
 580         }
 581 
 582         d->d_align = 1;
 583         d->d_off = 0LL;
 584         d->d_buf = buffer_ext_addr(&da);
 585         d->d_type = ELF_T_BYTE;
 586         d->d_size = buffer_ext_size(&da);
 587         d->d_version = EV_CURRENT;
 588 
 589         shdr = elf_getshdr(scn);
 590         if (!shdr) {
 591                 warnx("cannot get section header");
 592                 return -1;
 593         }
 594 
 595         shdr->sh_name = 76; /* .debug_info */
 596         shdr->sh_type = SHT_PROGBITS;
 597         shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
 598         shdr->sh_flags = 0;
 599         shdr->sh_entsize = 0;
 600 
 601         /*
 602          * now we update the ELF image with all the sections
 603          */
 604         if (elf_update(e, ELF_C_WRITE) < 0) {
 605                 warnx("elf_update debug failed");
 606                 return -1;
 607         }
 608         return 0;
 609 }