Print this page
rm code review
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/common/ctf/ctf_types.c
+++ new/usr/src/common/ctf/ctf_types.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License, Version 1.0 only
6 6 * (the "License"). You may not use this file except in compliance
7 7 * with the License.
8 8 *
9 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 * or http://www.opensolaris.org/os/licensing.
11 11 * See the License for the specific language governing permissions
12 12 * and limitations under the License.
13 13 *
14 14 * When distributing Covered Code, include this CDDL HEADER in each
15 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 * If applicable, add the following below this CDDL HEADER, with the
17 17 * fields enclosed by brackets "[]" replaced with your own identifying
18 18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 19 *
20 20 * CDDL HEADER END
21 21 */
22 22
23 23 /*
24 24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
25 25 * Use is subject to license terms.
26 26 */
27 27 /*
28 28 * Copyright 2020 Joyent, Inc.
29 29 */
30 30
31 31 #include <ctf_impl.h>
32 32 #include <sys/debug.h>
33 33
34 34 ssize_t
35 35 ctf_get_ctt_size(const ctf_file_t *fp, const ctf_type_t *tp, ssize_t *sizep,
36 36 ssize_t *incrementp)
37 37 {
38 38 ssize_t size, increment;
39 39
40 40 if (fp->ctf_version > CTF_VERSION_1 &&
41 41 tp->ctt_size == CTF_LSIZE_SENT) {
42 42 size = CTF_TYPE_LSIZE(tp);
43 43 increment = sizeof (ctf_type_t);
44 44 } else {
45 45 size = tp->ctt_size;
46 46 increment = sizeof (ctf_stype_t);
|
↓ open down ↓ |
46 lines elided |
↑ open up ↑ |
47 47 }
48 48
49 49 if (sizep)
50 50 *sizep = size;
51 51 if (incrementp)
52 52 *incrementp = increment;
53 53
54 54 return (size);
55 55 }
56 56
57 +void
58 +ctf_set_ctt_size(ctf_type_t *tp, ssize_t size)
59 +{
60 + if (size > CTF_MAX_SIZE) {
61 + tp->ctt_size = CTF_LSIZE_SENT;
62 + tp->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size);
63 + tp->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size);
64 + } else {
65 + tp->ctt_size = (ushort_t)size;
66 + }
67 +}
68 +
57 69 /*
58 70 * Iterate over the members of a STRUCT or UNION. We pass the name, member
59 71 * type, and offset of each member to the specified callback function.
60 72 */
61 73 int
62 74 ctf_member_iter(ctf_file_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
63 75 {
64 76 ctf_file_t *ofp = fp;
65 77 const ctf_type_t *tp;
66 78 ssize_t size, increment;
67 79 uint_t kind, n;
68 80 int rc;
69 81
70 82 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
71 83 return (CTF_ERR); /* errno is set for us */
72 84
73 85 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
74 86 return (CTF_ERR); /* errno is set for us */
75 87
76 88 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
77 89 kind = LCTF_INFO_KIND(fp, tp->ctt_info);
78 90
79 91 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
80 92 return (ctf_set_errno(ofp, ECTF_NOTSOU));
81 93
82 94 if (fp->ctf_version == CTF_VERSION_1 || size < CTF_LSTRUCT_THRESH) {
83 95 const ctf_member_t *mp = (const ctf_member_t *)
84 96 ((uintptr_t)tp + increment);
85 97
86 98 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, mp++) {
87 99 const char *name = ctf_strptr(fp, mp->ctm_name);
88 100 if ((rc = func(name, mp->ctm_type, mp->ctm_offset,
89 101 arg)) != 0)
90 102 return (rc);
91 103 }
92 104
93 105 } else {
94 106 const ctf_lmember_t *lmp = (const ctf_lmember_t *)
95 107 ((uintptr_t)tp + increment);
96 108
97 109 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, lmp++) {
98 110 const char *name = ctf_strptr(fp, lmp->ctlm_name);
99 111 if ((rc = func(name, lmp->ctlm_type,
100 112 (ulong_t)CTF_LMEM_OFFSET(lmp), arg)) != 0)
101 113 return (rc);
102 114 }
103 115 }
104 116
105 117 return (0);
106 118 }
107 119
108 120 /*
109 121 * Iterate over the members of an ENUM. We pass the string name and associated
110 122 * integer value of each enum element to the specified callback function.
111 123 */
112 124 int
113 125 ctf_enum_iter(ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
114 126 {
115 127 ctf_file_t *ofp = fp;
116 128 const ctf_type_t *tp;
117 129 const ctf_enum_t *ep;
118 130 ssize_t increment;
119 131 uint_t n;
120 132 int rc;
121 133
122 134 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
123 135 return (CTF_ERR); /* errno is set for us */
124 136
125 137 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
126 138 return (CTF_ERR); /* errno is set for us */
127 139
128 140 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ENUM)
129 141 return (ctf_set_errno(ofp, ECTF_NOTENUM));
130 142
131 143 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
132 144
133 145 ep = (const ctf_enum_t *)((uintptr_t)tp + increment);
134 146
135 147 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, ep++) {
136 148 const char *name = ctf_strptr(fp, ep->cte_name);
137 149 if ((rc = func(name, ep->cte_value, arg)) != 0)
138 150 return (rc);
139 151 }
140 152
141 153 return (0);
142 154 }
143 155
144 156 /*
145 157 * Iterate over every type in the given CTF container. If the user doesn't ask
146 158 * for all types, then we only give them the user visible, aka root, types. We
147 159 * pass the type ID of each type to the specified callback function.
148 160 */
149 161 int
150 162 ctf_type_iter(ctf_file_t *fp, boolean_t nonroot, ctf_type_f *func, void *arg)
151 163 {
152 164 ctf_id_t id, max = fp->ctf_typemax;
153 165 int rc, child = (fp->ctf_flags & LCTF_CHILD);
154 166
155 167 for (id = 1; id <= max; id++) {
156 168 const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR(fp, id);
157 169 if ((nonroot || CTF_INFO_ISROOT(tp->ctt_info)) &&
158 170 (rc = func(CTF_INDEX_TO_TYPE(id, child),
159 171 CTF_INFO_ISROOT(tp->ctt_info), arg)) != 0)
160 172 return (rc);
161 173 }
162 174
163 175 return (0);
164 176 }
165 177
166 178 /*
167 179 * Follow a given type through the graph for TYPEDEF, VOLATILE, CONST, and
168 180 * RESTRICT nodes until we reach a "base" type node. This is useful when
169 181 * we want to follow a type ID to a node that has members or a size. To guard
170 182 * against infinite loops, we implement simplified cycle detection and check
171 183 * each link against itself, the previous node, and the topmost node.
172 184 */
173 185 ctf_id_t
174 186 ctf_type_resolve(ctf_file_t *fp, ctf_id_t type)
175 187 {
176 188 ctf_id_t prev = type, otype = type;
177 189 ctf_file_t *ofp = fp;
178 190 const ctf_type_t *tp;
179 191
180 192 while ((tp = ctf_lookup_by_id(&fp, type)) != NULL) {
181 193 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
182 194 case CTF_K_TYPEDEF:
183 195 case CTF_K_VOLATILE:
184 196 case CTF_K_CONST:
185 197 case CTF_K_RESTRICT:
186 198 if (tp->ctt_type == type || tp->ctt_type == otype ||
187 199 tp->ctt_type == prev) {
188 200 ctf_dprintf("type %ld cycle detected\n", otype);
189 201 return (ctf_set_errno(ofp, ECTF_CORRUPT));
190 202 }
191 203 prev = type;
192 204 type = tp->ctt_type;
193 205 break;
194 206 default:
195 207 return (type);
196 208 }
197 209 }
198 210
199 211 return (CTF_ERR); /* errno is set for us */
200 212 }
201 213
202 214 /*
203 215 * Format an integer type; if a vname is specified, we need to insert it prior
204 216 * to any bitfield ":24" suffix. This works out far simpler than figuring it
205 217 * out from scratch.
206 218 */
207 219 static const char *
208 220 ctf_format_int(ctf_decl_t *cd, const char *vname, const char *qname,
209 221 const char *name)
210 222 {
211 223 const char *c;
212 224
213 225 if (vname == NULL) {
214 226 if (qname != NULL)
215 227 ctf_decl_sprintf(cd, "%s`%s", qname, name);
216 228 else
217 229 ctf_decl_sprintf(cd, "%s", name);
218 230 return (NULL);
219 231 }
220 232
221 233 if ((c = strchr(name, ':')) == NULL) {
222 234 ctf_decl_sprintf(cd, "%s", name);
223 235 return (vname);
224 236 }
225 237
226 238 /* "unsigned int mybits:23" */
227 239 ctf_decl_sprintf(cd, "%.*s %s%s", c - name, name, vname, c);
228 240 return (NULL);
229 241 }
230 242
231 243 static void
232 244 ctf_format_func(ctf_file_t *fp, ctf_decl_t *cd,
233 245 const char *vname, ctf_id_t id, int want_func_args)
234 246 {
235 247 ctf_funcinfo_t fi;
236 248 /* We'll presume zone_create() is a bad example. */
237 249 ctf_id_t args[20];
238 250
239 251 ctf_decl_sprintf(cd, "%s(", vname == NULL ? "" : vname);
240 252
241 253 if (!want_func_args)
242 254 goto out;
243 255
244 256 if (ctf_func_info_by_id(fp, id, &fi) != 0)
245 257 goto out;
246 258
247 259 if (fi.ctc_argc > ARRAY_SIZE(args))
248 260 fi.ctc_argc = ARRAY_SIZE(args);
249 261
250 262 if (fi.ctc_argc == 0) {
251 263 ctf_decl_sprintf(cd, "void");
252 264 goto out;
253 265 }
254 266
255 267 if (ctf_func_args_by_id(fp, id, fi.ctc_argc, args) != 0)
256 268 goto out;
257 269
258 270 for (size_t i = 0; i < fi.ctc_argc; i++) {
259 271 char aname[512];
260 272
261 273 if (ctf_type_name(fp, args[i], aname, sizeof (aname)) == NULL)
262 274 (void) strlcpy(aname, "unknown_t", sizeof (aname));
263 275
264 276 ctf_decl_sprintf(cd, "%s%s", aname,
265 277 i + 1 == fi.ctc_argc ? "" : ", ");
266 278 }
267 279
268 280 if (fi.ctc_flags & CTF_FUNC_VARARG)
269 281 ctf_decl_sprintf(cd, "%s...", fi.ctc_argc == 0 ? "" : ", ");
270 282
271 283 out:
272 284 ctf_decl_sprintf(cd, ")");
273 285 }
274 286
275 287 /*
276 288 * Lookup the given type ID and print a string name for it into buf. Return the
277 289 * actual number of bytes (not including \0) needed to format the name.
278 290 *
279 291 * "vname" is an optional variable name or similar, so array suffix formatting,
280 292 * bitfields, and functions are C-correct. (This is not perfect, as can be seen
281 293 * in kiconv_ops_t.)
282 294 */
283 295 static ssize_t
284 296 ctf_type_qlname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len,
285 297 const char *vname, const char *qname)
286 298 {
287 299 int want_func_args = (vname != NULL);
288 300 ctf_decl_t cd;
289 301 ctf_decl_node_t *cdp;
290 302 ctf_decl_prec_t prec, lp, rp;
291 303 int ptr, arr;
292 304 uint_t k;
293 305
294 306 if (fp == NULL && type == CTF_ERR)
295 307 return (-1); /* simplify caller code by permitting CTF_ERR */
296 308
297 309 ctf_decl_init(&cd, buf, len);
298 310 ctf_decl_push(&cd, fp, type);
299 311
300 312 if (cd.cd_err != 0) {
301 313 ctf_decl_fini(&cd);
302 314 return (ctf_set_errno(fp, cd.cd_err));
303 315 }
304 316
305 317 /*
306 318 * If the type graph's order conflicts with lexical precedence order
307 319 * for pointers or arrays, then we need to surround the declarations at
308 320 * the corresponding lexical precedence with parentheses. This can
309 321 * result in either a parenthesized pointer (*) as in int (*)() or
310 322 * int (*)[], or in a parenthesized pointer and array as in int (*[])().
311 323 */
312 324 ptr = cd.cd_order[CTF_PREC_POINTER] > CTF_PREC_POINTER;
313 325 arr = cd.cd_order[CTF_PREC_ARRAY] > CTF_PREC_ARRAY;
314 326
315 327 rp = arr ? CTF_PREC_ARRAY : ptr ? CTF_PREC_POINTER : -1;
316 328 lp = ptr ? CTF_PREC_POINTER : arr ? CTF_PREC_ARRAY : -1;
317 329
318 330 k = CTF_K_POINTER; /* avoid leading whitespace (see below) */
319 331
320 332 for (prec = CTF_PREC_BASE; prec < CTF_PREC_MAX; prec++) {
321 333 for (cdp = ctf_list_next(&cd.cd_nodes[prec]);
322 334 cdp != NULL; cdp = ctf_list_next(cdp)) {
323 335
324 336 ctf_file_t *rfp = fp;
325 337 const ctf_type_t *tp =
326 338 ctf_lookup_by_id(&rfp, cdp->cd_type);
327 339 const char *name = ctf_strptr(rfp, tp->ctt_name);
328 340
329 341 if (k != CTF_K_POINTER && k != CTF_K_ARRAY)
330 342 ctf_decl_sprintf(&cd, " ");
331 343
332 344 if (lp == prec) {
333 345 ctf_decl_sprintf(&cd, "(");
334 346 lp = -1;
335 347 }
336 348
337 349 switch (cdp->cd_kind) {
338 350 case CTF_K_INTEGER:
339 351 vname = ctf_format_int(&cd, vname, qname, name);
340 352 break;
341 353 case CTF_K_FLOAT:
342 354 case CTF_K_TYPEDEF:
343 355 if (qname != NULL)
344 356 ctf_decl_sprintf(&cd, "%s`", qname);
345 357 ctf_decl_sprintf(&cd, "%s", name);
346 358 break;
347 359 case CTF_K_POINTER:
348 360 ctf_decl_sprintf(&cd, "*");
349 361 break;
350 362 case CTF_K_ARRAY:
351 363 ctf_decl_sprintf(&cd, "%s[%u]",
352 364 vname != NULL ? vname : "", cdp->cd_n);
353 365 vname = NULL;
354 366 break;
355 367 case CTF_K_FUNCTION:
356 368 ctf_format_func(fp, &cd, vname,
357 369 cdp->cd_type, want_func_args);
358 370 vname = NULL;
359 371 break;
360 372 case CTF_K_STRUCT:
361 373 case CTF_K_FORWARD:
362 374 ctf_decl_sprintf(&cd, "struct ");
363 375 if (qname != NULL)
364 376 ctf_decl_sprintf(&cd, "%s`", qname);
365 377 ctf_decl_sprintf(&cd, "%s", name);
366 378 break;
367 379 case CTF_K_UNION:
368 380 ctf_decl_sprintf(&cd, "union ");
369 381 if (qname != NULL)
370 382 ctf_decl_sprintf(&cd, "%s`", qname);
371 383 ctf_decl_sprintf(&cd, "%s", name);
372 384 break;
373 385 case CTF_K_ENUM:
374 386 ctf_decl_sprintf(&cd, "enum ");
375 387 if (qname != NULL)
376 388 ctf_decl_sprintf(&cd, "%s`", qname);
377 389 ctf_decl_sprintf(&cd, "%s", name);
378 390 break;
379 391 case CTF_K_VOLATILE:
380 392 ctf_decl_sprintf(&cd, "volatile");
381 393 break;
382 394 case CTF_K_CONST:
383 395 ctf_decl_sprintf(&cd, "const");
384 396 break;
385 397 case CTF_K_RESTRICT:
386 398 ctf_decl_sprintf(&cd, "restrict");
387 399 break;
388 400 }
389 401
390 402 k = cdp->cd_kind;
391 403 }
392 404
393 405 if (rp == prec) {
394 406 /*
395 407 * Peek ahead: if we're going to hit a function,
396 408 * we want to insert its name now before this closing
397 409 * bracket.
398 410 */
399 411 if (vname != NULL && prec < CTF_PREC_FUNCTION) {
400 412 cdp = ctf_list_next(
401 413 &cd.cd_nodes[CTF_PREC_FUNCTION]);
402 414
403 415 if (cdp != NULL) {
404 416 ctf_decl_sprintf(&cd, "%s", vname);
405 417 vname = NULL;
406 418 }
407 419 }
408 420
409 421 ctf_decl_sprintf(&cd, ")");
410 422 }
411 423 }
412 424
413 425 if (vname != NULL)
414 426 ctf_decl_sprintf(&cd, " %s", vname);
415 427
416 428 if (cd.cd_len >= len)
417 429 (void) ctf_set_errno(fp, ECTF_NAMELEN);
418 430
419 431 ctf_decl_fini(&cd);
420 432 return (cd.cd_len);
421 433 }
422 434
423 435 ssize_t
424 436 ctf_type_lname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
425 437 {
426 438 return (ctf_type_qlname(fp, type, buf, len, NULL, NULL));
427 439 }
428 440
429 441 /*
430 442 * Lookup the given type ID and print a string name for it into buf. If buf
431 443 * is too small, return NULL: the ECTF_NAMELEN error is set on 'fp' for us.
432 444 */
433 445 char *
434 446 ctf_type_name(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
435 447 {
436 448 ssize_t rv = ctf_type_qlname(fp, type, buf, len, NULL, NULL);
437 449 return (rv >= 0 && rv < len ? buf : NULL);
438 450 }
439 451
440 452 char *
441 453 ctf_type_qname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len,
442 454 const char *qname)
443 455 {
444 456 ssize_t rv = ctf_type_qlname(fp, type, buf, len, NULL, qname);
445 457 return (rv >= 0 && rv < len ? buf : NULL);
446 458 }
447 459
448 460 char *
449 461 ctf_type_cname(ctf_file_t *fp, ctf_id_t type, char *buf, size_t len,
450 462 const char *cname)
451 463 {
452 464 ssize_t rv = ctf_type_qlname(fp, type, buf, len, cname, NULL);
453 465 return (rv >= 0 && rv < len ? buf : NULL);
454 466 }
455 467
456 468 /*
457 469 * Resolve the type down to a base type node, and then return the size
458 470 * of the type storage in bytes.
459 471 */
460 472 ssize_t
461 473 ctf_type_size(ctf_file_t *fp, ctf_id_t type)
462 474 {
463 475 const ctf_type_t *tp;
464 476 ssize_t size;
465 477 ctf_arinfo_t ar;
466 478
467 479 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
468 480 return (-1); /* errno is set for us */
469 481
470 482 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
471 483 return (-1); /* errno is set for us */
472 484
473 485 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
474 486 case CTF_K_POINTER:
475 487 return (fp->ctf_dmodel->ctd_pointer);
476 488
477 489 case CTF_K_FUNCTION:
478 490 return (0); /* function size is only known by symtab */
479 491
480 492 case CTF_K_FORWARD:
481 493 return (0);
482 494
483 495 case CTF_K_ENUM:
484 496 return (ctf_get_ctt_size(fp, tp, NULL, NULL));
485 497
486 498 case CTF_K_ARRAY:
487 499 /*
488 500 * Array size is not directly returned by stabs data. Instead,
489 501 * it defines the element type and requires the user to perform
490 502 * the multiplication. If ctf_get_ctt_size() returns zero, the
491 503 * current version of ctfconvert does not compute member sizes
492 504 * and we compute the size here on its behalf.
493 505 */
494 506 if ((size = ctf_get_ctt_size(fp, tp, NULL, NULL)) > 0)
495 507 return (size);
496 508
497 509 if (ctf_array_info(fp, type, &ar) == CTF_ERR ||
498 510 (size = ctf_type_size(fp, ar.ctr_contents)) == CTF_ERR)
499 511 return (-1); /* errno is set for us */
500 512
501 513 return (size * ar.ctr_nelems);
502 514 case CTF_K_STRUCT:
503 515 case CTF_K_UNION:
504 516 /*
505 517 * If we have a zero size, we may be in the process of adding a
506 518 * structure or union but having not called ctf_update() to deal
507 519 * with the circular dependencies in such structures and unions.
508 520 * To handle that case, if we get a size of zero from the ctt,
509 521 * we look up the dtdef and use its size instead.
510 522 */
511 523 size = ctf_get_ctt_size(fp, tp, NULL, NULL);
512 524 if (size == 0) {
513 525 ctf_dtdef_t *dtd = ctf_dtd_lookup(fp, type);
514 526 if (dtd != NULL)
515 527 return (dtd->dtd_data.ctt_size);
516 528 }
517 529 return (size);
518 530 default:
519 531 return (ctf_get_ctt_size(fp, tp, NULL, NULL));
520 532 }
521 533 }
522 534
523 535 /*
524 536 * Resolve the type down to a base type node, and then return the alignment
525 537 * needed for the type storage in bytes.
526 538 */
527 539 ssize_t
528 540 ctf_type_align(ctf_file_t *fp, ctf_id_t type)
529 541 {
530 542 const ctf_type_t *tp;
531 543 ctf_arinfo_t r;
532 544
533 545 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
534 546 return (-1); /* errno is set for us */
535 547
536 548 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
537 549 return (-1); /* errno is set for us */
538 550
539 551 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
540 552 case CTF_K_POINTER:
541 553 case CTF_K_FUNCTION:
542 554 return (fp->ctf_dmodel->ctd_pointer);
543 555
544 556 case CTF_K_ARRAY:
545 557 if (ctf_array_info(fp, type, &r) == CTF_ERR)
546 558 return (-1); /* errno is set for us */
547 559 return (ctf_type_align(fp, r.ctr_contents));
548 560
549 561 case CTF_K_STRUCT:
550 562 case CTF_K_UNION: {
551 563 uint_t n = LCTF_INFO_VLEN(fp, tp->ctt_info);
552 564 ssize_t size, increment;
553 565 size_t align = 0;
554 566 const void *vmp;
555 567
556 568 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
557 569 vmp = (uchar_t *)tp + increment;
558 570
559 571 if (LCTF_INFO_KIND(fp, tp->ctt_info) == CTF_K_STRUCT)
560 572 n = MIN(n, 1); /* only use first member for structs */
561 573
562 574 if (fp->ctf_version == CTF_VERSION_1 ||
563 575 size < CTF_LSTRUCT_THRESH) {
564 576 const ctf_member_t *mp = vmp;
565 577 for (; n != 0; n--, mp++) {
566 578 ssize_t am = ctf_type_align(fp, mp->ctm_type);
567 579 align = MAX(align, am);
568 580 }
569 581 } else {
570 582 const ctf_lmember_t *lmp = vmp;
571 583 for (; n != 0; n--, lmp++) {
572 584 ssize_t am = ctf_type_align(fp, lmp->ctlm_type);
573 585 align = MAX(align, am);
574 586 }
575 587 }
576 588
577 589 return (align);
578 590 }
579 591
580 592 case CTF_K_ENUM:
581 593 default:
582 594 return (ctf_get_ctt_size(fp, tp, NULL, NULL));
583 595 }
584 596 }
585 597
586 598 /*
587 599 * Return the kind (CTF_K_* constant) for the specified type ID.
588 600 */
589 601 int
590 602 ctf_type_kind(ctf_file_t *fp, ctf_id_t type)
591 603 {
592 604 const ctf_type_t *tp;
593 605
594 606 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
595 607 return (CTF_ERR); /* errno is set for us */
596 608
597 609 return (LCTF_INFO_KIND(fp, tp->ctt_info));
598 610 }
599 611
600 612 /*
601 613 * If the type is one that directly references another type (such as POINTER),
602 614 * then return the ID of the type to which it refers.
603 615 */
604 616 ctf_id_t
605 617 ctf_type_reference(ctf_file_t *fp, ctf_id_t type)
606 618 {
607 619 ctf_file_t *ofp = fp;
608 620 const ctf_type_t *tp;
609 621
610 622 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
611 623 return (CTF_ERR); /* errno is set for us */
612 624
613 625 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
614 626 case CTF_K_POINTER:
615 627 case CTF_K_TYPEDEF:
616 628 case CTF_K_VOLATILE:
617 629 case CTF_K_CONST:
618 630 case CTF_K_RESTRICT:
619 631 return (tp->ctt_type);
620 632 default:
621 633 return (ctf_set_errno(ofp, ECTF_NOTREF));
622 634 }
623 635 }
624 636
625 637 /*
626 638 * Find a pointer to type by looking in fp->ctf_ptrtab. If we can't find a
627 639 * pointer to the given type, see if we can compute a pointer to the type
628 640 * resulting from resolving the type down to its base type and use that
629 641 * instead. This helps with cases where the CTF data includes "struct foo *"
630 642 * but not "foo_t *" and the user accesses "foo_t *" in the debugger.
631 643 */
632 644 ctf_id_t
633 645 ctf_type_pointer(ctf_file_t *fp, ctf_id_t type)
634 646 {
635 647 ctf_file_t *ofp = fp;
636 648 ctf_id_t ntype;
637 649
638 650 if (ctf_lookup_by_id(&fp, type) == NULL)
639 651 return (CTF_ERR); /* errno is set for us */
640 652
641 653 if ((ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)]) != 0)
642 654 return (CTF_INDEX_TO_TYPE(ntype, (fp->ctf_flags & LCTF_CHILD)));
643 655
644 656 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
645 657 return (ctf_set_errno(ofp, ECTF_NOTYPE));
646 658
647 659 if (ctf_lookup_by_id(&fp, type) == NULL)
648 660 return (ctf_set_errno(ofp, ECTF_NOTYPE));
649 661
650 662 if ((ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)]) != 0)
651 663 return (CTF_INDEX_TO_TYPE(ntype, (fp->ctf_flags & LCTF_CHILD)));
652 664
653 665 return (ctf_set_errno(ofp, ECTF_NOTYPE));
654 666 }
655 667
656 668 /*
657 669 * Return the encoding for the specified INTEGER or FLOAT.
658 670 */
659 671 int
660 672 ctf_type_encoding(ctf_file_t *fp, ctf_id_t type, ctf_encoding_t *ep)
661 673 {
662 674 ctf_file_t *ofp = fp;
663 675 const ctf_type_t *tp;
664 676 ssize_t increment;
665 677 uint_t data;
666 678
667 679 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
668 680 return (CTF_ERR); /* errno is set for us */
669 681
670 682 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
671 683
672 684 switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
673 685 case CTF_K_INTEGER:
674 686 data = *(const uint_t *)((uintptr_t)tp + increment);
675 687 ep->cte_format = CTF_INT_ENCODING(data);
676 688 ep->cte_offset = CTF_INT_OFFSET(data);
677 689 ep->cte_bits = CTF_INT_BITS(data);
678 690 break;
679 691 case CTF_K_FLOAT:
680 692 data = *(const uint_t *)((uintptr_t)tp + increment);
681 693 ep->cte_format = CTF_FP_ENCODING(data);
682 694 ep->cte_offset = CTF_FP_OFFSET(data);
683 695 ep->cte_bits = CTF_FP_BITS(data);
684 696 break;
685 697 default:
686 698 return (ctf_set_errno(ofp, ECTF_NOTINTFP));
687 699 }
688 700
689 701 return (0);
690 702 }
691 703
692 704 int
693 705 ctf_type_cmp(ctf_file_t *lfp, ctf_id_t ltype, ctf_file_t *rfp, ctf_id_t rtype)
694 706 {
695 707 int rval;
696 708
697 709 if (ltype < rtype)
698 710 rval = -1;
699 711 else if (ltype > rtype)
700 712 rval = 1;
701 713 else
702 714 rval = 0;
703 715
704 716 if (lfp == rfp)
705 717 return (rval);
706 718
707 719 if (CTF_TYPE_ISPARENT(ltype) && lfp->ctf_parent != NULL)
708 720 lfp = lfp->ctf_parent;
709 721
710 722 if (CTF_TYPE_ISPARENT(rtype) && rfp->ctf_parent != NULL)
711 723 rfp = rfp->ctf_parent;
712 724
713 725 if (lfp < rfp)
714 726 return (-1);
715 727
716 728 if (lfp > rfp)
717 729 return (1);
718 730
719 731 return (rval);
720 732 }
721 733
722 734 /*
723 735 * Return a boolean value indicating if two types are compatible integers or
724 736 * floating-pointer values. This function returns true if the two types are
725 737 * the same, or if they have the same ASCII name and encoding properties.
726 738 * This function could be extended to test for compatibility for other kinds.
727 739 */
728 740 int
729 741 ctf_type_compat(ctf_file_t *lfp, ctf_id_t ltype,
730 742 ctf_file_t *rfp, ctf_id_t rtype)
731 743 {
732 744 const ctf_type_t *ltp, *rtp;
733 745 ctf_encoding_t le, re;
734 746 ctf_arinfo_t la, ra;
735 747 uint_t lkind, rkind;
736 748
737 749 if (ctf_type_cmp(lfp, ltype, rfp, rtype) == 0)
738 750 return (1);
739 751
740 752 ltype = ctf_type_resolve(lfp, ltype);
741 753 lkind = ctf_type_kind(lfp, ltype);
742 754
743 755 rtype = ctf_type_resolve(rfp, rtype);
744 756 rkind = ctf_type_kind(rfp, rtype);
745 757
746 758 if (lkind != rkind ||
747 759 (ltp = ctf_lookup_by_id(&lfp, ltype)) == NULL ||
748 760 (rtp = ctf_lookup_by_id(&rfp, rtype)) == NULL ||
749 761 strcmp(ctf_strptr(lfp, ltp->ctt_name),
750 762 ctf_strptr(rfp, rtp->ctt_name)) != 0)
751 763 return (0);
752 764
753 765 switch (lkind) {
754 766 case CTF_K_INTEGER:
755 767 case CTF_K_FLOAT:
756 768 return (ctf_type_encoding(lfp, ltype, &le) == 0 &&
757 769 ctf_type_encoding(rfp, rtype, &re) == 0 &&
758 770 bcmp(&le, &re, sizeof (ctf_encoding_t)) == 0);
759 771 case CTF_K_POINTER:
760 772 return (ctf_type_compat(lfp, ctf_type_reference(lfp, ltype),
761 773 rfp, ctf_type_reference(rfp, rtype)));
762 774 case CTF_K_ARRAY:
763 775 return (ctf_array_info(lfp, ltype, &la) == 0 &&
764 776 ctf_array_info(rfp, rtype, &ra) == 0 &&
765 777 la.ctr_nelems == ra.ctr_nelems && ctf_type_compat(
766 778 lfp, la.ctr_contents, rfp, ra.ctr_contents) &&
767 779 ctf_type_compat(lfp, la.ctr_index, rfp, ra.ctr_index));
768 780 case CTF_K_STRUCT:
769 781 case CTF_K_UNION:
770 782 return (ctf_type_size(lfp, ltype) == ctf_type_size(rfp, rtype));
771 783 case CTF_K_ENUM:
772 784 case CTF_K_FORWARD:
773 785 return (1); /* no other checks required for these type kinds */
774 786 default:
775 787 return (0); /* should not get here since we did a resolve */
776 788 }
777 789 }
778 790
779 791 /*
780 792 * Return the type and offset for a given member of a STRUCT or UNION.
781 793 */
782 794 int
783 795 ctf_member_info(ctf_file_t *fp, ctf_id_t type, const char *name,
784 796 ctf_membinfo_t *mip)
785 797 {
786 798 ctf_file_t *ofp = fp;
787 799 const ctf_type_t *tp;
788 800 ssize_t size, increment;
789 801 uint_t kind, n;
790 802
791 803 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
792 804 return (CTF_ERR); /* errno is set for us */
793 805
794 806 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
795 807 return (CTF_ERR); /* errno is set for us */
796 808
797 809 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
798 810 kind = LCTF_INFO_KIND(fp, tp->ctt_info);
799 811
800 812 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
801 813 return (ctf_set_errno(ofp, ECTF_NOTSOU));
802 814
803 815 if (fp->ctf_version == CTF_VERSION_1 || size < CTF_LSTRUCT_THRESH) {
804 816 const ctf_member_t *mp = (const ctf_member_t *)
805 817 ((uintptr_t)tp + increment);
806 818
807 819 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, mp++) {
808 820 if (strcmp(ctf_strptr(fp, mp->ctm_name), name) == 0) {
809 821 mip->ctm_type = mp->ctm_type;
810 822 mip->ctm_offset = mp->ctm_offset;
811 823 return (0);
812 824 }
813 825 }
814 826 } else {
815 827 const ctf_lmember_t *lmp = (const ctf_lmember_t *)
816 828 ((uintptr_t)tp + increment);
817 829
818 830 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, lmp++) {
819 831 if (strcmp(ctf_strptr(fp, lmp->ctlm_name), name) == 0) {
820 832 mip->ctm_type = lmp->ctlm_type;
821 833 mip->ctm_offset = (ulong_t)CTF_LMEM_OFFSET(lmp);
822 834 return (0);
823 835 }
824 836 }
825 837 }
826 838
827 839 return (ctf_set_errno(ofp, ECTF_NOMEMBNAM));
828 840 }
829 841
830 842 /*
831 843 * Return the array type, index, and size information for the specified ARRAY.
832 844 */
833 845 int
834 846 ctf_array_info(ctf_file_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
835 847 {
836 848 ctf_file_t *ofp = fp;
837 849 const ctf_type_t *tp;
838 850 const ctf_array_t *ap;
839 851 ssize_t increment;
840 852
841 853 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
842 854 return (CTF_ERR); /* errno is set for us */
843 855
844 856 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ARRAY)
845 857 return (ctf_set_errno(ofp, ECTF_NOTARRAY));
846 858
847 859 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
848 860
849 861 ap = (const ctf_array_t *)((uintptr_t)tp + increment);
850 862 arp->ctr_contents = ap->cta_contents;
851 863 arp->ctr_index = ap->cta_index;
852 864 arp->ctr_nelems = ap->cta_nelems;
853 865
854 866 return (0);
855 867 }
856 868
857 869 /*
858 870 * Convert the specified value to the corresponding enum member name, if a
859 871 * matching name can be found. Otherwise NULL is returned.
860 872 */
861 873 const char *
862 874 ctf_enum_name(ctf_file_t *fp, ctf_id_t type, int value)
863 875 {
864 876 ctf_file_t *ofp = fp;
865 877 const ctf_type_t *tp;
866 878 const ctf_enum_t *ep;
867 879 ssize_t increment;
868 880 uint_t n;
869 881
870 882 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
871 883 return (NULL); /* errno is set for us */
872 884
873 885 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
874 886 return (NULL); /* errno is set for us */
875 887
876 888 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ENUM) {
877 889 (void) ctf_set_errno(ofp, ECTF_NOTENUM);
878 890 return (NULL);
879 891 }
880 892
881 893 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
882 894
883 895 ep = (const ctf_enum_t *)((uintptr_t)tp + increment);
884 896
885 897 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, ep++) {
886 898 if (ep->cte_value == value)
887 899 return (ctf_strptr(fp, ep->cte_name));
888 900 }
889 901
890 902 (void) ctf_set_errno(ofp, ECTF_NOENUMNAM);
891 903 return (NULL);
892 904 }
893 905
894 906 /*
895 907 * Convert the specified enum tag name to the corresponding value, if a
896 908 * matching name can be found. Otherwise CTF_ERR is returned.
897 909 */
898 910 int
899 911 ctf_enum_value(ctf_file_t *fp, ctf_id_t type, const char *name, int *valp)
900 912 {
901 913 ctf_file_t *ofp = fp;
902 914 const ctf_type_t *tp;
903 915 const ctf_enum_t *ep;
904 916 ssize_t size, increment;
905 917 uint_t n;
906 918
907 919 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
908 920 return (CTF_ERR); /* errno is set for us */
909 921
910 922 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
911 923 return (CTF_ERR); /* errno is set for us */
912 924
913 925 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_ENUM) {
914 926 (void) ctf_set_errno(ofp, ECTF_NOTENUM);
915 927 return (CTF_ERR);
916 928 }
917 929
918 930 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
919 931
920 932 ep = (const ctf_enum_t *)((uintptr_t)tp + increment);
921 933
922 934 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, ep++) {
923 935 if (strcmp(ctf_strptr(fp, ep->cte_name), name) == 0) {
924 936 if (valp != NULL)
925 937 *valp = ep->cte_value;
926 938 return (0);
927 939 }
928 940 }
929 941
930 942 (void) ctf_set_errno(ofp, ECTF_NOENUMNAM);
931 943 return (CTF_ERR);
932 944 }
933 945
934 946 /*
935 947 * Recursively visit the members of any type. This function is used as the
936 948 * engine for ctf_type_visit, below. We resolve the input type, recursively
937 949 * invoke ourself for each type member if the type is a struct or union, and
938 950 * then invoke the callback function on the current type. If any callback
939 951 * returns non-zero, we abort and percolate the error code back up to the top.
940 952 */
941 953 static int
942 954 ctf_type_rvisit(ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg,
943 955 const char *name, ulong_t offset, int depth)
944 956 {
945 957 ctf_id_t otype = type;
946 958 const ctf_type_t *tp;
947 959 ssize_t size, increment;
948 960 uint_t kind, n;
949 961 int rc;
950 962
951 963 if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
952 964 return (CTF_ERR); /* errno is set for us */
953 965
954 966 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
955 967 return (CTF_ERR); /* errno is set for us */
956 968
957 969 if ((rc = func(name, otype, offset, depth, arg)) != 0)
958 970 return (rc);
959 971
960 972 kind = LCTF_INFO_KIND(fp, tp->ctt_info);
961 973
962 974 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
963 975 return (0);
964 976
965 977 (void) ctf_get_ctt_size(fp, tp, &size, &increment);
966 978
967 979 if (fp->ctf_version == CTF_VERSION_1 || size < CTF_LSTRUCT_THRESH) {
968 980 const ctf_member_t *mp = (const ctf_member_t *)
969 981 ((uintptr_t)tp + increment);
970 982
971 983 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, mp++) {
972 984 if ((rc = ctf_type_rvisit(fp, mp->ctm_type,
973 985 func, arg, ctf_strptr(fp, mp->ctm_name),
974 986 offset + mp->ctm_offset, depth + 1)) != 0)
975 987 return (rc);
976 988 }
977 989
978 990 } else {
979 991 const ctf_lmember_t *lmp = (const ctf_lmember_t *)
980 992 ((uintptr_t)tp + increment);
981 993
982 994 for (n = LCTF_INFO_VLEN(fp, tp->ctt_info); n != 0; n--, lmp++) {
983 995 if ((rc = ctf_type_rvisit(fp, lmp->ctlm_type,
984 996 func, arg, ctf_strptr(fp, lmp->ctlm_name),
985 997 offset + (ulong_t)CTF_LMEM_OFFSET(lmp),
986 998 depth + 1)) != 0)
987 999 return (rc);
988 1000 }
989 1001 }
990 1002
991 1003 return (0);
992 1004 }
993 1005
994 1006 /*
995 1007 * Recursively visit the members of any type. We pass the name, member
996 1008 * type, and offset of each member to the specified callback function.
997 1009 */
998 1010 int
999 1011 ctf_type_visit(ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg)
1000 1012 {
1001 1013 return (ctf_type_rvisit(fp, type, func, arg, "", 0, 0));
1002 1014 }
1003 1015
1004 1016 int
1005 1017 ctf_func_info_by_id(ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
1006 1018 {
1007 1019 ctf_file_t *ofp = fp;
1008 1020 const ctf_type_t *tp;
1009 1021 const ushort_t *dp;
1010 1022 int nargs;
1011 1023 ssize_t increment;
1012 1024
1013 1025 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
1014 1026 return (CTF_ERR); /* errno is set for us */
1015 1027
1016 1028 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_FUNCTION)
1017 1029 return (ctf_set_errno(ofp, ECTF_NOTFUNC));
1018 1030
1019 1031 fip->ctc_return = tp->ctt_type;
1020 1032 nargs = LCTF_INFO_VLEN(fp, tp->ctt_info);
1021 1033 fip->ctc_argc = nargs;
1022 1034 fip->ctc_flags = 0;
1023 1035
1024 1036 /* dp should now point to the first argument */
1025 1037 if (nargs != 0) {
1026 1038 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
1027 1039 dp = (ushort_t *)((uintptr_t)fp->ctf_buf +
1028 1040 fp->ctf_txlate[CTF_TYPE_TO_INDEX(type)] + increment);
1029 1041 if (dp[nargs - 1] == 0) {
1030 1042 fip->ctc_flags |= CTF_FUNC_VARARG;
1031 1043 fip->ctc_argc--;
1032 1044 }
1033 1045 }
1034 1046
1035 1047 return (0);
1036 1048 }
1037 1049
1038 1050 int
1039 1051 ctf_func_args_by_id(ctf_file_t *fp, ctf_id_t type, uint_t argc, ctf_id_t *argv)
1040 1052 {
1041 1053 ctf_file_t *ofp = fp;
1042 1054 const ctf_type_t *tp;
1043 1055 const ushort_t *dp;
1044 1056 int nargs;
1045 1057 ssize_t increment;
1046 1058
1047 1059 if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
1048 1060 return (CTF_ERR); /* errno is set for us */
1049 1061
1050 1062 if (LCTF_INFO_KIND(fp, tp->ctt_info) != CTF_K_FUNCTION)
1051 1063 return (ctf_set_errno(ofp, ECTF_NOTFUNC));
1052 1064
1053 1065 nargs = LCTF_INFO_VLEN(fp, tp->ctt_info);
1054 1066 (void) ctf_get_ctt_size(fp, tp, NULL, &increment);
1055 1067 dp = (ushort_t *)((uintptr_t)fp->ctf_buf +
1056 1068 fp->ctf_txlate[CTF_TYPE_TO_INDEX(type)] +
1057 1069 increment);
1058 1070 if (nargs != 0 && dp[nargs - 1] == 0)
1059 1071 nargs--;
1060 1072
1061 1073 for (nargs = MIN(argc, nargs); nargs != 0; nargs--)
1062 1074 *argv++ = *dp++;
1063 1075
1064 1076 return (0);
1065 1077 }
1066 1078
1067 1079 int
1068 1080 ctf_object_iter(ctf_file_t *fp, ctf_object_f *func, void *arg)
1069 1081 {
1070 1082 int i, ret;
1071 1083 ctf_id_t id;
1072 1084 uintptr_t symbase = (uintptr_t)fp->ctf_symtab.cts_data;
1073 1085 uintptr_t strbase = (uintptr_t)fp->ctf_strtab.cts_data;
1074 1086
1075 1087 if (fp->ctf_symtab.cts_data == NULL)
1076 1088 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
1077 1089
1078 1090 for (i = 0; i < fp->ctf_nsyms; i++) {
1079 1091 char *name;
1080 1092 if (fp->ctf_sxlate[i] == -1u)
1081 1093 continue;
1082 1094 id = *(ushort_t *)((uintptr_t)fp->ctf_buf +
1083 1095 fp->ctf_sxlate[i]);
1084 1096
1085 1097 /*
1086 1098 * Validate whether or not we're looking at a data object as
1087 1099 * oposed to a function.
1088 1100 */
1089 1101 if (fp->ctf_symtab.cts_entsize == sizeof (Elf32_Sym)) {
1090 1102 const Elf32_Sym *symp = (Elf32_Sym *)symbase + i;
1091 1103 if (ELF32_ST_TYPE(symp->st_info) != STT_OBJECT)
1092 1104 continue;
1093 1105 if (fp->ctf_strtab.cts_data != NULL &&
1094 1106 symp->st_name != 0)
1095 1107 name = (char *)(strbase + symp->st_name);
1096 1108 else
1097 1109 name = NULL;
1098 1110 } else {
1099 1111 const Elf64_Sym *symp = (Elf64_Sym *)symbase + i;
1100 1112 if (ELF64_ST_TYPE(symp->st_info) != STT_OBJECT)
1101 1113 continue;
1102 1114 if (fp->ctf_strtab.cts_data != NULL &&
1103 1115 symp->st_name != 0)
1104 1116 name = (char *)(strbase + symp->st_name);
1105 1117 else
1106 1118 name = NULL;
1107 1119 }
1108 1120
1109 1121 if ((ret = func(name, id, i, arg)) != 0)
1110 1122 return (ret);
1111 1123 }
1112 1124
1113 1125 return (0);
1114 1126 }
1115 1127
1116 1128 int
1117 1129 ctf_function_iter(ctf_file_t *fp, ctf_function_f *func, void *arg)
1118 1130 {
1119 1131 int i, ret;
1120 1132 uintptr_t symbase = (uintptr_t)fp->ctf_symtab.cts_data;
1121 1133 uintptr_t strbase = (uintptr_t)fp->ctf_strtab.cts_data;
1122 1134
1123 1135 if (fp->ctf_symtab.cts_data == NULL)
1124 1136 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
1125 1137
1126 1138 for (i = 0; i < fp->ctf_nsyms; i++) {
1127 1139 char *name;
1128 1140 ushort_t info, *dp;
1129 1141 ctf_funcinfo_t fi;
1130 1142 if (fp->ctf_sxlate[i] == -1u)
1131 1143 continue;
1132 1144
1133 1145 dp = (ushort_t *)((uintptr_t)fp->ctf_buf +
1134 1146 fp->ctf_sxlate[i]);
1135 1147 info = *dp;
1136 1148 if (info == 0)
1137 1149 continue;
1138 1150
1139 1151 /*
1140 1152 * This may be a function or it may be a data object. We have to
1141 1153 * consult the symbol table to be certain. Functions are encoded
1142 1154 * with their info, data objects with their actual type.
1143 1155 */
1144 1156 if (fp->ctf_symtab.cts_entsize == sizeof (Elf32_Sym)) {
1145 1157 const Elf32_Sym *symp = (Elf32_Sym *)symbase + i;
1146 1158 if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC)
1147 1159 continue;
1148 1160 if (fp->ctf_strtab.cts_data != NULL)
1149 1161 name = (char *)(strbase + symp->st_name);
1150 1162 else
1151 1163 name = NULL;
1152 1164 } else {
1153 1165 const Elf64_Sym *symp = (Elf64_Sym *)symbase + i;
1154 1166 if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC)
1155 1167 continue;
1156 1168 if (fp->ctf_strtab.cts_data != NULL)
1157 1169 name = (char *)(strbase + symp->st_name);
1158 1170 else
1159 1171 name = NULL;
1160 1172 }
1161 1173
1162 1174 if (LCTF_INFO_KIND(fp, info) != CTF_K_FUNCTION)
1163 1175 continue;
1164 1176 dp++;
1165 1177 fi.ctc_return = *dp;
1166 1178 dp++;
1167 1179 fi.ctc_argc = LCTF_INFO_VLEN(fp, info);
1168 1180 fi.ctc_flags = 0;
1169 1181
1170 1182 if (fi.ctc_argc != 0 && dp[fi.ctc_argc - 1] == 0) {
1171 1183 fi.ctc_flags |= CTF_FUNC_VARARG;
1172 1184 fi.ctc_argc--;
1173 1185 }
1174 1186
1175 1187 if ((ret = func(name, i, &fi, arg)) != 0)
1176 1188 return (ret);
1177 1189
1178 1190 }
1179 1191
1180 1192 return (0);
1181 1193 }
1182 1194
1183 1195 char *
1184 1196 ctf_symbol_name(ctf_file_t *fp, ulong_t idx, char *buf, size_t len)
1185 1197 {
1186 1198 const char *name;
1187 1199 uintptr_t symbase = (uintptr_t)fp->ctf_symtab.cts_data;
1188 1200 uintptr_t strbase = (uintptr_t)fp->ctf_strtab.cts_data;
1189 1201
1190 1202 if (fp->ctf_symtab.cts_data == NULL) {
1191 1203 (void) ctf_set_errno(fp, ECTF_NOSYMTAB);
1192 1204 return (NULL);
1193 1205 }
1194 1206
1195 1207 if (fp->ctf_strtab.cts_data == NULL) {
1196 1208 (void) ctf_set_errno(fp, ECTF_STRTAB);
1197 1209 return (NULL);
1198 1210 }
1199 1211
1200 1212 if (idx > fp->ctf_nsyms) {
1201 1213 (void) ctf_set_errno(fp, ECTF_NOTDATA);
1202 1214 return (NULL);
1203 1215 }
1204 1216
1205 1217 if (fp->ctf_symtab.cts_entsize == sizeof (Elf32_Sym)) {
1206 1218 const Elf32_Sym *symp = (Elf32_Sym *)symbase + idx;
1207 1219 if (ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
1208 1220 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) {
1209 1221 (void) ctf_set_errno(fp, ECTF_NOTDATA);
1210 1222 return (NULL);
1211 1223 }
1212 1224 if (symp->st_name == 0) {
1213 1225 (void) ctf_set_errno(fp, ENOENT);
1214 1226 return (NULL);
1215 1227 }
1216 1228 name = (const char *)(strbase + symp->st_name);
1217 1229 } else {
1218 1230 const Elf64_Sym *symp = (Elf64_Sym *)symbase + idx;
1219 1231 if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC &&
1220 1232 ELF64_ST_TYPE(symp->st_info) != STT_OBJECT) {
1221 1233 (void) ctf_set_errno(fp, ECTF_NOTDATA);
1222 1234 return (NULL);
1223 1235 }
1224 1236 if (symp->st_name == 0) {
1225 1237 (void) ctf_set_errno(fp, ENOENT);
1226 1238 return (NULL);
1227 1239 }
1228 1240 name = (const char *)(strbase + symp->st_name);
1229 1241 }
1230 1242
1231 1243 (void) strlcpy(buf, name, len);
1232 1244
1233 1245 return (buf);
1234 1246 }
1235 1247
1236 1248 int
1237 1249 ctf_string_iter(ctf_file_t *fp, ctf_string_f *func, void *arg)
1238 1250 {
1239 1251 int rc;
1240 1252 const char *strp = fp->ctf_str[CTF_STRTAB_0].cts_strs;
1241 1253 size_t strl = fp->ctf_str[CTF_STRTAB_0].cts_len;
1242 1254
1243 1255 while (strl > 0) {
1244 1256 size_t len;
1245 1257
1246 1258 if ((rc = func(strp, arg)) != 0)
1247 1259 return (rc);
1248 1260
1249 1261 len = strlen(strp) + 1;
1250 1262 strl -= len;
1251 1263 strp += len;
1252 1264 }
1253 1265
1254 1266 return (0);
1255 1267 }
1256 1268
1257 1269 /*
1258 1270 * fp isn't strictly necessary at the moment. However, if we ever rev the file
1259 1271 * format, the valid values for kind will change.
1260 1272 */
1261 1273 const char *
1262 1274 ctf_kind_name(ctf_file_t *fp, int kind)
1263 1275 {
1264 1276 switch (kind) {
1265 1277 case CTF_K_INTEGER:
1266 1278 return ("integer");
1267 1279 case CTF_K_FLOAT:
1268 1280 return ("float");
1269 1281 case CTF_K_POINTER:
1270 1282 return ("pointer");
1271 1283 case CTF_K_ARRAY:
1272 1284 return ("array");
1273 1285 case CTF_K_FUNCTION:
1274 1286 return ("function");
1275 1287 case CTF_K_STRUCT:
1276 1288 return ("struct");
1277 1289 case CTF_K_UNION:
1278 1290 return ("union");
1279 1291 case CTF_K_ENUM:
1280 1292 return ("enum");
1281 1293 case CTF_K_FORWARD:
1282 1294 return ("forward");
1283 1295 case CTF_K_TYPEDEF:
1284 1296 return ("typedef");
1285 1297 case CTF_K_VOLATILE:
1286 1298 return ("volatile");
1287 1299 case CTF_K_CONST:
1288 1300 return ("const");
1289 1301 case CTF_K_RESTRICT:
1290 1302 return ("restrict");
1291 1303 case CTF_K_UNKNOWN:
1292 1304 default:
1293 1305 return ("unknown");
1294 1306 }
1295 1307 }
1296 1308
1297 1309 ctf_id_t
1298 1310 ctf_max_id(ctf_file_t *fp)
1299 1311 {
1300 1312 int child = (fp->ctf_flags & LCTF_CHILD);
1301 1313 return (fp->ctf_typemax + (child ? CTF_CHILD_START : 0));
1302 1314 }
1303 1315
1304 1316 ulong_t
1305 1317 ctf_nr_syms(ctf_file_t *fp)
1306 1318 {
1307 1319 return (fp->ctf_nsyms);
1308 1320 }
|
↓ open down ↓ |
1242 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX