probe-finder.c 19.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * probe-finder.c : C expression to kprobe event converter
 *
 * Written by Masami Hiramatsu <mhiramat@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#include <sys/utsname.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
34

35
#include "string.h"
36 37
#include "event.h"
#include "debug.h"
38
#include "util.h"
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
#include "probe-finder.h"


/*
 * Generic dwarf analysis helpers
 */

#define X86_32_MAX_REGS 8
const char *x86_32_regs_table[X86_32_MAX_REGS] = {
	"%ax",
	"%cx",
	"%dx",
	"%bx",
	"$stack",	/* Stack address instead of %sp */
	"%bp",
	"%si",
	"%di",
};

#define X86_64_MAX_REGS 16
const char *x86_64_regs_table[X86_64_MAX_REGS] = {
	"%ax",
	"%dx",
	"%cx",
	"%bx",
	"%si",
	"%di",
	"%bp",
	"%sp",
	"%r8",
	"%r9",
	"%r10",
	"%r11",
	"%r12",
	"%r13",
	"%r14",
	"%r15",
};

/* TODO: switching by dwarf address size */
#ifdef __x86_64__
#define ARCH_MAX_REGS X86_64_MAX_REGS
#define arch_regs_table x86_64_regs_table
#else
#define ARCH_MAX_REGS X86_32_MAX_REGS
#define arch_regs_table x86_32_regs_table
#endif

/* Return architecture dependent register string (for kprobe-tracer) */
static const char *get_arch_regstr(unsigned int n)
{
	return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
}

/*
 * Compare the tail of two strings.
 * Return 0 if whole of either string is same as another's tail part.
 */
static int strtailcmp(const char *s1, const char *s2)
{
	int i1 = strlen(s1);
	int i2 = strlen(s2);
101
	while (--i1 >= 0 && --i2 >= 0) {
102 103 104 105 106 107
		if (s1[i1] != s2[i2])
			return s1[i1] - s2[i2];
	}
	return 0;
}

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
/* Line number list operations */

/* Add a line to line number list */
static void line_list__add_line(struct list_head *head, unsigned int line)
{
	struct line_node *ln;
	struct list_head *p;

	/* Reverse search, because new line will be the last one */
	list_for_each_entry_reverse(ln, head, list) {
		if (ln->line < line) {
			p = &ln->list;
			goto found;
		} else if (ln->line == line)	/* Already exist */
			return ;
	}
	/* List is empty, or the smallest entry */
	p = head;
found:
	pr_debug("line list: add a line %u\n", line);
	ln = zalloc(sizeof(struct line_node));
	DIE_IF(ln == NULL);
	ln->line = line;
	INIT_LIST_HEAD(&ln->list);
	list_add(&ln->list, p);
}

/* Check if the line in line number list */
static int line_list__has_line(struct list_head *head, unsigned int line)
{
	struct line_node *ln;

	/* Reverse search, because new line will be the last one */
	list_for_each_entry(ln, head, list)
		if (ln->line == line)
			return 1;

	return 0;
}

/* Init line number list */
static void line_list__init(struct list_head *head)
{
	INIT_LIST_HEAD(head);
}

/* Free line number list */
static void line_list__free(struct list_head *head)
{
	struct line_node *ln;
	while (!list_empty(head)) {
		ln = list_first_entry(head, struct line_node, list);
		list_del(&ln->list);
		free(ln);
	}
}

/* Dwarf wrappers */

/* Find the realpath of the target file. */
static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
169
{
170 171
	Dwarf_Files *files;
	size_t nfiles, i;
172
	const char *src = NULL;
173 174 175
	int ret;

	if (!fname)
176
		return NULL;
177

178
	ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
179 180 181 182 183 184 185
	if (ret != 0)
		return NULL;

	for (i = 0; i < nfiles; i++) {
		src = dwarf_filesrc(files, i, NULL, NULL);
		if (strtailcmp(src, fname) == 0)
			break;
186
	}
187
	return src;
188 189
}

190 191 192 193 194 195
struct __addr_die_search_param {
	Dwarf_Addr	addr;
	Dwarf_Die	*die_mem;
};

