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