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 "dwarf-regs.h"
  13#include "strbuf.h"
  14#include "string2.h"
  15
  16/**
  17 * cu_find_realpath - Find the realpath of the target file
  18 * @cu_die: A DIE(dwarf information entry) of CU(compilation Unit)
  19 * @fname:  The tail filename of the target file
  20 *
  21 * Find the real(long) path of @fname in @cu_die.
  22 */
  23const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
  24{
  25	Dwarf_Files *files;
  26	size_t nfiles, i;
  27	const char *src = NULL;
  28	int ret;
  29
  30	if (!fname)
  31		return NULL;
  32
  33	ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
  34	if (ret != 0)
  35		return NULL;
  36
  37	for (i = 0; i < nfiles; i++) {
  38		src = dwarf_filesrc(files, i, NULL, NULL);
  39		if (strtailcmp(src, fname) == 0)
  40			break;
  41	}
  42	if (i == nfiles)
  43		return NULL;
  44	return src;
  45}
  46
  47/**
  48 * cu_get_comp_dir - Get the path of compilation directory
  49 * @cu_die: a CU DIE
  50 *
  51 * Get the path of compilation directory of given @cu_die.
  52 * Since this depends on DW_AT_comp_dir, older gcc will not
  53 * embedded it. In that case, this returns NULL.
  54 */
  55const char *cu_get_comp_dir(Dwarf_Die *cu_die)
  56{
  57	Dwarf_Attribute attr;
  58	if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
  59		return NULL;
  60	return dwarf_formstring(&attr);
  61}
  62
  63/* Unlike dwarf_getsrc_die(), cu_getsrc_die() only returns statement line */
  64static Dwarf_Line *cu_getsrc_die(Dwarf_Die *cu_die, Dwarf_Addr addr)
  65{
  66	Dwarf_Addr laddr;
  67	Dwarf_Lines *lines;
  68	Dwarf_Line *line;
  69	size_t nlines, l, u, n;
  70	bool flag;
  71
  72	if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0 ||
  73	    nlines == 0)
  74		return NULL;
  75
  76	/* Lines are sorted by address, use binary search */
  77	l = 0; u = nlines - 1;
  78	while (l < u) {
  79		n = u - (u - l) / 2;
  80		line = dwarf_onesrcline(lines, n);
  81		if (!line || dwarf_lineaddr(line, &laddr) != 0)
  82			return NULL;
  83		if (addr < laddr)
  84			u = n - 1;
  85		else
  86			l = n;
  87	}
  88	/* Going backward to find the lowest line */
  89	do {
  90		line = dwarf_onesrcline(lines, --l);
  91		if (!line || dwarf_lineaddr(line, &laddr) != 0)
  92			return NULL;
  93	} while (laddr == addr);
  94	l++;
  95	/* Going forward to find the statement line */
  96	do {
  97		line = dwarf_onesrcline(lines, l++);
  98		if (!line || dwarf_lineaddr(line, &laddr) != 0 ||
  99		    dwarf_linebeginstatement(line, &flag) != 0)
 100			return NULL;
 101		if (laddr > addr)
 102			return NULL;
 103	} while (!flag);
 104
 105	return line;
 106}
 107
 108/**
 109 * cu_find_lineinfo - Get a line number and file name for given address
 110 * @cu_die: a CU DIE
 111 * @addr: An address
 112 * @fname: a pointer which returns the file name string
 113 * @lineno: a pointer which returns the line number
 114 *
 115 * Find a line number and file name for @addr in @cu_die.
 116 */
 117int cu_find_lineinfo(Dwarf_Die *cu_die, Dwarf_Addr addr,
 118		     const char **fname, int *lineno)
 119{
 120	Dwarf_Line *line;
 121	Dwarf_Die die_mem;
 122	Dwarf_Addr faddr;
 123
 124	if (die_find_realfunc(cu_die, addr, &die_mem)
 125	    && die_entrypc(&die_mem, &faddr) == 0 &&
 126	    faddr == addr) {
 127		*fname = die_get_decl_file(&die_mem);
 128		dwarf_decl_line(&die_mem, lineno);
 129		goto out;
 130	}
 131
 132	line = cu_getsrc_die(cu_die, addr);
 133	if (line && dwarf_lineno(line, lineno) == 0) {
 134		*fname = dwarf_linesrc(line, NULL, NULL);
 135		if (!*fname)
 136			/* line number is useless without filename */
 137			*lineno = 0;
 138	}
 139
 140out:
 141	return (*lineno && *fname) ? *lineno : -ENOENT;
 142}
 143
 144static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
 145
 146/**
 147 * cu_walk_functions_at - Walk on function DIEs at given address
 148 * @cu_die: A CU DIE
 149 * @addr: An address
 150 * @callback: A callback which called with found DIEs
 151 * @data: A user data
 152 *
 153 * Walk on function DIEs at given @addr in @cu_die. Passed DIEs
 154 * should be subprogram or inlined-subroutines.
 155 */
 156int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
 157		    int (*callback)(Dwarf_Die *, void *), void *data)
 158{
 159	Dwarf_Die die_mem;
 160	Dwarf_Die *sc_die;
 161	int ret = -ENOENT;
 162
 163	/* Inlined function could be recursive. Trace it until fail */
 164	for (sc_die = die_find_realfunc(cu_die, addr, &die_mem);
 165	     sc_die != NULL;
 166	     sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr,
 167				     &die_mem)) {
 168		ret = callback(sc_die, data);
 169		if (ret)
 170			break;
 171	}
 172
 173	return ret;
 174
 175}
 176
 177/**
 178 * die_get_linkage_name - Get the linkage name of the object
 179 * @dw_die: A DIE of the object
 180 *
 181 * Get the linkage name attribute of given @dw_die.
 182 * For C++ binary, the linkage name will be the mangled symbol.
 183 */
 184const char *die_get_linkage_name(Dwarf_Die *dw_die)
 185{
 186	Dwarf_Attribute attr;
 187
 188	if (dwarf_attr_integrate(dw_die, DW_AT_linkage_name, &attr) == NULL)
 189		return NULL;
 190	return dwarf_formstring(&attr);
 191}
 192
 193/**
 194 * die_compare_name - Compare diename and tname
 195 * @dw_die: a DIE
 196 * @tname: a string of target name
 197 *
 198 * Compare the name of @dw_die and @tname. Return false if @dw_die has no name.
 199 */
 200bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
 201{
 202	const char *name;
 203
 204	name = dwarf_diename(dw_die);
 205	return name ? (strcmp(tname, name) == 0) : false;
 206}
 207
 208/**
 209 * die_match_name - Match diename/linkage name and glob
 210 * @dw_die: a DIE
 211 * @glob: a string of target glob pattern
 212 *
 213 * Glob matching the name of @dw_die and @glob. Return false if matching fail.
 214 * This also match linkage name.
 215 */
 216bool die_match_name(Dwarf_Die *dw_die, const char *glob)
 217{
 218	const char *name;
 219
 220	name = dwarf_diename(dw_die);
 221	if (name && strglobmatch(name, glob))
 222		return true;
 223	/* fall back to check linkage name */
 224	name = die_get_linkage_name(dw_die);
 225	if (name && strglobmatch(name, glob))
 226		return true;
 227
 228	return false;
 229}
 230
 231/**
 232 * die_get_call_lineno - Get callsite line number of inline-function instance
 233 * @in_die: a DIE of an inlined function instance
 234 *
 235 * Get call-site line number of @in_die. This means from where the inline
 236 * function is called.
 237 */
 238int die_get_call_lineno(Dwarf_Die *in_die)
 239{
 240	Dwarf_Attribute attr;
 241	Dwarf_Word ret;
 242
 243	if (!dwarf_attr(in_die, DW_AT_call_line, &attr))
 244		return -ENOENT;
 245
 246	dwarf_formudata(&attr, &ret);
 247	return (int)ret;
 248}
 249
 250/**
 251 * die_get_type - Get type DIE
 252 * @vr_die: a DIE of a variable
 253 * @die_mem: where to store a type DIE
 254 *
 255 * Get a DIE of the type of given variable (@vr_die), and store
 256 * it to die_mem. Return NULL if fails to get a type DIE.
 257 */
 258Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 259{
 260	Dwarf_Attribute attr;
 261
 262	if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
 263	    dwarf_formref_die(&attr, die_mem))
 264		return die_mem;
 265	else
 266		return NULL;
 267}
 268
 269/* Get a type die, but skip qualifiers */
 270Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 271{
 272	int tag;
 273
 274	do {
 275		vr_die = die_get_type(vr_die, die_mem);
 276		if (!vr_die)
 277			break;
 278		tag = dwarf_tag(vr_die);
 279	} while (tag == DW_TAG_const_type ||
 280		 tag == DW_TAG_restrict_type ||
 281		 tag == DW_TAG_volatile_type ||
 282		 tag == DW_TAG_shared_type);
 283
 284	return vr_die;
 285}
 286
 287/**
 288 * die_get_real_type - Get a type die, but skip qualifiers and typedef
 289 * @vr_die: a DIE of a variable
 290 * @die_mem: where to store a type DIE
 291 *
 292 * Get a DIE of the type of given variable (@vr_die), and store
 293 * it to die_mem. Return NULL if fails to get a type DIE.
 294 * If the type is qualifiers (e.g. const) or typedef, this skips it
 295 * and tries to find real type (structure or basic types, e.g. int).
 296 */
 297Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 298{
 299	do {
 300		vr_die = __die_get_real_type(vr_die, die_mem);
 301	} while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef);
 302
 303	return vr_die;
 304}
 305
 306/* Get attribute and translate it as a udata */
 307static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
 308			      Dwarf_Word *result)
 309{
 310	Dwarf_Attribute attr;
 311
 312	if (dwarf_attr_integrate(tp_die, attr_name, &attr) == NULL ||
 313	    dwarf_formudata(&attr, result) != 0)
 314		return -ENOENT;
 315
 316	return 0;
 317}
 318
 
 
 
 
 
 
 
 
 
 
 
 
 
 319/**
 320 * die_is_signed_type - Check whether a type DIE is signed or not
 321 * @tp_die: a DIE of a type
 322 *
 323 * Get the encoding of @tp_die and return true if the encoding
 324 * is signed.
 325 */
 326bool die_is_signed_type(Dwarf_Die *tp_die)
 327{
 328	Dwarf_Word ret;
 329
 330	if (die_get_attr_udata(tp_die, DW_AT_encoding, &ret))
 331		return false;
 332
 333	return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
 334		ret == DW_ATE_signed_fixed);
 335}
 336
 337/**
 338 * die_is_func_def - Ensure that this DIE is a subprogram and definition
 339 * @dw_die: a DIE
 340 *
 341 * Ensure that this DIE is a subprogram and NOT a declaration. This
 342 * returns true if @dw_die is a function definition.
 343 **/
 344bool die_is_func_def(Dwarf_Die *dw_die)
 345{
 346	Dwarf_Attribute attr;
 347	Dwarf_Addr addr = 0;
 348
 349	if (dwarf_tag(dw_die) != DW_TAG_subprogram)
 350		return false;
 351
 352	if (dwarf_attr(dw_die, DW_AT_declaration, &attr))
 353		return false;
 354
 355	/*
 356	 * DW_AT_declaration can be lost from function declaration
 357	 * by gcc's bug #97060.
 358	 * So we need to check this subprogram DIE has DW_AT_inline
 359	 * or an entry address.
 360	 */
 361	if (!dwarf_attr(dw_die, DW_AT_inline, &attr) &&
 362	    die_entrypc(dw_die, &addr) < 0)
 363		return false;
 364
 365	return true;
 366}
 367
 368/**
 369 * die_entrypc - Returns entry PC (the lowest address) of a DIE
 370 * @dw_die: a DIE
 371 * @addr: where to store entry PC
 372 *
 373 * Since dwarf_entrypc() does not return entry PC if the DIE has only address
 374 * range, we have to use this to retrieve the lowest address from the address
 375 * range attribute.
 376 */
 377int die_entrypc(Dwarf_Die *dw_die, Dwarf_Addr *addr)
 378{
 379	Dwarf_Addr base, end;
 380	Dwarf_Attribute attr;
 381
 382	if (!addr)
 383		return -EINVAL;
 384
 385	if (dwarf_entrypc(dw_die, addr) == 0)
 386		return 0;
 387
 388	/*
 389	 *  Since the dwarf_ranges() will return 0 if there is no
 390	 * DW_AT_ranges attribute, we should check it first.
 391	 */
 392	if (!dwarf_attr(dw_die, DW_AT_ranges, &attr))
 393		return -ENOENT;
 394
 395	return dwarf_ranges(dw_die, 0, &base, addr, &end) < 0 ? -ENOENT : 0;
 396}
 397
 398/**
 399 * die_is_func_instance - Ensure that this DIE is an instance of a subprogram
 400 * @dw_die: a DIE
 401 *
 402 * Ensure that this DIE is an instance (which has an entry address).
 403 * This returns true if @dw_die is a function instance. If not, the @dw_die
 404 * must be a prototype. You can use die_walk_instances() to find actual
 405 * instances.
 406 **/
 407bool die_is_func_instance(Dwarf_Die *dw_die)
 408{
 409	Dwarf_Addr tmp;
 410	Dwarf_Attribute attr_mem;
 411	int tag = dwarf_tag(dw_die);
 412
 413	if (tag != DW_TAG_subprogram &&
 414	    tag != DW_TAG_inlined_subroutine)
 415		return false;
 416
 417	return dwarf_entrypc(dw_die, &tmp) == 0 ||
 418		dwarf_attr(dw_die, DW_AT_ranges, &attr_mem) != NULL;
 419}
 420
 421/**
 422 * die_get_data_member_location - Get the data-member offset
 423 * @mb_die: a DIE of a member of a data structure
 424 * @offs: The offset of the member in the data structure
 425 *
 426 * Get the offset of @mb_die in the data structure including @mb_die, and
 427 * stores result offset to @offs. If any error occurs this returns errno.
 428 */
 429int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
 430{
 431	Dwarf_Attribute attr;
 432	Dwarf_Op *expr;
 433	size_t nexpr;
 434	int ret;
 435
 436	if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
 437		return -ENOENT;
 438
 439	if (dwarf_formudata(&attr, offs) != 0) {
 440		/* DW_AT_data_member_location should be DW_OP_plus_uconst */
 441		ret = dwarf_getlocation(&attr, &expr, &nexpr);
 442		if (ret < 0 || nexpr == 0)
 443			return -ENOENT;
 444
 445		if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
 446			pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
 447				 expr[0].atom, nexpr);
 448			return -ENOTSUP;
 449		}
 450		*offs = (Dwarf_Word)expr[0].number;
 451	}
 452	return 0;
 453}
 454
 455/* Get the call file index number in CU DIE */
 456static int die_get_call_fileno(Dwarf_Die *in_die)
 457{
 458	Dwarf_Word idx;
 459
 460	if (die_get_attr_udata(in_die, DW_AT_call_file, &idx) == 0)
 461		return (int)idx;
 462	else
 463		return -ENOENT;
 464}
 465
 466/* Get the declared file index number in CU DIE */
 467static int die_get_decl_fileno(Dwarf_Die *pdie)
 468{
 469	Dwarf_Word idx;
 470
 471	if (die_get_attr_udata(pdie, DW_AT_decl_file, &idx) == 0)
 472		return (int)idx;
 473	else
 474		return -ENOENT;
 475}
 476
 477/* Return the file name by index */
 478static const char *die_get_file_name(Dwarf_Die *dw_die, int idx)
 479{
 480	Dwarf_Die cu_die;
 481	Dwarf_Files *files;
 482	Dwarf_Attribute attr_mem;
 483
 484	if (idx < 0 || !dwarf_attr_integrate(dw_die, DW_AT_decl_file, &attr_mem) ||
 485	    !dwarf_cu_die(attr_mem.cu, &cu_die, NULL, NULL, NULL, NULL, NULL, NULL) ||
 486	    dwarf_getsrcfiles(&cu_die, &files, NULL) != 0)
 487		return NULL;
 488
 489	return dwarf_filesrc(files, idx, NULL, NULL);
 490}
 491
 492/**
 493 * die_get_call_file - Get callsite file name of inlined function instance
 494 * @in_die: a DIE of an inlined function instance
 495 *
 496 * Get call-site file name of @in_die. This means from which file the inline
 497 * function is called.
 498 */
 499const char *die_get_call_file(Dwarf_Die *in_die)
 500{
 501	return die_get_file_name(in_die, die_get_call_fileno(in_die));
 502}
 
 503
 504/**
 505 * die_get_decl_file - Find the declared file name of this DIE
 506 * @dw_die: a DIE for something declared.
 507 *
 508 * Get declared file name of @dw_die.
 509 * NOTE: Since some version of clang DWARF5 implementation incorrectly uses
 510 * file index 0 for DW_AT_decl_file, die_get_decl_file() will return NULL for
 511 * such cases. Use this function instead.
 512 */
 513const char *die_get_decl_file(Dwarf_Die *dw_die)
 514{
 515	return die_get_file_name(dw_die, die_get_decl_fileno(dw_die));
 516}
 517
 
 518/**
 519 * die_find_child - Generic DIE search function in DIE tree
 520 * @rt_die: a root DIE
 521 * @callback: a callback function
 522 * @data: a user data passed to the callback function
 523 * @die_mem: a buffer for result DIE
 524 *
 525 * Trace DIE tree from @rt_die and call @callback for each child DIE.
 526 * If @callback returns DIE_FIND_CB_END, this stores the DIE into
 527 * @die_mem and returns it. If @callback returns DIE_FIND_CB_CONTINUE,
 528 * this continues to trace the tree. Optionally, @callback can return
 529 * DIE_FIND_CB_CHILD and DIE_FIND_CB_SIBLING, those means trace only
 530 * the children and trace only the siblings respectively.
 531 * Returns NULL if @callback can't find any appropriate DIE.
 532 */
 533Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
 534			  int (*callback)(Dwarf_Die *, void *),
 535			  void *data, Dwarf_Die *die_mem)
 536{
 537	Dwarf_Die child_die;
 538	int ret;
 539
 540	ret = dwarf_child(rt_die, die_mem);
 541	if (ret != 0)
 542		return NULL;
 543
 544	do {
 545		ret = callback(die_mem, data);
 546		if (ret == DIE_FIND_CB_END)
 547			return die_mem;
 548
 549		if ((ret & DIE_FIND_CB_CHILD) &&
 550		    die_find_child(die_mem, callback, data, &child_die)) {
 551			memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
 552			return die_mem;
 553		}
 554	} while ((ret & DIE_FIND_CB_SIBLING) &&
 555		 dwarf_siblingof(die_mem, die_mem) == 0);
 556
 557	return NULL;
 558}
 559
 560struct __addr_die_search_param {
 561	Dwarf_Addr	addr;
 562	Dwarf_Die	*die_mem;
 563};
 564
 565static int __die_search_func_tail_cb(Dwarf_Die *fn_die, void *data)
 566{
 567	struct __addr_die_search_param *ad = data;
 568	Dwarf_Addr addr = 0;
 569
 570	if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
 571	    !dwarf_highpc(fn_die, &addr) &&
 572	    addr == ad->addr) {
 573		memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
 574		return DWARF_CB_ABORT;
 575	}
 576	return DWARF_CB_OK;
 577}
 578
 579/**
 580 * die_find_tailfunc - Search for a non-inlined function with tail call at
 581 * given address
 582 * @cu_die: a CU DIE which including @addr
 583 * @addr: target address
 584 * @die_mem: a buffer for result DIE
 585 *
 586 * Search for a non-inlined function DIE with tail call at @addr. Stores the
 587 * DIE to @die_mem and returns it if found. Returns NULL if failed.
 588 */
 589Dwarf_Die *die_find_tailfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
 590				    Dwarf_Die *die_mem)
 591{
 592	struct __addr_die_search_param ad;
 593	ad.addr = addr;
 594	ad.die_mem = die_mem;
 595	/* dwarf_getscopes can't find subprogram. */
 596	if (!dwarf_getfuncs(cu_die, __die_search_func_tail_cb, &ad, 0))
 597		return NULL;
 598	else
 599		return die_mem;
 600}
 601
 602/* die_find callback for non-inlined function search */
 603static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
 604{
 605	struct __addr_die_search_param *ad = data;
 606
 607	/*
 608	 * Since a declaration entry doesn't has given pc, this always returns
 609	 * function definition entry.
 610	 */
 611	if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
 612	    dwarf_haspc(fn_die, ad->addr)) {
 613		memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
 614		return DWARF_CB_ABORT;
 615	}
 616	return DWARF_CB_OK;
 617}
 618
 619/**
 620 * die_find_realfunc - Search a non-inlined function at given address
 621 * @cu_die: a CU DIE which including @addr
 622 * @addr: target address
 623 * @die_mem: a buffer for result DIE
 624 *
 625 * Search a non-inlined function DIE which includes @addr. Stores the
 626 * DIE to @die_mem and returns it if found. Returns NULL if failed.
 627 */
 628Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
 629				    Dwarf_Die *die_mem)
 630{
 631	struct __addr_die_search_param ad;
 632	ad.addr = addr;
 633	ad.die_mem = die_mem;
 634	/* dwarf_getscopes can't find subprogram. */
 635	if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
 636		return NULL;
 637	else
 638		return die_mem;
 639}
 640
 641/* die_find callback for inline function search */
 642static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
 643{
 644	Dwarf_Addr *addr = data;
 645
 646	if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
 647	    dwarf_haspc(die_mem, *addr))
 648		return DIE_FIND_CB_END;
 649
 650	return DIE_FIND_CB_CONTINUE;
 651}
 652
 653/**
 654 * die_find_top_inlinefunc - Search the top inlined function at given address
 655 * @sp_die: a subprogram DIE which including @addr
 656 * @addr: target address
 657 * @die_mem: a buffer for result DIE
 658 *
 659 * Search an inlined function DIE which includes @addr. Stores the
 660 * DIE to @die_mem and returns it if found. Returns NULL if failed.
 661 * Even if several inlined functions are expanded recursively, this
 662 * doesn't trace it down, and returns the topmost one.
 663 */
 664Dwarf_Die *die_find_top_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
 665				   Dwarf_Die *die_mem)
 666{
 667	return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
 668}
 669
 670/**
 671 * die_find_inlinefunc - Search an inlined function at given address
 672 * @sp_die: a subprogram DIE which including @addr
 673 * @addr: target address
 674 * @die_mem: a buffer for result DIE
 675 *
 676 * Search an inlined function DIE which includes @addr. Stores the
 677 * DIE to @die_mem and returns it if found. Returns NULL if failed.
 678 * If several inlined functions are expanded recursively, this trace
 679 * it down and returns deepest one.
 680 */
 681Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
 682			       Dwarf_Die *die_mem)
 683{
 684	Dwarf_Die tmp_die;
 685
 686	sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr, &tmp_die);
 687	if (!sp_die)
 688		return NULL;
 689
 690	/* Inlined function could be recursive. Trace it until fail */
 691	while (sp_die) {
 692		memcpy(die_mem, sp_die, sizeof(Dwarf_Die));
 693		sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr,
 694					&tmp_die);
 695	}
 696
 697	return die_mem;
 698}
 699
 700static int __die_find_func_rettype_cb(Dwarf_Die *die_mem, void *data)
 701{
 702	const char *func_name;
 703
 704	if (dwarf_tag(die_mem) != DW_TAG_subprogram)
 705		return DIE_FIND_CB_SIBLING;
 706
 707	func_name = dwarf_diename(die_mem);
 708	if (func_name && !strcmp(func_name, data))
 709		return DIE_FIND_CB_END;
 710
 711	return DIE_FIND_CB_SIBLING;
 712}
 713
 714/**
 715 * die_find_func_rettype - Search a return type of function
 716 * @cu_die: a CU DIE
 717 * @name: target function name
 718 * @die_mem: a buffer for result DIE
 719 *
 720 * Search a non-inlined function which matches to @name and stores the
 721 * return type of the function to @die_mem and returns it if found.
 722 * Returns NULL if failed.  Note that it doesn't needs to find a
 723 * definition of the function, so it doesn't match with address.
 724 * Most likely, it can find a declaration at the top level.  Thus the
 725 * callback function continues to sibling entries only.
 726 */
 727Dwarf_Die *die_find_func_rettype(Dwarf_Die *cu_die, const char *name,
 728				 Dwarf_Die *die_mem)
 729{
 730	Dwarf_Die tmp_die;
 731
 732	cu_die = die_find_child(cu_die, __die_find_func_rettype_cb,
 733				(void *)name, &tmp_die);
 734	if (!cu_die)
 735		return NULL;
 736
 737	if (die_get_real_type(&tmp_die, die_mem) == NULL)
 738		return NULL;
 739
 740	return die_mem;
 741}
 742
 743struct __instance_walk_param {
 744	void    *addr;
 745	int	(*callback)(Dwarf_Die *, void *);
 746	void    *data;
 747	int	retval;
 748};
 749
 750static int __die_walk_instances_cb(Dwarf_Die *inst, void *data)
 751{
 752	struct __instance_walk_param *iwp = data;
 753	Dwarf_Attribute attr_mem;
 754	Dwarf_Die origin_mem;
 755	Dwarf_Attribute *attr;
 756	Dwarf_Die *origin;
 757	int tmp;
 758
 759	if (!die_is_func_instance(inst))
 760		return DIE_FIND_CB_CONTINUE;
 761
 762	attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem);
 763	if (attr == NULL)
 764		return DIE_FIND_CB_CONTINUE;
 765
 766	origin = dwarf_formref_die(attr, &origin_mem);
 767	if (origin == NULL || origin->addr != iwp->addr)
 768		return DIE_FIND_CB_CONTINUE;
 769
 770	/* Ignore redundant instances */
 771	if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) {
 772		dwarf_decl_line(origin, &tmp);
 773		if (die_get_call_lineno(inst) == tmp) {
 774			tmp = die_get_decl_fileno(origin);
 775			if (die_get_call_fileno(inst) == tmp)
 776				return DIE_FIND_CB_CONTINUE;
 777		}
 778	}
 779
 780	iwp->retval = iwp->callback(inst, iwp->data);
 781
 782	return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE;
 783}
 784
 785/**
 786 * die_walk_instances - Walk on instances of given DIE
 787 * @or_die: an abstract original DIE
 788 * @callback: a callback function which is called with instance DIE
 789 * @data: user data
 790 *
 791 * Walk on the instances of give @in_die. @in_die must be an inlined function
 792 * declaration. This returns the return value of @callback if it returns
 793 * non-zero value, or -ENOENT if there is no instance.
 794 */
 795int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
 796		       void *data)
 797{
 798	Dwarf_Die cu_die;
 799	Dwarf_Die die_mem;
 800	struct __instance_walk_param iwp = {
 801		.addr = or_die->addr,
 802		.callback = callback,
 803		.data = data,
 804		.retval = -ENOENT,
 805	};
 806
 807	if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
 808		return -ENOENT;
 809
 810	die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
 811
 812	return iwp.retval;
 813}
 814
 815/* Line walker internal parameters */
 816struct __line_walk_param {
 817	bool recursive;
 818	line_walk_callback_t callback;
 819	void *data;
 820	int retval;
 821};
 822
 823static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
 824{
 825	struct __line_walk_param *lw = data;
 826	Dwarf_Addr addr = 0;
 827	const char *fname;
 828	int lineno;
 829
 830	if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
 831		fname = die_get_call_file(in_die);
 832		lineno = die_get_call_lineno(in_die);
 833		if (fname && lineno > 0 && die_entrypc(in_die, &addr) == 0) {
 834			lw->retval = lw->callback(fname, lineno, addr, lw->data);
 835			if (lw->retval != 0)
 836				return DIE_FIND_CB_END;
 837		}
 838		if (!lw->recursive)
 839			return DIE_FIND_CB_SIBLING;
 840	}
 841
 842	if (addr) {
 843		fname = die_get_decl_file(in_die);
 844		if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
 845			lw->retval = lw->callback(fname, lineno, addr, lw->data);
 846			if (lw->retval != 0)
 847				return DIE_FIND_CB_END;
 848		}
 849	}
 850
 851	/* Continue to search nested inlined function call-sites */
 852	return DIE_FIND_CB_CONTINUE;
 853}
 854
 855/* Walk on lines of blocks included in given DIE */
 856static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
 857				line_walk_callback_t callback, void *data)
 858{
 859	struct __line_walk_param lw = {
 860		.recursive = recursive,
 861		.callback = callback,
 862		.data = data,
 863		.retval = 0,
 864	};
 865	Dwarf_Die die_mem;
 866	Dwarf_Addr addr;
 867	const char *fname;
 868	int lineno;
 869
 870	/* Handle function declaration line */
 871	fname = die_get_decl_file(sp_die);
 872	if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
 873	    die_entrypc(sp_die, &addr) == 0) {
 874		lw.retval = callback(fname, lineno, addr, data);
 875		if (lw.retval != 0)
 876			goto done;
 877	}
 878	die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
 879done:
 880	return lw.retval;
 881}
 882
 883static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
 884{
 885	struct __line_walk_param *lw = data;
 886
 887	/*
 888	 * Since inlined function can include another inlined function in
 889	 * the same file, we need to walk in it recursively.
 890	 */
 891	lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
 892	if (lw->retval != 0)
 893		return DWARF_CB_ABORT;
 894
 895	return DWARF_CB_OK;
 896}
 897
 898/**
 899 * die_walk_lines - Walk on lines inside given DIE
 900 * @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
 901 * @callback: callback routine
 902 * @data: user data
 903 *
 904 * Walk on all lines inside given @rt_die and call @callback on each line.
 905 * If the @rt_die is a function, walk only on the lines inside the function,
 906 * otherwise @rt_die must be a CU DIE.
 907 * Note that this walks not only dwarf line list, but also function entries
 908 * and inline call-site.
 909 */
 910int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
 911{
 912	Dwarf_Lines *lines;
 913	Dwarf_Line *line;
 914	Dwarf_Addr addr;
 915	const char *fname, *decf = NULL, *inf = NULL;
 916	int lineno, ret = 0;
 917	int decl = 0, inl;
 918	Dwarf_Die die_mem, *cu_die;
 919	size_t nlines, i;
 920	bool flag;
 921
 922	/* Get the CU die */
 923	if (dwarf_tag(rt_die) != DW_TAG_compile_unit) {
 924		cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
 925		dwarf_decl_line(rt_die, &decl);
 926		decf = die_get_decl_file(rt_die);
 927		if (!decf) {
 928			pr_debug2("Failed to get the declared file name of %s\n",
 929				  dwarf_diename(rt_die));
 930			return -EINVAL;
 931		}
 932	} else
 933		cu_die = rt_die;
 934	if (!cu_die) {
 935		pr_debug2("Failed to get CU from given DIE.\n");
 936		return -EINVAL;
 937	}
 938
 939	/* Get lines list in the CU */
 940	if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
 941		pr_debug2("Failed to get source lines on this CU.\n");
 942		return -ENOENT;
 943	}
 944	pr_debug2("Get %zd lines from this CU\n", nlines);
 945
 946	/* Walk on the lines on lines list */
 947	for (i = 0; i < nlines; i++) {
 948		line = dwarf_onesrcline(lines, i);
 949		if (line == NULL ||
 950		    dwarf_lineno(line, &lineno) != 0 ||
 951		    dwarf_lineaddr(line, &addr) != 0) {
 952			pr_debug2("Failed to get line info. "
 953				  "Possible error in debuginfo.\n");
 954			continue;
 955		}
 956		/* Skip end-of-sequence */
 957		if (dwarf_lineendsequence(line, &flag) != 0 || flag)
 958			continue;
 959		/* Skip Non statement line-info */
 960		if (dwarf_linebeginstatement(line, &flag) != 0 || !flag)
 961			continue;
 962		/* Filter lines based on address */
 963		if (rt_die != cu_die) {
 964			/*
 965			 * Address filtering
 966			 * The line is included in given function, and
 967			 * no inline block includes it.
 968			 */
 969			if (!dwarf_haspc(rt_die, addr))
 970				continue;
 971
 972			if (die_find_inlinefunc(rt_die, addr, &die_mem)) {
 973				/* Call-site check */
 974				inf = die_get_call_file(&die_mem);
 975				if ((inf && !strcmp(inf, decf)) &&
 976				    die_get_call_lineno(&die_mem) == lineno)
 977					goto found;
 978
 979				dwarf_decl_line(&die_mem, &inl);
 980				if (inl != decl ||
 981				    decf != die_get_decl_file(&die_mem))
 982					continue;
 983			}
 984		}
 985found:
 986		/* Get source line */
 987		fname = dwarf_linesrc(line, NULL, NULL);
 988
 989		ret = callback(fname, lineno, addr, data);
 990		if (ret != 0)
 991			return ret;
 992	}
 993
 994	/*
 995	 * Dwarf lines doesn't include function declarations and inlined
 996	 * subroutines. We have to check functions list or given function.
 997	 */
 998	if (rt_die != cu_die)
 999		/*
1000		 * Don't need walk inlined functions recursively, because
1001		 * inner inlined functions don't have the lines of the
1002		 * specified function.
1003		 */
1004		ret = __die_walk_funclines(rt_die, false, callback, data);
1005	else {
1006		struct __line_walk_param param = {
1007			.callback = callback,
1008			.data = data,
1009			.retval = 0,
1010		};
1011		dwarf_getfuncs(cu_die, __die_walk_culines_cb, &param, 0);
1012		ret = param.retval;
1013	}
1014
1015	return ret;
1016}
1017
1018struct __find_variable_param {
1019	const char *name;
1020	Dwarf_Addr addr;
1021};
1022
1023static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
1024{
1025	struct __find_variable_param *fvp = data;
1026	Dwarf_Attribute attr;
1027	int tag;
1028
1029	tag = dwarf_tag(die_mem);
1030	if ((tag == DW_TAG_formal_parameter ||
1031	     tag == DW_TAG_variable) &&
1032	    die_compare_name(die_mem, fvp->name) &&
1033	/*
1034	 * Does the DIE have location information or const value
1035	 * or external instance?
1036	 */
1037	    (dwarf_attr(die_mem, DW_AT_external, &attr) ||
1038	     dwarf_attr(die_mem, DW_AT_location, &attr) ||
1039	     dwarf_attr(die_mem, DW_AT_const_value, &attr)))
1040		return DIE_FIND_CB_END;
1041	if (dwarf_haspc(die_mem, fvp->addr))
1042		return DIE_FIND_CB_CONTINUE;
1043	else
1044		return DIE_FIND_CB_SIBLING;
1045}
1046
1047/**
1048 * die_find_variable_at - Find a given name variable at given address
1049 * @sp_die: a function DIE
1050 * @name: variable name
1051 * @addr: address
1052 * @die_mem: a buffer for result DIE
1053 *
1054 * Find a variable DIE called @name at @addr in @sp_die.
1055 */
1056Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
1057				Dwarf_Addr addr, Dwarf_Die *die_mem)
1058{
1059	struct __find_variable_param fvp = { .name = name, .addr = addr};
1060
1061	return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
1062			      die_mem);
1063}
1064
1065static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
1066{
1067	const char *name = data;
1068
1069	if (dwarf_tag(die_mem) == DW_TAG_member) {
1070		if (die_compare_name(die_mem, name))
1071			return DIE_FIND_CB_END;
1072		else if (!dwarf_diename(die_mem)) {	/* Unnamed structure */
1073			Dwarf_Die type_die, tmp_die;
1074			if (die_get_type(die_mem, &type_die) &&
1075			    die_find_member(&type_die, name, &tmp_die))
1076				return DIE_FIND_CB_END;
1077		}
1078	}
1079	return DIE_FIND_CB_SIBLING;
1080}
1081
1082/**
1083 * die_find_member - Find a given name member in a data structure
1084 * @st_die: a data structure type DIE
1085 * @name: member name
1086 * @die_mem: a buffer for result DIE
1087 *
1088 * Find a member DIE called @name in @st_die.
1089 */
1090Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
1091			   Dwarf_Die *die_mem)
1092{
1093	return die_find_child(st_die, __die_find_member_cb, (void *)name,
1094			      die_mem);
1095}
1096
1097/**
1098 * die_get_typename_from_type - Get the name of given type DIE
1099 * @type_die: a type DIE
1100 * @buf: a strbuf for result type name
1101 *
1102 * Get the name of @type_die and stores it to @buf. Return 0 if succeeded.
1103 * and Return -ENOENT if failed to find type name.
1104 * Note that the result will stores typedef name if possible, and stores
1105 * "*(function_type)" if the type is a function pointer.
1106 */
1107int die_get_typename_from_type(Dwarf_Die *type_die, struct strbuf *buf)
1108{
 
1109	int tag, ret;
1110	const char *tmp = "";
1111
1112	tag = dwarf_tag(type_die);
1113	if (tag == DW_TAG_pointer_type)
 
 
 
1114		tmp = "*";
1115	else if (tag == DW_TAG_array_type)
1116		tmp = "[]";
1117	else if (tag == DW_TAG_subroutine_type) {
1118		/* Function pointer */
1119		return strbuf_add(buf, "(function_type)", 15);
1120	} else {
1121		const char *name = dwarf_diename(type_die);
1122
1123		if (tag == DW_TAG_union_type)
1124			tmp = "union ";
1125		else if (tag == DW_TAG_structure_type)
1126			tmp = "struct ";
1127		else if (tag == DW_TAG_enumeration_type)
1128			tmp = "enum ";
1129		else if (name == NULL)
1130			return -ENOENT;
1131		/* Write a base name */
1132		return strbuf_addf(buf, "%s%s", tmp, name ?: "");
1133	}
1134	ret = die_get_typename(type_die, buf);
1135	if (ret < 0) {
1136		/* void pointer has no type attribute */
1137		if (tag == DW_TAG_pointer_type && ret == -ENOENT)
1138			return strbuf_addf(buf, "void*");
1139
1140		return ret;
1141	}
1142	return strbuf_addstr(buf, tmp);
1143}
1144
1145/**
1146 * die_get_typename - Get the name of given variable DIE
1147 * @vr_die: a variable DIE
1148 * @buf: a strbuf for result type name
1149 *
1150 * Get the name of @vr_die and stores it to @buf. Return 0 if succeeded.
1151 * and Return -ENOENT if failed to find type name.
1152 * Note that the result will stores typedef name if possible, and stores
1153 * "*(function_type)" if the type is a function pointer.
1154 */
1155int die_get_typename(Dwarf_Die *vr_die, struct strbuf *buf)
1156{
1157	Dwarf_Die type;
1158
1159	if (__die_get_real_type(vr_die, &type) == NULL)
1160		return -ENOENT;
1161
1162	return die_get_typename_from_type(&type, buf);
1163}
1164
1165/**
1166 * die_get_varname - Get the name and type of given variable DIE
1167 * @vr_die: a variable DIE
1168 * @buf: a strbuf for type and variable name
1169 *
1170 * Get the name and type of @vr_die and stores it in @buf as "type\tname".
1171 */
1172int die_get_varname(Dwarf_Die *vr_die, struct strbuf *buf)
1173{
1174	int ret;
1175
1176	ret = die_get_typename(vr_die, buf);
1177	if (ret < 0) {
1178		pr_debug("Failed to get type, make it unknown.\n");
1179		ret = strbuf_add(buf, "(unknown_type)", 14);
1180	}
1181
1182	return ret < 0 ? ret : strbuf_addf(buf, "\t%s", dwarf_diename(vr_die));
1183}
1184
1185static int reg_from_dwarf_op(Dwarf_Op *op)
1186{
1187	switch (op->atom) {
1188	case DW_OP_reg0 ... DW_OP_reg31:
1189		return op->atom - DW_OP_reg0;
1190	case DW_OP_breg0 ... DW_OP_breg31:
1191		return op->atom - DW_OP_breg0;
1192	case DW_OP_regx:
1193	case DW_OP_bregx:
1194		return op->number;
1195	case DW_OP_fbreg:
1196		return DWARF_REG_FB;
1197	default:
1198		break;
1199	}
1200	return -1;
1201}
1202
1203static int offset_from_dwarf_op(Dwarf_Op *op)
1204{
1205	switch (op->atom) {
1206	case DW_OP_reg0 ... DW_OP_reg31:
1207	case DW_OP_regx:
1208		return 0;
1209	case DW_OP_breg0 ... DW_OP_breg31:
1210	case DW_OP_fbreg:
1211		return op->number;
1212	case DW_OP_bregx:
1213		return op->number2;
1214	default:
1215		break;
1216	}
1217	return -1;
1218}
1219
1220static bool check_allowed_ops(Dwarf_Op *ops, size_t nops)
1221{
1222	/* The first op is checked separately */
1223	ops++;
1224	nops--;
1225
1226	/*
1227	 * It needs to make sure if the location expression matches to the given
1228	 * register and offset exactly.  Thus it rejects any complex expressions
1229	 * and only allows a few of selected operators that doesn't change the
1230	 * location.
1231	 */
1232	while (nops) {
1233		switch (ops->atom) {
1234		case DW_OP_stack_value:
1235		case DW_OP_deref_size:
1236		case DW_OP_deref:
1237		case DW_OP_piece:
1238			break;
1239		default:
1240			return false;
1241		}
1242		ops++;
1243		nops--;
1244	}
1245	return true;
1246}
1247
1248/**
1249 * die_get_var_innermost_scope - Get innermost scope range of given variable DIE
1250 * @sp_die: a subprogram DIE
1251 * @vr_die: a variable DIE
1252 * @buf: a strbuf for variable byte offset range
1253 *
1254 * Get the innermost scope range of @vr_die and stores it in @buf as
1255 * "@<function_name+[NN-NN,NN-NN]>".
1256 */
1257static int die_get_var_innermost_scope(Dwarf_Die *sp_die, Dwarf_Die *vr_die,
1258				struct strbuf *buf)
1259{
1260	Dwarf_Die *scopes;
1261	int count;
1262	size_t offset = 0;
1263	Dwarf_Addr base;
1264	Dwarf_Addr start, end;
1265	Dwarf_Addr entry;
1266	int ret;
1267	bool first = true;
1268	const char *name;
1269
1270	ret = die_entrypc(sp_die, &entry);
1271	if (ret)
1272		return ret;
1273
1274	name = dwarf_diename(sp_die);
1275	if (!name)
1276		return -ENOENT;
1277
1278	count = dwarf_getscopes_die(vr_die, &scopes);
1279
1280	/* (*SCOPES)[1] is the DIE for the scope containing that scope */
1281	if (count <= 1) {
1282		ret = -EINVAL;
1283		goto out;
1284	}
1285
1286	while ((offset = dwarf_ranges(&scopes[1], offset, &base,
1287					&start, &end)) > 0) {
1288		start -= entry;
1289		end -= entry;
1290
1291		if (first) {
1292			ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1293					  name, start, end);
1294			first = false;
1295		} else {
1296			ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1297					  start, end);
1298		}
1299		if (ret < 0)
1300			goto out;
1301	}
1302
1303	if (!first)
1304		ret = strbuf_add(buf, "]>", 2);
1305
1306out:
1307	free(scopes);
1308	return ret;
1309}
1310
1311/**
1312 * die_get_var_range - Get byte offset range of given variable DIE
1313 * @sp_die: a subprogram DIE
1314 * @vr_die: a variable DIE
1315 * @buf: a strbuf for type and variable name and byte offset range
1316 *
1317 * Get the byte offset range of @vr_die and stores it in @buf as
1318 * "@<function_name+[NN-NN,NN-NN]>".
1319 */
1320int die_get_var_range(Dwarf_Die *sp_die, Dwarf_Die *vr_die, struct strbuf *buf)
1321{
1322	int ret = 0;
1323	Dwarf_Addr base;
1324	Dwarf_Addr start, end;
1325	Dwarf_Addr entry;
1326	Dwarf_Op *op;
1327	size_t nops;
1328	size_t offset = 0;
1329	Dwarf_Attribute attr;
1330	bool first = true;
1331	const char *name;
1332
1333	ret = die_entrypc(sp_die, &entry);
1334	if (ret)
1335		return ret;
1336
1337	name = dwarf_diename(sp_die);
1338	if (!name)
1339		return -ENOENT;
1340
1341	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
1342		return -EINVAL;
1343
1344	while ((offset = dwarf_getlocations(&attr, offset, &base,
1345					&start, &end, &op, &nops)) > 0) {
1346		if (start == 0) {
1347			/* Single Location Descriptions */
1348			ret = die_get_var_innermost_scope(sp_die, vr_die, buf);
1349			goto out;
1350		}
1351
1352		/* Location Lists */
1353		start -= entry;
1354		end -= entry;
1355		if (first) {
1356			ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1357					  name, start, end);
1358			first = false;
1359		} else {
1360			ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1361					  start, end);
1362		}
1363		if (ret < 0)
1364			goto out;
1365	}
1366
1367	if (!first)
1368		ret = strbuf_add(buf, "]>", 2);
1369out:
1370	return ret;
1371}
1372
1373/* Interval parameters for __die_find_var_reg_cb() */
1374struct find_var_data {
1375	/* Target instruction address */
1376	Dwarf_Addr pc;
1377	/* Target memory address (for global data) */
1378	Dwarf_Addr addr;
1379	/* Target register */
1380	unsigned reg;
1381	/* Access offset, set for global data */
1382	int offset;
1383	/* True if the current register is the frame base */
1384	bool is_fbreg;
1385};
1386
1387/* Max number of registers DW_OP_regN supports */
1388#define DWARF_OP_DIRECT_REGS  32
1389
1390static bool match_var_offset(Dwarf_Die *die_mem, struct find_var_data *data,
1391			     u64 addr_offset, u64 addr_type, bool is_pointer)
1392{
1393	Dwarf_Die type_die;
1394	Dwarf_Word size;
1395
1396	if (addr_offset == addr_type) {
1397		/* Update offset relative to the start of the variable */
1398		data->offset = 0;
1399		return true;
1400	}
1401
1402	if (addr_offset < addr_type)
1403		return false;
1404
1405	if (die_get_real_type(die_mem, &type_die) == NULL)
1406		return false;
1407
1408	if (is_pointer && dwarf_tag(&type_die) == DW_TAG_pointer_type) {
1409		/* Get the target type of the pointer */
1410		if (die_get_real_type(&type_die, &type_die) == NULL)
1411			return false;
1412	}
1413
1414	if (dwarf_aggregate_size(&type_die, &size) < 0)
1415		return false;
1416
1417	if (addr_offset >= addr_type + size)
1418		return false;
1419
1420	/* Update offset relative to the start of the variable */
1421	data->offset = addr_offset - addr_type;
1422	return true;
1423}
1424
1425/* Only checks direct child DIEs in the given scope. */
1426static int __die_find_var_reg_cb(Dwarf_Die *die_mem, void *arg)
1427{
1428	struct find_var_data *data = arg;
1429	int tag = dwarf_tag(die_mem);
1430	ptrdiff_t off = 0;
1431	Dwarf_Attribute attr;
1432	Dwarf_Addr base, start, end;
1433	Dwarf_Op *ops;
1434	size_t nops;
1435
1436	if (tag != DW_TAG_variable && tag != DW_TAG_formal_parameter)
1437		return DIE_FIND_CB_SIBLING;
1438
1439	if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL)
1440		return DIE_FIND_CB_SIBLING;
1441
1442	while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) {
1443		/* Assuming the location list is sorted by address */
1444		if (end <= data->pc)
1445			continue;
1446		if (start > data->pc)
1447			break;
1448
1449		/* Local variables accessed using frame base register */
1450		if (data->is_fbreg && ops->atom == DW_OP_fbreg &&
1451		    check_allowed_ops(ops, nops) &&
1452		    match_var_offset(die_mem, data, data->offset, ops->number,
1453				     /*is_pointer=*/false))
1454			return DIE_FIND_CB_END;
1455
1456		/* Only match with a simple case */
1457		if (data->reg < DWARF_OP_DIRECT_REGS) {
1458			/* pointer variables saved in a register 0 to 31 */
1459			if (ops->atom == (DW_OP_reg0 + data->reg) &&
1460			    check_allowed_ops(ops, nops) &&
1461			    match_var_offset(die_mem, data, data->offset, 0,
1462					     /*is_pointer=*/true))
1463				return DIE_FIND_CB_END;
1464
1465			/* Local variables accessed by a register + offset */
1466			if (ops->atom == (DW_OP_breg0 + data->reg) &&
1467			    check_allowed_ops(ops, nops) &&
1468			    match_var_offset(die_mem, data, data->offset, ops->number,
1469					     /*is_pointer=*/false))
1470				return DIE_FIND_CB_END;
1471		} else {
1472			/* pointer variables saved in a register 32 or above */
1473			if (ops->atom == DW_OP_regx && ops->number == data->reg &&
1474			    check_allowed_ops(ops, nops) &&
1475			    match_var_offset(die_mem, data, data->offset, 0,
1476					     /*is_pointer=*/true))
1477				return DIE_FIND_CB_END;
1478
1479			/* Local variables accessed by a register + offset */
1480			if (ops->atom == DW_OP_bregx && data->reg == ops->number &&
1481			    check_allowed_ops(ops, nops) &&
1482			    match_var_offset(die_mem, data, data->offset, ops->number2,
1483					     /*is_poitner=*/false))
1484				return DIE_FIND_CB_END;
1485		}
1486	}
1487	return DIE_FIND_CB_SIBLING;
1488}
1489
1490/**
1491 * die_find_variable_by_reg - Find a variable saved in a register
1492 * @sc_die: a scope DIE
1493 * @pc: the program address to find
1494 * @reg: the register number to find
1495 * @poffset: pointer to offset, will be updated for fbreg case
1496 * @is_fbreg: boolean value if the current register is the frame base
1497 * @die_mem: a buffer to save the resulting DIE
1498 *
1499 * Find the variable DIE accessed by the given register.  It'll update the @offset
1500 * when the variable is in the stack.
1501 */
1502Dwarf_Die *die_find_variable_by_reg(Dwarf_Die *sc_die, Dwarf_Addr pc, int reg,
1503				    int *poffset, bool is_fbreg,
1504				    Dwarf_Die *die_mem)
1505{
1506	struct find_var_data data = {
1507		.pc = pc,
1508		.reg = reg,
1509		.offset = *poffset,
1510		.is_fbreg = is_fbreg,
1511	};
1512	Dwarf_Die *result;
1513
1514	result = die_find_child(sc_die, __die_find_var_reg_cb, &data, die_mem);
1515	if (result)
1516		*poffset = data.offset;
1517	return result;
1518}
1519
1520/* Only checks direct child DIEs in the given scope */
1521static int __die_find_var_addr_cb(Dwarf_Die *die_mem, void *arg)
1522{
1523	struct find_var_data *data = arg;
1524	int tag = dwarf_tag(die_mem);
1525	ptrdiff_t off = 0;
1526	Dwarf_Attribute attr;
1527	Dwarf_Addr base, start, end;
1528	Dwarf_Op *ops;
1529	size_t nops;
1530
1531	if (tag != DW_TAG_variable)
1532		return DIE_FIND_CB_SIBLING;
1533
1534	if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL)
1535		return DIE_FIND_CB_SIBLING;
1536
1537	while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) {
1538		if (ops->atom != DW_OP_addr)
1539			continue;
1540
1541		if (check_allowed_ops(ops, nops) &&
1542		    match_var_offset(die_mem, data, data->addr, ops->number,
1543				     /*is_pointer=*/false))
1544			return DIE_FIND_CB_END;
1545	}
1546	return DIE_FIND_CB_SIBLING;
1547}
1548
1549/**
1550 * die_find_variable_by_addr - Find variable located at given address
1551 * @sc_die: a scope DIE
1552 * @addr: the data address to find
1553 * @die_mem: a buffer to save the resulting DIE
1554 * @offset: the offset in the resulting type
1555 *
1556 * Find the variable DIE located at the given address (in PC-relative mode).
1557 * This is usually for global variables.
1558 */
1559Dwarf_Die *die_find_variable_by_addr(Dwarf_Die *sc_die, Dwarf_Addr addr,
1560				     Dwarf_Die *die_mem, int *offset)
1561{
1562	struct find_var_data data = {
1563		.addr = addr,
1564	};
1565	Dwarf_Die *result;
1566
1567	result = die_find_child(sc_die, __die_find_var_addr_cb, &data, die_mem);
1568	if (result)
1569		*offset = data.offset;
1570	return result;
1571}
1572
1573static int __die_collect_vars_cb(Dwarf_Die *die_mem, void *arg)
1574{
1575	struct die_var_type **var_types = arg;
1576	Dwarf_Die type_die;
1577	int tag = dwarf_tag(die_mem);
1578	Dwarf_Attribute attr;
1579	Dwarf_Addr base, start, end;
1580	Dwarf_Op *ops;
1581	size_t nops;
1582	struct die_var_type *vt;
1583
1584	if (tag != DW_TAG_variable && tag != DW_TAG_formal_parameter)
1585		return DIE_FIND_CB_SIBLING;
1586
1587	if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL)
1588		return DIE_FIND_CB_SIBLING;
1589
1590	/*
1591	 * Only collect the first location as it can reconstruct the
1592	 * remaining state by following the instructions.
1593	 * start = 0 means it covers the whole range.
1594	 */
1595	if (dwarf_getlocations(&attr, 0, &base, &start, &end, &ops, &nops) <= 0)
1596		return DIE_FIND_CB_SIBLING;
1597
1598	if (!check_allowed_ops(ops, nops))
1599		return DIE_FIND_CB_SIBLING;
1600
1601	if (die_get_real_type(die_mem, &type_die) == NULL)
1602		return DIE_FIND_CB_SIBLING;
1603
1604	vt = malloc(sizeof(*vt));
1605	if (vt == NULL)
1606		return DIE_FIND_CB_END;
1607
1608	vt->die_off = dwarf_dieoffset(&type_die);
1609	vt->addr = start;
1610	vt->reg = reg_from_dwarf_op(ops);
1611	vt->offset = offset_from_dwarf_op(ops);
1612	vt->next = *var_types;
1613	*var_types = vt;
1614
1615	return DIE_FIND_CB_SIBLING;
1616}
1617
1618/**
1619 * die_collect_vars - Save all variables and parameters
1620 * @sc_die: a scope DIE
1621 * @var_types: a pointer to save the resulting list
1622 *
1623 * Save all variables and parameters in the @sc_die and save them to @var_types.
1624 * The @var_types is a singly-linked list containing type and location info.
1625 * Actual type can be retrieved using dwarf_offdie() with 'die_off' later.
1626 *
1627 * Callers should free @var_types.
1628 */
1629void die_collect_vars(Dwarf_Die *sc_die, struct die_var_type **var_types)
1630{
1631	Dwarf_Die die_mem;
1632
1633	die_find_child(sc_die, __die_collect_vars_cb, (void *)var_types, &die_mem);
1634}
1635
1636static int __die_collect_global_vars_cb(Dwarf_Die *die_mem, void *arg)
1637{
1638	struct die_var_type **var_types = arg;
1639	Dwarf_Die type_die;
1640	int tag = dwarf_tag(die_mem);
1641	Dwarf_Attribute attr;
1642	Dwarf_Addr base, start, end;
1643	Dwarf_Op *ops;
1644	size_t nops;
1645	struct die_var_type *vt;
1646
1647	if (tag != DW_TAG_variable)
1648		return DIE_FIND_CB_SIBLING;
1649
1650	if (dwarf_attr(die_mem, DW_AT_location, &attr) == NULL)
1651		return DIE_FIND_CB_SIBLING;
1652
1653	/* Only collect the location with an absolute address. */
1654	if (dwarf_getlocations(&attr, 0, &base, &start, &end, &ops, &nops) <= 0)
1655		return DIE_FIND_CB_SIBLING;
1656
1657	if (ops->atom != DW_OP_addr)
1658		return DIE_FIND_CB_SIBLING;
1659
1660	if (!check_allowed_ops(ops, nops))
1661		return DIE_FIND_CB_SIBLING;
1662
1663	if (die_get_real_type(die_mem, &type_die) == NULL)
1664		return DIE_FIND_CB_SIBLING;
1665
1666	vt = malloc(sizeof(*vt));
1667	if (vt == NULL)
1668		return DIE_FIND_CB_END;
1669
1670	vt->die_off = dwarf_dieoffset(&type_die);
1671	vt->addr = ops->number;
1672	vt->reg = -1;
1673	vt->offset = 0;
1674	vt->next = *var_types;
1675	*var_types = vt;
1676
1677	return DIE_FIND_CB_SIBLING;
1678}
1679
1680/**
1681 * die_collect_global_vars - Save all global variables
1682 * @cu_die: a CU DIE
1683 * @var_types: a pointer to save the resulting list
1684 *
1685 * Save all global variables in the @cu_die and save them to @var_types.
1686 * The @var_types is a singly-linked list containing type and location info.
1687 * Actual type can be retrieved using dwarf_offdie() with 'die_off' later.
1688 *
1689 * Callers should free @var_types.
1690 */
1691void die_collect_global_vars(Dwarf_Die *cu_die, struct die_var_type **var_types)
1692{
1693	Dwarf_Die die_mem;
1694
1695	die_find_child(cu_die, __die_collect_global_vars_cb, (void *)var_types, &die_mem);
1696}
1697
1698/**
1699 * die_get_cfa - Get frame base information
1700 * @dwarf: a Dwarf info
1701 * @pc: program address
1702 * @preg: pointer for saved register
1703 * @poffset: pointer for saved offset
1704 *
1705 * This function gets register and offset for CFA (Canonical Frame Address)
1706 * by searching the CIE/FDE info.  The CFA usually points to the start address
1707 * of the current stack frame and local variables can be located using an offset
1708 * from the CFA.  The @preg and @poffset will be updated if it returns 0.
1709 */
1710int die_get_cfa(Dwarf *dwarf, u64 pc, int *preg, int *poffset)
1711{
1712	Dwarf_CFI *cfi;
1713	Dwarf_Frame *frame = NULL;
1714	Dwarf_Op *ops = NULL;
1715	size_t nops;
1716
1717	cfi = dwarf_getcfi(dwarf);
1718	if (cfi == NULL)
1719		return -1;
1720
1721	if (!dwarf_cfi_addrframe(cfi, pc, &frame) &&
1722	    !dwarf_frame_cfa(frame, &ops, &nops) &&
1723	    check_allowed_ops(ops, nops)) {
1724		*preg = reg_from_dwarf_op(ops);
1725		*poffset = offset_from_dwarf_op(ops);
1726		return 0;
1727	}
1728	return -1;
1729}
 
