]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - libctf/ctf-open.c
[gdb/testsuite] Fix gdb.arch/amd64-disp-step-avx.exp on x86_64-freebsd
[thirdparty/binutils-gdb.git] / libctf / ctf-open.c
CommitLineData
72f33921 1/* Opening CTF files.
e8e7cf2a 2 Copyright (C) 2019-2025 Free Software Foundation, Inc.
72f33921
NA
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>
72f33921
NA
25#include "swap.h"
26#include <bfd.h>
27#include <zlib.h>
28
72f33921
NA
29static 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
35const char _CTF_SECTION[] = ".ctf";
36const char _CTF_NULLSTR[] = "";
37
38/* Version-sensitive accessors. */
39
40static uint32_t
41get_kind_v1 (uint32_t info)
42{
43 return (CTF_V1_INFO_KIND (info));
44}
45
46static uint32_t
47get_root_v1 (uint32_t info)
48{
49 return (CTF_V1_INFO_ISROOT (info));
50}
51
52static uint32_t
53get_vlen_v1 (uint32_t info)
54{
55 return (CTF_V1_INFO_VLEN (info));
56}
57
58static uint32_t
59get_kind_v2 (uint32_t info)
60{
61 return (CTF_V2_INFO_KIND (info));
62}
63
64static uint32_t
65get_root_v2 (uint32_t info)
66{
67 return (CTF_V2_INFO_ISROOT (info));
68}
69
70static uint32_t
71get_vlen_v2 (uint32_t info)
72{
73 return (CTF_V2_INFO_VLEN (info));
74}
75
76static inline ssize_t
139633c3 77get_ctt_size_common (const ctf_dict_t *fp _libctf_unused_,
72f33921
NA
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
104static ssize_t
139633c3 105get_ctt_size_v1 (const ctf_dict_t *fp, const ctf_type_t *tp,
72f33921
NA
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
118static ssize_t
139633c3 119get_ctt_size_v2_unconverted (const ctf_dict_t *fp, const ctf_type_t *tp,
72f33921
NA
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
130static ssize_t
139633c3 131get_ctt_size_v2 (const ctf_dict_t *fp, const ctf_type_t *tp,
72f33921
NA
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
140static ssize_t
139633c3 141get_vbytes_common (ctf_dict_t *fp, unsigned short kind,
926c9e76 142 ssize_t size _libctf_unused_, size_t vlen)
72f33921
NA
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:
7cee1826 150 return (sizeof (ctf_slice_t));
72f33921
NA
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:
926c9e76
NA
162 ctf_set_errno (fp, ECTF_CORRUPT);
163 ctf_err_warn (fp, 0, 0, _("detected invalid CTF kind: %x"), kind);
164 return -1;
72f33921
NA
165 }
166}
167
168static ssize_t
139633c3 169get_vbytes_v1 (ctf_dict_t *fp, unsigned short kind, ssize_t size, size_t vlen)
72f33921
NA
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
926c9e76 185 return (get_vbytes_common (fp, kind, size, vlen));
72f33921
NA
186}
187
188static ssize_t
139633c3 189get_vbytes_v2 (ctf_dict_t *fp, unsigned short kind, ssize_t size, size_t vlen)
72f33921
NA
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
926c9e76 205 return (get_vbytes_common (fp, kind, size, vlen));
72f33921
NA
206}
207
139633c3 208static const ctf_dictops_t ctf_dictops[] = {
72f33921
NA
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
1136c379
NA
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
53651de8
NA
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. */
72f33921
NA
233
234static int
1136c379 235init_symtab (ctf_dict_t *fp, const ctf_header_t *hp, const ctf_sect_t *sp)
72f33921 236{
1136c379
NA
237 const unsigned char *symp;
238 int skip_func_info = 0;
239 int i;
72f33921 240 uint32_t *xp = fp->ctf_sxlate;
174fe10c 241 uint32_t *xend = PTR_ADD (xp, fp->ctf_nsyms);
72f33921
NA
242
243 uint32_t objtoff = hp->cth_objtoff;
244 uint32_t funcoff = hp->cth_funcoff;
245
1136c379
NA
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++)
72f33921 274 {
1136c379 275 ctf_link_sym_t sym;
72f33921 276
1136c379
NA
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 }
72f33921 294
53651de8
NA
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. */
1136c379 299 if (ctf_symtab_skippable (&sym))
72f33921
NA
300 {
301 *xp = -1u;
302 continue;
303 }
304
1136c379 305 switch (sym.st_type)
72f33921
NA
306 {
307 case STT_OBJECT:
1136c379 308 if (fp->ctf_objtidx_names || objtoff >= hp->cth_funcoff)
72f33921
NA
309 {
310 *xp = -1u;
311 break;
312 }
313
314 *xp = objtoff;
315 objtoff += sizeof (uint32_t);
316 break;
317
318 case STT_FUNC:
1136c379
NA
319 if (fp->ctf_funcidx_names || funcoff >= hp->cth_objtidxoff
320 || skip_func_info)
72f33921
NA
321 {
322 *xp = -1u;
323 break;
324 }
325
326 *xp = funcoff;
1136c379 327 funcoff += sizeof (uint32_t);
72f33921
NA
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
fd55eae8 340/* Reset the CTF base pointer and derive the buf pointer from it, initializing
139633c3 341 everything in the ctf_dict that depends on the base or buf pointers.
fd55eae8
NA
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. */
72f33921
NA
346
347static void
139633c3 348ctf_set_base (ctf_dict_t *fp, const ctf_header_t *hp, unsigned char *base)
72f33921 349{
fd55eae8 350 fp->ctf_buf = base + (fp->ctf_buf - fp->ctf_base);
72f33921 351 fp->ctf_base = base;
72f33921
NA
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
139633c3
NA
360 /* If we have a parent dict name and label, store the relocated string
361 pointers in the CTF dict for easy access later. */
72f33921
NA
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);
fd55eae8
NA
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,
72f33921
NA
379 fp->ctf_parlabel ? fp->ctf_parlabel : "<NULL>");
380}
381
72f33921
NA
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
388static void
139633c3 389ctf_set_version (ctf_dict_t *fp, ctf_header_t *cth, int ctf_version)
72f33921
NA
390{
391 fp->ctf_version = ctf_version;
392 cth->cth_version = ctf_version;
139633c3 393 fp->ctf_dictops = &ctf_dictops[ctf_version];
72f33921
NA
394}
395
fd55eae8
NA
396
397/* Upgrade the header to CTF_VERSION_3. The upgrade is done in-place. */
398static void
399upgrade_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;
2db912ba
NA
407 hp->cth_funcidxoff = hp->cth_varoff; /* No index sections. */
408 hp->cth_objtidxoff = hp->cth_funcidxoff;
fd55eae8
NA
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.
72f33921
NA
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
2db912ba
NA
421 Sections not checked here due to nonexistence or nonpopulated state in older
422 formats: objtidx, funcidx.
423
72f33921
NA
424 Type kinds not checked here due to nonexistence in older formats:
425 CTF_K_SLICE. */
426static int
139633c3 427upgrade_types_v1 (ctf_dict_t *fp, ctf_header_t *cth)
72f33921
NA
428{
429 const ctf_type_v1_t *tbuf;
430 const ctf_type_v1_t *tend;
fd55eae8 431 unsigned char *ctf_base, *old_ctf_base = (unsigned char *) fp->ctf_dynbase;
72f33921
NA
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;
72f33921
NA
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
7bc376bb 441 /* Much like init_static_types(), this is a two-pass process.
72f33921
NA
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);
926c9e76 459 vbytes = get_vbytes_v1 (fp, kind, size, vlen);
72f33921
NA
460
461 get_ctt_size_v2_unconverted (fp, (const ctf_type_t *) tp, NULL,
462 &v2increment);
926c9e76 463 v2bytes = get_vbytes_v2 (fp, kind, size, vlen);
72f33921
NA
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
fd55eae8
NA
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
72f33921
NA
475 as-yet-untranslated type info. */
476
de07e349 477 if ((ctf_base = malloc (fp->ctf_size + increase)) == NULL)
72f33921
NA
478 return ECTF_ZALLOC;
479
fd55eae8
NA
480 /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
481 never use it and it is unconverted. */
72f33921 482
fd55eae8
NA
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);
72f33921 486
fd55eae8
NA
487 memset (ctf_base + cth->cth_typeoff, 0, cth->cth_stroff - cth->cth_typeoff
488 + increase);
72f33921 489
fd55eae8 490 cth->cth_stroff += increase;
72f33921 491 fp->ctf_size += increase;
fd55eae8
NA
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);
72f33921 497
fd55eae8 498 t2buf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff);
72f33921
NA
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);
926c9e76 516 vbytes = get_vbytes_v1 (fp, kind, size, vlen);
72f33921
NA
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:
a0486bac 539 if ((size_t) size <= CTF_MAX_SIZE)
72f33921
NA
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);
926c9e76 550 v2bytes = get_vbytes_v2 (fp, kind, v2size, vlen);
72f33921
NA
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
7bc376bb 639 or at read time, in init_static_types().) */
72f33921 640
fd55eae8 641 assert ((size_t) t2p - (size_t) fp->ctf_buf == cth->cth_stroff);
72f33921 642
fd55eae8 643 ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3);
de07e349 644 free (old_ctf_base);
72f33921
NA
645
646 return 0;
647}
648
fd55eae8
NA
649/* Upgrade from any earlier version. */
650static int
139633c3 651upgrade_types (ctf_dict_t *fp, ctf_header_t *cth)
fd55eae8
NA
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
6e09d4a6
NA
673static int
674init_static_types_internal (ctf_dict_t *fp, ctf_header_t *cth,
675 ctf_dynset_t *all_enums);
676
8a60c930
NA
677/* Populate statically-defined types (those loaded from a saved buffer).
678
679 Initialize the type ID translation table with the byte offset of each type,
72f33921
NA
680 and initialize the hash tables of each named type. Upgrade the type table to
681 the latest supported representation in the process, if needed, and if this
6e09d4a6
NA
682 recension of libctf supports upgrading.
683
e34b3bde
NA
684 Returns zero on success and a *positive* ECTF_* or errno value on error.
685
6e09d4a6
NA
686 This is a wrapper to simplify memory allocation on error in the _internal
687 function that does all the actual work. */
72f33921
NA
688
689static int
8a60c930 690init_static_types (ctf_dict_t *fp, ctf_header_t *cth)
6e09d4a6
NA
691{
692 ctf_dynset_t *all_enums;
693 int err;
694
695 if ((all_enums = ctf_dynset_create (htab_hash_pointer, htab_eq_pointer,
696 NULL)) == NULL)
697 return ENOMEM;
698
699 err = init_static_types_internal (fp, cth, all_enums);
700 ctf_dynset_destroy (all_enums);
701 return err;
702}
703
704static int
705init_static_types_internal (ctf_dict_t *fp, ctf_header_t *cth,
706 ctf_dynset_t *all_enums)
72f33921
NA
707{
708 const ctf_type_t *tbuf;
709 const ctf_type_t *tend;
710
711 unsigned long pop[CTF_K_MAX + 1] = { 0 };
6e09d4a6 712 int pop_enumerators = 0;
72f33921 713 const ctf_type_t *tp;
78f28b89 714 uint32_t id;
72f33921 715 uint32_t *xp;
2ba5ec13 716 unsigned long typemax = 0;
6e09d4a6
NA
717 ctf_next_t *i = NULL;
718 void *k;
72f33921 719
139633c3
NA
720 /* We determine whether the dict is a child or a parent based on the value of
721 cth_parname. */
72f33921
NA
722
723 int child = cth->cth_parname != 0;
724 int nlstructs = 0, nlunions = 0;
725 int err;
726
727 if (_libctf_unlikely_ (fp->ctf_version == CTF_VERSION_1))
728 {
729 int err;
730 if ((err = upgrade_types (fp, cth)) != 0)
731 return err; /* Upgrade failed. */
732 }
733
734 tbuf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff);
735 tend = (ctf_type_t *) (fp->ctf_buf + cth->cth_stroff);
736
6e09d4a6
NA
737 /* We make two passes through the entire type section, and one third pass
738 through part of it. In this first pass, we count the number of each type
739 and type-like identifier (like enumerators) and the total number of
740 types. */
72f33921 741
2ba5ec13 742 for (tp = tbuf; tp < tend; typemax++)
72f33921
NA
743 {
744 unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
745 unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
746 ssize_t size, increment, vbytes;
747
748 (void) ctf_get_ctt_size (fp, tp, &size, &increment);
749 vbytes = LCTF_VBYTES (fp, kind, size, vlen);
750
751 if (vbytes < 0)
752 return ECTF_CORRUPT;
753
2484ca43
NA
754 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
755 so bump that population count too. */
72f33921 756 if (kind == CTF_K_FORWARD)
2484ca43 757 pop[tp->ctt_type]++;
72f33921 758
72f33921
NA
759 tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
760 pop[kind]++;
6e09d4a6
NA
761
762 if (kind == CTF_K_ENUM)
763 pop_enumerators += vlen;
72f33921
NA
764 }
765
766 if (child)
767 {
139633c3 768 ctf_dprintf ("CTF dict %p is a child\n", (void *) fp);
72f33921
NA
769 fp->ctf_flags |= LCTF_CHILD;
770 }
771 else
139633c3 772 ctf_dprintf ("CTF dict %p is a parent\n", (void *) fp);
72f33921
NA
773
774 /* Now that we've counted up the number of each type, we can allocate
775 the hash tables, type translation table, and pointer table. */
776
54a02191
NA
777 if ((fp->ctf_structs
778 = ctf_dynhash_create_sized (pop[CTF_K_STRUCT], ctf_hash_string,
779 ctf_hash_eq_string, NULL, NULL)) == NULL)
72f33921
NA
780 return ENOMEM;
781
54a02191
NA
782 if ((fp->ctf_unions
783 = ctf_dynhash_create_sized (pop[CTF_K_UNION], ctf_hash_string,
784 ctf_hash_eq_string, NULL, NULL)) == NULL)
72f33921
NA
785 return ENOMEM;
786
54a02191
NA
787 if ((fp->ctf_enums
788 = ctf_dynhash_create_sized (pop[CTF_K_ENUM], ctf_hash_string,
789 ctf_hash_eq_string, NULL, NULL)) == NULL)
72f33921
NA
790 return ENOMEM;
791
54a02191
NA
792 if ((fp->ctf_names
793 = ctf_dynhash_create_sized (pop[CTF_K_UNKNOWN] +
794 pop[CTF_K_INTEGER] +
795 pop[CTF_K_FLOAT] +
796 pop[CTF_K_FUNCTION] +
797 pop[CTF_K_TYPEDEF] +
798 pop[CTF_K_POINTER] +
799 pop[CTF_K_VOLATILE] +
800 pop[CTF_K_CONST] +
6e09d4a6
NA
801 pop[CTF_K_RESTRICT] +
802 pop_enumerators,
54a02191
NA
803 ctf_hash_string,
804 ctf_hash_eq_string, NULL, NULL)) == NULL)
72f33921
NA
805 return ENOMEM;
806
6e09d4a6
NA
807 if ((fp->ctf_conflicting_enums
808 = ctf_dynset_create (htab_hash_string, htab_eq_string, NULL)) == NULL)
809 return ENOMEM;
810
8a60c930
NA
811 /* The ptrtab and txlate can be appropriately sized for precisely this set
812 of types: the txlate because it is only used to look up static types,
813 so dynamic types added later will never go through it, and the ptrtab
814 because later-added types will call grow_ptrtab() automatically, as
815 needed. */
816
2ba5ec13
NA
817 fp->ctf_txlate = malloc (sizeof (uint32_t) * (typemax + 1));
818 fp->ctf_ptrtab_len = typemax + 1;
de07e349 819 fp->ctf_ptrtab = malloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
8a60c930 820 fp->ctf_stypes = typemax;
72f33921
NA
821
822 if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
823 return ENOMEM; /* Memory allocation failed. */
824
825 xp = fp->ctf_txlate;
826 *xp++ = 0; /* Type id 0 is used as a sentinel value. */
827
2ba5ec13
NA
828 memset (fp->ctf_txlate, 0, sizeof (uint32_t) * (typemax + 1));
829 memset (fp->ctf_ptrtab, 0, sizeof (uint32_t) * (typemax + 1));
72f33921
NA
830
831 /* In the second pass through the types, we fill in each entry of the
2ba5ec13 832 type and pointer tables and add names to the appropriate hashes.
72f33921 833
6e09d4a6
NA
834 (Not all names are added in this pass, only type names. See below.)
835
2ba5ec13
NA
836 Bump ctf_typemax as we go, but keep it one higher than normal, so that
837 the type being read in is considered a valid type and it is at least
838 barely possible to run simple lookups on it. */
839
840 for (id = 1, fp->ctf_typemax = 1, tp = tbuf; tp < tend; xp++, id++, fp->ctf_typemax++)
72f33921
NA
841 {
842 unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
fe4c2d55 843 unsigned short isroot = LCTF_INFO_ISROOT (fp, tp->ctt_info);
72f33921
NA
844 unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
845 ssize_t size, increment, vbytes;
846
847 const char *name;
848
849 (void) ctf_get_ctt_size (fp, tp, &size, &increment);
850 name = ctf_strptr (fp, tp->ctt_name);
926c9e76 851 /* Cannot fail: shielded by call in loop above. */
72f33921
NA
852 vbytes = LCTF_VBYTES (fp, kind, size, vlen);
853
2ba5ec13
NA
854 *xp = (uint32_t) ((uintptr_t) tp - (uintptr_t) fp->ctf_buf);
855
72f33921
NA
856 switch (kind)
857 {
49da556c 858 case CTF_K_UNKNOWN:
72f33921
NA
859 case CTF_K_INTEGER:
860 case CTF_K_FLOAT:
2ba5ec13
NA
861 {
862 ctf_id_t existing;
863 ctf_encoding_t existing_en;
864 ctf_encoding_t this_en;
865
866 if (!isroot)
867 break;
868
869 /* Names are reused by bitfields, which are differentiated by
870 their encodings. So check for the type already existing, and
871 iff the new type is a root-visible non-bitfield, replace the
872 old one. It's a little hard to figure out whether a type is
873 a non-bitfield without already knowing that type's native
874 width, but we can converge on it by replacing an existing
875 type as long as the new type is zero-offset and has a
876 bit-width wider than the existing one, since the native type
877 must necessarily have a bit-width at least as wide as any
878 bitfield based on it. */
879
880 if (((existing = ctf_dynhash_lookup_type (fp->ctf_names, name)) == 0)
881 || ctf_type_encoding (fp, existing, &existing_en) != 0
882 || (ctf_type_encoding (fp, LCTF_INDEX_TO_TYPE (fp, id, child), &this_en) == 0
883 && this_en.cte_offset == 0
884 && (existing_en.cte_offset != 0
885 || existing_en.cte_bits < this_en.cte_bits)))
886 {
887 err = ctf_dynhash_insert_type (fp, fp->ctf_names,
888 LCTF_INDEX_TO_TYPE (fp, id, child),
889 tp->ctt_name);
890 if (err != 0)
e34b3bde 891 return err * -1;
2ba5ec13
NA
892 }
893 break;
894 }
72f33921
NA
895
896 /* These kinds have no name, so do not need interning into any
897 hashtables. */
898 case CTF_K_ARRAY:
899 case CTF_K_SLICE:
900 break;
901
902 case CTF_K_FUNCTION:
fe4c2d55
NA
903 if (!isroot)
904 break;
905
54a02191
NA
906 err = ctf_dynhash_insert_type (fp, fp->ctf_names,
907 LCTF_INDEX_TO_TYPE (fp, id, child),
908 tp->ctt_name);
d851ecd3 909 if (err != 0)
e34b3bde 910 return err * -1;
72f33921
NA
911 break;
912
913 case CTF_K_STRUCT:
fe4c2d55
NA
914 if (size >= CTF_LSTRUCT_THRESH)
915 nlstructs++;
916
917 if (!isroot)
918 break;
919
54a02191
NA
920 err = ctf_dynhash_insert_type (fp, fp->ctf_structs,
921 LCTF_INDEX_TO_TYPE (fp, id, child),
922 tp->ctt_name);
72f33921 923
d851ecd3 924 if (err != 0)
e34b3bde 925 return err * -1;
72f33921 926
72f33921
NA
927 break;
928
929 case CTF_K_UNION:
fe4c2d55
NA
930 if (size >= CTF_LSTRUCT_THRESH)
931 nlunions++;
932
933 if (!isroot)
934 break;
935
54a02191
NA
936 err = ctf_dynhash_insert_type (fp, fp->ctf_unions,
937 LCTF_INDEX_TO_TYPE (fp, id, child),
938 tp->ctt_name);
72f33921 939
d851ecd3 940 if (err != 0)
e34b3bde 941 return err * -1;
72f33921
NA
942 break;
943
944 case CTF_K_ENUM:
6e09d4a6
NA
945 {
946 if (!isroot)
947 break;
fe4c2d55 948
6e09d4a6
NA
949 err = ctf_dynhash_insert_type (fp, fp->ctf_enums,
950 LCTF_INDEX_TO_TYPE (fp, id, child),
951 tp->ctt_name);
72f33921 952
6e09d4a6 953 if (err != 0)
e34b3bde 954 return err * -1;
6e09d4a6
NA
955
956 /* Remember all enums for later rescanning. */
957
958 err = ctf_dynset_insert (all_enums, (void *) (ptrdiff_t)
959 LCTF_INDEX_TO_TYPE (fp, id, child));
960 if (err != 0)
e34b3bde 961 return err * -1;
6e09d4a6
NA
962 break;
963 }
72f33921
NA
964
965 case CTF_K_TYPEDEF:
fe4c2d55
NA
966 if (!isroot)
967 break;
968
54a02191
NA
969 err = ctf_dynhash_insert_type (fp, fp->ctf_names,
970 LCTF_INDEX_TO_TYPE (fp, id, child),
971 tp->ctt_name);
d851ecd3 972 if (err != 0)
e34b3bde 973 return err * -1;
72f33921
NA
974 break;
975
976 case CTF_K_FORWARD:
676c3ecb 977 {
54a02191 978 ctf_dynhash_t *h = ctf_name_table (fp, tp->ctt_type);
fe4c2d55
NA
979
980 if (!isroot)
981 break;
982
676c3ecb
NA
983 /* Only insert forward tags into the given hash if the type or tag
984 name is not already present. */
54a02191 985 if (ctf_dynhash_lookup_type (h, name) == 0)
676c3ecb 986 {
54a02191
NA
987 err = ctf_dynhash_insert_type (fp, h, LCTF_INDEX_TO_TYPE (fp, id, child),
988 tp->ctt_name);
676c3ecb 989 if (err != 0)
e34b3bde 990 return err * -1;
676c3ecb
NA
991 }
992 break;
993 }
72f33921
NA
994
995 case CTF_K_POINTER:
139633c3
NA
996 /* If the type referenced by the pointer is in this CTF dict, then
997 store the index of the pointer type in fp->ctf_ptrtab[ index of
998 referenced type ]. */
72f33921
NA
999
1000 if (LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child
1001 && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
1002 fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = id;
1003 /*FALLTHRU*/
1004
1005 case CTF_K_VOLATILE:
1006 case CTF_K_CONST:
1007 case CTF_K_RESTRICT:
fe4c2d55
NA
1008 if (!isroot)
1009 break;
1010
54a02191
NA
1011 err = ctf_dynhash_insert_type (fp, fp->ctf_names,
1012 LCTF_INDEX_TO_TYPE (fp, id, child),
1013 tp->ctt_name);
d851ecd3 1014 if (err != 0)
e34b3bde 1015 return err * -1;
72f33921 1016 break;
0b4fa56e 1017 default:
926c9e76 1018 ctf_err_warn (fp, 0, ECTF_CORRUPT,
54a02191 1019 _("init_static_types(): unhandled CTF kind: %x"), kind);
0b4fa56e 1020 return ECTF_CORRUPT;
72f33921 1021 }
72f33921
NA
1022 tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
1023 }
2ba5ec13
NA
1024 fp->ctf_typemax--;
1025 assert (fp->ctf_typemax == typemax);
72f33921
NA
1026
1027 ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax);
6e09d4a6 1028
6da92674
NA
1029 /* In the third pass, we traverse the enums we spotted earlier and track all
1030 the enumeration constants to aid in future detection of duplicates.
6e09d4a6
NA
1031
1032 Doing this in a third pass is necessary to avoid the case where an
1033 enum appears with a constant FOO, then later a type named FOO appears,
1034 too late to spot the conflict by checking the enum's constants. */
1035
1036 while ((err = ctf_dynset_next (all_enums, &i, &k)) == 0)
1037 {
1038 ctf_id_t enum_id = (uintptr_t) k;
1039 ctf_next_t *i_constants = NULL;
1040 const char *cte_name;
1041
1042 while ((cte_name = ctf_enum_next (fp, enum_id, &i_constants, NULL)) != NULL)
1043 {
6da92674 1044 if (ctf_track_enumerator (fp, enum_id, cte_name) < 0)
6e09d4a6 1045 {
6da92674
NA
1046 ctf_next_destroy (i_constants);
1047 ctf_next_destroy (i);
1048 return ctf_errno (fp);
6e09d4a6 1049 }
6e09d4a6
NA
1050 }
1051 if (ctf_errno (fp) != ECTF_NEXT_END)
1052 {
1053 ctf_next_destroy (i);
1054 return ctf_errno (fp);
1055 }
1056 }
1057 if (err != ECTF_NEXT_END)
1058 return err;
1059
54a02191
NA
1060 ctf_dprintf ("%zu enum names hashed\n",
1061 ctf_dynhash_elements (fp->ctf_enums));
6e09d4a6
NA
1062 ctf_dprintf ("%zu conflicting enumerators identified\n",
1063 ctf_dynset_elements (fp->ctf_conflicting_enums));
54a02191
NA
1064 ctf_dprintf ("%zu struct names hashed (%d long)\n",
1065 ctf_dynhash_elements (fp->ctf_structs), nlstructs);
1066 ctf_dprintf ("%zu union names hashed (%d long)\n",
1067 ctf_dynhash_elements (fp->ctf_unions), nlunions);
6e09d4a6 1068 ctf_dprintf ("%zu base type names and identifiers hashed\n",
54a02191 1069 ctf_dynhash_elements (fp->ctf_names));
72f33921 1070
72f33921
NA
1071 return 0;
1072}
1073
1074/* Endianness-flipping routines.
1075
1076 We flip everything, mindlessly, even 1-byte entities, so that future
1077 expansions do not require changes to this code. */
1078
72f33921
NA
1079/* Flip the endianness of the CTF header. */
1080
faf5e6ac
NA
1081void
1082ctf_flip_header (ctf_header_t *cth)
72f33921
NA
1083{
1084 swap_thing (cth->cth_preamble.ctp_magic);
1085 swap_thing (cth->cth_preamble.ctp_version);
1086 swap_thing (cth->cth_preamble.ctp_flags);
1087 swap_thing (cth->cth_parlabel);
1088 swap_thing (cth->cth_parname);
fd55eae8 1089 swap_thing (cth->cth_cuname);
72f33921
NA
1090 swap_thing (cth->cth_objtoff);
1091 swap_thing (cth->cth_funcoff);
2db912ba
NA
1092 swap_thing (cth->cth_objtidxoff);
1093 swap_thing (cth->cth_funcidxoff);
72f33921
NA
1094 swap_thing (cth->cth_varoff);
1095 swap_thing (cth->cth_typeoff);
1096 swap_thing (cth->cth_stroff);
1097 swap_thing (cth->cth_strlen);
1098}
1099
1100/* Flip the endianness of the label section, an array of ctf_lblent_t. */
1101
1102static void
1103flip_lbls (void *start, size_t len)
1104{
1105 ctf_lblent_t *lbl = start;
5ae6af75 1106 ssize_t i;
72f33921 1107
5ae6af75 1108 for (i = len / sizeof (struct ctf_lblent); i > 0; lbl++, i--)
72f33921
NA
1109 {
1110 swap_thing (lbl->ctl_label);
1111 swap_thing (lbl->ctl_type);
1112 }
1113}
1114
2db912ba 1115/* Flip the endianness of the data-object or function sections or their indexes,
1136c379 1116 all arrays of uint32_t. */
72f33921
NA
1117
1118static void
1119flip_objts (void *start, size_t len)
1120{
1121 uint32_t *obj = start;
5ae6af75 1122 ssize_t i;
72f33921 1123
5ae6af75 1124 for (i = len / sizeof (uint32_t); i > 0; obj++, i--)
72f33921
NA
1125 swap_thing (*obj);
1126}
1127
1128/* Flip the endianness of the variable section, an array of ctf_varent_t. */
1129
1130static void
1131flip_vars (void *start, size_t len)
1132{
1133 ctf_varent_t *var = start;
5ae6af75 1134 ssize_t i;
72f33921 1135
5ae6af75 1136 for (i = len / sizeof (struct ctf_varent); i > 0; var++, i--)
72f33921
NA
1137 {
1138 swap_thing (var->ctv_name);
1139 swap_thing (var->ctv_type);
1140 }
1141}
1142
1143/* Flip the endianness of the type section, a tagged array of ctf_type or
1144 ctf_stype followed by variable data. */
1145
1146static int
faf5e6ac 1147flip_types (ctf_dict_t *fp, void *start, size_t len, int to_foreign)
72f33921
NA
1148{
1149 ctf_type_t *t = start;
1150
1151 while ((uintptr_t) t < ((uintptr_t) start) + len)
1152 {
faf5e6ac
NA
1153 uint32_t kind;
1154 size_t size;
1155 uint32_t vlen;
1156 size_t vbytes;
1157
1158 if (to_foreign)
1159 {
1160 kind = CTF_V2_INFO_KIND (t->ctt_info);
1161 size = t->ctt_size;
1162 vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1163 vbytes = get_vbytes_v2 (fp, kind, size, vlen);
1164 }
1165
72f33921
NA
1166 swap_thing (t->ctt_name);
1167 swap_thing (t->ctt_info);
1168 swap_thing (t->ctt_size);
1169
faf5e6ac
NA
1170 if (!to_foreign)
1171 {
1172 kind = CTF_V2_INFO_KIND (t->ctt_info);
1173 size = t->ctt_size;
1174 vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1175 vbytes = get_vbytes_v2 (fp, kind, size, vlen);
1176 }
72f33921
NA
1177
1178 if (_libctf_unlikely_ (size == CTF_LSIZE_SENT))
1179 {
faf5e6ac
NA
1180 if (to_foreign)
1181 size = CTF_TYPE_LSIZE (t);
1182
72f33921
NA
1183 swap_thing (t->ctt_lsizehi);
1184 swap_thing (t->ctt_lsizelo);
faf5e6ac
NA
1185
1186 if (!to_foreign)
1187 size = CTF_TYPE_LSIZE (t);
1188
72f33921
NA
1189 t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t));
1190 }
1191 else
1192 t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_stype_t));
1193
1194 switch (kind)
1195 {
1196 case CTF_K_FORWARD:
1197 case CTF_K_UNKNOWN:
1198 case CTF_K_POINTER:
1199 case CTF_K_TYPEDEF:
1200 case CTF_K_VOLATILE:
1201 case CTF_K_CONST:
1202 case CTF_K_RESTRICT:
1203 /* These types have no vlen data to swap. */
1204 assert (vbytes == 0);
1205 break;
1206
1207 case CTF_K_INTEGER:
1208 case CTF_K_FLOAT:
1209 {
1210 /* These types have a single uint32_t. */
1211
1212 uint32_t *item = (uint32_t *) t;
1213
1214 swap_thing (*item);
1215 break;
1216 }
1217
1218 case CTF_K_FUNCTION:
1219 {
1220 /* This type has a bunch of uint32_ts. */
1221
1222 uint32_t *item = (uint32_t *) t;
5ae6af75 1223 ssize_t i;
72f33921 1224
5ae6af75 1225 for (i = vlen; i > 0; item++, i--)
72f33921
NA
1226 swap_thing (*item);
1227 break;
1228 }
1229
1230 case CTF_K_ARRAY:
1231 {
1232 /* This has a single ctf_array_t. */
1233
1234 ctf_array_t *a = (ctf_array_t *) t;
1235
1236 assert (vbytes == sizeof (ctf_array_t));
1237 swap_thing (a->cta_contents);
1238 swap_thing (a->cta_index);
1239 swap_thing (a->cta_nelems);
1240
1241 break;
1242 }
1243
1244 case CTF_K_SLICE:
1245 {
1246 /* This has a single ctf_slice_t. */
1247
1248 ctf_slice_t *s = (ctf_slice_t *) t;
1249
1250 assert (vbytes == sizeof (ctf_slice_t));
1251 swap_thing (s->cts_type);
1252 swap_thing (s->cts_offset);
1253 swap_thing (s->cts_bits);
1254
1255 break;
1256 }
1257
1258 case CTF_K_STRUCT:
1259 case CTF_K_UNION:
1260 {
1261 /* This has an array of ctf_member or ctf_lmember, depending on
1262 size. We could consider it to be a simple array of uint32_t,
1263 but for safety's sake in case these structures ever acquire
1264 non-uint32_t members, do it member by member. */
1265
1266 if (_libctf_unlikely_ (size >= CTF_LSTRUCT_THRESH))
1267 {
1268 ctf_lmember_t *lm = (ctf_lmember_t *) t;
5ae6af75
NA
1269 ssize_t i;
1270 for (i = vlen; i > 0; i--, lm++)
72f33921
NA
1271 {
1272 swap_thing (lm->ctlm_name);
1273 swap_thing (lm->ctlm_offsethi);
1274 swap_thing (lm->ctlm_type);
1275 swap_thing (lm->ctlm_offsetlo);
1276 }
1277 }
1278 else
1279 {
1280 ctf_member_t *m = (ctf_member_t *) t;
5ae6af75
NA
1281 ssize_t i;
1282 for (i = vlen; i > 0; i--, m++)
72f33921
NA
1283 {
1284 swap_thing (m->ctm_name);
1285 swap_thing (m->ctm_offset);
1286 swap_thing (m->ctm_type);
1287 }
1288 }
1289 break;
1290 }
1291
1292 case CTF_K_ENUM:
1293 {
1294 /* This has an array of ctf_enum_t. */
1295
1296 ctf_enum_t *item = (ctf_enum_t *) t;
5ae6af75 1297 ssize_t i;
72f33921 1298
5ae6af75 1299 for (i = vlen; i > 0; item++, i--)
72f33921
NA
1300 {
1301 swap_thing (item->cte_name);
1302 swap_thing (item->cte_value);
1303 }
1304 break;
1305 }
1306 default:
926c9e76
NA
1307 ctf_err_warn (fp, 0, ECTF_CORRUPT,
1308 _("unhandled CTF kind in endianness conversion: %x"),
1309 kind);
72f33921
NA
1310 return ECTF_CORRUPT;
1311 }
1312
1313 t = (ctf_type_t *) ((uintptr_t) t + vbytes);
1314 }
1315
1316 return 0;
1317}
1318
483546ce
NA
1319/* Flip the endianness of BUF, given the offsets in the (native-endianness) CTH.
1320 If TO_FOREIGN is set, flip to foreign-endianness; if not, flip away.
72f33921
NA
1321
1322 All of this stuff happens before the header is fully initialized, so the
1323 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1324 data, this is no real loss. */
1325
faf5e6ac
NA
1326int
1327ctf_flip (ctf_dict_t *fp, ctf_header_t *cth, unsigned char *buf,
1328 int to_foreign)
72f33921 1329{
faf5e6ac
NA
1330 ctf_dprintf("flipping endianness\n");
1331
fd55eae8
NA
1332 flip_lbls (buf + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff);
1333 flip_objts (buf + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff);
2db912ba
NA
1334 flip_objts (buf + cth->cth_funcoff, cth->cth_objtidxoff - cth->cth_funcoff);
1335 flip_objts (buf + cth->cth_objtidxoff, cth->cth_funcidxoff - cth->cth_objtidxoff);
1336 flip_objts (buf + cth->cth_funcidxoff, cth->cth_varoff - cth->cth_funcidxoff);
fd55eae8 1337 flip_vars (buf + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff);
faf5e6ac
NA
1338 return flip_types (fp, buf + cth->cth_typeoff,
1339 cth->cth_stroff - cth->cth_typeoff, to_foreign);
72f33921
NA
1340}
1341
139633c3 1342/* Set up the ctl hashes in a ctf_dict_t. Called by both writable and
676c3ecb 1343 non-writable dictionary initialization. */
139633c3 1344void ctf_set_ctl_hashes (ctf_dict_t *fp)
676c3ecb
NA
1345{
1346 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1347 array of type name prefixes and the corresponding ctf_hash to use. */
1348 fp->ctf_lookups[0].ctl_prefix = "struct";
1349 fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
54a02191 1350 fp->ctf_lookups[0].ctl_hash = fp->ctf_structs;
676c3ecb
NA
1351 fp->ctf_lookups[1].ctl_prefix = "union";
1352 fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
54a02191 1353 fp->ctf_lookups[1].ctl_hash = fp->ctf_unions;
676c3ecb
NA
1354 fp->ctf_lookups[2].ctl_prefix = "enum";
1355 fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
54a02191 1356 fp->ctf_lookups[2].ctl_hash = fp->ctf_enums;
676c3ecb
NA
1357 fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
1358 fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
54a02191 1359 fp->ctf_lookups[3].ctl_hash = fp->ctf_names;
676c3ecb
NA
1360 fp->ctf_lookups[4].ctl_prefix = NULL;
1361 fp->ctf_lookups[4].ctl_len = 0;
1362 fp->ctf_lookups[4].ctl_hash = NULL;
1363}
1364
72f33921 1365/* Open a CTF file, mocking up a suitable ctf_sect. */
d851ecd3 1366
139633c3 1367ctf_dict_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
72f33921
NA
1368 const char *symsect, size_t symsect_size,
1369 size_t symsect_entsize,
1370 const char *strsect, size_t strsect_size,
1371 int *errp)
1372{
1373 ctf_sect_t skeleton;
1374
1375 ctf_sect_t ctf_sect, sym_sect, str_sect;
1376 ctf_sect_t *ctfsectp = NULL;
1377 ctf_sect_t *symsectp = NULL;
1378 ctf_sect_t *strsectp = NULL;
1379
1380 skeleton.cts_name = _CTF_SECTION;
72f33921 1381 skeleton.cts_entsize = 1;
72f33921
NA
1382
1383 if (ctfsect)
1384 {
1385 memcpy (&ctf_sect, &skeleton, sizeof (struct ctf_sect));
1386 ctf_sect.cts_data = ctfsect;
1387 ctf_sect.cts_size = ctfsect_size;
1388 ctfsectp = &ctf_sect;
1389 }
1390
1391 if (symsect)
1392 {
1393 memcpy (&sym_sect, &skeleton, sizeof (struct ctf_sect));
1394 sym_sect.cts_data = symsect;
1395 sym_sect.cts_size = symsect_size;
1396 sym_sect.cts_entsize = symsect_entsize;
1397 symsectp = &sym_sect;
1398 }
1399
1400 if (strsect)
1401 {
1402 memcpy (&str_sect, &skeleton, sizeof (struct ctf_sect));
1403 str_sect.cts_data = strsect;
1404 str_sect.cts_size = strsect_size;
1405 strsectp = &str_sect;
1406 }
1407
483546ce 1408 return ctf_bufopen (ctfsectp, symsectp, strsectp, errp);
72f33921
NA
1409}
1410
1411/* Decode the specified CTF buffer and optional symbol table, and create a new
139633c3 1412 CTF dict representing the symbolic debugging information. This code can
72f33921
NA
1413 be used directly by the debugger, or it can be used as the engine for
1414 ctf_fdopen() or ctf_open(), below. */
1415
139633c3 1416ctf_dict_t *
72f33921
NA
1417ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1418 const ctf_sect_t *strsect, int *errp)
1419{
1420 const ctf_preamble_t *pp;
fd55eae8
NA
1421 size_t hdrsz = sizeof (ctf_header_t);
1422 ctf_header_t *hp;
139633c3 1423 ctf_dict_t *fp;
72f33921
NA
1424 int foreign_endian = 0;
1425 int err;
1426
1427 libctf_init_debug();
1428
14303d62
NA
1429 ctf_set_open_errno (errp, 0);
1430
483546ce 1431 if ((ctfsect == NULL) || ((symsect != NULL) && (strsect == NULL)))
72f33921
NA
1432 return (ctf_set_open_errno (errp, EINVAL));
1433
1434 if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) &&
1435 symsect->cts_entsize != sizeof (Elf64_Sym))
1436 return (ctf_set_open_errno (errp, ECTF_SYMTAB));
1437
1438 if (symsect != NULL && symsect->cts_data == NULL)
1439 return (ctf_set_open_errno (errp, ECTF_SYMBAD));
1440
1441 if (strsect != NULL && strsect->cts_data == NULL)
1442 return (ctf_set_open_errno (errp, ECTF_STRBAD));
1443
027333da
AM
1444 if (ctfsect->cts_data == NULL
1445 || ctfsect->cts_size < sizeof (ctf_preamble_t))
72f33921
NA
1446 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1447
1448 pp = (const ctf_preamble_t *) ctfsect->cts_data;
1449
1450 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1451 pp->ctp_magic, pp->ctp_version);
1452
1453 /* Validate each part of the CTF header.
1454
1455 First, we validate the preamble (common to all versions). At that point,
1456 we know the endianness and specific header version, and can validate the
95861bb3 1457 version-specific parts including section offsets and alignments. */
72f33921
NA
1458
1459 if (_libctf_unlikely_ (pp->ctp_magic != CTF_MAGIC))
1460 {
1461 if (pp->ctp_magic == bswap_16 (CTF_MAGIC))
95861bb3 1462 foreign_endian = 1;
72f33921
NA
1463 else
1464 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1465 }
1466
1467 if (_libctf_unlikely_ ((pp->ctp_version < CTF_VERSION_1)
1468 || (pp->ctp_version > CTF_VERSION_3)))
1469 return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1470
1471 if ((symsect != NULL) && (pp->ctp_version < CTF_VERSION_2))
1472 {
1473 /* The symtab can contain function entries which contain embedded ctf
1474 info. We do not support dynamically upgrading such entries (none
1475 should exist in any case, since dwarf2ctf does not create them). */
1476
1136c379
NA
1477 ctf_err_warn (NULL, 0, ECTF_NOTSUP, _("ctf_bufopen: CTF version %d "
1478 "symsect not supported"),
1479 pp->ctp_version);
72f33921
NA
1480 return (ctf_set_open_errno (errp, ECTF_NOTSUP));
1481 }
1482
fd55eae8
NA
1483 if (pp->ctp_version < CTF_VERSION_3)
1484 hdrsz = sizeof (ctf_header_v2_t);
1485
ec388c16 1486 if (_libctf_unlikely_ (pp->ctp_flags > CTF_F_MAX))
1136c379
NA
1487 {
1488 ctf_err_warn (NULL, 0, ECTF_FLAGS, _("ctf_bufopen: invalid header "
1489 "flags: %x"),
1490 (unsigned int) pp->ctp_flags);
1491 return (ctf_set_open_errno (errp, ECTF_FLAGS));
1492 }
ec388c16 1493
fd55eae8 1494 if (ctfsect->cts_size < hdrsz)
72f33921
NA
1495 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1496
139633c3 1497 if ((fp = malloc (sizeof (ctf_dict_t))) == NULL)
fd55eae8
NA
1498 return (ctf_set_open_errno (errp, ENOMEM));
1499
139633c3 1500 memset (fp, 0, sizeof (ctf_dict_t));
fd55eae8 1501
de07e349 1502 if ((fp->ctf_header = malloc (sizeof (struct ctf_header))) == NULL)
fd55eae8 1503 {
de07e349 1504 free (fp);
fd55eae8
NA
1505 return (ctf_set_open_errno (errp, ENOMEM));
1506 }
1507 hp = fp->ctf_header;
1508 memcpy (hp, ctfsect->cts_data, hdrsz);
1509 if (pp->ctp_version < CTF_VERSION_3)
1510 upgrade_header (hp);
72f33921
NA
1511
1512 if (foreign_endian)
faf5e6ac 1513 ctf_flip_header (hp);
9b32cba4 1514 fp->ctf_openflags = hp->cth_flags;
fd55eae8 1515 fp->ctf_size = hp->cth_stroff + hp->cth_strlen;
72f33921 1516
fd55eae8
NA
1517 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
1518 (unsigned long) fp->ctf_size);
72f33921 1519
fd55eae8 1520 if (hp->cth_lbloff > fp->ctf_size || hp->cth_objtoff > fp->ctf_size
2db912ba
NA
1521 || hp->cth_funcoff > fp->ctf_size || hp->cth_objtidxoff > fp->ctf_size
1522 || hp->cth_funcidxoff > fp->ctf_size || hp->cth_typeoff > fp->ctf_size
fd55eae8 1523 || hp->cth_stroff > fp->ctf_size)
1136c379
NA
1524 {
1525 ctf_err_warn (NULL, 0, ECTF_CORRUPT, _("header offset exceeds CTF size"));
1526 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1527 }
72f33921 1528
fd55eae8
NA
1529 if (hp->cth_lbloff > hp->cth_objtoff
1530 || hp->cth_objtoff > hp->cth_funcoff
1531 || hp->cth_funcoff > hp->cth_typeoff
2db912ba
NA
1532 || hp->cth_funcoff > hp->cth_objtidxoff
1533 || hp->cth_objtidxoff > hp->cth_funcidxoff
1534 || hp->cth_funcidxoff > hp->cth_varoff
fd55eae8 1535 || hp->cth_varoff > hp->cth_typeoff || hp->cth_typeoff > hp->cth_stroff)
1136c379
NA
1536 {
1537 ctf_err_warn (NULL, 0, ECTF_CORRUPT, _("overlapping CTF sections"));
1538 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1539 }
72f33921 1540
fd55eae8 1541 if ((hp->cth_lbloff & 3) || (hp->cth_objtoff & 2)
2db912ba
NA
1542 || (hp->cth_funcoff & 2) || (hp->cth_objtidxoff & 2)
1543 || (hp->cth_funcidxoff & 2) || (hp->cth_varoff & 3)
fd55eae8 1544 || (hp->cth_typeoff & 3))
1136c379
NA
1545 {
1546 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1547 _("CTF sections not properly aligned"));
1548 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1549 }
1550
1551 /* This invariant will be lifted in v4, but for now it is true. */
1552
1553 if ((hp->cth_funcidxoff - hp->cth_objtidxoff != 0) &&
1554 (hp->cth_funcidxoff - hp->cth_objtidxoff
1555 != hp->cth_funcoff - hp->cth_objtoff))
1556 {
1557 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
b62d5edd 1558 _("Object index section is neither empty nor the "
1136c379
NA
1559 "same length as the object section: %u versus %u "
1560 "bytes"), hp->cth_funcoff - hp->cth_objtoff,
1561 hp->cth_funcidxoff - hp->cth_objtidxoff);
1562 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1563 }
1564
1565 if ((hp->cth_varoff - hp->cth_funcidxoff != 0) &&
1566 (hp->cth_varoff - hp->cth_funcidxoff
b62d5edd
NA
1567 != hp->cth_objtidxoff - hp->cth_funcoff) &&
1568 (hp->cth_flags & CTF_F_NEWFUNCINFO))
1136c379
NA
1569 {
1570 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
b62d5edd 1571 _("Function index section is neither empty nor the "
1136c379
NA
1572 "same length as the function section: %u versus %u "
1573 "bytes"), hp->cth_objtidxoff - hp->cth_funcoff,
1574 hp->cth_varoff - hp->cth_funcidxoff);
1575 return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1576 }
72f33921
NA
1577
1578 /* Once everything is determined to be valid, attempt to decompress the CTF
1579 data buffer if it is compressed, or copy it into new storage if it is not
1580 compressed but needs endian-flipping. Otherwise we just put the data
1581 section's buffer pointer into ctf_buf, below. */
1582
1583 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
8a60c930 1584 init_static_types(). */
72f33921 1585
fd55eae8 1586 if (hp->cth_flags & CTF_F_COMPRESS)
72f33921 1587 {
a0486bac
JM
1588 size_t srclen;
1589 uLongf dstlen;
72f33921
NA
1590 const void *src;
1591 int rc = Z_OK;
1592
fd55eae8
NA
1593 /* We are allocating this ourselves, so we can drop the ctf header
1594 copy in favour of ctf->ctf_header. */
72f33921 1595
de07e349 1596 if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
fd55eae8
NA
1597 {
1598 err = ECTF_ZALLOC;
1599 goto bad;
1600 }
1601 fp->ctf_dynbase = fp->ctf_base;
1602 hp->cth_flags &= ~CTF_F_COMPRESS;
72f33921
NA
1603
1604 src = (unsigned char *) ctfsect->cts_data + hdrsz;
1605 srclen = ctfsect->cts_size - hdrsz;
fd55eae8
NA
1606 dstlen = fp->ctf_size;
1607 fp->ctf_buf = fp->ctf_base;
72f33921 1608
fd55eae8 1609 if ((rc = uncompress (fp->ctf_base, &dstlen, src, srclen)) != Z_OK)
72f33921 1610 {
926c9e76
NA
1611 ctf_err_warn (NULL, 0, ECTF_DECOMPRESS, _("zlib inflate err: %s"),
1612 zError (rc));
fd55eae8
NA
1613 err = ECTF_DECOMPRESS;
1614 goto bad;
72f33921
NA
1615 }
1616
fd55eae8 1617 if ((size_t) dstlen != fp->ctf_size)
72f33921 1618 {
926c9e76
NA
1619 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1620 _("zlib inflate short: got %lu of %lu bytes"),
1621 (unsigned long) dstlen, (unsigned long) fp->ctf_size);
fd55eae8
NA
1622 err = ECTF_CORRUPT;
1623 goto bad;
72f33921 1624 }
72f33921 1625 }
84f5c557 1626 else
72f33921 1627 {
84f5c557 1628 if (_libctf_unlikely_ (ctfsect->cts_size < hdrsz + fp->ctf_size))
fd55eae8 1629 {
84f5c557
NA
1630 ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1631 _("%lu byte long CTF dictionary overruns %lu byte long CTF section"),
1632 (unsigned long) ctfsect->cts_size,
1633 (unsigned long) (hdrsz + fp->ctf_size));
1634 err = ECTF_CORRUPT;
fd55eae8
NA
1635 goto bad;
1636 }
84f5c557
NA
1637
1638 if (foreign_endian)
1639 {
1640 if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
1641 {
1642 err = ECTF_ZALLOC;
1643 goto bad;
1644 }
1645 fp->ctf_dynbase = fp->ctf_base;
1646 memcpy (fp->ctf_base, ((unsigned char *) ctfsect->cts_data) + hdrsz,
1647 fp->ctf_size);
1648 fp->ctf_buf = fp->ctf_base;
1649 }
1650 else
1651 {
1652 /* We are just using the section passed in -- but its header may
1653 be an old version. Point ctf_buf past the old header, and
1654 never touch it again. */
1655 fp->ctf_base = (unsigned char *) ctfsect->cts_data;
1656 fp->ctf_dynbase = NULL;
1657 fp->ctf_buf = fp->ctf_base + hdrsz;
1658 }
fd55eae8 1659 }
72f33921
NA
1660
1661 /* Once we have uncompressed and validated the CTF data buffer, we can
139633c3 1662 proceed with initializing the ctf_dict_t we allocated above.
72f33921
NA
1663
1664 Nothing that depends on buf or base should be set directly in this function
8a60c930 1665 before the init_static_types() call, because it may be reallocated during
72f33921 1666 transparent upgrade if this recension of libctf is so configured: see
fd55eae8 1667 ctf_set_base(). */
72f33921 1668
fd55eae8 1669 ctf_set_version (fp, hp, hp->cth_version);
cf9da3b0
NA
1670
1671 /* Temporary assignment, just enough to be able to initialize
1672 the atoms table. */
1673
1674 fp->ctf_str[CTF_STRTAB_0].cts_strs = (const char *) fp->ctf_buf
1675 + hp->cth_stroff;
1676 fp->ctf_str[CTF_STRTAB_0].cts_len = hp->cth_strlen;
483546ce 1677 if (ctf_str_create_atoms (fp) < 0)
e4c78f30
NA
1678 {
1679 err = ENOMEM;
1680 goto bad;
1681 }
1682
fd55eae8 1683 fp->ctf_parmax = CTF_MAX_PTYPE;
72f33921
NA
1684 memcpy (&fp->ctf_data, ctfsect, sizeof (ctf_sect_t));
1685
1686 if (symsect != NULL)
1687 {
629acbe4
NA
1688 memcpy (&fp->ctf_ext_symtab, symsect, sizeof (ctf_sect_t));
1689 memcpy (&fp->ctf_ext_strtab, strsect, sizeof (ctf_sect_t));
72f33921
NA
1690 }
1691
1692 if (fp->ctf_data.cts_name != NULL)
de07e349
NA
1693 if ((fp->ctf_data.cts_name = strdup (fp->ctf_data.cts_name)) == NULL)
1694 {
1695 err = ENOMEM;
1696 goto bad;
1697 }
629acbe4
NA
1698 if (fp->ctf_ext_symtab.cts_name != NULL)
1699 if ((fp->ctf_ext_symtab.cts_name = strdup (fp->ctf_ext_symtab.cts_name)) == NULL)
de07e349
NA
1700 {
1701 err = ENOMEM;
1702 goto bad;
1703 }
629acbe4
NA
1704 if (fp->ctf_ext_strtab.cts_name != NULL)
1705 if ((fp->ctf_ext_strtab.cts_name = strdup (fp->ctf_ext_strtab.cts_name)) == NULL)
de07e349
NA
1706 {
1707 err = ENOMEM;
1708 goto bad;
1709 }
72f33921
NA
1710
1711 if (fp->ctf_data.cts_name == NULL)
1712 fp->ctf_data.cts_name = _CTF_NULLSTR;
629acbe4
NA
1713 if (fp->ctf_ext_symtab.cts_name == NULL)
1714 fp->ctf_ext_symtab.cts_name = _CTF_NULLSTR;
1715 if (fp->ctf_ext_strtab.cts_name == NULL)
1716 fp->ctf_ext_strtab.cts_name = _CTF_NULLSTR;
72f33921
NA
1717
1718 if (strsect != NULL)
1719 {
1720 fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data;
1721 fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size;
1722 }
1723
8a60c930
NA
1724 /* Dynamic state, for dynamic addition to this dict after loading. */
1725
1726 fp->ctf_dthash = ctf_dynhash_create (ctf_hash_integer, ctf_hash_eq_integer,
1727 NULL, NULL);
1728 fp->ctf_dvhash = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
1729 NULL, NULL);
1730 fp->ctf_snapshots = 1;
1731
1732 fp->ctf_objthash = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
1733 free, NULL);
1734 fp->ctf_funchash = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
1735 free, NULL);
1736
1737 if (!fp->ctf_dthash || !fp->ctf_dvhash || !fp->ctf_snapshots ||
1738 !fp->ctf_objthash || !fp->ctf_funchash)
1739 {
1740 err = ENOMEM;
1741 goto bad;
1742 }
1743
72f33921 1744 if (foreign_endian &&
faf5e6ac 1745 (err = ctf_flip (fp, hp, fp->ctf_buf, 0)) != 0)
72f33921 1746 {
faf5e6ac 1747 /* We can be certain that ctf_flip() will have endian-flipped everything
fa56cdcd
NA
1748 other than the types table when we return. In particular the header
1749 is fine, so set it, to allow freeing to use the usual code path. */
72f33921 1750
fd55eae8 1751 ctf_set_base (fp, hp, fp->ctf_base);
72f33921
NA
1752 goto bad;
1753 }
1754
fd55eae8 1755 ctf_set_base (fp, hp, fp->ctf_base);
72f33921 1756
8a60c930 1757 if ((err = init_static_types (fp, hp)) != 0)
fd55eae8 1758 goto bad;
72f33921 1759
1136c379
NA
1760 /* Allocate and initialize the symtab translation table, pointed to by
1761 ctf_sxlate, and the corresponding index sections. This table may be too
1762 large for the actual size of the object and function info sections: if so,
1763 ctf_nsyms will be adjusted and the excess will never be used. It's
1764 possible to do indexed symbol lookups even without a symbol table, so check
53651de8
NA
1765 even in that case. Initially, we assume the symtab is native-endian: if it
1766 isn't, the caller will inform us later by calling ctf_symsect_endianness. */
1767#ifdef WORDS_BIGENDIAN
1768 fp->ctf_symsect_little_endian = 0;
1769#else
1770 fp->ctf_symsect_little_endian = 1;
1771#endif
72f33921
NA
1772
1773 if (symsect != NULL)
1774 {
1775 fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
de07e349 1776 fp->ctf_sxlate = malloc (fp->ctf_nsyms * sizeof (uint32_t));
72f33921
NA
1777
1778 if (fp->ctf_sxlate == NULL)
1779 {
fd55eae8 1780 err = ENOMEM;
72f33921
NA
1781 goto bad;
1782 }
72f33921
NA
1783 }
1784
1136c379
NA
1785 if ((err = init_symtab (fp, hp, symsect)) != 0)
1786 goto bad;
1787
676c3ecb 1788 ctf_set_ctl_hashes (fp);
72f33921
NA
1789
1790 if (symsect != NULL)
1791 {
1792 if (symsect->cts_entsize == sizeof (Elf64_Sym))
1793 (void) ctf_setmodel (fp, CTF_MODEL_LP64);
1794 else
1795 (void) ctf_setmodel (fp, CTF_MODEL_ILP32);
1796 }
1797 else
1798 (void) ctf_setmodel (fp, CTF_MODEL_NATIVE);
1799
1800 fp->ctf_refcnt = 1;
1801 return fp;
1802
1803bad:
fd55eae8 1804 ctf_set_open_errno (errp, err);
926c9e76 1805 ctf_err_warn_to_open (fp);
37ed36fc
NA
1806 /* Without this, the refcnt is zero on entry and ctf_dict_close() won't
1807 actually do anything on the grounds that this is a recursive call via
1808 another dict being closed. */
1809 fp->ctf_refcnt = 1;
139633c3 1810 ctf_dict_close (fp);
72f33921
NA
1811 return NULL;
1812}
1813
139633c3
NA
1814/* Bump the refcount on the specified CTF dict, to allow export of ctf_dict_t's
1815 from iterators that open and close the ctf_dict_t around the loop. (This
1816 does not extend their lifetime beyond that of the ctf_archive_t in which they
1817 are contained.) */
2399827b
NA
1818
1819void
139633c3 1820ctf_ref (ctf_dict_t *fp)
2399827b
NA
1821{
1822 fp->ctf_refcnt++;
1823}
1824
139633c3
NA
1825/* Close the specified CTF dict and free associated data structures. Note that
1826 ctf_dict_close() is a reference counted operation: if the specified file is
1827 the parent of other active dict, its reference count will be greater than one
1828 and it will be freed later when no active children exist. */
72f33921
NA
1829
1830void
139633c3 1831ctf_dict_close (ctf_dict_t *fp)
72f33921
NA
1832{
1833 ctf_dtdef_t *dtd, *ntd;
1834 ctf_dvdef_t *dvd, *nvd;
1136c379 1835 ctf_in_flight_dynsym_t *did, *nid;
8b37e7b6 1836 ctf_err_warning_t *err, *nerr;
72f33921
NA
1837
1838 if (fp == NULL)
139633c3 1839 return; /* Allow ctf_dict_close(NULL) to simplify caller code. */
72f33921 1840
139633c3 1841 ctf_dprintf ("ctf_dict_close(%p) refcnt=%u\n", (void *) fp, fp->ctf_refcnt);
72f33921
NA
1842
1843 if (fp->ctf_refcnt > 1)
1844 {
1845 fp->ctf_refcnt--;
1846 return;
1847 }
1848
1fa7a0c2
NA
1849 /* It is possible to recurse back in here, notably if dicts in the
1850 ctf_link_inputs or ctf_link_outputs cite this dict as a parent without
1851 using ctf_import_unref. Do nothing in that case. */
1852 if (fp->ctf_refcnt == 0)
1853 return;
1854
1855 fp->ctf_refcnt--;
de07e349
NA
1856 free (fp->ctf_dyncuname);
1857 free (fp->ctf_dynparname);
1fa7a0c2 1858 if (fp->ctf_parent && !fp->ctf_parent_unreffed)
139633c3 1859 ctf_dict_close (fp->ctf_parent);
72f33921
NA
1860
1861 for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
1862 {
1863 ntd = ctf_list_next (dtd);
1864 ctf_dtd_delete (fp, dtd);
1865 }
1866 ctf_dynhash_destroy (fp->ctf_dthash);
54a02191 1867
6e09d4a6 1868 ctf_dynset_destroy (fp->ctf_conflicting_enums);
54a02191
NA
1869 ctf_dynhash_destroy (fp->ctf_structs);
1870 ctf_dynhash_destroy (fp->ctf_unions);
1871 ctf_dynhash_destroy (fp->ctf_enums);
1872 ctf_dynhash_destroy (fp->ctf_names);
72f33921
NA
1873
1874 for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
1875 {
1876 nvd = ctf_list_next (dvd);
1877 ctf_dvd_delete (fp, dvd);
1878 }
1879 ctf_dynhash_destroy (fp->ctf_dvhash);
1136c379 1880
8a60c930
NA
1881 ctf_dynhash_destroy (fp->ctf_symhash_func);
1882 ctf_dynhash_destroy (fp->ctf_symhash_objt);
1136c379
NA
1883 free (fp->ctf_funcidx_sxlate);
1884 free (fp->ctf_objtidx_sxlate);
1885 ctf_dynhash_destroy (fp->ctf_objthash);
1886 ctf_dynhash_destroy (fp->ctf_funchash);
1887 free (fp->ctf_dynsymidx);
1888 ctf_dynhash_destroy (fp->ctf_dynsyms);
1889 for (did = ctf_list_next (&fp->ctf_in_flight_dynsyms); did != NULL; did = nid)
1890 {
1891 nid = ctf_list_next (did);
1892 ctf_list_delete (&fp->ctf_in_flight_dynsyms, did);
1893 free (did);
1894 }
1895
f5e9c9bd 1896 ctf_str_free_atoms (fp);
de07e349 1897 free (fp->ctf_tmp_typeslice);
72f33921 1898
fd55eae8 1899 if (fp->ctf_data.cts_name != _CTF_NULLSTR)
de07e349 1900 free ((char *) fp->ctf_data.cts_name);
72f33921 1901
629acbe4
NA
1902 if (fp->ctf_ext_symtab.cts_name != _CTF_NULLSTR)
1903 free ((char *) fp->ctf_ext_symtab.cts_name);
72f33921 1904
629acbe4
NA
1905 if (fp->ctf_ext_strtab.cts_name != _CTF_NULLSTR)
1906 free ((char *) fp->ctf_ext_strtab.cts_name);
72f33921
NA
1907 else if (fp->ctf_data_mmapped)
1908 ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
1909
de07e349 1910 free (fp->ctf_dynbase);
72f33921 1911
d851ecd3 1912 ctf_dynhash_destroy (fp->ctf_syn_ext_strtab);
72c83edd
NA
1913 ctf_dynhash_destroy (fp->ctf_link_inputs);
1914 ctf_dynhash_destroy (fp->ctf_link_outputs);
886453cb 1915 ctf_dynhash_destroy (fp->ctf_link_type_mapping);
5f54462c
NA
1916 ctf_dynhash_destroy (fp->ctf_link_in_cu_mapping);
1917 ctf_dynhash_destroy (fp->ctf_link_out_cu_mapping);
99dc3ebd 1918 ctf_dynhash_destroy (fp->ctf_add_processing);
0f0c11f7
NA
1919 ctf_dedup_fini (fp, NULL, 0);
1920 ctf_dynset_destroy (fp->ctf_dedup_atoms_alloc);
d851ecd3 1921
8b37e7b6
NA
1922 for (err = ctf_list_next (&fp->ctf_errs_warnings); err != NULL; err = nerr)
1923 {
1924 nerr = ctf_list_next (err);
1925 ctf_list_delete (&fp->ctf_errs_warnings, err);
1926 free (err->cew_text);
1927 free (err);
1928 }
1929
de07e349
NA
1930 free (fp->ctf_sxlate);
1931 free (fp->ctf_txlate);
1932 free (fp->ctf_ptrtab);
abe4ca69 1933 free (fp->ctf_pptrtab);
72f33921 1934
de07e349
NA
1935 free (fp->ctf_header);
1936 free (fp);
72f33921
NA
1937}
1938
139633c3
NA
1939/* Backward compatibility. */
1940void
1941ctf_file_close (ctf_file_t *fp)
1942{
1943 ctf_dict_close (fp);
1944}
1945
143dce84
NA
1946/* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1947 archive, so closing one is just like closing an archive. */
1948void
1949ctf_close (ctf_archive_t *arc)
1950{
1951 ctf_arc_close (arc);
1952}
1953
139633c3 1954/* Get the CTF archive from which this ctf_dict_t is derived. */
9402cc59 1955ctf_archive_t *
139633c3 1956ctf_get_arc (const ctf_dict_t *fp)
9402cc59
NA
1957{
1958 return fp->ctf_archive;
1959}
1960
72f33921 1961/* Return the ctfsect out of the core ctf_impl. Useful for freeing the
139633c3 1962 ctfsect's data * after ctf_dict_close(), which is why we return the actual
72f33921
NA
1963 structure, not a pointer to it, since that is likely to become a pointer to
1964 freed data before the return value is used under the expected use case of
139633c3 1965 ctf_getsect()/ ctf_dict_close()/free(). */
676c3ecb 1966ctf_sect_t
139633c3 1967ctf_getdatasect (const ctf_dict_t *fp)
72f33921
NA
1968{
1969 return fp->ctf_data;
1970}
1971
97a2a623
NA
1972ctf_sect_t
1973ctf_getsymsect (const ctf_dict_t *fp)
1974{
629acbe4 1975 return fp->ctf_ext_symtab;
97a2a623
NA
1976}
1977
1978ctf_sect_t
1979ctf_getstrsect (const ctf_dict_t *fp)
1980{
629acbe4 1981 return fp->ctf_ext_strtab;
97a2a623
NA
1982}
1983
53651de8
NA
1984/* Set the endianness of the symbol table attached to FP. */
1985void
1986ctf_symsect_endianness (ctf_dict_t *fp, int little_endian)
1987{
1988 int old_endianness = fp->ctf_symsect_little_endian;
1989
1990 fp->ctf_symsect_little_endian = !!little_endian;
1991
1992 /* If we already have a symtab translation table, we need to repopulate it if
1993 our idea of the endianness has changed. */
1994
1995 if (old_endianness != fp->ctf_symsect_little_endian
629acbe4
NA
1996 && fp->ctf_sxlate != NULL && fp->ctf_ext_symtab.cts_data != NULL)
1997 assert (init_symtab (fp, fp->ctf_header, &fp->ctf_ext_symtab) == 0);
53651de8
NA
1998}
1999
139633c3
NA
2000/* Return the CTF handle for the parent CTF dict, if one exists. Otherwise
2001 return NULL to indicate this dict has no imported parent. */
2002ctf_dict_t *
2003ctf_parent_dict (ctf_dict_t *fp)
72f33921
NA
2004{
2005 return fp->ctf_parent;
2006}
2007
139633c3
NA
2008/* Backward compatibility. */
2009ctf_dict_t *
2010ctf_parent_file (ctf_dict_t *fp)
2011{
2012 return ctf_parent_dict (fp);
2013}
2014
2015/* Return the name of the parent CTF dict, if one exists, or NULL otherwise. */
72f33921 2016const char *
139633c3 2017ctf_parent_name (ctf_dict_t *fp)
72f33921
NA
2018{
2019 return fp->ctf_parname;
2020}
2021
2022/* Set the parent name. It is an error to call this routine without calling
2023 ctf_import() at some point. */
de07e349 2024int
139633c3 2025ctf_parent_name_set (ctf_dict_t *fp, const char *name)
72f33921
NA
2026{
2027 if (fp->ctf_dynparname != NULL)
de07e349 2028 free (fp->ctf_dynparname);
72f33921 2029
de07e349
NA
2030 if ((fp->ctf_dynparname = strdup (name)) == NULL)
2031 return (ctf_set_errno (fp, ENOMEM));
72f33921 2032 fp->ctf_parname = fp->ctf_dynparname;
de07e349 2033 return 0;
72f33921
NA
2034}
2035
fd55eae8 2036/* Return the name of the compilation unit this CTF file applies to. Usually
139633c3 2037 non-NULL only for non-parent dicts. */
fd55eae8 2038const char *
139633c3 2039ctf_cuname (ctf_dict_t *fp)
fd55eae8
NA
2040{
2041 return fp->ctf_cuname;
2042}
2043
2044/* Set the compilation unit name. */
de07e349 2045int
139633c3 2046ctf_cuname_set (ctf_dict_t *fp, const char *name)
fd55eae8
NA
2047{
2048 if (fp->ctf_dyncuname != NULL)
de07e349 2049 free (fp->ctf_dyncuname);
fd55eae8 2050
de07e349
NA
2051 if ((fp->ctf_dyncuname = strdup (name)) == NULL)
2052 return (ctf_set_errno (fp, ENOMEM));
fd55eae8 2053 fp->ctf_cuname = fp->ctf_dyncuname;
de07e349 2054 return 0;
fd55eae8
NA
2055}
2056
139633c3
NA
2057/* Import the types from the specified parent dict by storing a pointer to it in
2058 ctf_parent and incrementing its reference count. Only one parent is allowed:
abe4ca69
NA
2059 if a parent already exists, it is replaced by the new parent. The pptrtab
2060 is wiped, and will be refreshed by the next ctf_lookup_by_name call. */
72f33921 2061int
139633c3 2062ctf_import (ctf_dict_t *fp, ctf_dict_t *pfp)
72f33921
NA
2063{
2064 if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
2065 return (ctf_set_errno (fp, EINVAL));
2066
2067 if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
2068 return (ctf_set_errno (fp, ECTF_DMODEL));
2069
1fa7a0c2 2070 if (fp->ctf_parent && !fp->ctf_parent_unreffed)
139633c3 2071 ctf_dict_close (fp->ctf_parent);
1fa7a0c2
NA
2072 fp->ctf_parent = NULL;
2073
abe4ca69
NA
2074 free (fp->ctf_pptrtab);
2075 fp->ctf_pptrtab = NULL;
2076 fp->ctf_pptrtab_len = 0;
2077 fp->ctf_pptrtab_typemax = 0;
2078
1fa7a0c2 2079 if (pfp != NULL)
de07e349 2080 {
1fa7a0c2
NA
2081 int err;
2082
2083 if (fp->ctf_parname == NULL)
2084 if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
2085 return err;
2086
2087 fp->ctf_flags |= LCTF_CHILD;
2088 pfp->ctf_refcnt++;
2089 fp->ctf_parent_unreffed = 0;
de07e349 2090 }
72f33921 2091
1fa7a0c2
NA
2092 fp->ctf_parent = pfp;
2093 return 0;
2094}
2095
2096/* Like ctf_import, but does not increment the refcount on the imported parent
2097 or close it at any point: as a result it can go away at any time and the
2098 caller must do all freeing itself. Used internally to avoid refcount
2099 loops. */
2100int
139633c3 2101ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp)
1fa7a0c2
NA
2102{
2103 if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
2104 return (ctf_set_errno (fp, EINVAL));
2105
2106 if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
2107 return (ctf_set_errno (fp, ECTF_DMODEL));
2108
2109 if (fp->ctf_parent && !fp->ctf_parent_unreffed)
139633c3 2110 ctf_dict_close (fp->ctf_parent);
1fa7a0c2
NA
2111 fp->ctf_parent = NULL;
2112
abe4ca69
NA
2113 free (fp->ctf_pptrtab);
2114 fp->ctf_pptrtab = NULL;
2115 fp->ctf_pptrtab_len = 0;
2116 fp->ctf_pptrtab_typemax = 0;
72f33921
NA
2117 if (pfp != NULL)
2118 {
de07e349 2119 int err;
72f33921
NA
2120
2121 if (fp->ctf_parname == NULL)
de07e349
NA
2122 if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
2123 return err;
2124
2125 fp->ctf_flags |= LCTF_CHILD;
1fa7a0c2 2126 fp->ctf_parent_unreffed = 1;
72f33921 2127 }
ad613f1d 2128
72f33921
NA
2129 fp->ctf_parent = pfp;
2130 return 0;
2131}
2132
139633c3 2133/* Set the data model constant for the CTF dict. */
72f33921 2134int
139633c3 2135ctf_setmodel (ctf_dict_t *fp, int model)
72f33921
NA
2136{
2137 const ctf_dmodel_t *dp;
2138
2139 for (dp = _libctf_models; dp->ctd_name != NULL; dp++)
2140 {
2141 if (dp->ctd_code == model)
2142 {
2143 fp->ctf_dmodel = dp;
2144 return 0;
2145 }
2146 }
2147
2148 return (ctf_set_errno (fp, EINVAL));
2149}
2150
139633c3 2151/* Return the data model constant for the CTF dict. */
72f33921 2152int
139633c3 2153ctf_getmodel (ctf_dict_t *fp)
72f33921
NA
2154{
2155 return fp->ctf_dmodel->ctd_code;
2156}
2157
139633c3 2158/* The caller can hang an arbitrary pointer off each ctf_dict_t using this
a0486bac 2159 function. */
72f33921 2160void
139633c3 2161ctf_setspecific (ctf_dict_t *fp, void *data)
72f33921
NA
2162{
2163 fp->ctf_specific = data;
2164}
2165
a0486bac 2166/* Retrieve the arbitrary pointer again. */
72f33921 2167void *
139633c3 2168ctf_getspecific (ctf_dict_t *fp)
72f33921
NA
2169{
2170 return fp->ctf_specific;
2171}