tools/perf/util/dwarf-aux.c

   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 "util.h"
  10 #include "debug.h"
  11 #include "dwarf-aux.h"
  12 #include "string2.h"
  13
  14 /**
  15  * cu_find_realpath - Find the realpath of the target file
  16  * @cu_die: A DIE(dwarf information entry) of CU(compilation Unit)
  17  * @fname:  The tail filename of the target file
  18  *
  19  * Find the real(long) path of @fname in @cu_die.
  20  */
  21 const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
  22 {
  23         Dwarf_Files *files;
  24         size_t nfiles, i;
  25         const char *src = NULL;
  26         int ret;
  27
  28         if (!fname)
  29                 return NULL;
  30
  31         ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
  32         if (ret != 0)
  33                 return NULL;
  34
  35         for (i = 0; i < nfiles; i++) {
  36                 src = dwarf_filesrc(files, i, NULL, NULL);
  37                 if (strtailcmp(src, fname) == 0)
  38                         break;
  39         }
  40         if (i == nfiles)
  41                 return NULL;
  42         return src;
  43 }
  44
  45 /**
  46  * cu_get_comp_dir - Get the path of compilation directory
  47  * @cu_die: a CU DIE
  48  *
  49  * Get the path of compilation directory of given @cu_die.
  50  * Since this depends on DW_AT_comp_dir, older gcc will not
  51  * embedded it. In that case, this returns NULL.
  52  */
  53 const char *cu_get_comp_dir(Dwarf_Die *cu_die)
  54 {
  55         Dwarf_Attribute attr;
  56         if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
  57                 return NULL;
  58         return dwarf_formstring(&attr);
  59 }
  60
  61 /**
  62  * cu_find_lineinfo - Get a line number and file name for given address
  63  * @cu_die: a CU DIE
  64  * @addr: An address
  65  * @fname: a pointer which returns the file name string
  66  * @lineno: a pointer which returns the line number
  67  *
  68  * Find a line number and file name for @addr in @cu_die.
  69  */
  70 int cu_find_lineinfo(Dwarf_Die *cu_die, unsigned long addr,
  71                     const char **fname, int *lineno)
  72 {
  73         Dwarf_Line *line;
  74         Dwarf_Addr laddr;
  75
  76         line = dwarf_getsrc_die(cu_die, (Dwarf_Addr)addr);
  77         if (line && dwarf_lineaddr(line, &laddr) == 0 &&
  78             addr == (unsigned long)laddr && dwarf_lineno(line, lineno) == 0) {
  79                 *fname = dwarf_linesrc(line, NULL, NULL);
  80                 if (!*fname)
  81                         /* line number is useless without filename */
  82                         *lineno = 0;
  83         }
  84
  85         return *lineno ?: -ENOENT;
  86 }
  87
  88 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
  89
  90 /**
  91  * cu_walk_functions_at - Walk on function DIEs at given address
  92  * @cu_die: A CU DIE
  93  * @addr: An address
  94  * @callback: A callback which called with found DIEs
  95  * @data: A user data
  96  *
  97  * Walk on function DIEs at given @addr in @cu_die. Passed DIEs
  98  * should be subprogram or inlined-subroutines.
  99  */
 100 int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
 101                     int (*callback)(Dwarf_Die *, void *), void *data)
 102 {
 103         Dwarf_Die die_mem;
 104         Dwarf_Die *sc_die;
 105         int ret = -ENOENT;
 106
 107         /* Inlined function could be recursive. Trace it until fail */
 108         for (sc_die = die_find_realfunc(cu_die, addr, &die_mem);
 109              sc_die != NULL;
 110              sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr,
 111                                      &die_mem)) {
 112                 ret = callback(sc_die, data);
 113                 if (ret)
 114                         break;
 115         }
 116
 117         return ret;
 118
 119 }
 120
 121 /**
 122  * die_get_linkage_name - Get the linkage name of the object
 123  * @dw_die: A DIE of the object
 124  *
 125  * Get the linkage name attiribute of given @dw_die.
 126  * For C++ binary, the linkage name will be the mangled symbol.
 127  */
 128 const char *die_get_linkage_name(Dwarf_Die *dw_die)
 129 {
 130         Dwarf_Attribute attr;
 131
 132         if (dwarf_attr_integrate(dw_die, DW_AT_linkage_name, &attr) == NULL)
 133                 return NULL;
 134         return dwarf_formstring(&attr);
 135 }
 136
 137 /**
 138  * die_compare_name - Compare diename and tname
 139  * @dw_die: a DIE
 140  * @tname: a string of target name
 141  *
 142  * Compare the name of @dw_die and @tname. Return false if @dw_die has no name.
 143  */
 144 bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
 145 {
 146         const char *name;
 147
 148         name = dwarf_diename(dw_die);
 149         return name ? (strcmp(tname, name) == 0) : false;
 150 }
 151
 152 /**
 153  * die_match_name - Match diename/linkage name and glob
 154  * @dw_die: a DIE
 155  * @glob: a string of target glob pattern
 156  *
 157  * Glob matching the name of @dw_die and @glob. Return false if matching fail.
 158  * This also match linkage name.
 159  */
 160 bool die_match_name(Dwarf_Die *dw_die, const char *glob)
 161 {
 162         const char *name;
 163
 164         name = dwarf_diename(dw_die);
 165         if (name && strglobmatch(name, glob))
 166                 return true;
 167         /* fall back to check linkage name */
 168         name = die_get_linkage_name(dw_die);
 169         if (name && strglobmatch(name, glob))
 170                 return true;
 171
 172         return false;
 173 }
 174
 175 /**
 176  * die_get_call_lineno - Get callsite line number of inline-function instance
 177  * @in_die: a DIE of an inlined function instance
 178  *
 179  * Get call-site line number of @in_die. This means from where the inline
 180  * function is called.
 181  */
 182 int die_get_call_lineno(Dwarf_Die *in_die)
 183 {
 184         Dwarf_Attribute attr;
 185         Dwarf_Word ret;
 186
 187         if (!dwarf_attr(in_die, DW_AT_call_line, &attr))
 188                 return -ENOENT;
 189
 190         dwarf_formudata(&attr, &ret);
 191         return (int)ret;
 192 }
 193
 194 /**
 195  * die_get_type - Get type DIE
 196  * @vr_die: a DIE of a variable
 197  * @die_mem: where to store a type DIE
 198  *
 199  * Get a DIE of the type of given variable (@vr_die), and store
 200  * it to die_mem. Return NULL if fails to get a type DIE.
 201  */
 202 Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 203 {
 204         Dwarf_Attribute attr;
 205
 206         if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
 207             dwarf_formref_die(&attr, die_mem))
 208                 return die_mem;
 209         else
 210                 return NULL;
 211 }
 212
 213 /* Get a type die, but skip qualifiers */
 214 static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 215 {
 216         int tag;
 217
 218         do {
 219                 vr_die = die_get_type(vr_die, die_mem);
 220                 if (!vr_die)
 221                         break;
 222                 tag = dwarf_tag(vr_die);
 223         } while (tag == DW_TAG_const_type ||
 224                  tag == DW_TAG_restrict_type ||
 225                  tag == DW_TAG_volatile_type ||
 226                  tag == DW_TAG_shared_type);
 227
 228         return vr_die;
 229 }
 230
 231 /**
 232  * die_get_real_type - Get a type die, but skip qualifiers and typedef
 233  * @vr_die: a DIE of a variable
 234  * @die_mem: where to store a type DIE
 235  *
 236  * Get a DIE of the type of given variable (@vr_die), and store
 237  * it to die_mem. Return NULL if fails to get a type DIE.
 238  * If the type is qualifiers (e.g. const) or typedef, this skips it
 239  * and tries to find real type (structure or basic types, e.g. int).
 240  */
 241 Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 242 {
 243         do {
 244                 vr_die = __die_get_real_type(vr_die, die_mem);
 245         } while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef);
 246
 247         return vr_die;
 248 }
 249
 250 /* Get attribute and translate it as a udata */
 251 static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
 252                               Dwarf_Word *result)
 253 {
 254         Dwarf_Attribute attr;
 255
 256         if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
 257             dwarf_formudata(&attr, result) != 0)
 258                 return -ENOENT;
 259
 260         return 0;
 261 }
 262
 263 /* Get attribute and translate it as a sdata */
 264 static int die_get_attr_sdata(Dwarf_Die *tp_die, unsigned int attr_name,
 265                               Dwarf_Sword *result)
 266 {
 267         Dwarf_Attribute attr;
 268
 269         if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
 270             dwarf_formsdata(&attr, result) != 0)
 271                 return -ENOENT;
 272
 273         return 0;
 274 }
 275
 276 /**
 277  * die_is_signed_type - Check whether a type DIE is signed or not
 278  * @tp_die: a DIE of a type
 279  *
 280  * Get the encoding of @tp_die and return true if the encoding
 281  * is signed.
 282  */
 283 bool die_is_signed_type(Dwarf_Die *tp_die)
 284 {
 285         Dwarf_Word ret;
 286
 287         if (die_get_attr_udata(tp_die, DW_AT_encoding, &ret))
 288                 return false;
 289
 290         return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
 291                 ret == DW_ATE_signed_fixed);
 292 }
 293
 294 /**
 295  * die_is_func_def - Ensure that this DIE is a subprogram and definition
 296  * @dw_die: a DIE
 297  *
 298  * Ensure that this DIE is a subprogram and NOT a declaration. This
 299  * returns true if @dw_die is a function definition.
 300  **/
 301 bool die_is_func_def(Dwarf_Die *dw_die)
 302 {
 303         Dwarf_Attribute attr;
 304
 305         return (dwarf_tag(dw_die) == DW_TAG_subprogram &&
 306                 dwarf_attr(dw_die, DW_AT_declaration, &attr) == NULL);
 307 }
 308
 309 /**
 310  * die_is_func_instance - Ensure that this DIE is an instance of a subprogram
 311  * @dw_die: a DIE
 312  *
 313  * Ensure that this DIE is an instance (which has an entry address).
 314  * This returns true if @dw_die is a function instance. If not, you need to
 315  * call die_walk_instances() to find actual instances.
 316  **/
 317 bool die_is_func_instance(Dwarf_Die *dw_die)
 318 {
 319         Dwarf_Addr tmp;
 320
 321         /* Actually gcc optimizes non-inline as like as inlined */
 322         return !dwarf_func_inline(dw_die) && dwarf_entrypc(dw_die, &tmp) == 0;
 323 }
 324 /**
 325  * die_get_data_member_location - Get the data-member offset
 326  * @mb_die: a DIE of a member of a data structure
 327  * @offs: The offset of the member in the data structure
 328  *
 329  * Get the offset of @mb_die in the data structure including @mb_die, and
 330  * stores result offset to @offs. If any error occurs this returns errno.
 331  */
 332 int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
 333 {
 334         Dwarf_Attribute attr;
 335         Dwarf_Op *expr;
 336         size_t nexpr;
 337         int ret;
 338
 339         if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
 340                 return -ENOENT;
 341
 342         if (dwarf_formudata(&attr, offs) != 0) {
 343                 /* DW_AT_data_member_location should be DW_OP_plus_uconst */
 344                 ret = dwarf_getlocation(&attr, &expr, &nexpr);
 345                 if (ret < 0 || nexpr == 0)
 346                         return -ENOENT;
 347
 348                 if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
 349                         pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
 350                                  expr[0].atom, nexpr);
 351                         return -ENOTSUP;
 352                 }
 353                 *offs = (Dwarf_Word)expr[0].number;
 354         }
 355         return 0;
 356 }
 357
 358 /* Get the call file index number in CU DIE */
 359 static int die_get_call_fileno(Dwarf_Die *in_die)
 360 {
 361         Dwarf_Sword idx;
 362
 363         if (die_get_attr_sdata(in_die, DW_AT_call_file, &idx) == 0)
 364                 return (int)idx;
 365         else
 366                 return -ENOENT;
 367 }
 368
 369 /* Get the declared file index number in CU DIE */
 370 static int die_get_decl_fileno(Dwarf_Die *pdie)
 371 {
 372         Dwarf_Sword idx;
 373
 374         if (die_get_attr_sdata(pdie, DW_AT_decl_file, &idx) == 0)
 375                 return (int)idx;
 376         else
 377                 return -ENOENT;
 378 }
 379
 380 /**
 381  * die_get_call_file - Get callsite file name of inlined function instance
 382  * @in_die: a DIE of an inlined function instance
 383  *
 384  * Get call-site file name of @in_die. This means from which file the inline
 385  * function is called.
 386  */
 387 const char *die_get_call_file(Dwarf_Die *in_die)
 388 {
 389         Dwarf_Die cu_die;
 390         Dwarf_Files *files;
 391         int idx;
 392
 393         idx = die_get_call_fileno(in_die);
 394         if (idx < 0 || !dwarf_diecu(in_die, &cu_die, NULL, NULL) ||
 395             dwarf_getsrcfiles(&cu_die, &files, NULL) != 0)
 396                 return NULL;
 397
 398         return dwarf_filesrc(files, idx, NULL, NULL);
 399 }
 400
 401
 402 /**
 403  * die_find_child - Generic DIE search function in DIE tree
 404  * @rt_die: a root DIE
 405  * @callback: a callback function
 406  * @data: a user data passed to the callback function
 407  * @die_mem: a buffer for result DIE
 408  *
 409  * Trace DIE tree from @rt_die and call @callback for each child DIE.
 410  * If @callback returns DIE_FIND_CB_END, this stores the DIE into
 411  * @die_mem and returns it. If @callback returns DIE_FIND_CB_CONTINUE,
 412  * this continues to trace the tree. Optionally, @callback can return
 413  * DIE_FIND_CB_CHILD and DIE_FIND_CB_SIBLING, those means trace only
 414  * the children and trace only the siblings respectively.
 415  * Returns NULL if @callback can't find any appropriate DIE.
 416  */
 417 Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
 418                           int (*callback)(Dwarf_Die *, void *),
 419                           void *data, Dwarf_Die *die_mem)
 420 {
 421         Dwarf_Die child_die;
 422         int ret;
 423
 424         ret = dwarf_child(rt_die, die_mem);
 425         if (ret != 0)
 426                 return NULL;
 427
 428         do {
 429                 ret = callback(die_mem, data);
 430                 if (ret == DIE_FIND_CB_END)
 431                         return die_mem;
 432
 433                 if ((ret & DIE_FIND_CB_CHILD) &&
 434                     die_find_child(die_mem, callback, data, &child_die)) {
 435                         memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
 436                         return die_mem;
 437                 }
 438         } while ((ret & DIE_FIND_CB_SIBLING) &&
 439                  dwarf_siblingof(die_mem, die_mem) == 0);
 440
 441         return NULL;
 442 }
 443
 444 struct __addr_die_search_param {
 445         Dwarf_Addr      addr;
 446         Dwarf_Die       *die_mem;
 447 };
 448
 449 static int __die_search_func_tail_cb(Dwarf_Die *fn_die, void *data)
 450 {
 451         struct __addr_die_search_param *ad = data;
 452         Dwarf_Addr addr = 0;
 453
 454         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
 455             !dwarf_highpc(fn_die, &addr) &&
 456             addr == ad->addr) {
 457                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
 458                 return DWARF_CB_ABORT;
 459         }
 460         return DWARF_CB_OK;
 461 }
 462
 463 /**
 464  * die_find_tailfunc - Search for a non-inlined function with tail call at
 465  * given address
 466  * @cu_die: a CU DIE which including @addr
 467  * @addr: target address
 468  * @die_mem: a buffer for result DIE
 469  *
 470  * Search for a non-inlined function DIE with tail call at @addr. Stores the
 471  * DIE to @die_mem and returns it if found. Returns NULL if failed.
 472  */
 473 Dwarf_Die *die_find_tailfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
 474                                     Dwarf_Die *die_mem)
 475 {
 476         struct __addr_die_search_param ad;
 477         ad.addr = addr;
 478         ad.die_mem = die_mem;
 479         /* dwarf_getscopes can't find subprogram. */
 480         if (!dwarf_getfuncs(cu_die, __die_search_func_tail_cb, &ad, 0))
 481                 return NULL;
 482         else
 483                 return die_mem;
 484 }
 485
 486 /* die_find callback for non-inlined function search */
 487 static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
 488 {
 489         struct __addr_die_search_param *ad = data;
 490
 491         /*
 492          * Since a declaration entry doesn't has given pc, this always returns
 493          * function definition entry.
 494          */
 495         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
 496             dwarf_haspc(fn_die, ad->addr)) {
 497                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
 498                 return DWARF_CB_ABORT;
 499         }
 500         return DWARF_CB_OK;
 501 }
 502
 503 /**
 504  * die_find_realfunc - Search a non-inlined function at given address
 505  * @cu_die: a CU DIE which including @addr
 506  * @addr: target address
 507  * @die_mem: a buffer for result DIE
 508  *
 509  * Search a non-inlined function DIE which includes @addr. Stores the
 510  * DIE to @die_mem and returns it if found. Returns NULL if failed.
 511  */
 512 Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
 513                                     Dwarf_Die *die_mem)
 514 {
 515         struct __addr_die_search_param ad;
 516         ad.addr = addr;
 517         ad.die_mem = die_mem;
 518         /* dwarf_getscopes can't find subprogram. */
 519         if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
 520                 return NULL;
 521         else
 522                 return die_mem;
 523 }
 524
 525 /* die_find callback for inline function search */
 526 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
 527 {
 528         Dwarf_Addr *addr = data;
 529
 530         if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
 531             dwarf_haspc(die_mem, *addr))
 532                 return DIE_FIND_CB_END;
 533
 534         return DIE_FIND_CB_CONTINUE;
 535 }
 536
 537 /**
 538  * die_find_top_inlinefunc - Search the top inlined function at given address
 539  * @sp_die: a subprogram DIE which including @addr
 540  * @addr: target address
 541  * @die_mem: a buffer for result DIE
 542  *
 543  * Search an inlined function DIE which includes @addr. Stores the
 544  * DIE to @die_mem and returns it if found. Returns NULL if failed.
 545  * Even if several inlined functions are expanded recursively, this
 546  * doesn't trace it down, and returns the topmost one.
 547  */
 548 Dwarf_Die *die_find_top_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
 549                                    Dwarf_Die *die_mem)
 550 {
 551         return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
 552 }
 553
 554 /**
 555  * die_find_inlinefunc - Search an inlined function at given address
 556  * @sp_die: a subprogram DIE which including @addr
 557  * @addr: target address
 558  * @die_mem: a buffer for result DIE
 559  *
 560  * Search an inlined function DIE which includes @addr. Stores the
 561  * DIE to @die_mem and returns it if found. Returns NULL if failed.
 562  * If several inlined functions are expanded recursively, this trace
 563  * it down and returns deepest one.
 564  */
 565 Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
 566                                Dwarf_Die *die_mem)
 567 {
 568         Dwarf_Die tmp_die;
 569
 570         sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr, &tmp_die);
 571         if (!sp_die)
 572                 return NULL;
 573
 574         /* Inlined function could be recursive. Trace it until fail */
 575         while (sp_die) {
 576                 memcpy(die_mem, sp_die, sizeof(Dwarf_Die));
 577                 sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr,
 578                                         &tmp_die);
 579         }
 580
 581         return die_mem;
 582 }
 583
 584 struct __instance_walk_param {
 585         void    *addr;
 586         int     (*callback)(Dwarf_Die *, void *);
 587         void    *data;
 588         int     retval;
 589 };
 590
 591 static int __die_walk_instances_cb(Dwarf_Die *inst, void *data)
 592 {
 593         struct __instance_walk_param *iwp = data;
 594         Dwarf_Attribute attr_mem;
 595         Dwarf_Die origin_mem;
 596         Dwarf_Attribute *attr;
 597         Dwarf_Die *origin;
 598         int tmp;
 599
 600         attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem);
 601         if (attr == NULL)
 602                 return DIE_FIND_CB_CONTINUE;
 603
 604         origin = dwarf_formref_die(attr, &origin_mem);
 605         if (origin == NULL || origin->addr != iwp->addr)
 606                 return DIE_FIND_CB_CONTINUE;
 607
 608         /* Ignore redundant instances */
 609         if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) {
 610                 dwarf_decl_line(origin, &tmp);
 611                 if (die_get_call_lineno(inst) == tmp) {
 612                         tmp = die_get_decl_fileno(origin);
 613                         if (die_get_call_fileno(inst) == tmp)
 614                                 return DIE_FIND_CB_CONTINUE;
 615                 }
 616         }
 617
 618         iwp->retval = iwp->callback(inst, iwp->data);
 619
 620         return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE;
 621 }
 622
 623 /**
 624  * die_walk_instances - Walk on instances of given DIE
 625  * @or_die: an abstract original DIE
 626  * @callback: a callback function which is called with instance DIE
 627  * @data: user data
 628  *
 629  * Walk on the instances of give @in_die. @in_die must be an inlined function
 630  * declartion. This returns the return value of @callback if it returns
 631  * non-zero value, or -ENOENT if there is no instance.
 632  */
 633 int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
 634                        void *data)
 635 {
 636         Dwarf_Die cu_die;
 637         Dwarf_Die die_mem;
 638         struct __instance_walk_param iwp = {
 639                 .addr = or_die->addr,
 640                 .callback = callback,
 641                 .data = data,
 642                 .retval = -ENOENT,
 643         };
 644
 645         if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
 646                 return -ENOENT;
 647
 648         die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
 649
 650         return iwp.retval;
 651 }
 652
 653 /* Line walker internal parameters */
 654 struct __line_walk_param {
 655         bool recursive;
 656         line_walk_callback_t callback;
 657         void *data;
 658         int retval;
 659 };
 660
 661 static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
 662 {
 663         struct __line_walk_param *lw = data;
 664         Dwarf_Addr addr = 0;
 665         const char *fname;
 666         int lineno;
 667
 668         if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
 669                 fname = die_get_call_file(in_die);
 670                 lineno = die_get_call_lineno(in_die);
 671                 if (fname && lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
 672                         lw->retval = lw->callback(fname, lineno, addr, lw->data);
 673                         if (lw->retval != 0)
 674                                 return DIE_FIND_CB_END;
 675                 }
 676         }
 677         if (!lw->recursive)
 678                 /* Don't need to search recursively */
 679                 return DIE_FIND_CB_SIBLING;
 680
 681         if (addr) {
 682                 fname = dwarf_decl_file(in_die);
 683                 if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
 684                         lw->retval = lw->callback(fname, lineno, addr, lw->data);
 685                         if (lw->retval != 0)
 686                                 return DIE_FIND_CB_END;
 687                 }
 688         }
 689
 690         /* Continue to search nested inlined function call-sites */
 691         return DIE_FIND_CB_CONTINUE;
 692 }
 693
 694 /* Walk on lines of blocks included in given DIE */
 695 static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
 696                                 line_walk_callback_t callback, void *data)
 697 {
 698         struct __line_walk_param lw = {
 699                 .recursive = recursive,
 700                 .callback = callback,
 701                 .data = data,
 702                 .retval = 0,
 703         };
 704         Dwarf_Die die_mem;
 705         Dwarf_Addr addr;
 706         const char *fname;
 707         int lineno;
 708
 709         /* Handle function declaration line */
 710         fname = dwarf_decl_file(sp_die);
 711         if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
 712             dwarf_entrypc(sp_die, &addr) == 0) {
 713                 lw.retval = callback(fname, lineno, addr, data);
 714                 if (lw.retval != 0)
 715                         goto done;
 716         }
 717         die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
 718 done:
 719         return lw.retval;
 720 }
 721
 722 static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
 723 {
 724         struct __line_walk_param *lw = data;
 725
 726         lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
 727         if (lw->retval != 0)
 728                 return DWARF_CB_ABORT;
 729
 730         return DWARF_CB_OK;
 731 }
 732
 733 /**
 734  * die_walk_lines - Walk on lines inside given DIE
 735  * @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
 736  * @callback: callback routine
 737  * @data: user data
 738  *
 739  * Walk on all lines inside given @rt_die and call @callback on each line.
 740  * If the @rt_die is a function, walk only on the lines inside the function,
 741  * otherwise @rt_die must be a CU DIE.
 742  * Note that this walks not only dwarf line list, but also function entries
 743  * and inline call-site.
 744  */
 745 int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
 746 {
 747         Dwarf_Lines *lines;
 748         Dwarf_Line *line;
 749         Dwarf_Addr addr;
 750         const char *fname, *decf = NULL;
 751         int lineno, ret = 0;
 752         int decl = 0, inl;
 753         Dwarf_Die die_mem, *cu_die;
 754         size_t nlines, i;
 755
 756         /* Get the CU die */
 757         if (dwarf_tag(rt_die) != DW_TAG_compile_unit) {
 758                 cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
 759                 dwarf_decl_line(rt_die, &decl);
 760                 decf = dwarf_decl_file(rt_die);
 761         } else
 762                 cu_die = rt_die;
 763         if (!cu_die) {
 764                 pr_debug2("Failed to get CU from given DIE.\n");
 765                 return -EINVAL;
 766         }
 767
 768         /* Get lines list in the CU */
 769         if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
 770                 pr_debug2("Failed to get source lines on this CU.\n");
 771                 return -ENOENT;
 772         }
 773         pr_debug2("Get %zd lines from this CU\n", nlines);
 774
 775         /* Walk on the lines on lines list */
 776         for (i = 0; i < nlines; i++) {
 777                 line = dwarf_onesrcline(lines, i);
 778                 if (line == NULL ||
 779                     dwarf_lineno(line, &lineno) != 0 ||
 780                     dwarf_lineaddr(line, &addr) != 0) {
 781                         pr_debug2("Failed to get line info. "
 782                                   "Possible error in debuginfo.\n");
 783                         continue;
 784                 }
 785                 /* Filter lines based on address */
 786                 if (rt_die != cu_die) {
 787                         /*
 788                          * Address filtering
 789                          * The line is included in given function, and
 790                          * no inline block includes it.
 791                          */
 792                         if (!dwarf_haspc(rt_die, addr))
 793                                 continue;
 794                         if (die_find_inlinefunc(rt_die, addr, &die_mem)) {
 795                                 dwarf_decl_line(&die_mem, &inl);
 796                                 if (inl != decl ||
 797                                     decf != dwarf_decl_file(&die_mem))
 798                                         continue;
 799                         }
 800                 }
 801                 /* Get source line */
 802                 fname = dwarf_linesrc(line, NULL, NULL);
 803
 804                 ret = callback(fname, lineno, addr, data);
 805                 if (ret != 0)
 806                         return ret;
 807         }
 808
 809         /*
 810          * Dwarf lines doesn't include function declarations and inlined
 811          * subroutines. We have to check functions list or given function.
 812          */
 813         if (rt_die != cu_die)
 814                 /*
 815                  * Don't need walk functions recursively, because nested
 816                  * inlined functions don't have lines of the specified DIE.
 817                  */
 818                 ret = __die_walk_funclines(rt_die, false, callback, data);
 819         else {
 820                 struct __line_walk_param param = {
 821                         .callback = callback,
 822                         .data = data,
 823                         .retval = 0,
 824                 };
 825                 dwarf_getfuncs(cu_die, __die_walk_culines_cb, &param, 0);
 826                 ret = param.retval;
 827         }
 828
 829         return ret;
 830 }
 831
 832 struct __find_variable_param {
 833         const char *name;
 834         Dwarf_Addr addr;
 835 };
 836
 837 static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
 838 {
 839         struct __find_variable_param *fvp = data;
 840         Dwarf_Attribute attr;
 841         int tag;
 842
 843         tag = dwarf_tag(die_mem);
 844         if ((tag == DW_TAG_formal_parameter ||
 845              tag == DW_TAG_variable) &&
 846             die_compare_name(die_mem, fvp->name) &&
 847         /* Does the DIE have location information or external instance? */
 848             (dwarf_attr(die_mem, DW_AT_external, &attr) ||
 849              dwarf_attr(die_mem, DW_AT_location, &attr)))
 850                 return DIE_FIND_CB_END;
 851         if (dwarf_haspc(die_mem, fvp->addr))
 852                 return DIE_FIND_CB_CONTINUE;
 853         else
 854                 return DIE_FIND_CB_SIBLING;
 855 }
 856
 857 /**
 858  * die_find_variable_at - Find a given name variable at given address
 859  * @sp_die: a function DIE
 860  * @name: variable name
 861  * @addr: address
 862  * @die_mem: a buffer for result DIE
 863  *
 864  * Find a variable DIE called @name at @addr in @sp_die.
 865  */
 866 Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
 867                                 Dwarf_Addr addr, Dwarf_Die *die_mem)
 868 {
 869         struct __find_variable_param fvp = { .name = name, .addr = addr};
 870
 871         return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
 872                               die_mem);
 873 }
 874
 875 static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
 876 {
 877         const char *name = data;
 878
 879         if (dwarf_tag(die_mem) == DW_TAG_member) {
 880                 if (die_compare_name(die_mem, name))
 881                         return DIE_FIND_CB_END;
 882                 else if (!dwarf_diename(die_mem)) {     /* Unnamed structure */
 883                         Dwarf_Die type_die, tmp_die;
 884                         if (die_get_type(die_mem, &type_die) &&
 885                             die_find_member(&type_die, name, &tmp_die))
 886                                 return DIE_FIND_CB_END;
 887                 }
 888         }
 889         return DIE_FIND_CB_SIBLING;
 890 }
 891
 892 /**
 893  * die_find_member - Find a given name member in a data structure
 894  * @st_die: a data structure type DIE
 895  * @name: member name
 896  * @die_mem: a buffer for result DIE
 897  *
 898  * Find a member DIE called @name in @st_die.
 899  */
 900 Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
 901                            Dwarf_Die *die_mem)
 902 {
 903         return die_find_child(st_die, __die_find_member_cb, (void *)name,
 904                               die_mem);
 905 }
 906
 907 /**
 908  * die_get_typename - Get the name of given variable DIE
 909  * @vr_die: a variable DIE
 910  * @buf: a strbuf for result type name
 911  *
 912  * Get the name of @vr_die and stores it to @buf. Return 0 if succeeded.
 913  * and Return -ENOENT if failed to find type name.
 914  * Note that the result will stores typedef name if possible, and stores
 915  * "*(function_type)" if the type is a function pointer.
 916  */
 917 int die_get_typename(Dwarf_Die *vr_die, struct strbuf *buf)
 918 {
 919         Dwarf_Die type;
 920         int tag, ret;
 921         const char *tmp = "";
 922
 923         if (__die_get_real_type(vr_die, &type) == NULL)
 924                 return -ENOENT;
 925
 926         tag = dwarf_tag(&type);
 927         if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
 928                 tmp = "*";
 929         else if (tag == DW_TAG_subroutine_type) {
 930                 /* Function pointer */
 931                 return strbuf_add(buf, "(function_type)", 15);
 932         } else {
 933                 if (!dwarf_diename(&type))
 934                         return -ENOENT;
 935                 if (tag == DW_TAG_union_type)
 936                         tmp = "union ";
 937                 else if (tag == DW_TAG_structure_type)
 938                         tmp = "struct ";
 939                 else if (tag == DW_TAG_enumeration_type)
 940                         tmp = "enum ";
 941                 /* Write a base name */
 942                 return strbuf_addf(buf, "%s%s", tmp, dwarf_diename(&type));
 943         }
 944         ret = die_get_typename(&type, buf);
 945         return ret ? ret : strbuf_addstr(buf, tmp);
 946 }
 947
 948 /**
 949  * die_get_varname - Get the name and type of given variable DIE
 950  * @vr_die: a variable DIE
 951  * @buf: a strbuf for type and variable name
 952  *
 953  * Get the name and type of @vr_die and stores it in @buf as "type\tname".
 954  */
 955 int die_get_varname(Dwarf_Die *vr_die, struct strbuf *buf)
 956 {
 957         int ret;
 958
 959         ret = die_get_typename(vr_die, buf);
 960         if (ret < 0) {
 961                 pr_debug("Failed to get type, make it unknown.\n");
 962                 ret = strbuf_add(buf, " (unknown_type)", 14);
 963         }
 964
 965         return ret < 0 ? ret : strbuf_addf(buf, "\t%s", dwarf_diename(vr_die));
 966 }
 967
 968 #ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT
 969 /**
 970  * die_get_var_innermost_scope - Get innermost scope range of given variable DIE
 971  * @sp_die: a subprogram DIE
 972  * @vr_die: a variable DIE
 973  * @buf: a strbuf for variable byte offset range
 974  *
 975  * Get the innermost scope range of @vr_die and stores it in @buf as
 976  * "@<function_name+[NN-NN,NN-NN]>".
 977  */
 978 static int die_get_var_innermost_scope(Dwarf_Die *sp_die, Dwarf_Die *vr_die,
 979                                 struct strbuf *buf)
 980 {
 981         Dwarf_Die *scopes;
 982         int count;
 983         size_t offset = 0;
 984         Dwarf_Addr base;
 985         Dwarf_Addr start, end;
 986         Dwarf_Addr entry;
 987         int ret;
 988         bool first = true;
 989         const char *name;
 990
 991         ret = dwarf_entrypc(sp_die, &entry);
 992         if (ret)
 993                 return ret;
 994
 995         name = dwarf_diename(sp_die);
 996         if (!name)
 997                 return -ENOENT;
 998
 999         count = dwarf_getscopes_die(vr_die, &scopes);
1000
1001         /* (*SCOPES)[1] is the DIE for the scope containing that scope */
1002         if (count <= 1) {
1003                 ret = -EINVAL;
1004                 goto out;
1005         }
1006
1007         while ((offset = dwarf_ranges(&scopes[1], offset, &base,
1008                                         &start, &end)) > 0) {
1009                 start -= entry;
1010                 end -= entry;
1011
1012                 if (first) {
1013                         ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1014                                           name, start, end);
1015                         first = false;
1016                 } else {
1017                         ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1018                                           start, end);
1019                 }
1020                 if (ret < 0)
1021                         goto out;
1022         }
1023
1024         if (!first)
1025                 ret = strbuf_add(buf, "]>", 2);
1026
1027 out:
1028         free(scopes);
1029         return ret;
1030 }
1031
1032 /**
1033  * die_get_var_range - Get byte offset range of given variable DIE
1034  * @sp_die: a subprogram DIE
1035  * @vr_die: a variable DIE
1036  * @buf: a strbuf for type and variable name and byte offset range
1037  *
1038  * Get the byte offset range of @vr_die and stores it in @buf as
1039  * "@<function_name+[NN-NN,NN-NN]>".
1040  */
1041 int die_get_var_range(Dwarf_Die *sp_die, Dwarf_Die *vr_die, struct strbuf *buf)
1042 {
1043         int ret = 0;
1044         Dwarf_Addr base;
1045         Dwarf_Addr start, end;
1046         Dwarf_Addr entry;
1047         Dwarf_Op *op;
1048         size_t nops;
1049         size_t offset = 0;
1050         Dwarf_Attribute attr;
1051         bool first = true;
1052         const char *name;
1053
1054         ret = dwarf_entrypc(sp_die, &entry);
1055         if (ret)
1056                 return ret;
1057
1058         name = dwarf_diename(sp_die);
1059         if (!name)
1060                 return -ENOENT;
1061
1062         if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
1063                 return -EINVAL;
1064
1065         while ((offset = dwarf_getlocations(&attr, offset, &base,
1066                                         &start, &end, &op, &nops)) > 0) {
1067                 if (start == 0) {
1068                         /* Single Location Descriptions */
1069                         ret = die_get_var_innermost_scope(sp_die, vr_die, buf);
1070                         goto out;
1071                 }
1072
1073                 /* Location Lists */
1074                 start -= entry;
1075                 end -= entry;
1076                 if (first) {
1077                         ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1078                                           name, start, end);
1079                         first = false;
1080                 } else {
1081                         ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1082                                           start, end);
1083                 }
1084                 if (ret < 0)
1085                         goto out;
1086         }
1087
1088         if (!first)
1089                 ret = strbuf_add(buf, "]>", 2);
1090 out:
1091         return ret;
1092 }
1093 #else
1094 int die_get_var_range(Dwarf_Die *sp_die __maybe_unused,
1095                       Dwarf_Die *vr_die __maybe_unused,
1096                       struct strbuf *buf __maybe_unused)
1097 {
1098         return -ENOTSUP;
1099 }
1100 #endif
1101
1102 /*
1103  * die_has_loclist - Check if DW_AT_location of @vr_die is a location list
1104  * @vr_die: a variable DIE
1105  */
1106 static bool die_has_loclist(Dwarf_Die *vr_die)
1107 {
1108         Dwarf_Attribute loc;
1109         int tag = dwarf_tag(vr_die);
1110
1111         if (tag != DW_TAG_formal_parameter &&
1112             tag != DW_TAG_variable)
1113                 return false;
1114
1115         return (dwarf_attr_integrate(vr_die, DW_AT_location, &loc) &&
1116                 dwarf_whatform(&loc) == DW_FORM_sec_offset);
1117 }
1118
1119 /*
1120  * die_is_optimized_target - Check if target program is compiled with
1121  * optimization
1122  * @cu_die: a CU DIE
1123  *
1124  * For any object in given CU whose DW_AT_location is a location list,
1125  * target program is compiled with optimization. This is applicable to
1126  * clang as well.
1127  */
1128 bool die_is_optimized_target(Dwarf_Die *cu_die)
1129 {
1130         Dwarf_Die tmp_die;
1131
1132         if (die_has_loclist(cu_die))
1133                 return true;
1134
1135         if (!dwarf_child(cu_die, &tmp_die) &&
1136             die_is_optimized_target(&tmp_die))
1137                 return true;
1138
1139         if (!dwarf_siblingof(cu_die, &tmp_die) &&
1140             die_is_optimized_target(&tmp_die))
1141                 return true;
1142
1143         return false;
1144 }
1145
1146 /*
1147  * die_search_idx - Search index of given line address
1148  * @lines: Line records of single CU
1149  * @nr_lines: Number of @lines
1150  * @addr: address we are looking for
1151  * @idx: index to be set by this function (return value)
1152  *
1153  * Search for @addr by looping over every lines of CU. If address
1154  * matches, set index of that line in @idx. Note that single source
1155  * line can have multiple line records. i.e. single source line can
1156  * have multiple index.
1157  */
1158 static bool die_search_idx(Dwarf_Lines *lines, unsigned long nr_lines,
1159                            Dwarf_Addr addr, unsigned long *idx)
1160 {
1161         unsigned long i;
1162         Dwarf_Addr tmp;
1163
1164         for (i = 0; i < nr_lines; i++) {
1165                 if (dwarf_lineaddr(dwarf_onesrcline(lines, i), &tmp))
1166                         return false;
1167
1168                 if (tmp == addr) {
1169                         *idx = i;
1170                         return true;
1171                 }
1172         }
1173         return false;
1174 }
1175
1176 /*
1177  * die_get_postprologue_addr - Search next address after function prologue
1178  * @entrypc_idx: entrypc index
1179  * @lines: Line records of single CU
1180  * @nr_lines: Number of @lines
1181  * @hignpc: high PC address of function
1182  * @postprologue_addr: Next address after function prologue (return value)
1183  *
1184  * Look for prologue-end marker. If there is no explicit marker, return
1185  * address of next line record or next source line.
1186  */
1187 static bool die_get_postprologue_addr(unsigned long entrypc_idx,
1188                                       Dwarf_Lines *lines,
1189                                       unsigned long nr_lines,
1190                                       Dwarf_Addr highpc,
1191                                       Dwarf_Addr *postprologue_addr)
1192 {
1193         unsigned long i;
1194         int entrypc_lno, lno;
1195         Dwarf_Line *line;
1196         Dwarf_Addr addr;
1197         bool p_end;
1198
1199         /* entrypc_lno is actual source line number */
1200         line = dwarf_onesrcline(lines, entrypc_idx);
1201         if (dwarf_lineno(line, &entrypc_lno))
1202                 return false;
1203
1204         for (i = entrypc_idx; i < nr_lines; i++) {
1205                 line = dwarf_onesrcline(lines, i);
1206
1207                 if (dwarf_lineaddr(line, &addr) ||
1208                     dwarf_lineno(line, &lno)    ||
1209                     dwarf_lineprologueend(line, &p_end))
1210                         return false;
1211
1212                 /* highpc is exclusive. [entrypc,highpc) */
1213                 if (addr >= highpc)
1214                         break;
1215
1216                 /* clang supports prologue-end marker */
1217                 if (p_end)
1218                         break;
1219
1220                 /* Actual next line in source */
1221                 if (lno != entrypc_lno)
1222                         break;
1223
1224                 /*
1225                  * Single source line can have multiple line records.
1226                  * For Example,
1227                  *     void foo() { printf("hello\n"); }
1228                  * contains two line records. One points to declaration and
1229                  * other points to printf() line. Variable 'lno' won't get
1230                  * incremented in this case but 'i' will.
1231                  */
1232                 if (i != entrypc_idx)
1233                         break;
1234         }
1235
1236         dwarf_lineaddr(line, postprologue_addr);
1237         if (*postprologue_addr >= highpc)
1238                 dwarf_lineaddr(dwarf_onesrcline(lines, i - 1),
1239                                postprologue_addr);
1240
1241         return true;
1242 }
1243
1244 /*
1245  * die_skip_prologue - Use next address after prologue as probe location
1246  * @sp_die: a subprogram DIE
1247  * @cu_die: a CU DIE
1248  * @entrypc: entrypc of the function
1249  *
1250  * Function prologue prepares stack and registers before executing function
1251  * logic. When target program is compiled without optimization, function
1252  * parameter information is only valid after prologue. When we probe entrypc
1253  * of the function, and try to record function parameter, it contains
1254  * garbage value.
1255  */
1256 void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die,
1257                        Dwarf_Addr *entrypc)
1258 {
1259         size_t nr_lines = 0;
1260         unsigned long entrypc_idx = 0;
1261         Dwarf_Lines *lines = NULL;
1262         Dwarf_Addr postprologue_addr;
1263         Dwarf_Addr highpc;
1264
1265         if (dwarf_highpc(sp_die, &highpc))
1266                 return;
1267
1268         if (dwarf_getsrclines(cu_die, &lines, &nr_lines))
1269                 return;
1270
1271         if (!die_search_idx(lines, nr_lines, *entrypc, &entrypc_idx))
1272                 return;
1273
1274         if (!die_get_postprologue_addr(entrypc_idx, lines, nr_lines,
1275                                        highpc, &postprologue_addr))
1276                 return;
1277
1278         *entrypc = postprologue_addr;
1279 }