Coverage Report

Created: 2023-08-28 06:23

/src/binutils-gdb/libctf/ctf-open.c
Line
Count
Source (jump to first uncovered line)
1
/* Opening CTF files.
2
   Copyright (C) 2019-2023 Free Software Foundation, Inc.
3
4
   This file is part of libctf.
5
6
   libctf is free software; you can redistribute it and/or modify it under
7
   the terms of the GNU General Public License as published by the Free
8
   Software Foundation; either version 3, or (at your option) any later
9
   version.
10
11
   This program is distributed in the hope that it will be useful, but
12
   WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14
   See the GNU General Public License for more details.
15
16
   You should have received a copy of the GNU General Public License
17
   along with this program; see the file COPYING.  If not see
18
   <http://www.gnu.org/licenses/>.  */
19
20
#include <ctf-impl.h>
21
#include <stddef.h>
22
#include <string.h>
23
#include <sys/types.h>
24
#include <elf.h>
25
#include "swap.h"
26
#include <bfd.h>
27
#include <zlib.h>
28
29
static const ctf_dmodel_t _libctf_models[] = {
30
  {"ILP32", CTF_MODEL_ILP32, 4, 1, 2, 4, 4},
31
  {"LP64", CTF_MODEL_LP64, 8, 1, 2, 4, 8},
32
  {NULL, 0, 0, 0, 0, 0, 0}
33
};
34
35
const char _CTF_SECTION[] = ".ctf";
36
const char _CTF_NULLSTR[] = "";
37
38
/* Version-sensitive accessors.  */
39
40
static uint32_t
41
get_kind_v1 (uint32_t info)
42
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_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_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
/* Initialize the type ID translation table with the byte offset of each type,
674
   and initialize the hash tables of each named type.  Upgrade the type table to
675
   the latest supported representation in the process, if needed, and if this
676
   recension of libctf supports upgrading.  */
677
678
static int
679
init_types (ctf_dict_t *fp, ctf_header_t *cth)
680
0
{
681
0
  const ctf_type_t *tbuf;
682
0
  const ctf_type_t *tend;
683
684
0
  unsigned long pop[CTF_K_MAX + 1] = { 0 };
685
0
  const ctf_type_t *tp;
686
0
  uint32_t id;
687
0
  uint32_t *xp;
688
689
  /* We determine whether the dict is a child or a parent based on the value of
690
     cth_parname.  */
691
692
0
  int child = cth->cth_parname != 0;
693
0
  int nlstructs = 0, nlunions = 0;
694
0
  int err;
695
696
0
  assert (!(fp->ctf_flags & LCTF_RDWR));
697
698
0
  if (_libctf_unlikely_ (fp->ctf_version == CTF_VERSION_1))
699
0
    {
700
0
      int err;
701
0
      if ((err = upgrade_types (fp, cth)) != 0)
702
0
  return err;       /* Upgrade failed.  */
703
0
    }
704
705
0
  tbuf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff);
706
0
  tend = (ctf_type_t *) (fp->ctf_buf + cth->cth_stroff);
707
708
  /* We make two passes through the entire type section.  In this first
709
     pass, we count the number of each type and the total number of types.  */
710
711
0
  for (tp = tbuf; tp < tend; fp->ctf_typemax++)
712
0
    {
713
0
      unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
714
0
      unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
715
0
      ssize_t size, increment, vbytes;
716
717
0
      (void) ctf_get_ctt_size (fp, tp, &size, &increment);
718
0
      vbytes = LCTF_VBYTES (fp, kind, size, vlen);
719
720
0
      if (vbytes < 0)
721
0
  return ECTF_CORRUPT;
722
723
      /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
724
   so bump that population count too.  */
725
0
      if (kind == CTF_K_FORWARD)
726
0
  pop[tp->ctt_type]++;
727
728
0
      tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
729
0
      pop[kind]++;
730
0
    }
731
732
0
  if (child)
733
0
    {
734
0
      ctf_dprintf ("CTF dict %p is a child\n", (void *) fp);
735
0
      fp->ctf_flags |= LCTF_CHILD;
736
0
    }
737
0
  else
738
0
    ctf_dprintf ("CTF dict %p is a parent\n", (void *) fp);
739
740
  /* Now that we've counted up the number of each type, we can allocate
741
     the hash tables, type translation table, and pointer table.  */
742
743
0
  if ((fp->ctf_structs.ctn_readonly
744
0
       = ctf_hash_create (pop[CTF_K_STRUCT], ctf_hash_string,
745
0
        ctf_hash_eq_string)) == NULL)
746
0
    return ENOMEM;
747
748
0
  if ((fp->ctf_unions.ctn_readonly
749
0
       = ctf_hash_create (pop[CTF_K_UNION], ctf_hash_string,
750
0
        ctf_hash_eq_string)) == NULL)
751
0
    return ENOMEM;
752
753
0
  if ((fp->ctf_enums.ctn_readonly
754
0
       = ctf_hash_create (pop[CTF_K_ENUM], ctf_hash_string,
755
0
        ctf_hash_eq_string)) == NULL)
756
0
    return ENOMEM;
757
758
0
  if ((fp->ctf_names.ctn_readonly
759
0
       = ctf_hash_create (pop[CTF_K_UNKNOWN] +
760
0
        pop[CTF_K_INTEGER] +
761
0
        pop[CTF_K_FLOAT] +
762
0
        pop[CTF_K_FUNCTION] +
763
0
        pop[CTF_K_TYPEDEF] +
764
0
        pop[CTF_K_POINTER] +
765
0
        pop[CTF_K_VOLATILE] +
766
0
        pop[CTF_K_CONST] +
767
0
        pop[CTF_K_RESTRICT],
768
0
        ctf_hash_string,
769
0
        ctf_hash_eq_string)) == NULL)
770
0
    return ENOMEM;
771
772
0
  fp->ctf_txlate = malloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
773
0
  fp->ctf_ptrtab_len = fp->ctf_typemax + 1;
774
0
  fp->ctf_ptrtab = malloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
775
776
0
  if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
777
0
    return ENOMEM;   /* Memory allocation failed.  */
778
779
0
  xp = fp->ctf_txlate;
780
0
  *xp++ = 0;      /* Type id 0 is used as a sentinel value.  */
781
782
0
  memset (fp->ctf_txlate, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1));
783
0
  memset (fp->ctf_ptrtab, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1));
784
785
  /* In the second pass through the types, we fill in each entry of the
786
     type and pointer tables and add names to the appropriate hashes.  */
787
788
0
  for (id = 1, tp = tbuf; tp < tend; xp++, id++)
