xref: /openbmc/linux/tools/perf/util/probe-finder.c (revision c819e2cf)
1 /*
2  * probe-finder.c : C expression to kprobe event converter
3  *
4  * Written by Masami Hiramatsu <mhiramat@redhat.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  *
20  */
21 
22 #include <sys/utsname.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <unistd.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stdarg.h>
32 #include <dwarf-regs.h>
33 
34 #include <linux/bitops.h>
35 #include "event.h"
36 #include "dso.h"
37 #include "debug.h"
38 #include "intlist.h"
39 #include "util.h"
40 #include "symbol.h"
41 #include "probe-finder.h"
42 
43 /* Kprobe tracer basic type is up to u64 */
44 #define MAX_BASIC_TYPE_BITS	64
45 
46 /* Dwarf FL wrappers */
47 static char *debuginfo_path;	/* Currently dummy */
48 
49 static const Dwfl_Callbacks offline_callbacks = {
50 	.find_debuginfo = dwfl_standard_find_debuginfo,
51 	.debuginfo_path = &debuginfo_path,
52 
53 	.section_address = dwfl_offline_section_address,
54 
55 	/* We use this table for core files too.  */
56 	.find_elf = dwfl_build_id_find_elf,
57 };
58 
59 /* Get a Dwarf from offline image */
60 static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
61 					 const char *path)
62 {
63 	int fd;
64 
65 	fd = open(path, O_RDONLY);
66 	if (fd < 0)
67 		return fd;
68 
69 	dbg->dwfl = dwfl_begin(&offline_callbacks);
70 	if (!dbg->dwfl)
71 		goto error;
72 
73 	dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
74 	if (!dbg->mod)
75 		goto error;
76 
77 	dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
78 	if (!dbg->dbg)
79 		goto error;
80 
81 	return 0;
82 error:
83 	if (dbg->dwfl)
84 		dwfl_end(dbg->dwfl);
85 	else
86 		close(fd);
87 	memset(dbg, 0, sizeof(*dbg));
88 
89 	return -ENOENT;
90 }
91 
92 static struct debuginfo *__debuginfo__new(const char *path)
93 {
94 	struct debuginfo *dbg = zalloc(sizeof(*dbg));
95 	if (!dbg)
96 		return NULL;
97 
98 	if (debuginfo__init_offline_dwarf(dbg, path) < 0)
99 		zfree(&dbg);
100 	if (dbg)
101 		pr_debug("Open Debuginfo file: %s\n", path);
102 	return dbg;
103 }
104 
105 enum dso_binary_type distro_dwarf_types[] = {
106 	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
107 	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
108 	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
109 	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
110 	DSO_BINARY_TYPE__NOT_FOUND,
111 };
112 
113 struct debuginfo *debuginfo__new(const char *path)
114 {
115 	enum dso_binary_type *type;
116 	char buf[PATH_MAX], nil = '\0';
117 	struct dso *dso;
118 	struct debuginfo *dinfo = NULL;
119 
120 	/* Try to open distro debuginfo files */
121 	dso = dso__new(path);
122 	if (!dso)
123 		goto out;
124 
125 	for (type = distro_dwarf_types;
126 	     !dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
127 	     type++) {
128 		if (dso__read_binary_type_filename(dso, *type, &nil,
129 						   buf, PATH_MAX) < 0)
130 			continue;
131 		dinfo = __debuginfo__new(buf);
132 	}
133 	dso__delete(dso);
134 
135 out:
136 	/* if failed to open all distro debuginfo, open given binary */
137 	return dinfo ? : __debuginfo__new(path);
138 }
139 
140 void debuginfo__delete(struct debuginfo *dbg)
141 {
142 	if (dbg) {
143 		if (dbg->dwfl)
144 			dwfl_end(dbg->dwfl);
145 		free(dbg);
146 	}
147 }
148 
149 /*
150  * Probe finder related functions
151  */
152 
153 static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
154 {
155 	struct probe_trace_arg_ref *ref;
156 	ref = zalloc(sizeof(struct probe_trace_arg_ref));
157 	if (ref != NULL)
158 		ref->offset = offs;
159 	return ref;
160 }
161 
162 /*
163  * Convert a location into trace_arg.
164  * If tvar == NULL, this just checks variable can be converted.
165  * If fentry == true and vr_die is a parameter, do huristic search
166  * for the location fuzzed by function entry mcount.
167  */
168 static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
169 				     Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
170 				     struct probe_trace_arg *tvar)
171 {
172 	Dwarf_Attribute attr;
173 	Dwarf_Addr tmp = 0;
174 	Dwarf_Op *op;
175 	size_t nops;
176 	unsigned int regn;
177 	Dwarf_Word offs = 0;
178 	bool ref = false;
179 	const char *regs;
180 	int ret;
181 
182 	if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
183 		goto static_var;
184 
185 	/* TODO: handle more than 1 exprs */
186 	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
187 		return -EINVAL;	/* Broken DIE ? */
188 	if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) {
189 		ret = dwarf_entrypc(sp_die, &tmp);
190 		if (ret || addr != tmp ||
191 		    dwarf_tag(vr_die) != DW_TAG_formal_parameter ||
192 		    dwarf_highpc(sp_die, &tmp))
193 			return -ENOENT;
194 		/*
195 		 * This is fuzzed by fentry mcount. We try to find the
196 		 * parameter location at the earliest address.
197 		 */
198 		for (addr += 1; addr <= tmp; addr++) {
199 			if (dwarf_getlocation_addr(&attr, addr, &op,
200 						   &nops, 1) > 0)
201 				goto found;
202 		}
203 		return -ENOENT;
204 	}
205 found:
206 	if (nops == 0)
207 		/* TODO: Support const_value */
208 		return -ENOENT;
209 
210 	if (op->atom == DW_OP_addr) {
211 static_var:
212 		if (!tvar)
213 			return 0;
214 		/* Static variables on memory (not stack), make @varname */
215 		ret = strlen(dwarf_diename(vr_die));
216 		tvar->value = zalloc(ret + 2);
217 		if (tvar->value == NULL)
218 			return -ENOMEM;
219 		snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
220 		tvar->ref = alloc_trace_arg_ref((long)offs);
221 		if (tvar->ref == NULL)
222 			return -ENOMEM;
223 		return 0;
224 	}
225 
226 	/* If this is based on frame buffer, set the offset */
227 	if (op->atom == DW_OP_fbreg) {
228 		if (fb_ops == NULL)
229 			return -ENOTSUP;
230 		ref = true;
231 		offs = op->number;
232 		op = &fb_ops[0];
233 	}
234 
235 	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
236 		regn = op->atom - DW_OP_breg0;
237 		offs += op->number;
238 		ref = true;
239 	} else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
240 		regn = op->atom - DW_OP_reg0;
241 	} else if (op->atom == DW_OP_bregx) {
242 		regn = op->number;
243 		offs += op->number2;
244 		ref = true;
245 	} else if (op->atom == DW_OP_regx) {
246 		regn = op->number;
247 	} else {
248 		pr_debug("DW_OP %x is not supported.\n", op->atom);
249 		return -ENOTSUP;
250 	}
251 
252 	if (!tvar)
253 		return 0;
254 
255 	regs = get_arch_regstr(regn);
256 	if (!regs) {
257 		/* This should be a bug in DWARF or this tool */
258 		pr_warning("Mapping for the register number %u "
259 			   "missing on this architecture.\n", regn);
260 		return -ERANGE;
261 	}
262 
263 	tvar->value = strdup(regs);
264 	if (tvar->value == NULL)
265 		return -ENOMEM;
266 
267 	if (ref) {
268 		tvar->ref = alloc_trace_arg_ref((long)offs);
269 		if (tvar->ref == NULL)
270 			return -ENOMEM;
271 	}
272 	return 0;
273 }
274 
275 #define BYTES_TO_BITS(nb)	((nb) * BITS_PER_LONG / sizeof(long))
276 
277 static int convert_variable_type(Dwarf_Die *vr_die,
278 				 struct probe_trace_arg *tvar,
279 				 const char *cast)
280 {
281 	struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
282 	Dwarf_Die type;
283 	char buf[16];
284 	char sbuf[STRERR_BUFSIZE];
285 	int bsize, boffs, total;
286 	int ret;
287 
288 	/* TODO: check all types */
289 	if (cast && strcmp(cast, "string") != 0) {
290 		/* Non string type is OK */
291 		tvar->type = strdup(cast);
292 		return (tvar->type == NULL) ? -ENOMEM : 0;
293 	}
294 
295 	bsize = dwarf_bitsize(vr_die);
296 	if (bsize > 0) {
297 		/* This is a bitfield */
298 		boffs = dwarf_bitoffset(vr_die);
299 		total = dwarf_bytesize(vr_die);
300 		if (boffs < 0 || total < 0)
301 			return -ENOENT;
302 		ret = snprintf(buf, 16, "b%d@%d/%zd", bsize, boffs,
303 				BYTES_TO_BITS(total));
304 		goto formatted;
305 	}
306 
307 	if (die_get_real_type(vr_die, &type) == NULL) {
308 		pr_warning("Failed to get a type information of %s.\n",
309 			   dwarf_diename(vr_die));
310 		return -ENOENT;
311 	}
312 
313 	pr_debug("%s type is %s.\n",
314 		 dwarf_diename(vr_die), dwarf_diename(&type));
315 
316 	if (cast && strcmp(cast, "string") == 0) {	/* String type */
317 		ret = dwarf_tag(&type);
318 		if (ret != DW_TAG_pointer_type &&
319 		    ret != DW_TAG_array_type) {
320 			pr_warning("Failed to cast into string: "
321 				   "%s(%s) is not a pointer nor array.\n",
322 				   dwarf_diename(vr_die), dwarf_diename(&type));
323 			return -EINVAL;
324 		}
325 		if (die_get_real_type(&type, &type) == NULL) {
326 			pr_warning("Failed to get a type"
327 				   " information.\n");
328 			return -ENOENT;
329 		}
330 		if (ret == DW_TAG_pointer_type) {
331 			while (*ref_ptr)
332 				ref_ptr = &(*ref_ptr)->next;
333 			/* Add new reference with offset +0 */
334 			*ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
335 			if (*ref_ptr == NULL) {
336 				pr_warning("Out of memory error\n");
337 				return -ENOMEM;
338 			}
339 		}
340 		if (!die_compare_name(&type, "char") &&
341 		    !die_compare_name(&type, "unsigned char")) {
342 			pr_warning("Failed to cast into string: "
343 				   "%s is not (unsigned) char *.\n",
344 				   dwarf_diename(vr_die));
345 			return -EINVAL;
346 		}
347 		tvar->type = strdup(cast);
348 		return (tvar->type == NULL) ? -ENOMEM : 0;
349 	}
350 
351 	ret = dwarf_bytesize(&type);
352 	if (ret <= 0)
353 		/* No size ... try to use default type */
354 		return 0;
355 	ret = BYTES_TO_BITS(ret);
356 
357 	/* Check the bitwidth */
358 	if (ret > MAX_BASIC_TYPE_BITS) {
359 		pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
360 			dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
361 		ret = MAX_BASIC_TYPE_BITS;
362 	}
363 	ret = snprintf(buf, 16, "%c%d",
364 		       die_is_signed_type(&type) ? 's' : 'u', ret);
365 
366 formatted:
367 	if (ret < 0 || ret >= 16) {
368 		if (ret >= 16)
369 			ret = -E2BIG;
370 		pr_warning("Failed to convert variable type: %s\n",
371 			   strerror_r(-ret, sbuf, sizeof(sbuf)));
372 		return ret;
373 	}
374 	tvar->type = strdup(buf);
375 	if (tvar->type == NULL)
376 		return -ENOMEM;
377 	return 0;
378 }
379 
380 static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
381 				    struct perf_probe_arg_field *field,
382 				    struct probe_trace_arg_ref **ref_ptr,
383 				    Dwarf_Die *die_mem)
384 {
385 	struct probe_trace_arg_ref *ref = *ref_ptr;
386 	Dwarf_Die type;
387 	Dwarf_Word offs;
388 	int ret, tag;
389 
390 	pr_debug("converting %s in %s\n", field->name, varname);
391 	if (die_get_real_type(vr_die, &type) == NULL) {
392 		pr_warning("Failed to get the type of %s.\n", varname);
393 		return -ENOENT;
394 	}
395 	pr_debug2("Var real type: (%x)\n", (unsigned)dwarf_dieoffset(&type));
396 	tag = dwarf_tag(&type);
397 
398 	if (field->name[0] == '[' &&
399 	    (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
400 		if (field->next)
401 			/* Save original type for next field */
402 			memcpy(die_mem, &type, sizeof(*die_mem));
403 		/* Get the type of this array */
404 		if (die_get_real_type(&type, &type) == NULL) {
405 			pr_warning("Failed to get the type of %s.\n", varname);
406 			return -ENOENT;
407 		}
408 		pr_debug2("Array real type: (%x)\n",
409 			 (unsigned)dwarf_dieoffset(&type));
410 		if (tag == DW_TAG_pointer_type) {
411 			ref = zalloc(sizeof(struct probe_trace_arg_ref));
412 			if (ref == NULL)
413 				return -ENOMEM;
414 			if (*ref_ptr)
415 				(*ref_ptr)->next = ref;
416 			else
417 				*ref_ptr = ref;
418 		}
419 		ref->offset += dwarf_bytesize(&type) * field->index;
420 		if (!field->next)
421 			/* Save vr_die for converting types */
422 			memcpy(die_mem, vr_die, sizeof(*die_mem));
423 		goto next;
424 	} else if (tag == DW_TAG_pointer_type) {
425 		/* Check the pointer and dereference */
426 		if (!field->ref) {
427 			pr_err("Semantic error: %s must be referred by '->'\n",
428 			       field->name);
429 			return -EINVAL;
430 		}
431 		/* Get the type pointed by this pointer */
432 		if (die_get_real_type(&type, &type) == NULL) {
433 			pr_warning("Failed to get the type of %s.\n", varname);
434 			return -ENOENT;
435 		}
436 		/* Verify it is a data structure  */
437 		tag = dwarf_tag(&type);
438 		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
439 			pr_warning("%s is not a data structure nor an union.\n",
440 				   varname);
441 			return -EINVAL;
442 		}
443 
444 		ref = zalloc(sizeof(struct probe_trace_arg_ref));
445 		if (ref == NULL)
446 			return -ENOMEM;
447 		if (*ref_ptr)
448 			(*ref_ptr)->next = ref;
449 		else
450 			*ref_ptr = ref;
451 	} else {
452 		/* Verify it is a data structure  */
453 		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
454 			pr_warning("%s is not a data structure nor an union.\n",
455 				   varname);
456 			return -EINVAL;
457 		}
458 		if (field->name[0] == '[') {
459 			pr_err("Semantic error: %s is not a pointor"
460 			       " nor array.\n", varname);
461 			return -EINVAL;
462 		}
463 		if (field->ref) {
464 			pr_err("Semantic error: %s must be referred by '.'\n",
465 			       field->name);
466 			return -EINVAL;
467 		}
468 		if (!ref) {
469 			pr_warning("Structure on a register is not "
470 				   "supported yet.\n");
471 			return -ENOTSUP;
472 		}
473 	}
474 
475 	if (die_find_member(&type, field->name, die_mem) == NULL) {
476 		pr_warning("%s(type:%s) has no member %s.\n", varname,
477 			   dwarf_diename(&type), field->name);
478 		return -EINVAL;
479 	}
480 
481 	/* Get the offset of the field */
482 	if (tag == DW_TAG_union_type) {
483 		offs = 0;
484 	} else {
485 		ret = die_get_data_member_location(die_mem, &offs);
486 		if (ret < 0) {
487 			pr_warning("Failed to get the offset of %s.\n",
488 				   field->name);
489 			return ret;
490 		}
491 	}
492 	ref->offset += (long)offs;
493 
494 next:
495 	/* Converting next field */
496 	if (field->next)
497 		return convert_variable_fields(die_mem, field->name,
498 					field->next, &ref, die_mem);
499 	else
500 		return 0;
501 }
502 
503 /* Show a variables in kprobe event format */
504 static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
505 {
506 	Dwarf_Die die_mem;
507 	int ret;
508 
509 	pr_debug("Converting variable %s into trace event.\n",
510 		 dwarf_diename(vr_die));
511 
512 	ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
513 					&pf->sp_die, pf->tvar);
514 	if (ret == -ENOENT || ret == -EINVAL)
515 		pr_err("Failed to find the location of %s at this address.\n"
516 		       " Perhaps, it has been optimized out.\n", pf->pvar->var);
517 	else if (ret == -ENOTSUP)
518 		pr_err("Sorry, we don't support this variable location yet.\n");
519 	else if (ret == 0 && pf->pvar->field) {
520 		ret = convert_variable_fields(vr_die, pf->pvar->var,
521 					      pf->pvar->field, &pf->tvar->ref,
522 					      &die_mem);
523 		vr_die = &die_mem;
524 	}
525 	if (ret == 0)
526 		ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
527 	/* *expr will be cached in libdw. Don't free it. */
528 	return ret;
529 }
530 
531 /* Find a variable in a scope DIE */
532 static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
533 {
534 	Dwarf_Die vr_die;
535 	char buf[32], *ptr;
536 	int ret = 0;
537 
538 	if (!is_c_varname(pf->pvar->var)) {
539 		/* Copy raw parameters */
540 		pf->tvar->value = strdup(pf->pvar->var);
541 		if (pf->tvar->value == NULL)
542 			return -ENOMEM;
543 		if (pf->pvar->type) {
544 			pf->tvar->type = strdup(pf->pvar->type);
545 			if (pf->tvar->type == NULL)
546 				return -ENOMEM;
547 		}
548 		if (pf->pvar->name) {
549 			pf->tvar->name = strdup(pf->pvar->name);
550 			if (pf->tvar->name == NULL)
551 				return -ENOMEM;
552 		} else
553 			pf->tvar->name = NULL;
554 		return 0;
555 	}
556 
557 	if (pf->pvar->name)
558 		pf->tvar->name = strdup(pf->pvar->name);
559 	else {
560 		ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
561 		if (ret < 0)
562 			return ret;
563 		ptr = strchr(buf, ':');	/* Change type separator to _ */
564 		if (ptr)
565 			*ptr = '_';
566 		pf->tvar->name = strdup(buf);
567 	}
568 	if (pf->tvar->name == NULL)
569 		return -ENOMEM;
570 
571 	pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
572 	/* Search child die for local variables and parameters. */
573 	if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
574 		/* Search again in global variables */
575 		if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 0, &vr_die))
576 			pr_warning("Failed to find '%s' in this function.\n",
577 				   pf->pvar->var);
578 			ret = -ENOENT;
579 	}
580 	if (ret >= 0)
581 		ret = convert_variable(&vr_die, pf);
582 
583 	return ret;
584 }
585 
586 /* Convert subprogram DIE to trace point */
587 static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
588 				  Dwarf_Addr paddr, bool retprobe,
589 				  struct probe_trace_point *tp)
590 {
591 	Dwarf_Addr eaddr, highaddr;
592 	GElf_Sym sym;
593 	const char *symbol;
594 
595 	/* Verify the address is correct */
596 	if (dwarf_entrypc(sp_die, &eaddr) != 0) {
597 		pr_warning("Failed to get entry address of %s\n",
598 			   dwarf_diename(sp_die));
599 		return -ENOENT;
600 	}
601 	if (dwarf_highpc(sp_die, &highaddr) != 0) {
602 		pr_warning("Failed to get end address of %s\n",
603 			   dwarf_diename(sp_die));
604 		return -ENOENT;
605 	}
606 	if (paddr > highaddr) {
607 		pr_warning("Offset specified is greater than size of %s\n",
608 			   dwarf_diename(sp_die));
609 		return -EINVAL;
610 	}
611 
612 	symbol = dwarf_diename(sp_die);
613 	if (!symbol) {
614 		/* Try to get the symbol name from symtab */
615 		symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
616 		if (!symbol) {
617 			pr_warning("Failed to find symbol at 0x%lx\n",
618 				   (unsigned long)paddr);
619 			return -ENOENT;
620 		}
621 		eaddr = sym.st_value;
622 	}
623 	tp->offset = (unsigned long)(paddr - eaddr);
624 	tp->address = (unsigned long)paddr;
625 	tp->symbol = strdup(symbol);
626 	if (!tp->symbol)
627 		return -ENOMEM;
628 
629 	/* Return probe must be on the head of a subprogram */
630 	if (retprobe) {
631 		if (eaddr != paddr) {
632 			pr_warning("Return probe must be on the head of"
633 				   " a real function.\n");
634 			return -EINVAL;
635 		}
636 		tp->retprobe = true;
637 	}
638 
639 	return 0;
640 }
641 
642 /* Call probe_finder callback with scope DIE */
643 static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
644 {
645 	Dwarf_Attribute fb_attr;
646 	size_t nops;
647 	int ret;
648 
649 	if (!sc_die) {
650 		pr_err("Caller must pass a scope DIE. Program error.\n");
651 		return -EINVAL;
652 	}
653 
654 	/* If not a real subprogram, find a real one */
655 	if (!die_is_func_def(sc_die)) {
656 		if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
657 			pr_warning("Failed to find probe point in any "
658 				   "functions.\n");
659 			return -ENOENT;
660 		}
661 	} else
662 		memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
663 
664 	/* Get the frame base attribute/ops from subprogram */
665 	dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
666 	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
667 	if (ret <= 0 || nops == 0) {
668 		pf->fb_ops = NULL;
669 #if _ELFUTILS_PREREQ(0, 142)
670 	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
671 		   pf->cfi != NULL) {
672 		Dwarf_Frame *frame;
673 		if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
674 		    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
675 			pr_warning("Failed to get call frame on 0x%jx\n",
676 				   (uintmax_t)pf->addr);
677 			return -ENOENT;
678 		}
679 #endif
680 	}
681 
682 	/* Call finder's callback handler */
683 	ret = pf->callback(sc_die, pf);
684 
685 	/* *pf->fb_ops will be cached in libdw. Don't free it. */
686 	pf->fb_ops = NULL;
687 
688 	return ret;
689 }
690 
691 struct find_scope_param {
692 	const char *function;
693 	const char *file;
694 	int line;
695 	int diff;
696 	Dwarf_Die *die_mem;
697 	bool found;
698 };
699 
700 static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
701 {
702 	struct find_scope_param *fsp = data;
703 	const char *file;
704 	int lno;
705 
706 	/* Skip if declared file name does not match */
707 	if (fsp->file) {
708 		file = dwarf_decl_file(fn_die);
709 		if (!file || strcmp(fsp->file, file) != 0)
710 			return 0;
711 	}
712 	/* If the function name is given, that's what user expects */
713 	if (fsp->function) {
714 		if (die_compare_name(fn_die, fsp->function)) {
715 			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
716 			fsp->found = true;
717 			return 1;
718 		}
719 	} else {
720 		/* With the line number, find the nearest declared DIE */
721 		dwarf_decl_line(fn_die, &lno);
722 		if (lno < fsp->line && fsp->diff > fsp->line - lno) {
723 			/* Keep a candidate and continue */
724 			fsp->diff = fsp->line - lno;
725 			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
726 			fsp->found = true;
727 		}
728 	}
729 	return 0;
730 }
731 
732 /* Find an appropriate scope fits to given conditions */
733 static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
734 {
735 	struct find_scope_param fsp = {
736 		.function = pf->pev->point.function,
737 		.file = pf->fname,
738 		.line = pf->lno,
739 		.diff = INT_MAX,
740 		.die_mem = die_mem,
741 		.found = false,
742 	};
743 
744 	cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp);
745 
746 	return fsp.found ? die_mem : NULL;
747 }
748 
749 static int probe_point_line_walker(const char *fname, int lineno,
750 				   Dwarf_Addr addr, void *data)
751 {
752 	struct probe_finder *pf = data;
753 	Dwarf_Die *sc_die, die_mem;
754 	int ret;
755 
756 	if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
757 		return 0;
758 
759 	pf->addr = addr;
760 	sc_die = find_best_scope(pf, &die_mem);
761 	if (!sc_die) {
762 		pr_warning("Failed to find scope of probe point.\n");
763 		return -ENOENT;
764 	}
765 
766 	ret = call_probe_finder(sc_die, pf);
767 
768 	/* Continue if no error, because the line will be in inline function */
769 	return ret < 0 ? ret : 0;
770 }
771 
772 /* Find probe point from its line number */
773 static int find_probe_point_by_line(struct probe_finder *pf)
774 {
775 	return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
776 }
777 
778 /* Find lines which match lazy pattern */
779 static int find_lazy_match_lines(struct intlist *list,
780 				 const char *fname, const char *pat)
781 {
782 	FILE *fp;
783 	char *line = NULL;
784 	size_t line_len;
785 	ssize_t len;
786 	int count = 0, linenum = 1;
787 	char sbuf[STRERR_BUFSIZE];
788 
789 	fp = fopen(fname, "r");
790 	if (!fp) {
791 		pr_warning("Failed to open %s: %s\n", fname,
792 			   strerror_r(errno, sbuf, sizeof(sbuf)));
793 		return -errno;
794 	}
795 
796 	while ((len = getline(&line, &line_len, fp)) > 0) {
797 
798 		if (line[len - 1] == '\n')
799 			line[len - 1] = '\0';
800 
801 		if (strlazymatch(line, pat)) {
802 			intlist__add(list, linenum);
803 			count++;
804 		}
805 		linenum++;
806 	}
807 
808 	if (ferror(fp))
809 		count = -errno;
810 	free(line);
811 	fclose(fp);
812 
813 	if (count == 0)
814 		pr_debug("No matched lines found in %s.\n", fname);
815 	return count;
816 }
817 
818 static int probe_point_lazy_walker(const char *fname, int lineno,
819 				   Dwarf_Addr addr, void *data)
820 {
821 	struct probe_finder *pf = data;
822 	Dwarf_Die *sc_die, die_mem;
823 	int ret;
824 
825 	if (!intlist__has_entry(pf->lcache, lineno) ||
826 	    strtailcmp(fname, pf->fname) != 0)
827 		return 0;
828 
829 	pr_debug("Probe line found: line:%d addr:0x%llx\n",
830 		 lineno, (unsigned long long)addr);
831 	pf->addr = addr;
832 	pf->lno = lineno;
833 	sc_die = find_best_scope(pf, &die_mem);
834 	if (!sc_die) {
835 		pr_warning("Failed to find scope of probe point.\n");
836 		return -ENOENT;
837 	}
838 
839 	ret = call_probe_finder(sc_die, pf);
840 
841 	/*
842 	 * Continue if no error, because the lazy pattern will match
843 	 * to other lines
844 	 */
845 	return ret < 0 ? ret : 0;
846 }
847 
848 /* Find probe points from lazy pattern  */
849 static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
850 {
851 	int ret = 0;
852 
853 	if (intlist__empty(pf->lcache)) {
854 		/* Matching lazy line pattern */
855 		ret = find_lazy_match_lines(pf->lcache, pf->fname,
856 					    pf->pev->point.lazy_line);
857 		if (ret <= 0)
858 			return ret;
859 	}
860 
861 	return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
862 }
863 
864 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
865 {
866 	struct probe_finder *pf = data;
867 	struct perf_probe_point *pp = &pf->pev->point;
868 	Dwarf_Addr addr;
869 	int ret;
870 
871 	if (pp->lazy_line)
872 		ret = find_probe_point_lazy(in_die, pf);
873 	else {
874 		/* Get probe address */
875 		if (dwarf_entrypc(in_die, &addr) != 0) {
876 			pr_warning("Failed to get entry address of %s.\n",
877 				   dwarf_diename(in_die));
878 			return -ENOENT;
879 		}
880 		pf->addr = addr;
881 		pf->addr += pp->offset;
882 		pr_debug("found inline addr: 0x%jx\n",
883 			 (uintmax_t)pf->addr);
884 
885 		ret = call_probe_finder(in_die, pf);
886 	}
887 
888 	return ret;
889 }
890 
891 /* Callback parameter with return value for libdw */
892 struct dwarf_callback_param {
893 	void *data;
894 	int retval;
895 };
896 
897 /* Search function from function name */
898 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
899 {
900 	struct dwarf_callback_param *param = data;
901 	struct probe_finder *pf = param->data;
902 	struct perf_probe_point *pp = &pf->pev->point;
903 
904 	/* Check tag and diename */
905 	if (!die_is_func_def(sp_die) ||
906 	    !die_compare_name(sp_die, pp->function))
907 		return DWARF_CB_OK;
908 
909 	/* Check declared file */
910 	if (pp->file && strtailcmp(pp->file, dwarf_decl_file(sp_die)))
911 		return DWARF_CB_OK;
912 
913 	pf->fname = dwarf_decl_file(sp_die);
914 	if (pp->line) { /* Function relative line */
915 		dwarf_decl_line(sp_die, &pf->lno);
916 		pf->lno += pp->line;
917 		param->retval = find_probe_point_by_line(pf);
918 	} else if (die_is_func_instance(sp_die)) {
919 		/* Instances always have the entry address */
920 		dwarf_entrypc(sp_die, &pf->addr);
921 		/* Real function */
922 		if (pp->lazy_line)
923 			param->retval = find_probe_point_lazy(sp_die, pf);
924 		else {
925 			pf->addr += pp->offset;
926 			/* TODO: Check the address in this function */
927 			param->retval = call_probe_finder(sp_die, pf);
928 		}
929 	} else
930 		/* Inlined function: search instances */
931 		param->retval = die_walk_instances(sp_die,
932 					probe_point_inline_cb, (void *)pf);
933 
934 	return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
935 }
936 
937 static int find_probe_point_by_func(struct probe_finder *pf)
938 {
939 	struct dwarf_callback_param _param = {.data = (void *)pf,
940 					      .retval = 0};
941 	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
942 	return _param.retval;
943 }
944 
945 struct pubname_callback_param {
946 	char *function;
947 	char *file;
948 	Dwarf_Die *cu_die;
949 	Dwarf_Die *sp_die;
950 	int found;
951 };
952 
953 static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data)
954 {
955 	struct pubname_callback_param *param = data;
956 
957 	if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) {
958 		if (dwarf_tag(param->sp_die) != DW_TAG_subprogram)
959 			return DWARF_CB_OK;
960 
961 		if (die_compare_name(param->sp_die, param->function)) {
962 			if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die))
963 				return DWARF_CB_OK;
964 
965 			if (param->file &&
966 			    strtailcmp(param->file, dwarf_decl_file(param->sp_die)))
967 				return DWARF_CB_OK;
968 
969 			param->found = 1;
970 			return DWARF_CB_ABORT;
971 		}
972 	}
973 
974 	return DWARF_CB_OK;
975 }
976 
977 /* Find probe points from debuginfo */
978 static int debuginfo__find_probes(struct debuginfo *dbg,
979 				  struct probe_finder *pf)
980 {
981 	struct perf_probe_point *pp = &pf->pev->point;
982 	Dwarf_Off off, noff;
983 	size_t cuhl;
984 	Dwarf_Die *diep;
985 	int ret = 0;
986 
987 #if _ELFUTILS_PREREQ(0, 142)
988 	Elf *elf;
989 	GElf_Ehdr ehdr;
990 	GElf_Shdr shdr;
991 
992 	/* Get the call frame information from this dwarf */
993 	elf = dwarf_getelf(dbg->dbg);
994 	if (elf == NULL)
995 		return -EINVAL;
996 
997 	if (gelf_getehdr(elf, &ehdr) == NULL)
998 		return -EINVAL;
999 
1000 	if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
1001 	    shdr.sh_type == SHT_PROGBITS) {
1002 		pf->cfi = dwarf_getcfi_elf(elf);
1003 	} else {
1004 		pf->cfi = dwarf_getcfi(dbg->dbg);
1005 	}
1006 #endif
1007 
1008 	off = 0;
1009 	pf->lcache = intlist__new(NULL);
1010 	if (!pf->lcache)
1011 		return -ENOMEM;
1012 
1013 	/* Fastpath: lookup by function name from .debug_pubnames section */
1014 	if (pp->function) {
1015 		struct pubname_callback_param pubname_param = {
1016 			.function = pp->function,
1017 			.file	  = pp->file,
1018 			.cu_die	  = &pf->cu_die,
1019 			.sp_die	  = &pf->sp_die,
1020 			.found	  = 0,
1021 		};
1022 		struct dwarf_callback_param probe_param = {
1023 			.data = pf,
1024 		};
1025 
1026 		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1027 				  &pubname_param, 0);
1028 		if (pubname_param.found) {
1029 			ret = probe_point_search_cb(&pf->sp_die, &probe_param);
1030 			if (ret)
1031 				goto found;
1032 		}
1033 	}
1034 
1035 	/* Loop on CUs (Compilation Unit) */
1036 	while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
1037 		/* Get the DIE(Debugging Information Entry) of this CU */
1038 		diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die);
1039 		if (!diep)
1040 			continue;
1041 
1042 		/* Check if target file is included. */
1043 		if (pp->file)
1044 			pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1045 		else
1046 			pf->fname = NULL;
1047 
1048 		if (!pp->file || pf->fname) {
1049 			if (pp->function)
1050 				ret = find_probe_point_by_func(pf);
1051 			else if (pp->lazy_line)
1052 				ret = find_probe_point_lazy(NULL, pf);
1053 			else {
1054 				pf->lno = pp->line;
1055 				ret = find_probe_point_by_line(pf);
1056 			}
1057 			if (ret < 0)
1058 				break;
1059 		}
1060 		off = noff;
1061 	}
1062 
1063 found:
1064 	intlist__delete(pf->lcache);
1065 	pf->lcache = NULL;
1066 
1067 	return ret;
1068 }
1069 
1070 struct local_vars_finder {
1071 	struct probe_finder *pf;
1072 	struct perf_probe_arg *args;
1073 	int max_args;
1074 	int nargs;
1075 	int ret;
1076 };
1077 
1078 /* Collect available variables in this scope */
1079 static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
1080 {
1081 	struct local_vars_finder *vf = data;
1082 	struct probe_finder *pf = vf->pf;
1083 	int tag;
1084 
1085 	tag = dwarf_tag(die_mem);
1086 	if (tag == DW_TAG_formal_parameter ||
1087 	    tag == DW_TAG_variable) {
1088 		if (convert_variable_location(die_mem, vf->pf->addr,
1089 					      vf->pf->fb_ops, &pf->sp_die,
1090 					      NULL) == 0) {
1091 			vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
1092 			if (vf->args[vf->nargs].var == NULL) {
1093 				vf->ret = -ENOMEM;
1094 				return DIE_FIND_CB_END;
1095 			}
1096 			pr_debug(" %s", vf->args[vf->nargs].var);
1097 			vf->nargs++;
1098 		}
1099 	}
1100 
1101 	if (dwarf_haspc(die_mem, vf->pf->addr))
1102 		return DIE_FIND_CB_CONTINUE;
1103 	else
1104 		return DIE_FIND_CB_SIBLING;
1105 }
1106 
1107 static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf,
1108 			     struct perf_probe_arg *args)
1109 {
1110 	Dwarf_Die die_mem;
1111 	int i;
1112 	int n = 0;
1113 	struct local_vars_finder vf = {.pf = pf, .args = args,
1114 				.max_args = MAX_PROBE_ARGS, .ret = 0};
1115 
1116 	for (i = 0; i < pf->pev->nargs; i++) {
1117 		/* var never be NULL */
1118 		if (strcmp(pf->pev->args[i].var, "$vars") == 0) {
1119 			pr_debug("Expanding $vars into:");
1120 			vf.nargs = n;
1121 			/* Special local variables */
1122 			die_find_child(sc_die, copy_variables_cb, (void *)&vf,
1123 				       &die_mem);
1124 			pr_debug(" (%d)\n", vf.nargs - n);
1125 			if (vf.ret < 0)
1126 				return vf.ret;
1127 			n = vf.nargs;
1128 		} else {
1129 			/* Copy normal argument */
1130 			args[n] = pf->pev->args[i];
1131 			n++;
1132 		}
1133 	}
1134 	return n;
1135 }
1136 
1137 /* Add a found probe point into trace event list */
1138 static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1139 {
1140 	struct trace_event_finder *tf =
1141 			container_of(pf, struct trace_event_finder, pf);
1142 	struct probe_trace_event *tev;
1143 	struct perf_probe_arg *args;
1144 	int ret, i;
1145 
1146 	/* Check number of tevs */
1147 	if (tf->ntevs == tf->max_tevs) {
1148 		pr_warning("Too many( > %d) probe point found.\n",
1149 			   tf->max_tevs);
1150 		return -ERANGE;
1151 	}
1152 	tev = &tf->tevs[tf->ntevs++];
1153 
1154 	/* Trace point should be converted from subprogram DIE */
1155 	ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
1156 				     pf->pev->point.retprobe, &tev->point);
1157 	if (ret < 0)
1158 		return ret;
1159 
1160 	pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
1161 		 tev->point.offset);
1162 
1163 	/* Expand special probe argument if exist */
1164 	args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
1165 	if (args == NULL)
1166 		return -ENOMEM;
1167 
1168 	ret = expand_probe_args(sc_die, pf, args);
1169 	if (ret < 0)
1170 		goto end;
1171 
1172 	tev->nargs = ret;
1173 	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1174 	if (tev->args == NULL) {
1175 		ret = -ENOMEM;
1176 		goto end;
1177 	}
1178 
1179 	/* Find each argument */
1180 	for (i = 0; i < tev->nargs; i++) {
1181 		pf->pvar = &args[i];
1182 		pf->tvar = &tev->args[i];
1183 		/* Variable should be found from scope DIE */
1184 		ret = find_variable(sc_die, pf);
1185 		if (ret != 0)
1186 			break;
1187 	}
1188 
1189 end:
1190 	free(args);
1191 	return ret;
1192 }
1193 
1194 /* Find probe_trace_events specified by perf_probe_event from debuginfo */
1195 int debuginfo__find_trace_events(struct debuginfo *dbg,
1196 				 struct perf_probe_event *pev,
1197 				 struct probe_trace_event **tevs, int max_tevs)
1198 {
1199 	struct trace_event_finder tf = {
1200 			.pf = {.pev = pev, .callback = add_probe_trace_event},
1201 			.mod = dbg->mod, .max_tevs = max_tevs};
1202 	int ret;
1203 
1204 	/* Allocate result tevs array */
1205 	*tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
1206 	if (*tevs == NULL)
1207 		return -ENOMEM;
1208 
1209 	tf.tevs = *tevs;
1210 	tf.ntevs = 0;
1211 
1212 	ret = debuginfo__find_probes(dbg, &tf.pf);
1213 	if (ret < 0) {
1214 		zfree(tevs);
1215 		return ret;
1216 	}
1217 
1218 	return (ret < 0) ? ret : tf.ntevs;
1219 }
1220 
1221 #define MAX_VAR_LEN 64
1222 
1223 /* Collect available variables in this scope */
1224 static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
1225 {
1226 	struct available_var_finder *af = data;
1227 	struct variable_list *vl;
1228 	char buf[MAX_VAR_LEN];
1229 	int tag, ret;
1230 
1231 	vl = &af->vls[af->nvls - 1];
1232 
1233 	tag = dwarf_tag(die_mem);
1234 	if (tag == DW_TAG_formal_parameter ||
1235 	    tag == DW_TAG_variable) {
1236 		ret = convert_variable_location(die_mem, af->pf.addr,
1237 						af->pf.fb_ops, &af->pf.sp_die,
1238 						NULL);
1239 		if (ret == 0) {
1240 			ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
1241 			pr_debug2("Add new var: %s\n", buf);
1242 			if (ret > 0)
1243 				strlist__add(vl->vars, buf);
1244 		}
1245 	}
1246 
1247 	if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1248 		return DIE_FIND_CB_CONTINUE;
1249 	else
1250 		return DIE_FIND_CB_SIBLING;
1251 }
1252 
1253 /* Add a found vars into available variables list */
1254 static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
1255 {
1256 	struct available_var_finder *af =
1257 			container_of(pf, struct available_var_finder, pf);
1258 	struct variable_list *vl;
1259 	Dwarf_Die die_mem;
1260 	int ret;
1261 
1262 	/* Check number of tevs */
1263 	if (af->nvls == af->max_vls) {
1264 		pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
1265 		return -ERANGE;
1266 	}
1267 	vl = &af->vls[af->nvls++];
1268 
1269 	/* Trace point should be converted from subprogram DIE */
1270 	ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
1271 				     pf->pev->point.retprobe, &vl->point);
1272 	if (ret < 0)
1273 		return ret;
1274 
1275 	pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
1276 		 vl->point.offset);
1277 
1278 	/* Find local variables */
1279 	vl->vars = strlist__new(true, NULL);
1280 	if (vl->vars == NULL)
1281 		return -ENOMEM;
1282 	af->child = true;
1283 	die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1284 
1285 	/* Find external variables */
1286 	if (!af->externs)
1287 		goto out;
1288 	/* Don't need to search child DIE for externs. */
1289 	af->child = false;
1290 	die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
1291 
1292 out:
1293 	if (strlist__empty(vl->vars)) {
1294 		strlist__delete(vl->vars);
1295 		vl->vars = NULL;
1296 	}
1297 
1298 	return ret;
1299 }
1300 
1301 /*
1302  * Find available variables at given probe point
1303  * Return the number of found probe points. Return 0 if there is no
1304  * matched probe point. Return <0 if an error occurs.
1305  */
1306 int debuginfo__find_available_vars_at(struct debuginfo *dbg,
1307 				      struct perf_probe_event *pev,
1308 				      struct variable_list **vls,
1309 				      int max_vls, bool externs)
1310 {
1311 	struct available_var_finder af = {
1312 			.pf = {.pev = pev, .callback = add_available_vars},
1313 			.mod = dbg->mod,
1314 			.max_vls = max_vls, .externs = externs};
1315 	int ret;
1316 
1317 	/* Allocate result vls array */
1318 	*vls = zalloc(sizeof(struct variable_list) * max_vls);
1319 	if (*vls == NULL)
1320 		return -ENOMEM;
1321 
1322 	af.vls = *vls;
1323 	af.nvls = 0;
1324 
1325 	ret = debuginfo__find_probes(dbg, &af.pf);
1326 	if (ret < 0) {
1327 		/* Free vlist for error */
1328 		while (af.nvls--) {
1329 			zfree(&af.vls[af.nvls].point.symbol);
1330 			strlist__delete(af.vls[af.nvls].vars);
1331 		}
1332 		zfree(vls);
1333 		return ret;
1334 	}
1335 
1336 	return (ret < 0) ? ret : af.nvls;
1337 }
1338 
1339 /* Reverse search */
1340 int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
1341 				struct perf_probe_point *ppt)
1342 {
1343 	Dwarf_Die cudie, spdie, indie;
1344 	Dwarf_Addr _addr = 0, baseaddr = 0;
1345 	const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
1346 	int baseline = 0, lineno = 0, ret = 0;
1347 
1348 	/* Adjust address with bias */
1349 	addr += dbg->bias;
1350 
1351 	/* Find cu die */
1352 	if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr - dbg->bias, &cudie)) {
1353 		pr_warning("Failed to find debug information for address %lx\n",
1354 			   addr);
1355 		ret = -EINVAL;
1356 		goto end;
1357 	}
1358 
1359 	/* Find a corresponding line (filename and lineno) */
1360 	cu_find_lineinfo(&cudie, addr, &fname, &lineno);
1361 	/* Don't care whether it failed or not */
1362 
1363 	/* Find a corresponding function (name, baseline and baseaddr) */
1364 	if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
1365 		/* Get function entry information */
1366 		func = basefunc = dwarf_diename(&spdie);
1367 		if (!func ||
1368 		    dwarf_entrypc(&spdie, &baseaddr) != 0 ||
1369 		    dwarf_decl_line(&spdie, &baseline) != 0) {
1370 			lineno = 0;
1371 			goto post;
1372 		}
1373 
1374 		fname = dwarf_decl_file(&spdie);
1375 		if (addr == (unsigned long)baseaddr) {
1376 			/* Function entry - Relative line number is 0 */
1377 			lineno = baseline;
1378 			goto post;
1379 		}
1380 
1381 		/* Track down the inline functions step by step */
1382 		while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr,
1383 						&indie)) {
1384 			/* There is an inline function */
1385 			if (dwarf_entrypc(&indie, &_addr) == 0 &&
1386 			    _addr == addr) {
1387 				/*
1388 				 * addr is at an inline function entry.
1389 				 * In this case, lineno should be the call-site
1390 				 * line number. (overwrite lineinfo)
1391 				 */
1392 				lineno = die_get_call_lineno(&indie);
1393 				fname = die_get_call_file(&indie);
1394 				break;
1395 			} else {
1396 				/*
1397 				 * addr is in an inline function body.
1398 				 * Since lineno points one of the lines
1399 				 * of the inline function, baseline should
1400 				 * be the entry line of the inline function.
1401 				 */
1402 				tmp = dwarf_diename(&indie);
1403 				if (!tmp ||
1404 				    dwarf_decl_line(&indie, &baseline) != 0)
1405 					break;
1406 				func = tmp;
1407 				spdie = indie;
1408 			}
1409 		}
1410 		/* Verify the lineno and baseline are in a same file */
1411 		tmp = dwarf_decl_file(&spdie);
1412 		if (!tmp || strcmp(tmp, fname) != 0)
1413 			lineno = 0;
1414 	}
1415 
1416 post:
1417 	/* Make a relative line number or an offset */
1418 	if (lineno)
1419 		ppt->line = lineno - baseline;
1420 	else if (basefunc) {
1421 		ppt->offset = addr - (unsigned long)baseaddr;
1422 		func = basefunc;
1423 	}
1424 
1425 	/* Duplicate strings */
1426 	if (func) {
1427 		ppt->function = strdup(func);
1428 		if (ppt->function == NULL) {
1429 			ret = -ENOMEM;
1430 			goto end;
1431 		}
1432 	}
1433 	if (fname) {
1434 		ppt->file = strdup(fname);
1435 		if (ppt->file == NULL) {
1436 			zfree(&ppt->function);
1437 			ret = -ENOMEM;
1438 			goto end;
1439 		}
1440 	}
1441 end:
1442 	if (ret == 0 && (fname || func))
1443 		ret = 1;	/* Found a point */
1444 	return ret;
1445 }
1446 
1447 /* Add a line and store the src path */
1448 static int line_range_add_line(const char *src, unsigned int lineno,
1449 			       struct line_range *lr)
1450 {
1451 	/* Copy source path */
1452 	if (!lr->path) {
1453 		lr->path = strdup(src);
1454 		if (lr->path == NULL)
1455 			return -ENOMEM;
1456 	}
1457 	return intlist__add(lr->line_list, lineno);
1458 }
1459 
1460 static int line_range_walk_cb(const char *fname, int lineno,
1461 			      Dwarf_Addr addr __maybe_unused,
1462 			      void *data)
1463 {
1464 	struct line_finder *lf = data;
1465 	int err;
1466 
1467 	if ((strtailcmp(fname, lf->fname) != 0) ||
1468 	    (lf->lno_s > lineno || lf->lno_e < lineno))
1469 		return 0;
1470 
1471 	err = line_range_add_line(fname, lineno, lf->lr);
1472 	if (err < 0 && err != -EEXIST)
1473 		return err;
1474 
1475 	return 0;
1476 }
1477 
1478 /* Find line range from its line number */
1479 static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1480 {
1481 	int ret;
1482 
1483 	ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
1484 
1485 	/* Update status */
1486 	if (ret >= 0)
1487 		if (!intlist__empty(lf->lr->line_list))
1488 			ret = lf->found = 1;
1489 		else
1490 			ret = 0;	/* Lines are not found */
1491 	else {
1492 		zfree(&lf->lr->path);
1493 	}
1494 	return ret;
1495 }
1496 
1497 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
1498 {
1499 	int ret = find_line_range_by_line(in_die, data);
1500 
1501 	/*
1502 	 * We have to check all instances of inlined function, because
1503 	 * some execution paths can be optimized out depends on the
1504 	 * function argument of instances. However, if an error occurs,
1505 	 * it should be handled by the caller.
1506 	 */
1507 	return ret < 0 ? ret : 0;
1508 }
1509 
1510 /* Search function definition from function name */
1511 static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1512 {
1513 	struct dwarf_callback_param *param = data;
1514 	struct line_finder *lf = param->data;
1515 	struct line_range *lr = lf->lr;
1516 
1517 	/* Check declared file */
1518 	if (lr->file && strtailcmp(lr->file, dwarf_decl_file(sp_die)))
1519 		return DWARF_CB_OK;
1520 
1521 	if (die_is_func_def(sp_die) &&
1522 	    die_compare_name(sp_die, lr->function)) {
1523 		lf->fname = dwarf_decl_file(sp_die);
1524 		dwarf_decl_line(sp_die, &lr->offset);
1525 		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1526 		lf->lno_s = lr->offset + lr->start;
1527 		if (lf->lno_s < 0)	/* Overflow */
1528 			lf->lno_s = INT_MAX;
1529 		lf->lno_e = lr->offset + lr->end;
1530 		if (lf->lno_e < 0)	/* Overflow */
1531 			lf->lno_e = INT_MAX;
1532 		pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1533 		lr->start = lf->lno_s;
1534 		lr->end = lf->lno_e;
1535 		if (!die_is_func_instance(sp_die))
1536 			param->retval = die_walk_instances(sp_die,
1537 						line_range_inline_cb, lf);
1538 		else
1539 			param->retval = find_line_range_by_line(sp_die, lf);
1540 		return DWARF_CB_ABORT;
1541 	}
1542 	return DWARF_CB_OK;
1543 }
1544 
1545 static int find_line_range_by_func(struct line_finder *lf)
1546 {
1547 	struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1548 	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
1549 	return param.retval;
1550 }
1551 
1552 int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr)
1553 {
1554 	struct line_finder lf = {.lr = lr, .found = 0};
1555 	int ret = 0;
1556 	Dwarf_Off off = 0, noff;
1557 	size_t cuhl;
1558 	Dwarf_Die *diep;
1559 	const char *comp_dir;
1560 
1561 	/* Fastpath: lookup by function name from .debug_pubnames section */
1562 	if (lr->function) {
1563 		struct pubname_callback_param pubname_param = {
1564 			.function = lr->function, .file = lr->file,
1565 			.cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0};
1566 		struct dwarf_callback_param line_range_param = {
1567 			.data = (void *)&lf, .retval = 0};
1568 
1569 		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1570 				  &pubname_param, 0);
1571 		if (pubname_param.found) {
1572 			line_range_search_cb(&lf.sp_die, &line_range_param);
1573 			if (lf.found)
1574 				goto found;
1575 		}
1576 	}
1577 
1578 	/* Loop on CUs (Compilation Unit) */
1579 	while (!lf.found && ret >= 0) {
1580 		if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl,
1581 				 NULL, NULL, NULL) != 0)
1582 			break;
1583 
1584 		/* Get the DIE(Debugging Information Entry) of this CU */
1585 		diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die);
1586 		if (!diep)
1587 			continue;
1588 
1589 		/* Check if target file is included. */
1590 		if (lr->file)
1591 			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1592 		else
1593 			lf.fname = 0;
1594 
1595 		if (!lr->file || lf.fname) {
1596 			if (lr->function)
1597 				ret = find_line_range_by_func(&lf);
1598 			else {
1599 				lf.lno_s = lr->start;
1600 				lf.lno_e = lr->end;
1601 				ret = find_line_range_by_line(NULL, &lf);
1602 			}
1603 		}
1604 		off = noff;
1605 	}
1606 
1607 found:
1608 	/* Store comp_dir */
1609 	if (lf.found) {
1610 		comp_dir = cu_get_comp_dir(&lf.cu_die);
1611 		if (comp_dir) {
1612 			lr->comp_dir = strdup(comp_dir);
1613 			if (!lr->comp_dir)
1614 				ret = -ENOMEM;
1615 		}
1616 	}
1617 
1618 	pr_debug("path: %s\n", lr->path);
1619 	return (ret < 0) ? ret : lf.found;
1620 }
1621 
1622