static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
196
{
197
	struct __addr_die_search_param *ad = data;
198

199 200 201 202 203 204 205
	if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
	    dwarf_haspc(fn_die, ad->addr)) {
		memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
		return DWARF_CB_ABORT;
	}
	return DWARF_CB_OK;
}
206

207 208 209 210 211 212 213 214 215 216 217 218
/* Search a real subprogram including this line, */
static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
					  Dwarf_Die *die_mem)
{
	struct __addr_die_search_param ad;
	ad.addr = addr;
	ad.die_mem = die_mem;
	/* dwarf_getscopes can't find subprogram. */
	if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
		return NULL;
	else
		return die_mem;
219 220
}

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
static Dwarf_Die *die_get_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
				     Dwarf_Die *die_mem)
{
	Dwarf_Die child_die;
	int ret;

	ret = dwarf_child(sp_die, die_mem);
	if (ret != 0)
		return NULL;

	do {
		if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
		    dwarf_haspc(die_mem, addr))
			return die_mem;

		if (die_get_inlinefunc(die_mem, addr, &child_die)) {
			memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
			return die_mem;
		}
	} while (dwarf_siblingof(die_mem, die_mem) == 0);

	return NULL;
}

246
/* Compare diename and tname */
247
static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
248
{
249 250 251 252
	const char *name;
	name = dwarf_diename(dw_die);
	DIE_IF(name == NULL);
	return strcmp(tname, name);
253 254
}

255 256
/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
257
{
258
	Dwarf_Addr epc;
259 260
	int ret;

261 262 263
	ret = dwarf_entrypc(dw_die, &epc);
	DIE_IF(ret == -1);
	return epc;
264 265
}

266 267 268
/* Get a variable die */
static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
				    Dwarf_Die *die_mem)
269
{
270 271
	Dwarf_Die child_die;
	int tag;
272 273
	int ret;

274 275 276
	ret = dwarf_child(sp_die, die_mem);
	if (ret != 0)
		return NULL;
277

278 279 280 281 282 283
	do {
		tag = dwarf_tag(die_mem);
		if ((tag == DW_TAG_formal_parameter ||
		     tag == DW_TAG_variable) &&
		    (die_compare_name(die_mem, name) == 0))
			return die_mem;
284

285 286 287 288 289
		if (die_find_variable(die_mem, name, &child_die)) {
			memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
			return die_mem;
		}
	} while (dwarf_siblingof(die_mem, die_mem) == 0);
290

291
	return NULL;
292 293 294 295 296 297 298
}

/*
 * Probe finder related functions
 */

/* Show a location */
299
static void show_location(Dwarf_Op *op, struct probe_finder *pf)
300
{
301 302
	unsigned int regn;
	Dwarf_Word offs = 0;
303 304 305
	int deref = 0, ret;
	const char *regs;

306
	/* TODO: support CFA */
307
	/* If this is based on frame buffer, set the offset */
308 309 310
	if (op->atom == DW_OP_fbreg) {
		if (pf->fb_ops == NULL)
			die("The attribute of frame base is not supported.\n");
311
		deref = 1;
312 313 314
		offs = op->number;
		op = &pf->fb_ops[0];
	}
315

316 317 318
	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
		regn = op->atom - DW_OP_breg0;
		offs += op->number;
319
		deref = 1;
320 321 322 323 324
	} else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
		regn = op->atom - DW_OP_reg0;
	} else if (op->atom == DW_OP_bregx) {
		regn = op->number;
		offs += op->number2;
325
		deref = 1;
326 327
	} else if (op->atom == DW_OP_regx) {
		regn = op->number;
328
	} else
329
		die("DW_OP %d is not supported.", op->atom);
330 331 332

	regs = get_arch_regstr(regn);
	if (!regs)
333
		die("%u exceeds max register number.", regn);
334 335

	if (deref)
336 337
		ret = snprintf(pf->buf, pf->len, " %s=+%ju(%s)",
			       pf->var, (uintmax_t)offs, regs);
338 339
	else
		ret = snprintf(pf->buf, pf->len, " %s=%s", pf->var, regs);