789
0
    {
790
0
      unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
791
0
      unsigned short isroot = LCTF_INFO_ISROOT (fp, tp->ctt_info);
792
0
      unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
793
0
      ssize_t size, increment, vbytes;
794
795
0
      const char *name;
796
797
0
      (void) ctf_get_ctt_size (fp, tp, &size, &increment);
798
0
      name = ctf_strptr (fp, tp->ctt_name);
799
      /* Cannot fail: shielded by call in loop above.  */
800
0
      vbytes = LCTF_VBYTES (fp, kind, size, vlen);
801
802
0
      switch (kind)
803
0
  {
804
0
  case CTF_K_UNKNOWN:
805
0
  case CTF_K_INTEGER:
806
0
  case CTF_K_FLOAT:
807
    /* Names are reused by bit-fields, which are differentiated by their
808
       encodings, and so typically we'd record only the first instance of
809
       a given intrinsic.  However, we replace an existing type with a
810
       root-visible version so that we can be sure to find it when
811
       checking for conflicting definitions in ctf_add_type().  */
812
813
0
    if (((ctf_hash_lookup_type (fp->ctf_names.ctn_readonly,
814
0
              fp, name)) == 0)
815
0
        || isroot)
816
0
      {
817
0
        err = ctf_hash_define_type (fp->ctf_names.ctn_readonly, fp,
818
0
            LCTF_INDEX_TO_TYPE (fp, id, child),
819
0
            tp->ctt_name);
820
0
        if (err != 0)
821
0
    return err;
822
0
      }
823
0
    break;
824
825
    /* These kinds have no name, so do not need interning into any
826
       hashtables.  */
827
0
  case CTF_K_ARRAY:
828
0
  case CTF_K_SLICE:
829
0
    break;
830
831
0
  case CTF_K_FUNCTION:
832
0
    if (!isroot)
833
0
      break;
834
835
0
    err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
836
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
837
0
              tp->ctt_name);
838
0
    if (err != 0)
839
0
      return err;
840
0
    break;
841
842
0
  case CTF_K_STRUCT:
843
0
    if (size >= CTF_LSTRUCT_THRESH)
844
0
      nlstructs++;
845
846
0
    if (!isroot)
847
0
      break;
848
849
0
    err = ctf_hash_define_type (fp->ctf_structs.ctn_readonly, fp,
850
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
851
0
              tp->ctt_name);
852
853
0
    if (err != 0)
854
0
      return err;
855
856
0
    break;
857
858
0
  case CTF_K_UNION:
859
0
    if (size >= CTF_LSTRUCT_THRESH)
860
0
      nlunions++;
861
862
0
    if (!isroot)
863
0
      break;
864
865
0
    err = ctf_hash_define_type (fp->ctf_unions.ctn_readonly, fp,
866
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
867
0
              tp->ctt_name);
868
869
0
    if (err != 0)
870
0
      return err;
871
0
    break;
872
873
0
  case CTF_K_ENUM:
874
0
    if (!isroot)
875
0
      break;
876
877
0
    err = ctf_hash_define_type (fp->ctf_enums.ctn_readonly, fp,
878
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
879
0
              tp->ctt_name);
880
881
0
    if (err != 0)
882
0
      return err;
883
0
    break;
884
885
0
  case CTF_K_TYPEDEF:
886
0
    if (!isroot)
887
0
      break;
888
889
0
    err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
890
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
891
0
              tp->ctt_name);
892
0
    if (err != 0)
893
0
      return err;
894
0
    break;
895
896
0
  case CTF_K_FORWARD:
897
0
    {
898
0
      ctf_names_t *np = ctf_name_table (fp, tp->ctt_type);
899
900
0
      if (!isroot)
901
0
        break;
902
903
      /* Only insert forward tags into the given hash if the type or tag
904
         name is not already present.  */
905
0
      if (ctf_hash_lookup_type (np->ctn_readonly, fp, name) == 0)
906
0
        {
907
0
    err = ctf_hash_insert_type (np->ctn_readonly, fp,
908
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
909
0
              tp->ctt_name);
910
0
    if (err != 0)
911
0
      return err;
912
0
        }
913
0
      break;
914
0
    }
915
916
0
  case CTF_K_POINTER:
917
    /* If the type referenced by the pointer is in this CTF dict, then
918
       store the index of the pointer type in fp->ctf_ptrtab[ index of
919
       referenced type ].  */
920
921
0
    if (LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child
922
0
        && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
923
0
      fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = id;
924
   /*FALLTHRU*/
925
926
0
  case CTF_K_VOLATILE:
927
0
  case CTF_K_CONST:
928
0
  case CTF_K_RESTRICT:
929
0
    if (!isroot)
930
0
      break;
931
932
0
    err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
933
0
              LCTF_INDEX_TO_TYPE (fp, id, child),
934
0
              tp->ctt_name);
935
0
    if (err != 0)
936
0
      return err;
937
0
    break;
938
0
  default:
939
0
    ctf_err_warn (fp, 0, ECTF_CORRUPT,
940
0
      _("init_types(): unhandled CTF kind: %x"), kind);
941
0
    return ECTF_CORRUPT;
942
0
  }
943
944
0
      *xp = (uint32_t) ((uintptr_t) tp - (uintptr_t) fp->ctf_buf);
945
0
      tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
946
0
    }
947
948
0
  ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax);
949
0
  ctf_dprintf ("%u enum names hashed\n",
950
0
         ctf_hash_size (fp->ctf_enums.ctn_readonly));
951
0
  ctf_dprintf ("%u struct names hashed (%d long)\n",
952
0
         ctf_hash_size (fp->ctf_structs.ctn_readonly), nlstructs);
953
0
  ctf_dprintf ("%u union names hashed (%d long)\n",
954
0
         ctf_hash_size (fp->ctf_unions.ctn_readonly), nlunions);
955
0
  ctf_dprintf ("%u base type names hashed\n",
956
0
         ctf_hash_size (fp->ctf_names.ctn_readonly));
957
958
0
  return 0;
959
0
}
960
961
/* Endianness-flipping routines.
962
963
   We flip everything, mindlessly, even 1-byte entities, so that future
964
   expansions do not require changes to this code.  */
965
966
/* Flip the endianness of the CTF header.  */
967
968
void
969
ctf_flip_header (ctf_header_t *cth)
970
0
{
971
0
  swap_thing (cth->cth_preamble.ctp_magic);
972
0
  swap_thing (cth->cth_preamble.ctp_version);
973
0
  swap_thing (cth->cth_preamble.ctp_flags);
974
0
  swap_thing (cth->cth_parlabel);
975
0
  swap_thing (cth->cth_parname);
976
0
  swap_thing (cth->cth_cuname);
977
0
  swap_thing (cth->cth_objtoff);
978
0
  swap_thing (cth->cth_funcoff);
979
0
  swap_thing (cth->cth_objtidxoff);
980
0
  swap_thing (cth->cth_funcidxoff);
981
0
  swap_thing (cth->cth_varoff);
982
0
  swap_thing (cth->cth_typeoff);
983
0
  swap_thing (cth->cth_stroff);
984
0
  swap_thing (cth->cth_strlen);
985
0
}
986
987
/* Flip the endianness of the label section, an array of ctf_lblent_t.  */
988
989
static void
990
flip_lbls (void *start, size_t len)
991
0
{
992
0
  ctf_lblent_t *lbl = start;
993
0
  ssize_t i;
994
995
0
  for (i = len / sizeof (struct ctf_lblent); i > 0; lbl++, i--)
996
0
    {
997
0
      swap_thing (lbl->ctl_label);
998
0
      swap_thing (lbl->ctl_type);
999
0
    }
1000
0
}
1001
1002
/* Flip the endianness of the data-object or function sections or their indexes,
1003
   all arrays of uint32_t.  */
1004
1005
static void
1006
flip_objts (void *start, size_t len)
1007
0
{
1008
0
  uint32_t *obj = start;
1009
0
  ssize_t i;
1010
1011
0
  for (i = len / sizeof (uint32_t); i > 0; obj++, i--)
1012
0
      swap_thing (*obj);
1013
0
}
1014
1015
/* Flip the endianness of the variable section, an array of ctf_varent_t.  */
1016
1017
static void
1018
flip_vars (void *start, size_t len)
1019
0
{
1020
0
  ctf_varent_t *var = start;
1021
0
  ssize_t i;
1022
1023
0
  for (i = len / sizeof (struct ctf_varent); i > 0; var++, i--)
1024
0
    {
1025
0
      swap_thing (var->ctv_name);
1026
0
      swap_thing (var->ctv_type);
1027
0
    }
1028
0
}
1029
1030
/* Flip the endianness of the type section, a tagged array of ctf_type or
1031
   ctf_stype followed by variable data.  */
