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 #include <ctf_impl.h>
29
30 ssize_t
31 ctf_get_ctt_size(const ctf_file_t *fp, const ctf_type_t *tp, ssize_t *sizep,
32 ssize_t *incrementp)
33 {
34 ssize_t size, increment;
35
36 if (fp->ctf_version > CTF_VERSION_1 &&
37 tp->ctt_size == CTF_LSIZE_SENT) {
38 size = CTF_TYPE_LSIZE(tp);
39 increment = sizeof (ctf_type_t);
40 } else {
41 size = tp->ctt_size;
42 increment = sizeof (ctf_stype_t);
43 }
44
45 if (sizep)
46 *sizep = size;
47 if (incrementp)
48 *incrementp = increment;
49
50 return (size);
51 }
52
53 /*
54 * Iterate over the members of a STRUCT or UNION. We pass the name, member
55 * type, and offset of each member to the specified callback function.
56 */
57 int
58 ctf_member_iter(ctf_file_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
59 {
60 ctf_file_t *ofp = fp;
61 const ctf_type_t *tp;
62 ssize_t size, increment;
63 uint_t kind, n;
64 int rc;
65
66 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
67 return (CTF_ERR); /* errno is set for us */
68
69 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
70 return (CTF_ERR); /* errno is set for us */
71
72 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
73 kind = LCTF_INFO_KIND(fp, tp->ctt_info);
74
75 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
76 return (ctf_set_errno(ofp, ECTF_NOTSOU));
77
78 if (fp->ctf_version == CTF_VERSION_1 || size < CTF_LSTRUCT_THRESH) {
79 const ctf_member_t *mp = (const ctf_member_t *)
80 ((uintptr_t)tp + increment);
81
82 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, mp++) {
83 const char *name = ctf_strptr(fp, mp->ctm_name);
84 if ((rc = func(name, mp->ctm_type, mp->ctm_offset,
85 arg)) != 0)
86 return (rc);
87 }
88
89 } else {
90 const ctf_lmember_t *lmp = (const ctf_lmember_t *)
91 ((uintptr_t)tp + increment);
92
93 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, lmp++) {
94 const char *name = ctf_strptr(fp, lmp->ctlm_name);
95 if ((rc = func(name, lmp->ctlm_type,
96 (ulong_t)CTF_LMEM_OFFSET(lmp), arg)) != 0)
97 return (rc);
98 }
99 }
100
101 return (0);
102 }
103
104 /*
105 * Iterate over the members of an ENUM. We pass the string name and associated
106 * integer value of each enum element to the specified callback function.
107 */
108 int
109 ctf_enum_iter(ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
110 {
111 ctf_file_t *ofp = fp;
112 const ctf_type_t *tp;
113 const ctf_enum_t *ep;
114 ssize_t increment;
115 uint_t n;
116 int rc;
117
118 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
119 return (CTF_ERR); /* errno is set for us */
120
121 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
122 return (CTF_ERR); /* errno is set for us */
123
124 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ENUM)
125 return (ctf_set_errno(ofp, ECTF_NOTENUM));
126
127 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
128
129 ep = (const ctf_enum_t *)((uintptr_t)tp + increment);
130
131 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, ep++) {
132 const char *name = ctf_strptr(fp, ep->cte_name);
133 if ((rc = func(name, ep->cte_value, arg)) != 0)
134 return (rc);
135 }
136
137 return (0);
138 }
139
140 /*
141 * Iterate over every root (user-visible) type in the given CTF container.
142 * We pass the type ID of each type to the specified callback function.
143 */
144 int
145 ctf_type_iter(ctf_file_t *fp, ctf_type_f *func, void *arg)
146 {
147 ctf_id_t id, max = fp->ctf_typemax;
148 int rc, child = (fp->ctf_flags & LCTF_CHILD);
149
150 for (id = 1; id <= max; id++) {
151 const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR(fp, id);
152 if (CTF_INFO_ISROOT(tp->ctt_info) &&
153 (rc = func(CTF_INDEX_TO_TYPE(id, child), arg)) != 0)
154 return (rc);
155 }
156
157 return (0);
158 }
159
160 /*
161 * Follow a given type through the graph for TYPEDEF, VOLATILE, CONST, and
162 * RESTRICT nodes until we reach a "base" type node. This is useful when
163 * we want to follow a type ID to a node that has members or a size. To guard
164 * against infinite loops, we implement simplified cycle detection and check
165 * each link against itself, the previous node, and the topmost node.
166 */
167 ctf_id_t
168 ctf_type_resolve(ctf_file_t *fp, ctf_id_t type)
169 {
170 ctf_id_t prev = type, otype = type;
171 ctf_file_t *ofp = fp;
172 const ctf_type_t *tp;
173
174 while ((tp = ctf_lookup_by_id(&fp, type)) != NULL) {
175 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
176 case CTF_K_TYPEDEF:
177 case CTF_K_VOLATILE:
178 case CTF_K_CONST:
179 case CTF_K_RESTRICT:
180 if (tp->ctt_type == type || tp->ctt_type == otype ||
181 tp->ctt_type == prev) {
182 ctf_dprintf("type %ld cycle detected\n", otype);
183 return (ctf_set_errno(ofp, ECTF_CORRUPT));
184 }
185 prev = type;
186 type = tp->ctt_type;
187 break;
188 default:
189 return (type);
190 }
191 }
192
193 return (CTF_ERR); /* errno is set for us */
194 }
195
196 /*
197 * Lookup the given type ID and print a string name for it into buf. Return
198 * the actual number of bytes (not including \0) needed to format the name.
199 */
200 static ssize_t
201 ctf_type_qlname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len,
202 const char *qname)
203 {
204 ctf_decl_t cd;
205 ctf_decl_node_t *cdp;
206 ctf_decl_prec_t prec, lp, rp;
207 int ptr, arr;
208 uint_t k;
209
210 if (fp == NULL && type == CTF_ERR)
211 return (-1); /* simplify caller code by permitting CTF_ERR */
212
213 ctf_decl_init(&cd, buf, len);
214 ctf_decl_push(&cd, fp, type);
215
216 if (cd.cd_err != 0) {
217 ctf_decl_fini(&cd);
218 return (ctf_set_errno(fp, cd.cd_err));
219 }
220
221 /*
222 * If the type graph's order conflicts with lexical precedence order
223 * for pointers or arrays, then we need to surround the declarations at
224 * the corresponding lexical precedence with parentheses. This can
225 * result in either a parenthesized pointer (*) as in int (*)() or
226 * int (*)[], or in a parenthesized pointer and array as in int (*[])().
227 */
228 ptr = cd.cd_order[CTF_PREC_POINTER] > CTF_PREC_POINTER;
229 arr = cd.cd_order[CTF_PREC_ARRAY] > CTF_PREC_ARRAY;
230
231 rp = arr ? CTF_PREC_ARRAY : ptr ? CTF_PREC_POINTER : -1;
232 lp = ptr ? CTF_PREC_POINTER : arr ? CTF_PREC_ARRAY : -1;
233
234 k = CTF_K_POINTER; /* avoid leading whitespace (see below) */
235
236 for (prec = CTF_PREC_BASE; prec < CTF_PREC_MAX; prec++) {
237 for (cdp = ctf_list_next(&cd.cd_nodes[prec]);
238 cdp != NULL; cdp = ctf_list_next(cdp)) {
239
240 ctf_file_t *rfp = fp;
241 const ctf_type_t *tp =
242 ctf_lookup_by_id(&rfp, cdp->cd_type);
243 const char *name = ctf_strptr(rfp, tp->ctt_name);
244
245 if (k != CTF_K_POINTER && k != CTF_K_ARRAY)
246 ctf_decl_sprintf(&cd, " ");
247
248 if (lp == prec) {
249 ctf_decl_sprintf(&cd, "(");
250 lp = -1;
251 }
252
253 switch (cdp->cd_kind) {
254 case CTF_K_INTEGER:
255 case CTF_K_FLOAT:
256 case CTF_K_TYPEDEF:
257 if (qname != NULL)
258 ctf_decl_sprintf(&cd, "%s`", qname);
259 ctf_decl_sprintf(&cd, "%s", name);
260 break;
261 case CTF_K_POINTER:
262 ctf_decl_sprintf(&cd, "*");
263 break;
264 case CTF_K_ARRAY:
265 ctf_decl_sprintf(&cd, "[%u]", cdp->cd_n);
266 break;
267 case CTF_K_FUNCTION:
268 ctf_decl_sprintf(&cd, "()");
269 break;
270 case CTF_K_STRUCT:
271 case CTF_K_FORWARD:
272 ctf_decl_sprintf(&cd, "struct ");
273 if (qname != NULL)
274 ctf_decl_sprintf(&cd, "%s`", qname);
275 ctf_decl_sprintf(&cd, "%s", name);
276 break;
277 case CTF_K_UNION:
278 ctf_decl_sprintf(&cd, "union ");
279 if (qname != NULL)
280 ctf_decl_sprintf(&cd, "%s`", qname);
281 ctf_decl_sprintf(&cd, "%s", name);
282 break;
283 case CTF_K_ENUM:
284 ctf_decl_sprintf(&cd, "enum ");
285 if (qname != NULL)
286 ctf_decl_sprintf(&cd, "%s`", qname);
287 ctf_decl_sprintf(&cd, "%s", name);
288 break;
289 case CTF_K_VOLATILE:
290 ctf_decl_sprintf(&cd, "volatile");
291 break;
292 case CTF_K_CONST:
293 ctf_decl_sprintf(&cd, "const");
294 break;
295 case CTF_K_RESTRICT:
296 ctf_decl_sprintf(&cd, "restrict");
297 break;
298 }
299
300 k = cdp->cd_kind;
301 }
302
303 if (rp == prec)
304 ctf_decl_sprintf(&cd, ")");
305 }
306
307 if (cd.cd_len >= len)
308 (void) ctf_set_errno(fp, ECTF_NAMELEN);
309
310 ctf_decl_fini(&cd);
311 return (cd.cd_len);
312 }
313
314 ssize_t
315 ctf_type_lname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
316 {
317 return (ctf_type_qlname(fp, type, buf, len, NULL));
318 }
319
320 /*
321 * Lookup the given type ID and print a string name for it into buf. If buf
322 * is too small, return NULL: the ECTF_NAMELEN error is set on 'fp' for us.
323 */
324 char *
325 ctf_type_name(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
326 {
327 ssize_t rv = ctf_type_qlname(fp, type, buf, len, NULL);
328 return (rv >= 0 && rv < len ? buf : NULL);
329 }
330
331 char *
332 ctf_type_qname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len,
333 const char *qname)
334 {
335 ssize_t rv = ctf_type_qlname(fp, type, buf, len, qname);
336 return (rv >= 0 && rv < len ? buf : NULL);
337 }
338
339
340 /*
341 * Resolve the type down to a base type node, and then return the size
342 * of the type storage in bytes.
343 */
344 ssize_t
345 ctf_type_size(ctf_file_t *fp, ctf_id_t type)
346 {
347 const ctf_type_t *tp;
348 ssize_t size;
349 ctf_arinfo_t ar;
350
351 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
352 return (-1); /* errno is set for us */
353
354 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
355 return (-1); /* errno is set for us */
356
357 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
358 case CTF_K_POINTER:
359 return (fp->ctf_dmodel->ctd_pointer);
360
361 case CTF_K_FUNCTION:
362 return (0); /* function size is only known by symtab */
363
364 case CTF_K_ENUM:
365 return (fp->ctf_dmodel->ctd_int);
366
367 case CTF_K_ARRAY:
368 /*
369 * Array size is not directly returned by stabs data. Instead,
370 * it defines the element type and requires the user to perform
371 * the multiplication. If ctf_get_ctt_size() returns zero, the
372 * current version of ctfconvert does not compute member sizes
373 * and we compute the size here on its behalf.
374 */
375 if ((size = ctf_get_ctt_size(fp, tp, NULL, NULL)) > 0)
376 return (size);
377
378 if (ctf_array_info(fp, type, &ar) == CTF_ERR ||
379 (size = ctf_type_size(fp, ar.ctr_contents)) == CTF_ERR)
380 return (-1); /* errno is set for us */
381
382 return (size * ar.ctr_nelems);
383
384 default:
385 return (ctf_get_ctt_size(fp, tp, NULL, NULL));
386 }
387 }
388
389 /*
390 * Resolve the type down to a base type node, and then return the alignment
391 * needed for the type storage in bytes.
392 */
393 ssize_t
394 ctf_type_align(ctf_file_t *fp, ctf_id_t type)
395 {
396 const ctf_type_t *tp;
397 ctf_arinfo_t r;
398
399 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
400 return (-1); /* errno is set for us */
401
402 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
403 return (-1); /* errno is set for us */
404
405 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
406 case CTF_K_POINTER:
407 case CTF_K_FUNCTION:
408 return (fp->ctf_dmodel->ctd_pointer);
409
410 case CTF_K_ARRAY:
411 if (ctf_array_info(fp, type, &r) == CTF_ERR)
412 return (-1); /* errno is set for us */
413 return (ctf_type_align(fp, r.ctr_contents));
414
415 case CTF_K_STRUCT:
416 case CTF_K_UNION: {
417 uint_t n = LCTF_INFO_VLEN(fp, tp->ctt_info);
418 ssize_t size, increment;
419 size_t align = 0;
420 const void *vmp;
421
422 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
423 vmp = (uchar_t *)tp + increment;
424
425 if (LCTF_INFO_KIND(fp, tp->ctt_info) == CTF_K_STRUCT)
426 n = MIN(n, 1); /* only use first member for structs */
427
428 if (fp->ctf_version == CTF_VERSION_1 ||
429 size < CTF_LSTRUCT_THRESH) {
430 const ctf_member_t *mp = vmp;
431 for (; n != 0; n--, mp++) {
432 ssize_t am = ctf_type_align(fp, mp->ctm_type);
433 align = MAX(align, am);
434 }
435 } else {
436 const ctf_lmember_t *lmp = vmp;
437 for (; n != 0; n--, lmp++) {
438 ssize_t am = ctf_type_align(fp, lmp->ctlm_type);
439 align = MAX(align, am);
440 }
441 }
442
443 return (align);
444 }
445
446 case CTF_K_ENUM:
447 return (fp->ctf_dmodel->ctd_int);
448
449 default:
450 return (ctf_get_ctt_size(fp, tp, NULL, NULL));
451 }
452 }
453
454 /*
455 * Return the kind (CTF_K_* constant) for the specified type ID.
456 */
457 int
458 ctf_type_kind(ctf_file_t *fp, ctf_id_t type)
459 {
460 const ctf_type_t *tp;
461
462 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
463 return (CTF_ERR); /* errno is set for us */
464
465 return (LCTF_INFO_KIND(fp, tp->ctt_info));
466 }
467
468 /*
469 * If the type is one that directly references another type (such as POINTER),
470 * then return the ID of the type to which it refers.
471 */
472 ctf_id_t
473 ctf_type_reference(ctf_file_t *fp, ctf_id_t type)
474 {
475 ctf_file_t *ofp = fp;
476 const ctf_type_t *tp;
477
478 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
479 return (CTF_ERR); /* errno is set for us */
480
481 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
482 case CTF_K_POINTER:
483 case CTF_K_TYPEDEF:
484 case CTF_K_VOLATILE:
485 case CTF_K_CONST:
486 case CTF_K_RESTRICT:
487 return (tp->ctt_type);
488 default:
489 return (ctf_set_errno(ofp, ECTF_NOTREF));
490 }
491 }
492
493 /*
494 * Find a pointer to type by looking in fp->ctf_ptrtab. If we can't find a
495 * pointer to the given type, see if we can compute a pointer to the type
496 * resulting from resolving the type down to its base type and use that
497 * instead. This helps with cases where the CTF data includes "struct foo *"
498 * but not "foo_t *" and the user accesses "foo_t *" in the debugger.
499 */
500 ctf_id_t
501 ctf_type_pointer(ctf_file_t *fp, ctf_id_t type)
502 {
503 ctf_file_t *ofp = fp;
504 ctf_id_t ntype;
505
506 if (ctf_lookup_by_id(&fp, type) == NULL)
507 return (CTF_ERR); /* errno is set for us */
508
509 if ((ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)]) != 0)
510 return (CTF_INDEX_TO_TYPE(ntype, (fp->ctf_flags & LCTF_CHILD)));
511
512 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
513 return (ctf_set_errno(ofp, ECTF_NOTYPE));
514
515 if (ctf_lookup_by_id(&fp, type) == NULL)
516 return (ctf_set_errno(ofp, ECTF_NOTYPE));
517
518 if ((ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)]) != 0)
519 return (CTF_INDEX_TO_TYPE(ntype, (fp->ctf_flags & LCTF_CHILD)));
520
521 return (ctf_set_errno(ofp, ECTF_NOTYPE));
522 }
523
524 /*
525 * Return the encoding for the specified INTEGER or FLOAT.
526 */
527 int
528 ctf_type_encoding(ctf_file_t *fp, ctf_id_t type, ctf_encoding_t *ep)
529 {
530 ctf_file_t *ofp = fp;
531 const ctf_type_t *tp;
532 ssize_t increment;
533 uint_t data;
534
535 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
536 return (CTF_ERR); /* errno is set for us */
537
538 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
539
540 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
541 case CTF_K_INTEGER:
542 data = *(const uint_t *)((uintptr_t)tp + increment);
543 ep->cte_format = CTF_INT_ENCODING(data);
544 ep->cte_offset = CTF_INT_OFFSET(data);
545 ep->cte_bits = CTF_INT_BITS(data);
546 break;
547 case CTF_K_FLOAT:
548 data = *(const uint_t *)((uintptr_t)tp + increment);
549 ep->cte_format = CTF_FP_ENCODING(data);
550 ep->cte_offset = CTF_FP_OFFSET(data);
551 ep->cte_bits = CTF_FP_BITS(data);
552 break;
553 default:
554 return (ctf_set_errno(ofp, ECTF_NOTINTFP));
555 }
556
557 return (0);
558 }
559
560 int
561 ctf_type_cmp(ctf_file_t *lfp, ctf_id_t ltype, ctf_file_t *rfp, ctf_id_t rtype)
562 {
563 int rval;
564
565 if (ltype < rtype)
566 rval = -1;
567 else if (ltype > rtype)
568 rval = 1;
569 else
570 rval = 0;
571
572 if (lfp == rfp)
573 return (rval);
574
575 if (CTF_TYPE_ISPARENT(ltype) && lfp->ctf_parent != NULL)
576 lfp = lfp->ctf_parent;
577
578 if (CTF_TYPE_ISPARENT(rtype) && rfp->ctf_parent != NULL)
579 rfp = rfp->ctf_parent;
580
581 if (lfp < rfp)
582 return (-1);
583
584 if (lfp > rfp)
585 return (1);
586
587 return (rval);
588 }
589
590 /*
591 * Return a boolean value indicating if two types are compatible integers or
592 * floating-pointer values. This function returns true if the two types are
593 * the same, or if they have the same ASCII name and encoding properties.
594 * This function could be extended to test for compatibility for other kinds.
595 */
596 int
597 ctf_type_compat(ctf_file_t *lfp, ctf_id_t ltype,
598 ctf_file_t *rfp, ctf_id_t rtype)
599 {
600 const ctf_type_t *ltp, *rtp;
601 ctf_encoding_t le, re;
602 ctf_arinfo_t la, ra;
603 uint_t lkind, rkind;
604
605 if (ctf_type_cmp(lfp, ltype, rfp, rtype) == 0)
606 return (1);
607
608 ltype = ctf_type_resolve(lfp, ltype);
609 lkind = ctf_type_kind(lfp, ltype);
610
611 rtype = ctf_type_resolve(rfp, rtype);
612 rkind = ctf_type_kind(rfp, rtype);
613
614 if (lkind != rkind ||
615 (ltp = ctf_lookup_by_id(&lfp, ltype)) == NULL ||
616 (rtp = ctf_lookup_by_id(&rfp, rtype)) == NULL ||
617 strcmp(ctf_strptr(lfp, ltp->ctt_name),
618 ctf_strptr(rfp, rtp->ctt_name)) != 0)
619 return (0);
620
621 switch (lkind) {
622 case CTF_K_INTEGER:
623 case CTF_K_FLOAT:
624 return (ctf_type_encoding(lfp, ltype, &le) == 0 &&
625 ctf_type_encoding(rfp, rtype, &re) == 0 &&
626 bcmp(&le, &re, sizeof (ctf_encoding_t)) == 0);
627 case CTF_K_POINTER:
628 return (ctf_type_compat(lfp, ctf_type_reference(lfp, ltype),
629 rfp, ctf_type_reference(rfp, rtype)));
630 case CTF_K_ARRAY:
631 return (ctf_array_info(lfp, ltype, &la) == 0 &&
632 ctf_array_info(rfp, rtype, &ra) == 0 &&
633 la.ctr_nelems == ra.ctr_nelems && ctf_type_compat(
634 lfp, la.ctr_contents, rfp, ra.ctr_contents) &&
635 ctf_type_compat(lfp, la.ctr_index, rfp, ra.ctr_index));
636 case CTF_K_STRUCT:
637 case CTF_K_UNION:
638 return (ctf_type_size(lfp, ltype) == ctf_type_size(rfp, rtype));
639 case CTF_K_ENUM:
640 case CTF_K_FORWARD:
641 return (1); /* no other checks required for these type kinds */
642 default:
643 return (0); /* should not get here since we did a resolve */
644 }
645 }
646
647 /*
648 * Return the type and offset for a given member of a STRUCT or UNION.
649 */
650 int
651 ctf_member_info(ctf_file_t *fp, ctf_id_t type, const char *name,
652 ctf_membinfo_t *mip)
653 {
654 ctf_file_t *ofp = fp;
655 const ctf_type_t *tp;
656 ssize_t size, increment;
657 uint_t kind, n;
658
659 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
660 return (CTF_ERR); /* errno is set for us */
661
662 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
663 return (CTF_ERR); /* errno is set for us */
664
665 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
666 kind = LCTF_INFO_KIND(fp, tp->ctt_info);
667
668 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
669 return (ctf_set_errno(ofp, ECTF_NOTSOU));
670
671 if (fp->ctf_version == CTF_VERSION_1 || size < CTF_LSTRUCT_THRESH) {
672 const ctf_member_t *mp = (const ctf_member_t *)
673 ((uintptr_t)tp + increment);
674
675 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, mp++) {
676 if (strcmp(ctf_strptr(fp, mp->ctm_name), name) == 0) {
677 mip->ctm_type = mp->ctm_type;
678 mip->ctm_offset = mp->ctm_offset;
679 return (0);
680 }
681 }
682 } else {
683 const ctf_lmember_t *lmp = (const ctf_lmember_t *)
684 ((uintptr_t)tp + increment);
685
686 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, lmp++) {
687 if (strcmp(ctf_strptr(fp, lmp->ctlm_name), name) == 0) {
688 mip->ctm_type = lmp->ctlm_type;
689 mip->ctm_offset = (ulong_t)CTF_LMEM_OFFSET(lmp);
690 return (0);
691 }
692 }
693 }
694
695 return (ctf_set_errno(ofp, ECTF_NOMEMBNAM));
696 }
697
698 /*
699 * Return the array type, index, and size information for the specified ARRAY.
700 */
701 int
702 ctf_array_info(ctf_file_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
703 {
704 ctf_file_t *ofp = fp;
705 const ctf_type_t *tp;
706 const ctf_array_t *ap;
707 ssize_t increment;
708
709 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
710 return (CTF_ERR); /* errno is set for us */
711
712 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ARRAY)
713 return (ctf_set_errno(ofp, ECTF_NOTARRAY));
714
715 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
716
717 ap = (const ctf_array_t *)((uintptr_t)tp + increment);
718 arp->ctr_contents = ap->cta_contents;
719 arp->ctr_index = ap->cta_index;
720 arp->ctr_nelems = ap->cta_nelems;
721
722 return (0);
723 }
724
725 /*
726 * Convert the specified value to the corresponding enum member name, if a
727 * matching name can be found. Otherwise NULL is returned.
728 */
729 const char *
730 ctf_enum_name(ctf_file_t *fp, ctf_id_t type, int value)
731 {
732 ctf_file_t *ofp = fp;
733 const ctf_type_t *tp;
734 const ctf_enum_t *ep;
735 ssize_t increment;
736 uint_t n;
737
738 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
739 return (NULL); /* errno is set for us */
740
741 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
742 return (NULL); /* errno is set for us */
743
744 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ENUM) {
745 (void) ctf_set_errno(ofp, ECTF_NOTENUM);
746 return (NULL);
747 }
748
749 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
750
751 ep = (const ctf_enum_t *)((uintptr_t)tp + increment);
752
753 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, ep++) {
754 if (ep->cte_value == value)
755 return (ctf_strptr(fp, ep->cte_name));
756 }
757
758 (void) ctf_set_errno(ofp, ECTF_NOENUMNAM);
759 return (NULL);
760 }
761
762 /*
763 * Convert the specified enum tag name to the corresponding value, if a
764 * matching name can be found. Otherwise CTF_ERR is returned.
765 */
766 int
767 ctf_enum_value(ctf_file_t *fp, ctf_id_t type, const char *name, int *valp)
768 {
769 ctf_file_t *ofp = fp;
770 const ctf_type_t *tp;
771 const ctf_enum_t *ep;
772 ssize_t size, increment;
773 uint_t n;
774
775 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
776 return (CTF_ERR); /* errno is set for us */
777
778 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
779 return (CTF_ERR); /* errno is set for us */
780
781 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ENUM) {
782 (void) ctf_set_errno(ofp, ECTF_NOTENUM);
783 return (CTF_ERR);
784 }
785
786 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
787
788 ep = (const ctf_enum_t *)((uintptr_t)tp + increment);
789
790 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, ep++) {
791 if (strcmp(ctf_strptr(fp, ep->cte_name), name) == 0) {
792 if (valp != NULL)
793 *valp = ep->cte_value;
794 return (0);
795 }
796 }
797
798 (void) ctf_set_errno(ofp, ECTF_NOENUMNAM);
799 return (CTF_ERR);
800 }
801
802 /*
803 * Recursively visit the members of any type. This function is used as the
804 * engine for ctf_type_visit, below. We resolve the input type, recursively
805 * invoke ourself for each type member if the type is a struct or union, and
806 * then invoke the callback function on the current type. If any callback
807 * returns non-zero, we abort and percolate the error code back up to the top.
808 */
809 static int
810 ctf_type_rvisit(ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg,
811 const char *name, ulong_t offset, int depth)
812 {
813 ctf_id_t otype = type;
814 const ctf_type_t *tp;
815 ssize_t size, increment;
816 uint_t kind, n;
817 int rc;
818
819 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
820 return (CTF_ERR); /* errno is set for us */
821
822 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
823 return (CTF_ERR); /* errno is set for us */
824
825 if ((rc = func(name, otype, offset, depth, arg)) != 0)
826 return (rc);
827
828 kind = LCTF_INFO_KIND(fp, tp->ctt_info);
829
830 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
831 return (0);
832
833 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
834
835 if (fp->ctf_version == CTF_VERSION_1 || size < CTF_LSTRUCT_THRESH) {
836 const ctf_member_t *mp = (const ctf_member_t *)
837 ((uintptr_t)tp + increment);
838
839 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, mp++) {
840 if ((rc = ctf_type_rvisit(fp, mp->ctm_type,
841 func, arg, ctf_strptr(fp, mp->ctm_name),
842 offset + mp->ctm_offset, depth + 1)) != 0)
843 return (rc);
844 }
845
846 } else {
847 const ctf_lmember_t *lmp = (const ctf_lmember_t *)
848 ((uintptr_t)tp + increment);
849
850 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, lmp++) {
851 if ((rc = ctf_type_rvisit(fp, lmp->ctlm_type,
852 func, arg, ctf_strptr(fp, lmp->ctlm_name),
853 offset + (ulong_t)CTF_LMEM_OFFSET(lmp),
854 depth + 1)) != 0)
855 return (rc);
856 }
857 }
858
859 return (0);
860 }
861
862 /*
863 * Recursively visit the members of any type. We pass the name, member
864 * type, and offset of each member to the specified callback function.
865 */
866 int
867 ctf_type_visit(ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg)
868 {
869 return (ctf_type_rvisit(fp, type, func, arg, "", 0, 0));
870 }