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