1032
1033
static int
1034
flip_types (ctf_dict_t *fp, void *start, size_t len, int to_foreign)
1035
0
{
1036
0
  ctf_type_t *t = start;
1037
1038
0
  while ((uintptr_t) t < ((uintptr_t) start) + len)
1039
0
    {
1040
0
      uint32_t kind;
1041
0
      size_t size;
1042
0
      uint32_t vlen;
1043
0
      size_t vbytes;
1044
1045
0
      if (to_foreign)
1046
0
  {
1047
0
    kind = CTF_V2_INFO_KIND (t->ctt_info);
1048
0
    size = t->ctt_size;
1049
0
    vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1050
0
    vbytes = get_vbytes_v2 (fp, kind, size, vlen);
1051
0
  }
1052
1053
0
      swap_thing (t->ctt_name);
1054
0
      swap_thing (t->ctt_info);
1055
0
      swap_thing (t->ctt_size);
1056
1057
0
      if (!to_foreign)
1058
0
  {
1059
0
    kind = CTF_V2_INFO_KIND (t->ctt_info);
1060
0
    size = t->ctt_size;
1061
0
    vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1062
0
    vbytes = get_vbytes_v2 (fp, kind, size, vlen);
1063
0
  }
1064
1065
0
      if (_libctf_unlikely_ (size == CTF_LSIZE_SENT))
1066
0
  {
1067
0
    if (to_foreign)
1068
0
      size = CTF_TYPE_LSIZE (t);
1069
1070
0
    swap_thing (t->ctt_lsizehi);
1071
0
    swap_thing (t->ctt_lsizelo);
1072
1073
0
    if (!to_foreign)
1074
0
      size = CTF_TYPE_LSIZE (t);
1075
1076
0
    t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t));
1077
0
  }
1078
0
      else
1079
0
  t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_stype_t));
1080
1081
0
      switch (kind)
1082
0
  {
1083
0
  case CTF_K_FORWARD:
1084
0
  case CTF_K_UNKNOWN:
1085
0
  case CTF_K_POINTER:
1086
0
  case CTF_K_TYPEDEF:
1087
0
  case CTF_K_VOLATILE:
1088
0
  case CTF_K_CONST:
1089
0
  case CTF_K_RESTRICT:
1090
    /* These types have no vlen data to swap.  */
1091
0
    assert (vbytes == 0);
1092
0
    break;
1093
1094
0
  case CTF_K_INTEGER:
1095
0
  case CTF_K_FLOAT:
1096
0
    {
1097
      /* These types have a single uint32_t.  */
1098
1099
0
      uint32_t *item = (uint32_t *) t;
1100
1101
0
      swap_thing (*item);
1102
0
      break;
1103
0
    }
1104
1105
0
  case CTF_K_FUNCTION:
1106
0
    {
1107
      /* This type has a bunch of uint32_ts.  */
1108
1109
0
      uint32_t *item = (uint32_t *) t;
1110
0
      ssize_t i;
1111
1112
0
      for (i = vlen; i > 0; item++, i--)
1113
0
        swap_thing (*item);
1114
0
      break;
1115
0
    }
1116
1117
0
  case CTF_K_ARRAY:
1118
0
    {
1119
      /* This has a single ctf_array_t.  */
1120
1121
0
      ctf_array_t *a = (ctf_array_t *) t;
1122
1123
0
      assert (vbytes == sizeof (ctf_array_t));
1124
0
      swap_thing (a->cta_contents);
1125
0
      swap_thing (a->cta_index);
1126
0
      swap_thing (a->cta_nelems);
1127
1128
0
      break;
1129
0
    }
1130
1131
0
  case CTF_K_SLICE:
1132
0
    {
1133
      /* This has a single ctf_slice_t.  */
1134
1135
0
      ctf_slice_t *s = (ctf_slice_t *) t;
1136
1137
0
      assert (vbytes == sizeof (ctf_slice_t));
1138
0
      swap_thing (s->cts_type);
1139
0
      swap_thing (s->cts_offset);
1140
0
      swap_thing (s->cts_bits);
1141
1142
0
      break;
1143
0
    }
1144
1145
0
  case CTF_K_STRUCT:
1146
0
  case CTF_K_UNION:
1147
0
    {
1148
      /* This has an array of ctf_member or ctf_lmember, depending on
1149
         size.  We could consider it to be a simple array of uint32_t,
1150
         but for safety's sake in case these structures ever acquire
1151
         non-uint32_t members, do it member by member.  */
1152
1153
0
      if (_libctf_unlikely_ (size >= CTF_LSTRUCT_THRESH))
1154
0
        {
1155
0
    ctf_lmember_t *lm = (ctf_lmember_t *) t;
1156
0
    ssize_t i;
1157
0
    for (i = vlen; i > 0; i--, lm++)
1158
0
      {
1159
0
        swap_thing (lm->ctlm_name);
1160
0
        swap_thing (lm->ctlm_offsethi);
1161
0
        swap_thing (lm->ctlm_type);
1162
0
        swap_thing (lm->ctlm_offsetlo);
1163
0
      }
1164
0
        }
1165
0
      else
1166
0
        {
1167
0
    ctf_member_t *m = (ctf_member_t *) t;
1168
0
    ssize_t i;
1169
0
    for (i = vlen; i > 0; i--, m++)
1170
0
      {
1171
0
        swap_thing (m->ctm_name);
1172
0
        swap_thing (m->ctm_offset);
1173
0
        swap_thing (m->ctm_type);
1174
0
      }
1175
0
        }
1176
0
      break;
1177
0
    }
1178
1179
0
  case CTF_K_ENUM:
1180
0
    {
1181
      /* This has an array of ctf_enum_t.  */
1182
1183
0
      ctf_enum_t *item = (ctf_enum_t *) t;
1184
0
      ssize_t i;
1185
1186
0
      for (i = vlen; i > 0; item++, i--)
1187
0
        {
1188
0
    swap_thing (item->cte_name);
1189
0
    swap_thing (item->cte_value);
1190
0
        }
1191
0
      break;
1192
0
    }
1193
0
  default:
1194
0
    ctf_err_warn (fp, 0, ECTF_CORRUPT,
1195
0
      _("unhandled CTF kind in endianness conversion: %x"),
1196
0
      kind);
1197
0
    return ECTF_CORRUPT;
1198
0
  }
1199
1200
0
      t = (ctf_type_t *) ((uintptr_t) t + vbytes);
1201
0
    }
1202
1203
0
  return 0;
1204
0
}
1205
1206
/* Flip the endianness of BUF, given the offsets in the (already endian-
1207
   converted) CTH.  If TO_FOREIGN is set, flip to foreign-endianness; if not,
1208
   flip away.
1209
1210
   All of this stuff happens before the header is fully initialized, so the
1211
   LCTF_*() macros cannot be used yet.  Since we do not try to endian-convert v1
1212
   data, this is no real loss.  */
1213
1214
int
1215
ctf_flip (ctf_dict_t *fp, ctf_header_t *cth, unsigned char *buf,
1216
    int to_foreign)
1217
0
{
1218
0
  ctf_dprintf("flipping endianness\n");
1219
1220
0
  flip_lbls (buf + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff);
1221
0
  flip_objts (buf + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff);
1222
0
  flip_objts (buf + cth->cth_funcoff, cth->cth_objtidxoff - cth->cth_funcoff);
1223
0
  flip_objts (buf + cth->cth_objtidxoff, cth->cth_funcidxoff - cth->cth_objtidxoff);
1224
0
  flip_objts (buf + cth->cth_funcidxoff, cth->cth_varoff - cth->cth_funcidxoff);
1225
0
  flip_vars (buf + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff);
1226
0
  return flip_types (fp, buf + cth->cth_typeoff,
1227
0
         cth->cth_stroff - cth->cth_typeoff, to_foreign);
1228
0
}
1229
1230
/* Set up the ctl hashes in a ctf_dict_t.  Called by both writable and
1231
   non-writable dictionary initialization.  */
