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