Coverage Report

Created: 2024-05-21 06:29

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