1232
void ctf_set_ctl_hashes (ctf_dict_t *fp)
1233
0
{
1234
  /* Initialize the ctf_lookup_by_name top-level dictionary.  We keep an
1235
     array of type name prefixes and the corresponding ctf_hash to use.  */
1236
0
  fp->ctf_lookups[0].ctl_prefix = "struct";
1237
0
  fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
1238
0
  fp->ctf_lookups[0].ctl_hash = &fp->ctf_structs;
1239
0
  fp->ctf_lookups[1].ctl_prefix = "union";
1240
0
  fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
1241
0
  fp->ctf_lookups[1].ctl_hash = &fp->ctf_unions;
1242
0
  fp->ctf_lookups[2].ctl_prefix = "enum";
1243
0
  fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
1244
0
  fp->ctf_lookups[2].ctl_hash = &fp->ctf_enums;
1245
0
  fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
1246
0
  fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
1247
0
  fp->ctf_lookups[3].ctl_hash = &fp->ctf_names;
1248
0
  fp->ctf_lookups[4].ctl_prefix = NULL;
1249
0
  fp->ctf_lookups[4].ctl_len = 0;
1250
0
  fp->ctf_lookups[4].ctl_hash = NULL;
1251
0
}
1252
1253
/* Open a CTF file, mocking up a suitable ctf_sect.  */
1254
1255
ctf_dict_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
1256
           const char *symsect, size_t symsect_size,
1257
           size_t symsect_entsize,
1258
           const char *strsect, size_t strsect_size,
1259
           int *errp)
1260
0
{
1261
0
  return ctf_simple_open_internal (ctfsect, ctfsect_size, symsect, symsect_size,
1262
0
           symsect_entsize, strsect, strsect_size, NULL,
1263
0
           0, errp);
1264
0
}
1265
1266
/* Open a CTF file, mocking up a suitable ctf_sect and overriding the external
1267
   strtab with a synthetic one.  */
1268
1269
ctf_dict_t *ctf_simple_open_internal (const char *ctfsect, size_t ctfsect_size,
1270
              const char *symsect, size_t symsect_size,
1271
              size_t symsect_entsize,
1272
              const char *strsect, size_t strsect_size,
1273
              ctf_dynhash_t *syn_strtab, int writable,
1274
              int *errp)
1275
0
{
1276
0
  ctf_sect_t skeleton;
1277
1278
0
  ctf_sect_t ctf_sect, sym_sect, str_sect;
1279
0
  ctf_sect_t *ctfsectp = NULL;
1280
0
  ctf_sect_t *symsectp = NULL;
1281
0
  ctf_sect_t *strsectp = NULL;
1282
1283
0
  skeleton.cts_name = _CTF_SECTION;
1284
0
  skeleton.cts_entsize = 1;
1285
1286
0
  if (ctfsect)
1287
0
    {
1288
0
      memcpy (&ctf_sect, &skeleton, sizeof (struct ctf_sect));
1289
0
      ctf_sect.cts_data = ctfsect;
1290
0
      ctf_sect.cts_size = ctfsect_size;
1291
0
      ctfsectp = &ctf_sect;
1292
0
    }
1293
1294
0
  if (symsect)
1295
0
    {
1296
0
      memcpy (&sym_sect, &skeleton, sizeof (struct ctf_sect));
1297
0
      sym_sect.cts_data = symsect;
1298
0
      sym_sect.cts_size = symsect_size;
1299
0
      sym_sect.cts_entsize = symsect_entsize;
1300
0
      symsectp = &sym_sect;
1301
0
    }
1302
1303
0
  if (strsect)
1304
0
    {
1305
0
      memcpy (&str_sect, &skeleton, sizeof (struct ctf_sect));
1306
0
      str_sect.cts_data = strsect;
1307
0
      str_sect.cts_size = strsect_size;
1308
0
      strsectp = &str_sect;
1309
0
    }
1310
1311
0
  return ctf_bufopen_internal (ctfsectp, symsectp, strsectp, syn_strtab,
1312
0
             writable, errp);
1313
0
}
1314
1315
/* Decode the specified CTF buffer and optional symbol table, and create a new
1316
   CTF dict representing the symbolic debugging information.  This code can
1317
   be used directly by the debugger, or it can be used as the engine for
1318
   ctf_fdopen() or ctf_open(), below.  */
1319
1320
ctf_dict_t *
1321
ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1322
       const ctf_sect_t *strsect, int *errp)
1323
0
{
1324
0
  return ctf_bufopen_internal (ctfsect, symsect, strsect, NULL, 0, errp);
1325
0
}
1326
1327
/* Like ctf_bufopen, but overriding the external strtab with a synthetic one.  */
1328
1329
ctf_dict_t *
1330
ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1331
          const ctf_sect_t *strsect, ctf_dynhash_t *syn_strtab,
1332
          int writable, int *errp)
1333
0
{
1334
0
  const ctf_preamble_t *pp;
1335
0
  size_t hdrsz = sizeof (ctf_header_t);
1336
0
  ctf_header_t *hp;
1337
0
  ctf_dict_t *fp;
1338
0
  int foreign_endian = 0;
1339
0
  int err;
1340
1341
0
  libctf_init_debug();
1342
1343
0
  if ((ctfsect == NULL) || ((symsect != NULL) &&
1344
0
          ((strsect == NULL) && syn_strtab == NULL)))
1345
0
    return (ctf_set_open_errno (errp, EINVAL));
1346
1347
0
  if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) &&
1348
0
      symsect->cts_entsize != sizeof (Elf64_Sym))
1349
0
    return (ctf_set_open_errno (errp, ECTF_SYMTAB));
1350
1351
0
  if (symsect != NULL && symsect->cts_data == NULL)
1352
0
    return (ctf_set_open_errno (errp, ECTF_SYMBAD));
1353
1354
0
  if (strsect != NULL && strsect->cts_data == NULL)
1355
0
    return (ctf_set_open_errno (errp, ECTF_STRBAD));
1356
1357
0
  if (ctfsect->cts_data == NULL
1358
0
      || ctfsect->cts_size < sizeof (ctf_preamble_t))
1359
0
    return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1360
1361
0
  pp = (const ctf_preamble_t *) ctfsect->cts_data;
1362
1363
0
  ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1364
0
         pp->ctp_magic, pp->ctp_version);
1365
1366
  /* Validate each part of the CTF header.
1367
1368
     First, we validate the preamble (common to all versions).  At that point,
1369
     we know the endianness and specific header version, and can validate the
1370
     version-specific parts including section offsets and alignments.
1371
1372
     We specifically do not support foreign-endian old versions.  */
1373
1374
0
  if (_libctf_unlikely_ (pp->ctp_magic != CTF_MAGIC))
1375
0
    {
1376
0
      if (pp->ctp_magic == bswap_16 (CTF_MAGIC))
1377
0
  {
1378
0
    if (pp->ctp_version != CTF_VERSION_3)
1379
0
      return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1380
0
    foreign_endian = 1;
1381
0
  }
1382
0
      else
1383
0
  return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1384
0
    }
1385
1386
0
  if (_libctf_unlikely_ ((pp->ctp_version < CTF_VERSION_1)
1387
0
       || (pp->ctp_version > CTF_VERSION_3)))
1388
0
    return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1389
1390
0
  if ((symsect != NULL) && (pp->ctp_version < CTF_VERSION_2))
