1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #pragma ident "%Z%%M% %I% %E% SMI"
29
30 #include <sys/sysmacros.h>
31 #include <ctf_impl.h>
32
33 /*
34 * Compare the given input string and length against a table of known C storage
35 * qualifier keywords. We just ignore these in ctf_lookup_by_name, below. To
36 * do this quickly, we use a pre-computed Perfect Hash Function similar to the
37 * technique originally described in the classic paper:
38 *
39 * R.J. Cichelli, "Minimal Perfect Hash Functions Made Simple",
40 * Communications of the ACM, Volume 23, Issue 1, January 1980, pp. 17-19.
41 *
42 * For an input string S of length N, we use hash H = S[N - 1] + N - 105, which
43 * for the current set of qualifiers yields a unique H in the range [0 .. 20].
44 * The hash can be modified when the keyword set changes as necessary. We also
45 * store the length of each keyword and check it prior to the final strcmp().
46 */
47 static int
48 isqualifier(const char *s, size_t len)
49 {
50 static const struct qual {
51 const char *q_name;
52 size_t q_len;
53 } qhash[] = {
54 { "static", 6 }, { "", 0 }, { "", 0 }, { "", 0 },
55 { "volatile", 8 }, { "", 0 }, { "", 0 }, { "", 0 }, { "", 0 },
56 { "", 0 }, { "auto", 4 }, { "extern", 6 }, { "", 0 }, { "", 0 },
57 { "", 0 }, { "", 0 }, { "const", 5 }, { "register", 8 },
58 { "", 0 }, { "restrict", 8 }, { "_Restrict", 9 }
59 };
60
61 int h = s[len - 1] + (int)len - 105;
62 const struct qual *qp = &qhash[h];
63
64 return (h >= 0 && h < sizeof (qhash) / sizeof (qhash[0]) &&
65 len == qp->q_len && strncmp(qp->q_name, s, qp->q_len) == 0);
66 }
67
68 /*
69 * Attempt to convert the given C type name into the corresponding CTF type ID.
70 * It is not possible to do complete and proper conversion of type names
71 * without implementing a more full-fledged parser, which is necessary to
72 * handle things like types that are function pointers to functions that
73 * have arguments that are function pointers, and fun stuff like that.
74 * Instead, this function implements a very simple conversion algorithm that
75 * finds the things that we actually care about: structs, unions, enums,
76 * integers, floats, typedefs, and pointers to any of these named types.
77 */
78 ctf_id_t
79 ctf_lookup_by_name(ctf_file_t *fp, const char *name)
80 {
81 static const char delimiters[] = " \t\n\r\v\f*";
82
83 const ctf_lookup_t *lp;
84 const ctf_helem_t *hp;
85 const char *p, *q, *end;
86 ctf_id_t type = 0;
87 ctf_id_t ntype, ptype;
88
89 if (name == NULL)
90 return (ctf_set_errno(fp, EINVAL));
91
92 for (p = name, end = name + strlen(name); *p != '\0'; p = q) {
93 while (isspace(*p))
94 p++; /* skip leading ws */
95
96 if (p == end)
97 break;
98
99 if ((q = strpbrk(p + 1, delimiters)) == NULL)
100 q = end; /* compare until end */
101
102 if (*p == '*') {
103 /*
104 * Find a pointer to type by looking in fp->ctf_ptrtab.
105 * If we can't find a pointer to the given type, see if
106 * we can compute a pointer to the type resulting from
107 * resolving the type down to its base type and use
108 * that instead. This helps with cases where the CTF
109 * data includes "struct foo *" but not "foo_t *" and
110 * the user tries to access "foo_t *" in the debugger.
111 */
112 ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)];
113 if (ntype == 0) {
114 ntype = ctf_type_resolve(fp, type);
115 if (ntype == CTF_ERR || (ntype = fp->ctf_ptrtab[
116 CTF_TYPE_TO_INDEX(ntype)]) == 0) {
117 (void) ctf_set_errno(fp, ECTF_NOTYPE);
118 goto err;
119 }
120 }
121
122 type = CTF_INDEX_TO_TYPE(ntype,
123 (fp->ctf_flags & LCTF_CHILD));
124
125 q = p + 1;
126 continue;
127 }
128
129 if (isqualifier(p, (size_t)(q - p)))
130 continue; /* skip qualifier keyword */
131
132 for (lp = fp->ctf_lookups; lp->ctl_prefix != NULL; lp++) {
133 if (lp->ctl_prefix[0] == '\0' ||
134 strncmp(p, lp->ctl_prefix, (size_t)(q - p)) == 0) {
135 for (p += lp->ctl_len; isspace(*p); p++)
136 continue; /* skip prefix and next ws */
137
138 if ((q = strchr(p, '*')) == NULL)
139 q = end; /* compare until end */
140
141 while (isspace(q[-1]))
142 q--; /* exclude trailing ws */
143
144 if ((hp = ctf_hash_lookup(lp->ctl_hash, fp, p,
145 (size_t)(q - p))) == NULL) {
146 (void) ctf_set_errno(fp, ECTF_NOTYPE);
147 goto err;
148 }
149
150 type = hp->h_type;
151 break;
152 }
153 }
154
155 if (lp->ctl_prefix == NULL) {
156 (void) ctf_set_errno(fp, ECTF_NOTYPE);
157 goto err;
158 }
159 }
160
161 if (*p != '\0' || type == 0)
162 return (ctf_set_errno(fp, ECTF_SYNTAX));
163
164 return (type);
165
166 err:
167 if (fp->ctf_parent != NULL &&
168 (ptype = ctf_lookup_by_name(fp->ctf_parent, name)) != CTF_ERR)
169 return (ptype);
170
171 return (CTF_ERR);
172 }
173
174 /*
175 * Given a symbol table index, return the type of the data object described
176 * by the corresponding entry in the symbol table.
177 */
178 ctf_id_t
179 ctf_lookup_by_symbol(ctf_file_t *fp, ulong_t symidx)
180 {
181 const ctf_sect_t *sp = &fp->ctf_symtab;
182 ctf_id_t type;
183
184 if (sp->cts_data == NULL)
185 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
186
187 if (symidx >= fp->ctf_nsyms)
188 return (ctf_set_errno(fp, EINVAL));
189
190 if (sp->cts_entsize == sizeof (Elf32_Sym)) {
191 const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
192 if (ELF32_ST_TYPE(symp->st_info) != STT_OBJECT)
193 return (ctf_set_errno(fp, ECTF_NOTDATA));
194 } else {
195 const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
196 if (ELF64_ST_TYPE(symp->st_info) != STT_OBJECT)
197 return (ctf_set_errno(fp, ECTF_NOTDATA));
198 }
199
200 if (fp->ctf_sxlate[symidx] == -1u)
201 return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
202
203 type = *(ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
204 if (type == 0)
205 return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
206
207 return (type);
208 }
209
210 /*
211 * Return the pointer to the internal CTF type data corresponding to the
212 * given type ID. If the ID is invalid, the function returns NULL.
213 * This function is not exported outside of the library.
214 */
215 const ctf_type_t *
216 ctf_lookup_by_id(ctf_file_t **fpp, ctf_id_t type)
217 {
218 ctf_file_t *fp = *fpp; /* caller passes in starting CTF container */
219
220 if ((fp->ctf_flags & LCTF_CHILD) && CTF_TYPE_ISPARENT(type) &&
221 (fp = fp->ctf_parent) == NULL) {
222 (void) ctf_set_errno(*fpp, ECTF_NOPARENT);
223 return (NULL);
224 }
225
226 type = CTF_TYPE_TO_INDEX(type);
227 if (type > 0 && type <= fp->ctf_typemax) {
228 *fpp = fp; /* function returns ending CTF container */
229 return (LCTF_INDEX_TO_TYPEPTR(fp, type));
230 }
231
232 (void) ctf_set_errno(fp, ECTF_BADID);
233 return (NULL);
234 }
235
236 /*
237 * Given a symbol table index, return the info for the function described
238 * by the corresponding entry in the symbol table.
239 */
240 int
241 ctf_func_info(ctf_file_t *fp, ulong_t symidx, ctf_funcinfo_t *fip)
242 {
243 const ctf_sect_t *sp = &fp->ctf_symtab;
244 const ushort_t *dp;
245 ushort_t info, kind, n;
246
247 if (sp->cts_data == NULL)
248 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
249
250 if (symidx >= fp->ctf_nsyms)
251 return (ctf_set_errno(fp, EINVAL));
252
253 if (sp->cts_entsize == sizeof (Elf32_Sym)) {
254 const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
255 if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC)
256 return (ctf_set_errno(fp, ECTF_NOTFUNC));
257 } else {
258 const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
259 if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC)
260 return (ctf_set_errno(fp, ECTF_NOTFUNC));
261 }
262
263 if (fp->ctf_sxlate[symidx] == -1u)
264 return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
265
266 dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
267
268 info = *dp++;
269 kind = LCTF_INFO_KIND(fp, info);
270 n = LCTF_INFO_VLEN(fp, info);
271
272 if (kind == CTF_K_UNKNOWN && n == 0)
273 return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
274
275 if (kind != CTF_K_FUNCTION)
276 return (ctf_set_errno(fp, ECTF_CORRUPT));
277
278 fip->ctc_return = *dp++;
279 fip->ctc_argc = n;
280 fip->ctc_flags = 0;
281
282 if (n != 0 && dp[n - 1] == 0) {
283 fip->ctc_flags |= CTF_FUNC_VARARG;
284 fip->ctc_argc--;
285 }
286
287 return (0);
288 }
289
290 /*
291 * Given a symbol table index, return the arguments for the function described
292 * by the corresponding entry in the symbol table.
293 */
294 int
295 ctf_func_args(ctf_file_t *fp, ulong_t symidx, uint_t argc, ctf_id_t *argv)
296 {
297 const ushort_t *dp;
298 ctf_funcinfo_t f;
299
300 if (ctf_func_info(fp, symidx, &f) == CTF_ERR)
301 return (CTF_ERR); /* errno is set for us */
302
303 /*
304 * The argument data is two ushort_t's past the translation table
305 * offset: one for the function info, and one for the return type.
306 */
307 dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]) + 2;
308
309 for (argc = MIN(argc, f.ctc_argc); argc != 0; argc--)
310 *argv++ = *dp++;
311
312 return (0);
313 }