340 341
	DIE_IF(ret < 0);
	DIE_IF(ret >= pf->len);
342 343 344
}

/* Show a variables in kprobe event format */
345
static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
346 347
{
	Dwarf_Attribute attr;
348 349
	Dwarf_Op *expr;
	size_t nexpr;
350 351
	int ret;

352
	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
353
		goto error;
354 355 356 357
	/* TODO: handle more than 1 exprs */
	ret = dwarf_getlocation_addr(&attr, (pf->addr - pf->cu_base),
				     &expr, &nexpr, 1);
	if (ret <= 0 || nexpr == 0)
358
		goto error;
359 360 361

	show_location(expr, pf);
	/* *expr will be cached in libdw. Don't free it. */
362 363
	return ;
error:
364
	/* TODO: Support const_value */
365
	die("Failed to find the location of %s at this address.\n"
366
	    " Perhaps, it has been optimized out.", pf->var);
367 368 369
}

/* Find a variable in a subprogram die */
370
static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
371 372
{
	int ret;
373
	Dwarf_Die vr_die;
374

375
	/* TODO: Support struct members and arrays */
376 377 378
	if (!is_c_varname(pf->var)) {
		/* Output raw parameters */
		ret = snprintf(pf->buf, pf->len, " %s", pf->var);
379 380
		DIE_IF(ret < 0);
		DIE_IF(ret >= pf->len);
381 382 383
		return ;
	}

384
	pr_debug("Searching '%s' variable in context.\n", pf->var);
385
	/* Search child die for local variables and parameters. */
386
	if (!die_find_variable(sp_die, pf->var, &vr_die))
387
		die("Failed to find '%s' in this function.", pf->var);
388 389

	show_variable(&vr_die, pf);
390 391 392
}

/* Show a probe point to output buffer */
393
static void show_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
394 395
{
	struct probe_point *pp = pf->pp;
396 397
	Dwarf_Addr eaddr;
	Dwarf_Die die_mem;
398
	const char *name;
399 400
	char tmp[MAX_PROBE_BUFFER];
	int ret, i, len;
401 402
	Dwarf_Attribute fb_attr;
	size_t nops;
403

404 405 406 407 408 409 410 411
	/* If no real subprogram, find a real one */
	if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
		sp_die = die_get_real_subprogram(&pf->cu_die,
						 pf->addr, &die_mem);
		if (!sp_die)
			die("Probe point is not found in subprograms.");
	}

412
	/* Output name of probe point */
413 414
	name = dwarf_diename(sp_die);
	if (name) {
415 416 417
		dwarf_entrypc(sp_die, &eaddr);
		ret = snprintf(tmp, MAX_PROBE_BUFFER, "%s+%lu", name,
				(unsigned long)(pf->addr - eaddr));
418 419 420
		/* Copy the function name if possible */
		if (!pp->function) {
			pp->function = strdup(name);
421
			pp->offset = (size_t)(pf->addr - eaddr);
422
		}
423 424
	} else {
		/* This function has no name. */
425 426
		ret = snprintf(tmp, MAX_PROBE_BUFFER, "0x%jx",
			       (uintmax_t)pf->addr);
427 428 429
		if (!pp->function) {
			/* TODO: Use _stext */
			pp->function = strdup("");
430
			pp->offset = (size_t)pf->addr;
431
		}
432
	}
433 434
	DIE_IF(ret < 0);
	DIE_IF(ret >= MAX_PROBE_BUFFER);
435
	len = ret;
436
	pr_debug("Probe point found: %s\n", tmp);
437

438 439 440 441 442 443 444
	/* Get the frame base attribute/ops */
	dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
	ret = dwarf_getlocation_addr(&fb_attr, (pf->addr - pf->cu_base),
				     &pf->fb_ops, &nops, 1);
	if (ret <= 0 || nops == 0)
		pf->fb_ops = NULL;

445
	/* Find each argument */
446
	/* TODO: use dwarf_cfi_addrframe */