1391
0
    {
1392
      /* The symtab can contain function entries which contain embedded ctf
1393
   info.  We do not support dynamically upgrading such entries (none
1394
   should exist in any case, since dwarf2ctf does not create them).  */
1395
1396
0
      ctf_err_warn (NULL, 0, ECTF_NOTSUP, _("ctf_bufopen: CTF version %d "
1397
0
              "symsect not supported"),
1398
0
        pp->ctp_version);
1399
0
      return (ctf_set_open_errno (errp, ECTF_NOTSUP));
1400
0
    }
1401
1402
0
  if (pp->ctp_version < CTF_VERSION_3)
1403
0
    hdrsz = sizeof (ctf_header_v2_t);
1404
1405
0
  if (_libctf_unlikely_ (pp->ctp_flags > CTF_F_MAX))
1406
0
    {
1407
0
      ctf_err_warn (NULL, 0, ECTF_FLAGS, _("ctf_bufopen: invalid header "
1408
0
             "flags: %x"),
1409
0
        (unsigned int) pp->ctp_flags);
1410
0
      return (ctf_set_open_errno (errp, ECTF_FLAGS));
1411
0
    }
1412
1413
0
  if (ctfsect->cts_size < hdrsz)
1414
0
    return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1415
1416
0
  if ((fp = malloc (sizeof (ctf_dict_t))) == NULL)
1417
0
    return (ctf_set_open_errno (errp, ENOMEM));
1418
1419
0
  memset (fp, 0, sizeof (ctf_dict_t));
1420
1421
0
  if (writable)
1422
0
    fp->ctf_flags |= LCTF_RDWR;
1423
1424
0
  if ((fp->ctf_header = malloc (sizeof (struct ctf_header))) == NULL)
1425
0
    {
1426
0
      free (fp);
1427
0
      return (ctf_set_open_errno (errp, ENOMEM));
1428
0
    }
1429
0
  hp = fp->ctf_header;
1430
0
  memcpy (hp, ctfsect->cts_data, hdrsz);
1431
0
  if (pp->ctp_version < CTF_VERSION_3)
1432
0
    upgrade_header (hp);
1433
1434
0
  if (foreign_endian)
1435
0
    ctf_flip_header (hp);
1436
0
  fp->ctf_openflags = hp->cth_flags;
1437
0
  fp->ctf_size = hp->cth_stroff + hp->cth_strlen;
1438
1439
0
  ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
1440
0
         (unsigned long) fp->ctf_size);
1441
1442
0
  if (hp->cth_lbloff > fp->ctf_size || hp->cth_objtoff > fp->ctf_size
1443
0
      || hp->cth_funcoff > fp->ctf_size || hp->cth_objtidxoff > fp->ctf_size
1444
0
      || hp->cth_funcidxoff > fp->ctf_size || hp->cth_typeoff > fp->ctf_size
1445
0
      || hp->cth_stroff > fp->ctf_size)
1446
0
    {
1447
0
      ctf_err_warn (NULL, 0, ECTF_CORRUPT, _("header offset exceeds CTF size"));
1448
0
      return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1449
0
    }
1450
1451
0
  if (hp->cth_lbloff > hp->cth_objtoff
1452
0
      || hp->cth_objtoff > hp->cth_funcoff
1453
0
      || hp->cth_funcoff > hp->cth_typeoff
1454
0
      || hp->cth_funcoff > hp->cth_objtidxoff
1455
0
      || hp->cth_objtidxoff > hp->cth_funcidxoff
1456
0
      || hp->cth_funcidxoff > hp->cth_varoff
1457
0
      || hp->cth_varoff > hp->cth_typeoff || hp->cth_typeoff > hp->cth_stroff)
1458
0
    {
1459
0
      ctf_err_warn (NULL, 0, ECTF_CORRUPT, _("overlapping CTF sections"));
1460
0
      return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1461
0
    }
1462
1463
0
  if ((hp->cth_lbloff & 3) || (hp->cth_objtoff & 2)
1464
0
      || (hp->cth_funcoff & 2) || (hp->cth_objtidxoff & 2)
1465
0
      || (hp->cth_funcidxoff & 2) || (hp->cth_varoff & 3)
1466
0
      || (hp->cth_typeoff & 3))
1467
0
    {
1468
0
      ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1469
0
        _("CTF sections not properly aligned"));
1470
0
      return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1471
0
    }
1472
1473
  /* This invariant will be lifted in v4, but for now it is true.  */
1474
1475
0
  if ((hp->cth_funcidxoff - hp->cth_objtidxoff != 0) &&
1476
0
      (hp->cth_funcidxoff - hp->cth_objtidxoff
1477
0
       != hp->cth_funcoff - hp->cth_objtoff))
1478
0
    {
1479
0
      ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1480
0
        _("Object index section is neither empty nor the "
1481
0
          "same length as the object section: %u versus %u "
1482
0
          "bytes"), hp->cth_funcoff - hp->cth_objtoff,
1483
0
        hp->cth_funcidxoff - hp->cth_objtidxoff);
1484
0
      return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1485
0
    }
1486
1487
0
  if ((hp->cth_varoff - hp->cth_funcidxoff != 0) &&
1488
0
      (hp->cth_varoff - hp->cth_funcidxoff
1489
0
       != hp->cth_objtidxoff - hp->cth_funcoff) &&
1490
0
      (hp->cth_flags & CTF_F_NEWFUNCINFO))
1491
0
    {
1492
0
      ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1493
0
        _("Function index section is neither empty nor the "
1494
0
          "same length as the function section: %u versus %u "
1495
0
          "bytes"), hp->cth_objtidxoff - hp->cth_funcoff,
1496
0
        hp->cth_varoff - hp->cth_funcidxoff);
1497
0
      return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1498
0
    }
1499
1500
  /* Once everything is determined to be valid, attempt to decompress the CTF
1501
     data buffer if it is compressed, or copy it into new storage if it is not
1502
     compressed but needs endian-flipping.  Otherwise we just put the data
1503
     section's buffer pointer into ctf_buf, below.  */
1504
1505
  /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1506
     init_types().  */
1507
1508
0
  if (hp->cth_flags & CTF_F_COMPRESS)
1509
0
    {
1510
0
      size_t srclen;
1511
0
      uLongf dstlen;
1512
0
      const void *src;
1513
0
      int rc = Z_OK;
1514
1515
      /* We are allocating this ourselves, so we can drop the ctf header
1516
   copy in favour of ctf->ctf_header.  */
1517
1518
0
      if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
1519
0
  {
1520
0
    err = ECTF_ZALLOC;
1521
0
    goto bad;
1522
0
  }
1523
0
      fp->ctf_dynbase = fp->ctf_base;
1524
0
      hp->cth_flags &= ~CTF_F_COMPRESS;
1525
1526
0
      src = (unsigned char *) ctfsect->cts_data + hdrsz;
1527
0
      srclen = ctfsect->cts_size - hdrsz;
1528
0
      dstlen = fp->ctf_size;
1529
0
      fp->ctf_buf = fp->ctf_base;
1530
1531
0
      if ((rc = uncompress (fp->ctf_base, &dstlen, src, srclen)) != Z_OK)
1532
0
  {
1533
0
    ctf_err_warn (NULL, 0, ECTF_DECOMPRESS, _("zlib inflate err: %s"),
1534
0
      zError (rc));
1535
0
    err = ECTF_DECOMPRESS;
1536
0
    goto bad;
1537
0
  }
1538
1539
0
      if ((size_t) dstlen != fp->ctf_size)
1540
0
  {
1541
0
    ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1542
0
      _("zlib inflate short: got %lu of %lu bytes"),
1543
0
      (unsigned long) dstlen, (unsigned long) fp->ctf_size);
1544
0
    err = ECTF_CORRUPT;
1545
0
    goto bad;
1546
0
  }
1547
0
    }
1548
0
  else
