perf probe: Remove redundant checks
[linux-2.6.git] / tools / perf / util / probe-finder.c
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 <getopt.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <stdarg.h>
33 #include <ctype.h>
34 #include <dwarf-regs.h>
35
36 #include <linux/bitops.h>
37 #include "event.h"
38 #include "debug.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 /*
47  * Compare the tail of two strings.
48  * Return 0 if whole of either string is same as another's tail part.
49  */
50 static int strtailcmp(const char *s1, const char *s2)
51 {
52         int i1 = strlen(s1);
53         int i2 = strlen(s2);
54         while (--i1 >= 0 && --i2 >= 0) {
55                 if (s1[i1] != s2[i2])
56                         return s1[i1] - s2[i2];
57         }
58         return 0;
59 }
60
61 /* Line number list operations */
62
63 /* Add a line to line number list */
64 static int line_list__add_line(struct list_head *head, int line)
65 {
66         struct line_node *ln;
67         struct list_head *p;
68
69         /* Reverse search, because new line will be the last one */
70         list_for_each_entry_reverse(ln, head, list) {
71                 if (ln->line < line) {
72                         p = &ln->list;
73                         goto found;
74                 } else if (ln->line == line)    /* Already exist */
75                         return 1;
76         }
77         /* List is empty, or the smallest entry */
78         p = head;
79 found:
80         pr_debug("line list: add a line %u\n", line);
81         ln = zalloc(sizeof(struct line_node));
82         if (ln == NULL)
83                 return -ENOMEM;
84         ln->line = line;
85         INIT_LIST_HEAD(&ln->list);
86         list_add(&ln->list, p);
87         return 0;
88 }
89
90 /* Check if the line in line number list */
91 static int line_list__has_line(struct list_head *head, int line)
92 {
93         struct line_node *ln;
94
95         /* Reverse search, because new line will be the last one */
96         list_for_each_entry(ln, head, list)
97                 if (ln->line == line)
98                         return 1;
99
100         return 0;
101 }
102
103 /* Init line number list */
104 static void line_list__init(struct list_head *head)
105 {
106         INIT_LIST_HEAD(head);
107 }
108
109 /* Free line number list */
110 static void line_list__free(struct list_head *head)
111 {
112         struct line_node *ln;
113         while (!list_empty(head)) {
114                 ln = list_first_entry(head, struct line_node, list);
115                 list_del(&ln->list);
116                 free(ln);
117         }
118 }
119
120 /* Dwarf FL wrappers */
121 static char *debuginfo_path;    /* Currently dummy */
122
123 static const Dwfl_Callbacks offline_callbacks = {
124         .find_debuginfo = dwfl_standard_find_debuginfo,
125         .debuginfo_path = &debuginfo_path,
126
127         .section_address = dwfl_offline_section_address,
128
129         /* We use this table for core files too.  */
130         .find_elf = dwfl_build_id_find_elf,
131 };
132
133 /* Get a Dwarf from offline image */
134 static Dwarf *dwfl_init_offline_dwarf(int fd, Dwfl **dwflp, Dwarf_Addr *bias)
135 {
136         Dwfl_Module *mod;
137         Dwarf *dbg = NULL;
138
139         if (!dwflp)
140                 return NULL;
141
142         *dwflp = dwfl_begin(&offline_callbacks);
143         if (!*dwflp)
144                 return NULL;
145
146         mod = dwfl_report_offline(*dwflp, "", "", fd);
147         if (!mod)
148                 goto error;
149
150         dbg = dwfl_module_getdwarf(mod, bias);
151         if (!dbg) {
152 error:
153                 dwfl_end(*dwflp);
154                 *dwflp = NULL;
155         }
156         return dbg;
157 }
158
159 #if _ELFUTILS_PREREQ(0, 148)
160 /* This method is buggy if elfutils is older than 0.148 */
161 static int __linux_kernel_find_elf(Dwfl_Module *mod,
162                                    void **userdata,
163                                    const char *module_name,
164                                    Dwarf_Addr base,
165                                    char **file_name, Elf **elfp)
166 {
167         int fd;
168         const char *path = kernel_get_module_path(module_name);
169
170         pr_debug2("Use file %s for %s\n", path, module_name);
171         if (path) {
172                 fd = open(path, O_RDONLY);
173                 if (fd >= 0) {
174                         *file_name = strdup(path);
175                         return fd;
176                 }
177         }
178         /* If failed, try to call standard method */
179         return dwfl_linux_kernel_find_elf(mod, userdata, module_name, base,
180                                           file_name, elfp);
181 }
182
183 static const Dwfl_Callbacks kernel_callbacks = {
184         .find_debuginfo = dwfl_standard_find_debuginfo,
185         .debuginfo_path = &debuginfo_path,
186
187         .find_elf = __linux_kernel_find_elf,
188         .section_address = dwfl_linux_kernel_module_section_address,
189 };
190
191 /* Get a Dwarf from live kernel image */
192 static Dwarf *dwfl_init_live_kernel_dwarf(Dwarf_Addr addr, Dwfl **dwflp,
193                                           Dwarf_Addr *bias)
194 {
195         Dwarf *dbg;
196
197         if (!dwflp)
198                 return NULL;
199
200         *dwflp = dwfl_begin(&kernel_callbacks);
201         if (!*dwflp)
202                 return NULL;
203
204         /* Load the kernel dwarves: Don't care the result here */
205         dwfl_linux_kernel_report_kernel(*dwflp);
206         dwfl_linux_kernel_report_modules(*dwflp);
207
208         dbg = dwfl_addrdwarf(*dwflp, addr, bias);
209         /* Here, check whether we could get a real dwarf */
210         if (!dbg) {
211                 pr_debug("Failed to find kernel dwarf at %lx\n",
212                          (unsigned long)addr);
213                 dwfl_end(*dwflp);
214                 *dwflp = NULL;
215         }
216         return dbg;
217 }
218 #else
219 /* With older elfutils, this just support kernel module... */
220 static Dwarf *dwfl_init_live_kernel_dwarf(Dwarf_Addr addr __used, Dwfl **dwflp,
221                                           Dwarf_Addr *bias)
222 {
223         int fd;
224         const char *path = kernel_get_module_path("kernel");
225
226         if (!path) {
227                 pr_err("Failed to find vmlinux path\n");
228                 return NULL;
229         }
230
231         pr_debug2("Use file %s for debuginfo\n", path);
232         fd = open(path, O_RDONLY);
233         if (fd < 0)
234                 return NULL;
235
236         return dwfl_init_offline_dwarf(fd, dwflp, bias);
237 }
238 #endif
239
240 /* Dwarf wrappers */
241
242 /* Find the realpath of the target file. */
243 static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
244 {
245         Dwarf_Files *files;
246         size_t nfiles, i;
247         const char *src = NULL;
248         int ret;
249
250         if (!fname)
251                 return NULL;
252
253         ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
254         if (ret != 0)
255                 return NULL;
256
257         for (i = 0; i < nfiles; i++) {
258                 src = dwarf_filesrc(files, i, NULL, NULL);
259                 if (strtailcmp(src, fname) == 0)
260                         break;
261         }
262         if (i == nfiles)
263                 return NULL;
264         return src;
265 }
266
267 /* Get DW_AT_comp_dir (should be NULL with older gcc) */
268 static const char *cu_get_comp_dir(Dwarf_Die *cu_die)
269 {
270         Dwarf_Attribute attr;
271         if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
272                 return NULL;
273         return dwarf_formstring(&attr);
274 }
275
276 /* Compare diename and tname */
277 static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
278 {
279         const char *name;
280         name = dwarf_diename(dw_die);
281         return name ? (strcmp(tname, name) == 0) : false;
282 }
283
284 /* Get callsite line number of inline-function instance */
285 static int die_get_call_lineno(Dwarf_Die *in_die)
286 {
287         Dwarf_Attribute attr;
288         Dwarf_Word ret;
289
290         if (!dwarf_attr(in_die, DW_AT_call_line, &attr))
291                 return -ENOENT;
292
293         dwarf_formudata(&attr, &ret);
294         return (int)ret;
295 }
296
297 /* Get type die */
298 static Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
299 {
300         Dwarf_Attribute attr;
301
302         if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
303             dwarf_formref_die(&attr, die_mem))
304                 return die_mem;
305         else
306                 return NULL;
307 }
308
309 /* Get a type die, but skip qualifiers */
310 static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
311 {
312         int tag;
313
314         do {
315                 vr_die = die_get_type(vr_die, die_mem);
316                 if (!vr_die)
317                         break;
318                 tag = dwarf_tag(vr_die);
319         } while (tag == DW_TAG_const_type ||
320                  tag == DW_TAG_restrict_type ||
321                  tag == DW_TAG_volatile_type ||
322                  tag == DW_TAG_shared_type);
323
324         return vr_die;
325 }
326
327 /* Get a type die, but skip qualifiers and typedef */
328 static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
329 {
330         do {
331                 vr_die = __die_get_real_type(vr_die, die_mem);
332         } while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef);
333
334         return vr_die;
335 }
336
337 static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
338                               Dwarf_Word *result)
339 {
340         Dwarf_Attribute attr;
341
342         if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
343             dwarf_formudata(&attr, result) != 0)
344                 return -ENOENT;
345
346         return 0;
347 }
348
349 static bool die_is_signed_type(Dwarf_Die *tp_die)
350 {
351         Dwarf_Word ret;
352
353         if (die_get_attr_udata(tp_die, DW_AT_encoding, &ret))
354                 return false;
355
356         return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
357                 ret == DW_ATE_signed_fixed);
358 }
359
360 static int die_get_byte_size(Dwarf_Die *tp_die)
361 {
362         Dwarf_Word ret;
363
364         if (die_get_attr_udata(tp_die, DW_AT_byte_size, &ret))
365                 return 0;
366
367         return (int)ret;
368 }
369
370 static int die_get_bit_size(Dwarf_Die *tp_die)
371 {
372         Dwarf_Word ret;
373
374         if (die_get_attr_udata(tp_die, DW_AT_bit_size, &ret))
375                 return 0;
376
377         return (int)ret;
378 }
379
380 static int die_get_bit_offset(Dwarf_Die *tp_die)
381 {
382         Dwarf_Word ret;
383
384         if (die_get_attr_udata(tp_die, DW_AT_bit_offset, &ret))
385                 return 0;
386
387         return (int)ret;
388 }
389
390 /* Get data_member_location offset */
391 static int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
392 {
393         Dwarf_Attribute attr;
394         Dwarf_Op *expr;
395         size_t nexpr;
396         int ret;
397
398         if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
399                 return -ENOENT;
400
401         if (dwarf_formudata(&attr, offs) != 0) {
402                 /* DW_AT_data_member_location should be DW_OP_plus_uconst */
403                 ret = dwarf_getlocation(&attr, &expr, &nexpr);
404                 if (ret < 0 || nexpr == 0)
405                         return -ENOENT;
406
407                 if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
408                         pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
409                                  expr[0].atom, nexpr);
410                         return -ENOTSUP;
411                 }
412                 *offs = (Dwarf_Word)expr[0].number;
413         }
414         return 0;
415 }
416
417 /* Return values for die_find callbacks */
418 enum {
419         DIE_FIND_CB_FOUND = 0,          /* End of Search */
420         DIE_FIND_CB_CHILD = 1,          /* Search only children */
421         DIE_FIND_CB_SIBLING = 2,        /* Search only siblings */
422         DIE_FIND_CB_CONTINUE = 3,       /* Search children and siblings */
423 };
424
425 /* Search a child die */
426 static Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
427                                  int (*callback)(Dwarf_Die *, void *),
428                                  void *data, Dwarf_Die *die_mem)
429 {
430         Dwarf_Die child_die;
431         int ret;
432
433         ret = dwarf_child(rt_die, die_mem);
434         if (ret != 0)
435                 return NULL;
436
437         do {
438                 ret = callback(die_mem, data);
439                 if (ret == DIE_FIND_CB_FOUND)
440                         return die_mem;
441
442                 if ((ret & DIE_FIND_CB_CHILD) &&
443                     die_find_child(die_mem, callback, data, &child_die)) {
444                         memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
445                         return die_mem;
446                 }
447         } while ((ret & DIE_FIND_CB_SIBLING) &&
448                  dwarf_siblingof(die_mem, die_mem) == 0);
449
450         return NULL;
451 }
452
453 struct __addr_die_search_param {
454         Dwarf_Addr      addr;
455         Dwarf_Die       *die_mem;
456 };
457
458 static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
459 {
460         struct __addr_die_search_param *ad = data;
461
462         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
463             dwarf_haspc(fn_die, ad->addr)) {
464                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
465                 return DWARF_CB_ABORT;
466         }
467         return DWARF_CB_OK;
468 }
469
470 /* Search a real subprogram including this line, */
471 static Dwarf_Die *die_find_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
472                                            Dwarf_Die *die_mem)
473 {
474         struct __addr_die_search_param ad;
475         ad.addr = addr;
476         ad.die_mem = die_mem;
477         /* dwarf_getscopes can't find subprogram. */
478         if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
479                 return NULL;
480         else
481                 return die_mem;
482 }
483
484 /* die_find callback for inline function search */
485 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
486 {
487         Dwarf_Addr *addr = data;
488
489         if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
490             dwarf_haspc(die_mem, *addr))
491                 return DIE_FIND_CB_FOUND;
492
493         return DIE_FIND_CB_CONTINUE;
494 }
495
496 /* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
497 static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
498                                       Dwarf_Die *die_mem)
499 {
500         return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
501 }
502
503 /* Walker on lines (Note: line number will not be sorted) */
504 typedef int (* line_walk_handler_t) (const char *fname, int lineno,
505                                      Dwarf_Addr addr, void *data);
506
507 struct __line_walk_param {
508         const char *fname;
509         line_walk_handler_t handler;
510         void *data;
511         int retval;
512 };
513
514 static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
515 {
516         struct __line_walk_param *lw = data;
517         Dwarf_Addr addr;
518         int lineno;
519
520         if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
521                 lineno = die_get_call_lineno(in_die);
522                 if (lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
523                         lw->retval = lw->handler(lw->fname, lineno, addr,
524                                                  lw->data);
525                         if (lw->retval != 0)
526                                 return DIE_FIND_CB_FOUND;
527                 }
528         }
529         return DIE_FIND_CB_SIBLING;
530 }
531
532 /* Walk on lines of blocks included in given DIE */
533 static int __die_walk_funclines(Dwarf_Die *sp_die,
534                                 line_walk_handler_t handler, void *data)
535 {
536         struct __line_walk_param lw = {
537                 .handler = handler,
538                 .data = data,
539                 .retval = 0,
540         };
541         Dwarf_Die die_mem;
542         Dwarf_Addr addr;
543         int lineno;
544
545         /* Handle function declaration line */
546         lw.fname = dwarf_decl_file(sp_die);
547         if (lw.fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
548             dwarf_entrypc(sp_die, &addr) == 0) {
549                 lw.retval = handler(lw.fname, lineno, addr, data);
550                 if (lw.retval != 0)
551                         goto done;
552         }
553         die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
554 done:
555         return lw.retval;
556 }
557
558 static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
559 {
560         struct __line_walk_param *lw = data;
561
562         lw->retval = __die_walk_funclines(sp_die, lw->handler, lw->data);
563         if (lw->retval != 0)
564                 return DWARF_CB_ABORT;
565
566         return DWARF_CB_OK;
567 }
568
569 /*
570  * Walk on lines inside given PDIE. If the PDIE is subprogram, walk only on
571  * the lines inside the subprogram, otherwise PDIE must be a CU DIE.
572  */
573 static int die_walk_lines(Dwarf_Die *pdie, line_walk_handler_t handler,
574                           void *data)
575 {
576         Dwarf_Lines *lines;
577         Dwarf_Line *line;
578         Dwarf_Addr addr;
579         const char *fname;
580         int lineno, ret = 0;
581         Dwarf_Die die_mem, *cu_die;
582         size_t nlines, i;
583
584         /* Get the CU die */
585         if (dwarf_tag(pdie) == DW_TAG_subprogram)
586                 cu_die = dwarf_diecu(pdie, &die_mem, NULL, NULL);
587         else
588                 cu_die = pdie;
589         if (!cu_die) {
590                 pr_debug2("Failed to get CU from subprogram\n");
591                 return -EINVAL;
592         }
593
594         /* Get lines list in the CU */
595         if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
596                 pr_debug2("Failed to get source lines on this CU.\n");
597                 return -ENOENT;
598         }
599         pr_debug2("Get %zd lines from this CU\n", nlines);
600
601         /* Walk on the lines on lines list */
602         for (i = 0; i < nlines; i++) {
603                 line = dwarf_onesrcline(lines, i);
604                 if (line == NULL ||
605                     dwarf_lineno(line, &lineno) != 0 ||
606                     dwarf_lineaddr(line, &addr) != 0) {
607                         pr_debug2("Failed to get line info. "
608                                   "Possible error in debuginfo.\n");
609                         continue;
610                 }
611                 /* Filter lines based on address */
612                 if (pdie != cu_die)
613                         /*
614                          * Address filtering
615                          * The line is included in given function, and
616                          * no inline block includes it.
617                          */
618                         if (!dwarf_haspc(pdie, addr) ||
619                             die_find_inlinefunc(pdie, addr, &die_mem))
620                                 continue;
621                 /* Get source line */
622                 fname = dwarf_linesrc(line, NULL, NULL);
623
624                 ret = handler(fname, lineno, addr, data);
625                 if (ret != 0)
626                         return ret;
627         }
628
629         /*
630          * Dwarf lines doesn't include function declarations and inlined
631          * subroutines. We have to check functions list or given function.
632          */
633         if (pdie != cu_die)
634                 ret = __die_walk_funclines(pdie, handler, data);
635         else {
636                 struct __line_walk_param param = {
637                         .handler = handler,
638                         .data = data,
639                         .retval = 0,
640                 };
641                 dwarf_getfuncs(cu_die, __die_walk_culines_cb, &param, 0);
642                 ret = param.retval;
643         }
644
645         return ret;
646 }
647
648 struct __find_variable_param {
649         const char *name;
650         Dwarf_Addr addr;
651 };
652
653 static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
654 {
655         struct __find_variable_param *fvp = data;
656         int tag;
657
658         tag = dwarf_tag(die_mem);
659         if ((tag == DW_TAG_formal_parameter ||
660              tag == DW_TAG_variable) &&
661             die_compare_name(die_mem, fvp->name))
662                 return DIE_FIND_CB_FOUND;
663
664         if (dwarf_haspc(die_mem, fvp->addr))
665                 return DIE_FIND_CB_CONTINUE;
666         else
667                 return DIE_FIND_CB_SIBLING;
668 }
669
670 /* Find a variable called 'name' at given address */
671 static Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
672                                        Dwarf_Addr addr, Dwarf_Die *die_mem)
673 {
674         struct __find_variable_param fvp = { .name = name, .addr = addr};
675
676         return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
677                               die_mem);
678 }
679
680 static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
681 {
682         const char *name = data;
683
684         if ((dwarf_tag(die_mem) == DW_TAG_member) &&
685             die_compare_name(die_mem, name))
686                 return DIE_FIND_CB_FOUND;
687
688         return DIE_FIND_CB_SIBLING;
689 }
690
691 /* Find a member called 'name' */
692 static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
693                                   Dwarf_Die *die_mem)
694 {
695         return die_find_child(st_die, __die_find_member_cb, (void *)name,
696                               die_mem);
697 }
698
699 /* Get the name of given variable DIE */
700 static int die_get_typename(Dwarf_Die *vr_die, char *buf, int len)
701 {
702         Dwarf_Die type;
703         int tag, ret, ret2;
704         const char *tmp = "";
705
706         if (__die_get_real_type(vr_die, &type) == NULL)
707                 return -ENOENT;
708
709         tag = dwarf_tag(&type);
710         if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
711                 tmp = "*";
712         else if (tag == DW_TAG_subroutine_type) {
713                 /* Function pointer */
714                 ret = snprintf(buf, len, "(function_type)");
715                 return (ret >= len) ? -E2BIG : ret;
716         } else {
717                 if (!dwarf_diename(&type))
718                         return -ENOENT;
719                 if (tag == DW_TAG_union_type)
720                         tmp = "union ";
721                 else if (tag == DW_TAG_structure_type)
722                         tmp = "struct ";
723                 /* Write a base name */
724                 ret = snprintf(buf, len, "%s%s", tmp, dwarf_diename(&type));
725                 return (ret >= len) ? -E2BIG : ret;
726         }
727         ret = die_get_typename(&type, buf, len);
728         if (ret > 0) {
729                 ret2 = snprintf(buf + ret, len - ret, "%s", tmp);
730                 ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
731         }
732         return ret;
733 }
734
735 /* Get the name and type of given variable DIE, stored as "type\tname" */
736 static int die_get_varname(Dwarf_Die *vr_die, char *buf, int len)
737 {
738         int ret, ret2;
739
740         ret = die_get_typename(vr_die, buf, len);
741         if (ret < 0) {
742                 pr_debug("Failed to get type, make it unknown.\n");
743                 ret = snprintf(buf, len, "(unknown_type)");
744         }
745         if (ret > 0) {
746                 ret2 = snprintf(buf + ret, len - ret, "\t%s",
747                                 dwarf_diename(vr_die));
748                 ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
749         }
750         return ret;
751 }
752
753 /*
754  * Probe finder related functions
755  */
756
757 static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
758 {
759         struct probe_trace_arg_ref *ref;
760         ref = zalloc(sizeof(struct probe_trace_arg_ref));
761         if (ref != NULL)
762                 ref->offset = offs;
763         return ref;
764 }
765
766 /*
767  * Convert a location into trace_arg.
768  * If tvar == NULL, this just checks variable can be converted.
769  */
770 static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
771                                      Dwarf_Op *fb_ops,
772                                      struct probe_trace_arg *tvar)
773 {
774         Dwarf_Attribute attr;
775         Dwarf_Op *op;
776         size_t nops;
777         unsigned int regn;
778         Dwarf_Word offs = 0;
779         bool ref = false;
780         const char *regs;
781         int ret;
782
783         if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
784                 goto static_var;
785
786         /* TODO: handle more than 1 exprs */
787         if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL ||
788             dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0 ||
789             nops == 0) {
790                 /* TODO: Support const_value */
791                 return -ENOENT;
792         }
793
794         if (op->atom == DW_OP_addr) {
795 static_var:
796                 if (!tvar)
797                         return 0;
798                 /* Static variables on memory (not stack), make @varname */
799                 ret = strlen(dwarf_diename(vr_die));
800                 tvar->value = zalloc(ret + 2);
801                 if (tvar->value == NULL)
802                         return -ENOMEM;
803                 snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
804                 tvar->ref = alloc_trace_arg_ref((long)offs);
805                 if (tvar->ref == NULL)
806                         return -ENOMEM;
807                 return 0;
808         }
809
810         /* If this is based on frame buffer, set the offset */
811         if (op->atom == DW_OP_fbreg) {
812                 if (fb_ops == NULL)
813                         return -ENOTSUP;
814                 ref = true;
815                 offs = op->number;
816                 op = &fb_ops[0];
817         }
818
819         if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
820                 regn = op->atom - DW_OP_breg0;
821                 offs += op->number;
822                 ref = true;
823         } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
824                 regn = op->atom - DW_OP_reg0;
825         } else if (op->atom == DW_OP_bregx) {
826                 regn = op->number;
827                 offs += op->number2;
828                 ref = true;
829         } else if (op->atom == DW_OP_regx) {
830                 regn = op->number;
831         } else {
832                 pr_debug("DW_OP %x is not supported.\n", op->atom);
833                 return -ENOTSUP;
834         }
835
836         if (!tvar)
837                 return 0;
838
839         regs = get_arch_regstr(regn);
840         if (!regs) {
841                 /* This should be a bug in DWARF or this tool */
842                 pr_warning("Mapping for the register number %u "
843                            "missing on this architecture.\n", regn);
844                 return -ERANGE;
845         }
846
847         tvar->value = strdup(regs);
848         if (tvar->value == NULL)
849                 return -ENOMEM;
850
851         if (ref) {
852                 tvar->ref = alloc_trace_arg_ref((long)offs);
853                 if (tvar->ref == NULL)
854                         return -ENOMEM;
855         }
856         return 0;
857 }
858
859 #define BYTES_TO_BITS(nb)       ((nb) * BITS_PER_LONG / sizeof(long))
860
861 static int convert_variable_type(Dwarf_Die *vr_die,
862                                  struct probe_trace_arg *tvar,
863                                  const char *cast)
864 {
865         struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
866         Dwarf_Die type;
867         char buf[16];
868         int ret;
869
870         /* TODO: check all types */
871         if (cast && strcmp(cast, "string") != 0) {
872                 /* Non string type is OK */
873                 tvar->type = strdup(cast);
874                 return (tvar->type == NULL) ? -ENOMEM : 0;
875         }
876
877         if (die_get_bit_size(vr_die) != 0) {
878                 /* This is a bitfield */
879                 ret = snprintf(buf, 16, "b%d@%d/%zd", die_get_bit_size(vr_die),
880                                 die_get_bit_offset(vr_die),
881                                 BYTES_TO_BITS(die_get_byte_size(vr_die)));
882                 goto formatted;
883         }
884
885         if (die_get_real_type(vr_die, &type) == NULL) {
886                 pr_warning("Failed to get a type information of %s.\n",
887                            dwarf_diename(vr_die));
888                 return -ENOENT;
889         }
890
891         pr_debug("%s type is %s.\n",
892                  dwarf_diename(vr_die), dwarf_diename(&type));
893
894         if (cast && strcmp(cast, "string") == 0) {      /* String type */
895                 ret = dwarf_tag(&type);
896                 if (ret != DW_TAG_pointer_type &&
897                     ret != DW_TAG_array_type) {
898                         pr_warning("Failed to cast into string: "
899                                    "%s(%s) is not a pointer nor array.\n",
900                                    dwarf_diename(vr_die), dwarf_diename(&type));
901                         return -EINVAL;
902                 }
903                 if (ret == DW_TAG_pointer_type) {
904                         if (die_get_real_type(&type, &type) == NULL) {
905                                 pr_warning("Failed to get a type"
906                                            " information.\n");
907                                 return -ENOENT;
908                         }
909                         while (*ref_ptr)
910                                 ref_ptr = &(*ref_ptr)->next;
911                         /* Add new reference with offset +0 */
912                         *ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
913                         if (*ref_ptr == NULL) {
914                                 pr_warning("Out of memory error\n");
915                                 return -ENOMEM;
916                         }
917                 }
918                 if (!die_compare_name(&type, "char") &&
919                     !die_compare_name(&type, "unsigned char")) {
920                         pr_warning("Failed to cast into string: "
921                                    "%s is not (unsigned) char *.\n",
922                                    dwarf_diename(vr_die));
923                         return -EINVAL;
924                 }
925                 tvar->type = strdup(cast);
926                 return (tvar->type == NULL) ? -ENOMEM : 0;
927         }
928
929         ret = BYTES_TO_BITS(die_get_byte_size(&type));
930         if (!ret)
931                 /* No size ... try to use default type */
932                 return 0;
933
934         /* Check the bitwidth */
935         if (ret > MAX_BASIC_TYPE_BITS) {
936                 pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
937                         dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
938                 ret = MAX_BASIC_TYPE_BITS;
939         }
940         ret = snprintf(buf, 16, "%c%d",
941                        die_is_signed_type(&type) ? 's' : 'u', ret);
942
943 formatted:
944         if (ret < 0 || ret >= 16) {
945                 if (ret >= 16)
946                         ret = -E2BIG;
947                 pr_warning("Failed to convert variable type: %s\n",
948                            strerror(-ret));
949                 return ret;
950         }
951         tvar->type = strdup(buf);
952         if (tvar->type == NULL)
953                 return -ENOMEM;
954         return 0;
955 }
956
957 static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
958                                     struct perf_probe_arg_field *field,
959                                     struct probe_trace_arg_ref **ref_ptr,
960                                     Dwarf_Die *die_mem)
961 {
962         struct probe_trace_arg_ref *ref = *ref_ptr;
963         Dwarf_Die type;
964         Dwarf_Word offs;
965         int ret, tag;
966
967         pr_debug("converting %s in %s\n", field->name, varname);
968         if (die_get_real_type(vr_die, &type) == NULL) {
969                 pr_warning("Failed to get the type of %s.\n", varname);
970                 return -ENOENT;
971         }
972         pr_debug2("Var real type: (%x)\n", (unsigned)dwarf_dieoffset(&type));
973         tag = dwarf_tag(&type);
974
975         if (field->name[0] == '[' &&
976             (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
977                 if (field->next)
978                         /* Save original type for next field */
979                         memcpy(die_mem, &type, sizeof(*die_mem));
980                 /* Get the type of this array */
981                 if (die_get_real_type(&type, &type) == NULL) {
982                         pr_warning("Failed to get the type of %s.\n", varname);
983                         return -ENOENT;
984                 }
985                 pr_debug2("Array real type: (%x)\n",
986                          (unsigned)dwarf_dieoffset(&type));
987                 if (tag == DW_TAG_pointer_type) {
988                         ref = zalloc(sizeof(struct probe_trace_arg_ref));
989                         if (ref == NULL)
990                                 return -ENOMEM;
991                         if (*ref_ptr)
992                                 (*ref_ptr)->next = ref;
993                         else
994                                 *ref_ptr = ref;
995                 }
996                 ref->offset += die_get_byte_size(&type) * field->index;
997                 if (!field->next)
998                         /* Save vr_die for converting types */
999                         memcpy(die_mem, vr_die, sizeof(*die_mem));
1000                 goto next;
1001         } else if (tag == DW_TAG_pointer_type) {
1002                 /* Check the pointer and dereference */
1003                 if (!field->ref) {
1004                         pr_err("Semantic error: %s must be referred by '->'\n",
1005                                field->name);
1006                         return -EINVAL;
1007                 }
1008                 /* Get the type pointed by this pointer */
1009                 if (die_get_real_type(&type, &type) == NULL) {
1010                         pr_warning("Failed to get the type of %s.\n", varname);
1011                         return -ENOENT;
1012                 }
1013                 /* Verify it is a data structure  */
1014                 if (dwarf_tag(&type) != DW_TAG_structure_type) {
1015                         pr_warning("%s is not a data structure.\n", varname);
1016                         return -EINVAL;
1017                 }
1018
1019                 ref = zalloc(sizeof(struct probe_trace_arg_ref));
1020                 if (ref == NULL)
1021                         return -ENOMEM;
1022                 if (*ref_ptr)
1023                         (*ref_ptr)->next = ref;
1024                 else
1025                         *ref_ptr = ref;
1026         } else {
1027                 /* Verify it is a data structure  */
1028                 if (tag != DW_TAG_structure_type) {
1029                         pr_warning("%s is not a data structure.\n", varname);
1030                         return -EINVAL;
1031                 }
1032                 if (field->name[0] == '[') {
1033                         pr_err("Semantic error: %s is not a pointor"
1034                                " nor array.\n", varname);
1035                         return -EINVAL;
1036                 }
1037                 if (field->ref) {
1038                         pr_err("Semantic error: %s must be referred by '.'\n",
1039                                field->name);
1040                         return -EINVAL;
1041                 }
1042                 if (!ref) {
1043                         pr_warning("Structure on a register is not "
1044                                    "supported yet.\n");
1045                         return -ENOTSUP;
1046                 }
1047         }
1048
1049         if (die_find_member(&type, field->name, die_mem) == NULL) {
1050                 pr_warning("%s(tyep:%s) has no member %s.\n", varname,
1051                            dwarf_diename(&type), field->name);
1052                 return -EINVAL;
1053         }
1054
1055         /* Get the offset of the field */
1056         ret = die_get_data_member_location(die_mem, &offs);
1057         if (ret < 0) {
1058                 pr_warning("Failed to get the offset of %s.\n", field->name);
1059                 return ret;
1060         }
1061         ref->offset += (long)offs;
1062
1063 next:
1064         /* Converting next field */
1065         if (field->next)
1066                 return convert_variable_fields(die_mem, field->name,
1067                                         field->next, &ref, die_mem);
1068         else
1069                 return 0;
1070 }
1071
1072 /* Show a variables in kprobe event format */
1073 static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
1074 {
1075         Dwarf_Die die_mem;
1076         int ret;
1077
1078         pr_debug("Converting variable %s into trace event.\n",
1079                  dwarf_diename(vr_die));
1080
1081         ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
1082                                         pf->tvar);
1083         if (ret == -ENOENT)
1084                 pr_err("Failed to find the location of %s at this address.\n"
1085                        " Perhaps, it has been optimized out.\n", pf->pvar->var);
1086         else if (ret == -ENOTSUP)
1087                 pr_err("Sorry, we don't support this variable location yet.\n");
1088         else if (pf->pvar->field) {
1089                 ret = convert_variable_fields(vr_die, pf->pvar->var,
1090                                               pf->pvar->field, &pf->tvar->ref,
1091                                               &die_mem);
1092                 vr_die = &die_mem;
1093         }
1094         if (ret == 0)
1095                 ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
1096         /* *expr will be cached in libdw. Don't free it. */
1097         return ret;
1098 }
1099
1100 /* Find a variable in a subprogram die */
1101 static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
1102 {
1103         Dwarf_Die vr_die, *scopes;
1104         char buf[32], *ptr;
1105         int ret, nscopes;
1106
1107         if (!is_c_varname(pf->pvar->var)) {
1108                 /* Copy raw parameters */
1109                 pf->tvar->value = strdup(pf->pvar->var);
1110                 if (pf->tvar->value == NULL)
1111                         return -ENOMEM;
1112                 if (pf->pvar->type) {
1113                         pf->tvar->type = strdup(pf->pvar->type);
1114                         if (pf->tvar->type == NULL)
1115                                 return -ENOMEM;
1116                 }
1117                 if (pf->pvar->name) {
1118                         pf->tvar->name = strdup(pf->pvar->name);
1119                         if (pf->tvar->name == NULL)
1120                                 return -ENOMEM;
1121                 } else
1122                         pf->tvar->name = NULL;
1123                 return 0;
1124         }
1125
1126         if (pf->pvar->name)
1127                 pf->tvar->name = strdup(pf->pvar->name);
1128         else {
1129                 ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
1130                 if (ret < 0)
1131                         return ret;
1132                 ptr = strchr(buf, ':'); /* Change type separator to _ */
1133                 if (ptr)
1134                         *ptr = '_';
1135                 pf->tvar->name = strdup(buf);
1136         }
1137         if (pf->tvar->name == NULL)
1138                 return -ENOMEM;
1139
1140         pr_debug("Searching '%s' variable in context.\n",
1141                  pf->pvar->var);
1142         /* Search child die for local variables and parameters. */
1143         if (die_find_variable_at(sp_die, pf->pvar->var, pf->addr, &vr_die))
1144                 ret = convert_variable(&vr_die, pf);
1145         else {
1146                 /* Search upper class */
1147                 nscopes = dwarf_getscopes_die(sp_die, &scopes);
1148                 while (nscopes-- > 1) {
1149                         pr_debug("Searching variables in %s\n",
1150                                  dwarf_diename(&scopes[nscopes]));
1151                         /* We should check this scope, so give dummy address */
1152                         if (die_find_variable_at(&scopes[nscopes],
1153                                                  pf->pvar->var, 0,
1154                                                  &vr_die)) {
1155                                 ret = convert_variable(&vr_die, pf);
1156                                 goto found;
1157                         }
1158                 }
1159                 if (scopes)
1160                         free(scopes);
1161                 ret = -ENOENT;
1162         }
1163 found:
1164         if (ret < 0)
1165                 pr_warning("Failed to find '%s' in this function.\n",
1166                            pf->pvar->var);
1167         return ret;
1168 }
1169
1170 /* Convert subprogram DIE to trace point */
1171 static int convert_to_trace_point(Dwarf_Die *sp_die, Dwarf_Addr paddr,
1172                                   bool retprobe, struct probe_trace_point *tp)
1173 {
1174         Dwarf_Addr eaddr;
1175         const char *name;
1176
1177         /* Copy the name of probe point */
1178         name = dwarf_diename(sp_die);
1179         if (name) {
1180                 if (dwarf_entrypc(sp_die, &eaddr) != 0) {
1181                         pr_warning("Failed to get entry address of %s\n",
1182                                    dwarf_diename(sp_die));
1183                         return -ENOENT;
1184                 }
1185                 tp->symbol = strdup(name);
1186                 if (tp->symbol == NULL)
1187                         return -ENOMEM;
1188                 tp->offset = (unsigned long)(paddr - eaddr);
1189         } else
1190                 /* This function has no name. */
1191                 tp->offset = (unsigned long)paddr;
1192
1193         /* Return probe must be on the head of a subprogram */
1194         if (retprobe) {
1195                 if (eaddr != paddr) {
1196                         pr_warning("Return probe must be on the head of"
1197                                    " a real function.\n");
1198                         return -EINVAL;
1199                 }
1200                 tp->retprobe = true;
1201         }
1202
1203         return 0;
1204 }
1205
1206 /* Call probe_finder callback with real subprogram DIE */
1207 static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
1208 {
1209         Dwarf_Die die_mem;
1210         Dwarf_Attribute fb_attr;
1211         size_t nops;
1212         int ret;
1213
1214         /* If no real subprogram, find a real one */
1215         if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
1216                 sp_die = die_find_real_subprogram(&pf->cu_die,
1217                                                   pf->addr, &die_mem);
1218                 if (!sp_die) {
1219                         pr_warning("Failed to find probe point in any "
1220                                    "functions.\n");
1221                         return -ENOENT;
1222                 }
1223         }
1224
1225         /* Get the frame base attribute/ops */
1226         dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
1227         ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
1228         if (ret <= 0 || nops == 0) {
1229                 pf->fb_ops = NULL;
1230 #if _ELFUTILS_PREREQ(0, 142)
1231         } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
1232                    pf->cfi != NULL) {
1233                 Dwarf_Frame *frame;
1234                 if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
1235                     dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
1236                         pr_warning("Failed to get call frame on 0x%jx\n",
1237                                    (uintmax_t)pf->addr);
1238                         return -ENOENT;
1239                 }
1240 #endif
1241         }
1242
1243         /* Call finder's callback handler */
1244         ret = pf->callback(sp_die, pf);
1245
1246         /* *pf->fb_ops will be cached in libdw. Don't free it. */
1247         pf->fb_ops = NULL;
1248
1249         return ret;
1250 }
1251
1252 static int probe_point_line_walker(const char *fname, int lineno,
1253                                    Dwarf_Addr addr, void *data)
1254 {
1255         struct probe_finder *pf = data;
1256         int ret;
1257
1258         if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
1259                 return 0;
1260
1261         pf->addr = addr;
1262         ret = call_probe_finder(NULL, pf);
1263
1264         /* Continue if no error, because the line will be in inline function */
1265         return ret < 0 ? ret : 0;
1266 }
1267
1268 /* Find probe point from its line number */
1269 static int find_probe_point_by_line(struct probe_finder *pf)
1270 {
1271         return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
1272 }
1273
1274 /* Find lines which match lazy pattern */
1275 static int find_lazy_match_lines(struct list_head *head,
1276                                  const char *fname, const char *pat)
1277 {
1278         FILE *fp;
1279         char *line = NULL;
1280         size_t line_len;
1281         ssize_t len;
1282         int count = 0, linenum = 1;
1283
1284         fp = fopen(fname, "r");
1285         if (!fp) {
1286                 pr_warning("Failed to open %s: %s\n", fname, strerror(errno));
1287                 return -errno;
1288         }
1289
1290         while ((len = getline(&line, &line_len, fp)) > 0) {
1291
1292                 if (line[len - 1] == '\n')
1293                         line[len - 1] = '\0';
1294
1295                 if (strlazymatch(line, pat)) {
1296                         line_list__add_line(head, linenum);
1297                         count++;
1298                 }
1299                 linenum++;
1300         }
1301
1302         if (ferror(fp))
1303                 count = -errno;
1304         free(line);
1305         fclose(fp);
1306
1307         if (count == 0)
1308                 pr_debug("No matched lines found in %s.\n", fname);
1309         return count;
1310 }
1311
1312 static int probe_point_lazy_walker(const char *fname, int lineno,
1313                                    Dwarf_Addr addr, void *data)
1314 {
1315         struct probe_finder *pf = data;
1316         int ret;
1317
1318         if (!line_list__has_line(&pf->lcache, lineno) ||
1319             strtailcmp(fname, pf->fname) != 0)
1320                 return 0;
1321
1322         pr_debug("Probe line found: line:%d addr:0x%llx\n",
1323                  lineno, (unsigned long long)addr);
1324         pf->addr = addr;
1325         ret = call_probe_finder(NULL, pf);
1326
1327         /*
1328          * Continue if no error, because the lazy pattern will match
1329          * to other lines
1330          */
1331         return ret < 0 ?: 0;
1332 }
1333
1334 /* Find probe points from lazy pattern  */
1335 static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
1336 {
1337         int ret = 0;
1338
1339         if (list_empty(&pf->lcache)) {
1340                 /* Matching lazy line pattern */
1341                 ret = find_lazy_match_lines(&pf->lcache, pf->fname,
1342                                             pf->pev->point.lazy_line);
1343                 if (ret <= 0)
1344                         return ret;
1345         }
1346
1347         return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
1348 }
1349
1350 /* Callback parameter with return value */
1351 struct dwarf_callback_param {
1352         void *data;
1353         int retval;
1354 };
1355
1356 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
1357 {
1358         struct dwarf_callback_param *param = data;
1359         struct probe_finder *pf = param->data;
1360         struct perf_probe_point *pp = &pf->pev->point;
1361         Dwarf_Addr addr;
1362
1363         if (pp->lazy_line)
1364                 param->retval = find_probe_point_lazy(in_die, pf);
1365         else {
1366                 /* Get probe address */
1367                 if (dwarf_entrypc(in_die, &addr) != 0) {
1368                         pr_warning("Failed to get entry address of %s.\n",
1369                                    dwarf_diename(in_die));
1370                         param->retval = -ENOENT;
1371                         return DWARF_CB_ABORT;
1372                 }
1373                 pf->addr = addr;
1374                 pf->addr += pp->offset;
1375                 pr_debug("found inline addr: 0x%jx\n",
1376                          (uintmax_t)pf->addr);
1377
1378                 param->retval = call_probe_finder(in_die, pf);
1379                 if (param->retval < 0)
1380                         return DWARF_CB_ABORT;
1381         }
1382
1383         return DWARF_CB_OK;
1384 }
1385
1386 /* Search function from function name */
1387 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
1388 {
1389         struct dwarf_callback_param *param = data;
1390         struct probe_finder *pf = param->data;
1391         struct perf_probe_point *pp = &pf->pev->point;
1392
1393         /* Check tag and diename */
1394         if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
1395             !die_compare_name(sp_die, pp->function))
1396                 return DWARF_CB_OK;
1397
1398         pf->fname = dwarf_decl_file(sp_die);
1399         if (pp->line) { /* Function relative line */
1400                 dwarf_decl_line(sp_die, &pf->lno);
1401                 pf->lno += pp->line;
1402                 param->retval = find_probe_point_by_line(pf);
1403         } else if (!dwarf_func_inline(sp_die)) {
1404                 /* Real function */
1405                 if (pp->lazy_line)
1406                         param->retval = find_probe_point_lazy(sp_die, pf);
1407                 else {
1408                         if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
1409                                 pr_warning("Failed to get entry address of "
1410                                            "%s.\n", dwarf_diename(sp_die));
1411                                 param->retval = -ENOENT;
1412                                 return DWARF_CB_ABORT;
1413                         }
1414                         pf->addr += pp->offset;
1415                         /* TODO: Check the address in this function */
1416                         param->retval = call_probe_finder(sp_die, pf);
1417                 }
1418         } else {
1419                 struct dwarf_callback_param _param = {.data = (void *)pf,
1420                                                       .retval = 0};
1421                 /* Inlined function: search instances */
1422                 dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
1423                                             &_param);
1424                 param->retval = _param.retval;
1425         }
1426
1427         return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1428 }
1429
1430 static int find_probe_point_by_func(struct probe_finder *pf)
1431 {
1432         struct dwarf_callback_param _param = {.data = (void *)pf,
1433                                               .retval = 0};
1434         dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
1435         return _param.retval;
1436 }
1437
1438 /* Find probe points from debuginfo */
1439 static int find_probes(int fd, struct probe_finder *pf)
1440 {
1441         struct perf_probe_point *pp = &pf->pev->point;
1442         Dwarf_Off off, noff;
1443         size_t cuhl;
1444         Dwarf_Die *diep;
1445         Dwarf *dbg = NULL;
1446         Dwfl *dwfl;
1447         Dwarf_Addr bias;        /* Currently ignored */
1448         int ret = 0;
1449
1450         dbg = dwfl_init_offline_dwarf(fd, &dwfl, &bias);
1451         if (!dbg) {
1452                 pr_warning("No debug information found in the vmlinux - "
1453                         "please rebuild with CONFIG_DEBUG_INFO=y.\n");
1454                 return -EBADF;
1455         }
1456
1457 #if _ELFUTILS_PREREQ(0, 142)
1458         /* Get the call frame information from this dwarf */
1459         pf->cfi = dwarf_getcfi(dbg);
1460 #endif
1461
1462         off = 0;
1463         line_list__init(&pf->lcache);
1464         /* Loop on CUs (Compilation Unit) */
1465         while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
1466                 /* Get the DIE(Debugging Information Entry) of this CU */
1467                 diep = dwarf_offdie(dbg, off + cuhl, &pf->cu_die);
1468                 if (!diep)
1469                         continue;
1470
1471                 /* Check if target file is included. */
1472                 if (pp->file)
1473                         pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1474                 else
1475                         pf->fname = NULL;
1476
1477                 if (!pp->file || pf->fname) {
1478                         if (pp->function)
1479                                 ret = find_probe_point_by_func(pf);
1480                         else if (pp->lazy_line)
1481                                 ret = find_probe_point_lazy(NULL, pf);
1482                         else {
1483                                 pf->lno = pp->line;
1484                                 ret = find_probe_point_by_line(pf);
1485                         }
1486                         if (ret < 0)
1487                                 break;
1488                 }
1489                 off = noff;
1490         }
1491         line_list__free(&pf->lcache);
1492         if (dwfl)
1493                 dwfl_end(dwfl);
1494
1495         return ret;
1496 }
1497
1498 /* Add a found probe point into trace event list */
1499 static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
1500 {
1501         struct trace_event_finder *tf =
1502                         container_of(pf, struct trace_event_finder, pf);
1503         struct probe_trace_event *tev;
1504         int ret, i;
1505
1506         /* Check number of tevs */
1507         if (tf->ntevs == tf->max_tevs) {
1508                 pr_warning("Too many( > %d) probe point found.\n",
1509                            tf->max_tevs);
1510                 return -ERANGE;
1511         }
1512         tev = &tf->tevs[tf->ntevs++];
1513
1514         ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
1515                                      &tev->point);
1516         if (ret < 0)
1517                 return ret;
1518
1519         pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
1520                  tev->point.offset);
1521
1522         /* Find each argument */
1523         tev->nargs = pf->pev->nargs;
1524         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1525         if (tev->args == NULL)
1526                 return -ENOMEM;
1527         for (i = 0; i < pf->pev->nargs; i++) {
1528                 pf->pvar = &pf->pev->args[i];
1529                 pf->tvar = &tev->args[i];
1530                 ret = find_variable(sp_die, pf);
1531                 if (ret != 0)
1532                         return ret;
1533         }
1534
1535         return 0;
1536 }
1537
1538 /* Find probe_trace_events specified by perf_probe_event from debuginfo */
1539 int find_probe_trace_events(int fd, struct perf_probe_event *pev,
1540                             struct probe_trace_event **tevs, int max_tevs)
1541 {
1542         struct trace_event_finder tf = {
1543                         .pf = {.pev = pev, .callback = add_probe_trace_event},
1544                         .max_tevs = max_tevs};
1545         int ret;
1546
1547         /* Allocate result tevs array */
1548         *tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
1549         if (*tevs == NULL)
1550                 return -ENOMEM;
1551
1552         tf.tevs = *tevs;
1553         tf.ntevs = 0;
1554
1555         ret = find_probes(fd, &tf.pf);
1556         if (ret < 0) {
1557                 free(*tevs);
1558                 *tevs = NULL;
1559                 return ret;
1560         }
1561
1562         return (ret < 0) ? ret : tf.ntevs;
1563 }
1564
1565 #define MAX_VAR_LEN 64
1566
1567 /* Collect available variables in this scope */
1568 static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
1569 {
1570         struct available_var_finder *af = data;
1571         struct variable_list *vl;
1572         char buf[MAX_VAR_LEN];
1573         int tag, ret;
1574
1575         vl = &af->vls[af->nvls - 1];
1576
1577         tag = dwarf_tag(die_mem);
1578         if (tag == DW_TAG_formal_parameter ||
1579             tag == DW_TAG_variable) {
1580                 ret = convert_variable_location(die_mem, af->pf.addr,
1581                                                 af->pf.fb_ops, NULL);
1582                 if (ret == 0) {
1583                         ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
1584                         pr_debug2("Add new var: %s\n", buf);
1585                         if (ret > 0)
1586                                 strlist__add(vl->vars, buf);
1587                 }
1588         }
1589
1590         if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1591                 return DIE_FIND_CB_CONTINUE;
1592         else
1593                 return DIE_FIND_CB_SIBLING;
1594 }
1595
1596 /* Add a found vars into available variables list */
1597 static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
1598 {
1599         struct available_var_finder *af =
1600                         container_of(pf, struct available_var_finder, pf);
1601         struct variable_list *vl;
1602         Dwarf_Die die_mem, *scopes = NULL;
1603         int ret, nscopes;
1604
1605         /* Check number of tevs */
1606         if (af->nvls == af->max_vls) {
1607                 pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
1608                 return -ERANGE;
1609         }
1610         vl = &af->vls[af->nvls++];
1611
1612         ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
1613                                      &vl->point);
1614         if (ret < 0)
1615                 return ret;
1616
1617         pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
1618                  vl->point.offset);
1619
1620         /* Find local variables */
1621         vl->vars = strlist__new(true, NULL);
1622         if (vl->vars == NULL)
1623                 return -ENOMEM;
1624         af->child = true;
1625         die_find_child(sp_die, collect_variables_cb, (void *)af, &die_mem);
1626
1627         /* Find external variables */
1628         if (!af->externs)
1629                 goto out;
1630         /* Don't need to search child DIE for externs. */
1631         af->child = false;
1632         nscopes = dwarf_getscopes_die(sp_die, &scopes);
1633         while (nscopes-- > 1)
1634                 die_find_child(&scopes[nscopes], collect_variables_cb,
1635                                (void *)af, &die_mem);
1636         if (scopes)
1637                 free(scopes);
1638
1639 out:
1640         if (strlist__empty(vl->vars)) {
1641                 strlist__delete(vl->vars);
1642                 vl->vars = NULL;
1643         }
1644
1645         return ret;
1646 }
1647
1648 /* Find available variables at given probe point */
1649 int find_available_vars_at(int fd, struct perf_probe_event *pev,
1650                            struct variable_list **vls, int max_vls,
1651                            bool externs)
1652 {
1653         struct available_var_finder af = {
1654                         .pf = {.pev = pev, .callback = add_available_vars},
1655                         .max_vls = max_vls, .externs = externs};
1656         int ret;
1657
1658         /* Allocate result vls array */
1659         *vls = zalloc(sizeof(struct variable_list) * max_vls);
1660         if (*vls == NULL)
1661                 return -ENOMEM;
1662
1663         af.vls = *vls;
1664         af.nvls = 0;
1665
1666         ret = find_probes(fd, &af.pf);
1667         if (ret < 0) {
1668                 /* Free vlist for error */
1669                 while (af.nvls--) {
1670                         if (af.vls[af.nvls].point.symbol)
1671                                 free(af.vls[af.nvls].point.symbol);
1672                         if (af.vls[af.nvls].vars)
1673                                 strlist__delete(af.vls[af.nvls].vars);
1674                 }
1675                 free(af.vls);
1676                 *vls = NULL;
1677                 return ret;
1678         }
1679
1680         return (ret < 0) ? ret : af.nvls;
1681 }
1682
1683 /* Reverse search */
1684 int find_perf_probe_point(unsigned long addr, struct perf_probe_point *ppt)
1685 {
1686         Dwarf_Die cudie, spdie, indie;
1687         Dwarf *dbg = NULL;
1688         Dwfl *dwfl = NULL;
1689         Dwarf_Line *line;
1690         Dwarf_Addr laddr, eaddr, bias = 0;
1691         const char *tmp;
1692         int lineno, ret = 0;
1693         bool found = false;
1694
1695         /* Open the live linux kernel */
1696         dbg = dwfl_init_live_kernel_dwarf(addr, &dwfl, &bias);
1697         if (!dbg) {
1698                 pr_warning("No debug information found in the vmlinux - "
1699                         "please rebuild with CONFIG_DEBUG_INFO=y.\n");
1700                 ret = -EINVAL;
1701                 goto end;
1702         }
1703
1704         /* Adjust address with bias */
1705         addr += bias;
1706         /* Find cu die */
1707         if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr - bias, &cudie)) {
1708                 pr_warning("Failed to find debug information for address %lx\n",
1709                            addr);
1710                 ret = -EINVAL;
1711                 goto end;
1712         }
1713
1714         /* Find a corresponding line */
1715         line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
1716         if (line) {
1717                 if (dwarf_lineaddr(line, &laddr) == 0 &&
1718                     (Dwarf_Addr)addr == laddr &&
1719                     dwarf_lineno(line, &lineno) == 0) {
1720                         tmp = dwarf_linesrc(line, NULL, NULL);
1721                         if (tmp) {
1722                                 ppt->line = lineno;
1723                                 ppt->file = strdup(tmp);
1724                                 if (ppt->file == NULL) {
1725                                         ret = -ENOMEM;
1726                                         goto end;
1727                                 }
1728                                 found = true;
1729                         }
1730                 }
1731         }
1732
1733         /* Find a corresponding function */
1734         if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
1735                 tmp = dwarf_diename(&spdie);
1736                 if (!tmp || dwarf_entrypc(&spdie, &eaddr) != 0)
1737                         goto end;
1738
1739                 if (ppt->line) {
1740                         if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
1741                                                 &indie)) {
1742                                 /* addr in an inline function */
1743                                 tmp = dwarf_diename(&indie);
1744                                 if (!tmp)
1745                                         goto end;
1746                                 ret = dwarf_decl_line(&indie, &lineno);
1747                         } else {
1748                                 if (eaddr == addr) {    /* Function entry */
1749                                         lineno = ppt->line;
1750                                         ret = 0;
1751                                 } else
1752                                         ret = dwarf_decl_line(&spdie, &lineno);
1753                         }
1754                         if (ret == 0) {
1755                                 /* Make a relative line number */
1756                                 ppt->line -= lineno;
1757                                 goto found;
1758                         }
1759                 }
1760                 /* We don't have a line number, let's use offset */
1761                 ppt->offset = addr - (unsigned long)eaddr;
1762 found:
1763                 ppt->function = strdup(tmp);
1764                 if (ppt->function == NULL) {
1765                         ret = -ENOMEM;
1766                         goto end;
1767                 }
1768                 found = true;
1769         }
1770
1771 end:
1772         if (dwfl)
1773                 dwfl_end(dwfl);
1774         if (ret >= 0)
1775                 ret = found ? 1 : 0;
1776         return ret;
1777 }
1778
1779 /* Add a line and store the src path */
1780 static int line_range_add_line(const char *src, unsigned int lineno,
1781                                struct line_range *lr)
1782 {
1783         /* Copy source path */
1784         if (!lr->path) {
1785                 lr->path = strdup(src);
1786                 if (lr->path == NULL)
1787                         return -ENOMEM;
1788         }
1789         return line_list__add_line(&lr->line_list, lineno);
1790 }
1791
1792 static int line_range_walk_cb(const char *fname, int lineno,
1793                               Dwarf_Addr addr __used,
1794                               void *data)
1795 {
1796         struct line_finder *lf = data;
1797
1798         if ((strtailcmp(fname, lf->fname) != 0) ||
1799             (lf->lno_s > lineno || lf->lno_e < lineno))
1800                 return 0;
1801
1802         if (line_range_add_line(fname, lineno, lf->lr) < 0)
1803                 return -EINVAL;
1804
1805         return 0;
1806 }
1807
1808 /* Find line range from its line number */
1809 static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1810 {
1811         int ret;
1812
1813         ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
1814
1815         /* Update status */
1816         if (ret >= 0)
1817                 if (!list_empty(&lf->lr->line_list))
1818                         ret = lf->found = 1;
1819                 else
1820                         ret = 0;        /* Lines are not found */
1821         else {
1822                 free(lf->lr->path);
1823                 lf->lr->path = NULL;
1824         }
1825         return ret;
1826 }
1827
1828 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
1829 {
1830         struct dwarf_callback_param *param = data;
1831
1832         param->retval = find_line_range_by_line(in_die, param->data);
1833         return DWARF_CB_ABORT;  /* No need to find other instances */
1834 }
1835
1836 /* Search function from function name */
1837 static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1838 {
1839         struct dwarf_callback_param *param = data;
1840         struct line_finder *lf = param->data;
1841         struct line_range *lr = lf->lr;
1842
1843         if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
1844             die_compare_name(sp_die, lr->function)) {
1845                 lf->fname = dwarf_decl_file(sp_die);
1846                 dwarf_decl_line(sp_die, &lr->offset);
1847                 pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1848                 lf->lno_s = lr->offset + lr->start;
1849                 if (lf->lno_s < 0)      /* Overflow */
1850                         lf->lno_s = INT_MAX;
1851                 lf->lno_e = lr->offset + lr->end;
1852                 if (lf->lno_e < 0)      /* Overflow */
1853                         lf->lno_e = INT_MAX;
1854                 pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1855                 lr->start = lf->lno_s;
1856                 lr->end = lf->lno_e;
1857                 if (dwarf_func_inline(sp_die)) {
1858                         struct dwarf_callback_param _param;
1859                         _param.data = (void *)lf;
1860                         _param.retval = 0;
1861                         dwarf_func_inline_instances(sp_die,
1862                                                     line_range_inline_cb,
1863                                                     &_param);
1864                         param->retval = _param.retval;
1865                 } else
1866                         param->retval = find_line_range_by_line(sp_die, lf);
1867                 return DWARF_CB_ABORT;
1868         }
1869         return DWARF_CB_OK;
1870 }
1871
1872 static int find_line_range_by_func(struct line_finder *lf)
1873 {
1874         struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1875         dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
1876         return param.retval;
1877 }
1878
1879 int find_line_range(int fd, struct line_range *lr)
1880 {
1881         struct line_finder lf = {.lr = lr, .found = 0};
1882         int ret = 0;
1883         Dwarf_Off off = 0, noff;
1884         size_t cuhl;
1885         Dwarf_Die *diep;
1886         Dwarf *dbg = NULL;
1887         Dwfl *dwfl;
1888         Dwarf_Addr bias;        /* Currently ignored */
1889         const char *comp_dir;
1890
1891         dbg = dwfl_init_offline_dwarf(fd, &dwfl, &bias);
1892         if (!dbg) {
1893                 pr_warning("No debug information found in the vmlinux - "
1894                         "please rebuild with CONFIG_DEBUG_INFO=y.\n");
1895                 return -EBADF;
1896         }
1897
1898         /* Loop on CUs (Compilation Unit) */
1899         while (!lf.found && ret >= 0) {
1900                 if (dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) != 0)
1901                         break;
1902
1903                 /* Get the DIE(Debugging Information Entry) of this CU */
1904                 diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
1905                 if (!diep)
1906                         continue;
1907
1908                 /* Check if target file is included. */
1909                 if (lr->file)
1910                         lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1911                 else
1912                         lf.fname = 0;
1913
1914                 if (!lr->file || lf.fname) {
1915                         if (lr->function)
1916                                 ret = find_line_range_by_func(&lf);
1917                         else {
1918                                 lf.lno_s = lr->start;
1919                                 lf.lno_e = lr->end;
1920                                 ret = find_line_range_by_line(NULL, &lf);
1921                         }
1922                 }
1923                 off = noff;
1924         }
1925
1926         /* Store comp_dir */
1927         if (lf.found) {
1928                 comp_dir = cu_get_comp_dir(&lf.cu_die);
1929                 if (comp_dir) {
1930                         lr->comp_dir = strdup(comp_dir);
1931                         if (!lr->comp_dir)
1932                                 ret = -ENOMEM;
1933                 }
1934         }
1935
1936         pr_debug("path: %s\n", lr->path);
1937         dwfl_end(dwfl);
1938         return (ret < 0) ? ret : lf.found;
1939 }
1940