]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
a43783ae | 2 | #include <errno.h> |
f5a70801 RB |
3 | #include <string.h> |
4 | #include <regex.h> | |
5 | ||
bb62bad6 | 6 | #include "../../perf.h" |
f5a70801 | 7 | #include "../../util/util.h" |
bb62bad6 | 8 | #include "../../util/perf_regs.h" |
f5a70801 | 9 | #include "../../util/debug.h" |
bb62bad6 MS |
10 | |
11 | const struct sample_reg sample_reg_masks[] = { | |
12 | SMPL_REG(r0, PERF_REG_POWERPC_R0), | |
13 | SMPL_REG(r1, PERF_REG_POWERPC_R1), | |
14 | SMPL_REG(r2, PERF_REG_POWERPC_R2), | |
15 | SMPL_REG(r3, PERF_REG_POWERPC_R3), | |
16 | SMPL_REG(r4, PERF_REG_POWERPC_R4), | |
17 | SMPL_REG(r5, PERF_REG_POWERPC_R5), | |
18 | SMPL_REG(r6, PERF_REG_POWERPC_R6), | |
19 | SMPL_REG(r7, PERF_REG_POWERPC_R7), | |
20 | SMPL_REG(r8, PERF_REG_POWERPC_R8), | |
21 | SMPL_REG(r9, PERF_REG_POWERPC_R9), | |
22 | SMPL_REG(r10, PERF_REG_POWERPC_R10), | |
23 | SMPL_REG(r11, PERF_REG_POWERPC_R11), | |
24 | SMPL_REG(r12, PERF_REG_POWERPC_R12), | |
25 | SMPL_REG(r13, PERF_REG_POWERPC_R13), | |
26 | SMPL_REG(r14, PERF_REG_POWERPC_R14), | |
27 | SMPL_REG(r15, PERF_REG_POWERPC_R15), | |
28 | SMPL_REG(r16, PERF_REG_POWERPC_R16), | |
29 | SMPL_REG(r17, PERF_REG_POWERPC_R17), | |
30 | SMPL_REG(r18, PERF_REG_POWERPC_R18), | |
31 | SMPL_REG(r19, PERF_REG_POWERPC_R19), | |
32 | SMPL_REG(r20, PERF_REG_POWERPC_R20), | |
33 | SMPL_REG(r21, PERF_REG_POWERPC_R21), | |
34 | SMPL_REG(r22, PERF_REG_POWERPC_R22), | |
35 | SMPL_REG(r23, PERF_REG_POWERPC_R23), | |
36 | SMPL_REG(r24, PERF_REG_POWERPC_R24), | |
37 | SMPL_REG(r25, PERF_REG_POWERPC_R25), | |
38 | SMPL_REG(r26, PERF_REG_POWERPC_R26), | |
39 | SMPL_REG(r27, PERF_REG_POWERPC_R27), | |
40 | SMPL_REG(r28, PERF_REG_POWERPC_R28), | |
41 | SMPL_REG(r29, PERF_REG_POWERPC_R29), | |
42 | SMPL_REG(r30, PERF_REG_POWERPC_R30), | |
43 | SMPL_REG(r31, PERF_REG_POWERPC_R31), | |
44 | SMPL_REG(nip, PERF_REG_POWERPC_NIP), | |
45 | SMPL_REG(msr, PERF_REG_POWERPC_MSR), | |
46 | SMPL_REG(orig_r3, PERF_REG_POWERPC_ORIG_R3), | |
47 | SMPL_REG(ctr, PERF_REG_POWERPC_CTR), | |
48 | SMPL_REG(link, PERF_REG_POWERPC_LINK), | |
49 | SMPL_REG(xer, PERF_REG_POWERPC_XER), | |
50 | SMPL_REG(ccr, PERF_REG_POWERPC_CCR), | |
51 | SMPL_REG(softe, PERF_REG_POWERPC_SOFTE), | |
52 | SMPL_REG(trap, PERF_REG_POWERPC_TRAP), | |
53 | SMPL_REG(dar, PERF_REG_POWERPC_DAR), | |
54 | SMPL_REG(dsisr, PERF_REG_POWERPC_DSISR), | |
55 | SMPL_REG_END | |
56 | }; | |
f5a70801 RB |
57 | |
58 | /* REG or %rREG */ | |
59 | #define SDT_OP_REGEX1 "^(%r)?([1-2]?[0-9]|3[0-1])$" | |
60 | ||
61 | /* -NUM(REG) or NUM(REG) or -NUM(%rREG) or NUM(%rREG) */ | |
62 | #define SDT_OP_REGEX2 "^(\\-)?([0-9]+)\\((%r)?([1-2]?[0-9]|3[0-1])\\)$" | |
63 | ||
64 | static regex_t sdt_op_regex1, sdt_op_regex2; | |
65 | ||
66 | static int sdt_init_op_regex(void) | |
67 | { | |
68 | static int initialized; | |
69 | int ret = 0; | |
70 | ||
71 | if (initialized) | |
72 | return 0; | |
73 | ||
74 | ret = regcomp(&sdt_op_regex1, SDT_OP_REGEX1, REG_EXTENDED); | |
75 | if (ret) | |
76 | goto error; | |
77 | ||
78 | ret = regcomp(&sdt_op_regex2, SDT_OP_REGEX2, REG_EXTENDED); | |
79 | if (ret) | |
80 | goto free_regex1; | |
81 | ||
82 | initialized = 1; | |
83 | return 0; | |
84 | ||
85 | free_regex1: | |
86 | regfree(&sdt_op_regex1); | |
87 | error: | |
88 | pr_debug4("Regex compilation error.\n"); | |
89 | return ret; | |
90 | } | |
91 | ||
92 | /* | |
93 | * Parse OP and convert it into uprobe format, which is, +/-NUM(%gprREG). | |
94 | * Possible variants of OP are: | |
95 | * Format Example | |
96 | * ------------------------- | |
97 | * NUM(REG) 48(18) | |
98 | * -NUM(REG) -48(18) | |
99 | * NUM(%rREG) 48(%r18) | |
100 | * -NUM(%rREG) -48(%r18) | |
101 | * REG 18 | |
102 | * %rREG %r18 | |
103 | * iNUM i0 | |
104 | * i-NUM i-1 | |
105 | * | |
106 | * SDT marker arguments on Powerpc uses %rREG form with -mregnames flag | |
107 | * and REG form with -mno-regnames. Here REG is general purpose register, | |
108 | * which is in 0 to 31 range. | |
109 | */ | |
110 | int arch_sdt_arg_parse_op(char *old_op, char **new_op) | |
111 | { | |
112 | int ret, new_len; | |
113 | regmatch_t rm[5]; | |
114 | char prefix; | |
115 | ||
116 | /* Constant argument. Uprobe does not support it */ | |
117 | if (old_op[0] == 'i') { | |
118 | pr_debug4("Skipping unsupported SDT argument: %s\n", old_op); | |
119 | return SDT_ARG_SKIP; | |
120 | } | |
121 | ||
122 | ret = sdt_init_op_regex(); | |
123 | if (ret < 0) | |
124 | return ret; | |
125 | ||
126 | if (!regexec(&sdt_op_regex1, old_op, 3, rm, 0)) { | |
127 | /* REG or %rREG --> %gprREG */ | |
128 | ||
129 | new_len = 5; /* % g p r NULL */ | |
130 | new_len += (int)(rm[2].rm_eo - rm[2].rm_so); | |
131 | ||
132 | *new_op = zalloc(new_len); | |
133 | if (!*new_op) | |
134 | return -ENOMEM; | |
135 | ||
136 | scnprintf(*new_op, new_len, "%%gpr%.*s", | |
137 | (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so); | |
138 | } else if (!regexec(&sdt_op_regex2, old_op, 5, rm, 0)) { | |
139 | /* | |
140 | * -NUM(REG) or NUM(REG) or -NUM(%rREG) or NUM(%rREG) --> | |
141 | * +/-NUM(%gprREG) | |
142 | */ | |
143 | prefix = (rm[1].rm_so == -1) ? '+' : '-'; | |
144 | ||
145 | new_len = 8; /* +/- ( % g p r ) NULL */ | |
146 | new_len += (int)(rm[2].rm_eo - rm[2].rm_so); | |
147 | new_len += (int)(rm[4].rm_eo - rm[4].rm_so); | |
148 | ||
149 | *new_op = zalloc(new_len); | |
150 | if (!*new_op) | |
151 | return -ENOMEM; | |
152 | ||
153 | scnprintf(*new_op, new_len, "%c%.*s(%%gpr%.*s)", prefix, | |
154 | (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so, | |
155 | (int)(rm[4].rm_eo - rm[4].rm_so), old_op + rm[4].rm_so); | |
156 | } else { | |
157 | pr_debug4("Skipping unsupported SDT argument: %s\n", old_op); | |
158 | return SDT_ARG_SKIP; | |
159 | } | |
160 | ||
161 | return SDT_ARG_VALID; | |
162 | } |