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