11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
24ea42b18SMasami Hiramatsu /*
34ea42b18SMasami Hiramatsu * probe-finder.c : C expression to kprobe event converter
44ea42b18SMasami Hiramatsu *
54ea42b18SMasami Hiramatsu * Written by Masami Hiramatsu <mhiramat@redhat.com>
64ea42b18SMasami Hiramatsu */
74ea42b18SMasami Hiramatsu
8fd20e811SArnaldo Carvalho de Melo #include <inttypes.h>
94ea42b18SMasami Hiramatsu #include <sys/utsname.h>
104ea42b18SMasami Hiramatsu #include <sys/types.h>
114ea42b18SMasami Hiramatsu #include <sys/stat.h>
124ea42b18SMasami Hiramatsu #include <fcntl.h>
134ea42b18SMasami Hiramatsu #include <errno.h>
144ea42b18SMasami Hiramatsu #include <stdio.h>
154ea42b18SMasami Hiramatsu #include <unistd.h>
164ea42b18SMasami Hiramatsu #include <stdlib.h>
174ea42b18SMasami Hiramatsu #include <string.h>
184ea42b18SMasami Hiramatsu #include <stdarg.h>
19cd932c59SIan Munsie #include <dwarf-regs.h>
20074fc0e4SMasami Hiramatsu
21124bb83cSMasami Hiramatsu #include <linux/bitops.h>
227f7c536fSArnaldo Carvalho de Melo #include <linux/zalloc.h>
2389c69c0eSMasami Hiramatsu #include "event.h"
24a15ad2f5SMasami Hiramatsu #include "dso.h"
2589c69c0eSMasami Hiramatsu #include "debug.h"
266f1b6291SNamhyung Kim #include "debuginfo.h"
275a62257aSMasami Hiramatsu #include "intlist.h"
288520a98dSArnaldo Carvalho de Melo #include "strbuf.h"
298ec20b17SArnaldo Carvalho de Melo #include "strlist.h"
309ed7e1b8SChase Douglas #include "symbol.h"
314ea42b18SMasami Hiramatsu #include "probe-finder.h"
32180b2061SMasami Hiramatsu #include "probe-file.h"
33a067558eSArnaldo Carvalho de Melo #include "string2.h"
344ea42b18SMasami Hiramatsu
354984912eSMasami Hiramatsu /* Kprobe tracer basic type is up to u64 */
364984912eSMasami Hiramatsu #define MAX_BASIC_TYPE_BITS 64
374984912eSMasami Hiramatsu
384ea42b18SMasami Hiramatsu /*
394ea42b18SMasami Hiramatsu * Probe finder related functions
404ea42b18SMasami Hiramatsu */
414ea42b18SMasami Hiramatsu
alloc_trace_arg_ref(long offs)420e60836bSSrikar Dronamraju static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
434ea42b18SMasami Hiramatsu {
440e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref;
450e60836bSSrikar Dronamraju ref = zalloc(sizeof(struct probe_trace_arg_ref));
46b7dcb857SMasami Hiramatsu if (ref != NULL)
47b7dcb857SMasami Hiramatsu ref->offset = offs;
48b7dcb857SMasami Hiramatsu return ref;
49b7dcb857SMasami Hiramatsu }
50b7dcb857SMasami Hiramatsu
51cf6eb489SMasami Hiramatsu /*
52cf6eb489SMasami Hiramatsu * Convert a location into trace_arg.
53cf6eb489SMasami Hiramatsu * If tvar == NULL, this just checks variable can be converted.
544d39c89fSIngo Molnar * If fentry == true and vr_die is a parameter, do heuristic search
553d918a12SMasami Hiramatsu * for the location fuzzed by function entry mcount.
56cf6eb489SMasami Hiramatsu */
convert_variable_location(Dwarf_Die * vr_die,Dwarf_Addr addr,Dwarf_Op * fb_ops,Dwarf_Die * sp_die,unsigned int machine,struct probe_trace_arg * tvar)57cf6eb489SMasami Hiramatsu static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
583d918a12SMasami Hiramatsu Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
59293d5b43SMasami Hiramatsu unsigned int machine,
60cf6eb489SMasami Hiramatsu struct probe_trace_arg *tvar)
61b7dcb857SMasami Hiramatsu {
62b7dcb857SMasami Hiramatsu Dwarf_Attribute attr;
633d918a12SMasami Hiramatsu Dwarf_Addr tmp = 0;
64b7dcb857SMasami Hiramatsu Dwarf_Op *op;
65b7dcb857SMasami Hiramatsu size_t nops;
66804b3606SMasami Hiramatsu unsigned int regn;
67804b3606SMasami Hiramatsu Dwarf_Word offs = 0;
684235b045SMasami Hiramatsu bool ref = false;
694ea42b18SMasami Hiramatsu const char *regs;
70349e8d26SHe Kuang int ret, ret2 = 0;
71b7dcb857SMasami Hiramatsu
72632941c4SMasami Hiramatsu if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
73632941c4SMasami Hiramatsu goto static_var;
74632941c4SMasami Hiramatsu
7566f69b21SMasami Hiramatsu /* Constant value */
7666f69b21SMasami Hiramatsu if (dwarf_attr(vr_die, DW_AT_const_value, &attr) &&
7766f69b21SMasami Hiramatsu immediate_value_is_supported()) {
7866f69b21SMasami Hiramatsu Dwarf_Sword snum;
7966f69b21SMasami Hiramatsu
803cb17cceSLi Huafei if (!tvar)
813cb17cceSLi Huafei return 0;
823cb17cceSLi Huafei
8366f69b21SMasami Hiramatsu dwarf_formsdata(&attr, &snum);
8466f69b21SMasami Hiramatsu ret = asprintf(&tvar->value, "\\%ld", (long)snum);
8566f69b21SMasami Hiramatsu
8666f69b21SMasami Hiramatsu return ret < 0 ? -ENOMEM : 0;
8766f69b21SMasami Hiramatsu }
8866f69b21SMasami Hiramatsu
89b7dcb857SMasami Hiramatsu /* TODO: handle more than 1 exprs */
903d918a12SMasami Hiramatsu if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
913d918a12SMasami Hiramatsu return -EINVAL; /* Broken DIE ? */
923d918a12SMasami Hiramatsu if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) {
933d918a12SMasami Hiramatsu ret = dwarf_entrypc(sp_die, &tmp);
94349e8d26SHe Kuang if (ret)
95349e8d26SHe Kuang return -ENOENT;
96349e8d26SHe Kuang
97349e8d26SHe Kuang if (probe_conf.show_location_range &&
98349e8d26SHe Kuang (dwarf_tag(vr_die) == DW_TAG_variable)) {
99349e8d26SHe Kuang ret2 = -ERANGE;
100349e8d26SHe Kuang } else if (addr != tmp ||
101349e8d26SHe Kuang dwarf_tag(vr_die) != DW_TAG_formal_parameter) {
102349e8d26SHe Kuang return -ENOENT;
103349e8d26SHe Kuang }
104349e8d26SHe Kuang
105349e8d26SHe Kuang ret = dwarf_highpc(sp_die, &tmp);
106349e8d26SHe Kuang if (ret)
1073d918a12SMasami Hiramatsu return -ENOENT;
1083d918a12SMasami Hiramatsu /*
1093d918a12SMasami Hiramatsu * This is fuzzed by fentry mcount. We try to find the
1103d918a12SMasami Hiramatsu * parameter location at the earliest address.
1113d918a12SMasami Hiramatsu */
1123d918a12SMasami Hiramatsu for (addr += 1; addr <= tmp; addr++) {
1133d918a12SMasami Hiramatsu if (dwarf_getlocation_addr(&attr, addr, &op,
1143d918a12SMasami Hiramatsu &nops, 1) > 0)
1153d918a12SMasami Hiramatsu goto found;
1163d918a12SMasami Hiramatsu }
117b7dcb857SMasami Hiramatsu return -ENOENT;
118b7dcb857SMasami Hiramatsu }
1193d918a12SMasami Hiramatsu found:
1203d918a12SMasami Hiramatsu if (nops == 0)
1213d918a12SMasami Hiramatsu /* TODO: Support const_value */
1223d918a12SMasami Hiramatsu return -ENOENT;
123b7dcb857SMasami Hiramatsu
124b7dcb857SMasami Hiramatsu if (op->atom == DW_OP_addr) {
125632941c4SMasami Hiramatsu static_var:
126cf6eb489SMasami Hiramatsu if (!tvar)
127349e8d26SHe Kuang return ret2;
128b7dcb857SMasami Hiramatsu /* Static variables on memory (not stack), make @varname */
129b7dcb857SMasami Hiramatsu ret = strlen(dwarf_diename(vr_die));
130b7dcb857SMasami Hiramatsu tvar->value = zalloc(ret + 2);
131b7dcb857SMasami Hiramatsu if (tvar->value == NULL)
132b7dcb857SMasami Hiramatsu return -ENOMEM;
133b7dcb857SMasami Hiramatsu snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
134b7dcb857SMasami Hiramatsu tvar->ref = alloc_trace_arg_ref((long)offs);
135b7dcb857SMasami Hiramatsu if (tvar->ref == NULL)
136b7dcb857SMasami Hiramatsu return -ENOMEM;
137349e8d26SHe Kuang return ret2;
138b7dcb857SMasami Hiramatsu }
1394ea42b18SMasami Hiramatsu
1404ea42b18SMasami Hiramatsu /* If this is based on frame buffer, set the offset */
141804b3606SMasami Hiramatsu if (op->atom == DW_OP_fbreg) {
142cf6eb489SMasami Hiramatsu if (fb_ops == NULL)
143b55a87adSMasami Hiramatsu return -ENOTSUP;
1444235b045SMasami Hiramatsu ref = true;
145804b3606SMasami Hiramatsu offs = op->number;
146cf6eb489SMasami Hiramatsu op = &fb_ops[0];
147804b3606SMasami Hiramatsu }
1484ea42b18SMasami Hiramatsu
149804b3606SMasami Hiramatsu if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
150804b3606SMasami Hiramatsu regn = op->atom - DW_OP_breg0;
151804b3606SMasami Hiramatsu offs += op->number;
1524235b045SMasami Hiramatsu ref = true;
153804b3606SMasami Hiramatsu } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
154804b3606SMasami Hiramatsu regn = op->atom - DW_OP_reg0;
155804b3606SMasami Hiramatsu } else if (op->atom == DW_OP_bregx) {
156804b3606SMasami Hiramatsu regn = op->number;
157804b3606SMasami Hiramatsu offs += op->number2;
1584235b045SMasami Hiramatsu ref = true;
159804b3606SMasami Hiramatsu } else if (op->atom == DW_OP_regx) {
160804b3606SMasami Hiramatsu regn = op->number;
161b55a87adSMasami Hiramatsu } else {
162cf6eb489SMasami Hiramatsu pr_debug("DW_OP %x is not supported.\n", op->atom);
163b55a87adSMasami Hiramatsu return -ENOTSUP;
164b55a87adSMasami Hiramatsu }
1654ea42b18SMasami Hiramatsu
166cf6eb489SMasami Hiramatsu if (!tvar)
167349e8d26SHe Kuang return ret2;
168cf6eb489SMasami Hiramatsu
169293d5b43SMasami Hiramatsu regs = get_dwarf_regstr(regn, machine);
170b55a87adSMasami Hiramatsu if (!regs) {
171cf6eb489SMasami Hiramatsu /* This should be a bug in DWARF or this tool */
1720e43e5d2SMasami Hiramatsu pr_warning("Mapping for the register number %u "
1730e43e5d2SMasami Hiramatsu "missing on this architecture.\n", regn);
174349e8d26SHe Kuang return -ENOTSUP;
175b55a87adSMasami Hiramatsu }
1764ea42b18SMasami Hiramatsu
17702b95dadSMasami Hiramatsu tvar->value = strdup(regs);
17802b95dadSMasami Hiramatsu if (tvar->value == NULL)
17902b95dadSMasami Hiramatsu return -ENOMEM;
18002b95dadSMasami Hiramatsu
1814235b045SMasami Hiramatsu if (ref) {
182b7dcb857SMasami Hiramatsu tvar->ref = alloc_trace_arg_ref((long)offs);
183e334016fSMasami Hiramatsu if (tvar->ref == NULL)
184e334016fSMasami Hiramatsu return -ENOMEM;
1854235b045SMasami Hiramatsu }
186349e8d26SHe Kuang return ret2;
1874ea42b18SMasami Hiramatsu }
1884ea42b18SMasami Hiramatsu
convert_variable_type(Dwarf_Die * vr_die,struct probe_trace_arg * tvar,const char * cast,bool user_access)189b55a87adSMasami Hiramatsu static int convert_variable_type(Dwarf_Die *vr_die,
1900e60836bSSrikar Dronamraju struct probe_trace_arg *tvar,
1911e032f7cSMasami Hiramatsu const char *cast, bool user_access)
1924984912eSMasami Hiramatsu {
1930e60836bSSrikar Dronamraju struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
1944984912eSMasami Hiramatsu Dwarf_Die type;
1954984912eSMasami Hiramatsu char buf[16];
1965f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE];
197bcfc0821SMasami Hiramatsu int bsize, boffs, total;
1984984912eSMasami Hiramatsu int ret;
19992543787SMasami Hiramatsu char prefix;
2004984912eSMasami Hiramatsu
20173317b95SMasami Hiramatsu /* TODO: check all types */
2021873f154SThomas Richter if (cast && strcmp(cast, "string") != 0 && strcmp(cast, "ustring") &&
2031873f154SThomas Richter strcmp(cast, "x") != 0 &&
20419f00b01SNaohiro Aota strcmp(cast, "s") != 0 && strcmp(cast, "u") != 0) {
20573317b95SMasami Hiramatsu /* Non string type is OK */
20692543787SMasami Hiramatsu /* and respect signedness/hexadecimal cast */
20773317b95SMasami Hiramatsu tvar->type = strdup(cast);
20873317b95SMasami Hiramatsu return (tvar->type == NULL) ? -ENOMEM : 0;
20973317b95SMasami Hiramatsu }
21073317b95SMasami Hiramatsu
211bcfc0821SMasami Hiramatsu bsize = dwarf_bitsize(vr_die);
212bcfc0821SMasami Hiramatsu if (bsize > 0) {
213124bb83cSMasami Hiramatsu /* This is a bitfield */
214bcfc0821SMasami Hiramatsu boffs = dwarf_bitoffset(vr_die);
215bcfc0821SMasami Hiramatsu total = dwarf_bytesize(vr_die);
216bcfc0821SMasami Hiramatsu if (boffs < 0 || total < 0)
217bcfc0821SMasami Hiramatsu return -ENOENT;
218*7d8296b2SAlexander Lobakin ret = snprintf(buf, 16, "b%d@%d/%d", bsize, boffs,
219bcfc0821SMasami Hiramatsu BYTES_TO_BITS(total));
220124bb83cSMasami Hiramatsu goto formatted;
221124bb83cSMasami Hiramatsu }
222124bb83cSMasami Hiramatsu
223b55a87adSMasami Hiramatsu if (die_get_real_type(vr_die, &type) == NULL) {
224b55a87adSMasami Hiramatsu pr_warning("Failed to get a type information of %s.\n",
2254984912eSMasami Hiramatsu dwarf_diename(vr_die));
226b55a87adSMasami Hiramatsu return -ENOENT;
227b55a87adSMasami Hiramatsu }
2284984912eSMasami Hiramatsu
229b2a3c12bSMasami Hiramatsu pr_debug("%s type is %s.\n",
230b2a3c12bSMasami Hiramatsu dwarf_diename(vr_die), dwarf_diename(&type));
231b2a3c12bSMasami Hiramatsu
2321e032f7cSMasami Hiramatsu if (cast && (!strcmp(cast, "string") || !strcmp(cast, "ustring"))) {
2331e032f7cSMasami Hiramatsu /* String type */
23473317b95SMasami Hiramatsu ret = dwarf_tag(&type);
23573317b95SMasami Hiramatsu if (ret != DW_TAG_pointer_type &&
23673317b95SMasami Hiramatsu ret != DW_TAG_array_type) {
23773317b95SMasami Hiramatsu pr_warning("Failed to cast into string: "
2380e43e5d2SMasami Hiramatsu "%s(%s) is not a pointer nor array.\n",
23973317b95SMasami Hiramatsu dwarf_diename(vr_die), dwarf_diename(&type));
24073317b95SMasami Hiramatsu return -EINVAL;
24173317b95SMasami Hiramatsu }
24273317b95SMasami Hiramatsu if (die_get_real_type(&type, &type) == NULL) {
2430e43e5d2SMasami Hiramatsu pr_warning("Failed to get a type"
2440e43e5d2SMasami Hiramatsu " information.\n");
24573317b95SMasami Hiramatsu return -ENOENT;
24673317b95SMasami Hiramatsu }
2477ce28b5bSHyeoncheol Lee if (ret == DW_TAG_pointer_type) {
24873317b95SMasami Hiramatsu while (*ref_ptr)
24973317b95SMasami Hiramatsu ref_ptr = &(*ref_ptr)->next;
25073317b95SMasami Hiramatsu /* Add new reference with offset +0 */
2510e60836bSSrikar Dronamraju *ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
25273317b95SMasami Hiramatsu if (*ref_ptr == NULL) {
25373317b95SMasami Hiramatsu pr_warning("Out of memory error\n");
25473317b95SMasami Hiramatsu return -ENOMEM;
25573317b95SMasami Hiramatsu }
2561e032f7cSMasami Hiramatsu (*ref_ptr)->user_access = user_access;
25773317b95SMasami Hiramatsu }
25882175633SMasami Hiramatsu if (!die_compare_name(&type, "char") &&
25982175633SMasami Hiramatsu !die_compare_name(&type, "unsigned char")) {
26073317b95SMasami Hiramatsu pr_warning("Failed to cast into string: "
2610e43e5d2SMasami Hiramatsu "%s is not (unsigned) char *.\n",
26273317b95SMasami Hiramatsu dwarf_diename(vr_die));
26373317b95SMasami Hiramatsu return -EINVAL;
26473317b95SMasami Hiramatsu }
26573317b95SMasami Hiramatsu tvar->type = strdup(cast);
26673317b95SMasami Hiramatsu return (tvar->type == NULL) ? -ENOMEM : 0;
26773317b95SMasami Hiramatsu }
26873317b95SMasami Hiramatsu
26919f00b01SNaohiro Aota if (cast && (strcmp(cast, "u") == 0))
27092543787SMasami Hiramatsu prefix = 'u';
27119f00b01SNaohiro Aota else if (cast && (strcmp(cast, "s") == 0))
27292543787SMasami Hiramatsu prefix = 's';
27392543787SMasami Hiramatsu else if (cast && (strcmp(cast, "x") == 0) &&
27492543787SMasami Hiramatsu probe_type_is_available(PROBE_TYPE_X))
27592543787SMasami Hiramatsu prefix = 'x';
27619f00b01SNaohiro Aota else
2779880ce4aSMasami Hiramatsu prefix = die_is_signed_type(&type) ? 's' :
2789880ce4aSMasami Hiramatsu probe_type_is_available(PROBE_TYPE_X) ? 'x' : 'u';
27919f00b01SNaohiro Aota
280bcfc0821SMasami Hiramatsu ret = dwarf_bytesize(&type);
281bcfc0821SMasami Hiramatsu if (ret <= 0)
282124bb83cSMasami Hiramatsu /* No size ... try to use default type */
283124bb83cSMasami Hiramatsu return 0;
284bcfc0821SMasami Hiramatsu ret = BYTES_TO_BITS(ret);
285124bb83cSMasami Hiramatsu
2864984912eSMasami Hiramatsu /* Check the bitwidth */
2874984912eSMasami Hiramatsu if (ret > MAX_BASIC_TYPE_BITS) {
288124bb83cSMasami Hiramatsu pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
2894984912eSMasami Hiramatsu dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
2904984912eSMasami Hiramatsu ret = MAX_BASIC_TYPE_BITS;
2914984912eSMasami Hiramatsu }
29292543787SMasami Hiramatsu ret = snprintf(buf, 16, "%c%d", prefix, ret);
293124bb83cSMasami Hiramatsu
294124bb83cSMasami Hiramatsu formatted:
295b55a87adSMasami Hiramatsu if (ret < 0 || ret >= 16) {
296b55a87adSMasami Hiramatsu if (ret >= 16)
297b55a87adSMasami Hiramatsu ret = -E2BIG;
298b55a87adSMasami Hiramatsu pr_warning("Failed to convert variable type: %s\n",
299c8b5f2c9SArnaldo Carvalho de Melo str_error_r(-ret, sbuf, sizeof(sbuf)));
300b55a87adSMasami Hiramatsu return ret;
301b55a87adSMasami Hiramatsu }
30273317b95SMasami Hiramatsu tvar->type = strdup(buf);
30373317b95SMasami Hiramatsu if (tvar->type == NULL)
30402b95dadSMasami Hiramatsu return -ENOMEM;
305b55a87adSMasami Hiramatsu return 0;
3064984912eSMasami Hiramatsu }
3074984912eSMasami Hiramatsu
convert_variable_fields(Dwarf_Die * vr_die,const char * varname,struct perf_probe_arg_field * field,struct probe_trace_arg_ref ** ref_ptr,Dwarf_Die * die_mem,bool user_access)308b55a87adSMasami Hiramatsu static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
3097df2f329SMasami Hiramatsu struct perf_probe_arg_field *field,
3100e60836bSSrikar Dronamraju struct probe_trace_arg_ref **ref_ptr,
3111e032f7cSMasami Hiramatsu Dwarf_Die *die_mem, bool user_access)
3127df2f329SMasami Hiramatsu {
3130e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref = *ref_ptr;
3147df2f329SMasami Hiramatsu Dwarf_Die type;
3157df2f329SMasami Hiramatsu Dwarf_Word offs;
316b2a3c12bSMasami Hiramatsu int ret, tag;
3177df2f329SMasami Hiramatsu
3187df2f329SMasami Hiramatsu pr_debug("converting %s in %s\n", field->name, varname);
319b55a87adSMasami Hiramatsu if (die_get_real_type(vr_die, &type) == NULL) {
320b55a87adSMasami Hiramatsu pr_warning("Failed to get the type of %s.\n", varname);
321b55a87adSMasami Hiramatsu return -ENOENT;
322b55a87adSMasami Hiramatsu }
323d0461794SMasami Hiramatsu pr_debug2("Var real type: %s (%x)\n", dwarf_diename(&type),
324d0461794SMasami Hiramatsu (unsigned)dwarf_dieoffset(&type));
325b2a3c12bSMasami Hiramatsu tag = dwarf_tag(&type);
3267df2f329SMasami Hiramatsu
327b2a3c12bSMasami Hiramatsu if (field->name[0] == '[' &&
328b2a3c12bSMasami Hiramatsu (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
329d0461794SMasami Hiramatsu /* Save original type for next field or type */
330b2a3c12bSMasami Hiramatsu memcpy(die_mem, &type, sizeof(*die_mem));
331b2a3c12bSMasami Hiramatsu /* Get the type of this array */
332b2a3c12bSMasami Hiramatsu if (die_get_real_type(&type, &type) == NULL) {
333b2a3c12bSMasami Hiramatsu pr_warning("Failed to get the type of %s.\n", varname);
334b2a3c12bSMasami Hiramatsu return -ENOENT;
335b2a3c12bSMasami Hiramatsu }
336d0461794SMasami Hiramatsu pr_debug2("Array real type: %s (%x)\n", dwarf_diename(&type),
337b2a3c12bSMasami Hiramatsu (unsigned)dwarf_dieoffset(&type));
338b2a3c12bSMasami Hiramatsu if (tag == DW_TAG_pointer_type) {
3390e60836bSSrikar Dronamraju ref = zalloc(sizeof(struct probe_trace_arg_ref));
340b2a3c12bSMasami Hiramatsu if (ref == NULL)
341b2a3c12bSMasami Hiramatsu return -ENOMEM;
342b2a3c12bSMasami Hiramatsu if (*ref_ptr)
343b2a3c12bSMasami Hiramatsu (*ref_ptr)->next = ref;
344b2a3c12bSMasami Hiramatsu else
345b2a3c12bSMasami Hiramatsu *ref_ptr = ref;
346b2a3c12bSMasami Hiramatsu }
347bcfc0821SMasami Hiramatsu ref->offset += dwarf_bytesize(&type) * field->index;
3481e032f7cSMasami Hiramatsu ref->user_access = user_access;
349b2a3c12bSMasami Hiramatsu goto next;
350b2a3c12bSMasami Hiramatsu } else if (tag == DW_TAG_pointer_type) {
3517df2f329SMasami Hiramatsu /* Check the pointer and dereference */
352b55a87adSMasami Hiramatsu if (!field->ref) {
353b55a87adSMasami Hiramatsu pr_err("Semantic error: %s must be referred by '->'\n",
3547df2f329SMasami Hiramatsu field->name);
355b55a87adSMasami Hiramatsu return -EINVAL;
356b55a87adSMasami Hiramatsu }
3577df2f329SMasami Hiramatsu /* Get the type pointed by this pointer */
358b55a87adSMasami Hiramatsu if (die_get_real_type(&type, &type) == NULL) {
359b55a87adSMasami Hiramatsu pr_warning("Failed to get the type of %s.\n", varname);
360b55a87adSMasami Hiramatsu return -ENOENT;
361b55a87adSMasami Hiramatsu }
36212e5a7aeSMasami Hiramatsu /* Verify it is a data structure */
3637b0295b3SHyeoncheol Lee tag = dwarf_tag(&type);
3647b0295b3SHyeoncheol Lee if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
36503440c4eSMasahiro Yamada pr_warning("%s is not a data structure nor a union.\n",
3667b0295b3SHyeoncheol Lee varname);
367b55a87adSMasami Hiramatsu return -EINVAL;
368b55a87adSMasami Hiramatsu }
36912e5a7aeSMasami Hiramatsu
3700e60836bSSrikar Dronamraju ref = zalloc(sizeof(struct probe_trace_arg_ref));
371e334016fSMasami Hiramatsu if (ref == NULL)
372e334016fSMasami Hiramatsu return -ENOMEM;
3737df2f329SMasami Hiramatsu if (*ref_ptr)
3747df2f329SMasami Hiramatsu (*ref_ptr)->next = ref;
3757df2f329SMasami Hiramatsu else
3767df2f329SMasami Hiramatsu *ref_ptr = ref;
3777df2f329SMasami Hiramatsu } else {
37812e5a7aeSMasami Hiramatsu /* Verify it is a data structure */
3797b0295b3SHyeoncheol Lee if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
38003440c4eSMasahiro Yamada pr_warning("%s is not a data structure nor a union.\n",
3817b0295b3SHyeoncheol Lee varname);
382b55a87adSMasami Hiramatsu return -EINVAL;
383b55a87adSMasami Hiramatsu }
384b2a3c12bSMasami Hiramatsu if (field->name[0] == '[') {
385d939be3aSMasanari Iida pr_err("Semantic error: %s is not a pointer"
3860e43e5d2SMasami Hiramatsu " nor array.\n", varname);
387b2a3c12bSMasami Hiramatsu return -EINVAL;
388b2a3c12bSMasami Hiramatsu }
3894d39c89fSIngo Molnar /* While processing unnamed field, we don't care about this */
390c7273835SMasami Hiramatsu if (field->ref && dwarf_diename(vr_die)) {
391b55a87adSMasami Hiramatsu pr_err("Semantic error: %s must be referred by '.'\n",
3927df2f329SMasami Hiramatsu field->name);
393b55a87adSMasami Hiramatsu return -EINVAL;
394b55a87adSMasami Hiramatsu }
395b55a87adSMasami Hiramatsu if (!ref) {
396b55a87adSMasami Hiramatsu pr_warning("Structure on a register is not "
397b55a87adSMasami Hiramatsu "supported yet.\n");
398b55a87adSMasami Hiramatsu return -ENOTSUP;
399b55a87adSMasami Hiramatsu }
4007df2f329SMasami Hiramatsu }
4017df2f329SMasami Hiramatsu
402b55a87adSMasami Hiramatsu if (die_find_member(&type, field->name, die_mem) == NULL) {
4039ef0438aSArnaldo Carvalho de Melo pr_warning("%s(type:%s) has no member %s.\n", varname,
4047df2f329SMasami Hiramatsu dwarf_diename(&type), field->name);
405b55a87adSMasami Hiramatsu return -EINVAL;
406b55a87adSMasami Hiramatsu }
4077df2f329SMasami Hiramatsu
4087df2f329SMasami Hiramatsu /* Get the offset of the field */
4097b0295b3SHyeoncheol Lee if (tag == DW_TAG_union_type) {
4107b0295b3SHyeoncheol Lee offs = 0;
4117b0295b3SHyeoncheol Lee } else {
412de1439d8SMasami Hiramatsu ret = die_get_data_member_location(die_mem, &offs);
413de1439d8SMasami Hiramatsu if (ret < 0) {
4147b0295b3SHyeoncheol Lee pr_warning("Failed to get the offset of %s.\n",
4157b0295b3SHyeoncheol Lee field->name);
416de1439d8SMasami Hiramatsu return ret;
417b55a87adSMasami Hiramatsu }
4187b0295b3SHyeoncheol Lee }
4197df2f329SMasami Hiramatsu ref->offset += (long)offs;
4201e032f7cSMasami Hiramatsu ref->user_access = user_access;
4217df2f329SMasami Hiramatsu
422c7273835SMasami Hiramatsu /* If this member is unnamed, we need to reuse this field */
423c7273835SMasami Hiramatsu if (!dwarf_diename(die_mem))
424c7273835SMasami Hiramatsu return convert_variable_fields(die_mem, varname, field,
4251e032f7cSMasami Hiramatsu &ref, die_mem, user_access);
426c7273835SMasami Hiramatsu
427b2a3c12bSMasami Hiramatsu next:
4287df2f329SMasami Hiramatsu /* Converting next field */
4297df2f329SMasami Hiramatsu if (field->next)
430b55a87adSMasami Hiramatsu return convert_variable_fields(die_mem, field->name,
4311e032f7cSMasami Hiramatsu field->next, &ref, die_mem, user_access);
432b55a87adSMasami Hiramatsu else
433b55a87adSMasami Hiramatsu return 0;
4347df2f329SMasami Hiramatsu }
4357df2f329SMasami Hiramatsu
print_var_not_found(const char * varname)436cb402730SMasami Hiramatsu static void print_var_not_found(const char *varname)
437cb402730SMasami Hiramatsu {
438cb402730SMasami Hiramatsu pr_err("Failed to find the location of the '%s' variable at this address.\n"
439cb402730SMasami Hiramatsu " Perhaps it has been optimized out.\n"
440cb402730SMasami Hiramatsu " Use -V with the --range option to show '%s' location range.\n",
441cb402730SMasami Hiramatsu varname, varname);
442cb402730SMasami Hiramatsu }
443cb402730SMasami Hiramatsu
4444ea42b18SMasami Hiramatsu /* Show a variables in kprobe event format */
convert_variable(Dwarf_Die * vr_die,struct probe_finder * pf)445b55a87adSMasami Hiramatsu static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
4464ea42b18SMasami Hiramatsu {
4474984912eSMasami Hiramatsu Dwarf_Die die_mem;
4484ea42b18SMasami Hiramatsu int ret;
4494ea42b18SMasami Hiramatsu
450b7dcb857SMasami Hiramatsu pr_debug("Converting variable %s into trace event.\n",
451b7dcb857SMasami Hiramatsu dwarf_diename(vr_die));
452804b3606SMasami Hiramatsu
453cf6eb489SMasami Hiramatsu ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
454293d5b43SMasami Hiramatsu &pf->sp_die, pf->machine, pf->tvar);
455cb402730SMasami Hiramatsu if (ret == -ENOENT && pf->skip_empty_arg)
456cb402730SMasami Hiramatsu /* This can be found in other place. skip it */
457cb402730SMasami Hiramatsu return 0;
4587d5eaba9SHe Kuang if (ret == -ENOENT || ret == -EINVAL) {
459cb402730SMasami Hiramatsu print_var_not_found(pf->pvar->var);
4607d5eaba9SHe Kuang } else if (ret == -ENOTSUP)
461cf6eb489SMasami Hiramatsu pr_err("Sorry, we don't support this variable location yet.\n");
4620c188a07SMasami Hiramatsu else if (ret == 0 && pf->pvar->field) {
463b55a87adSMasami Hiramatsu ret = convert_variable_fields(vr_die, pf->pvar->var,
4644984912eSMasami Hiramatsu pf->pvar->field, &pf->tvar->ref,
4651e032f7cSMasami Hiramatsu &die_mem, pf->pvar->user_access);
4664984912eSMasami Hiramatsu vr_die = &die_mem;
4674984912eSMasami Hiramatsu }
46873317b95SMasami Hiramatsu if (ret == 0)
4691e032f7cSMasami Hiramatsu ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type,
4701e032f7cSMasami Hiramatsu pf->pvar->user_access);
471804b3606SMasami Hiramatsu /* *expr will be cached in libdw. Don't free it. */
472b55a87adSMasami Hiramatsu return ret;
4734ea42b18SMasami Hiramatsu }
4744ea42b18SMasami Hiramatsu
475221d0611SMasami Hiramatsu /* Find a variable in a scope DIE */
find_variable(Dwarf_Die * sc_die,struct probe_finder * pf)476221d0611SMasami Hiramatsu static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
4774ea42b18SMasami Hiramatsu {
478f182e3e1SMasami Hiramatsu Dwarf_Die vr_die;
479909b0360SMasami Hiramatsu char *buf, *ptr;
480f182e3e1SMasami Hiramatsu int ret = 0;
4814ea42b18SMasami Hiramatsu
482367e94c1SMasami Hiramatsu /* Copy raw parameters */
483da15bd9dSWang Nan if (!is_c_varname(pf->pvar->var))
484da15bd9dSWang Nan return copy_to_probe_trace_arg(pf->tvar, pf->pvar);
485367e94c1SMasami Hiramatsu
48648481938SMasami Hiramatsu if (pf->pvar->name)
48702b95dadSMasami Hiramatsu pf->tvar->name = strdup(pf->pvar->name);
48848481938SMasami Hiramatsu else {
489909b0360SMasami Hiramatsu buf = synthesize_perf_probe_arg(pf->pvar);
490909b0360SMasami Hiramatsu if (!buf)
491909b0360SMasami Hiramatsu return -ENOMEM;
49211a1ca35SMasami Hiramatsu ptr = strchr(buf, ':'); /* Change type separator to _ */
49311a1ca35SMasami Hiramatsu if (ptr)
49411a1ca35SMasami Hiramatsu *ptr = '_';
495909b0360SMasami Hiramatsu pf->tvar->name = buf;
49648481938SMasami Hiramatsu }
49702b95dadSMasami Hiramatsu if (pf->tvar->name == NULL)
49802b95dadSMasami Hiramatsu return -ENOMEM;
49948481938SMasami Hiramatsu
500f182e3e1SMasami Hiramatsu pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
5014ea42b18SMasami Hiramatsu /* Search child die for local variables and parameters. */
502f182e3e1SMasami Hiramatsu if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
503f182e3e1SMasami Hiramatsu /* Search again in global variables */
504d13855efSHe Kuang if (!die_find_variable_at(&pf->cu_die, pf->pvar->var,
505d13855efSHe Kuang 0, &vr_die)) {
506cb402730SMasami Hiramatsu if (pf->skip_empty_arg)
507cb402730SMasami Hiramatsu return 0;
50836d789a4SMasami Hiramatsu pr_warning("Failed to find '%s' in this function.\n",
50936d789a4SMasami Hiramatsu pf->pvar->var);
5108afa2a70SMasami Hiramatsu ret = -ENOENT;
511f182e3e1SMasami Hiramatsu }
512d13855efSHe Kuang }
513f66fedcbSMasami Hiramatsu if (ret >= 0)
514b7dcb857SMasami Hiramatsu ret = convert_variable(&vr_die, pf);
515f182e3e1SMasami Hiramatsu
516b7dcb857SMasami Hiramatsu return ret;
5174ea42b18SMasami Hiramatsu }
5184ea42b18SMasami Hiramatsu
519cf6eb489SMasami Hiramatsu /* Convert subprogram DIE to trace point */
convert_to_trace_point(Dwarf_Die * sp_die,Dwfl_Module * mod,Dwarf_Addr paddr,bool retprobe,const char * function,struct probe_trace_point * tp)520576b5237SMasami Hiramatsu static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
521576b5237SMasami Hiramatsu Dwarf_Addr paddr, bool retprobe,
5226cca13bdSMasami Hiramatsu const char *function,
523576b5237SMasami Hiramatsu struct probe_trace_point *tp)
5244ea42b18SMasami Hiramatsu {
52507d36985SMasami Hiramatsu Dwarf_Addr eaddr;
526576b5237SMasami Hiramatsu GElf_Sym sym;
527576b5237SMasami Hiramatsu const char *symbol;
528cf6eb489SMasami Hiramatsu
529576b5237SMasami Hiramatsu /* Verify the address is correct */
53007d36985SMasami Hiramatsu if (!dwarf_haspc(sp_die, paddr)) {
53107d36985SMasami Hiramatsu pr_warning("Specified offset is out of %s\n",
53226b79524SPrashanth Nageshappa dwarf_diename(sp_die));
53326b79524SPrashanth Nageshappa return -EINVAL;
53426b79524SPrashanth Nageshappa }
535576b5237SMasami Hiramatsu
5361efde275SMasami Hiramatsu if (dwarf_entrypc(sp_die, &eaddr) == 0) {
5371efde275SMasami Hiramatsu /* If the DIE has entrypc, use it. */
5381efde275SMasami Hiramatsu symbol = dwarf_diename(sp_die);
5391efde275SMasami Hiramatsu } else {
5401efde275SMasami Hiramatsu /* Try to get actual symbol name and address from symtab */
541576b5237SMasami Hiramatsu symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
5421efde275SMasami Hiramatsu eaddr = sym.st_value;
5431efde275SMasami Hiramatsu }
544576b5237SMasami Hiramatsu if (!symbol) {
545576b5237SMasami Hiramatsu pr_warning("Failed to find symbol at 0x%lx\n",
546576b5237SMasami Hiramatsu (unsigned long)paddr);
547576b5237SMasami Hiramatsu return -ENOENT;
548576b5237SMasami Hiramatsu }
54907d36985SMasami Hiramatsu
550664fee3dSMasami Hiramatsu tp->offset = (unsigned long)(paddr - eaddr);
55122a66551SYang Jihong tp->address = paddr;
552576b5237SMasami Hiramatsu tp->symbol = strdup(symbol);
553576b5237SMasami Hiramatsu if (!tp->symbol)
554cf6eb489SMasami Hiramatsu return -ENOMEM;
555cf6eb489SMasami Hiramatsu
556cf6eb489SMasami Hiramatsu /* Return probe must be on the head of a subprogram */
557cf6eb489SMasami Hiramatsu if (retprobe) {
558cf6eb489SMasami Hiramatsu if (eaddr != paddr) {
5596cca13bdSMasami Hiramatsu pr_warning("Failed to find \"%s%%return\",\n"
5606cca13bdSMasami Hiramatsu " because %s is an inlined function and"
5616cca13bdSMasami Hiramatsu " has no return point.\n", function,
5626cca13bdSMasami Hiramatsu function);
563cf6eb489SMasami Hiramatsu return -EINVAL;
564cf6eb489SMasami Hiramatsu }
565cf6eb489SMasami Hiramatsu tp->retprobe = true;
566cf6eb489SMasami Hiramatsu }
567cf6eb489SMasami Hiramatsu
568cf6eb489SMasami Hiramatsu return 0;
569cf6eb489SMasami Hiramatsu }
570cf6eb489SMasami Hiramatsu
571221d0611SMasami Hiramatsu /* Call probe_finder callback with scope DIE */
call_probe_finder(Dwarf_Die * sc_die,struct probe_finder * pf)572221d0611SMasami Hiramatsu static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
573cf6eb489SMasami Hiramatsu {
574804b3606SMasami Hiramatsu Dwarf_Attribute fb_attr;
5754d3b1626SMasami Hiramatsu Dwarf_Frame *frame = NULL;
576804b3606SMasami Hiramatsu size_t nops;
577cf6eb489SMasami Hiramatsu int ret;
5784235b045SMasami Hiramatsu
579221d0611SMasami Hiramatsu if (!sc_die) {
580221d0611SMasami Hiramatsu pr_err("Caller must pass a scope DIE. Program error.\n");
581221d0611SMasami Hiramatsu return -EINVAL;
582221d0611SMasami Hiramatsu }
583221d0611SMasami Hiramatsu
584221d0611SMasami Hiramatsu /* If not a real subprogram, find a real one */
5850dbb1cacSMasami Hiramatsu if (!die_is_func_def(sc_die)) {
586221d0611SMasami Hiramatsu if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
587d4c537e6SNaveen N. Rao if (die_find_tailfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
588d4c537e6SNaveen N. Rao pr_warning("Ignoring tail call from %s\n",
589d4c537e6SNaveen N. Rao dwarf_diename(&pf->sp_die));
590d4c537e6SNaveen N. Rao return 0;
591d4c537e6SNaveen N. Rao } else {
592b55a87adSMasami Hiramatsu pr_warning("Failed to find probe point in any "
593b55a87adSMasami Hiramatsu "functions.\n");
594b55a87adSMasami Hiramatsu return -ENOENT;
595b55a87adSMasami Hiramatsu }
596d4c537e6SNaveen N. Rao }
597221d0611SMasami Hiramatsu } else
598221d0611SMasami Hiramatsu memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
599e92b85e1SMasami Hiramatsu
600221d0611SMasami Hiramatsu /* Get the frame base attribute/ops from subprogram */
601221d0611SMasami Hiramatsu dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
602d0cb4260SMasami Hiramatsu ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
603a34a9854SMasami Hiramatsu if (ret <= 0 || nops == 0) {
604804b3606SMasami Hiramatsu pf->fb_ops = NULL;
605c06547d0SNamhyung Kim #ifdef HAVE_DWARF_CFI_SUPPORT
606a34a9854SMasami Hiramatsu } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
607270bde1eSHemant Kumar (pf->cfi_eh != NULL || pf->cfi_dbg != NULL)) {
608270bde1eSHemant Kumar if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 &&
609270bde1eSHemant Kumar (dwarf_cfi_addrframe(pf->cfi_dbg, pf->addr, &frame) != 0)) ||
610b55a87adSMasami Hiramatsu dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
6110e43e5d2SMasami Hiramatsu pr_warning("Failed to get call frame on 0x%jx\n",
612b55a87adSMasami Hiramatsu (uintmax_t)pf->addr);
61305c8d802SMasami Hiramatsu free(frame);
6144d3b1626SMasami Hiramatsu return -ENOENT;
6154d3b1626SMasami Hiramatsu }
616c06547d0SNamhyung Kim #endif /* HAVE_DWARF_CFI_SUPPORT */
617a34a9854SMasami Hiramatsu }
618804b3606SMasami Hiramatsu
619cf6eb489SMasami Hiramatsu /* Call finder's callback handler */
620221d0611SMasami Hiramatsu ret = pf->callback(sc_die, pf);
621804b3606SMasami Hiramatsu
6224d3b1626SMasami Hiramatsu /* Since *pf->fb_ops can be a part of frame. we should free it here. */
6234d3b1626SMasami Hiramatsu free(frame);
624804b3606SMasami Hiramatsu pf->fb_ops = NULL;
625cf6eb489SMasami Hiramatsu
626cf6eb489SMasami Hiramatsu return ret;
6274ea42b18SMasami Hiramatsu }
6284ea42b18SMasami Hiramatsu
629221d0611SMasami Hiramatsu struct find_scope_param {
630221d0611SMasami Hiramatsu const char *function;
631221d0611SMasami Hiramatsu const char *file;
632221d0611SMasami Hiramatsu int line;
633221d0611SMasami Hiramatsu int diff;
634221d0611SMasami Hiramatsu Dwarf_Die *die_mem;
635221d0611SMasami Hiramatsu bool found;
636221d0611SMasami Hiramatsu };
637221d0611SMasami Hiramatsu
find_best_scope_cb(Dwarf_Die * fn_die,void * data)638221d0611SMasami Hiramatsu static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
639221d0611SMasami Hiramatsu {
640221d0611SMasami Hiramatsu struct find_scope_param *fsp = data;
641221d0611SMasami Hiramatsu const char *file;
642221d0611SMasami Hiramatsu int lno;
643221d0611SMasami Hiramatsu
644221d0611SMasami Hiramatsu /* Skip if declared file name does not match */
645221d0611SMasami Hiramatsu if (fsp->file) {
646dc9a5d2cSMasami Hiramatsu (Google) file = die_get_decl_file(fn_die);
647221d0611SMasami Hiramatsu if (!file || strcmp(fsp->file, file) != 0)
648221d0611SMasami Hiramatsu return 0;
649221d0611SMasami Hiramatsu }
650221d0611SMasami Hiramatsu /* If the function name is given, that's what user expects */
651221d0611SMasami Hiramatsu if (fsp->function) {
6524c859351SMasami Hiramatsu if (die_match_name(fn_die, fsp->function)) {
653221d0611SMasami Hiramatsu memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
654221d0611SMasami Hiramatsu fsp->found = true;
655221d0611SMasami Hiramatsu return 1;
656221d0611SMasami Hiramatsu }
657221d0611SMasami Hiramatsu } else {
658221d0611SMasami Hiramatsu /* With the line number, find the nearest declared DIE */
659221d0611SMasami Hiramatsu dwarf_decl_line(fn_die, &lno);
660221d0611SMasami Hiramatsu if (lno < fsp->line && fsp->diff > fsp->line - lno) {
661221d0611SMasami Hiramatsu /* Keep a candidate and continue */
662221d0611SMasami Hiramatsu fsp->diff = fsp->line - lno;
663221d0611SMasami Hiramatsu memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
664221d0611SMasami Hiramatsu fsp->found = true;
665221d0611SMasami Hiramatsu }
666221d0611SMasami Hiramatsu }
667221d0611SMasami Hiramatsu return 0;
668221d0611SMasami Hiramatsu }
669221d0611SMasami Hiramatsu
670c701636aSMasami Hiramatsu /* Return innermost DIE */
find_inner_scope_cb(Dwarf_Die * fn_die,void * data)671c701636aSMasami Hiramatsu static int find_inner_scope_cb(Dwarf_Die *fn_die, void *data)
672c701636aSMasami Hiramatsu {
673c701636aSMasami Hiramatsu struct find_scope_param *fsp = data;
674c701636aSMasami Hiramatsu
675c701636aSMasami Hiramatsu memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
676c701636aSMasami Hiramatsu fsp->found = true;
677c701636aSMasami Hiramatsu return 1;
678c701636aSMasami Hiramatsu }
679c701636aSMasami Hiramatsu
680221d0611SMasami Hiramatsu /* Find an appropriate scope fits to given conditions */
find_best_scope(struct probe_finder * pf,Dwarf_Die * die_mem)681221d0611SMasami Hiramatsu static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
682221d0611SMasami Hiramatsu {
683221d0611SMasami Hiramatsu struct find_scope_param fsp = {
684221d0611SMasami Hiramatsu .function = pf->pev->point.function,
685221d0611SMasami Hiramatsu .file = pf->fname,
686221d0611SMasami Hiramatsu .line = pf->lno,
687221d0611SMasami Hiramatsu .diff = INT_MAX,
688221d0611SMasami Hiramatsu .die_mem = die_mem,
689221d0611SMasami Hiramatsu .found = false,
690221d0611SMasami Hiramatsu };
691c701636aSMasami Hiramatsu int ret;
692221d0611SMasami Hiramatsu
693c701636aSMasami Hiramatsu ret = cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb,
694c701636aSMasami Hiramatsu &fsp);
695c701636aSMasami Hiramatsu if (!ret && !fsp.found)
696c701636aSMasami Hiramatsu cu_walk_functions_at(&pf->cu_die, pf->addr,
697c701636aSMasami Hiramatsu find_inner_scope_cb, &fsp);
698221d0611SMasami Hiramatsu
699221d0611SMasami Hiramatsu return fsp.found ? die_mem : NULL;
700221d0611SMasami Hiramatsu }
701221d0611SMasami Hiramatsu
verify_representive_line(struct probe_finder * pf,const char * fname,int lineno,Dwarf_Addr addr)7021ae5d88aSMasami Hiramatsu static int verify_representive_line(struct probe_finder *pf, const char *fname,
7031ae5d88aSMasami Hiramatsu int lineno, Dwarf_Addr addr)
7041ae5d88aSMasami Hiramatsu {
7051ae5d88aSMasami Hiramatsu const char *__fname, *__func = NULL;
7061ae5d88aSMasami Hiramatsu Dwarf_Die die_mem;
7071ae5d88aSMasami Hiramatsu int __lineno;
7081ae5d88aSMasami Hiramatsu
7091ae5d88aSMasami Hiramatsu /* Verify line number and address by reverse search */
7101ae5d88aSMasami Hiramatsu if (cu_find_lineinfo(&pf->cu_die, addr, &__fname, &__lineno) < 0)
7111ae5d88aSMasami Hiramatsu return 0;
7121ae5d88aSMasami Hiramatsu
7131ae5d88aSMasami Hiramatsu pr_debug2("Reversed line: %s:%d\n", __fname, __lineno);
7141ae5d88aSMasami Hiramatsu if (strcmp(fname, __fname) || lineno == __lineno)
7151ae5d88aSMasami Hiramatsu return 0;
7161ae5d88aSMasami Hiramatsu
717358f98eeSColin Ian King pr_warning("This line is sharing the address with other lines.\n");
7181ae5d88aSMasami Hiramatsu
7191ae5d88aSMasami Hiramatsu if (pf->pev->point.function) {
7201ae5d88aSMasami Hiramatsu /* Find best match function name and lines */
7211ae5d88aSMasami Hiramatsu pf->addr = addr;
7221ae5d88aSMasami Hiramatsu if (find_best_scope(pf, &die_mem)
7231ae5d88aSMasami Hiramatsu && die_match_name(&die_mem, pf->pev->point.function)
7241ae5d88aSMasami Hiramatsu && dwarf_decl_line(&die_mem, &lineno) == 0) {
7251ae5d88aSMasami Hiramatsu __func = dwarf_diename(&die_mem);
7261ae5d88aSMasami Hiramatsu __lineno -= lineno;
7271ae5d88aSMasami Hiramatsu }
7281ae5d88aSMasami Hiramatsu }
7291ae5d88aSMasami Hiramatsu pr_warning("Please try to probe at %s:%d instead.\n",
7301ae5d88aSMasami Hiramatsu __func ? : __fname, __lineno);
7311ae5d88aSMasami Hiramatsu
7321ae5d88aSMasami Hiramatsu return -ENOENT;
7331ae5d88aSMasami Hiramatsu }
7341ae5d88aSMasami Hiramatsu
probe_point_line_walker(const char * fname,int lineno,Dwarf_Addr addr,void * data)7354cc9cec6SMasami Hiramatsu static int probe_point_line_walker(const char *fname, int lineno,
7364cc9cec6SMasami Hiramatsu Dwarf_Addr addr, void *data)
7374cc9cec6SMasami Hiramatsu {
7384cc9cec6SMasami Hiramatsu struct probe_finder *pf = data;
739221d0611SMasami Hiramatsu Dwarf_Die *sc_die, die_mem;
7404cc9cec6SMasami Hiramatsu int ret;
7414cc9cec6SMasami Hiramatsu
7424cc9cec6SMasami Hiramatsu if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
7434cc9cec6SMasami Hiramatsu return 0;
7444cc9cec6SMasami Hiramatsu
7451ae5d88aSMasami Hiramatsu if (verify_representive_line(pf, fname, lineno, addr))
7461ae5d88aSMasami Hiramatsu return -ENOENT;
7471ae5d88aSMasami Hiramatsu
7484cc9cec6SMasami Hiramatsu pf->addr = addr;
749221d0611SMasami Hiramatsu sc_die = find_best_scope(pf, &die_mem);
750221d0611SMasami Hiramatsu if (!sc_die) {
751221d0611SMasami Hiramatsu pr_warning("Failed to find scope of probe point.\n");
752221d0611SMasami Hiramatsu return -ENOENT;
753221d0611SMasami Hiramatsu }
754221d0611SMasami Hiramatsu
755221d0611SMasami Hiramatsu ret = call_probe_finder(sc_die, pf);
7564cc9cec6SMasami Hiramatsu
7574cc9cec6SMasami Hiramatsu /* Continue if no error, because the line will be in inline function */
758fbee632dSArnaldo Carvalho de Melo return ret < 0 ? ret : 0;
7594cc9cec6SMasami Hiramatsu }
7604cc9cec6SMasami Hiramatsu
7614ea42b18SMasami Hiramatsu /* Find probe point from its line number */
find_probe_point_by_line(struct probe_finder * pf)762b55a87adSMasami Hiramatsu static int find_probe_point_by_line(struct probe_finder *pf)
7634ea42b18SMasami Hiramatsu {
7644cc9cec6SMasami Hiramatsu return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
7654ea42b18SMasami Hiramatsu }
7664ea42b18SMasami Hiramatsu
7672a9c8c36SMasami Hiramatsu /* Find lines which match lazy pattern */
find_lazy_match_lines(struct intlist * list,const char * fname,const char * pat)7685a62257aSMasami Hiramatsu static int find_lazy_match_lines(struct intlist *list,
7692a9c8c36SMasami Hiramatsu const char *fname, const char *pat)
7702a9c8c36SMasami Hiramatsu {
771f50c2169SFranck Bui-Huu FILE *fp;
772f50c2169SFranck Bui-Huu char *line = NULL;
773f50c2169SFranck Bui-Huu size_t line_len;
774f50c2169SFranck Bui-Huu ssize_t len;
775f50c2169SFranck Bui-Huu int count = 0, linenum = 1;
7765f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE];
7772a9c8c36SMasami Hiramatsu
778f50c2169SFranck Bui-Huu fp = fopen(fname, "r");
779f50c2169SFranck Bui-Huu if (!fp) {
7805f03cba4SMasami Hiramatsu pr_warning("Failed to open %s: %s\n", fname,
781c8b5f2c9SArnaldo Carvalho de Melo str_error_r(errno, sbuf, sizeof(sbuf)));
782b448c4b6SArnaldo Carvalho de Melo return -errno;
783b55a87adSMasami Hiramatsu }
784b55a87adSMasami Hiramatsu
785f50c2169SFranck Bui-Huu while ((len = getline(&line, &line_len, fp)) > 0) {
786f50c2169SFranck Bui-Huu
787f50c2169SFranck Bui-Huu if (line[len - 1] == '\n')
788f50c2169SFranck Bui-Huu line[len - 1] = '\0';
789f50c2169SFranck Bui-Huu
790f50c2169SFranck Bui-Huu if (strlazymatch(line, pat)) {
7915a62257aSMasami Hiramatsu intlist__add(list, linenum);
792f50c2169SFranck Bui-Huu count++;
793f50c2169SFranck Bui-Huu }
794f50c2169SFranck Bui-Huu linenum++;
795b55a87adSMasami Hiramatsu }
796b448c4b6SArnaldo Carvalho de Melo
797f50c2169SFranck Bui-Huu if (ferror(fp))
798f50c2169SFranck Bui-Huu count = -errno;
799f50c2169SFranck Bui-Huu free(line);
800f50c2169SFranck Bui-Huu fclose(fp);
801f50c2169SFranck Bui-Huu
802f50c2169SFranck Bui-Huu if (count == 0)
803f50c2169SFranck Bui-Huu pr_debug("No matched lines found in %s.\n", fname);
804f50c2169SFranck Bui-Huu return count;
8052a9c8c36SMasami Hiramatsu }
8062a9c8c36SMasami Hiramatsu
probe_point_lazy_walker(const char * fname,int lineno,Dwarf_Addr addr,void * data)8074cc9cec6SMasami Hiramatsu static int probe_point_lazy_walker(const char *fname, int lineno,
8084cc9cec6SMasami Hiramatsu Dwarf_Addr addr, void *data)
8094cc9cec6SMasami Hiramatsu {
8104cc9cec6SMasami Hiramatsu struct probe_finder *pf = data;
811221d0611SMasami Hiramatsu Dwarf_Die *sc_die, die_mem;
8124cc9cec6SMasami Hiramatsu int ret;
8134cc9cec6SMasami Hiramatsu
8145a62257aSMasami Hiramatsu if (!intlist__has_entry(pf->lcache, lineno) ||
8154cc9cec6SMasami Hiramatsu strtailcmp(fname, pf->fname) != 0)
8164cc9cec6SMasami Hiramatsu return 0;
8174cc9cec6SMasami Hiramatsu
8184cc9cec6SMasami Hiramatsu pr_debug("Probe line found: line:%d addr:0x%llx\n",
8194cc9cec6SMasami Hiramatsu lineno, (unsigned long long)addr);
8204cc9cec6SMasami Hiramatsu pf->addr = addr;
821221d0611SMasami Hiramatsu pf->lno = lineno;
822221d0611SMasami Hiramatsu sc_die = find_best_scope(pf, &die_mem);
823221d0611SMasami Hiramatsu if (!sc_die) {
824221d0611SMasami Hiramatsu pr_warning("Failed to find scope of probe point.\n");
825221d0611SMasami Hiramatsu return -ENOENT;
826221d0611SMasami Hiramatsu }
827221d0611SMasami Hiramatsu
828221d0611SMasami Hiramatsu ret = call_probe_finder(sc_die, pf);
8294cc9cec6SMasami Hiramatsu
8304cc9cec6SMasami Hiramatsu /*
8314cc9cec6SMasami Hiramatsu * Continue if no error, because the lazy pattern will match
8324cc9cec6SMasami Hiramatsu * to other lines
8334cc9cec6SMasami Hiramatsu */
8345e814dd5SIngo Molnar return ret < 0 ? ret : 0;
8354cc9cec6SMasami Hiramatsu }
8364cc9cec6SMasami Hiramatsu
8372a9c8c36SMasami Hiramatsu /* Find probe points from lazy pattern */
find_probe_point_lazy(Dwarf_Die * sp_die,struct probe_finder * pf)838b55a87adSMasami Hiramatsu static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
8392a9c8c36SMasami Hiramatsu {
840bf541169SJiri Olsa struct build_id bid;
8417cd5738dSMasami Hiramatsu char sbuild_id[SBUILD_ID_SIZE] = "";
842b55a87adSMasami Hiramatsu int ret = 0;
84309ed8975SNaohiro Aota char *fpath;
8442a9c8c36SMasami Hiramatsu
8455a62257aSMasami Hiramatsu if (intlist__empty(pf->lcache)) {
84609ed8975SNaohiro Aota const char *comp_dir;
84709ed8975SNaohiro Aota
84809ed8975SNaohiro Aota comp_dir = cu_get_comp_dir(&pf->cu_die);
849bf541169SJiri Olsa if (pf->dbg->build_id) {
850bf541169SJiri Olsa build_id__init(&bid, pf->dbg->build_id, BUILD_ID_SIZE);
851bf541169SJiri Olsa build_id__sprintf(&bid, sbuild_id);
852bf541169SJiri Olsa }
8537cd5738dSMasami Hiramatsu ret = find_source_path(pf->fname, sbuild_id, comp_dir, &fpath);
85409ed8975SNaohiro Aota if (ret < 0) {
85509ed8975SNaohiro Aota pr_warning("Failed to find source file path.\n");
85609ed8975SNaohiro Aota return ret;
85709ed8975SNaohiro Aota }
85809ed8975SNaohiro Aota
8592a9c8c36SMasami Hiramatsu /* Matching lazy line pattern */
86009ed8975SNaohiro Aota ret = find_lazy_match_lines(pf->lcache, fpath,
8614235b045SMasami Hiramatsu pf->pev->point.lazy_line);
86209ed8975SNaohiro Aota free(fpath);
863f50c2169SFranck Bui-Huu if (ret <= 0)
864b55a87adSMasami Hiramatsu return ret;
8652a9c8c36SMasami Hiramatsu }
8662a9c8c36SMasami Hiramatsu
8674cc9cec6SMasami Hiramatsu return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
8682a9c8c36SMasami Hiramatsu }
8692a9c8c36SMasami Hiramatsu
skip_prologue(Dwarf_Die * sp_die,struct probe_finder * pf)870e47392bfSRavi Bangoria static void skip_prologue(Dwarf_Die *sp_die, struct probe_finder *pf)
871e47392bfSRavi Bangoria {
872e47392bfSRavi Bangoria struct perf_probe_point *pp = &pf->pev->point;
873e47392bfSRavi Bangoria
874e47392bfSRavi Bangoria /* Not uprobe? */
875e47392bfSRavi Bangoria if (!pf->pev->uprobes)
876e47392bfSRavi Bangoria return;
877e47392bfSRavi Bangoria
878e47392bfSRavi Bangoria /* Compiled with optimization? */
8796243b9dcSRavi Bangoria if (die_is_optimized_target(&pf->cu_die))
880e47392bfSRavi Bangoria return;
881e47392bfSRavi Bangoria
882e47392bfSRavi Bangoria /* Don't know entrypc? */
883e47392bfSRavi Bangoria if (!pf->addr)
884e47392bfSRavi Bangoria return;
885e47392bfSRavi Bangoria
886e47392bfSRavi Bangoria /* Only FUNC and FUNC@SRC are eligible. */
887e47392bfSRavi Bangoria if (!pp->function || pp->line || pp->retprobe || pp->lazy_line ||
888e47392bfSRavi Bangoria pp->offset || pp->abs_address)
889e47392bfSRavi Bangoria return;
890e47392bfSRavi Bangoria
891e47392bfSRavi Bangoria /* Not interested in func parameter? */
892e47392bfSRavi Bangoria if (!perf_probe_with_var(pf->pev))
893e47392bfSRavi Bangoria return;
894e47392bfSRavi Bangoria
895e47392bfSRavi Bangoria pr_info("Target program is compiled without optimization. Skipping prologue.\n"
896e47392bfSRavi Bangoria "Probe on address 0x%" PRIx64 " to force probing at the function entry.\n\n",
897e47392bfSRavi Bangoria pf->addr);
898e47392bfSRavi Bangoria
8996243b9dcSRavi Bangoria die_skip_prologue(sp_die, &pf->cu_die, &pf->addr);
900e47392bfSRavi Bangoria }
901e47392bfSRavi Bangoria
probe_point_inline_cb(Dwarf_Die * in_die,void * data)902e92b85e1SMasami Hiramatsu static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
9034ea42b18SMasami Hiramatsu {
904db0d2c64SMasami Hiramatsu struct probe_finder *pf = data;
9054235b045SMasami Hiramatsu struct perf_probe_point *pp = &pf->pev->point;
906b55a87adSMasami Hiramatsu Dwarf_Addr addr;
907db0d2c64SMasami Hiramatsu int ret;
9084ea42b18SMasami Hiramatsu
9092a9c8c36SMasami Hiramatsu if (pp->lazy_line)
910db0d2c64SMasami Hiramatsu ret = find_probe_point_lazy(in_die, pf);
9112a9c8c36SMasami Hiramatsu else {
912e92b85e1SMasami Hiramatsu /* Get probe address */
913eb6933b2SMasami Hiramatsu if (die_entrypc(in_die, &addr) != 0) {
9140e43e5d2SMasami Hiramatsu pr_warning("Failed to get entry address of %s.\n",
915b55a87adSMasami Hiramatsu dwarf_diename(in_die));
916db0d2c64SMasami Hiramatsu return -ENOENT;
917b55a87adSMasami Hiramatsu }
9180ad45b33SMasami Hiramatsu if (addr == 0) {
9190ad45b33SMasami Hiramatsu pr_debug("%s has no valid entry address. skipped.\n",
9200ad45b33SMasami Hiramatsu dwarf_diename(in_die));
9210ad45b33SMasami Hiramatsu return -ENOENT;
9220ad45b33SMasami Hiramatsu }
923b55a87adSMasami Hiramatsu pf->addr = addr;
924e92b85e1SMasami Hiramatsu pf->addr += pp->offset;
9252a9c8c36SMasami Hiramatsu pr_debug("found inline addr: 0x%jx\n",
9262a9c8c36SMasami Hiramatsu (uintmax_t)pf->addr);
927e92b85e1SMasami Hiramatsu
928db0d2c64SMasami Hiramatsu ret = call_probe_finder(in_die, pf);
9292a9c8c36SMasami Hiramatsu }
9302a9c8c36SMasami Hiramatsu
931db0d2c64SMasami Hiramatsu return ret;
932e92b85e1SMasami Hiramatsu }
933e92b85e1SMasami Hiramatsu
934db0d2c64SMasami Hiramatsu /* Callback parameter with return value for libdw */
935db0d2c64SMasami Hiramatsu struct dwarf_callback_param {
936db0d2c64SMasami Hiramatsu void *data;
937db0d2c64SMasami Hiramatsu int retval;
938db0d2c64SMasami Hiramatsu };
939db0d2c64SMasami Hiramatsu
940e92b85e1SMasami Hiramatsu /* Search function from function name */
probe_point_search_cb(Dwarf_Die * sp_die,void * data)941e92b85e1SMasami Hiramatsu static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
942e92b85e1SMasami Hiramatsu {
943b55a87adSMasami Hiramatsu struct dwarf_callback_param *param = data;
944b55a87adSMasami Hiramatsu struct probe_finder *pf = param->data;
9454235b045SMasami Hiramatsu struct perf_probe_point *pp = &pf->pev->point;
94698e4c68dSMasami Hiramatsu (Google) const char *fname;
947e92b85e1SMasami Hiramatsu
948e92b85e1SMasami Hiramatsu /* Check tag and diename */
9490dbb1cacSMasami Hiramatsu if (!die_is_func_def(sp_die) ||
9504c859351SMasami Hiramatsu !die_match_name(sp_die, pp->function))
951b55a87adSMasami Hiramatsu return DWARF_CB_OK;
952e92b85e1SMasami Hiramatsu
9537d21635aSMasami Hiramatsu /* Check declared file */
954dc9a5d2cSMasami Hiramatsu (Google) fname = die_get_decl_file(sp_die);
95598e4c68dSMasami Hiramatsu (Google) if (!fname) {
95698e4c68dSMasami Hiramatsu (Google) pr_warning("A function DIE doesn't have decl_line. Maybe broken DWARF?\n");
95798e4c68dSMasami Hiramatsu (Google) return DWARF_CB_OK;
95898e4c68dSMasami Hiramatsu (Google) }
95998e4c68dSMasami Hiramatsu (Google) if (pp->file && fname && strtailcmp(pp->file, fname))
9607d21635aSMasami Hiramatsu return DWARF_CB_OK;
9617d21635aSMasami Hiramatsu
962f8da4b51SMasami Hiramatsu pr_debug("Matched function: %s [%lx]\n", dwarf_diename(sp_die),
963f8da4b51SMasami Hiramatsu (unsigned long)dwarf_dieoffset(sp_die));
96498e4c68dSMasami Hiramatsu (Google) pf->fname = fname;
9652a9c8c36SMasami Hiramatsu if (pp->line) { /* Function relative line */
966e92b85e1SMasami Hiramatsu dwarf_decl_line(sp_die, &pf->lno);
967804b3606SMasami Hiramatsu pf->lno += pp->line;
968b55a87adSMasami Hiramatsu param->retval = find_probe_point_by_line(pf);
969e1ecbbc3SMasami Hiramatsu } else if (die_is_func_instance(sp_die)) {
970e1ecbbc3SMasami Hiramatsu /* Instances always have the entry address */
9715d16dbccSMasami Hiramatsu die_entrypc(sp_die, &pf->addr);
9720ad45b33SMasami Hiramatsu /* But in some case the entry address is 0 */
9730ad45b33SMasami Hiramatsu if (pf->addr == 0) {
9740ad45b33SMasami Hiramatsu pr_debug("%s has no entry PC. Skipped\n",
9750ad45b33SMasami Hiramatsu dwarf_diename(sp_die));
9760ad45b33SMasami Hiramatsu param->retval = 0;
977e92b85e1SMasami Hiramatsu /* Real function */
9780ad45b33SMasami Hiramatsu } else if (pp->lazy_line)
979b55a87adSMasami Hiramatsu param->retval = find_probe_point_lazy(sp_die, pf);
9802a9c8c36SMasami Hiramatsu else {
981e47392bfSRavi Bangoria skip_prologue(sp_die, pf);
9824ea42b18SMasami Hiramatsu pf->addr += pp->offset;
9834ea42b18SMasami Hiramatsu /* TODO: Check the address in this function */
984cf6eb489SMasami Hiramatsu param->retval = call_probe_finder(sp_die, pf);
9852a9c8c36SMasami Hiramatsu }
9864c859351SMasami Hiramatsu } else if (!probe_conf.no_inlines) {
987e92b85e1SMasami Hiramatsu /* Inlined function: search instances */
988db0d2c64SMasami Hiramatsu param->retval = die_walk_instances(sp_die,
989db0d2c64SMasami Hiramatsu probe_point_inline_cb, (void *)pf);
9904c859351SMasami Hiramatsu /* This could be a non-existed inline definition */
991f8da4b51SMasami Hiramatsu if (param->retval == -ENOENT)
9924c859351SMasami Hiramatsu param->retval = 0;
9934c859351SMasami Hiramatsu }
9944c859351SMasami Hiramatsu
9954c859351SMasami Hiramatsu /* We need to find other candidates */
9964c859351SMasami Hiramatsu if (strisglob(pp->function) && param->retval >= 0) {
9974c859351SMasami Hiramatsu param->retval = 0; /* We have to clear the result */
9984c859351SMasami Hiramatsu return DWARF_CB_OK;
9994c859351SMasami Hiramatsu }
10004ea42b18SMasami Hiramatsu
1001b55a87adSMasami Hiramatsu return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1002b55a87adSMasami Hiramatsu }
1003b55a87adSMasami Hiramatsu
find_probe_point_by_func(struct probe_finder * pf)1004b55a87adSMasami Hiramatsu static int find_probe_point_by_func(struct probe_finder *pf)
10054ea42b18SMasami Hiramatsu {
1006b55a87adSMasami Hiramatsu struct dwarf_callback_param _param = {.data = (void *)pf,
1007b55a87adSMasami Hiramatsu .retval = 0};
1008b55a87adSMasami Hiramatsu dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
1009b55a87adSMasami Hiramatsu return _param.retval;
10104ea42b18SMasami Hiramatsu }
10114ea42b18SMasami Hiramatsu
1012cd25f8bcSLin Ming struct pubname_callback_param {
1013cd25f8bcSLin Ming char *function;
1014cd25f8bcSLin Ming char *file;
1015cd25f8bcSLin Ming Dwarf_Die *cu_die;
1016cd25f8bcSLin Ming Dwarf_Die *sp_die;
1017cd25f8bcSLin Ming int found;
1018cd25f8bcSLin Ming };
1019cd25f8bcSLin Ming
pubname_search_cb(Dwarf * dbg,Dwarf_Global * gl,void * data)1020cd25f8bcSLin Ming static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data)
1021cd25f8bcSLin Ming {
1022cd25f8bcSLin Ming struct pubname_callback_param *param = data;
102398e4c68dSMasami Hiramatsu (Google) const char *fname;
1024cd25f8bcSLin Ming
1025cd25f8bcSLin Ming if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) {
1026cd25f8bcSLin Ming if (dwarf_tag(param->sp_die) != DW_TAG_subprogram)
1027cd25f8bcSLin Ming return DWARF_CB_OK;
1028cd25f8bcSLin Ming
10294c859351SMasami Hiramatsu if (die_match_name(param->sp_die, param->function)) {
1030cd25f8bcSLin Ming if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die))
1031cd25f8bcSLin Ming return DWARF_CB_OK;
1032cd25f8bcSLin Ming
103398e4c68dSMasami Hiramatsu (Google) if (param->file) {
1034dc9a5d2cSMasami Hiramatsu (Google) fname = die_get_decl_file(param->sp_die);
103598e4c68dSMasami Hiramatsu (Google) if (!fname || strtailcmp(param->file, fname))
1036cd25f8bcSLin Ming return DWARF_CB_OK;
103798e4c68dSMasami Hiramatsu (Google) }
1038cd25f8bcSLin Ming
1039cd25f8bcSLin Ming param->found = 1;
1040cd25f8bcSLin Ming return DWARF_CB_ABORT;
1041cd25f8bcSLin Ming }
1042cd25f8bcSLin Ming }
1043cd25f8bcSLin Ming
1044cd25f8bcSLin Ming return DWARF_CB_OK;
1045cd25f8bcSLin Ming }
1046cd25f8bcSLin Ming
debuginfo__find_probe_location(struct debuginfo * dbg,struct probe_finder * pf)1047270bde1eSHemant Kumar static int debuginfo__find_probe_location(struct debuginfo *dbg,
1048ff741783SMasami Hiramatsu struct probe_finder *pf)
10494ea42b18SMasami Hiramatsu {
1050cf6eb489SMasami Hiramatsu struct perf_probe_point *pp = &pf->pev->point;
1051804b3606SMasami Hiramatsu Dwarf_Off off, noff;
1052804b3606SMasami Hiramatsu size_t cuhl;
1053804b3606SMasami Hiramatsu Dwarf_Die *diep;
1054b55a87adSMasami Hiramatsu int ret = 0;
10554ea42b18SMasami Hiramatsu
1056804b3606SMasami Hiramatsu off = 0;
10575a62257aSMasami Hiramatsu pf->lcache = intlist__new(NULL);
10585a62257aSMasami Hiramatsu if (!pf->lcache)
10595a62257aSMasami Hiramatsu return -ENOMEM;
1060cd25f8bcSLin Ming
1061cd25f8bcSLin Ming /* Fastpath: lookup by function name from .debug_pubnames section */
10624c859351SMasami Hiramatsu if (pp->function && !strisglob(pp->function)) {
1063cd25f8bcSLin Ming struct pubname_callback_param pubname_param = {
1064cd25f8bcSLin Ming .function = pp->function,
1065cd25f8bcSLin Ming .file = pp->file,
1066cd25f8bcSLin Ming .cu_die = &pf->cu_die,
1067cd25f8bcSLin Ming .sp_die = &pf->sp_die,
10682b348a77SLin Ming .found = 0,
1069cd25f8bcSLin Ming };
1070cd25f8bcSLin Ming struct dwarf_callback_param probe_param = {
1071cd25f8bcSLin Ming .data = pf,
1072cd25f8bcSLin Ming };
1073cd25f8bcSLin Ming
1074316c7136SArnaldo Carvalho de Melo dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1075ff741783SMasami Hiramatsu &pubname_param, 0);
1076cd25f8bcSLin Ming if (pubname_param.found) {
1077cd25f8bcSLin Ming ret = probe_point_search_cb(&pf->sp_die, &probe_param);
1078cd25f8bcSLin Ming if (ret)
1079cd25f8bcSLin Ming goto found;
1080cd25f8bcSLin Ming }
1081cd25f8bcSLin Ming }
1082cd25f8bcSLin Ming
1083804b3606SMasami Hiramatsu /* Loop on CUs (Compilation Unit) */
1084316c7136SArnaldo Carvalho de Melo while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
10854ea42b18SMasami Hiramatsu /* Get the DIE(Debugging Information Entry) of this CU */
1086316c7136SArnaldo Carvalho de Melo diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die);
1087900547ddSJianlin Lv if (!diep) {
1088900547ddSJianlin Lv off = noff;
1089804b3606SMasami Hiramatsu continue;
1090900547ddSJianlin Lv }
10914ea42b18SMasami Hiramatsu
10924ea42b18SMasami Hiramatsu /* Check if target file is included. */
10934ea42b18SMasami Hiramatsu if (pp->file)
1094cf6eb489SMasami Hiramatsu pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1095804b3606SMasami Hiramatsu else
1096cf6eb489SMasami Hiramatsu pf->fname = NULL;
10974ea42b18SMasami Hiramatsu
1098cf6eb489SMasami Hiramatsu if (!pp->file || pf->fname) {
10994ea42b18SMasami Hiramatsu if (pp->function)
1100cf6eb489SMasami Hiramatsu ret = find_probe_point_by_func(pf);
11012a9c8c36SMasami Hiramatsu else if (pp->lazy_line)
1102f19e80c6SHe Kuang ret = find_probe_point_lazy(&pf->cu_die, pf);
1103b0ef0732SMasami Hiramatsu else {
1104cf6eb489SMasami Hiramatsu pf->lno = pp->line;
1105cf6eb489SMasami Hiramatsu ret = find_probe_point_by_line(pf);
11064ea42b18SMasami Hiramatsu }
11078635bf6eSArnaldo Carvalho de Melo if (ret < 0)
1108fbee632dSArnaldo Carvalho de Melo break;
1109b0ef0732SMasami Hiramatsu }
1110804b3606SMasami Hiramatsu off = noff;
11114ea42b18SMasami Hiramatsu }
1112cd25f8bcSLin Ming
1113cd25f8bcSLin Ming found:
11145a62257aSMasami Hiramatsu intlist__delete(pf->lcache);
11155a62257aSMasami Hiramatsu pf->lcache = NULL;
11164ea42b18SMasami Hiramatsu
1117cf6eb489SMasami Hiramatsu return ret;
1118cf6eb489SMasami Hiramatsu }
1119cf6eb489SMasami Hiramatsu
1120270bde1eSHemant Kumar /* Find probe points from debuginfo */
debuginfo__find_probes(struct debuginfo * dbg,struct probe_finder * pf)1121270bde1eSHemant Kumar static int debuginfo__find_probes(struct debuginfo *dbg,
1122270bde1eSHemant Kumar struct probe_finder *pf)
1123270bde1eSHemant Kumar {
1124270bde1eSHemant Kumar int ret = 0;
1125270bde1eSHemant Kumar Elf *elf;
1126270bde1eSHemant Kumar GElf_Ehdr ehdr;
1127270bde1eSHemant Kumar
1128270bde1eSHemant Kumar if (pf->cfi_eh || pf->cfi_dbg)
1129270bde1eSHemant Kumar return debuginfo__find_probe_location(dbg, pf);
1130270bde1eSHemant Kumar
1131270bde1eSHemant Kumar /* Get the call frame information from this dwarf */
1132270bde1eSHemant Kumar elf = dwarf_getelf(dbg->dbg);
1133270bde1eSHemant Kumar if (elf == NULL)
1134270bde1eSHemant Kumar return -EINVAL;
1135270bde1eSHemant Kumar
1136270bde1eSHemant Kumar if (gelf_getehdr(elf, &ehdr) == NULL)
1137270bde1eSHemant Kumar return -EINVAL;
1138270bde1eSHemant Kumar
1139293d5b43SMasami Hiramatsu pf->machine = ehdr.e_machine;
1140293d5b43SMasami Hiramatsu
1141c06547d0SNamhyung Kim #ifdef HAVE_DWARF_CFI_SUPPORT
1142293d5b43SMasami Hiramatsu do {
1143293d5b43SMasami Hiramatsu GElf_Shdr shdr;
1144293d5b43SMasami Hiramatsu
1145270bde1eSHemant Kumar if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
1146270bde1eSHemant Kumar shdr.sh_type == SHT_PROGBITS)
1147270bde1eSHemant Kumar pf->cfi_eh = dwarf_getcfi_elf(elf);
1148270bde1eSHemant Kumar
1149270bde1eSHemant Kumar pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
1150293d5b43SMasami Hiramatsu } while (0);
1151c06547d0SNamhyung Kim #endif /* HAVE_DWARF_CFI_SUPPORT */
1152270bde1eSHemant Kumar
1153270bde1eSHemant Kumar ret = debuginfo__find_probe_location(dbg, pf);
1154270bde1eSHemant Kumar return ret;
1155270bde1eSHemant Kumar }
1156270bde1eSHemant Kumar
11577969ec77SMasami Hiramatsu struct local_vars_finder {
11587969ec77SMasami Hiramatsu struct probe_finder *pf;
11597969ec77SMasami Hiramatsu struct perf_probe_arg *args;
1160f8bffbf1SMasami Hiramatsu bool vars;
11617969ec77SMasami Hiramatsu int max_args;
11627969ec77SMasami Hiramatsu int nargs;
11637969ec77SMasami Hiramatsu int ret;
11647969ec77SMasami Hiramatsu };
11657969ec77SMasami Hiramatsu
11667969ec77SMasami Hiramatsu /* Collect available variables in this scope */
copy_variables_cb(Dwarf_Die * die_mem,void * data)11677969ec77SMasami Hiramatsu static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
11687969ec77SMasami Hiramatsu {
11697969ec77SMasami Hiramatsu struct local_vars_finder *vf = data;
11703d918a12SMasami Hiramatsu struct probe_finder *pf = vf->pf;
11717969ec77SMasami Hiramatsu int tag;
11727969ec77SMasami Hiramatsu
11737969ec77SMasami Hiramatsu tag = dwarf_tag(die_mem);
11747969ec77SMasami Hiramatsu if (tag == DW_TAG_formal_parameter ||
1175f8bffbf1SMasami Hiramatsu (tag == DW_TAG_variable && vf->vars)) {
11767969ec77SMasami Hiramatsu if (convert_variable_location(die_mem, vf->pf->addr,
11773d918a12SMasami Hiramatsu vf->pf->fb_ops, &pf->sp_die,
1178293d5b43SMasami Hiramatsu pf->machine, NULL) == 0) {
11797969ec77SMasami Hiramatsu vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
11807969ec77SMasami Hiramatsu if (vf->args[vf->nargs].var == NULL) {
11817969ec77SMasami Hiramatsu vf->ret = -ENOMEM;
11827969ec77SMasami Hiramatsu return DIE_FIND_CB_END;
11837969ec77SMasami Hiramatsu }
11847969ec77SMasami Hiramatsu pr_debug(" %s", vf->args[vf->nargs].var);
11857969ec77SMasami Hiramatsu vf->nargs++;
11867969ec77SMasami Hiramatsu }
11877969ec77SMasami Hiramatsu }
11887969ec77SMasami Hiramatsu
11897969ec77SMasami Hiramatsu if (dwarf_haspc(die_mem, vf->pf->addr))
11907969ec77SMasami Hiramatsu return DIE_FIND_CB_CONTINUE;
11917969ec77SMasami Hiramatsu else
11927969ec77SMasami Hiramatsu return DIE_FIND_CB_SIBLING;
11937969ec77SMasami Hiramatsu }
11947969ec77SMasami Hiramatsu
expand_probe_args(Dwarf_Die * sc_die,struct probe_finder * pf,struct perf_probe_arg * args)11957969ec77SMasami Hiramatsu static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf,
11967969ec77SMasami Hiramatsu struct perf_probe_arg *args)
11977969ec77SMasami Hiramatsu {
11987969ec77SMasami Hiramatsu Dwarf_Die die_mem;
11997969ec77SMasami Hiramatsu int i;
12007969ec77SMasami Hiramatsu int n = 0;
1201f8bffbf1SMasami Hiramatsu struct local_vars_finder vf = {.pf = pf, .args = args, .vars = false,
12027969ec77SMasami Hiramatsu .max_args = MAX_PROBE_ARGS, .ret = 0};
12037969ec77SMasami Hiramatsu
12047969ec77SMasami Hiramatsu for (i = 0; i < pf->pev->nargs; i++) {
12057969ec77SMasami Hiramatsu /* var never be NULL */
1206f8bffbf1SMasami Hiramatsu if (strcmp(pf->pev->args[i].var, PROBE_ARG_VARS) == 0)
1207f8bffbf1SMasami Hiramatsu vf.vars = true;
1208f8bffbf1SMasami Hiramatsu else if (strcmp(pf->pev->args[i].var, PROBE_ARG_PARAMS) != 0) {
1209f8bffbf1SMasami Hiramatsu /* Copy normal argument */
1210f8bffbf1SMasami Hiramatsu args[n] = pf->pev->args[i];
1211f8bffbf1SMasami Hiramatsu n++;
1212f8bffbf1SMasami Hiramatsu continue;
1213f8bffbf1SMasami Hiramatsu }
1214f8bffbf1SMasami Hiramatsu pr_debug("Expanding %s into:", pf->pev->args[i].var);
12157969ec77SMasami Hiramatsu vf.nargs = n;
12167969ec77SMasami Hiramatsu /* Special local variables */
12177969ec77SMasami Hiramatsu die_find_child(sc_die, copy_variables_cb, (void *)&vf,
12187969ec77SMasami Hiramatsu &die_mem);
12197969ec77SMasami Hiramatsu pr_debug(" (%d)\n", vf.nargs - n);
12207969ec77SMasami Hiramatsu if (vf.ret < 0)
12217969ec77SMasami Hiramatsu return vf.ret;
12227969ec77SMasami Hiramatsu n = vf.nargs;
12237969ec77SMasami Hiramatsu }
12247969ec77SMasami Hiramatsu return n;
12257969ec77SMasami Hiramatsu }
12267969ec77SMasami Hiramatsu
trace_event_finder_overlap(struct trace_event_finder * tf)12271a375ae7SMasami Hiramatsu static bool trace_event_finder_overlap(struct trace_event_finder *tf)
12281a375ae7SMasami Hiramatsu {
12291a375ae7SMasami Hiramatsu int i;
12301a375ae7SMasami Hiramatsu
12311a375ae7SMasami Hiramatsu for (i = 0; i < tf->ntevs; i++) {
12321a375ae7SMasami Hiramatsu if (tf->pf.addr == tf->tevs[i].point.address)
12331a375ae7SMasami Hiramatsu return true;
12341a375ae7SMasami Hiramatsu }
12351a375ae7SMasami Hiramatsu return false;
12361a375ae7SMasami Hiramatsu }
12371a375ae7SMasami Hiramatsu
1238cf6eb489SMasami Hiramatsu /* Add a found probe point into trace event list */
add_probe_trace_event(Dwarf_Die * sc_die,struct probe_finder * pf)1239221d0611SMasami Hiramatsu static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1240cf6eb489SMasami Hiramatsu {
1241cf6eb489SMasami Hiramatsu struct trace_event_finder *tf =
1242cf6eb489SMasami Hiramatsu container_of(pf, struct trace_event_finder, pf);
12436cca13bdSMasami Hiramatsu struct perf_probe_point *pp = &pf->pev->point;
1244cf6eb489SMasami Hiramatsu struct probe_trace_event *tev;
1245092b1f0bSWang Nan struct perf_probe_arg *args = NULL;
1246cf6eb489SMasami Hiramatsu int ret, i;
1247cf6eb489SMasami Hiramatsu
12481a375ae7SMasami Hiramatsu /*
12491a375ae7SMasami Hiramatsu * For some reason (e.g. different column assigned to same address)
12501a375ae7SMasami Hiramatsu * This callback can be called with the address which already passed.
12511a375ae7SMasami Hiramatsu * Ignore it first.
12521a375ae7SMasami Hiramatsu */
12531a375ae7SMasami Hiramatsu if (trace_event_finder_overlap(tf))
12541a375ae7SMasami Hiramatsu return 0;
12551a375ae7SMasami Hiramatsu
1256cf6eb489SMasami Hiramatsu /* Check number of tevs */
1257cf6eb489SMasami Hiramatsu if (tf->ntevs == tf->max_tevs) {
1258cf6eb489SMasami Hiramatsu pr_warning("Too many( > %d) probe point found.\n",
1259cf6eb489SMasami Hiramatsu tf->max_tevs);
1260cf6eb489SMasami Hiramatsu return -ERANGE;
1261cf6eb489SMasami Hiramatsu }
1262cf6eb489SMasami Hiramatsu tev = &tf->tevs[tf->ntevs++];
1263cf6eb489SMasami Hiramatsu
1264221d0611SMasami Hiramatsu /* Trace point should be converted from subprogram DIE */
1265576b5237SMasami Hiramatsu ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
12666cca13bdSMasami Hiramatsu pp->retprobe, pp->function, &tev->point);
1267cf6eb489SMasami Hiramatsu if (ret < 0)
1268092b1f0bSWang Nan goto end;
1269cf6eb489SMasami Hiramatsu
12704c859351SMasami Hiramatsu tev->point.realname = strdup(dwarf_diename(sc_die));
1271092b1f0bSWang Nan if (!tev->point.realname) {
1272092b1f0bSWang Nan ret = -ENOMEM;
1273092b1f0bSWang Nan goto end;
1274092b1f0bSWang Nan }
12754c859351SMasami Hiramatsu
1276cf6eb489SMasami Hiramatsu pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
1277cf6eb489SMasami Hiramatsu tev->point.offset);
1278cf6eb489SMasami Hiramatsu
12797969ec77SMasami Hiramatsu /* Expand special probe argument if exist */
12807969ec77SMasami Hiramatsu args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
1281092b1f0bSWang Nan if (args == NULL) {
1282092b1f0bSWang Nan ret = -ENOMEM;
1283092b1f0bSWang Nan goto end;
1284092b1f0bSWang Nan }
12857969ec77SMasami Hiramatsu
12867969ec77SMasami Hiramatsu ret = expand_probe_args(sc_die, pf, args);
12877969ec77SMasami Hiramatsu if (ret < 0)
12887969ec77SMasami Hiramatsu goto end;
12897969ec77SMasami Hiramatsu
12907969ec77SMasami Hiramatsu tev->nargs = ret;
12917969ec77SMasami Hiramatsu tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
12927969ec77SMasami Hiramatsu if (tev->args == NULL) {
12937969ec77SMasami Hiramatsu ret = -ENOMEM;
12947969ec77SMasami Hiramatsu goto end;
12957969ec77SMasami Hiramatsu }
12967969ec77SMasami Hiramatsu
12977969ec77SMasami Hiramatsu /* Find each argument */
12987969ec77SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) {
12997969ec77SMasami Hiramatsu pf->pvar = &args[i];
1300cf6eb489SMasami Hiramatsu pf->tvar = &tev->args[i];
1301221d0611SMasami Hiramatsu /* Variable should be found from scope DIE */
1302221d0611SMasami Hiramatsu ret = find_variable(sc_die, pf);
1303cf6eb489SMasami Hiramatsu if (ret != 0)
13047969ec77SMasami Hiramatsu break;
1305cf6eb489SMasami Hiramatsu }
1306cf6eb489SMasami Hiramatsu
13077969ec77SMasami Hiramatsu end:
1308092b1f0bSWang Nan if (ret) {
1309092b1f0bSWang Nan clear_probe_trace_event(tev);
1310092b1f0bSWang Nan tf->ntevs--;
1311092b1f0bSWang Nan }
13127969ec77SMasami Hiramatsu free(args);
13137969ec77SMasami Hiramatsu return ret;
1314cf6eb489SMasami Hiramatsu }
1315cf6eb489SMasami Hiramatsu
fill_empty_trace_arg(struct perf_probe_event * pev,struct probe_trace_event * tevs,int ntevs)1316cb402730SMasami Hiramatsu static int fill_empty_trace_arg(struct perf_probe_event *pev,
1317cb402730SMasami Hiramatsu struct probe_trace_event *tevs, int ntevs)
1318cb402730SMasami Hiramatsu {
1319cb402730SMasami Hiramatsu char **valp;
1320cb402730SMasami Hiramatsu char *type;
1321cb402730SMasami Hiramatsu int i, j, ret;
1322cb402730SMasami Hiramatsu
132311fd3eb8SMasami Hiramatsu if (!ntevs)
132411fd3eb8SMasami Hiramatsu return -ENOENT;
132511fd3eb8SMasami Hiramatsu
1326cb402730SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) {
1327cb402730SMasami Hiramatsu type = NULL;
1328cb402730SMasami Hiramatsu for (j = 0; j < ntevs; j++) {
1329cb402730SMasami Hiramatsu if (tevs[j].args[i].value) {
1330cb402730SMasami Hiramatsu type = tevs[j].args[i].type;
1331cb402730SMasami Hiramatsu break;
1332cb402730SMasami Hiramatsu }
1333cb402730SMasami Hiramatsu }
1334cb402730SMasami Hiramatsu if (j == ntevs) {
1335cb402730SMasami Hiramatsu print_var_not_found(pev->args[i].var);
1336cb402730SMasami Hiramatsu return -ENOENT;
1337cb402730SMasami Hiramatsu }
1338cb402730SMasami Hiramatsu for (j = 0; j < ntevs; j++) {
1339cb402730SMasami Hiramatsu valp = &tevs[j].args[i].value;
1340cb402730SMasami Hiramatsu if (*valp)
1341cb402730SMasami Hiramatsu continue;
1342cb402730SMasami Hiramatsu
1343cb402730SMasami Hiramatsu ret = asprintf(valp, "\\%lx", probe_conf.magic_num);
1344cb402730SMasami Hiramatsu if (ret < 0)
1345cb402730SMasami Hiramatsu return -ENOMEM;
1346cb402730SMasami Hiramatsu /* Note that type can be NULL */
1347cb402730SMasami Hiramatsu if (type) {
1348cb402730SMasami Hiramatsu tevs[j].args[i].type = strdup(type);
1349cb402730SMasami Hiramatsu if (!tevs[j].args[i].type)
1350cb402730SMasami Hiramatsu return -ENOMEM;
1351cb402730SMasami Hiramatsu }
1352cb402730SMasami Hiramatsu }
1353cb402730SMasami Hiramatsu }
1354cb402730SMasami Hiramatsu return 0;
1355cb402730SMasami Hiramatsu }
1356cb402730SMasami Hiramatsu
1357cf6eb489SMasami Hiramatsu /* Find probe_trace_events specified by perf_probe_event from debuginfo */
debuginfo__find_trace_events(struct debuginfo * dbg,struct perf_probe_event * pev,struct probe_trace_event ** tevs)1358316c7136SArnaldo Carvalho de Melo int debuginfo__find_trace_events(struct debuginfo *dbg,
1359ff741783SMasami Hiramatsu struct perf_probe_event *pev,
1360ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs)
1361cf6eb489SMasami Hiramatsu {
1362cf6eb489SMasami Hiramatsu struct trace_event_finder tf = {
13637cd5738dSMasami Hiramatsu .pf = {.pev = pev, .dbg = dbg, .callback = add_probe_trace_event},
1364ddb2f58fSMasami Hiramatsu .max_tevs = probe_conf.max_probes, .mod = dbg->mod};
13650196e787SMasami Hiramatsu int ret, i;
1366cf6eb489SMasami Hiramatsu
1367cf6eb489SMasami Hiramatsu /* Allocate result tevs array */
1368ddb2f58fSMasami Hiramatsu *tevs = zalloc(sizeof(struct probe_trace_event) * tf.max_tevs);
1369cf6eb489SMasami Hiramatsu if (*tevs == NULL)
1370cf6eb489SMasami Hiramatsu return -ENOMEM;
1371cf6eb489SMasami Hiramatsu
1372cf6eb489SMasami Hiramatsu tf.tevs = *tevs;
1373cf6eb489SMasami Hiramatsu tf.ntevs = 0;
1374cf6eb489SMasami Hiramatsu
1375cb402730SMasami Hiramatsu if (pev->nargs != 0 && immediate_value_is_supported())
1376cb402730SMasami Hiramatsu tf.pf.skip_empty_arg = true;
1377cb402730SMasami Hiramatsu
1378316c7136SArnaldo Carvalho de Melo ret = debuginfo__find_probes(dbg, &tf.pf);
1379cb402730SMasami Hiramatsu if (ret >= 0 && tf.pf.skip_empty_arg)
1380cb402730SMasami Hiramatsu ret = fill_empty_trace_arg(pev, tf.tevs, tf.ntevs);
1381cb402730SMasami Hiramatsu
138212d572e7SMasami Hiramatsu if (ret < 0 || tf.ntevs == 0) {
13830196e787SMasami Hiramatsu for (i = 0; i < tf.ntevs; i++)
13840196e787SMasami Hiramatsu clear_probe_trace_event(&tf.tevs[i]);
138504662523SArnaldo Carvalho de Melo zfree(tevs);
1386cf6eb489SMasami Hiramatsu return ret;
1387cf6eb489SMasami Hiramatsu }
1388cf6eb489SMasami Hiramatsu
1389cf6eb489SMasami Hiramatsu return (ret < 0) ? ret : tf.ntevs;
1390cf6eb489SMasami Hiramatsu }
1391cf6eb489SMasami Hiramatsu
1392cf6eb489SMasami Hiramatsu /* Collect available variables in this scope */
collect_variables_cb(Dwarf_Die * die_mem,void * data)1393cf6eb489SMasami Hiramatsu static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
1394cf6eb489SMasami Hiramatsu {
1395cf6eb489SMasami Hiramatsu struct available_var_finder *af = data;
1396cf6eb489SMasami Hiramatsu struct variable_list *vl;
1397bf4d5f25SMasami Hiramatsu struct strbuf buf = STRBUF_INIT;
1398cf6eb489SMasami Hiramatsu int tag, ret;
1399cf6eb489SMasami Hiramatsu
1400cf6eb489SMasami Hiramatsu vl = &af->vls[af->nvls - 1];
1401cf6eb489SMasami Hiramatsu
1402cf6eb489SMasami Hiramatsu tag = dwarf_tag(die_mem);
1403cf6eb489SMasami Hiramatsu if (tag == DW_TAG_formal_parameter ||
1404cf6eb489SMasami Hiramatsu tag == DW_TAG_variable) {
1405cf6eb489SMasami Hiramatsu ret = convert_variable_location(die_mem, af->pf.addr,
14063d918a12SMasami Hiramatsu af->pf.fb_ops, &af->pf.sp_die,
1407293d5b43SMasami Hiramatsu af->pf.machine, NULL);
1408349e8d26SHe Kuang if (ret == 0 || ret == -ERANGE) {
1409349e8d26SHe Kuang int ret2;
1410349e8d26SHe Kuang bool externs = !af->child;
1411fb9596d1SHe Kuang
1412bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 64) < 0)
1413bf4d5f25SMasami Hiramatsu goto error;
1414349e8d26SHe Kuang
1415349e8d26SHe Kuang if (probe_conf.show_location_range) {
1416bf4d5f25SMasami Hiramatsu if (!externs)
1417bf4d5f25SMasami Hiramatsu ret2 = strbuf_add(&buf,
1418bf4d5f25SMasami Hiramatsu ret ? "[INV]\t" : "[VAL]\t", 6);
1419349e8d26SHe Kuang else
1420bf4d5f25SMasami Hiramatsu ret2 = strbuf_add(&buf, "[EXT]\t", 6);
1421bf4d5f25SMasami Hiramatsu if (ret2)
1422bf4d5f25SMasami Hiramatsu goto error;
1423349e8d26SHe Kuang }
1424349e8d26SHe Kuang
1425349e8d26SHe Kuang ret2 = die_get_varname(die_mem, &buf);
1426349e8d26SHe Kuang
1427349e8d26SHe Kuang if (!ret2 && probe_conf.show_location_range &&
1428349e8d26SHe Kuang !externs) {
1429bf4d5f25SMasami Hiramatsu if (strbuf_addch(&buf, '\t') < 0)
1430bf4d5f25SMasami Hiramatsu goto error;
1431349e8d26SHe Kuang ret2 = die_get_var_range(&af->pf.sp_die,
1432349e8d26SHe Kuang die_mem, &buf);
1433349e8d26SHe Kuang }
1434349e8d26SHe Kuang
1435349e8d26SHe Kuang pr_debug("Add new var: %s\n", buf.buf);
1436349e8d26SHe Kuang if (ret2 == 0) {
1437fb9596d1SHe Kuang strlist__add(vl->vars,
1438fb9596d1SHe Kuang strbuf_detach(&buf, NULL));
1439bf4d5f25SMasami Hiramatsu }
1440fb9596d1SHe Kuang strbuf_release(&buf);
1441cf6eb489SMasami Hiramatsu }
1442cf6eb489SMasami Hiramatsu }
1443cf6eb489SMasami Hiramatsu
1444fb8c5a56SMasami Hiramatsu if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1445cf6eb489SMasami Hiramatsu return DIE_FIND_CB_CONTINUE;
1446cf6eb489SMasami Hiramatsu else
1447cf6eb489SMasami Hiramatsu return DIE_FIND_CB_SIBLING;
1448bf4d5f25SMasami Hiramatsu error:
1449bf4d5f25SMasami Hiramatsu strbuf_release(&buf);
1450bf4d5f25SMasami Hiramatsu pr_debug("Error in strbuf\n");
1451bf4d5f25SMasami Hiramatsu return DIE_FIND_CB_END;
1452cf6eb489SMasami Hiramatsu }
1453cf6eb489SMasami Hiramatsu
available_var_finder_overlap(struct available_var_finder * af)1454dee36a2aSMasami Hiramatsu static bool available_var_finder_overlap(struct available_var_finder *af)
1455dee36a2aSMasami Hiramatsu {
1456dee36a2aSMasami Hiramatsu int i;
1457dee36a2aSMasami Hiramatsu
1458dee36a2aSMasami Hiramatsu for (i = 0; i < af->nvls; i++) {
1459dee36a2aSMasami Hiramatsu if (af->pf.addr == af->vls[i].point.address)
1460dee36a2aSMasami Hiramatsu return true;
1461dee36a2aSMasami Hiramatsu }
1462dee36a2aSMasami Hiramatsu return false;
1463dee36a2aSMasami Hiramatsu
1464dee36a2aSMasami Hiramatsu }
1465dee36a2aSMasami Hiramatsu
1466cf6eb489SMasami Hiramatsu /* Add a found vars into available variables list */
add_available_vars(Dwarf_Die * sc_die,struct probe_finder * pf)1467221d0611SMasami Hiramatsu static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
1468cf6eb489SMasami Hiramatsu {
1469cf6eb489SMasami Hiramatsu struct available_var_finder *af =
1470cf6eb489SMasami Hiramatsu container_of(pf, struct available_var_finder, pf);
14716cca13bdSMasami Hiramatsu struct perf_probe_point *pp = &pf->pev->point;
1472cf6eb489SMasami Hiramatsu struct variable_list *vl;
1473f182e3e1SMasami Hiramatsu Dwarf_Die die_mem;
1474f182e3e1SMasami Hiramatsu int ret;
1475cf6eb489SMasami Hiramatsu
1476dee36a2aSMasami Hiramatsu /*
1477dee36a2aSMasami Hiramatsu * For some reason (e.g. different column assigned to same address),
1478dee36a2aSMasami Hiramatsu * this callback can be called with the address which already passed.
1479dee36a2aSMasami Hiramatsu * Ignore it first.
1480dee36a2aSMasami Hiramatsu */
1481dee36a2aSMasami Hiramatsu if (available_var_finder_overlap(af))
1482dee36a2aSMasami Hiramatsu return 0;
1483dee36a2aSMasami Hiramatsu
1484cf6eb489SMasami Hiramatsu /* Check number of tevs */
1485cf6eb489SMasami Hiramatsu if (af->nvls == af->max_vls) {
1486cf6eb489SMasami Hiramatsu pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
1487cf6eb489SMasami Hiramatsu return -ERANGE;
1488cf6eb489SMasami Hiramatsu }
1489cf6eb489SMasami Hiramatsu vl = &af->vls[af->nvls++];
1490cf6eb489SMasami Hiramatsu
1491221d0611SMasami Hiramatsu /* Trace point should be converted from subprogram DIE */
1492576b5237SMasami Hiramatsu ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
14936cca13bdSMasami Hiramatsu pp->retprobe, pp->function, &vl->point);
1494cf6eb489SMasami Hiramatsu if (ret < 0)
1495cf6eb489SMasami Hiramatsu return ret;
1496cf6eb489SMasami Hiramatsu
1497cf6eb489SMasami Hiramatsu pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
1498cf6eb489SMasami Hiramatsu vl->point.offset);
1499cf6eb489SMasami Hiramatsu
1500cf6eb489SMasami Hiramatsu /* Find local variables */
15014a77e218SArnaldo Carvalho de Melo vl->vars = strlist__new(NULL, NULL);
1502cf6eb489SMasami Hiramatsu if (vl->vars == NULL)
1503cf6eb489SMasami Hiramatsu return -ENOMEM;
1504fb8c5a56SMasami Hiramatsu af->child = true;
1505221d0611SMasami Hiramatsu die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1506cf6eb489SMasami Hiramatsu
1507fb8c5a56SMasami Hiramatsu /* Find external variables */
1508ddb2f58fSMasami Hiramatsu if (!probe_conf.show_ext_vars)
1509fb8c5a56SMasami Hiramatsu goto out;
1510ddb2f58fSMasami Hiramatsu /* Don't need to search child DIE for external vars. */
1511fb8c5a56SMasami Hiramatsu af->child = false;
1512f182e3e1SMasami Hiramatsu die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
1513fb8c5a56SMasami Hiramatsu
1514fb8c5a56SMasami Hiramatsu out:
1515cf6eb489SMasami Hiramatsu if (strlist__empty(vl->vars)) {
1516cf6eb489SMasami Hiramatsu strlist__delete(vl->vars);
1517cf6eb489SMasami Hiramatsu vl->vars = NULL;
1518cf6eb489SMasami Hiramatsu }
1519cf6eb489SMasami Hiramatsu
1520cf6eb489SMasami Hiramatsu return ret;
1521cf6eb489SMasami Hiramatsu }
1522cf6eb489SMasami Hiramatsu
152369e96eaaSMasami Hiramatsu /*
152469e96eaaSMasami Hiramatsu * Find available variables at given probe point
152569e96eaaSMasami Hiramatsu * Return the number of found probe points. Return 0 if there is no
152669e96eaaSMasami Hiramatsu * matched probe point. Return <0 if an error occurs.
152769e96eaaSMasami Hiramatsu */
debuginfo__find_available_vars_at(struct debuginfo * dbg,struct perf_probe_event * pev,struct variable_list ** vls)1528316c7136SArnaldo Carvalho de Melo int debuginfo__find_available_vars_at(struct debuginfo *dbg,
1529ff741783SMasami Hiramatsu struct perf_probe_event *pev,
1530ddb2f58fSMasami Hiramatsu struct variable_list **vls)
1531cf6eb489SMasami Hiramatsu {
1532cf6eb489SMasami Hiramatsu struct available_var_finder af = {
15337cd5738dSMasami Hiramatsu .pf = {.pev = pev, .dbg = dbg, .callback = add_available_vars},
1534316c7136SArnaldo Carvalho de Melo .mod = dbg->mod,
1535ddb2f58fSMasami Hiramatsu .max_vls = probe_conf.max_probes};
1536cf6eb489SMasami Hiramatsu int ret;
1537cf6eb489SMasami Hiramatsu
1538cf6eb489SMasami Hiramatsu /* Allocate result vls array */
1539ddb2f58fSMasami Hiramatsu *vls = zalloc(sizeof(struct variable_list) * af.max_vls);
1540cf6eb489SMasami Hiramatsu if (*vls == NULL)
1541cf6eb489SMasami Hiramatsu return -ENOMEM;
1542cf6eb489SMasami Hiramatsu
1543cf6eb489SMasami Hiramatsu af.vls = *vls;
1544cf6eb489SMasami Hiramatsu af.nvls = 0;
1545cf6eb489SMasami Hiramatsu
1546316c7136SArnaldo Carvalho de Melo ret = debuginfo__find_probes(dbg, &af.pf);
1547cf6eb489SMasami Hiramatsu if (ret < 0) {
1548cf6eb489SMasami Hiramatsu /* Free vlist for error */
1549cf6eb489SMasami Hiramatsu while (af.nvls--) {
155074cf249dSArnaldo Carvalho de Melo zfree(&af.vls[af.nvls].point.symbol);
1551cf6eb489SMasami Hiramatsu strlist__delete(af.vls[af.nvls].vars);
1552cf6eb489SMasami Hiramatsu }
155304662523SArnaldo Carvalho de Melo zfree(vls);
1554cf6eb489SMasami Hiramatsu return ret;
1555cf6eb489SMasami Hiramatsu }
1556cf6eb489SMasami Hiramatsu
1557cf6eb489SMasami Hiramatsu return (ret < 0) ? ret : af.nvls;
15584ea42b18SMasami Hiramatsu }
15594ea42b18SMasami Hiramatsu
1560fb1587d8SMasami Hiramatsu /* Reverse search */
debuginfo__find_probe_point(struct debuginfo * dbg,u64 addr,struct perf_probe_point * ppt)156122a66551SYang Jihong int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr,
1562ff741783SMasami Hiramatsu struct perf_probe_point *ppt)
1563fb1587d8SMasami Hiramatsu {
1564fb1587d8SMasami Hiramatsu Dwarf_Die cudie, spdie, indie;
1565e08cfd4bSMasami Hiramatsu Dwarf_Addr _addr = 0, baseaddr = 0;
1566e08cfd4bSMasami Hiramatsu const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
15671d46ea2aSMasami Hiramatsu int baseline = 0, lineno = 0, ret = 0;
1568fb1587d8SMasami Hiramatsu
1569d2d4edbeSMasami Hiramatsu /* We always need to relocate the address for aranges */
1570613f050dSMasami Hiramatsu if (debuginfo__get_text_offset(dbg, &baseaddr, false) == 0)
1571d2d4edbeSMasami Hiramatsu addr += baseaddr;
1572fb1587d8SMasami Hiramatsu /* Find cu die */
15730104fe69SMasami Hiramatsu if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) {
1574265b0de2SArnaldo Carvalho de Melo pr_warning("Failed to find debug information for address %#" PRIx64 "\n",
15750e43e5d2SMasami Hiramatsu addr);
157675ec5a24SMasami Hiramatsu ret = -EINVAL;
157775ec5a24SMasami Hiramatsu goto end;
157875ec5a24SMasami Hiramatsu }
1579fb1587d8SMasami Hiramatsu
15801d46ea2aSMasami Hiramatsu /* Find a corresponding line (filename and lineno) */
158122a66551SYang Jihong cu_find_lineinfo(&cudie, (Dwarf_Addr)addr, &fname, &lineno);
15821d46ea2aSMasami Hiramatsu /* Don't care whether it failed or not */
1583fb1587d8SMasami Hiramatsu
15841d46ea2aSMasami Hiramatsu /* Find a corresponding function (name, baseline and baseaddr) */
1585e0d153c6SMasami Hiramatsu if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
15861d46ea2aSMasami Hiramatsu /* Get function entry information */
1587e08cfd4bSMasami Hiramatsu func = basefunc = dwarf_diename(&spdie);
1588e08cfd4bSMasami Hiramatsu if (!func ||
15893895534dSMasami Hiramatsu die_entrypc(&spdie, &baseaddr) != 0 ||
1590e08cfd4bSMasami Hiramatsu dwarf_decl_line(&spdie, &baseline) != 0) {
1591e08cfd4bSMasami Hiramatsu lineno = 0;
15921d46ea2aSMasami Hiramatsu goto post;
1593e08cfd4bSMasami Hiramatsu }
1594fb1587d8SMasami Hiramatsu
1595dc9a5d2cSMasami Hiramatsu (Google) fname = die_get_decl_file(&spdie);
159622a66551SYang Jihong if (addr == baseaddr) {
15971d46ea2aSMasami Hiramatsu /* Function entry - Relative line number is 0 */
15981d46ea2aSMasami Hiramatsu lineno = baseline;
1599e08cfd4bSMasami Hiramatsu goto post;
1600e08cfd4bSMasami Hiramatsu }
1601e08cfd4bSMasami Hiramatsu
1602e08cfd4bSMasami Hiramatsu /* Track down the inline functions step by step */
1603e08cfd4bSMasami Hiramatsu while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr,
1604b55a87adSMasami Hiramatsu &indie)) {
1605e08cfd4bSMasami Hiramatsu /* There is an inline function */
16063895534dSMasami Hiramatsu if (die_entrypc(&indie, &_addr) == 0 &&
1607e08cfd4bSMasami Hiramatsu _addr == addr) {
16081d46ea2aSMasami Hiramatsu /*
16091d46ea2aSMasami Hiramatsu * addr is at an inline function entry.
16101d46ea2aSMasami Hiramatsu * In this case, lineno should be the call-site
1611e08cfd4bSMasami Hiramatsu * line number. (overwrite lineinfo)
16121d46ea2aSMasami Hiramatsu */
16131d46ea2aSMasami Hiramatsu lineno = die_get_call_lineno(&indie);
1614e08cfd4bSMasami Hiramatsu fname = die_get_call_file(&indie);
1615e08cfd4bSMasami Hiramatsu break;
1616e08cfd4bSMasami Hiramatsu } else {
16171d46ea2aSMasami Hiramatsu /*
16181d46ea2aSMasami Hiramatsu * addr is in an inline function body.
16191d46ea2aSMasami Hiramatsu * Since lineno points one of the lines
16201d46ea2aSMasami Hiramatsu * of the inline function, baseline should
16211d46ea2aSMasami Hiramatsu * be the entry line of the inline function.
16221d46ea2aSMasami Hiramatsu */
1623fb1587d8SMasami Hiramatsu tmp = dwarf_diename(&indie);
1624e08cfd4bSMasami Hiramatsu if (!tmp ||
1625e08cfd4bSMasami Hiramatsu dwarf_decl_line(&indie, &baseline) != 0)
1626e08cfd4bSMasami Hiramatsu break;
16271d46ea2aSMasami Hiramatsu func = tmp;
1628e08cfd4bSMasami Hiramatsu spdie = indie;
1629b55a87adSMasami Hiramatsu }
1630b55a87adSMasami Hiramatsu }
1631e08cfd4bSMasami Hiramatsu /* Verify the lineno and baseline are in a same file */
1632dc9a5d2cSMasami Hiramatsu (Google) tmp = die_get_decl_file(&spdie);
163398e4c68dSMasami Hiramatsu (Google) if (!tmp || (fname && strcmp(tmp, fname) != 0))
1634e08cfd4bSMasami Hiramatsu lineno = 0;
16351d46ea2aSMasami Hiramatsu }
16361d46ea2aSMasami Hiramatsu
16371d46ea2aSMasami Hiramatsu post:
16381d46ea2aSMasami Hiramatsu /* Make a relative line number or an offset */
16391d46ea2aSMasami Hiramatsu if (lineno)
16401d46ea2aSMasami Hiramatsu ppt->line = lineno - baseline;
1641e08cfd4bSMasami Hiramatsu else if (basefunc) {
164222a66551SYang Jihong ppt->offset = addr - baseaddr;
1643e08cfd4bSMasami Hiramatsu func = basefunc;
1644e08cfd4bSMasami Hiramatsu }
16451d46ea2aSMasami Hiramatsu
16461d46ea2aSMasami Hiramatsu /* Duplicate strings */
16471d46ea2aSMasami Hiramatsu if (func) {
16481d46ea2aSMasami Hiramatsu ppt->function = strdup(func);
164902b95dadSMasami Hiramatsu if (ppt->function == NULL) {
165002b95dadSMasami Hiramatsu ret = -ENOMEM;
165102b95dadSMasami Hiramatsu goto end;
165202b95dadSMasami Hiramatsu }
1653fb1587d8SMasami Hiramatsu }
16541d46ea2aSMasami Hiramatsu if (fname) {
16551d46ea2aSMasami Hiramatsu ppt->file = strdup(fname);
16561d46ea2aSMasami Hiramatsu if (ppt->file == NULL) {
165704662523SArnaldo Carvalho de Melo zfree(&ppt->function);
16581d46ea2aSMasami Hiramatsu ret = -ENOMEM;
16591d46ea2aSMasami Hiramatsu goto end;
16601d46ea2aSMasami Hiramatsu }
16611d46ea2aSMasami Hiramatsu }
1662fb1587d8SMasami Hiramatsu end:
16631d46ea2aSMasami Hiramatsu if (ret == 0 && (fname || func))
16641d46ea2aSMasami Hiramatsu ret = 1; /* Found a point */
1665fb1587d8SMasami Hiramatsu return ret;
1666fb1587d8SMasami Hiramatsu }
1667fb1587d8SMasami Hiramatsu
1668f6c903f5SMasami Hiramatsu /* Add a line and store the src path */
line_range_add_line(const char * src,unsigned int lineno,struct line_range * lr)1669f6c903f5SMasami Hiramatsu static int line_range_add_line(const char *src, unsigned int lineno,
1670f6c903f5SMasami Hiramatsu struct line_range *lr)
1671f6c903f5SMasami Hiramatsu {
16727cf0b79eSMasami Hiramatsu /* Copy source path */
1673f6c903f5SMasami Hiramatsu if (!lr->path) {
16747cf0b79eSMasami Hiramatsu lr->path = strdup(src);
16757cf0b79eSMasami Hiramatsu if (lr->path == NULL)
16767cf0b79eSMasami Hiramatsu return -ENOMEM;
1677f6c903f5SMasami Hiramatsu }
16785a62257aSMasami Hiramatsu return intlist__add(lr->line_list, lineno);
1679f6c903f5SMasami Hiramatsu }
1680f6c903f5SMasami Hiramatsu
line_range_walk_cb(const char * fname,int lineno,Dwarf_Addr addr,void * data)16814cc9cec6SMasami Hiramatsu static int line_range_walk_cb(const char *fname, int lineno,
168222a66551SYang Jihong Dwarf_Addr addr, void *data)
1683f6c903f5SMasami Hiramatsu {
16844cc9cec6SMasami Hiramatsu struct line_finder *lf = data;
1685499144c8SMasami Hiramatsu const char *__fname;
1686499144c8SMasami Hiramatsu int __lineno;
1687202c7c12SNamhyung Kim int err;
1688f6c903f5SMasami Hiramatsu
16894cc9cec6SMasami Hiramatsu if ((strtailcmp(fname, lf->fname) != 0) ||
1690f6c903f5SMasami Hiramatsu (lf->lno_s > lineno || lf->lno_e < lineno))
16914cc9cec6SMasami Hiramatsu return 0;
1692f6c903f5SMasami Hiramatsu
16934d39c89fSIngo Molnar /* Make sure this line can be reversible */
1694499144c8SMasami Hiramatsu if (cu_find_lineinfo(&lf->cu_die, addr, &__fname, &__lineno) > 0
1695499144c8SMasami Hiramatsu && (lineno != __lineno || strcmp(fname, __fname)))
1696499144c8SMasami Hiramatsu return 0;
1697499144c8SMasami Hiramatsu
1698202c7c12SNamhyung Kim err = line_range_add_line(fname, lineno, lf->lr);
1699202c7c12SNamhyung Kim if (err < 0 && err != -EEXIST)
1700202c7c12SNamhyung Kim return err;
1701f6c903f5SMasami Hiramatsu
17024cc9cec6SMasami Hiramatsu return 0;
1703f6c903f5SMasami Hiramatsu }
1704fb1587d8SMasami Hiramatsu
1705631c9defSMasami Hiramatsu /* Find line range from its line number */
find_line_range_by_line(Dwarf_Die * sp_die,struct line_finder * lf)1706b55a87adSMasami Hiramatsu static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1707631c9defSMasami Hiramatsu {
17084cc9cec6SMasami Hiramatsu int ret;
1709631c9defSMasami Hiramatsu
17104cc9cec6SMasami Hiramatsu ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
1711f6c903f5SMasami Hiramatsu
1712804b3606SMasami Hiramatsu /* Update status */
1713f6c903f5SMasami Hiramatsu if (ret >= 0)
17145a62257aSMasami Hiramatsu if (!intlist__empty(lf->lr->line_list))
1715f6c903f5SMasami Hiramatsu ret = lf->found = 1;
1716f6c903f5SMasami Hiramatsu else
1717f6c903f5SMasami Hiramatsu ret = 0; /* Lines are not found */
1718804b3606SMasami Hiramatsu else {
171904662523SArnaldo Carvalho de Melo zfree(&lf->lr->path);
1720804b3606SMasami Hiramatsu }
1721f6c903f5SMasami Hiramatsu return ret;
1722631c9defSMasami Hiramatsu }
1723631c9defSMasami Hiramatsu
line_range_inline_cb(Dwarf_Die * in_die,void * data)1724161a26b0SMasami Hiramatsu static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
1725161a26b0SMasami Hiramatsu {
1726182c228eSMasami Hiramatsu int ret = find_line_range_by_line(in_die, data);
172736c0c588SMasami Hiramatsu
172836c0c588SMasami Hiramatsu /*
172936c0c588SMasami Hiramatsu * We have to check all instances of inlined function, because
173036c0c588SMasami Hiramatsu * some execution paths can be optimized out depends on the
1731182c228eSMasami Hiramatsu * function argument of instances. However, if an error occurs,
1732182c228eSMasami Hiramatsu * it should be handled by the caller.
173336c0c588SMasami Hiramatsu */
1734182c228eSMasami Hiramatsu return ret < 0 ? ret : 0;
1735161a26b0SMasami Hiramatsu }
1736161a26b0SMasami Hiramatsu
17370dbb1cacSMasami Hiramatsu /* Search function definition from function name */
line_range_search_cb(Dwarf_Die * sp_die,void * data)1738e92b85e1SMasami Hiramatsu static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1739631c9defSMasami Hiramatsu {
1740b55a87adSMasami Hiramatsu struct dwarf_callback_param *param = data;
1741b55a87adSMasami Hiramatsu struct line_finder *lf = param->data;
1742631c9defSMasami Hiramatsu struct line_range *lr = lf->lr;
174398e4c68dSMasami Hiramatsu (Google) const char *fname;
1744631c9defSMasami Hiramatsu
17457d21635aSMasami Hiramatsu /* Check declared file */
174698e4c68dSMasami Hiramatsu (Google) if (lr->file) {
1747dc9a5d2cSMasami Hiramatsu (Google) fname = die_get_decl_file(sp_die);
174898e4c68dSMasami Hiramatsu (Google) if (!fname || strtailcmp(lr->file, fname))
17497d21635aSMasami Hiramatsu return DWARF_CB_OK;
175098e4c68dSMasami Hiramatsu (Google) }
17517d21635aSMasami Hiramatsu
1752a9ffd048SMasami Hiramatsu if (die_match_name(sp_die, lr->function) && die_is_func_def(sp_die)) {
1753dc9a5d2cSMasami Hiramatsu (Google) lf->fname = die_get_decl_file(sp_die);
1754e92b85e1SMasami Hiramatsu dwarf_decl_line(sp_die, &lr->offset);
1755804b3606SMasami Hiramatsu pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1756631c9defSMasami Hiramatsu lf->lno_s = lr->offset + lr->start;
1757d3b63d7aSMasami Hiramatsu if (lf->lno_s < 0) /* Overflow */
1758d3b63d7aSMasami Hiramatsu lf->lno_s = INT_MAX;
1759631c9defSMasami Hiramatsu lf->lno_e = lr->offset + lr->end;
1760d3b63d7aSMasami Hiramatsu if (lf->lno_e < 0) /* Overflow */
1761d3b63d7aSMasami Hiramatsu lf->lno_e = INT_MAX;
1762d3b63d7aSMasami Hiramatsu pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1763631c9defSMasami Hiramatsu lr->start = lf->lno_s;
1764631c9defSMasami Hiramatsu lr->end = lf->lno_e;
1765e1ecbbc3SMasami Hiramatsu if (!die_is_func_instance(sp_die))
1766db0d2c64SMasami Hiramatsu param->retval = die_walk_instances(sp_die,
1767db0d2c64SMasami Hiramatsu line_range_inline_cb, lf);
1768db0d2c64SMasami Hiramatsu else
1769b55a87adSMasami Hiramatsu param->retval = find_line_range_by_line(sp_die, lf);
1770b55a87adSMasami Hiramatsu return DWARF_CB_ABORT;
1771631c9defSMasami Hiramatsu }
1772b55a87adSMasami Hiramatsu return DWARF_CB_OK;
1773631c9defSMasami Hiramatsu }
1774631c9defSMasami Hiramatsu
find_line_range_by_func(struct line_finder * lf)1775b55a87adSMasami Hiramatsu static int find_line_range_by_func(struct line_finder *lf)
1776631c9defSMasami Hiramatsu {
1777b55a87adSMasami Hiramatsu struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1778b55a87adSMasami Hiramatsu dwarf_getfuncs(&lf->cu_die, line_range_search_cb, ¶m, 0);
1779b55a87adSMasami Hiramatsu return param.retval;
1780631c9defSMasami Hiramatsu }
1781631c9defSMasami Hiramatsu
debuginfo__find_line_range(struct debuginfo * dbg,struct line_range * lr)1782316c7136SArnaldo Carvalho de Melo int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr)
1783631c9defSMasami Hiramatsu {
1784804b3606SMasami Hiramatsu struct line_finder lf = {.lr = lr, .found = 0};
1785b55a87adSMasami Hiramatsu int ret = 0;
1786804b3606SMasami Hiramatsu Dwarf_Off off = 0, noff;
1787804b3606SMasami Hiramatsu size_t cuhl;
1788804b3606SMasami Hiramatsu Dwarf_Die *diep;
17896a330a3cSMasami Hiramatsu const char *comp_dir;
1790631c9defSMasami Hiramatsu
1791cd25f8bcSLin Ming /* Fastpath: lookup by function name from .debug_pubnames section */
1792cd25f8bcSLin Ming if (lr->function) {
1793cd25f8bcSLin Ming struct pubname_callback_param pubname_param = {
1794cd25f8bcSLin Ming .function = lr->function, .file = lr->file,
1795cd25f8bcSLin Ming .cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0};
1796cd25f8bcSLin Ming struct dwarf_callback_param line_range_param = {
1797cd25f8bcSLin Ming .data = (void *)&lf, .retval = 0};
1798cd25f8bcSLin Ming
1799316c7136SArnaldo Carvalho de Melo dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1800ff741783SMasami Hiramatsu &pubname_param, 0);
1801cd25f8bcSLin Ming if (pubname_param.found) {
1802cd25f8bcSLin Ming line_range_search_cb(&lf.sp_die, &line_range_param);
1803cd25f8bcSLin Ming if (lf.found)
1804cd25f8bcSLin Ming goto found;
1805cd25f8bcSLin Ming }
1806cd25f8bcSLin Ming }
1807cd25f8bcSLin Ming
1808804b3606SMasami Hiramatsu /* Loop on CUs (Compilation Unit) */
1809b55a87adSMasami Hiramatsu while (!lf.found && ret >= 0) {
1810316c7136SArnaldo Carvalho de Melo if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl,
1811ff741783SMasami Hiramatsu NULL, NULL, NULL) != 0)
1812631c9defSMasami Hiramatsu break;
1813631c9defSMasami Hiramatsu
1814631c9defSMasami Hiramatsu /* Get the DIE(Debugging Information Entry) of this CU */
1815316c7136SArnaldo Carvalho de Melo diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die);
1816900547ddSJianlin Lv if (!diep) {
1817900547ddSJianlin Lv off = noff;
1818804b3606SMasami Hiramatsu continue;
1819900547ddSJianlin Lv }
1820631c9defSMasami Hiramatsu
1821631c9defSMasami Hiramatsu /* Check if target file is included. */
1822631c9defSMasami Hiramatsu if (lr->file)
18232a9c8c36SMasami Hiramatsu lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1824804b3606SMasami Hiramatsu else
18252a9c8c36SMasami Hiramatsu lf.fname = 0;
1826631c9defSMasami Hiramatsu
18272a9c8c36SMasami Hiramatsu if (!lr->file || lf.fname) {
1828631c9defSMasami Hiramatsu if (lr->function)
1829b55a87adSMasami Hiramatsu ret = find_line_range_by_func(&lf);
1830631c9defSMasami Hiramatsu else {
1831631c9defSMasami Hiramatsu lf.lno_s = lr->start;
1832631c9defSMasami Hiramatsu lf.lno_e = lr->end;
1833b55a87adSMasami Hiramatsu ret = find_line_range_by_line(NULL, &lf);
1834631c9defSMasami Hiramatsu }
1835631c9defSMasami Hiramatsu }
1836804b3606SMasami Hiramatsu off = noff;
1837631c9defSMasami Hiramatsu }
18386a330a3cSMasami Hiramatsu
1839cd25f8bcSLin Ming found:
18406a330a3cSMasami Hiramatsu /* Store comp_dir */
18416a330a3cSMasami Hiramatsu if (lf.found) {
18426a330a3cSMasami Hiramatsu comp_dir = cu_get_comp_dir(&lf.cu_die);
18436a330a3cSMasami Hiramatsu if (comp_dir) {
18446a330a3cSMasami Hiramatsu lr->comp_dir = strdup(comp_dir);
18456a330a3cSMasami Hiramatsu if (!lr->comp_dir)
18466a330a3cSMasami Hiramatsu ret = -ENOMEM;
18476a330a3cSMasami Hiramatsu }
18486a330a3cSMasami Hiramatsu }
18496a330a3cSMasami Hiramatsu
18507cf0b79eSMasami Hiramatsu pr_debug("path: %s\n", lr->path);
1851b55a87adSMasami Hiramatsu return (ret < 0) ? ret : lf.found;
1852631c9defSMasami Hiramatsu }
1853631c9defSMasami Hiramatsu
185409ed8975SNaohiro Aota /*
185509ed8975SNaohiro Aota * Find a src file from a DWARF tag path. Prepend optional source path prefix
185609ed8975SNaohiro Aota * and chop off leading directories that do not exist. Result is passed back as
185709ed8975SNaohiro Aota * a newly allocated path on success.
185809ed8975SNaohiro Aota * Return 0 if file was found and readable, -errno otherwise.
185909ed8975SNaohiro Aota */
find_source_path(const char * raw_path,const char * sbuild_id,const char * comp_dir,char ** new_path)18607cd5738dSMasami Hiramatsu int find_source_path(const char *raw_path, const char *sbuild_id,
18617cd5738dSMasami Hiramatsu const char *comp_dir, char **new_path)
186209ed8975SNaohiro Aota {
186309ed8975SNaohiro Aota const char *prefix = symbol_conf.source_prefix;
186409ed8975SNaohiro Aota
18657cd5738dSMasami Hiramatsu if (sbuild_id && !prefix) {
18667cd5738dSMasami Hiramatsu if (!get_source_from_debuginfod(raw_path, sbuild_id, new_path))
18677cd5738dSMasami Hiramatsu return 0;
18687cd5738dSMasami Hiramatsu }
18697cd5738dSMasami Hiramatsu
187009ed8975SNaohiro Aota if (!prefix) {
187109ed8975SNaohiro Aota if (raw_path[0] != '/' && comp_dir)
187209ed8975SNaohiro Aota /* If not an absolute path, try to use comp_dir */
187309ed8975SNaohiro Aota prefix = comp_dir;
187409ed8975SNaohiro Aota else {
187509ed8975SNaohiro Aota if (access(raw_path, R_OK) == 0) {
187609ed8975SNaohiro Aota *new_path = strdup(raw_path);
187709ed8975SNaohiro Aota return *new_path ? 0 : -ENOMEM;
187809ed8975SNaohiro Aota } else
187909ed8975SNaohiro Aota return -errno;
188009ed8975SNaohiro Aota }
188109ed8975SNaohiro Aota }
188209ed8975SNaohiro Aota
188309ed8975SNaohiro Aota *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
188409ed8975SNaohiro Aota if (!*new_path)
188509ed8975SNaohiro Aota return -ENOMEM;
188609ed8975SNaohiro Aota
188709ed8975SNaohiro Aota for (;;) {
188809ed8975SNaohiro Aota sprintf(*new_path, "%s/%s", prefix, raw_path);
188909ed8975SNaohiro Aota
189009ed8975SNaohiro Aota if (access(*new_path, R_OK) == 0)
189109ed8975SNaohiro Aota return 0;
189209ed8975SNaohiro Aota
189309ed8975SNaohiro Aota if (!symbol_conf.source_prefix) {
189409ed8975SNaohiro Aota /* In case of searching comp_dir, don't retry */
189509ed8975SNaohiro Aota zfree(new_path);
189609ed8975SNaohiro Aota return -errno;
189709ed8975SNaohiro Aota }
189809ed8975SNaohiro Aota
189909ed8975SNaohiro Aota switch (errno) {
190009ed8975SNaohiro Aota case ENAMETOOLONG:
190109ed8975SNaohiro Aota case ENOENT:
190209ed8975SNaohiro Aota case EROFS:
190309ed8975SNaohiro Aota case EFAULT:
190409ed8975SNaohiro Aota raw_path = strchr(++raw_path, '/');
190509ed8975SNaohiro Aota if (!raw_path) {
190609ed8975SNaohiro Aota zfree(new_path);
190709ed8975SNaohiro Aota return -ENOENT;
190809ed8975SNaohiro Aota }
190909ed8975SNaohiro Aota continue;
191009ed8975SNaohiro Aota
191109ed8975SNaohiro Aota default:
191209ed8975SNaohiro Aota zfree(new_path);
191309ed8975SNaohiro Aota return -errno;
191409ed8975SNaohiro Aota }
191509ed8975SNaohiro Aota }
191609ed8975SNaohiro Aota }
1917