1549
0
    {
1550
0
      if (_libctf_unlikely_ (ctfsect->cts_size < hdrsz + fp->ctf_size))
1551
0
  {
1552
0
    ctf_err_warn (NULL, 0, ECTF_CORRUPT,
1553
0
      _("%lu byte long CTF dictionary overruns %lu byte long CTF section"),
1554
0
      (unsigned long) ctfsect->cts_size,
1555
0
      (unsigned long) (hdrsz + fp->ctf_size));
1556
0
    err = ECTF_CORRUPT;
1557
0
    goto bad;
1558
0
  }
1559
1560
0
      if (foreign_endian)
1561
0
  {
1562
0
    if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
1563
0
      {
1564
0
        err = ECTF_ZALLOC;
1565
0
        goto bad;
1566
0
      }
1567
0
    fp->ctf_dynbase = fp->ctf_base;
1568
0
    memcpy (fp->ctf_base, ((unsigned char *) ctfsect->cts_data) + hdrsz,
1569
0
      fp->ctf_size);
1570
0
    fp->ctf_buf = fp->ctf_base;
1571
0
  }
1572
0
      else
1573
0
  {
1574
    /* We are just using the section passed in -- but its header may
1575
       be an old version.  Point ctf_buf past the old header, and
1576
       never touch it again.  */
1577
0
    fp->ctf_base = (unsigned char *) ctfsect->cts_data;
1578
0
    fp->ctf_dynbase = NULL;
1579
0
    fp->ctf_buf = fp->ctf_base + hdrsz;
1580
0
  }
1581
0
    }
1582
1583
  /* Once we have uncompressed and validated the CTF data buffer, we can
1584
     proceed with initializing the ctf_dict_t we allocated above.
1585
1586
     Nothing that depends on buf or base should be set directly in this function
1587
     before the init_types() call, because it may be reallocated during
1588
     transparent upgrade if this recension of libctf is so configured: see
1589
     ctf_set_base().  */
1590
1591
0
  ctf_set_version (fp, hp, hp->cth_version);
1592
0
  if (ctf_str_create_atoms (fp) < 0)
1593
0
    {
1594
0
      err = ENOMEM;
1595
0
      goto bad;
1596
0
    }
1597
1598
0
  fp->ctf_parmax = CTF_MAX_PTYPE;
1599
0
  memcpy (&fp->ctf_data, ctfsect, sizeof (ctf_sect_t));
1600
1601
0
  if (symsect != NULL)
1602
0
    {
1603
0
      memcpy (&fp->ctf_symtab, symsect, sizeof (ctf_sect_t));
1604
0
      memcpy (&fp->ctf_strtab, strsect, sizeof (ctf_sect_t));
1605
0
    }
1606
1607
0
  if (fp->ctf_data.cts_name != NULL)
1608
0
    if ((fp->ctf_data.cts_name = strdup (fp->ctf_data.cts_name)) == NULL)
1609
0
      {
1610
0
  err = ENOMEM;
1611
0
  goto bad;
1612
0
      }
1613
0
  if (fp->ctf_symtab.cts_name != NULL)
1614
0
    if ((fp->ctf_symtab.cts_name = strdup (fp->ctf_symtab.cts_name)) == NULL)
1615
0
      {
1616
0
  err = ENOMEM;
1617
0
  goto bad;
1618
0
      }
1619
0
  if (fp->ctf_strtab.cts_name != NULL)
1620
0
    if ((fp->ctf_strtab.cts_name = strdup (fp->ctf_strtab.cts_name)) == NULL)
1621
0
      {
1622
0
  err = ENOMEM;
1623
0
  goto bad;
1624
0
      }
1625
1626
0
  if (fp->ctf_data.cts_name == NULL)
1627
0
    fp->ctf_data.cts_name = _CTF_NULLSTR;
1628
0
  if (fp->ctf_symtab.cts_name == NULL)
1629
0
    fp->ctf_symtab.cts_name = _CTF_NULLSTR;
1630
0
  if (fp->ctf_strtab.cts_name == NULL)
1631
0
    fp->ctf_strtab.cts_name = _CTF_NULLSTR;
1632
1633
0
  if (strsect != NULL)
1634
0
    {
1635
0
      fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data;
1636
0
      fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size;
1637
0
    }
1638
0
  fp->ctf_syn_ext_strtab = syn_strtab;
1639
1640
0
  if (foreign_endian &&
1641
0
      (err = ctf_flip (fp, hp, fp->ctf_buf, 0)) != 0)
1642
0
    {
1643
      /* We can be certain that ctf_flip() will have endian-flipped everything
1644
   other than the types table when we return.  In particular the header
1645
   is fine, so set it, to allow freeing to use the usual code path.  */
1646
1647
0
      ctf_set_base (fp, hp, fp->ctf_base);
1648
0
      goto bad;
1649
0
    }
1650
1651
0
  ctf_set_base (fp, hp, fp->ctf_base);
1652
1653
  /* No need to do anything else for dynamic dicts: they do not support symbol
1654
     lookups, and the type table is maintained in the dthashes.  */
1655
0
  if (fp->ctf_flags & LCTF_RDWR)
1656
0
    {
1657
0
      fp->ctf_refcnt = 1;
1658
0
      return fp;
1659
0
    }
1660
1661
0
  if ((err = init_types (fp, hp)) != 0)
1662
0
    goto bad;
1663
1664
  /* Allocate and initialize the symtab translation table, pointed to by
1665
     ctf_sxlate, and the corresponding index sections.  This table may be too
1666
     large for the actual size of the object and function info sections: if so,
1667
     ctf_nsyms will be adjusted and the excess will never be used.  It's
1668
     possible to do indexed symbol lookups even without a symbol table, so check
1669
     even in that case.  Initially, we assume the symtab is native-endian: if it
1670
     isn't, the caller will inform us later by calling ctf_symsect_endianness.  */
1671
#ifdef WORDS_BIGENDIAN
1672
  fp->ctf_symsect_little_endian = 0;
1673
#else
1674
0
  fp->ctf_symsect_little_endian = 1;
1675
0
#endif
1676
1677
0
  if (symsect != NULL)
1678
0
    {
1679
0
      fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
1680
0
      fp->ctf_sxlate = malloc (fp->ctf_nsyms * sizeof (uint32_t));
1681
1682
0
      if (fp->ctf_sxlate == NULL)
1683
0
  {
1684
0
    err = ENOMEM;
1685
0
    goto bad;
1686
0
  }
1687
0
    }
1688
1689
0
  if ((err = init_symtab (fp, hp, symsect)) != 0)
1690
0
    goto bad;
1691
1692
0
  ctf_set_ctl_hashes (fp);
1693
1694
0
  if (symsect != NULL)
1695
0
    {
1696
0
      if (symsect->cts_entsize == sizeof (Elf64_Sym))
1697
0
  (void) ctf_setmodel (fp, CTF_MODEL_LP64);
1698
0
      else
1699
0
  (void) ctf_setmodel (fp, CTF_MODEL_ILP32);
1700
0
    }
1701
0
  else
1702
0
    (void) ctf_setmodel (fp, CTF_MODEL_NATIVE);
1703
1704
0
  fp->ctf_refcnt = 1;
1705
0
  return fp;
1706
1707
0
bad:
1708
0
  ctf_set_open_errno (errp, err);
1709
0
  ctf_err_warn_to_open (fp);
1710
0
  ctf_dict_close (fp);
1711
0
  return NULL;
1712
0
}
1713
1714
/* Bump the refcount on the specified CTF dict, to allow export of ctf_dict_t's
1715
   from iterators that open and close the ctf_dict_t around the loop.  (This
1716
   does not extend their lifetime beyond that of the ctf_archive_t in which they
1717
   are contained.)  */