1730
1731/*
1732 * die_has_loclist - Check if DW_AT_location of @vr_die is a location list
1733 * @vr_die: a variable DIE
1734 */
1735static bool die_has_loclist(Dwarf_Die *vr_die)
1736{
1737	Dwarf_Attribute loc;
1738	int tag = dwarf_tag(vr_die);
1739
1740	if (tag != DW_TAG_formal_parameter &&
1741	    tag != DW_TAG_variable)
1742		return false;
1743
1744	return (dwarf_attr_integrate(vr_die, DW_AT_location, &loc) &&
1745		dwarf_whatform(&loc) == DW_FORM_sec_offset);
1746}
1747
1748/*
1749 * die_is_optimized_target - Check if target program is compiled with
1750 * optimization
1751 * @cu_die: a CU DIE
1752 *
1753 * For any object in given CU whose DW_AT_location is a location list,
1754 * target program is compiled with optimization. This is applicable to
1755 * clang as well.
1756 */
1757bool die_is_optimized_target(Dwarf_Die *cu_die)
1758{
1759	Dwarf_Die tmp_die;
1760
1761	if (die_has_loclist(cu_die))
1762		return true;
1763
1764	if (!dwarf_child(cu_die, &tmp_die) &&
1765	    die_is_optimized_target(&tmp_die))
1766		return true;
1767
1768	if (!dwarf_siblingof(cu_die, &tmp_die) &&
1769	    die_is_optimized_target(&tmp_die))
1770		return true;
1771
1772	return false;
1773}
1774
1775/*
1776 * die_search_idx - Search index of given line address
1777 * @lines: Line records of single CU
1778 * @nr_lines: Number of @lines
1779 * @addr: address we are looking for
1780 * @idx: index to be set by this function (return value)
1781 *
1782 * Search for @addr by looping over every lines of CU. If address
1783 * matches, set index of that line in @idx. Note that single source
1784 * line can have multiple line records. i.e. single source line can
1785 * have multiple index.
1786 */
1787static bool die_search_idx(Dwarf_Lines *lines, unsigned long nr_lines,
1788			   Dwarf_Addr addr, unsigned long *idx)
1789{
1790	unsigned long i;
1791	Dwarf_Addr tmp;
1792
1793	for (i = 0; i < nr_lines; i++) {
1794		if (dwarf_lineaddr(dwarf_onesrcline(lines, i), &tmp))
1795			return false;
1796
1797		if (tmp == addr) {
1798			*idx = i;
1799			return true;
1800		}
1801	}
1802	return false;
1803}
1804
1805/*
1806 * die_get_postprologue_addr - Search next address after function prologue
1807 * @entrypc_idx: entrypc index
1808 * @lines: Line records of single CU
1809 * @nr_lines: Number of @lines
1810 * @hignpc: high PC address of function
1811 * @postprologue_addr: Next address after function prologue (return value)
1812 *
1813 * Look for prologue-end marker. If there is no explicit marker, return
1814 * address of next line record or next source line.
1815 */
1816static bool die_get_postprologue_addr(unsigned long entrypc_idx,
1817				      Dwarf_Lines *lines,
1818				      unsigned long nr_lines,
1819				      Dwarf_Addr highpc,
1820				      Dwarf_Addr *postprologue_addr)
1821{
1822	unsigned long i;
1823	int entrypc_lno, lno;
1824	Dwarf_Line *line;
1825	Dwarf_Addr addr;
1826	bool p_end;
1827
1828	/* entrypc_lno is actual source line number */
1829	line = dwarf_onesrcline(lines, entrypc_idx);
1830	if (dwarf_lineno(line, &entrypc_lno))
1831		return false;
1832
1833	for (i = entrypc_idx; i < nr_lines; i++) {
1834		line = dwarf_onesrcline(lines, i);
1835
1836		if (dwarf_lineaddr(line, &addr) ||
1837		    dwarf_lineno(line, &lno)    ||
1838		    dwarf_lineprologueend(line, &p_end))
1839			return false;
1840
1841		/* highpc is exclusive. [entrypc,highpc) */
1842		if (addr >= highpc)
1843			break;
1844
1845		/* clang supports prologue-end marker */
1846		if (p_end)
1847			break;
1848
1849		/* Actual next line in source */
1850		if (lno != entrypc_lno)
1851			break;
1852
1853		/*
1854		 * Single source line can have multiple line records.
1855		 * For Example,
1856		 *     void foo() { printf("hello\n"); }
1857		 * contains two line records. One points to declaration and
1858		 * other points to printf() line. Variable 'lno' won't get
1859		 * incremented in this case but 'i' will.
1860		 */
1861		if (i != entrypc_idx)
1862			break;
1863	}
1864
1865	dwarf_lineaddr(line, postprologue_addr);
1866	if (*postprologue_addr >= highpc)
1867		dwarf_lineaddr(dwarf_onesrcline(lines, i - 1),
1868			       postprologue_addr);
1869
1870	return true;
1871}
1872
1873/*
1874 * die_skip_prologue - Use next address after prologue as probe location
1875 * @sp_die: a subprogram DIE
1876 * @cu_die: a CU DIE
1877 * @entrypc: entrypc of the function
1878 *
1879 * Function prologue prepares stack and registers before executing function
1880 * logic. When target program is compiled without optimization, function
1881 * parameter information is only valid after prologue. When we probe entrypc
1882 * of the function, and try to record function parameter, it contains
1883 * garbage value.
1884 */
1885void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die,
1886		       Dwarf_Addr *entrypc)
1887{
1888	size_t nr_lines = 0;
1889	unsigned long entrypc_idx = 0;
1890	Dwarf_Lines *lines = NULL;
1891	Dwarf_Addr postprologue_addr;
1892	Dwarf_Addr highpc;
1893
1894	if (dwarf_highpc(sp_die, &highpc))
1895		return;
1896
1897	if (dwarf_getsrclines(cu_die, &lines, &nr_lines))
1898		return;
1899
1900	if (!die_search_idx(lines, nr_lines, *entrypc, &entrypc_idx))
1901		return;
1902
1903	if (!die_get_postprologue_addr(entrypc_idx, lines, nr_lines,
1904				       highpc, &postprologue_addr))
1905		return;
1906
1907	*entrypc = postprologue_addr;
1908}
1909
1910/* Internal parameters for __die_find_scope_cb() */
1911struct find_scope_data {
1912	/* Target instruction address */
1913	Dwarf_Addr pc;
1914	/* Number of scopes found [output] */
1915	int nr;
1916	/* Array of scopes found, 0 for the outermost one. [output] */
1917	Dwarf_Die *scopes;
1918};
1919
1920static int __die_find_scope_cb(Dwarf_Die *die_mem, void *arg)
1921{
1922	struct find_scope_data *data = arg;
1923
1924	if (dwarf_haspc(die_mem, data->pc)) {
1925		Dwarf_Die *tmp;
1926
1927		tmp = realloc(data->scopes, (data->nr + 1) * sizeof(*tmp));
1928		if (tmp == NULL)
1929			return DIE_FIND_CB_END;
1930
1931		memcpy(tmp + data->nr, die_mem, sizeof(*die_mem));
1932		data->scopes = tmp;
1933		data->nr++;
1934		return DIE_FIND_CB_CHILD;
1935	}
1936	return DIE_FIND_CB_SIBLING;
1937}
1938
1939/**
1940 * die_get_scopes - Return a list of scopes including the address
1941 * @cu_die: a compile unit DIE
1942 * @pc: the address to find
1943 * @scopes: the array of DIEs for scopes (result)
1944 *
1945 * This function does the same as the dwarf_getscopes() but doesn't follow
1946 * the origins of inlined functions.  It returns the number of scopes saved
1947 * in the @scopes argument.  The outer scope will be saved first (index 0) and
1948 * the last one is the innermost scope at the @pc.
1949 */
1950int die_get_scopes(Dwarf_Die *cu_die, Dwarf_Addr pc, Dwarf_Die **scopes)
1951{
1952	struct find_scope_data data = {
1953		.pc = pc,
1954	};
1955	Dwarf_Die die_mem;
1956
1957	die_find_child(cu_die, __die_find_scope_cb, &data, &die_mem);
1958
1959	*scopes = data.scopes;
1960	return data.nr;
1961}
1962
1963static int __die_find_member_offset_cb(Dwarf_Die *die_mem, void *arg)
1964{
1965	Dwarf_Die type_die;
1966	Dwarf_Word size, loc;
1967	Dwarf_Word offset = (long)arg;
1968	int tag = dwarf_tag(die_mem);
1969
1970	if (tag != DW_TAG_member)
1971		return DIE_FIND_CB_SIBLING;
1972
1973	/* Unions might not have location */
1974	if (die_get_data_member_location(die_mem, &loc) < 0) {
1975		Dwarf_Attribute attr;
1976
1977		if (dwarf_attr_integrate(die_mem, DW_AT_data_bit_offset, &attr) &&
1978		    dwarf_formudata(&attr, &loc) == 0)
1979			loc /= 8;
1980		else
1981			loc = 0;
1982	}
1983
1984	if (offset == loc)
1985		return DIE_FIND_CB_END;
1986
1987	if (die_get_real_type(die_mem, &type_die) == NULL) {
1988		// TODO: add a pr_debug_dtp() later for this unlikely failure
1989		return DIE_FIND_CB_SIBLING;
1990	}
1991
1992	if (dwarf_aggregate_size(&type_die, &size) < 0)
1993		size = 0;
1994
1995	if (loc < offset && offset < (loc + size))
1996		return DIE_FIND_CB_END;
1997
1998	return DIE_FIND_CB_SIBLING;
1999}
2000
2001/**
2002 * die_get_member_type - Return type info of struct member
2003 * @type_die: a type DIE
2004 * @offset: offset in the type
2005 * @die_mem: a buffer to save the resulting DIE
2006 *
2007 * This function returns a type of a member in @type_die where it's located at
2008 * @offset if it's a struct.  For now, it just returns the first matching
2009 * member in a union.  For other types, it'd return the given type directly
2010 * if it's within the size of the type or NULL otherwise.
2011 */
2012Dwarf_Die *die_get_member_type(Dwarf_Die *type_die, int offset,
2013			       Dwarf_Die *die_mem)
2014{
2015	Dwarf_Die *member;
2016	Dwarf_Die mb_type;
2017	int tag;
2018
2019	tag = dwarf_tag(type_die);
2020	/* If it's not a compound type, return the type directly */
2021	if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
2022		Dwarf_Word size;
2023
2024		if (dwarf_aggregate_size(type_die, &size) < 0)
2025			size = 0;
2026
2027		if ((unsigned)offset >= size)
2028			return NULL;
2029
2030		*die_mem = *type_die;
2031		return die_mem;
2032	}
2033
2034	mb_type = *type_die;
2035	/* TODO: Handle union types better? */
2036	while (tag == DW_TAG_structure_type || tag == DW_TAG_union_type) {
2037		member = die_find_child(&mb_type, __die_find_member_offset_cb,
2038					(void *)(long)offset, die_mem);
2039		if (member == NULL)
2040			return NULL;
2041
2042		if (die_get_real_type(member, &mb_type) == NULL)
2043			return NULL;
2044
2045		tag = dwarf_tag(&mb_type);
2046
2047		if (tag == DW_TAG_structure_type || tag == DW_TAG_union_type) {
2048			Dwarf_Word loc;
2049
2050			/* Update offset for the start of the member struct */
2051			if (die_get_data_member_location(member, &loc) == 0)
2052				offset -= loc;
2053		}
2054	}
2055	*die_mem = mb_type;
2056	return die_mem;
2057}
2058
2059/**
2060 * die_deref_ptr_type - Return type info for pointer access
2061 * @ptr_die: a pointer type DIE
2062 * @offset: access offset for the pointer
2063 * @die_mem: a buffer to save the resulting DIE
2064 *
2065 * This function follows the pointer in @ptr_die with given @offset
2066 * and saves the resulting type in @die_mem.  If the pointer points
2067 * a struct type, actual member at the offset would be returned.
2068 */
2069Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset,
2070			      Dwarf_Die *die_mem)
2071{
2072	Dwarf_Die type_die;
2073
2074	if (dwarf_tag(ptr_die) != DW_TAG_pointer_type)
2075		return NULL;
2076
2077	if (die_get_real_type(ptr_die, &type_die) == NULL)
2078		return NULL;
2079
2080	return die_get_member_type(&type_die, offset, die_mem);
2081}