447 448 449 450 451 452 453
	for (i = 0; i < pp->nr_args; i++) {
		pf->var = pp->args[i];
		pf->buf = &tmp[len];
		pf->len = MAX_PROBE_BUFFER - len;
		find_variable(sp_die, pf);
		len += strlen(pf->buf);
	}
454 455 456

	/* *pf->fb_ops will be cached in libdw. Don't free it. */
	pf->fb_ops = NULL;
457

458 459 460
	if (pp->found == MAX_PROBES)
		die("Too many( > %d) probe point found.\n", MAX_PROBES);

461 462 463 464 465
	pp->probes[pp->found] = strdup(tmp);
	pp->found++;
}

/* Find probe point from its line number */
466
static void find_probe_point_by_line(struct probe_finder *pf)
467
{
468 469 470
	Dwarf_Lines *lines;
	Dwarf_Line *line;
	size_t nlines, i;
471
	Dwarf_Addr addr;
472
	int lineno;
473 474
	int ret;

475 476
	ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
	DIE_IF(ret != 0);
477

478 479 480
	for (i = 0; i < nlines; i++) {
		line = dwarf_onesrcline(lines, i);
		dwarf_lineno(line, &lineno);
481
		if (lineno != pf->lno)
482 483
			continue;

484 485 486
		/* TODO: Get fileno from line, but how? */
		if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
			continue;
487

488 489 490 491
		ret = dwarf_lineaddr(line, &addr);
		DIE_IF(ret != 0);
		pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
			 (int)i, lineno, (uintmax_t)addr);
492
		pf->addr = addr;
493

494
		show_probe_point(NULL, pf);
495 496 497 498
		/* Continuing, because target line might be inlined. */
	}
}

499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
/* Find lines which match lazy pattern */
static int find_lazy_match_lines(struct list_head *head,
				 const char *fname, const char *pat)
{
	char *fbuf, *p1, *p2;
	int fd, line, nlines = 0;
	struct stat st;

	fd = open(fname, O_RDONLY);
	if (fd < 0)
		die("failed to open %s", fname);
	DIE_IF(fstat(fd, &st) < 0);
	fbuf = malloc(st.st_size + 2);
	DIE_IF(fbuf == NULL);
	DIE_IF(read(fd, fbuf, st.st_size) < 0);
	close(fd);
	fbuf[st.st_size] = '\n';	/* Dummy line */
	fbuf[st.st_size + 1] = '\0';
	p1 = fbuf;
	line = 1;
	while ((p2 = strchr(p1, '\n')) != NULL) {
		*p2 = '\0';
		if (strlazymatch(p1, pat)) {
			line_list__add_line(head, line);
			nlines++;
		}
		line++;
		p1 = p2 + 1;
	}
	free(fbuf);
	return nlines;
}

/* Find probe points from lazy pattern  */
static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
{
	Dwarf_Lines *lines;
	Dwarf_Line *line;
	size_t nlines, i;
	Dwarf_Addr addr;
	Dwarf_Die die_mem;
	int lineno;
	int ret;

	if (list_empty(&pf->lcache)) {
		/* Matching lazy line pattern */
		ret = find_lazy_match_lines(&pf->lcache, pf->fname,
					    pf->pp->lazy_line);
		if (ret <= 0)
			die("No matched lines found in %s.", pf->fname);
	}

	ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
	DIE_IF(ret != 0);
	for (i = 0; i < nlines; i++) {
		line = dwarf_onesrcline(lines, i);

		dwarf_lineno(line, &lineno);
		if (!line_list__has_line(&pf->lcache, lineno))
			continue;

		/* TODO: Get fileno from line, but how? */
		if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
			continue;

		ret = dwarf_lineaddr(line, &addr);
		DIE_IF(ret != 0);
		if (sp_die) {
			/* Address filtering 1: does sp_die include addr? */
			if (!dwarf_haspc(sp_die, addr))
				continue;
			/* Address filtering 2: No child include addr? */
			if (die_get_inlinefunc(sp_die, addr, &die_mem))
				continue;
		}

		pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
			 (int)i, lineno, (unsigned long long)addr);
		pf->addr = addr;

		show_probe_point(sp_die, pf);
		/* Continuing, because target line might be inlined. */
	}
	/* TODO: deallocate lines, but how? */
}