1718
1719
void
1720
ctf_ref (ctf_dict_t *fp)
1721
0
{
1722
0
  fp->ctf_refcnt++;
1723
0
}
1724
1725
/* Close the specified CTF dict and free associated data structures.  Note that
1726
   ctf_dict_close() is a reference counted operation: if the specified file is
1727
   the parent of other active dict, its reference count will be greater than one
1728
   and it will be freed later when no active children exist.  */
1729
1730
void
1731
ctf_dict_close (ctf_dict_t *fp)
1732
0
{
1733
0
  ctf_dtdef_t *dtd, *ntd;
1734
0
  ctf_dvdef_t *dvd, *nvd;
1735
0
  ctf_in_flight_dynsym_t *did, *nid;
1736
0
  ctf_err_warning_t *err, *nerr;
1737
1738
0
  if (fp == NULL)
1739
0
    return;      /* Allow ctf_dict_close(NULL) to simplify caller code.  */
1740
1741
0
  ctf_dprintf ("ctf_dict_close(%p) refcnt=%u\n", (void *) fp, fp->ctf_refcnt);
1742
1743
0
  if (fp->ctf_refcnt > 1)
1744
0
    {
1745
0
      fp->ctf_refcnt--;
1746
0
      return;
1747
0
    }
1748
1749
  /* It is possible to recurse back in here, notably if dicts in the
1750
     ctf_link_inputs or ctf_link_outputs cite this dict as a parent without
1751
     using ctf_import_unref.  Do nothing in that case.  */
1752
0
  if (fp->ctf_refcnt == 0)
1753
0
    return;
1754
1755
0
  fp->ctf_refcnt--;
1756
0
  free (fp->ctf_dyncuname);
1757
0
  free (fp->ctf_dynparname);
1758
0
  if (fp->ctf_parent && !fp->ctf_parent_unreffed)
1759
0
    ctf_dict_close (fp->ctf_parent);
1760
1761
0
  for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
1762
0
    {
1763
0
      ntd = ctf_list_next (dtd);
1764
0
      ctf_dtd_delete (fp, dtd);
1765
0
    }
1766
0
  ctf_dynhash_destroy (fp->ctf_dthash);
1767
0
  if (fp->ctf_flags & LCTF_RDWR)
1768
0
    {
1769
0
      ctf_dynhash_destroy (fp->ctf_structs.ctn_writable);
1770
0
      ctf_dynhash_destroy (fp->ctf_unions.ctn_writable);
1771
0
      ctf_dynhash_destroy (fp->ctf_enums.ctn_writable);
1772
0
      ctf_dynhash_destroy (fp->ctf_names.ctn_writable);
1773
0
    }
1774
0
  else
1775
0
    {
1776
0
      ctf_hash_destroy (fp->ctf_structs.ctn_readonly);
1777
0
      ctf_hash_destroy (fp->ctf_unions.ctn_readonly);
1778
0
      ctf_hash_destroy (fp->ctf_enums.ctn_readonly);
1779
0
      ctf_hash_destroy (fp->ctf_names.ctn_readonly);
1780
0
    }
1781
1782
0
  for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
1783
0
    {
1784
0
      nvd = ctf_list_next (dvd);
1785
0
      ctf_dvd_delete (fp, dvd);
1786
0
    }
1787
0
  ctf_dynhash_destroy (fp->ctf_dvhash);
1788
1789
0
  ctf_dynhash_destroy (fp->ctf_symhash);
1790
0
  free (fp->ctf_funcidx_sxlate);
1791
0
  free (fp->ctf_objtidx_sxlate);
1792
0
  ctf_dynhash_destroy (fp->ctf_objthash);
1793
0
  ctf_dynhash_destroy (fp->ctf_funchash);
1794
0
  free (fp->ctf_dynsymidx);
1795
0
  ctf_dynhash_destroy (fp->ctf_dynsyms);
1796
0
  for (did = ctf_list_next (&fp->ctf_in_flight_dynsyms); did != NULL; did = nid)
1797
0
    {
1798
0
      nid = ctf_list_next (did);
1799
0
      ctf_list_delete (&fp->ctf_in_flight_dynsyms, did);
1800
0
      free (did);
1801
0
    }
1802
1803
0
  ctf_str_free_atoms (fp);
1804
0
  free (fp->ctf_tmp_typeslice);
1805
1806
0
  if (fp->ctf_data.cts_name != _CTF_NULLSTR)
1807
0
    free ((char *) fp->ctf_data.cts_name);
1808
1809
0
  if (fp->ctf_symtab.cts_name != _CTF_NULLSTR)
1810
0
    free ((char *) fp->ctf_symtab.cts_name);
1811
1812
0
  if (fp->ctf_strtab.cts_name != _CTF_NULLSTR)
1813
0
    free ((char *) fp->ctf_strtab.cts_name);
1814
0
  else if (fp->ctf_data_mmapped)
1815
0
    ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
1816
1817
0
  free (fp->ctf_dynbase);
1818
1819
0
  ctf_dynhash_destroy (fp->ctf_syn_ext_strtab);
1820
0
  ctf_dynhash_destroy (fp->ctf_link_inputs);
1821
0
  ctf_dynhash_destroy (fp->ctf_link_outputs);
1822
0
  ctf_dynhash_destroy (fp->ctf_link_type_mapping);
1823
0
  ctf_dynhash_destroy (fp->ctf_link_in_cu_mapping);
1824
0
  ctf_dynhash_destroy (fp->ctf_link_out_cu_mapping);
1825
0
  ctf_dynhash_destroy (fp->ctf_add_processing);
1826
0
  ctf_dedup_fini (fp, NULL, 0);
1827
0
  ctf_dynset_destroy (fp->ctf_dedup_atoms_alloc);
1828
1829
0
  for (err = ctf_list_next (&fp->ctf_errs_warnings); err != NULL; err = nerr)
1830
0
    {
1831
0
      nerr = ctf_list_next (err);
1832
0
      ctf_list_delete (&fp->ctf_errs_warnings, err);
1833
0
      free (err->cew_text);
1834
0
      free (err);
1835
0
    }
1836
1837
0
  free (fp->ctf_sxlate);
1838
0
  free (fp->ctf_txlate);
1839
0
  free (fp->ctf_ptrtab);
1840
0
  free (fp->ctf_pptrtab);
1841
1842
0
  free (fp->ctf_header);
1843
0
  free (fp);
1844
0
}
1845
1846
/* Backward compatibility.  */
1847
void
1848
ctf_file_close (ctf_file_t *fp)
1849
0
{
1850
0
  ctf_dict_close (fp);
1851
0
}
1852
1853
/* The converse of ctf_open().  ctf_open() disguises whatever it opens as an
1854
   archive, so closing one is just like closing an archive.  */
1855
void
1856
ctf_close (ctf_archive_t *arc)
1857
0
{
1858
0
  ctf_arc_close (arc);
1859
0
}
1860
1861
/* Get the CTF archive from which this ctf_dict_t is derived.  */
1862
ctf_archive_t *
1863
ctf_get_arc (const ctf_dict_t *fp)
1864
0
{
1865
0
  return fp->ctf_archive;
1866
0
}
1867
1868
/* Return the ctfsect out of the core ctf_impl.  Useful for freeing the
1869
   ctfsect's data * after ctf_dict_close(), which is why we return the actual
1870
   structure, not a pointer to it, since that is likely to become a pointer to
1871
   freed data before the return value is used under the expected use case of
1872
   ctf_getsect()/ ctf_dict_close()/free().  */
