1 /* Opening CTF files.
2 Copyright (C) 2019-2023 Free Software Foundation, Inc.
3
4 This file is part of libctf.
5
6 libctf is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #include <ctf-impl.h>
21 #include <stddef.h>
22 #include <string.h>
23 #include <sys/types.h>
24 #include <elf.h>
25 #include "swap.h"
26 #include <bfd.h>
27 #include <zlib.h>
28
29 static const ctf_dmodel_t _libctf_models[] = {
30 {"ILP32", CTF_MODEL_ILP32, 4, 1, 2, 4, 4},
31 {"LP64", CTF_MODEL_LP64, 8, 1, 2, 4, 8},
32 {NULL, 0, 0, 0, 0, 0, 0}
33 };
34
35 const char _CTF_SECTION[] = ".ctf";
36 const char _CTF_NULLSTR[] = "";
37
38 /* Version-sensitive accessors. */
39
40 static uint32_t
41 get_kind_v1 (uint32_t info)
42 {
43 return (CTF_V1_INFO_KIND (info));
44 }
45
46 static uint32_t
47 get_root_v1 (uint32_t info)
48 {
49 return (CTF_V1_INFO_ISROOT (info));
50 }
51
52 static uint32_t
53 get_vlen_v1 (uint32_t info)
54 {
55 return (CTF_V1_INFO_VLEN (info));
56 }
57
58 static uint32_t
59 get_kind_v2 (uint32_t info)
60 {
61 return (CTF_V2_INFO_KIND (info));
62 }
63
64 static uint32_t
65 get_root_v2 (uint32_t info)
66 {
67 return (CTF_V2_INFO_ISROOT (info));
68 }
69
70 static uint32_t
71 get_vlen_v2 (uint32_t info)
72 {
73 return (CTF_V2_INFO_VLEN (info));
74 }
75
76 static inline ssize_t
77 get_ctt_size_common (const ctf_dict_t *fp _libctf_unused_,
78 const ctf_type_t *tp _libctf_unused_,
79 ssize_t *sizep, ssize_t *incrementp, size_t lsize,
80 size_t csize, size_t ctf_type_size,
81 size_t ctf_stype_size, size_t ctf_lsize_sent)
82 {
83 ssize_t size, increment;
84
85 if (csize == ctf_lsize_sent)
86 {
87 size = lsize;
88 increment = ctf_type_size;
89 }
90 else
91 {
92 size = csize;
93 increment = ctf_stype_size;
94 }
95
96 if (sizep)
97 *sizep = size;
98 if (incrementp)
99 *incrementp = increment;
100
101 return size;
102 }
103
104 static ssize_t
105 get_ctt_size_v1 (const ctf_dict_t *fp, const ctf_type_t *tp,
106 ssize_t *sizep, ssize_t *incrementp)
107 {
108 ctf_type_v1_t *t1p = (ctf_type_v1_t *) tp;
109
110 return (get_ctt_size_common (fp, tp, sizep, incrementp,
111 CTF_TYPE_LSIZE (t1p), t1p->ctt_size,
112 sizeof (ctf_type_v1_t), sizeof (ctf_stype_v1_t),
113 CTF_LSIZE_SENT_V1));
114 }
115
116 /* Return the size that a v1 will be once it is converted to v2. */
117
118 static ssize_t
119 get_ctt_size_v2_unconverted (const ctf_dict_t *fp, const ctf_type_t *tp,
120 ssize_t *sizep, ssize_t *incrementp)
121 {
122 ctf_type_v1_t *t1p = (ctf_type_v1_t *) tp;
123
124 return (get_ctt_size_common (fp, tp, sizep, incrementp,
125 CTF_TYPE_LSIZE (t1p), t1p->ctt_size,
126 sizeof (ctf_type_t), sizeof (ctf_stype_t),
127 CTF_LSIZE_SENT));
128 }
129
130 static ssize_t
131 get_ctt_size_v2 (const ctf_dict_t *fp, const ctf_type_t *tp,
132 ssize_t *sizep, ssize_t *incrementp)
133 {
134 return (get_ctt_size_common (fp, tp, sizep, incrementp,
135 CTF_TYPE_LSIZE (tp), tp->ctt_size,
136 sizeof (ctf_type_t), sizeof (ctf_stype_t),
137 CTF_LSIZE_SENT));
138 }
139
140 static ssize_t
141 get_vbytes_common (ctf_dict_t *fp, unsigned short kind,
142 ssize_t size _libctf_unused_, size_t vlen)
143 {
144 switch (kind)
145 {
146 case CTF_K_INTEGER:
147 case CTF_K_FLOAT:
148 return (sizeof (uint32_t));
149 case CTF_K_SLICE:
150 return (sizeof (ctf_slice_t));
151 case CTF_K_ENUM:
152 return (sizeof (ctf_enum_t) * vlen);
153 case CTF_K_FORWARD:
154 case CTF_K_UNKNOWN:
155 case CTF_K_POINTER:
156 case CTF_K_TYPEDEF:
157 case CTF_K_VOLATILE:
158 case CTF_K_CONST:
159 case CTF_K_RESTRICT:
160 return 0;
161 default:
162 ctf_set_errno (fp, ECTF_CORRUPT);
163 ctf_err_warn (fp, 0, 0, _("detected invalid CTF kind: %x"), kind);
164 return -1;
165 }
166 }
167
168 static ssize_t
169 get_vbytes_v1 (ctf_dict_t *fp, unsigned short kind, ssize_t size, size_t vlen)
170 {
171 switch (kind)
172 {
173 case CTF_K_ARRAY:
174 return (sizeof (ctf_array_v1_t));
175 case CTF_K_FUNCTION:
176 return (sizeof (unsigned short) * (vlen + (vlen & 1)));
177 case CTF_K_STRUCT:
178 case CTF_K_UNION:
179 if (size < CTF_LSTRUCT_THRESH_V1)
180 return (sizeof (ctf_member_v1_t) * vlen);
181 else
182 return (sizeof (ctf_lmember_v1_t) * vlen);
183 }
184
185 return (get_vbytes_common (fp, kind, size, vlen));
186 }
187
188 static ssize_t
189 get_vbytes_v2 (ctf_dict_t *fp, unsigned short kind, ssize_t size, size_t vlen)
190 {
191 switch (kind)
192 {
193 case CTF_K_ARRAY:
194 return (sizeof (ctf_array_t));
195 case CTF_K_FUNCTION:
196 return (sizeof (uint32_t) * (vlen + (vlen & 1)));
197 case CTF_K_STRUCT:
198 case CTF_K_UNION:
199 if (size < CTF_LSTRUCT_THRESH)
200 return (sizeof (ctf_member_t) * vlen);
201 else
202 return (sizeof (ctf_lmember_t) * vlen);
203 }
204
205 return (get_vbytes_common (fp, kind, size, vlen));
206 }
207
208 static const ctf_dictops_t ctf_dictops[] = {
209 {NULL, NULL, NULL, NULL, NULL},
210 /* CTF_VERSION_1 */
211 {get_kind_v1, get_root_v1, get_vlen_v1, get_ctt_size_v1, get_vbytes_v1},
212 /* CTF_VERSION_1_UPGRADED_3 */
213 {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2},
214 /* CTF_VERSION_2 */
215 {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2},
216 /* CTF_VERSION_3, identical to 2: only new type kinds */
217 {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2},
218 };
219
220 /* Initialize the symtab translation table as appropriate for its indexing
221 state. For unindexed symtypetabs, fill each entry with the offset of the CTF
222 type or function data corresponding to each STT_FUNC or STT_OBJECT entry in
223 the symbol table. For indexed symtypetabs, do nothing: the needed
224 initialization for indexed lookups may be quite expensive, so it is done only
225 as needed, when lookups happen. (In particular, the majority of indexed
226 symtypetabs come from the compiler, and all the linker does is iteration over
227 all entries, which doesn't need this initialization.)
228
229 The SP symbol table section may be NULL if there is no symtab.
230
231 If init_symtab works on one call, it cannot fail on future calls to the same
232 fp: ctf_symsect_endianness relies on this. */
233
234 static int
235 init_symtab (ctf_dict_t *fp, const ctf_header_t *hp, const ctf_sect_t *sp)
236 {
237 const unsigned char *symp;
238 int skip_func_info = 0;
239 int i;
240 uint32_t *xp = fp->ctf_sxlate;
241 uint32_t *xend = PTR_ADD (xp, fp->ctf_nsyms);
242
243 uint32_t objtoff = hp->cth_objtoff;
244 uint32_t funcoff = hp->cth_funcoff;
245
246 /* If the CTF_F_NEWFUNCINFO flag is not set, pretend the func info section
247 is empty: this compiler is too old to emit a function info section we
248 understand. */
249
250 if (!(hp->cth_flags & CTF_F_NEWFUNCINFO))
251 skip_func_info = 1;
252
253 if (hp->cth_objtidxoff < hp->cth_funcidxoff)
254 fp->ctf_objtidx_names = (uint32_t *) (fp->ctf_buf + hp->cth_objtidxoff);
255 if (hp->cth_funcidxoff < hp->cth_varoff && !skip_func_info)
256 fp->ctf_funcidx_names = (uint32_t *) (fp->ctf_buf + hp->cth_funcidxoff);
257
258 /* Don't bother doing the rest if everything is indexed, or if we don't have a
259 symbol table: we will never use it. */
260 if ((fp->ctf_objtidx_names && fp->ctf_funcidx_names) || !sp || !sp->cts_data)
261 return 0;
262
263 /* The CTF data object and function type sections are ordered to match the
264 relative order of the respective symbol types in the symtab, unless there
265 is an index section, in which case the order is arbitrary and the index
266 gives the mapping. If no type information is available for a symbol table
267 entry, a pad is inserted in the CTF section. As a further optimization,
268 anonymous or undefined symbols are omitted from the CTF data. If an
269 index is available for function symbols but not object symbols, or vice
270 versa, we populate the xslate table for the unindexed symbols only. */
271
272 for (i = 0, symp = sp->cts_data; xp < xend; xp++, symp += sp->cts_entsize,
273 i++)
274 {
275 ctf_link_sym_t sym;
276
277 switch (sp->cts_entsize)
278 {
279 case sizeof (Elf64_Sym):
280 {
281 const Elf64_Sym *symp64 = (Elf64_Sym *) (uintptr_t) symp;
282 ctf_elf64_to_link_sym (fp, &sym, symp64, i);
283 }
284 break;
285 case sizeof (Elf32_Sym):
286 {
287 const Elf32_Sym *symp32 = (Elf32_Sym *) (uintptr_t) symp;
288 ctf_elf32_to_link_sym (fp, &sym, symp32, i);
289 }
290 break;
291 default:
292 return ECTF_SYMTAB;
293 }
294
295 /* This call may be led astray if our idea of the symtab's endianness is
296 wrong, but when this is fixed by a call to ctf_symsect_endianness,
297 init_symtab will be called again with the right endianness in
298 force. */
299 if (ctf_symtab_skippable (&sym))
300 {
301 *xp = -1u;
302 continue;
303 }
304
305 switch (sym.st_type)
306 {
307 case STT_OBJECT:
308 if (fp->ctf_objtidx_names || objtoff >= hp->cth_funcoff)
309 {
310 *xp = -1u;
311 break;
312 }
313
314 *xp = objtoff;
315 objtoff += sizeof (uint32_t);
316 break;
317
318 case STT_FUNC:
319 if (fp->ctf_funcidx_names || funcoff >= hp->cth_objtidxoff
320 || skip_func_info)
321 {
322 *xp = -1u;
323 break;
324 }
325
326 *xp = funcoff;
327 funcoff += sizeof (uint32_t);
328 break;
329
330 default:
331 *xp = -1u;
332 break;
333 }
334 }
335
336 ctf_dprintf ("loaded %lu symtab entries\n", fp->ctf_nsyms);
337 return 0;
338 }
339
340 /* Reset the CTF base pointer and derive the buf pointer from it, initializing
341 everything in the ctf_dict that depends on the base or buf pointers.
342
343 The original gap between the buf and base pointers, if any -- the original,
344 unconverted CTF header -- is kept, but its contents are not specified and are
345 never used. */
346
347 static void
348 ctf_set_base (ctf_dict_t *fp, const ctf_header_t *hp, unsigned char *base)
349 {
350 fp->ctf_buf = base + (fp->ctf_buf - fp->ctf_base);
351 fp->ctf_base = base;
352 fp->ctf_vars = (ctf_varent_t *) ((const char *) fp->ctf_buf +
353 hp->cth_varoff);
354 fp->ctf_nvars = (hp->cth_typeoff - hp->cth_varoff) / sizeof (ctf_varent_t);
355
356 fp->ctf_str[CTF_STRTAB_0].cts_strs = (const char *) fp->ctf_buf
357 + hp->cth_stroff;
358 fp->ctf_str[CTF_STRTAB_0].cts_len = hp->cth_strlen;
359
360 /* If we have a parent dict name and label, store the relocated string
361 pointers in the CTF dict for easy access later. */
362
363 /* Note: before conversion, these will be set to values that will be
364 immediately invalidated by the conversion process, but the conversion
365 process will call ctf_set_base() again to fix things up. */
366
367 if (hp->cth_parlabel != 0)
368 fp->ctf_parlabel = ctf_strptr (fp, hp->cth_parlabel);
369 if (hp->cth_parname != 0)
370 fp->ctf_parname = ctf_strptr (fp, hp->cth_parname);
371 if (hp->cth_cuname != 0)
372 fp->ctf_cuname = ctf_strptr (fp, hp->cth_cuname);
373
374 if (fp->ctf_cuname)
375 ctf_dprintf ("ctf_set_base: CU name %s\n", fp->ctf_cuname);
376 if (fp->ctf_parname)
377 ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n",
378 fp->ctf_parname,
379 fp->ctf_parlabel ? fp->ctf_parlabel : "<NULL>");
380 }
381
382 /* Set the version of the CTF file. */
383
384 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
385 the variable data list associated with each type has been upgraded: the
386 caller must ensure this has been done in advance. */
387
388 static void
389 ctf_set_version (ctf_dict_t *fp, ctf_header_t *cth, int ctf_version)
390 {
391 fp->ctf_version = ctf_version;
392 cth->cth_version = ctf_version;
393 fp->ctf_dictops = &ctf_dictops[ctf_version];
394 }
395
396
397 /* Upgrade the header to CTF_VERSION_3. The upgrade is done in-place. */
398 static void
399 upgrade_header (ctf_header_t *hp)
400 {
401 ctf_header_v2_t *oldhp = (ctf_header_v2_t *) hp;
402
403 hp->cth_strlen = oldhp->cth_strlen;
404 hp->cth_stroff = oldhp->cth_stroff;
405 hp->cth_typeoff = oldhp->cth_typeoff;
406 hp->cth_varoff = oldhp->cth_varoff;
407 hp->cth_funcidxoff = hp->cth_varoff; /* No index sections. */
408 hp->cth_objtidxoff = hp->cth_funcidxoff;
409 hp->cth_funcoff = oldhp->cth_funcoff;
410 hp->cth_objtoff = oldhp->cth_objtoff;
411 hp->cth_lbloff = oldhp->cth_lbloff;
412 hp->cth_cuname = 0; /* No CU name. */
413 }
414
415 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3)
416 from CTF_VERSION_1.
417
418 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
419 not be called before reallocation is complete.
420
421 Sections not checked here due to nonexistence or nonpopulated state in older
422 formats: objtidx, funcidx.
423
424 Type kinds not checked here due to nonexistence in older formats:
425 CTF_K_SLICE. */
426 static int
427 upgrade_types_v1 (ctf_dict_t *fp, ctf_header_t *cth)
428 {
429 const ctf_type_v1_t *tbuf;
430 const ctf_type_v1_t *tend;
431 unsigned char *ctf_base, *old_ctf_base = (unsigned char *) fp->ctf_dynbase;
432 ctf_type_t *t2buf;
433
434 ssize_t increase = 0, size, increment, v2increment, vbytes, v2bytes;
435 const ctf_type_v1_t *tp;
436 ctf_type_t *t2p;
437
438 tbuf = (ctf_type_v1_t *) (fp->ctf_buf + cth->cth_typeoff);
439 tend = (ctf_type_v1_t *) (fp->ctf_buf + cth->cth_stroff);
440
441 /* Much like init_types(), this is a two-pass process.
442
443 First, figure out the new type-section size needed. (It is possible,
444 in theory, for it to be less than the old size, but this is very
445 unlikely. It cannot be so small that cth_typeoff ends up of negative
446 size. We validate this with an assertion below.)
447
448 We must cater not only for changes in vlen and types sizes but also
449 for changes in 'increment', which happen because v2 places some types
450 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
451
452 for (tp = tbuf; tp < tend;
453 tp = (ctf_type_v1_t *) ((uintptr_t) tp + increment + vbytes))
454 {
455 unsigned short kind = CTF_V1_INFO_KIND (tp->ctt_info);
456 unsigned long vlen = CTF_V1_INFO_VLEN (tp->ctt_info);
457
458 size = get_ctt_size_v1 (fp, (const ctf_type_t *) tp, NULL, &increment);
459 vbytes = get_vbytes_v1 (fp, kind, size, vlen);
460
461 get_ctt_size_v2_unconverted (fp, (const ctf_type_t *) tp, NULL,
462 &v2increment);
463 v2bytes = get_vbytes_v2 (fp, kind, size, vlen);
464
465 if ((vbytes < 0) || (size < 0))
466 return ECTF_CORRUPT;
467
468 increase += v2increment - increment; /* May be negative. */
469 increase += v2bytes - vbytes;
470 }
471
472 /* Allocate enough room for the new buffer, then copy everything but the type
473 section into place, and reset the base accordingly. Leave the version
474 number unchanged, so that LCTF_INFO_* still works on the
475 as-yet-untranslated type info. */
476
477 if ((ctf_base = malloc (fp->ctf_size + increase)) == NULL)
478 return ECTF_ZALLOC;
479
480 /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
481 never use it and it is unconverted. */
482
483 memcpy (ctf_base, fp->ctf_buf, cth->cth_typeoff);
484 memcpy (ctf_base + cth->cth_stroff + increase,
485 fp->ctf_buf + cth->cth_stroff, cth->cth_strlen);
486
487 memset (ctf_base + cth->cth_typeoff, 0, cth->cth_stroff - cth->cth_typeoff
488 + increase);
489
490 cth->cth_stroff += increase;
491 fp->ctf_size += increase;
492 assert (cth->cth_stroff >= cth->cth_typeoff);
493 fp->ctf_base = ctf_base;
494 fp->ctf_buf = ctf_base;
495 fp->ctf_dynbase = ctf_base;
496 ctf_set_base (fp, cth, ctf_base);
497
498 t2buf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff);
499
500 /* Iterate through all the types again, upgrading them.
501
502 Everything that hasn't changed can just be outright memcpy()ed.
503 Things that have changed need field-by-field consideration. */
504
505 for (tp = tbuf, t2p = t2buf; tp < tend;
506 tp = (ctf_type_v1_t *) ((uintptr_t) tp + increment + vbytes),
507 t2p = (ctf_type_t *) ((uintptr_t) t2p + v2increment + v2bytes))
508 {
509 unsigned short kind = CTF_V1_INFO_KIND (tp->ctt_info);
510 int isroot = CTF_V1_INFO_ISROOT (tp->ctt_info);
511 unsigned long vlen = CTF_V1_INFO_VLEN (tp->ctt_info);
512 ssize_t v2size;
513 void *vdata, *v2data;
514
515 size = get_ctt_size_v1 (fp, (const ctf_type_t *) tp, NULL, &increment);
516 vbytes = get_vbytes_v1 (fp, kind, size, vlen);
517
518 t2p->ctt_name = tp->ctt_name;
519 t2p->ctt_info = CTF_TYPE_INFO (kind, isroot, vlen);
520
521 switch (kind)
522 {
523 case CTF_K_FUNCTION:
524 case CTF_K_FORWARD:
525 case CTF_K_TYPEDEF:
526 case CTF_K_POINTER:
527 case CTF_K_VOLATILE:
528 case CTF_K_CONST:
529 case CTF_K_RESTRICT:
530 t2p->ctt_type = tp->ctt_type;
531 break;
532 case CTF_K_INTEGER:
533 case CTF_K_FLOAT:
534 case CTF_K_ARRAY:
535 case CTF_K_STRUCT:
536 case CTF_K_UNION:
537 case CTF_K_ENUM:
538 case CTF_K_UNKNOWN:
539 if ((size_t) size <= CTF_MAX_SIZE)
540 t2p->ctt_size = size;
541 else
542 {
543 t2p->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
544 t2p->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
545 }
546 break;
547 }
548
549 v2size = get_ctt_size_v2 (fp, t2p, NULL, &v2increment);
550 v2bytes = get_vbytes_v2 (fp, kind, v2size, vlen);
551
552 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
553 these are not identical (and having them different makes no
554 sense semantically). */
555
556 assert (size == v2size);
557
558 /* Now the varlen info. */
559
560 vdata = (void *) ((uintptr_t) tp + increment);
561 v2data = (void *) ((uintptr_t) t2p + v2increment);
562
563 switch (kind)
564 {
565 case CTF_K_ARRAY:
566 {
567 const ctf_array_v1_t *ap = (const ctf_array_v1_t *) vdata;
568 ctf_array_t *a2p = (ctf_array_t *) v2data;
569
570 a2p->cta_contents = ap->cta_contents;
571 a2p->cta_index = ap->cta_index;
572 a2p->cta_nelems = ap->cta_nelems;
573 break;
574 }
575 case CTF_K_STRUCT:
576 case CTF_K_UNION:
577 {
578 ctf_member_t tmp;
579 const ctf_member_v1_t *m1 = (const ctf_member_v1_t *) vdata;
580 const ctf_lmember_v1_t *lm1 = (const ctf_lmember_v1_t *) m1;
581 ctf_member_t *m2 = (ctf_member_t *) v2data;
582 ctf_lmember_t *lm2 = (ctf_lmember_t *) m2;
583 unsigned long i;
584
585 /* We walk all four pointers forward, but only reference the two
586 that are valid for the given size, to avoid quadruplicating all
587 the code. */
588
589 for (i = vlen; i != 0; i--, m1++, lm1++, m2++, lm2++)
590 {
591 size_t offset;
592 if (size < CTF_LSTRUCT_THRESH_V1)
593 {
594 offset = m1->ctm_offset;
595 tmp.ctm_name = m1->ctm_name;
596 tmp.ctm_type = m1->ctm_type;
597 }
598 else
599 {
600 offset = CTF_LMEM_OFFSET (lm1);
601 tmp.ctm_name = lm1->ctlm_name;
602 tmp.ctm_type = lm1->ctlm_type;
603 }
604 if (size < CTF_LSTRUCT_THRESH)
605 {
606 m2->ctm_name = tmp.ctm_name;
607 m2->ctm_type = tmp.ctm_type;
608 m2->ctm_offset = offset;
609 }
610 else
611 {
612 lm2->ctlm_name = tmp.ctm_name;
613 lm2->ctlm_type = tmp.ctm_type;
614 lm2->ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (offset);
615 lm2->ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (offset);
616 }
617 }
618 break;
619 }
620 case CTF_K_FUNCTION:
621 {
622 unsigned long i;
623 unsigned short *a1 = (unsigned short *) vdata;
624 uint32_t *a2 = (uint32_t *) v2data;
625
626 for (i = vlen; i != 0; i--, a1++, a2++)
627 *a2 = *a1;
628 }
629 /* FALLTHRU */
630 default:
631 /* Catch out-of-sync get_vbytes_*(). */
632 assert (vbytes == v2bytes);
633 memcpy (v2data, vdata, vbytes);
634 }
635 }
636
637 /* Verify that the entire region was converted. If not, we are either
638 converting too much, or too little (leading to a buffer overrun either here
639 or at read time, in init_types().) */
640
641 assert ((size_t) t2p - (size_t) fp->ctf_buf == cth->cth_stroff);
642
643 ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3);
644 free (old_ctf_base);
645
646 return 0;
647 }
648
649 /* Upgrade from any earlier version. */
650 static int
651 upgrade_types (ctf_dict_t *fp, ctf_header_t *cth)
652 {
653 switch (cth->cth_version)
654 {
655 /* v1 requires a full pass and reformatting. */
656 case CTF_VERSION_1:
657 upgrade_types_v1 (fp, cth);
658 /* FALLTHRU */
659 /* Already-converted v1 is just like later versions except that its
660 parent/child boundary is unchanged (and much lower). */
661
662 case CTF_VERSION_1_UPGRADED_3:
663 fp->ctf_parmax = CTF_MAX_PTYPE_V1;
664
665 /* v2 is just the same as v3 except for new types and sections:
666 no upgrading required. */
667 case CTF_VERSION_2: ;
668 /* FALLTHRU */
669 }
670 return 0;
671 }
672
673 /* Initialize the type ID translation table with the byte offset of each type,
674 and initialize the hash tables of each named type. Upgrade the type table to
675 the latest supported representation in the process, if needed, and if this
676 recension of libctf supports upgrading. */
677
678 static int
679 init_types (ctf_dict_t *fp, ctf_header_t *cth)
680 {
681 const ctf_type_t *tbuf;
682 const ctf_type_t *tend;
683
684 unsigned long pop[CTF_K_MAX + 1] = { 0 };
685 const ctf_type_t *tp;
686 uint32_t id;
687 uint32_t *xp;
688
689 /* We determine whether the dict is a child or a parent based on the value of
690 cth_parname. */
691
692 int child = cth->cth_parname != 0;
693 int nlstructs = 0, nlunions = 0;
694 int err;
695
696 assert (!(fp->ctf_flags & LCTF_RDWR));
697
698 if (_libctf_unlikely_ (fp->ctf_version == CTF_VERSION_1))
699 {
700 int err;
701 if ((err = upgrade_types (fp, cth)) != 0)
702 return err; /* Upgrade failed. */
703 }
704
705 tbuf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff);
706 tend = (ctf_type_t *) (fp->ctf_buf + cth->cth_stroff);
707
708 /* We make two passes through the entire type section. In this first
709 pass, we count the number of each type and the total number of types. */
710
711 for (tp = tbuf; tp < tend; fp->ctf_typemax++)
712 {
713 unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
714 unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
715 ssize_t size, increment, vbytes;
716
717 (void) ctf_get_ctt_size (fp, tp, &size, &increment);
718 vbytes = LCTF_VBYTES (fp, kind, size, vlen);
719
720 if (vbytes < 0)
721 return ECTF_CORRUPT;
722
723 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
724 so bump that population count too. */
725 if (kind == CTF_K_FORWARD)
726 pop[tp->ctt_type]++;
727
728 tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
729 pop[kind]++;
730 }
731
732 if (child)
733 {
734 ctf_dprintf ("CTF dict %p is a child\n", (void *) fp);
735 fp->ctf_flags |= LCTF_CHILD;
736 }
737 else
738 ctf_dprintf ("CTF dict %p is a parent\n", (void *) fp);
739
740 /* Now that we've counted up the number of each type, we can allocate
741 the hash tables, type translation table, and pointer table. */
742
743 if ((fp->ctf_structs.ctn_readonly
744 = ctf_hash_create (pop[CTF_K_STRUCT], ctf_hash_string,
745 ctf_hash_eq_string)) == NULL)
746 return ENOMEM;
747
748 if ((fp->ctf_unions.ctn_readonly
749 = ctf_hash_create (pop[CTF_K_UNION], ctf_hash_string,
750 ctf_hash_eq_string)) == NULL)
751 return ENOMEM;
752
753 if ((fp->ctf_enums.ctn_readonly
754 = ctf_hash_create (pop[CTF_K_ENUM], ctf_hash_string,
755 ctf_hash_eq_string)) == NULL)
756 return ENOMEM;
757
758 if ((fp->ctf_names.ctn_readonly
759 = ctf_hash_create (pop[CTF_K_UNKNOWN] +
760 pop[CTF_K_INTEGER] +
761 pop[CTF_K_FLOAT] +
762 pop[CTF_K_FUNCTION] +
763 pop[CTF_K_TYPEDEF] +
764 pop[CTF_K_POINTER] +
765 pop[CTF_K_VOLATILE] +
766 pop[CTF_K_CONST] +
767 pop[CTF_K_RESTRICT],
768 ctf_hash_string,
769 ctf_hash_eq_string)) == NULL)
770 return ENOMEM;
771
772 fp->ctf_txlate = malloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
773 fp->ctf_ptrtab_len = fp->ctf_typemax + 1;
774 fp->ctf_ptrtab = malloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
775
776 if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
777 return ENOMEM; /* Memory allocation failed. */
778
779 xp = fp->ctf_txlate;
780 *xp++ = 0; /* Type id 0 is used as a sentinel value. */
781
782 memset (fp->ctf_txlate, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1));
783 memset (fp->ctf_ptrtab, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1));
784
785 /* In the second pass through the types, we fill in each entry of the
786 type and pointer tables and add names to the appropriate hashes. */
787
788 for (id = 1, tp = tbuf; tp < tend; xp++, id++)
789 {
790 unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
791 unsigned short isroot = LCTF_INFO_ISROOT (fp, tp->ctt_info);
792 unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
793 ssize_t size, increment, vbytes;
794
795 const char *name;
796
797 (void) ctf_get_ctt_size (fp, tp, &size, &increment);
798 name = ctf_strptr (fp, tp->ctt_name);
799 /* Cannot fail: shielded by call in loop above. */
800 vbytes = LCTF_VBYTES (fp, kind, size, vlen);
801
802 switch (kind)
803 {
804 case CTF_K_UNKNOWN:
805 case CTF_K_INTEGER:
806 case CTF_K_FLOAT:
807 /* Names are reused by bit-fields, which are differentiated by their
808 encodings, and so typically we'd record only the first instance of
809 a given intrinsic. However, we replace an existing type with a
810 root-visible version so that we can be sure to find it when
811 checking for conflicting definitions in ctf_add_type(). */
812
813 if (((ctf_hash_lookup_type (fp->ctf_names.ctn_readonly,
814 fp, name)) == 0)
815 || isroot)
816 {
817 err = ctf_hash_define_type (fp->ctf_names.ctn_readonly, fp,
818 LCTF_INDEX_TO_TYPE (fp, id, child),
819 tp->ctt_name);
820 if (err != 0)
821 return err;
822 }
823 break;
824
825 /* These kinds have no name, so do not need interning into any
826 hashtables. */
827 case CTF_K_ARRAY:
828 case CTF_K_SLICE:
829 break;
830
831 case CTF_K_FUNCTION:
832 if (!isroot)
833 break;
834
835 err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
836 LCTF_INDEX_TO_TYPE (fp, id, child),
837 tp->ctt_name);
838 if (err != 0)
839 return err;
840 break;
841
842 case CTF_K_STRUCT:
843 if (size >= CTF_LSTRUCT_THRESH)
844 nlstructs++;
845
846 if (!isroot)
847 break;
848
849 err = ctf_hash_define_type (fp->ctf_structs.ctn_readonly, fp,
850 LCTF_INDEX_TO_TYPE (fp, id, child),
851 tp->ctt_name);
852
853 if (err != 0)
854 return err;
855
856 break;
857
858 case CTF_K_UNION:
859 if (size >= CTF_LSTRUCT_THRESH)
860 nlunions++;
861
862 if (!isroot)
863 break;
864
865 err = ctf_hash_define_type (fp->ctf_unions.ctn_readonly, fp,
866 LCTF_INDEX_TO_TYPE (fp, id, child),
867 tp->ctt_name);
868
869 if (err != 0)
870 return err;
871 break;
872
873 case CTF_K_ENUM:
874 if (!isroot)
875 break;
876
877 err = ctf_hash_define_type (fp->ctf_enums.ctn_readonly, fp,
878 LCTF_INDEX_TO_TYPE (fp, id, child),
879 tp->ctt_name);
880
881 if (err != 0)
882 return err;
883 break;
884
885 case CTF_K_TYPEDEF:
886 if (!isroot)
887 break;
888
889 err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
890 LCTF_INDEX_TO_TYPE (fp, id, child),
891 tp->ctt_name);
892 if (err != 0)
893 return err;
894 break;
895
896 case CTF_K_FORWARD:
897 {
898 ctf_names_t *np = ctf_name_table (fp, tp->ctt_type);
899
900 if (!isroot)
901 break;
902
903 /* Only insert forward tags into the given hash if the type or tag
904 name is not already present. */
905 if (ctf_hash_lookup_type (np->ctn_readonly, fp, name) == 0)
906 {
907 err = ctf_hash_insert_type (np->ctn_readonly, fp,
908 LCTF_INDEX_TO_TYPE (fp, id, child),
909 tp->ctt_name);
910 if (err != 0)
911 return err;
912 }
913 break;
914 }
915
916 case CTF_K_POINTER:
917 /* If the type referenced by the pointer is in this CTF dict, then
918 store the index of the pointer type in fp->ctf_ptrtab[ index of
919 referenced type ]. */
920
921 if (LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child
922 && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
923 fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = id;
924 /*FALLTHRU*/
925
926 case CTF_K_VOLATILE:
927 case CTF_K_CONST:
928 case CTF_K_RESTRICT:
929 if (!isroot)
930 break;
931
932 err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
933 LCTF_INDEX_TO_TYPE (fp, id, child),
934 tp->ctt_name);
935 if (err != 0)
936 return err;
937 break;
938 default:
939 ctf_err_warn (fp, 0, ECTF_CORRUPT,
940 _("init_types(): unhandled CTF kind: %x"), kind);
941 return ECTF_CORRUPT;
942 }
943
944 *xp = (uint32_t) ((uintptr_t) tp - (uintptr_t) fp->ctf_buf);
945 tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
946 }
947
948 ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax);
949 ctf_dprintf ("%u enum names hashed\n",
950 ctf_hash_size (fp->ctf_enums.ctn_readonly));
951 ctf_dprintf ("%u struct names hashed (%d long)\n",
952 ctf_hash_size (fp->ctf_structs.ctn_readonly), nlstructs);
953 ctf_dprintf ("%u union names hashed (%d long)\n",
954 ctf_hash_size (fp->ctf_unions.ctn_readonly), nlunions);
955 ctf_dprintf ("%u base type names hashed\n",
956 ctf_hash_size (fp->ctf_names.ctn_readonly));
957
958 return 0;
959 }
960
961 /* Endianness-flipping routines.
962
963 We flip everything, mindlessly, even 1-byte entities, so that future
964 expansions do not require changes to this code. */
965
966 /* Flip the endianness of the CTF header. */
967
968 void
969 ctf_flip_header (ctf_header_t *cth)
970 {
971 swap_thing (cth->cth_preamble.ctp_magic);
972 swap_thing (cth->cth_preamble.ctp_version);
973 swap_thing (cth->cth_preamble.ctp_flags);
974 swap_thing (cth->cth_parlabel);
975 swap_thing (cth->cth_parname);
976 swap_thing (cth->cth_cuname);
977 swap_thing (cth->cth_objtoff);
978 swap_thing (cth->cth_funcoff);
979 swap_thing (cth->cth_objtidxoff);
980 swap_thing (cth->cth_funcidxoff);
981 swap_thing (cth->cth_varoff);
982 swap_thing (cth->cth_typeoff);
983 swap_thing (cth->cth_stroff);
984 swap_thing (cth->cth_strlen);
985 }
986
987 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
988
989 static void
990 flip_lbls (void *start, size_t len)
991 {
992 ctf_lblent_t *lbl = start;
993 ssize_t i;
994
995 for (i = len / sizeof (struct ctf_lblent); i > 0; lbl++, i--)
996 {
997 swap_thing (lbl->ctl_label);
998 swap_thing (lbl->ctl_type);
999 }
1000 }
1001
1002 /* Flip the endianness of the data-object or function sections or their indexes,
1003 all arrays of uint32_t. */
1004
1005 static void
1006 flip_objts (void *start, size_t len)
1007 {
1008 uint32_t *obj = start;
1009 ssize_t i;
1010
1011 for (i = len / sizeof (uint32_t); i > 0; obj++, i--)
1012 swap_thing (*obj);
1013 }
1014
1015 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
1016
1017 static void
1018 flip_vars (void *start, size_t len)
1019 {
1020 ctf_varent_t *var = start;
1021 ssize_t i;
1022
1023 for (i = len / sizeof (struct ctf_varent); i > 0; var++, i--)
1024 {
1025 swap_thing (var->ctv_name);
1026 swap_thing (var->ctv_type);
1027 }
1028 }
1029
1030 /* Flip the endianness of the type section, a tagged array of ctf_type or
1031 ctf_stype followed by variable data. */
1032
1033 static int
1034 flip_types (ctf_dict_t *fp, void *start, size_t len, int to_foreign)
1035 {
1036 ctf_type_t *t = start;
1037
1038 while ((uintptr_t) t < ((uintptr_t) start) + len)
1039 {
1040 uint32_t kind;
1041 size_t size;
1042 uint32_t vlen;
1043 size_t vbytes;
1044
1045 if (to_foreign)
1046 {
1047 kind = CTF_V2_INFO_KIND (t->ctt_info);
1048 size = t->ctt_size;
1049 vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1050 vbytes = get_vbytes_v2 (fp, kind, size, vlen);
1051 }
1052
1053 swap_thing (t->ctt_name);
1054 swap_thing (t->ctt_info);
1055 swap_thing (t->ctt_size);
1056
1057 if (!to_foreign)
1058 {
1059 kind = CTF_V2_INFO_KIND (t->ctt_info);
1060 size = t->ctt_size;
1061 vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1062 vbytes = get_vbytes_v2 (fp, kind, size, vlen);
1063 }
1064
1065 if (_libctf_unlikely_ (size == CTF_LSIZE_SENT))
1066 {
1067 if (to_foreign)
1068 size = CTF_TYPE_LSIZE (t);
1069
1070 swap_thing (t->ctt_lsizehi);
1071 swap_thing (t->ctt_lsizelo);
1072
1073 if (!to_foreign)
1074 size = CTF_TYPE_LSIZE (t);
1075
1076 t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t));
1077 }
1078 else
1079 t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_stype_t));
1080
1081 switch (kind)
1082 {
1083 case CTF_K_FORWARD:
1084 case CTF_K_UNKNOWN:
1085 case CTF_K_POINTER:
1086 case CTF_K_TYPEDEF:
1087 case CTF_K_VOLATILE:
1088 case CTF_K_CONST:
1089 case CTF_K_RESTRICT:
1090 /* These types have no vlen data to swap. */
1091 assert (vbytes == 0);
1092 break;
1093
1094 case CTF_K_INTEGER:
1095 case CTF_K_FLOAT:
1096 {
1097 /* These types have a single uint32_t. */
1098
1099 uint32_t *item = (uint32_t *) t;
1100
1101 swap_thing (*item);
1102 break;
1103 }
1104
1105 case CTF_K_FUNCTION:
1106 {
1107 /* This type has a bunch of uint32_ts. */
1108
1109 uint32_t *item = (uint32_t *) t;
1110 ssize_t i;
1111
1112 for (i = vlen; i > 0; item++, i--)
1113 swap_thing (*item);
1114 break;
1115 }
1116
1117 case CTF_K_ARRAY:
1118 {
1119 /* This has a single ctf_array_t. */
1120
1121 ctf_array_t *a = (ctf_array_t *) t;
1122
1123 assert (vbytes == sizeof (ctf_array_t));
1124 swap_thing (a->cta_contents);
1125 swap_thing (a->cta_index);
1126 swap_thing (a->cta_nelems);
1127
1128 break;
1129 }
1130
1131 case CTF_K_SLICE:
1132 {
1133 /* This has a single ctf_slice_t. */
1134
1135 ctf_slice_t *s = (ctf_slice_t *) t;
1136
1137 assert (vbytes == sizeof (ctf_slice_t));
1138 swap_thing (s->cts_type);
1139 swap_thing (s->cts_offset);
1140 swap_thing (s->cts_bits);
1141
1142 break;
1143 }
1144
1145 case CTF_K_STRUCT:
1146 case CTF_K_UNION:
1147 {
1148 /* This has an array of ctf_member or ctf_lmember, depending on
1149 size. We could consider it to be a simple array of uint32_t,
1150 but for safety's sake in case these structures ever acquire
1151 non-uint32_t members, do it member by member. */
1152
1153 if (_libctf_unlikely_ (size >= CTF_LSTRUCT_THRESH))
1154 {
1155 ctf_lmember_t *lm = (ctf_lmember_t *) t;
1156 ssize_t i;
1157 for (i = vlen; i > 0; i--, lm++)
1158 {
1159 swap_thing (lm->ctlm_name);
1160 swap_thing (lm->ctlm_offsethi);
1161 swap_thing (lm->ctlm_type);
1162 swap_thing (lm->ctlm_offsetlo);
1163 }
1164 }
1165 else
1166 {
1167 ctf_member_t *m = (ctf_member_t *) t;
1168 ssize_t i;
1169 for (i = vlen; i > 0; i--, m++)
1170 {
1171 swap_thing (m->ctm_name);
1172 swap_thing (m->ctm_offset);
1173 swap_thing (m->ctm_type);
1174 }
1175 }
1176 break;
1177 }
1178
1179 case CTF_K_ENUM:
1180 {
1181 /* This has an array of ctf_enum_t. */
1182
1183 ctf_enum_t *item = (ctf_enum_t *) t;
1184 ssize_t i;
1185
1186 for (i = vlen; i > 0; item++, i--)
1187 {
1188 swap_thing (item->cte_name);
1189 swap_thing (item->cte_value);
1190 }
1191 break;
1192 }
1193 default:
1194 ctf_err_warn (fp, 0, ECTF_CORRUPT,
1195 _("unhandled CTF kind in endianness conversion: %x"),
1196 kind);
1197 return ECTF_CORRUPT;
1198 }
1199
1200 t = (ctf_type_t *) ((uintptr_t) t + vbytes);
1201 }
1202
1203 return 0;
1204 }
1205
1206 /* Flip the endianness of BUF, given the offsets in the (already endian-
1207 converted) CTH. If TO_FOREIGN is set, flip to foreign-endianness; if not,
1208 flip away.
1209
1210 All of this stuff happens before the header is fully initialized, so the
1211 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1212 data, this is no real loss. */
1213
1214 int
1215 ctf_flip (ctf_dict_t *fp, ctf_header_t *cth, unsigned char *buf,
1216 int to_foreign)
1217 {
1218 ctf_dprintf("flipping endianness\n");
1219
1220 flip_lbls (buf + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff);
1221 flip_objts (buf + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff);
1222 flip_objts (buf + cth->cth_funcoff, cth->cth_objtidxoff - cth->cth_funcoff);
1223 flip_objts (buf + cth->cth_objtidxoff, cth->cth_funcidxoff - cth->cth_objtidxoff);
1224 flip_objts (buf + cth->cth_funcidxoff, cth->cth_varoff - cth->cth_funcidxoff);
1225 flip_vars (buf + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff);
1226 return flip_types (fp, buf + cth->cth_typeoff,
1227 cth->cth_stroff - cth->cth_typeoff, to_foreign);
1228 }
1229
1230 /* Set up the ctl hashes in a ctf_dict_t. Called by both writable and
1231 non-writable dictionary initialization. */
1232 void ctf_set_ctl_hashes (ctf_dict_t *fp)
1233 {
1234 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1235 array of type name prefixes and the corresponding ctf_hash to use. */
1236 fp->ctf_lookups[0].ctl_prefix = "struct";
1237 fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
1238 fp->ctf_lookups[0].ctl_hash = &fp->ctf_structs;
1239 fp->ctf_lookups[1].ctl_prefix = "union";
1240 fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
1241 fp->ctf_lookups[1].ctl_hash = &fp->ctf_unions;
1242 fp->ctf_lookups[2].ctl_prefix = "enum";
1243 fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
1244 fp->ctf_lookups[2].ctl_hash = &fp->ctf_enums;
1245 fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
1246 fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
1247 fp->ctf_lookups[3].ctl_hash = &fp->ctf_names;
1248 fp->ctf_lookups[4].ctl_prefix = NULL;
1249 fp->ctf_lookups[4].ctl_len = 0;
1250 fp->ctf_lookups[4].ctl_hash = NULL;
1251 }
1252
1253 /* Open a CTF file, mocking up a suitable ctf_sect. */
1254
1255 ctf_dict_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
1256 const char *symsect, size_t symsect_size,
1257 size_t symsect_entsize,
1258 const char *strsect, size_t strsect_size,
1259 int *errp)
1260 {
1261 return ctf_simple_open_internal (ctfsect, ctfsect_size, symsect, symsect_size,
1262 symsect_entsize, strsect, strsect_size, NULL,
1263 0, errp);
1264 }
1265
1266 /* Open a CTF file, mocking up a suitable ctf_sect and overriding the external
1267 strtab with a synthetic one. */
1268
1269 ctf_dict_t *ctf_simple_open_internal (const char *ctfsect, size_t ctfsect_size,
1270 const char *symsect, size_t symsect_size,
1271 size_t symsect_entsize,
1272 const char *strsect, size_t strsect_size,
1273 ctf_dynhash_t *syn_strtab, int writable,
1274 int *errp)
1275 {
1276 ctf_sect_t skeleton;
1277
1278 ctf_sect_t ctf_sect, sym_sect, str_sect;
1279 ctf_sect_t *ctfsectp = NULL;
1280 ctf_sect_t *symsectp = NULL;
1281 ctf_sect_t *strsectp = NULL;
1282
1283 skeleton.cts_name = _CTF_SECTION;
1284 skeleton.cts_entsize = 1;
1285
1286 if (ctfsect)
1287 {
1288 memcpy (&ctf_sect, &skeleton, sizeof (struct ctf_sect));
1289 ctf_sect.cts_data = ctfsect;
1290 ctf_sect.cts_size = ctfsect_size;
1291 ctfsectp = &ctf_sect;
1292 }
1293
1294 if (symsect)
1295 {
1296 memcpy (&sym_sect, &skeleton, sizeof (struct ctf_sect));
1297 sym_sect.cts_data = symsect;
1298 sym_sect.cts_size = symsect_size;
1299 sym_sect.cts_entsize = symsect_entsize;
1300 symsectp = &sym_sect;
1301 }
1302
1303 if (strsect)
1304 {
1305 memcpy (&str_sect, &skeleton, sizeof (struct ctf_sect));
1306 str_sect.cts_data = strsect;
1307 str_sect.cts_size = strsect_size;
1308 strsectp = &str_sect;
1309 }
1310
1311 return ctf_bufopen_internal (ctfsectp, symsectp, strsectp, syn_strtab,
1312 writable, errp);
1313 }
1314
1315 /* Decode the specified CTF buffer and optional symbol table, and create a new
1316 CTF dict representing the symbolic debugging information. This code can
1317 be used directly by the debugger, or it can be used as the engine for
1318 ctf_fdopen() or ctf_open(), below. */
1319
1320 ctf_dict_t *
1321 ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1322 const ctf_sect_t *strsect, int *errp)
1323 {
1324 return ctf_bufopen_internal (ctfsect, symsect, strsect, NULL, 0, errp);
1325 }
1326
1327 /* Like ctf_bufopen, but overriding the external strtab with a synthetic one. */
1328
1329 ctf_dict_t *
1330 ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1331 const ctf_sect_t *strsect, ctf_dynhash_t *syn_strtab,
1332 int writable, int *errp)
1333 {
1334 const ctf_preamble_t *pp;
1335 size_t hdrsz = sizeof (ctf_header_t);
1336 ctf_header_t *hp;
1337 ctf_dict_t *fp;
1338 int foreign_endian = 0;
1339 int err;
1340
1341 libctf_init_debug();
1342
1343 if ((ctfsect == NULL) || ((symsect != NULL) &&
1344 ((strsect == NULL) && syn_strtab == NULL)))
1345 return (ctf_set_open_errno (errp, EINVAL));
1346
1347 if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) &&
1348 symsect->cts_entsize != sizeof (Elf64_Sym))
1349 return (ctf_set_open_errno (errp, ECTF_SYMTAB));
1350
1351 if (symsect != NULL && symsect->cts_data == NULL)
1352 return (ctf_set_open_errno (errp, ECTF_SYMBAD));
1353
1354 if (strsect != NULL && strsect->cts_data == NULL)
1355 return (ctf_set_open_errno (errp, ECTF_STRBAD));
1356
1357 if (ctfsect->cts_data == NULL
1358 || ctfsect->cts_size < sizeof (ctf_preamble_t))
1359 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1360
1361 pp = (const ctf_preamble_t *) ctfsect->cts_data;
1362
1363 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1364 pp->ctp_magic, pp->ctp_version);
1365
1366 /* Validate each part of the CTF header.
1367
1368 First, we validate the preamble (common to all versions). At that point,
1369 we know the endianness and specific header version, and can validate the
1370 version-specific parts including section offsets and alignments.
1371
1372 We specifically do not support foreign-endian old versions. */
1373
1374 if (_libctf_unlikely_ (pp->ctp_magic != CTF_MAGIC))
1375 {
1376 if (pp->ctp_magic == bswap_16 (CTF_MAGIC))
1377 {
1378 if (pp->ctp_version != CTF_VERSION_3)
1379 return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1380 foreign_endian = 1;
1381 }
1382 else
1383 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1384 }
1385
1386 if (_libctf_unlikely_ ((pp->ctp_version < CTF_VERSION_1)
1387 || (pp->ctp_version > CTF_VERSION_3)))
1388 return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1389
1390 if ((symsect != NULL) && (pp->ctp_version < CTF_VERSION_2))
1391 {
1392 /* The symtab can contain function entries which contain embedded ctf
1393 info. We do not support dynamically upgrading such entries (none
1394 should exist in any case, since dwarf2ctf does not create them). */
1395
1396 ctf_err_warn (NULL, 0, ECTF_NOTSUP, _("ctf_bufopen: CTF version %d "
1397 "symsect not supported"),
1398 pp->ctp_version);
1399 return (ctf_set_open_errno (errp, ECTF_NOTSUP));
1400 }
1401
1402 if (pp->ctp_version < CTF_VERSION_3)
1403 hdrsz = sizeof (ctf_header_v2_t);
1404
1405 if (_libctf_unlikely_ (pp->ctp_flags > CTF_F_MAX))
1406 {
1407 ctf_err_warn (NULL, 0, ECTF_FLAGS, _("ctf_bufopen: invalid header "
1408 "flags: %x"),
1409 (unsigned int) pp->ctp_flags);
1410 return (ctf_set_open_errno (errp, ECTF_FLAGS));
1411 }
1412
1413 if (ctfsect->cts_size < hdrsz)
1414 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1415
1416 if ((fp = malloc (sizeof (ctf_dict_t))) == NULL)
1417 return (ctf_set_open_errno (errp, ENOMEM));
1418
1419 memset (fp, 0, sizeof (ctf_dict_t));
1420
1421 if (writable)
1422 fp->ctf_flags |= LCTF_RDWR;
1423
1424 if ((fp->ctf_header = malloc (sizeof (struct ctf_header))) == NULL)
1425 {
1426 free (fp);
1427 return (ctf_set_open_errno (errp, ENOMEM));
1428 }
1429 hp = fp->ctf_header;
1430 memcpy (hp, ctfsect->cts_data, hdrsz);
1431 if (pp->ctp_version < CTF_VERSION_3)
1432 upgrade_header (hp);
1433
1434 if (foreign_endian)
1435 ctf_flip_header (hp);
1436 fp->ctf_openflags = hp->cth_flags;
1437 fp->ctf_size = hp->cth_stroff + hp->cth_strlen;
1438
1439 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
1440 (unsigned long) fp->ctf_size);
1441
1442 if (hp->cth_lbloff > fp->ctf_size || hp->cth_objtoff > fp->ctf_size
1443 || hp->cth_funcoff > fp->ctf_size || hp->cth_objtidxoff > fp->ctf_size
1444 || hp->cth_funcidxoff > fp->ctf_size || hp->cth_typeoff > fp->ctf_size
1445 || hp->cth_stroff > fp->ctf_size)
1446 {
1447 ctf_err_warn (NULL, 0, ECTF_CORRUPT, _("header offset exceeds CTF size"));
1448 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1449 }
1450
1451 if (hp->cth_lbloff > hp->cth_objtoff
1452 || hp->cth_objtoff > hp->cth_funcoff
1453 || hp->cth_funcoff > hp->cth_typeoff
1454 || hp->cth_funcoff > hp->cth_objtidxoff
1455 || hp->cth_objtidxoff > hp->cth_funcidxoff
1456 || hp->cth_funcidxoff > hp->cth_varoff
1457 || hp->cth_varoff > hp->cth_typeoff || hp->cth_typeoff > hp->cth_stroff)
1458 {
1459 ctf_err_warn (NULL, 0, ECTF_CORRUPT, _("overlapping CTF sections"));
1460 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1461 }
1462
1463 if ((hp->cth_lbloff & 3) || (hp->cth_objtoff & 2)
1464 || (hp->cth_funcoff & 2) || (hp->cth_objtidxoff & 2)
1465 || (hp->cth_funcidxoff & 2) || (hp->cth_varoff & 3)
1466 || (hp->cth_typeoff & 3))
1467 {
1468 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1469 _("CTF sections not properly aligned"));
1470 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1471 }
1472
1473 /* This invariant will be lifted in v4, but for now it is true. */
1474
1475 if ((hp->cth_funcidxoff - hp->cth_objtidxoff != 0) &&
1476 (hp->cth_funcidxoff - hp->cth_objtidxoff
1477 != hp->cth_funcoff - hp->cth_objtoff))
1478 {
1479 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1480 _("Object index section is neither empty nor the "
1481 "same length as the object section: %u versus %u "
1482 "bytes"), hp->cth_funcoff - hp->cth_objtoff,
1483 hp->cth_funcidxoff - hp->cth_objtidxoff);
1484 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1485 }
1486
1487 if ((hp->cth_varoff - hp->cth_funcidxoff != 0) &&
1488 (hp->cth_varoff - hp->cth_funcidxoff
1489 != hp->cth_objtidxoff - hp->cth_funcoff) &&
1490 (hp->cth_flags & CTF_F_NEWFUNCINFO))
1491 {
1492 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1493 _("Function index section is neither empty nor the "
1494 "same length as the function section: %u versus %u "
1495 "bytes"), hp->cth_objtidxoff - hp->cth_funcoff,
1496 hp->cth_varoff - hp->cth_funcidxoff);
1497 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1498 }
1499
1500 /* Once everything is determined to be valid, attempt to decompress the CTF
1501 data buffer if it is compressed, or copy it into new storage if it is not
1502 compressed but needs endian-flipping. Otherwise we just put the data
1503 section's buffer pointer into ctf_buf, below. */
1504
1505 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1506 init_types(). */
1507
1508 if (hp->cth_flags & CTF_F_COMPRESS)
1509 {
1510 size_t srclen;
1511 uLongf dstlen;
1512 const void *src;
1513 int rc = Z_OK;
1514
1515 /* We are allocating this ourselves, so we can drop the ctf header
1516 copy in favour of ctf->ctf_header. */
1517
1518 if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
1519 {
1520 err = ECTF_ZALLOC;
1521 goto bad;
1522 }
1523 fp->ctf_dynbase = fp->ctf_base;
1524 hp->cth_flags &= ~CTF_F_COMPRESS;
1525
1526 src = (unsigned char *) ctfsect->cts_data + hdrsz;
1527 srclen = ctfsect->cts_size - hdrsz;
1528 dstlen = fp->ctf_size;
1529 fp->ctf_buf = fp->ctf_base;
1530
1531 if ((rc = uncompress (fp->ctf_base, &dstlen, src, srclen)) != Z_OK)
1532 {
1533 ctf_err_warn (NULL, 0, ECTF_DECOMPRESS, _("zlib inflate err: %s"),
1534 zError (rc));
1535 err = ECTF_DECOMPRESS;
1536 goto bad;
1537 }
1538
1539 if ((size_t) dstlen != fp->ctf_size)
1540 {
1541 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1542 _("zlib inflate short: got %lu of %lu bytes"),
1543 (unsigned long) dstlen, (unsigned long) fp->ctf_size);
1544 err = ECTF_CORRUPT;
1545 goto bad;
1546 }
1547 }
1548 else
1549 {
1550 if (_libctf_unlikely_ (ctfsect->cts_size < hdrsz + fp->ctf_size))
1551 {
1552 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1553 _("%lu byte long CTF dictionary overruns %lu byte long CTF section"),
1554 (unsigned long) ctfsect->cts_size,
1555 (unsigned long) (hdrsz + fp->ctf_size));
1556 err = ECTF_CORRUPT;
1557 goto bad;
1558 }
1559
1560 if (foreign_endian)
1561 {
1562 if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
1563 {
1564 err = ECTF_ZALLOC;
1565 goto bad;
1566 }
1567 fp->ctf_dynbase = fp->ctf_base;
1568 memcpy (fp->ctf_base, ((unsigned char *) ctfsect->cts_data) + hdrsz,
1569 fp->ctf_size);
1570 fp->ctf_buf = fp->ctf_base;
1571 }
1572 else
1573 {
1574 /* We are just using the section passed in -- but its header may
1575 be an old version. Point ctf_buf past the old header, and
1576 never touch it again. */
1577 fp->ctf_base = (unsigned char *) ctfsect->cts_data;
1578 fp->ctf_dynbase = NULL;
1579 fp->ctf_buf = fp->ctf_base + hdrsz;
1580 }
1581 }
1582
1583 /* Once we have uncompressed and validated the CTF data buffer, we can
1584 proceed with initializing the ctf_dict_t we allocated above.
1585
1586 Nothing that depends on buf or base should be set directly in this function
1587 before the init_types() call, because it may be reallocated during
1588 transparent upgrade if this recension of libctf is so configured: see
1589 ctf_set_base(). */
1590
1591 ctf_set_version (fp, hp, hp->cth_version);
1592 if (ctf_str_create_atoms (fp) < 0)
1593 {
1594 err = ENOMEM;
1595 goto bad;
1596 }
1597
1598 fp->ctf_parmax = CTF_MAX_PTYPE;
1599 memcpy (&fp->ctf_data, ctfsect, sizeof (ctf_sect_t));
1600
1601 if (symsect != NULL)
1602 {
1603 memcpy (&fp->ctf_symtab, symsect, sizeof (ctf_sect_t));
1604 memcpy (&fp->ctf_strtab, strsect, sizeof (ctf_sect_t));
1605 }
1606
1607 if (fp->ctf_data.cts_name != NULL)
1608 if ((fp->ctf_data.cts_name = strdup (fp->ctf_data.cts_name)) == NULL)
1609 {
1610 err = ENOMEM;
1611 goto bad;
1612 }
1613 if (fp->ctf_symtab.cts_name != NULL)
1614 if ((fp->ctf_symtab.cts_name = strdup (fp->ctf_symtab.cts_name)) == NULL)
1615 {
1616 err = ENOMEM;
1617 goto bad;
1618 }
1619 if (fp->ctf_strtab.cts_name != NULL)
1620 if ((fp->ctf_strtab.cts_name = strdup (fp->ctf_strtab.cts_name)) == NULL)
1621 {
1622 err = ENOMEM;
1623 goto bad;
1624 }
1625
1626 if (fp->ctf_data.cts_name == NULL)
1627 fp->ctf_data.cts_name = _CTF_NULLSTR;
1628 if (fp->ctf_symtab.cts_name == NULL)
1629 fp->ctf_symtab.cts_name = _CTF_NULLSTR;
1630 if (fp->ctf_strtab.cts_name == NULL)
1631 fp->ctf_strtab.cts_name = _CTF_NULLSTR;
1632
1633 if (strsect != NULL)
1634 {
1635 fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data;
1636 fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size;
1637 }
1638 fp->ctf_syn_ext_strtab = syn_strtab;
1639
1640 if (foreign_endian &&
1641 (err = ctf_flip (fp, hp, fp->ctf_buf, 0)) != 0)
1642 {
1643 /* We can be certain that ctf_flip() will have endian-flipped everything
1644 other than the types table when we return. In particular the header
1645 is fine, so set it, to allow freeing to use the usual code path. */
1646
1647 ctf_set_base (fp, hp, fp->ctf_base);
1648 goto bad;
1649 }
1650
1651 ctf_set_base (fp, hp, fp->ctf_base);
1652
1653 /* No need to do anything else for dynamic dicts: they do not support symbol
1654 lookups, and the type table is maintained in the dthashes. */
1655 if (fp->ctf_flags & LCTF_RDWR)
1656 {
1657 fp->ctf_refcnt = 1;
1658 return fp;
1659 }
1660
1661 if ((err = init_types (fp, hp)) != 0)
1662 goto bad;
1663
1664 /* Allocate and initialize the symtab translation table, pointed to by
1665 ctf_sxlate, and the corresponding index sections. This table may be too
1666 large for the actual size of the object and function info sections: if so,
1667 ctf_nsyms will be adjusted and the excess will never be used. It's
1668 possible to do indexed symbol lookups even without a symbol table, so check
1669 even in that case. Initially, we assume the symtab is native-endian: if it
1670 isn't, the caller will inform us later by calling ctf_symsect_endianness. */
1671 #ifdef WORDS_BIGENDIAN
1672 fp->ctf_symsect_little_endian = 0;
1673 #else
1674 fp->ctf_symsect_little_endian = 1;
1675 #endif
1676
1677 if (symsect != NULL)
1678 {
1679 fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
1680 fp->ctf_sxlate = malloc (fp->ctf_nsyms * sizeof (uint32_t));
1681
1682 if (fp->ctf_sxlate == NULL)
1683 {
1684 err = ENOMEM;
1685 goto bad;
1686 }
1687 }
1688
1689 if ((err = init_symtab (fp, hp, symsect)) != 0)
1690 goto bad;
1691
1692 ctf_set_ctl_hashes (fp);
1693
1694 if (symsect != NULL)
1695 {
1696 if (symsect->cts_entsize == sizeof (Elf64_Sym))
1697 (void) ctf_setmodel (fp, CTF_MODEL_LP64);
1698 else
1699 (void) ctf_setmodel (fp, CTF_MODEL_ILP32);
1700 }
1701 else
1702 (void) ctf_setmodel (fp, CTF_MODEL_NATIVE);
1703
1704 fp->ctf_refcnt = 1;
1705 return fp;
1706
1707 bad:
1708 ctf_set_open_errno (errp, err);
1709 ctf_err_warn_to_open (fp);
1710 ctf_dict_close (fp);
1711 return NULL;
1712 }
1713
1714 /* Bump the refcount on the specified CTF dict, to allow export of ctf_dict_t's
1715 from iterators that open and close the ctf_dict_t around the loop. (This
1716 does not extend their lifetime beyond that of the ctf_archive_t in which they
1717 are contained.) */
1718
1719 void
1720 ctf_ref (ctf_dict_t *fp)
1721 {
1722 fp->ctf_refcnt++;
1723 }
1724
1725 /* Close the specified CTF dict and free associated data structures. Note that
1726 ctf_dict_close() is a reference counted operation: if the specified file is
1727 the parent of other active dict, its reference count will be greater than one
1728 and it will be freed later when no active children exist. */
1729
1730 void
1731 ctf_dict_close (ctf_dict_t *fp)
1732 {
1733 ctf_dtdef_t *dtd, *ntd;
1734 ctf_dvdef_t *dvd, *nvd;
1735 ctf_in_flight_dynsym_t *did, *nid;
1736 ctf_err_warning_t *err, *nerr;
1737
1738 if (fp == NULL)
1739 return; /* Allow ctf_dict_close(NULL) to simplify caller code. */
1740
1741 ctf_dprintf ("ctf_dict_close(%p) refcnt=%u\n", (void *) fp, fp->ctf_refcnt);
1742
1743 if (fp->ctf_refcnt > 1)
1744 {
1745 fp->ctf_refcnt--;
1746 return;
1747 }
1748
1749 /* It is possible to recurse back in here, notably if dicts in the
1750 ctf_link_inputs or ctf_link_outputs cite this dict as a parent without
1751 using ctf_import_unref. Do nothing in that case. */
1752 if (fp->ctf_refcnt == 0)
1753 return;
1754
1755 fp->ctf_refcnt--;
1756 free (fp->ctf_dyncuname);
1757 free (fp->ctf_dynparname);
1758 if (fp->ctf_parent && !fp->ctf_parent_unreffed)
1759 ctf_dict_close (fp->ctf_parent);
1760
1761 for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
1762 {
1763 ntd = ctf_list_next (dtd);
1764 ctf_dtd_delete (fp, dtd);
1765 }
1766 ctf_dynhash_destroy (fp->ctf_dthash);
1767 if (fp->ctf_flags & LCTF_RDWR)
1768 {
1769 ctf_dynhash_destroy (fp->ctf_structs.ctn_writable);
1770 ctf_dynhash_destroy (fp->ctf_unions.ctn_writable);
1771 ctf_dynhash_destroy (fp->ctf_enums.ctn_writable);
1772 ctf_dynhash_destroy (fp->ctf_names.ctn_writable);
1773 }
1774 else
1775 {
1776 ctf_hash_destroy (fp->ctf_structs.ctn_readonly);
1777 ctf_hash_destroy (fp->ctf_unions.ctn_readonly);
1778 ctf_hash_destroy (fp->ctf_enums.ctn_readonly);
1779 ctf_hash_destroy (fp->ctf_names.ctn_readonly);
1780 }
1781
1782 for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
1783 {
1784 nvd = ctf_list_next (dvd);
1785 ctf_dvd_delete (fp, dvd);
1786 }
1787 ctf_dynhash_destroy (fp->ctf_dvhash);
1788
1789 ctf_dynhash_destroy (fp->ctf_symhash);
1790 free (fp->ctf_funcidx_sxlate);
1791 free (fp->ctf_objtidx_sxlate);
1792 ctf_dynhash_destroy (fp->ctf_objthash);
1793 ctf_dynhash_destroy (fp->ctf_funchash);
1794 free (fp->ctf_dynsymidx);
1795 ctf_dynhash_destroy (fp->ctf_dynsyms);
1796 for (did = ctf_list_next (&fp->ctf_in_flight_dynsyms); did != NULL; did = nid)
1797 {
1798 nid = ctf_list_next (did);
1799 ctf_list_delete (&fp->ctf_in_flight_dynsyms, did);
1800 free (did);
1801 }
1802
1803 ctf_str_free_atoms (fp);
1804 free (fp->ctf_tmp_typeslice);
1805
1806 if (fp->ctf_data.cts_name != _CTF_NULLSTR)
1807 free ((char *) fp->ctf_data.cts_name);
1808
1809 if (fp->ctf_symtab.cts_name != _CTF_NULLSTR)
1810 free ((char *) fp->ctf_symtab.cts_name);
1811
1812 if (fp->ctf_strtab.cts_name != _CTF_NULLSTR)
1813 free ((char *) fp->ctf_strtab.cts_name);
1814 else if (fp->ctf_data_mmapped)
1815 ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
1816
1817 free (fp->ctf_dynbase);
1818
1819 ctf_dynhash_destroy (fp->ctf_syn_ext_strtab);
1820 ctf_dynhash_destroy (fp->ctf_link_inputs);
1821 ctf_dynhash_destroy (fp->ctf_link_outputs);
1822 ctf_dynhash_destroy (fp->ctf_link_type_mapping);
1823 ctf_dynhash_destroy (fp->ctf_link_in_cu_mapping);
1824 ctf_dynhash_destroy (fp->ctf_link_out_cu_mapping);
1825 ctf_dynhash_destroy (fp->ctf_add_processing);
1826 ctf_dedup_fini (fp, NULL, 0);
1827 ctf_dynset_destroy (fp->ctf_dedup_atoms_alloc);
1828
1829 for (err = ctf_list_next (&fp->ctf_errs_warnings); err != NULL; err = nerr)
1830 {
1831 nerr = ctf_list_next (err);
1832 ctf_list_delete (&fp->ctf_errs_warnings, err);
1833 free (err->cew_text);
1834 free (err);
1835 }
1836
1837 free (fp->ctf_sxlate);
1838 free (fp->ctf_txlate);
1839 free (fp->ctf_ptrtab);
1840 free (fp->ctf_pptrtab);
1841
1842 free (fp->ctf_header);
1843 free (fp);
1844 }
1845
1846 /* Backward compatibility. */
1847 void
1848 ctf_file_close (ctf_file_t *fp)
1849 {
1850 ctf_dict_close (fp);
1851 }
1852
1853 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1854 archive, so closing one is just like closing an archive. */
1855 void
1856 ctf_close (ctf_archive_t *arc)
1857 {
1858 ctf_arc_close (arc);
1859 }
1860
1861 /* Get the CTF archive from which this ctf_dict_t is derived. */
1862 ctf_archive_t *
1863 ctf_get_arc (const ctf_dict_t *fp)
1864 {
1865 return fp->ctf_archive;
1866 }
1867
1868 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1869 ctfsect's data * after ctf_dict_close(), which is why we return the actual
1870 structure, not a pointer to it, since that is likely to become a pointer to
1871 freed data before the return value is used under the expected use case of
1872 ctf_getsect()/ ctf_dict_close()/free(). */
1873 ctf_sect_t
1874 ctf_getdatasect (const ctf_dict_t *fp)
1875 {
1876 return fp->ctf_data;
1877 }
1878
1879 ctf_sect_t
1880 ctf_getsymsect (const ctf_dict_t *fp)
1881 {
1882 return fp->ctf_symtab;
1883 }
1884
1885 ctf_sect_t
1886 ctf_getstrsect (const ctf_dict_t *fp)
1887 {
1888 return fp->ctf_strtab;
1889 }
1890
1891 /* Set the endianness of the symbol table attached to FP. */
1892 void
1893 ctf_symsect_endianness (ctf_dict_t *fp, int little_endian)
1894 {
1895 int old_endianness = fp->ctf_symsect_little_endian;
1896
1897 fp->ctf_symsect_little_endian = !!little_endian;
1898
1899 /* If we already have a symtab translation table, we need to repopulate it if
1900 our idea of the endianness has changed. */
1901
1902 if (old_endianness != fp->ctf_symsect_little_endian
1903 && fp->ctf_sxlate != NULL && fp->ctf_symtab.cts_data != NULL)
1904 assert (init_symtab (fp, fp->ctf_header, &fp->ctf_symtab) == 0);
1905 }
1906
1907 /* Return the CTF handle for the parent CTF dict, if one exists. Otherwise
1908 return NULL to indicate this dict has no imported parent. */
1909 ctf_dict_t *
1910 ctf_parent_dict (ctf_dict_t *fp)
1911 {
1912 return fp->ctf_parent;
1913 }
1914
1915 /* Backward compatibility. */
1916 ctf_dict_t *
1917 ctf_parent_file (ctf_dict_t *fp)
1918 {
1919 return ctf_parent_dict (fp);
1920 }
1921
1922 /* Return the name of the parent CTF dict, if one exists, or NULL otherwise. */
1923 const char *
1924 ctf_parent_name (ctf_dict_t *fp)
1925 {
1926 return fp->ctf_parname;
1927 }
1928
1929 /* Set the parent name. It is an error to call this routine without calling
1930 ctf_import() at some point. */
1931 int
1932 ctf_parent_name_set (ctf_dict_t *fp, const char *name)
1933 {
1934 if (fp->ctf_dynparname != NULL)
1935 free (fp->ctf_dynparname);
1936
1937 if ((fp->ctf_dynparname = strdup (name)) == NULL)
1938 return (ctf_set_errno (fp, ENOMEM));
1939 fp->ctf_parname = fp->ctf_dynparname;
1940 return 0;
1941 }
1942
1943 /* Return the name of the compilation unit this CTF file applies to. Usually
1944 non-NULL only for non-parent dicts. */
1945 const char *
1946 ctf_cuname (ctf_dict_t *fp)
1947 {
1948 return fp->ctf_cuname;
1949 }
1950
1951 /* Set the compilation unit name. */
1952 int
1953 ctf_cuname_set (ctf_dict_t *fp, const char *name)
1954 {
1955 if (fp->ctf_dyncuname != NULL)
1956 free (fp->ctf_dyncuname);
1957
1958 if ((fp->ctf_dyncuname = strdup (name)) == NULL)
1959 return (ctf_set_errno (fp, ENOMEM));
1960 fp->ctf_cuname = fp->ctf_dyncuname;
1961 return 0;
1962 }
1963
1964 /* Import the types from the specified parent dict by storing a pointer to it in
1965 ctf_parent and incrementing its reference count. Only one parent is allowed:
1966 if a parent already exists, it is replaced by the new parent. The pptrtab
1967 is wiped, and will be refreshed by the next ctf_lookup_by_name call. */
1968 int
1969 ctf_import (ctf_dict_t *fp, ctf_dict_t *pfp)
1970 {
1971 if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
1972 return (ctf_set_errno (fp, EINVAL));
1973
1974 if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
1975 return (ctf_set_errno (fp, ECTF_DMODEL));
1976
1977 if (fp->ctf_parent && !fp->ctf_parent_unreffed)
1978 ctf_dict_close (fp->ctf_parent);
1979 fp->ctf_parent = NULL;
1980
1981 free (fp->ctf_pptrtab);
1982 fp->ctf_pptrtab = NULL;
1983 fp->ctf_pptrtab_len = 0;
1984 fp->ctf_pptrtab_typemax = 0;
1985
1986 if (pfp != NULL)
1987 {
1988 int err;
1989
1990 if (fp->ctf_parname == NULL)
1991 if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
1992 return err;
1993
1994 fp->ctf_flags |= LCTF_CHILD;
1995 pfp->ctf_refcnt++;
1996 fp->ctf_parent_unreffed = 0;
1997 }
1998
1999 fp->ctf_parent = pfp;
2000 return 0;
2001 }
2002
2003 /* Like ctf_import, but does not increment the refcount on the imported parent
2004 or close it at any point: as a result it can go away at any time and the
2005 caller must do all freeing itself. Used internally to avoid refcount
2006 loops. */
2007 int
2008 ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp)
2009 {
2010 if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
2011 return (ctf_set_errno (fp, EINVAL));
2012
2013 if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
2014 return (ctf_set_errno (fp, ECTF_DMODEL));
2015
2016 if (fp->ctf_parent && !fp->ctf_parent_unreffed)
2017 ctf_dict_close (fp->ctf_parent);
2018 fp->ctf_parent = NULL;
2019
2020 free (fp->ctf_pptrtab);
2021 fp->ctf_pptrtab = NULL;
2022 fp->ctf_pptrtab_len = 0;
2023 fp->ctf_pptrtab_typemax = 0;
2024 if (pfp != NULL)
2025 {
2026 int err;
2027
2028 if (fp->ctf_parname == NULL)
2029 if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
2030 return err;
2031
2032 fp->ctf_flags |= LCTF_CHILD;
2033 fp->ctf_parent_unreffed = 1;
2034 }
2035
2036 fp->ctf_parent = pfp;
2037 return 0;
2038 }
2039
2040 /* Set the data model constant for the CTF dict. */
2041 int
2042 ctf_setmodel (ctf_dict_t *fp, int model)
2043 {
2044 const ctf_dmodel_t *dp;
2045
2046 for (dp = _libctf_models; dp->ctd_name != NULL; dp++)
2047 {
2048 if (dp->ctd_code == model)
2049 {
2050 fp->ctf_dmodel = dp;
2051 return 0;
2052 }
2053 }
2054
2055 return (ctf_set_errno (fp, EINVAL));
2056 }
2057
2058 /* Return the data model constant for the CTF dict. */
2059 int
2060 ctf_getmodel (ctf_dict_t *fp)
2061 {
2062 return fp->ctf_dmodel->ctd_code;
2063 }
2064
2065 /* The caller can hang an arbitrary pointer off each ctf_dict_t using this
2066 function. */
2067 void
2068 ctf_setspecific (ctf_dict_t *fp, void *data)
2069 {
2070 fp->ctf_specific = data;
2071 }
2072
2073 /* Retrieve the arbitrary pointer again. */
2074 void *
2075 ctf_getspecific (ctf_dict_t *fp)
2076 {
2077 return fp->ctf_specific;
2078 }