585 586 587 588 589
static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
{
	struct probe_finder *pf = (struct probe_finder *)data;
	struct probe_point *pp = pf->pp;

590 591 592 593 594 595 596 597 598 599 600
	if (pp->lazy_line)
		find_probe_point_lazy(in_die, pf);
	else {
		/* Get probe address */
		pf->addr = die_get_entrypc(in_die);
		pf->addr += pp->offset;
		pr_debug("found inline addr: 0x%jx\n",
			 (uintmax_t)pf->addr);

		show_probe_point(in_die, pf);
	}
601 602 603

	return DWARF_CB_OK;
}
604

605
/* Search function from function name */
606
static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
607 608 609 610
{
	struct probe_finder *pf = (struct probe_finder *)data;
	struct probe_point *pp = pf->pp;

611 612 613 614 615
	/* Check tag and diename */
	if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
	    die_compare_name(sp_die, pp->function) != 0)
		return 0;

616
	pf->fname = dwarf_decl_file(sp_die);
617 618 619 620 621 622
	if (pp->line) { /* Function relative line */
		dwarf_decl_line(sp_die, &pf->lno);
		pf->lno += pp->line;
		find_probe_point_by_line(pf);
	} else if (!dwarf_func_inline(sp_die)) {
		/* Real function */
623 624 625 626 627 628 629 630
		if (pp->lazy_line)
			find_probe_point_lazy(sp_die, pf);
		else {
			pf->addr = die_get_entrypc(sp_die);
			pf->addr += pp->offset;
			/* TODO: Check the address in this function */
			show_probe_point(sp_die, pf);
		}
631 632 633 634 635
	} else
		/* Inlined function: search instances */
		dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf);

	return 1; /* Exit; no same symbol in this CU. */
636 637
}

638
static void find_probe_point_by_func(struct probe_finder *pf)
639
{
640
	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0);
641 642 643
}

/* Find a probe point */
644
int find_probe_point(int fd, struct probe_point *pp)
645 646
{
	struct probe_finder pf = {.pp = pp};
647 648 649 650 651 652 653 654
	int ret;
	Dwarf_Off off, noff;
	size_t cuhl;
	Dwarf_Die *diep;
	Dwarf *dbg;

	dbg = dwarf_begin(fd, DWARF_C_READ);
	if (!dbg)
655
		return -ENOENT;
656 657

	pp->found = 0;
658
	off = 0;
659
	line_list__init(&pf.lcache);
660 661
	/* Loop on CUs (Compilation Unit) */
	while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
662
		/* Get the DIE(Debugging Information Entry) of this CU */
663 664 665
		diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
		if (!diep)
			continue;
666 667 668

		/* Check if target file is included. */
		if (pp->file)
669
			pf.fname = cu_find_realpath(&pf.cu_die, pp->file);
670
		else
671
			pf.fname = NULL;
672

673
		if (!pp->file || pf.fname) {
674
			/* Save CU base address (for frame_base) */
675 676
			ret = dwarf_lowpc(&pf.cu_die, &pf.cu_base);
			if (ret != 0)
677 678
				pf.cu_base = 0;
			if (pp->function)
679
				find_probe_point_by_func(&pf);
680 681
			else if (pp->lazy_line)
				find_probe_point_lazy(NULL, &pf);
682 683
			else {
				pf.lno = pp->line;
684
				find_probe_point_by_line(&pf);
685
			}
686
		}
687
		off = noff;
688
	}
689
	line_list__free(&pf.lcache);
690
	dwarf_end(dbg);
691 692 693 694

	return pp->found;
}