1873
ctf_sect_t
1874
ctf_getdatasect (const ctf_dict_t *fp)
1875
0
{
1876
0
  return fp->ctf_data;
1877
0
}
1878
1879
ctf_sect_t
1880
ctf_getsymsect (const ctf_dict_t *fp)
1881
0
{
1882
0
  return fp->ctf_symtab;
1883
0
}
1884
1885
ctf_sect_t
1886
ctf_getstrsect (const ctf_dict_t *fp)
1887
0
{
1888
0
  return fp->ctf_strtab;
1889
0
}
1890
1891
/* Set the endianness of the symbol table attached to FP.  */
1892
void
1893
ctf_symsect_endianness (ctf_dict_t *fp, int little_endian)
1894
0
{
1895
0
  int old_endianness = fp->ctf_symsect_little_endian;
1896
1897
0
  fp->ctf_symsect_little_endian = !!little_endian;
1898
1899
  /* If we already have a symtab translation table, we need to repopulate it if
1900
     our idea of the endianness has changed.  */
1901
1902
0
  if (old_endianness != fp->ctf_symsect_little_endian
1903
0
      && fp->ctf_sxlate != NULL && fp->ctf_symtab.cts_data != NULL)
1904
0
    assert (init_symtab (fp, fp->ctf_header, &fp->ctf_symtab) == 0);
1905
0
}
1906
1907
/* Return the CTF handle for the parent CTF dict, if one exists.  Otherwise
1908
   return NULL to indicate this dict has no imported parent.  */
1909
ctf_dict_t *
1910
ctf_parent_dict (ctf_dict_t *fp)
1911
0
{
1912
0
  return fp->ctf_parent;
1913
0
}
1914
1915
/* Backward compatibility.  */
1916
ctf_dict_t *
1917
ctf_parent_file (ctf_dict_t *fp)
1918
0
{
1919
0
  return ctf_parent_dict (fp);
1920
0
}
1921
1922
/* Return the name of the parent CTF dict, if one exists, or NULL otherwise.  */
1923
const char *
1924
ctf_parent_name (ctf_dict_t *fp)
1925
0
{
1926
0
  return fp->ctf_parname;
1927
0
}
1928
1929
/* Set the parent name.  It is an error to call this routine without calling
1930
   ctf_import() at some point.  */
1931
int
1932
ctf_parent_name_set (ctf_dict_t *fp, const char *name)
1933
0
{
1934
0
  if (fp->ctf_dynparname != NULL)
1935
0
    free (fp->ctf_dynparname);
1936
1937
0
  if ((fp->ctf_dynparname = strdup (name)) == NULL)
1938
0
    return (ctf_set_errno (fp, ENOMEM));
1939
0
  fp->ctf_parname = fp->ctf_dynparname;
1940
0
  return 0;
1941
0
}
1942
1943
/* Return the name of the compilation unit this CTF file applies to.  Usually
1944
   non-NULL only for non-parent dicts.  */
1945
const char *
1946
ctf_cuname (ctf_dict_t *fp)
1947
0
{
1948
0
  return fp->ctf_cuname;
1949
0
}
1950
1951
/* Set the compilation unit name.  */
1952
int
1953
ctf_cuname_set (ctf_dict_t *fp, const char *name)
1954
0
{
1955
0
  if (fp->ctf_dyncuname != NULL)
1956
0
    free (fp->ctf_dyncuname);
1957
1958
0
  if ((fp->ctf_dyncuname = strdup (name)) == NULL)
1959
0
    return (ctf_set_errno (fp, ENOMEM));
1960
0
  fp->ctf_cuname = fp->ctf_dyncuname;
1961
0
  return 0;
1962
0
}
1963
1964
/* Import the types from the specified parent dict by storing a pointer to it in
1965
   ctf_parent and incrementing its reference count.  Only one parent is allowed:
1966
   if a parent already exists, it is replaced by the new parent.  The pptrtab
1967
   is wiped, and will be refreshed by the next ctf_lookup_by_name call.  */
1968
int
1969
ctf_import (ctf_dict_t *fp, ctf_dict_t *pfp)
1970
0
{
1971
0
  if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
1972
0
    return (ctf_set_errno (fp, EINVAL));
1973
1974
0
  if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
1975
0
    return (ctf_set_errno (fp, ECTF_DMODEL));
1976
1977
0
  if (fp->ctf_parent && !fp->ctf_parent_unreffed)
1978
0
    ctf_dict_close (fp->ctf_parent);
1979
0
  fp->ctf_parent = NULL;
1980
1981
0
  free (fp->ctf_pptrtab);
1982
0
  fp->ctf_pptrtab = NULL;
1983
0
  fp->ctf_pptrtab_len = 0;
1984
0
  fp->ctf_pptrtab_typemax = 0;
1985
1986
0
  if (pfp != NULL)
1987
0
    {
1988
0
      int err;
1989
1990
0
      if (fp->ctf_parname == NULL)
1991
0
  if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
1992
0
    return err;
1993
1994
0
      fp->ctf_flags |= LCTF_CHILD;
1995
0
      pfp->ctf_refcnt++;
1996
0
      fp->ctf_parent_unreffed = 0;
1997
0
    }
1998
1999
0
  fp->ctf_parent = pfp;
2000
0
  return 0;
2001
0
}
2002
2003
/* Like ctf_import, but does not increment the refcount on the imported parent
2004
   or close it at any point: as a result it can go away at any time and the
2005
   caller must do all freeing itself.  Used internally to avoid refcount
2006
   loops.  */
2007
int
2008
ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp)
2009
0
{
2010
0
  if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
2011
0
    return (ctf_set_errno (fp, EINVAL));
2012
2013
0
  if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
2014
0
    return (ctf_set_errno (fp, ECTF_DMODEL));
2015
2016
0
  if (fp->ctf_parent && !fp->ctf_parent_unreffed)
2017
0
    ctf_dict_close (fp->ctf_parent);
2018
0
  fp->ctf_parent = NULL;
2019
2020
0
  free (fp->ctf_pptrtab);
2021
0
  fp->ctf_pptrtab = NULL;
2022
0
  fp->ctf_pptrtab_len = 0;
2023
0
  fp->ctf_pptrtab_typemax = 0;
2024
0
  if (pfp != NULL)
2025
0
    {
2026
0
      int err;
2027
2028
0
      if (fp->ctf_parname == NULL)
2029
0
  if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
2030
0
    return err;
2031
2032
0
      fp->ctf_flags |= LCTF_CHILD;
2033
0
      fp->ctf_parent_unreffed = 1;
2034
0
    }
2035
2036
0
  fp->ctf_parent = pfp;
2037
0
  return 0;
2038
0
}
2039
2040
/* Set the data model constant for the CTF dict.  */
2041
int
2042
ctf_setmodel (ctf_dict_t *fp, int model)
2043
0
{
2044
0
  const ctf_dmodel_t *dp;
2045
2046
0
  for (dp = _libctf_models; dp->ctd_name != NULL; dp++)
2047
0
    {
2048
0
      if (dp->ctd_code == model)
2049
0
  {
2050
0
    fp->ctf_dmodel = dp;
2051
0
    return 0;
2052
0
  }
2053
0
    }
2054
2055
0
  return (ctf_set_errno (fp, EINVAL));
2056
0
}
2057
2058
/* Return the data model constant for the CTF dict.  */
2059
int
2060
ctf_getmodel (ctf_dict_t *fp)
2061
0
{
2062
0
  return fp->ctf_dmodel->ctd_code;
2063
0
}
2064
2065
/* The caller can hang an arbitrary pointer off each ctf_dict_t using this
2066
   function.  */
2067
void
2068
ctf_setspecific (ctf_dict_t *fp, void *data)
2069
0
{
2070
0
  fp->ctf_specific = data;
2071
0
}
2072
2073
/* Retrieve the arbitrary pointer again.  */
2074
void *
2075
ctf_getspecific (ctf_dict_t *fp)
2076
0
{
2077
0
  return fp->ctf_specific;
2078
0
}