1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * dwarf-aux.c : libdw auxiliary interfaces 4 */ 5 6 #include <errno.h> 7 #include <inttypes.h> 8 #include <stdbool.h> 9 #include <stdlib.h> 10 #include "debug.h" 11 #include "dwarf-aux.h" 12 #include "strbuf.h" 13 #include "string2.h" 14 15 /** 16 * cu_find_realpath - Find the realpath of the target file 17 * @cu_die: A DIE(dwarf information entry) of CU(compilation Unit) 18 * @fname: The tail filename of the target file 19 * 20 * Find the real(long) path of @fname in @cu_die. 21 */ 22 const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname) 23 { 24 Dwarf_Files *files; 25 size_t nfiles, i; 26 const char *src = NULL; 27 int ret; 28 29 if (!fname) 30 return NULL; 31 32 ret = dwarf_getsrcfiles(cu_die, &files, &nfiles); 33 if (ret != 0) 34 return NULL; 35 36 for (i = 0; i < nfiles; i++) { 37 src = dwarf_filesrc(files, i, NULL, NULL); 38 if (strtailcmp(src, fname) == 0) 39 break; 40 } 41 if (i == nfiles) 42 return NULL; 43 return src; 44 } 45 46 /** 47 * cu_get_comp_dir - Get the path of compilation directory 48 * @cu_die: a CU DIE 49 * 50 * Get the path of compilation directory of given @cu_die. 51 * Since this depends on DW_AT_comp_dir, older gcc will not 52 * embedded it. In that case, this returns NULL. 53 */ 54 const char *cu_get_comp_dir(Dwarf_Die *cu_die) 55 { 56 Dwarf_Attribute attr; 57 if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL) 58 return NULL; 59 return dwarf_formstring(&attr); 60 } 61 62 /* Unlike dwarf_getsrc_die(), cu_getsrc_die() only returns statement line */ 63 static Dwarf_Line *cu_getsrc_die(Dwarf_Die *cu_die, Dwarf_Addr addr) 64 { 65 Dwarf_Addr laddr; 66 Dwarf_Lines *lines; 67 Dwarf_Line *line; 68 size_t nlines, l, u, n; 69 bool flag; 70 71 if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0 || 72 nlines == 0) 73 return NULL; 74 75 /* Lines are sorted by address, use binary search */ 76 l = 0; u = nlines - 1; 77 while (l < u) { 78 n = u - (u - l) / 2; 79 line = dwarf_onesrcline(lines, n); 80 if (!line || dwarf_lineaddr(line, &laddr) != 0) 81 return NULL; 82 if (addr < laddr) 83 u = n - 1; 84 else 85 l = n; 86 } 87 /* Going backward to find the lowest line */ 88 do { 89 line = dwarf_onesrcline(lines, --l); 90 if (!line || dwarf_lineaddr(line, &laddr) != 0) 91 return NULL; 92 } while (laddr == addr); 93 l++; 94 /* Going forward to find the statement line */ 95 do { 96 line = dwarf_onesrcline(lines, l++); 97 if (!line || dwarf_lineaddr(line, &laddr) != 0 || 98 dwarf_linebeginstatement(line, &flag) != 0) 99 return NULL; 100 if (laddr > addr) 101 return NULL; 102 } while (!flag); 103 104 return line; 105 } 106 107 /** 108 * cu_find_lineinfo - Get a line number and file name for given address 109 * @cu_die: a CU DIE 110 * @addr: An address 111 * @fname: a pointer which returns the file name string 112 * @lineno: a pointer which returns the line number 113 * 114 * Find a line number and file name for @addr in @cu_die. 115 */ 116 int cu_find_lineinfo(Dwarf_Die *cu_die, Dwarf_Addr addr, 117 const char **fname, int *lineno) 118 { 119 Dwarf_Line *line; 120 Dwarf_Die die_mem; 121 Dwarf_Addr faddr; 122 123 if (die_find_realfunc(cu_die, addr, &die_mem) 124 && die_entrypc(&die_mem, &faddr) == 0 && 125 faddr == addr) { 126 *fname = die_get_decl_file(&die_mem); 127 dwarf_decl_line(&die_mem, lineno); 128 goto out; 129 } 130 131 line = cu_getsrc_die(cu_die, addr); 132 if (line && dwarf_lineno(line, lineno) == 0) { 133 *fname = dwarf_linesrc(line, NULL, NULL); 134 if (!*fname) 135 /* line number is useless without filename */ 136 *lineno = 0; 137 } 138 139 out: 140 return (*lineno && *fname) ? *lineno : -ENOENT; 141 } 142 143 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data); 144 145 /** 146 * cu_walk_functions_at - Walk on function DIEs at given address 147 * @cu_die: A CU DIE 148 * @addr: An address 149 * @callback: A callback which called with found DIEs 150 * @data: A user data 151 * 152 * Walk on function DIEs at given @addr in @cu_die. Passed DIEs 153 * should be subprogram or inlined-subroutines. 154 */ 155 int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr, 156 int (*callback)(Dwarf_Die *, void *), void *data) 157 { 158 Dwarf_Die die_mem; 159 Dwarf_Die *sc_die; 160 int ret = -ENOENT; 161 162 /* Inlined function could be recursive. Trace it until fail */ 163 for (sc_die = die_find_realfunc(cu_die, addr, &die_mem); 164 sc_die != NULL; 165 sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr, 166 &die_mem)) { 167 ret = callback(sc_die, data); 168 if (ret) 169 break; 170 } 171 172 return ret; 173 174 } 175 176 /** 177 * die_get_linkage_name - Get the linkage name of the object 178 * @dw_die: A DIE of the object 179 * 180 * Get the linkage name attribute of given @dw_die. 181 * For C++ binary, the linkage name will be the mangled symbol. 182 */ 183 const char *die_get_linkage_name(Dwarf_Die *dw_die) 184 { 185 Dwarf_Attribute attr; 186 187 if (dwarf_attr_integrate(dw_die, DW_AT_linkage_name, &attr) == NULL) 188 return NULL; 189 return dwarf_formstring(&attr); 190 } 191 192 /** 193 * die_compare_name - Compare diename and tname 194 * @dw_die: a DIE 195 * @tname: a string of target name 196 * 197 * Compare the name of @dw_die and @tname. Return false if @dw_die has no name. 198 */ 199 bool die_compare_name(Dwarf_Die *dw_die, const char *tname) 200 { 201 const char *name; 202 203 name = dwarf_diename(dw_die); 204 return name ? (strcmp(tname, name) == 0) : false; 205 } 206 207 /** 208 * die_match_name - Match diename/linkage name and glob 209 * @dw_die: a DIE 210 * @glob: a string of target glob pattern 211 * 212 * Glob matching the name of @dw_die and @glob. Return false if matching fail. 213 * This also match linkage name. 214 */ 215 bool die_match_name(Dwarf_Die *dw_die, const char *glob) 216 { 217 const char *name; 218 219 name = dwarf_diename(dw_die); 220 if (name && strglobmatch(name, glob)) 221 return true; 222 /* fall back to check linkage name */ 223 name = die_get_linkage_name(dw_die); 224 if (name && strglobmatch(name, glob)) 225 return true; 226 227 return false; 228 } 229 230 /** 231 * die_get_call_lineno - Get callsite line number of inline-function instance 232 * @in_die: a DIE of an inlined function instance 233 * 234 * Get call-site line number of @in_die. This means from where the inline 235 * function is called. 236 */ 237 int die_get_call_lineno(Dwarf_Die *in_die) 238 { 239 Dwarf_Attribute attr; 240 Dwarf_Word ret; 241 242 if (!dwarf_attr(in_die, DW_AT_call_line, &attr)) 243 return -ENOENT; 244 245 dwarf_formudata(&attr, &ret); 246 return (int)ret; 247 } 248 249 /** 250 * die_get_type - Get type DIE 251 * @vr_die: a DIE of a variable 252 * @die_mem: where to store a type DIE 253 * 254 * Get a DIE of the type of given variable (@vr_die), and store 255 * it to die_mem. Return NULL if fails to get a type DIE. 256 */ 257 Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem) 258 { 259 Dwarf_Attribute attr; 260 261 if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) && 262 dwarf_formref_die(&attr, die_mem)) 263 return die_mem; 264 else 265 return NULL; 266 } 267 268 /* Get a type die, but skip qualifiers */ 269 static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem) 270 { 271 int tag; 272 273 do { 274 vr_die = die_get_type(vr_die, die_mem); 275 if (!vr_die) 276 break; 277 tag = dwarf_tag(vr_die); 278 } while (tag == DW_TAG_const_type || 279 tag == DW_TAG_restrict_type || 280 tag == DW_TAG_volatile_type || 281 tag == DW_TAG_shared_type); 282 283 return vr_die; 284 } 285 286 /** 287 * die_get_real_type - Get a type die, but skip qualifiers and typedef 288 * @vr_die: a DIE of a variable 289 * @die_mem: where to store a type DIE 290 * 291 * Get a DIE of the type of given variable (@vr_die), and store 292 * it to die_mem. Return NULL if fails to get a type DIE. 293 * If the type is qualifiers (e.g. const) or typedef, this skips it 294 * and tries to find real type (structure or basic types, e.g. int). 295 */ 296 Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem) 297 { 298 do { 299 vr_die = __die_get_real_type(vr_die, die_mem); 300 } while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef); 301 302 return vr_die; 303 } 304 305 /* Get attribute and translate it as a udata */ 306 static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name, 307 Dwarf_Word *result) 308 { 309 Dwarf_Attribute attr; 310 311 if (dwarf_attr_integrate(tp_die, attr_name, &attr) == NULL || 312 dwarf_formudata(&attr, result) != 0) 313 return -ENOENT; 314 315 return 0; 316 } 317 318 /** 319 * die_is_signed_type - Check whether a type DIE is signed or not 320 * @tp_die: a DIE of a type 321 * 322 * Get the encoding of @tp_die and return true if the encoding 323 * is signed. 324 */ 325 bool die_is_signed_type(Dwarf_Die *tp_die) 326 { 327 Dwarf_Word ret; 328 329 if (die_get_attr_udata(tp_die, DW_AT_encoding, &ret)) 330 return false; 331 332 return (ret == DW_ATE_signed_char || ret == DW_ATE_signed || 333 ret == DW_ATE_signed_fixed); 334 } 335 336 /** 337 * die_is_func_def - Ensure that this DIE is a subprogram and definition 338 * @dw_die: a DIE 339 * 340 * Ensure that this DIE is a subprogram and NOT a declaration. This 341 * returns true if @dw_die is a function definition. 342 **/ 343 bool die_is_func_def(Dwarf_Die *dw_die) 344 { 345 Dwarf_Attribute attr; 346 Dwarf_Addr addr = 0; 347 348 if (dwarf_tag(dw_die) != DW_TAG_subprogram) 349 return false; 350 351 if (dwarf_attr(dw_die, DW_AT_declaration, &attr)) 352 return false; 353 354 /* 355 * DW_AT_declaration can be lost from function declaration 356 * by gcc's bug #97060. 357 * So we need to check this subprogram DIE has DW_AT_inline 358 * or an entry address. 359 */ 360 if (!dwarf_attr(dw_die, DW_AT_inline, &attr) && 361 die_entrypc(dw_die, &addr) < 0) 362 return false; 363 364 return true; 365 } 366 367 /** 368 * die_entrypc - Returns entry PC (the lowest address) of a DIE 369 * @dw_die: a DIE 370 * @addr: where to store entry PC 371 * 372 * Since dwarf_entrypc() does not return entry PC if the DIE has only address 373 * range, we have to use this to retrieve the lowest address from the address 374 * range attribute. 375 */ 376 int die_entrypc(Dwarf_Die *dw_die, Dwarf_Addr *addr) 377 { 378 Dwarf_Addr base, end; 379 Dwarf_Attribute attr; 380 381 if (!addr) 382 return -EINVAL; 383 384 if (dwarf_entrypc(dw_die, addr) == 0) 385 return 0; 386 387 /* 388 * Since the dwarf_ranges() will return 0 if there is no 389 * DW_AT_ranges attribute, we should check it first. 390 */ 391 if (!dwarf_attr(dw_die, DW_AT_ranges, &attr)) 392 return -ENOENT; 393 394 return dwarf_ranges(dw_die, 0, &base, addr, &end) < 0 ? -ENOENT : 0; 395 } 396 397 /** 398 * die_is_func_instance - Ensure that this DIE is an instance of a subprogram 399 * @dw_die: a DIE 400 * 401 * Ensure that this DIE is an instance (which has an entry address). 402 * This returns true if @dw_die is a function instance. If not, the @dw_die 403 * must be a prototype. You can use die_walk_instances() to find actual 404 * instances. 405 **/ 406 bool die_is_func_instance(Dwarf_Die *dw_die) 407 { 408 Dwarf_Addr tmp; 409 Dwarf_Attribute attr_mem; 410 int tag = dwarf_tag(dw_die); 411 412 if (tag != DW_TAG_subprogram && 413 tag != DW_TAG_inlined_subroutine) 414 return false; 415 416 return dwarf_entrypc(dw_die, &tmp) == 0 || 417 dwarf_attr(dw_die, DW_AT_ranges, &attr_mem) != NULL; 418 } 419 420 /** 421 * die_get_data_member_location - Get the data-member offset 422 * @mb_die: a DIE of a member of a data structure 423 * @offs: The offset of the member in the data structure 424 * 425 * Get the offset of @mb_die in the data structure including @mb_die, and 426 * stores result offset to @offs. If any error occurs this returns errno. 427 */ 428 int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs) 429 { 430 Dwarf_Attribute attr; 431 Dwarf_Op *expr; 432 size_t nexpr; 433 int ret; 434 435 if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL) 436 return -ENOENT; 437 438 if (dwarf_formudata(&attr, offs) != 0) { 439 /* DW_AT_data_member_location should be DW_OP_plus_uconst */ 440 ret = dwarf_getlocation(&attr, &expr, &nexpr); 441 if (ret < 0 || nexpr == 0) 442 return -ENOENT; 443 444 if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) { 445 pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n", 446 expr[0].atom, nexpr); 447 return -ENOTSUP; 448 } 449 *offs = (Dwarf_Word)expr[0].number; 450 } 451 return 0; 452 } 453 454 /* Get the call file index number in CU DIE */ 455 static int die_get_call_fileno(Dwarf_Die *in_die) 456 { 457 Dwarf_Word idx; 458 459 if (die_get_attr_udata(in_die, DW_AT_call_file, &idx) == 0) 460 return (int)idx; 461 else 462 return -ENOENT; 463 } 464 465 /* Get the declared file index number in CU DIE */ 466 static int die_get_decl_fileno(Dwarf_Die *pdie) 467 { 468 Dwarf_Word idx; 469 470 if (die_get_attr_udata(pdie, DW_AT_decl_file, &idx) == 0) 471 return (int)idx; 472 else 473 return -ENOENT; 474 } 475 476 /* Return the file name by index */ 477 static const char *die_get_file_name(Dwarf_Die *dw_die, int idx) 478 { 479 Dwarf_Die cu_die; 480 Dwarf_Files *files; 481 Dwarf_Attribute attr_mem; 482 483 if (idx < 0 || !dwarf_attr_integrate(dw_die, DW_AT_decl_file, &attr_mem) || 484 !dwarf_cu_die(attr_mem.cu, &cu_die, NULL, NULL, NULL, NULL, NULL, NULL) || 485 dwarf_getsrcfiles(&cu_die, &files, NULL) != 0) 486 return NULL; 487 488 return dwarf_filesrc(files, idx, NULL, NULL); 489 } 490 491 /** 492 * die_get_call_file - Get callsite file name of inlined function instance 493 * @in_die: a DIE of an inlined function instance 494 * 495 * Get call-site file name of @in_die. This means from which file the inline 496 * function is called. 497 */ 498 const char *die_get_call_file(Dwarf_Die *in_die) 499 { 500 return die_get_file_name(in_die, die_get_call_fileno(in_die)); 501 } 502 503 /** 504 * die_get_decl_file - Find the declared file name of this DIE 505 * @dw_die: a DIE for something declared. 506 * 507 * Get declared file name of @dw_die. 508 * NOTE: Since some version of clang DWARF5 implementation incorrectly uses 509 * file index 0 for DW_AT_decl_file, die_get_decl_file() will return NULL for 510 * such cases. Use this function instead. 511 */ 512 const char *die_get_decl_file(Dwarf_Die *dw_die) 513 { 514 return die_get_file_name(dw_die, die_get_decl_fileno(dw_die)); 515 } 516 517 /** 518 * die_find_child - Generic DIE search function in DIE tree 519 * @rt_die: a root DIE 520 * @callback: a callback function 521 * @data: a user data passed to the callback function 522 * @die_mem: a buffer for result DIE 523 * 524 * Trace DIE tree from @rt_die and call @callback for each child DIE. 525 * If @callback returns DIE_FIND_CB_END, this stores the DIE into 526 * @die_mem and returns it. If @callback returns DIE_FIND_CB_CONTINUE, 527 * this continues to trace the tree. Optionally, @callback can return 528 * DIE_FIND_CB_CHILD and DIE_FIND_CB_SIBLING, those means trace only 529 * the children and trace only the siblings respectively. 530 * Returns NULL if @callback can't find any appropriate DIE. 531 */ 532 Dwarf_Die *die_find_child(Dwarf_Die *rt_die, 533 int (*callback)(Dwarf_Die *, void *), 534 void *data, Dwarf_Die *die_mem) 535 { 536 Dwarf_Die child_die; 537 int ret; 538 539 ret = dwarf_child(rt_die, die_mem); 540 if (ret != 0) 541 return NULL; 542 543 do { 544 ret = callback(die_mem, data); 545 if (ret == DIE_FIND_CB_END) 546 return die_mem; 547 548 if ((ret & DIE_FIND_CB_CHILD) && 549 die_find_child(die_mem, callback, data, &child_die)) { 550 memcpy(die_mem, &child_die, sizeof(Dwarf_Die)); 551 return die_mem; 552 } 553 } while ((ret & DIE_FIND_CB_SIBLING) && 554 dwarf_siblingof(die_mem, die_mem) == 0); 555 556 return NULL; 557 } 558 559 struct __addr_die_search_param { 560 Dwarf_Addr addr; 561 Dwarf_Die *die_mem; 562 }; 563 564 static int __die_search_func_tail_cb(Dwarf_Die *fn_die, void *data) 565 { 566 struct __addr_die_search_param *ad = data; 567 Dwarf_Addr addr = 0; 568 569 if (dwarf_tag(fn_die) == DW_TAG_subprogram && 570 !dwarf_highpc(fn_die, &addr) && 571 addr == ad->addr) { 572 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die)); 573 return DWARF_CB_ABORT; 574 } 575 return DWARF_CB_OK; 576 } 577 578 /** 579 * die_find_tailfunc - Search for a non-inlined function with tail call at 580 * given address 581 * @cu_die: a CU DIE which including @addr 582 * @addr: target address 583 * @die_mem: a buffer for result DIE 584 * 585 * Search for a non-inlined function DIE with tail call at @addr. Stores the 586 * DIE to @die_mem and returns it if found. Returns NULL if failed. 587 */ 588 Dwarf_Die *die_find_tailfunc(Dwarf_Die *cu_die, Dwarf_Addr addr, 589 Dwarf_Die *die_mem) 590 { 591 struct __addr_die_search_param ad; 592 ad.addr = addr; 593 ad.die_mem = die_mem; 594 /* dwarf_getscopes can't find subprogram. */ 595 if (!dwarf_getfuncs(cu_die, __die_search_func_tail_cb, &ad, 0)) 596 return NULL; 597 else 598 return die_mem; 599 } 600 601 /* die_find callback for non-inlined function search */ 602 static int __die_search_func_cb(Dwarf_Die *fn_die, void *data) 603 { 604 struct __addr_die_search_param *ad = data; 605 606 /* 607 * Since a declaration entry doesn't has given pc, this always returns 608 * function definition entry. 609 */ 610 if (dwarf_tag(fn_die) == DW_TAG_subprogram && 611 dwarf_haspc(fn_die, ad->addr)) { 612 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die)); 613 return DWARF_CB_ABORT; 614 } 615 return DWARF_CB_OK; 616 } 617 618 /** 619 * die_find_realfunc - Search a non-inlined function at given address 620 * @cu_die: a CU DIE which including @addr 621 * @addr: target address 622 * @die_mem: a buffer for result DIE 623 * 624 * Search a non-inlined function DIE which includes @addr. Stores the 625 * DIE to @die_mem and returns it if found. Returns NULL if failed. 626 */ 627 Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr, 628 Dwarf_Die *die_mem) 629 { 630 struct __addr_die_search_param ad; 631 ad.addr = addr; 632 ad.die_mem = die_mem; 633 /* dwarf_getscopes can't find subprogram. */ 634 if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0)) 635 return NULL; 636 else 637 return die_mem; 638 } 639 640 /* die_find callback for inline function search */ 641 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data) 642 { 643 Dwarf_Addr *addr = data; 644 645 if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine && 646 dwarf_haspc(die_mem, *addr)) 647 return DIE_FIND_CB_END; 648 649 return DIE_FIND_CB_CONTINUE; 650 } 651 652 /** 653 * die_find_top_inlinefunc - Search the top inlined function at given address 654 * @sp_die: a subprogram DIE which including @addr 655 * @addr: target address 656 * @die_mem: a buffer for result DIE 657 * 658 * Search an inlined function DIE which includes @addr. Stores the 659 * DIE to @die_mem and returns it if found. Returns NULL if failed. 660 * Even if several inlined functions are expanded recursively, this 661 * doesn't trace it down, and returns the topmost one. 662 */ 663 Dwarf_Die *die_find_top_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr, 664 Dwarf_Die *die_mem) 665 { 666 return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem); 667 } 668 669 /** 670 * die_find_inlinefunc - Search an inlined function at given address 671 * @sp_die: a subprogram DIE which including @addr 672 * @addr: target address 673 * @die_mem: a buffer for result DIE 674 * 675 * Search an inlined function DIE which includes @addr. Stores the 676 * DIE to @die_mem and returns it if found. Returns NULL if failed. 677 * If several inlined functions are expanded recursively, this trace 678 * it down and returns deepest one. 679 */ 680 Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr, 681 Dwarf_Die *die_mem) 682 { 683 Dwarf_Die tmp_die; 684 685 sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr, &tmp_die); 686 if (!sp_die) 687 return NULL; 688 689 /* Inlined function could be recursive. Trace it until fail */ 690 while (sp_die) { 691 memcpy(die_mem, sp_die, sizeof(Dwarf_Die)); 692 sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr, 693 &tmp_die); 694 } 695 696 return die_mem; 697 } 698 699 struct __instance_walk_param { 700 void *addr; 701 int (*callback)(Dwarf_Die *, void *); 702 void *data; 703 int retval; 704 }; 705 706 static int __die_walk_instances_cb(Dwarf_Die *inst, void *data) 707 { 708 struct __instance_walk_param *iwp = data; 709 Dwarf_Attribute attr_mem; 710 Dwarf_Die origin_mem; 711 Dwarf_Attribute *attr; 712 Dwarf_Die *origin; 713 int tmp; 714 715 if (!die_is_func_instance(inst)) 716 return DIE_FIND_CB_CONTINUE; 717 718 attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem); 719 if (attr == NULL) 720 return DIE_FIND_CB_CONTINUE; 721 722 origin = dwarf_formref_die(attr, &origin_mem); 723 if (origin == NULL || origin->addr != iwp->addr) 724 return DIE_FIND_CB_CONTINUE; 725 726 /* Ignore redundant instances */ 727 if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) { 728 dwarf_decl_line(origin, &tmp); 729 if (die_get_call_lineno(inst) == tmp) { 730 tmp = die_get_decl_fileno(origin); 731 if (die_get_call_fileno(inst) == tmp) 732 return DIE_FIND_CB_CONTINUE; 733 } 734 } 735 736 iwp->retval = iwp->callback(inst, iwp->data); 737 738 return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE; 739 } 740 741 /** 742 * die_walk_instances - Walk on instances of given DIE 743 * @or_die: an abstract original DIE 744 * @callback: a callback function which is called with instance DIE 745 * @data: user data 746 * 747 * Walk on the instances of give @in_die. @in_die must be an inlined function 748 * declaration. This returns the return value of @callback if it returns 749 * non-zero value, or -ENOENT if there is no instance. 750 */ 751 int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *), 752 void *data) 753 { 754 Dwarf_Die cu_die; 755 Dwarf_Die die_mem; 756 struct __instance_walk_param iwp = { 757 .addr = or_die->addr, 758 .callback = callback, 759 .data = data, 760 .retval = -ENOENT, 761 }; 762 763 if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL) 764 return -ENOENT; 765 766 die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem); 767 768 return iwp.retval; 769 } 770 771 /* Line walker internal parameters */ 772 struct __line_walk_param { 773 bool recursive; 774 line_walk_callback_t callback; 775 void *data; 776 int retval; 777 }; 778 779 static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data) 780 { 781 struct __line_walk_param *lw = data; 782 Dwarf_Addr addr = 0; 783 const char *fname; 784 int lineno; 785 786 if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) { 787 fname = die_get_call_file(in_die); 788 lineno = die_get_call_lineno(in_die); 789 if (fname && lineno > 0 && die_entrypc(in_die, &addr) == 0) { 790 lw->retval = lw->callback(fname, lineno, addr, lw->data); 791 if (lw->retval != 0) 792 return DIE_FIND_CB_END; 793 } 794 if (!lw->recursive) 795 return DIE_FIND_CB_SIBLING; 796 } 797 798 if (addr) { 799 fname = die_get_decl_file(in_die); 800 if (fname && dwarf_decl_line(in_die, &lineno) == 0) { 801 lw->retval = lw->callback(fname, lineno, addr, lw->data); 802 if (lw->retval != 0) 803 return DIE_FIND_CB_END; 804 } 805 } 806 807 /* Continue to search nested inlined function call-sites */ 808 return DIE_FIND_CB_CONTINUE; 809 } 810 811 /* Walk on lines of blocks included in given DIE */ 812 static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive, 813 line_walk_callback_t callback, void *data) 814 { 815 struct __line_walk_param lw = { 816 .recursive = recursive, 817 .callback = callback, 818 .data = data, 819 .retval = 0, 820 }; 821 Dwarf_Die die_mem; 822 Dwarf_Addr addr; 823 const char *fname; 824 int lineno; 825 826 /* Handle function declaration line */ 827 fname = die_get_decl_file(sp_die); 828 if (fname && dwarf_decl_line(sp_die, &lineno) == 0 && 829 die_entrypc(sp_die, &addr) == 0) { 830 lw.retval = callback(fname, lineno, addr, data); 831 if (lw.retval != 0) 832 goto done; 833 } 834 die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem); 835 done: 836 return lw.retval; 837 } 838 839 static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data) 840 { 841 struct __line_walk_param *lw = data; 842 843 /* 844 * Since inlined function can include another inlined function in 845 * the same file, we need to walk in it recursively. 846 */ 847 lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data); 848 if (lw->retval != 0) 849 return DWARF_CB_ABORT; 850 851 return DWARF_CB_OK; 852 } 853 854 /** 855 * die_walk_lines - Walk on lines inside given DIE 856 * @rt_die: a root DIE (CU, subprogram or inlined_subroutine) 857 * @callback: callback routine 858 * @data: user data 859 * 860 * Walk on all lines inside given @rt_die and call @callback on each line. 861 * If the @rt_die is a function, walk only on the lines inside the function, 862 * otherwise @rt_die must be a CU DIE. 863 * Note that this walks not only dwarf line list, but also function entries 864 * and inline call-site. 865 */ 866 int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data) 867 { 868 Dwarf_Lines *lines; 869 Dwarf_Line *line; 870 Dwarf_Addr addr; 871 const char *fname, *decf = NULL, *inf = NULL; 872 int lineno, ret = 0; 873 int decl = 0, inl; 874 Dwarf_Die die_mem, *cu_die; 875 size_t nlines, i; 876 bool flag; 877 878 /* Get the CU die */ 879 if (dwarf_tag(rt_die) != DW_TAG_compile_unit) { 880 cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL); 881 dwarf_decl_line(rt_die, &decl); 882 decf = die_get_decl_file(rt_die); 883 if (!decf) { 884 pr_debug2("Failed to get the declared file name of %s\n", 885 dwarf_diename(rt_die)); 886 return -EINVAL; 887 } 888 } else 889 cu_die = rt_die; 890 if (!cu_die) { 891 pr_debug2("Failed to get CU from given DIE.\n"); 892 return -EINVAL; 893 } 894 895 /* Get lines list in the CU */ 896 if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) { 897 pr_debug2("Failed to get source lines on this CU.\n"); 898 return -ENOENT; 899 } 900 pr_debug2("Get %zd lines from this CU\n", nlines); 901 902 /* Walk on the lines on lines list */ 903 for (i = 0; i < nlines; i++) { 904 line = dwarf_onesrcline(lines, i); 905 if (line == NULL || 906 dwarf_lineno(line, &lineno) != 0 || 907 dwarf_lineaddr(line, &addr) != 0) { 908 pr_debug2("Failed to get line info. " 909 "Possible error in debuginfo.\n"); 910 continue; 911 } 912 /* Skip end-of-sequence */ 913 if (dwarf_lineendsequence(line, &flag) != 0 || flag) 914 continue; 915 /* Skip Non statement line-info */ 916 if (dwarf_linebeginstatement(line, &flag) != 0 || !flag) 917 continue; 918 /* Filter lines based on address */ 919 if (rt_die != cu_die) { 920 /* 921 * Address filtering 922 * The line is included in given function, and 923 * no inline block includes it. 924 */ 925 if (!dwarf_haspc(rt_die, addr)) 926 continue; 927 928 if (die_find_inlinefunc(rt_die, addr, &die_mem)) { 929 /* Call-site check */ 930 inf = die_get_call_file(&die_mem); 931 if ((inf && !strcmp(inf, decf)) && 932 die_get_call_lineno(&die_mem) == lineno) 933 goto found; 934 935 dwarf_decl_line(&die_mem, &inl); 936 if (inl != decl || 937 decf != die_get_decl_file(&die_mem)) 938 continue; 939 } 940 } 941 found: 942 /* Get source line */ 943 fname = dwarf_linesrc(line, NULL, NULL); 944 945 ret = callback(fname, lineno, addr, data); 946 if (ret != 0) 947 return ret; 948 } 949 950 /* 951 * Dwarf lines doesn't include function declarations and inlined 952 * subroutines. We have to check functions list or given function. 953 */ 954 if (rt_die != cu_die) 955 /* 956 * Don't need walk inlined functions recursively, because 957 * inner inlined functions don't have the lines of the 958 * specified function. 959 */ 960 ret = __die_walk_funclines(rt_die, false, callback, data); 961 else { 962 struct __line_walk_param param = { 963 .callback = callback, 964 .data = data, 965 .retval = 0, 966 }; 967 dwarf_getfuncs(cu_die, __die_walk_culines_cb, ¶m, 0); 968 ret = param.retval; 969 } 970 971 return ret; 972 } 973 974 struct __find_variable_param { 975 const char *name; 976 Dwarf_Addr addr; 977 }; 978 979 static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data) 980 { 981 struct __find_variable_param *fvp = data; 982 Dwarf_Attribute attr; 983 int tag; 984 985 tag = dwarf_tag(die_mem); 986 if ((tag == DW_TAG_formal_parameter || 987 tag == DW_TAG_variable) && 988 die_compare_name(die_mem, fvp->name) && 989 /* 990 * Does the DIE have location information or const value 991 * or external instance? 992 */ 993 (dwarf_attr(die_mem, DW_AT_external, &attr) || 994 dwarf_attr(die_mem, DW_AT_location, &attr) || 995 dwarf_attr(die_mem, DW_AT_const_value, &attr))) 996 return DIE_FIND_CB_END; 997 if (dwarf_haspc(die_mem, fvp->addr)) 998 return DIE_FIND_CB_CONTINUE; 999 else 1000 return DIE_FIND_CB_SIBLING; 1001 } 1002 1003 /** 1004 * die_find_variable_at - Find a given name variable at given address 1005 * @sp_die: a function DIE 1006 * @name: variable name 1007 * @addr: address 1008 * @die_mem: a buffer for result DIE 1009 * 1010 * Find a variable DIE called @name at @addr in @sp_die. 1011 */ 1012 Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name, 1013 Dwarf_Addr addr, Dwarf_Die *die_mem) 1014 { 1015 struct __find_variable_param fvp = { .name = name, .addr = addr}; 1016 1017 return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp, 1018 die_mem); 1019 } 1020 1021 static int __die_find_member_cb(Dwarf_Die *die_mem, void *data) 1022 { 1023 const char *name = data; 1024 1025 if (dwarf_tag(die_mem) == DW_TAG_member) { 1026 if (die_compare_name(die_mem, name)) 1027 return DIE_FIND_CB_END; 1028 else if (!dwarf_diename(die_mem)) { /* Unnamed structure */ 1029 Dwarf_Die type_die, tmp_die; 1030 if (die_get_type(die_mem, &type_die) && 1031 die_find_member(&type_die, name, &tmp_die)) 1032 return DIE_FIND_CB_END; 1033 } 1034 } 1035 return DIE_FIND_CB_SIBLING; 1036 } 1037 1038 /** 1039 * die_find_member - Find a given name member in a data structure 1040 * @st_die: a data structure type DIE 1041 * @name: member name 1042 * @die_mem: a buffer for result DIE 1043 * 1044 * Find a member DIE called @name in @st_die. 1045 */ 1046 Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name, 1047 Dwarf_Die *die_mem) 1048 { 1049 return die_find_child(st_die, __die_find_member_cb, (void *)name, 1050 die_mem); 1051 } 1052 1053 /** 1054 * die_get_typename_from_type - Get the name of given type DIE 1055 * @type_die: a type DIE 1056 * @buf: a strbuf for result type name 1057 * 1058 * Get the name of @type_die and stores it to @buf. Return 0 if succeeded. 1059 * and Return -ENOENT if failed to find type name. 1060 * Note that the result will stores typedef name if possible, and stores 1061 * "*(function_type)" if the type is a function pointer. 1062 */ 1063 int die_get_typename_from_type(Dwarf_Die *type_die, struct strbuf *buf) 1064 { 1065 int tag, ret; 1066 const char *tmp = ""; 1067 1068 tag = dwarf_tag(type_die); 1069 if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type) 1070 tmp = "*"; 1071 else if (tag == DW_TAG_subroutine_type) { 1072 /* Function pointer */ 1073 return strbuf_add(buf, "(function_type)", 15); 1074 } else { 1075 const char *name = dwarf_diename(type_die); 1076 1077 if (tag == DW_TAG_union_type) 1078 tmp = "union "; 1079 else if (tag == DW_TAG_structure_type) 1080 tmp = "struct "; 1081 else if (tag == DW_TAG_enumeration_type) 1082 tmp = "enum "; 1083 else if (name == NULL) 1084 return -ENOENT; 1085 /* Write a base name */ 1086 return strbuf_addf(buf, "%s%s", tmp, name ?: ""); 1087 } 1088 ret = die_get_typename(type_die, buf); 1089 if (ret < 0) { 1090 /* void pointer has no type attribute */ 1091 if (tag == DW_TAG_pointer_type && ret == -ENOENT) 1092 return strbuf_addf(buf, "void*"); 1093 1094 return ret; 1095 } 1096 return strbuf_addstr(buf, tmp); 1097 } 1098 1099 /** 1100 * die_get_typename - Get the name of given variable DIE 1101 * @vr_die: a variable DIE 1102 * @buf: a strbuf for result type name 1103 * 1104 * Get the name of @vr_die and stores it to @buf. Return 0 if succeeded. 1105 * and Return -ENOENT if failed to find type name. 1106 * Note that the result will stores typedef name if possible, and stores 1107 * "*(function_type)" if the type is a function pointer. 1108 */ 1109 int die_get_typename(Dwarf_Die *vr_die, struct strbuf *buf) 1110 { 1111 Dwarf_Die type; 1112 1113 if (__die_get_real_type(vr_die, &type) == NULL) 1114 return -ENOENT; 1115 1116 return die_get_typename_from_type(&type, buf); 1117 } 1118 1119 /** 1120 * die_get_varname - Get the name and type of given variable DIE 1121 * @vr_die: a variable DIE 1122 * @buf: a strbuf for type and variable name 1123 * 1124 * Get the name and type of @vr_die and stores it in @buf as "type\tname". 1125 */ 1126 int die_get_varname(Dwarf_Die *vr_die, struct strbuf *buf) 1127 { 1128 int ret; 1129 1130 ret = die_get_typename(vr_die, buf); 1131 if (ret < 0) { 1132 pr_debug("Failed to get type, make it unknown.\n"); 1133 ret = strbuf_add(buf, "(unknown_type)", 14); 1134 } 1135 1136 return ret < 0 ? ret : strbuf_addf(buf, "\t%s", dwarf_diename(vr_die)); 1137 } 1138 1139 #ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT 1140 /** 1141 * die_get_var_innermost_scope - Get innermost scope range of given variable DIE 1142 * @sp_die: a subprogram DIE 1143 * @vr_die: a variable DIE 1144 * @buf: a strbuf for variable byte offset range 1145 * 1146 * Get the innermost scope range of @vr_die and stores it in @buf as 1147 * "@<function_name+[NN-NN,NN-NN]>". 1148 */ 1149 static int die_get_var_innermost_scope(Dwarf_Die *sp_die, Dwarf_Die *vr_die, 1150 struct strbuf *buf) 1151 { 1152 Dwarf_Die *scopes; 1153 int count; 1154 size_t offset = 0; 1155 Dwarf_Addr base; 1156 Dwarf_Addr start, end; 1157 Dwarf_Addr entry; 1158 int ret; 1159 bool first = true; 1160 const char *name; 1161 1162 ret = die_entrypc(sp_die, &entry); 1163 if (ret) 1164 return ret; 1165 1166 name = dwarf_diename(sp_die); 1167 if (!name) 1168 return -ENOENT; 1169 1170 count = dwarf_getscopes_die(vr_die, &scopes); 1171 1172 /* (*SCOPES)[1] is the DIE for the scope containing that scope */ 1173 if (count <= 1) { 1174 ret = -EINVAL; 1175 goto out; 1176 } 1177 1178 while ((offset = dwarf_ranges(&scopes[1], offset, &base, 1179 &start, &end)) > 0) { 1180 start -= entry; 1181 end -= entry; 1182 1183 if (first) { 1184 ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64, 1185 name, start, end); 1186 first = false; 1187 } else { 1188 ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64, 1189 start, end); 1190 } 1191 if (ret < 0) 1192 goto out; 1193 } 1194 1195 if (!first) 1196 ret = strbuf_add(buf, "]>", 2); 1197 1198 out: 1199 free(scopes); 1200 return ret; 1201 } 1202 1203 /** 1204 * die_get_var_range - Get byte offset range of given variable DIE 1205 * @sp_die: a subprogram DIE 1206 * @vr_die: a variable DIE 1207 * @buf: a strbuf for type and variable name and byte offset range 1208 * 1209 * Get the byte offset range of @vr_die and stores it in @buf as 1210 * "@<function_name+[NN-NN,NN-NN]>". 1211 */ 1212 int die_get_var_range(Dwarf_Die *sp_die, Dwarf_Die *vr_die, struct strbuf *buf) 1213 { 1214 int ret = 0; 1215 Dwarf_Addr base; 1216 Dwarf_Addr start, end; 1217 Dwarf_Addr entry; 1218 Dwarf_Op *op; 1219 size_t nops; 1220 size_t offset = 0; 1221 Dwarf_Attribute attr; 1222 bool first = true; 1223 const char *name; 1224 1225 ret = die_entrypc(sp_die, &entry); 1226 if (ret) 1227 return ret; 1228 1229 name = dwarf_diename(sp_die); 1230 if (!name) 1231 return -ENOENT; 1232 1233 if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL) 1234 return -EINVAL; 1235 1236 while ((offset = dwarf_getlocations(&attr, offset, &base, 1237 &start, &end, &op, &nops)) > 0) { 1238 if (start == 0) { 1239 /* Single Location Descriptions */ 1240 ret = die_get_var_innermost_scope(sp_die, vr_die, buf); 1241 goto out; 1242 } 1243 1244 /* Location Lists */ 1245 start -= entry; 1246 end -= entry; 1247 if (first) { 1248 ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64, 1249 name, start, end); 1250 first = false; 1251 } else { 1252 ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64, 1253 start, end); 1254 } 1255 if (ret < 0) 1256 goto out; 1257 } 1258 1259 if (!first) 1260 ret = strbuf_add(buf, "]>", 2); 1261 out: 1262 return ret; 1263 } 1264 1265 /* Interval parameters for __die_find_var_reg_cb() */ 1266 struct find_var_data { 1267 /* Target instruction address */ 1268 Dwarf_Addr pc; 1269 /* Target memory address (for global data) */ 1270 Dwarf_Addr addr; 1271 /* Target register */ 1272 unsigned reg; 1273 /* Access offset, set for global data */ 1274 int offset; 1275 }; 1276 1277 /* Max number of registers DW_OP_regN supports */ 1278 #define DWARF_OP_DIRECT_REGS 32 1279 1280 /* Only checks direct child DIEs in the given scope. */ 1281 static int __die_find_var_reg_cb(Dwarf_Die *die_mem, void *arg) 1282 { 1283 struct find_var_data *data = arg; 1284 int tag = dwarf_tag(die_mem); 1285 ptrdiff_t off = 0; 1286 Dwarf_Attribute attr; 1287 Dwarf_Addr base, start, end; 1288 Dwarf_Op *ops; 1289 size_t nops; 1290 1291 if (tag != DW_TAG_variable && tag != DW_TAG_formal_parameter) 1292 return DIE_FIND_CB_SIBLING; 1293 1294 if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL) 1295 return DIE_FIND_CB_SIBLING; 1296 1297 while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) { 1298 /* Assuming the location list is sorted by address */ 1299 if (end < data->pc) 1300 continue; 1301 if (start > data->pc) 1302 break; 1303 1304 /* Only match with a simple case */ 1305 if (data->reg < DWARF_OP_DIRECT_REGS) { 1306 if (ops->atom == (DW_OP_reg0 + data->reg) && nops == 1) 1307 return DIE_FIND_CB_END; 1308 } else { 1309 if (ops->atom == DW_OP_regx && ops->number == data->reg && 1310 nops == 1) 1311 return DIE_FIND_CB_END; 1312 } 1313 } 1314 return DIE_FIND_CB_SIBLING; 1315 } 1316 1317 /** 1318 * die_find_variable_by_reg - Find a variable saved in a register 1319 * @sc_die: a scope DIE 1320 * @pc: the program address to find 1321 * @reg: the register number to find 1322 * @die_mem: a buffer to save the resulting DIE 1323 * 1324 * Find the variable DIE accessed by the given register. 1325 */ 1326 Dwarf_Die *die_find_variable_by_reg(Dwarf_Die *sc_die, Dwarf_Addr pc, int reg, 1327 Dwarf_Die *die_mem) 1328 { 1329 struct find_var_data data = { 1330 .pc = pc, 1331 .reg = reg, 1332 }; 1333 return die_find_child(sc_die, __die_find_var_reg_cb, &data, die_mem); 1334 } 1335 1336 /* Only checks direct child DIEs in the given scope */ 1337 static int __die_find_var_addr_cb(Dwarf_Die *die_mem, void *arg) 1338 { 1339 struct find_var_data *data = arg; 1340 int tag = dwarf_tag(die_mem); 1341 ptrdiff_t off = 0; 1342 Dwarf_Attribute attr; 1343 Dwarf_Addr base, start, end; 1344 Dwarf_Word size; 1345 Dwarf_Die type_die; 1346 Dwarf_Op *ops; 1347 size_t nops; 1348 1349 if (tag != DW_TAG_variable) 1350 return DIE_FIND_CB_SIBLING; 1351 1352 if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL) 1353 return DIE_FIND_CB_SIBLING; 1354 1355 while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) { 1356 if (ops->atom != DW_OP_addr) 1357 continue; 1358 1359 if (data->addr < ops->number) 1360 continue; 1361 1362 if (data->addr == ops->number) { 1363 /* Update offset relative to the start of the variable */ 1364 data->offset = 0; 1365 return DIE_FIND_CB_END; 1366 } 1367 1368 if (die_get_real_type(die_mem, &type_die) == NULL) 1369 continue; 1370 1371 if (dwarf_aggregate_size(&type_die, &size) < 0) 1372 continue; 1373 1374 if (data->addr >= ops->number + size) 1375 continue; 1376 1377 /* Update offset relative to the start of the variable */ 1378 data->offset = data->addr - ops->number; 1379 return DIE_FIND_CB_END; 1380 } 1381 return DIE_FIND_CB_SIBLING; 1382 } 1383 1384 /** 1385 * die_find_variable_by_addr - Find variable located at given address 1386 * @sc_die: a scope DIE 1387 * @pc: the program address to find 1388 * @addr: the data address to find 1389 * @die_mem: a buffer to save the resulting DIE 1390 * @offset: the offset in the resulting type 1391 * 1392 * Find the variable DIE located at the given address (in PC-relative mode). 1393 * This is usually for global variables. 1394 */ 1395 Dwarf_Die *die_find_variable_by_addr(Dwarf_Die *sc_die, Dwarf_Addr pc, 1396 Dwarf_Addr addr, Dwarf_Die *die_mem, 1397 int *offset) 1398 { 1399 struct find_var_data data = { 1400 .pc = pc, 1401 .addr = addr, 1402 }; 1403 Dwarf_Die *result; 1404 1405 result = die_find_child(sc_die, __die_find_var_addr_cb, &data, die_mem); 1406 if (result) 1407 *offset = data.offset; 1408 return result; 1409 } 1410 #endif 1411 1412 /* 1413 * die_has_loclist - Check if DW_AT_location of @vr_die is a location list 1414 * @vr_die: a variable DIE 1415 */ 1416 static bool die_has_loclist(Dwarf_Die *vr_die) 1417 { 1418 Dwarf_Attribute loc; 1419 int tag = dwarf_tag(vr_die); 1420 1421 if (tag != DW_TAG_formal_parameter && 1422 tag != DW_TAG_variable) 1423 return false; 1424 1425 return (dwarf_attr_integrate(vr_die, DW_AT_location, &loc) && 1426 dwarf_whatform(&loc) == DW_FORM_sec_offset); 1427 } 1428 1429 /* 1430 * die_is_optimized_target - Check if target program is compiled with 1431 * optimization 1432 * @cu_die: a CU DIE 1433 * 1434 * For any object in given CU whose DW_AT_location is a location list, 1435 * target program is compiled with optimization. This is applicable to 1436 * clang as well. 1437 */ 1438 bool die_is_optimized_target(Dwarf_Die *cu_die) 1439 { 1440 Dwarf_Die tmp_die; 1441 1442 if (die_has_loclist(cu_die)) 1443 return true; 1444 1445 if (!dwarf_child(cu_die, &tmp_die) && 1446 die_is_optimized_target(&tmp_die)) 1447 return true; 1448 1449 if (!dwarf_siblingof(cu_die, &tmp_die) && 1450 die_is_optimized_target(&tmp_die)) 1451 return true; 1452 1453 return false; 1454 } 1455 1456 /* 1457 * die_search_idx - Search index of given line address 1458 * @lines: Line records of single CU 1459 * @nr_lines: Number of @lines 1460 * @addr: address we are looking for 1461 * @idx: index to be set by this function (return value) 1462 * 1463 * Search for @addr by looping over every lines of CU. If address 1464 * matches, set index of that line in @idx. Note that single source 1465 * line can have multiple line records. i.e. single source line can 1466 * have multiple index. 1467 */ 1468 static bool die_search_idx(Dwarf_Lines *lines, unsigned long nr_lines, 1469 Dwarf_Addr addr, unsigned long *idx) 1470 { 1471 unsigned long i; 1472 Dwarf_Addr tmp; 1473 1474 for (i = 0; i < nr_lines; i++) { 1475 if (dwarf_lineaddr(dwarf_onesrcline(lines, i), &tmp)) 1476 return false; 1477 1478 if (tmp == addr) { 1479 *idx = i; 1480 return true; 1481 } 1482 } 1483 return false; 1484 } 1485 1486 /* 1487 * die_get_postprologue_addr - Search next address after function prologue 1488 * @entrypc_idx: entrypc index 1489 * @lines: Line records of single CU 1490 * @nr_lines: Number of @lines 1491 * @hignpc: high PC address of function 1492 * @postprologue_addr: Next address after function prologue (return value) 1493 * 1494 * Look for prologue-end marker. If there is no explicit marker, return 1495 * address of next line record or next source line. 1496 */ 1497 static bool die_get_postprologue_addr(unsigned long entrypc_idx, 1498 Dwarf_Lines *lines, 1499 unsigned long nr_lines, 1500 Dwarf_Addr highpc, 1501 Dwarf_Addr *postprologue_addr) 1502 { 1503 unsigned long i; 1504 int entrypc_lno, lno; 1505 Dwarf_Line *line; 1506 Dwarf_Addr addr; 1507 bool p_end; 1508 1509 /* entrypc_lno is actual source line number */ 1510 line = dwarf_onesrcline(lines, entrypc_idx); 1511 if (dwarf_lineno(line, &entrypc_lno)) 1512 return false; 1513 1514 for (i = entrypc_idx; i < nr_lines; i++) { 1515 line = dwarf_onesrcline(lines, i); 1516 1517 if (dwarf_lineaddr(line, &addr) || 1518 dwarf_lineno(line, &lno) || 1519 dwarf_lineprologueend(line, &p_end)) 1520 return false; 1521 1522 /* highpc is exclusive. [entrypc,highpc) */ 1523 if (addr >= highpc) 1524 break; 1525 1526 /* clang supports prologue-end marker */ 1527 if (p_end) 1528 break; 1529 1530 /* Actual next line in source */ 1531 if (lno != entrypc_lno) 1532 break; 1533 1534 /* 1535 * Single source line can have multiple line records. 1536 * For Example, 1537 * void foo() { printf("hello\n"); } 1538 * contains two line records. One points to declaration and 1539 * other points to printf() line. Variable 'lno' won't get 1540 * incremented in this case but 'i' will. 1541 */ 1542 if (i != entrypc_idx) 1543 break; 1544 } 1545 1546 dwarf_lineaddr(line, postprologue_addr); 1547 if (*postprologue_addr >= highpc) 1548 dwarf_lineaddr(dwarf_onesrcline(lines, i - 1), 1549 postprologue_addr); 1550 1551 return true; 1552 } 1553 1554 /* 1555 * die_skip_prologue - Use next address after prologue as probe location 1556 * @sp_die: a subprogram DIE 1557 * @cu_die: a CU DIE 1558 * @entrypc: entrypc of the function 1559 * 1560 * Function prologue prepares stack and registers before executing function 1561 * logic. When target program is compiled without optimization, function 1562 * parameter information is only valid after prologue. When we probe entrypc 1563 * of the function, and try to record function parameter, it contains 1564 * garbage value. 1565 */ 1566 void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die, 1567 Dwarf_Addr *entrypc) 1568 { 1569 size_t nr_lines = 0; 1570 unsigned long entrypc_idx = 0; 1571 Dwarf_Lines *lines = NULL; 1572 Dwarf_Addr postprologue_addr; 1573 Dwarf_Addr highpc; 1574 1575 if (dwarf_highpc(sp_die, &highpc)) 1576 return; 1577 1578 if (dwarf_getsrclines(cu_die, &lines, &nr_lines)) 1579 return; 1580 1581 if (!die_search_idx(lines, nr_lines, *entrypc, &entrypc_idx)) 1582 return; 1583 1584 if (!die_get_postprologue_addr(entrypc_idx, lines, nr_lines, 1585 highpc, &postprologue_addr)) 1586 return; 1587 1588 *entrypc = postprologue_addr; 1589 } 1590 1591 /* Internal parameters for __die_find_scope_cb() */ 1592 struct find_scope_data { 1593 /* Target instruction address */ 1594 Dwarf_Addr pc; 1595 /* Number of scopes found [output] */ 1596 int nr; 1597 /* Array of scopes found, 0 for the outermost one. [output] */ 1598 Dwarf_Die *scopes; 1599 }; 1600 1601 static int __die_find_scope_cb(Dwarf_Die *die_mem, void *arg) 1602 { 1603 struct find_scope_data *data = arg; 1604 1605 if (dwarf_haspc(die_mem, data->pc)) { 1606 Dwarf_Die *tmp; 1607 1608 tmp = realloc(data->scopes, (data->nr + 1) * sizeof(*tmp)); 1609 if (tmp == NULL) 1610 return DIE_FIND_CB_END; 1611 1612 memcpy(tmp + data->nr, die_mem, sizeof(*die_mem)); 1613 data->scopes = tmp; 1614 data->nr++; 1615 return DIE_FIND_CB_CHILD; 1616 } 1617 return DIE_FIND_CB_SIBLING; 1618 } 1619 1620 /** 1621 * die_get_scopes - Return a list of scopes including the address 1622 * @cu_die: a compile unit DIE 1623 * @pc: the address to find 1624 * @scopes: the array of DIEs for scopes (result) 1625 * 1626 * This function does the same as the dwarf_getscopes() but doesn't follow 1627 * the origins of inlined functions. It returns the number of scopes saved 1628 * in the @scopes argument. The outer scope will be saved first (index 0) and 1629 * the last one is the innermost scope at the @pc. 1630 */ 1631 int die_get_scopes(Dwarf_Die *cu_die, Dwarf_Addr pc, Dwarf_Die **scopes) 1632 { 1633 struct find_scope_data data = { 1634 .pc = pc, 1635 }; 1636 Dwarf_Die die_mem; 1637 1638 die_find_child(cu_die, __die_find_scope_cb, &data, &die_mem); 1639 1640 *scopes = data.scopes; 1641 return data.nr; 1642 } 1643