695
/* Find line range from its line number */
696
static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
697
{
698 699 700
	Dwarf_Lines *lines;
	Dwarf_Line *line;
	size_t nlines, i;
701
	Dwarf_Addr addr;
702
	int lineno;
703
	int ret;
704
	const char *src;
705
	Dwarf_Die die_mem;
706

707
	line_list__init(&lf->lr->line_list);
708 709
	ret = dwarf_getsrclines(&lf->cu_die, &lines, &nlines);
	DIE_IF(ret != 0);
710

711 712
	for (i = 0; i < nlines; i++) {
		line = dwarf_onesrcline(lines, i);
713 714
		ret = dwarf_lineno(line, &lineno);
		DIE_IF(ret != 0);
715
		if (lf->lno_s > lineno || lf->lno_e < lineno)
716 717
			continue;

718 719 720 721 722 723 724 725 726 727 728 729
		if (sp_die) {
			/* Address filtering 1: does sp_die include addr? */
			ret = dwarf_lineaddr(line, &addr);
			DIE_IF(ret != 0);
			if (!dwarf_haspc(sp_die, addr))
				continue;

			/* Address filtering 2: No child include addr? */
			if (die_get_inlinefunc(sp_die, addr, &die_mem))
				continue;
		}

730 731 732
		/* TODO: Get fileno from line, but how? */
		src = dwarf_linesrc(line, NULL, NULL);
		if (strtailcmp(src, lf->fname) != 0)
733 734
			continue;

735 736 737
		/* Copy real path */
		if (!lf->lr->path)
			lf->lr->path = strdup(src);
738
		line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
739
	}
740
	/* Update status */
741 742
	if (!list_empty(&lf->lr->line_list))
		lf->found = 1;
743 744 745 746
	else {
		free(lf->lr->path);
		lf->lr->path = NULL;
	}
747 748
}

749 750 751 752 753 754
static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
{
	find_line_range_by_line(in_die, (struct line_finder *)data);
	return DWARF_CB_ABORT;	/* No need to find other instances */
}

755
/* Search function from function name */
756
static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
757 758 759 760
{
	struct line_finder *lf = (struct line_finder *)data;
	struct line_range *lr = lf->lr;

761 762 763 764
	if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
	    die_compare_name(sp_die, lr->function) == 0) {
		lf->fname = dwarf_decl_file(sp_die);
		dwarf_decl_line(sp_die, &lr->offset);
765
		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
766 767
		lf->lno_s = lr->offset + lr->start;
		if (!lr->end)
768
			lf->lno_e = INT_MAX;
769 770 771 772
		else
			lf->lno_e = lr->offset + lr->end;
		lr->start = lf->lno_s;
		lr->end = lf->lno_e;
773 774 775 776 777
		if (dwarf_func_inline(sp_die))
			dwarf_func_inline_instances(sp_die,
						    line_range_inline_cb, lf);
		else
			find_line_range_by_line(sp_die, lf);
778 779 780 781 782 783 784
		return 1;
	}
	return 0;
}

static void find_line_range_by_func(struct line_finder *lf)
{
785
	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0);
786 787 788 789
}

int find_line_range(int fd, struct line_range *lr)
{
790
	struct line_finder lf = {.lr = lr, .found = 0};
791
	int ret;
792 793 794 795 796 797 798
	Dwarf_Off off = 0, noff;
	size_t cuhl;
	Dwarf_Die *diep;
	Dwarf *dbg;

	dbg = dwarf_begin(fd, DWARF_C_READ);
	if (!dbg)
799 800
		return -ENOENT;

801
	/* Loop on CUs (Compilation Unit) */
802
	while (!lf.found) {
803 804
		ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL);
		if (ret != 0)
805 806 807
			break;

		/* Get the DIE(Debugging Information Entry) of this CU */
808 809 810
		diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
		if (!diep)
			continue;
811 812 813

		/* Check if target file is included. */
		if (lr->file)
814
			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
815
		else
816
			lf.fname = 0;
817

818
		if (!lr->file || lf.fname) {
819 820 821 822 823
			if (lr->function)
				find_line_range_by_func(&lf);
			else {
				lf.lno_s = lr->start;
				if (!lr->end)
824
					lf.lno_e = INT_MAX;
825 826
				else
					lf.lno_e = lr->end;
827
				find_line_range_by_line(NULL, &lf);
828 829
			}
		}
830
		off = noff;
831
	}
832 833
	pr_debug("path: %lx\n", (unsigned long)lr->path);
	dwarf_end(dbg);
834 835 836
	return lf.found;
}