libctf/ctf-open.c

   1 /* Opening CTF files.
   2    Copyright (C) 2019 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 <assert.h>
  26 #include "swap.h"
  27 #include <bfd.h>
  28 #include <zlib.h>
  29
  30 #include "elf-bfd.h"
  31
  32 static const ctf_dmodel_t _libctf_models[] = {
  33   {"ILP32", CTF_MODEL_ILP32, 4, 1, 2, 4, 4},
  34   {"LP64", CTF_MODEL_LP64, 8, 1, 2, 4, 8},
  35   {NULL, 0, 0, 0, 0, 0, 0}
  36 };
  37
  38 const char _CTF_SECTION[] = ".ctf";
  39 const char _CTF_NULLSTR[] = "";
  40
  41 /* Version-sensitive accessors.  */
  42
  43 static uint32_t
  44 get_kind_v1 (uint32_t info)
  45 {
  46   return (CTF_V1_INFO_KIND (info));
  47 }
  48
  49 static uint32_t
  50 get_root_v1 (uint32_t info)
  51 {
  52   return (CTF_V1_INFO_ISROOT (info));
  53 }
  54
  55 static uint32_t
  56 get_vlen_v1 (uint32_t info)
  57 {
  58   return (CTF_V1_INFO_VLEN (info));
  59 }
  60
  61 static uint32_t
  62 get_kind_v2 (uint32_t info)
  63 {
  64   return (CTF_V2_INFO_KIND (info));
  65 }
  66
  67 static uint32_t
  68 get_root_v2 (uint32_t info)
  69 {
  70   return (CTF_V2_INFO_ISROOT (info));
  71 }
  72
  73 static uint32_t
  74 get_vlen_v2 (uint32_t info)
  75 {
  76   return (CTF_V2_INFO_VLEN (info));
  77 }
  78
  79 static inline ssize_t
  80 get_ctt_size_common (const ctf_file_t *fp _libctf_unused_,
  81                      const ctf_type_t *tp _libctf_unused_,
  82                      ssize_t *sizep, ssize_t *incrementp, size_t lsize,
  83                      size_t csize, size_t ctf_type_size,
  84                      size_t ctf_stype_size, size_t ctf_lsize_sent)
  85 {
  86   ssize_t size, increment;
  87
  88   if (csize == ctf_lsize_sent)
  89     {
  90       size = lsize;
  91       increment = ctf_type_size;
  92     }
  93   else
  94     {
  95       size = csize;
  96       increment = ctf_stype_size;
  97     }
  98
  99   if (sizep)
 100     *sizep = size;
 101   if (incrementp)
 102     *incrementp = increment;
 103
 104   return size;
 105 }
 106
 107 static ssize_t
 108 get_ctt_size_v1 (const ctf_file_t *fp, const ctf_type_t *tp,
 109                  ssize_t *sizep, ssize_t *incrementp)
 110 {
 111   ctf_type_v1_t *t1p = (ctf_type_v1_t *) tp;
 112
 113   return (get_ctt_size_common (fp, tp, sizep, incrementp,
 114                                CTF_TYPE_LSIZE (t1p), t1p->ctt_size,
 115                                sizeof (ctf_type_v1_t), sizeof (ctf_stype_v1_t),
 116                                CTF_LSIZE_SENT_V1));
 117 }
 118
 119 /* Return the size that a v1 will be once it is converted to v2.  */
 120
 121 static ssize_t
 122 get_ctt_size_v2_unconverted (const ctf_file_t *fp, const ctf_type_t *tp,
 123                              ssize_t *sizep, ssize_t *incrementp)
 124 {
 125   ctf_type_v1_t *t1p = (ctf_type_v1_t *) tp;
 126
 127   return (get_ctt_size_common (fp, tp, sizep, incrementp,
 128                                CTF_TYPE_LSIZE (t1p), t1p->ctt_size,
 129                                sizeof (ctf_type_t), sizeof (ctf_stype_t),
 130                                CTF_LSIZE_SENT));
 131 }
 132
 133 static ssize_t
 134 get_ctt_size_v2 (const ctf_file_t *fp, const ctf_type_t *tp,
 135                  ssize_t *sizep, ssize_t *incrementp)
 136 {
 137   return (get_ctt_size_common (fp, tp, sizep, incrementp,
 138                                CTF_TYPE_LSIZE (tp), tp->ctt_size,
 139                                sizeof (ctf_type_t), sizeof (ctf_stype_t),
 140                                CTF_LSIZE_SENT));
 141 }
 142
 143 static ssize_t
 144 get_vbytes_common (unsigned short kind, ssize_t size _libctf_unused_,
 145                    size_t vlen)
 146 {
 147   switch (kind)
 148     {
 149     case CTF_K_INTEGER:
 150     case CTF_K_FLOAT:
 151       return (sizeof (uint32_t));
 152     case CTF_K_SLICE:
 153       return (offsetof (ctf_slice_t, cts_bits) +
 154               sizeof (((ctf_slice_t *)0)->cts_bits));
 155     case CTF_K_ENUM:
 156       return (sizeof (ctf_enum_t) * vlen);
 157     case CTF_K_FORWARD:
 158     case CTF_K_UNKNOWN:
 159     case CTF_K_POINTER:
 160     case CTF_K_TYPEDEF:
 161     case CTF_K_VOLATILE:
 162     case CTF_K_CONST:
 163     case CTF_K_RESTRICT:
 164       return 0;
 165     default:
 166       ctf_dprintf ("detected invalid CTF kind -- %x\n", kind);
 167       return ECTF_CORRUPT;
 168     }
 169 }
 170
 171 static ssize_t
 172 get_vbytes_v1 (unsigned short kind, ssize_t size, size_t vlen)
 173 {
 174   switch (kind)
 175     {
 176     case CTF_K_ARRAY:
 177       return (sizeof (ctf_array_v1_t));
 178     case CTF_K_FUNCTION:
 179       return (sizeof (unsigned short) * (vlen + (vlen & 1)));
 180     case CTF_K_STRUCT:
 181     case CTF_K_UNION:
 182       if (size < CTF_LSTRUCT_THRESH_V1)
 183         return (sizeof (ctf_member_v1_t) * vlen);
 184       else
 185         return (sizeof (ctf_lmember_v1_t) * vlen);
 186     }
 187
 188   return (get_vbytes_common (kind, size, vlen));
 189 }
 190
 191 static ssize_t
 192 get_vbytes_v2 (unsigned short kind, ssize_t size, size_t vlen)
 193 {
 194   switch (kind)
 195     {
 196     case CTF_K_ARRAY:
 197       return (sizeof (ctf_array_t));
 198     case CTF_K_FUNCTION:
 199       return (sizeof (uint32_t) * (vlen + (vlen & 1)));
 200     case CTF_K_STRUCT:
 201     case CTF_K_UNION:
 202       if (size < CTF_LSTRUCT_THRESH)
 203         return (sizeof (ctf_member_t) * vlen);
 204       else
 205         return (sizeof (ctf_lmember_t) * vlen);
 206     }
 207
 208   return (get_vbytes_common (kind, size, vlen));
 209 }
 210
 211 static const ctf_fileops_t ctf_fileops[] = {
 212   {NULL, NULL, NULL, NULL, NULL},
 213   /* CTF_VERSION_1 */
 214   {get_kind_v1, get_root_v1, get_vlen_v1, get_ctt_size_v1, get_vbytes_v1},
 215   /* CTF_VERSION_1_UPGRADED_3 */
 216   {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2},
 217   /* CTF_VERSION_2 */
 218   {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2},
 219   /* CTF_VERSION_3, identical to 2: only new type kinds */
 220   {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2},
 221 };
 222
 223 /* Initialize the symtab translation table by filling each entry with the
 224   offset of the CTF type or function data corresponding to each STT_FUNC or
 225   STT_OBJECT entry in the symbol table.  */
 226
 227 static int
 228 init_symtab (ctf_file_t *fp, const ctf_header_t *hp,
 229              const ctf_sect_t *sp, const ctf_sect_t *strp)
 230 {
 231   const unsigned char *symp = sp->cts_data;
 232   uint32_t *xp = fp->ctf_sxlate;
 233   uint32_t *xend = xp + fp->ctf_nsyms;
 234
 235   uint32_t objtoff = hp->cth_objtoff;
 236   uint32_t funcoff = hp->cth_funcoff;
 237
 238   uint32_t info, vlen;
 239   Elf64_Sym sym, *gsp;
 240   const char *name;
 241
 242   /* The CTF data object and function type sections are ordered to match
 243      the relative order of the respective symbol types in the symtab.
 244      If no type information is available for a symbol table entry, a
 245      pad is inserted in the CTF section.  As a further optimization,
 246      anonymous or undefined symbols are omitted from the CTF data.  */
 247
 248   for (; xp < xend; xp++, symp += sp->cts_entsize)
 249     {
 250       if (sp->cts_entsize == sizeof (Elf32_Sym))
 251         gsp = ctf_sym_to_elf64 ((Elf32_Sym *) (uintptr_t) symp, &sym);
 252       else
 253         gsp = (Elf64_Sym *) (uintptr_t) symp;
 254
 255       if (gsp->st_name < strp->cts_size)
 256         name = (const char *) strp->cts_data + gsp->st_name;
 257       else
 258         name = _CTF_NULLSTR;
 259
 260       if (gsp->st_name == 0 || gsp->st_shndx == SHN_UNDEF
 261           || strcmp (name, "_START_") == 0 || strcmp (name, "_END_") == 0)
 262         {
 263           *xp = -1u;
 264           continue;
 265         }
 266
 267       switch (ELF64_ST_TYPE (gsp->st_info))
 268         {
 269         case STT_OBJECT:
 270           if (objtoff >= hp->cth_funcoff
 271               || (gsp->st_shndx == SHN_EXTABS && gsp->st_value == 0))
 272             {
 273               *xp = -1u;
 274               break;
 275             }
 276
 277           *xp = objtoff;
 278           objtoff += sizeof (uint32_t);
 279           break;
 280
 281         case STT_FUNC:
 282           if (funcoff >= hp->cth_typeoff)
 283             {
 284               *xp = -1u;
 285               break;
 286             }
 287
 288           *xp = funcoff;
 289
 290           info = *(uint32_t *) ((uintptr_t) fp->ctf_buf + funcoff);
 291           vlen = LCTF_INFO_VLEN (fp, info);
 292
 293           /* If we encounter a zero pad at the end, just skip it.  Otherwise
 294              skip over the function and its return type (+2) and the argument
 295              list (vlen).
 296            */
 297           if (LCTF_INFO_KIND (fp, info) == CTF_K_UNKNOWN && vlen == 0)
 298             funcoff += sizeof (uint32_t);       /* Skip pad.  */
 299           else
 300             funcoff += sizeof (uint32_t) * (vlen + 2);
 301           break;
 302
 303         default:
 304           *xp = -1u;
 305           break;
 306         }
 307     }
 308
 309   ctf_dprintf ("loaded %lu symtab entries\n", fp->ctf_nsyms);
 310   return 0;
 311 }
 312
 313 /* Set the CTF base pointer and derive the buf pointer from it, initializing
 314    everything in the ctf_file that depends on the base or buf pointers.  */
 315
 316 static void
 317 ctf_set_base (ctf_file_t *fp, const ctf_header_t *hp, void *base)
 318 {
 319   fp->ctf_base = base;
 320   fp->ctf_buf = fp->ctf_base + sizeof (ctf_header_t);
 321   fp->ctf_vars = (ctf_varent_t *) ((const char *) fp->ctf_buf +
 322                                    hp->cth_varoff);
 323   fp->ctf_nvars = (hp->cth_typeoff - hp->cth_varoff) / sizeof (ctf_varent_t);
 324
 325   fp->ctf_str[CTF_STRTAB_0].cts_strs = (const char *) fp->ctf_buf
 326     + hp->cth_stroff;
 327   fp->ctf_str[CTF_STRTAB_0].cts_len = hp->cth_strlen;
 328
 329   /* If we have a parent container name and label, store the relocated
 330      string pointers in the CTF container for easy access later. */
 331
 332   /* Note: before conversion, these will be set to values that will be
 333      immediately invalidated by the conversion process, but the conversion
 334      process will call ctf_set_base() again to fix things up.  */
 335
 336   if (hp->cth_parlabel != 0)
 337     fp->ctf_parlabel = ctf_strptr (fp, hp->cth_parlabel);
 338   if (hp->cth_parname != 0)
 339     fp->ctf_parname = ctf_strptr (fp, hp->cth_parname);
 340
 341   ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n",
 342                fp->ctf_parname ? fp->ctf_parname : "<NULL>",
 343                fp->ctf_parlabel ? fp->ctf_parlabel : "<NULL>");
 344 }
 345
 346 /* Free a ctf_base pointer: the pointer passed, or (if NULL) fp->ctf_base.  */
 347 static void
 348 ctf_free_base (ctf_file_t *fp, unsigned char *ctf_base)
 349 {
 350   unsigned char *base;
 351
 352   if (ctf_base)
 353       base = ctf_base;
 354   else
 355       base = (unsigned char *) fp->ctf_base;
 356
 357   if (base != fp->ctf_data.cts_data && base != NULL)
 358     ctf_free (base);
 359 }
 360
 361 /* Set the version of the CTF file. */
 362
 363 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
 364    the variable data list associated with each type has been upgraded: the
 365    caller must ensure this has been done in advance.  */
 366
 367 static void
 368 ctf_set_version (ctf_file_t * fp, ctf_header_t * cth, int ctf_version)
 369 {
 370   fp->ctf_version = ctf_version;
 371   cth->cth_version = ctf_version;
 372   fp->ctf_fileops = &ctf_fileops[ctf_version];
 373 }
 374
 375 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3).
 376
 377    The upgrade is not done in-place: the ctf_base is moved.  ctf_strptr() must
 378    not be called before reallocation is complete.
 379
 380    Type kinds not checked here due to nonexistence in older formats:
 381       CTF_K_SLICE.  */
 382 static int
 383 upgrade_types (ctf_file_t *fp, ctf_header_t *cth)
 384 {
 385   const ctf_type_v1_t *tbuf;
 386   const ctf_type_v1_t *tend;
 387   unsigned char *ctf_base, *old_ctf_base = (unsigned char *) fp->ctf_base;
 388   ctf_type_t *t2buf;
 389
 390   ssize_t increase = 0, size, increment, v2increment, vbytes, v2bytes;
 391   const ctf_type_v1_t *tp;
 392   ctf_type_t *t2p;
 393   ctf_header_t *new_cth;
 394
 395   tbuf = (ctf_type_v1_t *) (fp->ctf_buf + cth->cth_typeoff);
 396   tend = (ctf_type_v1_t *) (fp->ctf_buf + cth->cth_stroff);
 397
 398   /* Much like init_types(), this is a two-pass process.
 399
 400      First, figure out the new type-section size needed.  (It is possible,
 401      in theory, for it to be less than the old size, but this is very
 402      unlikely.  It cannot be so small that cth_typeoff ends up of negative
 403      size.  We validate this with an assertion below.)
 404
 405      We must cater not only for changes in vlen and types sizes but also
 406      for changes in 'increment', which happen because v2 places some types
 407      into ctf_stype_t where v1 would be forced to use the larger non-stype.  */
 408
 409   for (tp = tbuf; tp < tend;
 410        tp = (ctf_type_v1_t *) ((uintptr_t) tp + increment + vbytes))
 411     {
 412       unsigned short kind = CTF_V1_INFO_KIND (tp->ctt_info);
 413       unsigned long vlen = CTF_V1_INFO_VLEN (tp->ctt_info);
 414
 415       size = get_ctt_size_v1 (fp, (const ctf_type_t *) tp, NULL, &increment);
 416       vbytes = get_vbytes_v1 (kind, size, vlen);
 417
 418       get_ctt_size_v2_unconverted (fp, (const ctf_type_t *) tp, NULL,
 419                                    &v2increment);
 420       v2bytes = get_vbytes_v2 (kind, size, vlen);
 421
 422       if ((vbytes < 0) || (size < 0))
 423         return ECTF_CORRUPT;
 424
 425       increase += v2increment - increment;      /* May be negative.  */
 426       increase += v2bytes - vbytes;
 427     }
 428
 429   /* Allocate enough room for the new buffer, then copy everything but the
 430      type section into place, and reset the base accordingly.  Leave the
 431      version number unchanged, so that LCTF_INFO_* still works on the
 432      as-yet-untranslated type info.  */
 433
 434   if ((ctf_base = ctf_alloc (fp->ctf_size + increase)) == NULL)
 435     return ECTF_ZALLOC;
 436
 437   memcpy (ctf_base, fp->ctf_base, sizeof (ctf_header_t) + cth->cth_typeoff);
 438   memcpy (ctf_base + sizeof (ctf_header_t) + cth->cth_stroff + increase,
 439           fp->ctf_base + sizeof (ctf_header_t) + cth->cth_stroff,
 440           cth->cth_strlen);
 441
 442   memset (ctf_base + sizeof (ctf_header_t) + cth->cth_typeoff, 0,
 443          cth->cth_stroff - cth->cth_typeoff + increase);
 444
 445   /* The cth here is an automatic variable in ctf_bufopen(), and transient
 446      (a copy maintained because at that stage the header read out of the
 447      ctf file may be read-only). We make all modifications in the
 448      canonical copy at ctf_base (by now, writable), then copy it back into
 449      cth at the end.  */
 450
 451   new_cth = (ctf_header_t *) ctf_base;
 452   new_cth->cth_stroff += increase;
 453   fp->ctf_size += increase;
 454   assert (new_cth->cth_stroff >= new_cth->cth_typeoff);
 455   ctf_set_base (fp, new_cth, ctf_base);
 456
 457   t2buf = (ctf_type_t *) (fp->ctf_buf + new_cth->cth_typeoff);
 458
 459   /* Iterate through all the types again, upgrading them.
 460
 461      Everything that hasn't changed can just be outright memcpy()ed.
 462      Things that have changed need field-by-field consideration.  */
 463
 464   for (tp = tbuf, t2p = t2buf; tp < tend;
 465        tp = (ctf_type_v1_t *) ((uintptr_t) tp + increment + vbytes),
 466        t2p = (ctf_type_t *) ((uintptr_t) t2p + v2increment + v2bytes))
 467     {
 468       unsigned short kind = CTF_V1_INFO_KIND (tp->ctt_info);
 469       int isroot = CTF_V1_INFO_ISROOT (tp->ctt_info);
 470       unsigned long vlen = CTF_V1_INFO_VLEN (tp->ctt_info);
 471       ssize_t v2size;
 472       void *vdata, *v2data;
 473
 474       size = get_ctt_size_v1 (fp, (const ctf_type_t *) tp, NULL, &increment);
 475       vbytes = get_vbytes_v1 (kind, size, vlen);
 476
 477       t2p->ctt_name = tp->ctt_name;
 478       t2p->ctt_info = CTF_TYPE_INFO (kind, isroot, vlen);
 479
 480       switch (kind)
 481         {
 482         case CTF_K_FUNCTION:
 483         case CTF_K_FORWARD:
 484         case CTF_K_TYPEDEF:
 485         case CTF_K_POINTER:
 486         case CTF_K_VOLATILE:
 487         case CTF_K_CONST:
 488         case CTF_K_RESTRICT:
 489           t2p->ctt_type = tp->ctt_type;
 490           break;
 491         case CTF_K_INTEGER:
 492         case CTF_K_FLOAT:
 493         case CTF_K_ARRAY:
 494         case CTF_K_STRUCT:
 495         case CTF_K_UNION:
 496         case CTF_K_ENUM:
 497         case CTF_K_UNKNOWN:
 498           if ((size_t) size <= CTF_MAX_SIZE)
 499             t2p->ctt_size = size;
 500           else
 501             {
 502               t2p->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
 503               t2p->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
 504             }
 505           break;
 506         }
 507
 508       v2size = get_ctt_size_v2 (fp, t2p, NULL, &v2increment);
 509       v2bytes = get_vbytes_v2 (kind, v2size, vlen);
 510
 511       /* Catch out-of-sync get_ctt_size_*().  The count goes wrong if
 512          these are not identical (and having them different makes no
 513          sense semantically).  */
 514
 515       assert (size == v2size);
 516
 517       /* Now the varlen info.  */
 518
 519       vdata = (void *) ((uintptr_t) tp + increment);
 520       v2data = (void *) ((uintptr_t) t2p + v2increment);
 521
 522       switch (kind)
 523         {
 524         case CTF_K_ARRAY:
 525           {
 526             const ctf_array_v1_t *ap = (const ctf_array_v1_t *) vdata;
 527             ctf_array_t *a2p = (ctf_array_t *) v2data;
 528
 529             a2p->cta_contents = ap->cta_contents;
 530             a2p->cta_index = ap->cta_index;
 531             a2p->cta_nelems = ap->cta_nelems;
 532             break;
 533           }
 534         case CTF_K_STRUCT:
 535         case CTF_K_UNION:
 536           {
 537             ctf_member_t tmp;
 538             const ctf_member_v1_t *m1 = (const ctf_member_v1_t *) vdata;
 539             const ctf_lmember_v1_t *lm1 = (const ctf_lmember_v1_t *) m1;
 540             ctf_member_t *m2 = (ctf_member_t *) v2data;
 541             ctf_lmember_t *lm2 = (ctf_lmember_t *) m2;
 542             unsigned long i;
 543
 544             /* We walk all four pointers forward, but only reference the two
 545                that are valid for the given size, to avoid quadruplicating all
 546                the code.  */
 547
 548             for (i = vlen; i != 0; i--, m1++, lm1++, m2++, lm2++)
 549               {
 550                 size_t offset;
 551                 if (size < CTF_LSTRUCT_THRESH_V1)
 552                   {
 553                     offset = m1->ctm_offset;
 554                     tmp.ctm_name = m1->ctm_name;
 555                     tmp.ctm_type = m1->ctm_type;
 556                   }
 557                 else
 558                   {
 559                     offset = CTF_LMEM_OFFSET (lm1);
 560                     tmp.ctm_name = lm1->ctlm_name;
 561                     tmp.ctm_type = lm1->ctlm_type;
 562                   }
 563                 if (size < CTF_LSTRUCT_THRESH)
 564                   {
 565                     m2->ctm_name = tmp.ctm_name;
 566                     m2->ctm_type = tmp.ctm_type;
 567                     m2->ctm_offset = offset;
 568                   }
 569                 else
 570                   {
 571                     lm2->ctlm_name = tmp.ctm_name;
 572                     lm2->ctlm_type = tmp.ctm_type;
 573                     lm2->ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (offset);
 574                     lm2->ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (offset);
 575                   }
 576               }
 577             break;
 578           }
 579         case CTF_K_FUNCTION:
 580           {
 581             unsigned long i;
 582             unsigned short *a1 = (unsigned short *) vdata;
 583             uint32_t *a2 = (uint32_t *) v2data;
 584
 585             for (i = vlen; i != 0; i--, a1++, a2++)
 586               *a2 = *a1;
 587           }
 588         /* FALLTHRU */
 589         default:
 590           /* Catch out-of-sync get_vbytes_*().  */
 591           assert (vbytes == v2bytes);
 592           memcpy (v2data, vdata, vbytes);
 593         }
 594     }
 595
 596   /* Verify that the entire region was converted.  If not, we are either
 597      converting too much, or too little (leading to a buffer overrun either here
 598      or at read time, in init_types().) */
 599
 600   assert ((size_t) t2p - (size_t) fp->ctf_buf == new_cth->cth_stroff);
 601
 602   ctf_set_version (fp, (ctf_header_t *) ctf_base, CTF_VERSION_1_UPGRADED_3);
 603   ctf_free_base (fp, old_ctf_base);
 604   memcpy (cth, new_cth, sizeof (ctf_header_t));
 605
 606   return 0;
 607 }
 608
 609 /* Initialize the type ID translation table with the byte offset of each type,
 610    and initialize the hash tables of each named type.  Upgrade the type table to
 611    the latest supported representation in the process, if needed, and if this
 612    recension of libctf supports upgrading.  */
 613
 614 static int
 615 init_types (ctf_file_t *fp, ctf_header_t *cth)
 616 {
 617   const ctf_type_t *tbuf;
 618   const ctf_type_t *tend;
 619
 620   unsigned long pop[CTF_K_MAX + 1] = { 0 };
 621   const ctf_type_t *tp;
 622   ctf_hash_t *hp;
 623   uint32_t id, dst;
 624   uint32_t *xp;
 625
 626   /* We determine whether the container is a child or a parent based on
 627      the value of cth_parname.  */
 628
 629   int child = cth->cth_parname != 0;
 630   int nlstructs = 0, nlunions = 0;
 631   int err;
 632
 633   if (_libctf_unlikely_ (fp->ctf_version == CTF_VERSION_1))
 634     {
 635       int err;
 636       if ((err = upgrade_types (fp, cth)) != 0)
 637         return err;                             /* Upgrade failed.  */
 638     }
 639
 640   tbuf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff);
 641   tend = (ctf_type_t *) (fp->ctf_buf + cth->cth_stroff);
 642
 643   /* We make two passes through the entire type section.  In this first
 644      pass, we count the number of each type and the total number of types.  */
 645
 646   for (tp = tbuf; tp < tend; fp->ctf_typemax++)
 647     {
 648       unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
 649       unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
 650       ssize_t size, increment, vbytes;
 651
 652       (void) ctf_get_ctt_size (fp, tp, &size, &increment);
 653       vbytes = LCTF_VBYTES (fp, kind, size, vlen);
 654
 655       if (vbytes < 0)
 656         return ECTF_CORRUPT;
 657
 658       if (kind == CTF_K_FORWARD)
 659         {
 660           /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
 661              so bump that population count too.  If ctt_type is unknown, treat
 662              the tag as a struct.  */
 663
 664           if (tp->ctt_type == CTF_K_UNKNOWN || tp->ctt_type >= CTF_K_MAX)
 665             pop[CTF_K_STRUCT]++;
 666           else
 667             pop[tp->ctt_type]++;
 668         }
 669       tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
 670       pop[kind]++;
 671     }
 672
 673   if (child)
 674     {
 675       ctf_dprintf ("CTF container %p is a child\n", (void *) fp);
 676       fp->ctf_flags |= LCTF_CHILD;
 677     }
 678   else
 679     ctf_dprintf ("CTF container %p is a parent\n", (void *) fp);
 680
 681   /* Now that we've counted up the number of each type, we can allocate
 682      the hash tables, type translation table, and pointer table.  */
 683
 684   if ((fp->ctf_structs = ctf_hash_create (pop[CTF_K_STRUCT], ctf_hash_string,
 685                                           ctf_hash_eq_string)) == NULL)
 686     return ENOMEM;
 687
 688   if ((fp->ctf_unions = ctf_hash_create (pop[CTF_K_UNION], ctf_hash_string,
 689                                          ctf_hash_eq_string)) == NULL)
 690     return ENOMEM;
 691
 692   if ((fp->ctf_enums = ctf_hash_create (pop[CTF_K_ENUM], ctf_hash_string,
 693                                         ctf_hash_eq_string)) == NULL)
 694     return ENOMEM;
 695
 696   if ((fp->ctf_names = ctf_hash_create (pop[CTF_K_INTEGER] +
 697                                         pop[CTF_K_FLOAT] +
 698                                         pop[CTF_K_FUNCTION] +
 699                                         pop[CTF_K_TYPEDEF] +
 700                                         pop[CTF_K_POINTER] +
 701                                         pop[CTF_K_VOLATILE] +
 702                                         pop[CTF_K_CONST] +
 703                                         pop[CTF_K_RESTRICT],
 704                                         ctf_hash_string,
 705                                         ctf_hash_eq_string)) == NULL)
 706     return ENOMEM;
 707
 708   fp->ctf_txlate = ctf_alloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
 709   fp->ctf_ptrtab = ctf_alloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
 710
 711   if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
 712     return ENOMEM;              /* Memory allocation failed.  */
 713
 714   xp = fp->ctf_txlate;
 715   *xp++ = 0;                    /* Type id 0 is used as a sentinel value.  */
 716
 717   memset (fp->ctf_txlate, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1));
 718   memset (fp->ctf_ptrtab, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1));
 719
 720   /* In the second pass through the types, we fill in each entry of the
 721      type and pointer tables and add names to the appropriate hashes.  */
 722
 723   for (id = 1, tp = tbuf; tp < tend; xp++, id++)
 724     {
 725       unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info);
 726       unsigned short flag = LCTF_INFO_ISROOT (fp, tp->ctt_info);
 727       unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
 728       ssize_t size, increment, vbytes;
 729
 730       const char *name;
 731
 732       (void) ctf_get_ctt_size (fp, tp, &size, &increment);
 733       name = ctf_strptr (fp, tp->ctt_name);
 734       vbytes = LCTF_VBYTES (fp, kind, size, vlen);
 735
 736       switch (kind)
 737         {
 738         case CTF_K_INTEGER:
 739         case CTF_K_FLOAT:
 740           /* Names are reused by bit-fields, which are differentiated by their
 741              encodings, and so typically we'd record only the first instance of
 742              a given intrinsic.  However, we replace an existing type with a
 743              root-visible version so that we can be sure to find it when
 744              checking for conflicting definitions in ctf_add_type().  */
 745
 746           if (((ctf_hash_lookup_type (fp->ctf_names, fp, name)) == 0)
 747               || (flag & CTF_ADD_ROOT))
 748             {
 749               err = ctf_hash_define_type (fp->ctf_names, fp,
 750                                           LCTF_INDEX_TO_TYPE (fp, id, child),
 751                                           tp->ctt_name);
 752               if (err != 0 && err != ECTF_STRTAB)
 753                 return err;
 754             }
 755           break;
 756
 757           /* These kinds have no name, so do not need interning into any
 758              hashtables.  */
 759         case CTF_K_ARRAY:
 760         case CTF_K_SLICE:
 761           break;
 762
 763         case CTF_K_FUNCTION:
 764           err = ctf_hash_insert_type (fp->ctf_names, fp,
 765                                       LCTF_INDEX_TO_TYPE (fp, id, child),
 766                                       tp->ctt_name);
 767           if (err != 0 && err != ECTF_STRTAB)
 768             return err;
 769           break;
 770
 771         case CTF_K_STRUCT:
 772           err = ctf_hash_define_type (fp->ctf_structs, fp,
 773                                       LCTF_INDEX_TO_TYPE (fp, id, child),
 774                                       tp->ctt_name);
 775
 776           if (err != 0 && err != ECTF_STRTAB)
 777             return err;
 778
 779           if (size >= CTF_LSTRUCT_THRESH)
 780             nlstructs++;
 781           break;
 782
 783         case CTF_K_UNION:
 784           err = ctf_hash_define_type (fp->ctf_unions, fp,
 785                                       LCTF_INDEX_TO_TYPE (fp, id, child),
 786                                       tp->ctt_name);
 787
 788           if (err != 0 && err != ECTF_STRTAB)
 789             return err;
 790
 791           if (size >= CTF_LSTRUCT_THRESH)
 792             nlunions++;
 793           break;
 794
 795         case CTF_K_ENUM:
 796           err = ctf_hash_define_type (fp->ctf_enums, fp,
 797                                       LCTF_INDEX_TO_TYPE (fp, id, child),
 798                                       tp->ctt_name);
 799
 800           if (err != 0 && err != ECTF_STRTAB)
 801             return err;
 802           break;
 803
 804         case CTF_K_TYPEDEF:
 805           err = ctf_hash_insert_type (fp->ctf_names, fp,
 806                                       LCTF_INDEX_TO_TYPE (fp, id, child),
 807                                       tp->ctt_name);
 808           if (err != 0 && err != ECTF_STRTAB)
 809             return err;
 810           break;
 811
 812         case CTF_K_FORWARD:
 813           /* Only insert forward tags into the given hash if the type or tag
 814              name is not already present.  */
 815           switch (tp->ctt_type)
 816             {
 817             case CTF_K_STRUCT:
 818               hp = fp->ctf_structs;
 819               break;
 820             case CTF_K_UNION:
 821               hp = fp->ctf_unions;
 822               break;
 823             case CTF_K_ENUM:
 824               hp = fp->ctf_enums;
 825               break;
 826             default:
 827               hp = fp->ctf_structs;
 828             }
 829
 830           if (ctf_hash_lookup_type (hp, fp, name) == 0)
 831             {
 832               err = ctf_hash_insert_type (hp, fp,
 833                                           LCTF_INDEX_TO_TYPE (fp, id, child),
 834                                           tp->ctt_name);
 835               if (err != 0 && err != ECTF_STRTAB)
 836                 return err;
 837             }
 838           break;
 839
 840         case CTF_K_POINTER:
 841           /* If the type referenced by the pointer is in this CTF container,
 842              then store the index of the pointer type in
 843              fp->ctf_ptrtab[ index of referenced type ].  */
 844
 845           if (LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child
 846               && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
 847             fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = id;
 848          /*FALLTHRU*/
 849
 850         case CTF_K_VOLATILE:
 851         case CTF_K_CONST:
 852         case CTF_K_RESTRICT:
 853           err = ctf_hash_insert_type (fp->ctf_names, fp,
 854                                       LCTF_INDEX_TO_TYPE (fp, id, child),
 855                                       tp->ctt_name);
 856           if (err != 0 && err != ECTF_STRTAB)
 857             return err;
 858           break;
 859         }
 860
 861       *xp = (uint32_t) ((uintptr_t) tp - (uintptr_t) fp->ctf_buf);
 862       tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
 863     }
 864
 865   ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax);
 866   ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp->ctf_enums));
 867   ctf_dprintf ("%u struct names hashed (%d long)\n",
 868                ctf_hash_size (fp->ctf_structs), nlstructs);
 869   ctf_dprintf ("%u union names hashed (%d long)\n",
 870                ctf_hash_size (fp->ctf_unions), nlunions);
 871   ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp->ctf_names));
 872
 873   /* Make an additional pass through the pointer table to find pointers that
 874      point to anonymous typedef nodes.  If we find one, modify the pointer table
 875      so that the pointer is also known to point to the node that is referenced
 876      by the anonymous typedef node.  */
 877
 878   for (id = 1; id <= fp->ctf_typemax; id++)
 879     {
 880       if ((dst = fp->ctf_ptrtab[id]) != 0)
 881         {
 882           tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
 883
 884           if (LCTF_INFO_KIND (fp, tp->ctt_info) == CTF_K_TYPEDEF &&
 885               strcmp (ctf_strptr (fp, tp->ctt_name), "") == 0 &&
 886               LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child &&
 887               LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
 888             fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = dst;
 889         }
 890     }
 891
 892   return 0;
 893 }
 894
 895 /* Endianness-flipping routines.
 896
 897    We flip everything, mindlessly, even 1-byte entities, so that future
 898    expansions do not require changes to this code.  */
 899
 900 /* < C11? define away static assertions.  */
 901
 902 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
 903 #define _Static_assert(cond, err)
 904 #endif
 905
 906 /* Swap the endianness of something.  */
 907
 908 #define swap_thing(x)                                                   \
 909   do {                                                                  \
 910     _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0             \
 911                                         && sizeof (x) <= 8),            \
 912                     "Invalid size, update endianness code");            \
 913     switch (sizeof (x)) {                                               \
 914     case 2: x = bswap_16 (x); break;                                    \
 915     case 4: x = bswap_32 (x); break;                                    \
 916     case 8: x = bswap_64 (x); break;                                    \
 917     case 1: /* Nothing needs doing */                                   \
 918       break;                                                            \
 919     }                                                                   \
 920   } while (0);
 921
 922 /* Flip the endianness of the CTF header.  */
 923
 924 static void
 925 flip_header (ctf_header_t *cth)
 926 {
 927   swap_thing (cth->cth_preamble.ctp_magic);
 928   swap_thing (cth->cth_preamble.ctp_version);
 929   swap_thing (cth->cth_preamble.ctp_flags);
 930   swap_thing (cth->cth_parlabel);
 931   swap_thing (cth->cth_parname);
 932   swap_thing (cth->cth_objtoff);
 933   swap_thing (cth->cth_funcoff);
 934   swap_thing (cth->cth_varoff);
 935   swap_thing (cth->cth_typeoff);
 936   swap_thing (cth->cth_stroff);
 937   swap_thing (cth->cth_strlen);
 938 }
 939
 940 /* Flip the endianness of the label section, an array of ctf_lblent_t.  */
 941
 942 static void
 943 flip_lbls (void *start, size_t len)
 944 {
 945   ctf_lblent_t *lbl = start;
 946
 947   for (ssize_t i = len / sizeof (struct ctf_lblent); i > 0; lbl++, i--)
 948     {
 949       swap_thing (lbl->ctl_label);
 950       swap_thing (lbl->ctl_type);
 951     }
 952 }
 953
 954 /* Flip the endianness of the data-object or function sections, an array of
 955    uint32_t.  (The function section has more internal structure, but that
 956    structure is an array of uint32_t, so can be treated as one big array for
 957    byte-swapping.)  */
 958
 959 static void
 960 flip_objts (void *start, size_t len)
 961 {
 962   uint32_t *obj = start;
 963
 964   for (ssize_t i = len / sizeof (uint32_t); i > 0; obj++, i--)
 965       swap_thing (*obj);
 966 }
 967
 968 /* Flip the endianness of the variable section, an array of ctf_varent_t.  */
 969
 970 static void
 971 flip_vars (void *start, size_t len)
 972 {
 973   ctf_varent_t *var = start;
 974
 975   for (ssize_t i = len / sizeof (struct ctf_varent); i > 0; var++, i--)
 976     {
 977       swap_thing (var->ctv_name);
 978       swap_thing (var->ctv_type);
 979     }
 980 }
 981
 982 /* Flip the endianness of the type section, a tagged array of ctf_type or
 983    ctf_stype followed by variable data.  */
 984
 985 static int
 986 flip_types (void *start, size_t len)
 987 {
 988   ctf_type_t *t = start;
 989
 990   while ((uintptr_t) t < ((uintptr_t) start) + len)
 991     {
 992       swap_thing (t->ctt_name);
 993       swap_thing (t->ctt_info);
 994       swap_thing (t->ctt_size);
 995
 996       uint32_t kind = CTF_V2_INFO_KIND (t->ctt_info);
 997       size_t size = t->ctt_size;
 998       uint32_t vlen = CTF_V2_INFO_VLEN (t->ctt_info);
 999       size_t vbytes = get_vbytes_v2 (kind, size, vlen);
1000
1001       if (_libctf_unlikely_ (size == CTF_LSIZE_SENT))
1002         {
1003           swap_thing (t->ctt_lsizehi);
1004           swap_thing (t->ctt_lsizelo);
1005           size = CTF_TYPE_LSIZE (t);
1006           t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t));
1007         }
1008       else
1009         t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_stype_t));
1010
1011       switch (kind)
1012         {
1013         case CTF_K_FORWARD:
1014         case CTF_K_UNKNOWN:
1015         case CTF_K_POINTER:
1016         case CTF_K_TYPEDEF:
1017         case CTF_K_VOLATILE:
1018         case CTF_K_CONST:
1019         case CTF_K_RESTRICT:
1020           /* These types have no vlen data to swap.  */
1021           assert (vbytes == 0);
1022           break;
1023
1024         case CTF_K_INTEGER:
1025         case CTF_K_FLOAT:
1026           {
1027             /* These types have a single uint32_t.  */
1028
1029             uint32_t *item = (uint32_t *) t;
1030
1031             swap_thing (*item);
1032             break;
1033           }
1034
1035         case CTF_K_FUNCTION:
1036           {
1037             /* This type has a bunch of uint32_ts.  */
1038
1039             uint32_t *item = (uint32_t *) t;
1040
1041             for (ssize_t i = vlen; i > 0; item++, i--)
1042               swap_thing (*item);
1043             break;
1044           }
1045
1046         case CTF_K_ARRAY:
1047           {
1048             /* This has a single ctf_array_t.  */
1049
1050             ctf_array_t *a = (ctf_array_t *) t;
1051
1052             assert (vbytes == sizeof (ctf_array_t));
1053             swap_thing (a->cta_contents);
1054             swap_thing (a->cta_index);
1055             swap_thing (a->cta_nelems);
1056
1057             break;
1058           }
1059
1060         case CTF_K_SLICE:
1061           {
1062             /* This has a single ctf_slice_t.  */
1063
1064             ctf_slice_t *s = (ctf_slice_t *) t;
1065
1066             assert (vbytes == sizeof (ctf_slice_t));
1067             swap_thing (s->cts_type);
1068             swap_thing (s->cts_offset);
1069             swap_thing (s->cts_bits);
1070
1071             break;
1072           }
1073
1074         case CTF_K_STRUCT:
1075         case CTF_K_UNION:
1076           {
1077             /* This has an array of ctf_member or ctf_lmember, depending on
1078                size.  We could consider it to be a simple array of uint32_t,
1079                but for safety's sake in case these structures ever acquire
1080                non-uint32_t members, do it member by member.  */
1081
1082             if (_libctf_unlikely_ (size >= CTF_LSTRUCT_THRESH))
1083               {
1084                 ctf_lmember_t *lm = (ctf_lmember_t *) t;
1085                 for (ssize_t i = vlen; i > 0; i--, lm++)
1086                   {
1087                     swap_thing (lm->ctlm_name);
1088                     swap_thing (lm->ctlm_offsethi);
1089                     swap_thing (lm->ctlm_type);
1090                     swap_thing (lm->ctlm_offsetlo);
1091                   }
1092               }
1093             else
1094               {
1095                 ctf_member_t *m = (ctf_member_t *) t;
1096                 for (ssize_t i = vlen; i > 0; i--, m++)
1097                   {
1098                     swap_thing (m->ctm_name);
1099                     swap_thing (m->ctm_offset);
1100                     swap_thing (m->ctm_type);
1101                   }
1102               }
1103             break;
1104           }
1105
1106         case CTF_K_ENUM:
1107           {
1108             /* This has an array of ctf_enum_t.  */
1109
1110             ctf_enum_t *item = (ctf_enum_t *) t;
1111
1112             for (ssize_t i = vlen; i > 0; item++, i--)
1113               {
1114                 swap_thing (item->cte_name);
1115                 swap_thing (item->cte_value);
1116               }
1117             break;
1118           }
1119         default:
1120           ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1121                        kind);
1122           return ECTF_CORRUPT;
1123         }
1124
1125       t = (ctf_type_t *) ((uintptr_t) t + vbytes);
1126     }
1127
1128   return 0;
1129 }
1130
1131 /* Flip the endianness of BASE, given the offsets in the (already endian-
1132    converted) CTH.
1133
1134    All of this stuff happens before the header is fully initialized, so the
1135    LCTF_*() macros cannot be used yet.  Since we do not try to endian-convert v1
1136    data, this is no real loss.  */
1137
1138 static int
1139 flip_ctf (ctf_header_t *cth, unsigned char *base)
1140 {
1141   base += sizeof (ctf_header_t);
1142
1143   flip_lbls (base + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff);
1144   flip_objts (base + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff);
1145   flip_objts (base + cth->cth_funcoff, cth->cth_varoff - cth->cth_funcoff);
1146   flip_vars (base + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff);
1147   return flip_types (base + cth->cth_typeoff, cth->cth_stroff - cth->cth_typeoff);
1148 }
1149
1150 /* Open a CTF file, mocking up a suitable ctf_sect.  */
1151 ctf_file_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
1152                              const char *symsect, size_t symsect_size,
1153                              size_t symsect_entsize,
1154                              const char *strsect, size_t strsect_size,
1155                              int *errp)
1156 {
1157   ctf_sect_t skeleton;
1158
1159   ctf_sect_t ctf_sect, sym_sect, str_sect;
1160   ctf_sect_t *ctfsectp = NULL;
1161   ctf_sect_t *symsectp = NULL;
1162   ctf_sect_t *strsectp = NULL;
1163
1164   skeleton.cts_name = _CTF_SECTION;
1165   skeleton.cts_entsize = 1;
1166
1167   if (ctfsect)
1168     {
1169       memcpy (&ctf_sect, &skeleton, sizeof (struct ctf_sect));
1170       ctf_sect.cts_data = ctfsect;
1171       ctf_sect.cts_size = ctfsect_size;
1172       ctfsectp = &ctf_sect;
1173     }
1174
1175   if (symsect)
1176     {
1177       memcpy (&sym_sect, &skeleton, sizeof (struct ctf_sect));
1178       sym_sect.cts_data = symsect;
1179       sym_sect.cts_size = symsect_size;
1180       sym_sect.cts_entsize = symsect_entsize;
1181       symsectp = &sym_sect;
1182     }
1183
1184   if (strsect)
1185     {
1186       memcpy (&str_sect, &skeleton, sizeof (struct ctf_sect));
1187       str_sect.cts_data = strsect;
1188       str_sect.cts_size = strsect_size;
1189       strsectp = &str_sect;
1190     }
1191
1192   return ctf_bufopen (ctfsectp, symsectp, strsectp, errp);
1193 }
1194
1195 /* Decode the specified CTF buffer and optional symbol table, and create a new
1196    CTF container representing the symbolic debugging information.  This code can
1197    be used directly by the debugger, or it can be used as the engine for
1198    ctf_fdopen() or ctf_open(), below.  */
1199
1200 ctf_file_t *
1201 ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1202              const ctf_sect_t *strsect, int *errp)
1203 {
1204   const ctf_preamble_t *pp;
1205   ctf_header_t hp;
1206   ctf_file_t *fp;
1207   void *buf, *base;
1208   size_t size, hdrsz;
1209   int foreign_endian = 0;
1210   int err;
1211
1212   libctf_init_debug();
1213
1214   if (ctfsect == NULL || ((symsect == NULL) != (strsect == NULL)))
1215     return (ctf_set_open_errno (errp, EINVAL));
1216
1217   if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) &&
1218       symsect->cts_entsize != sizeof (Elf64_Sym))
1219     return (ctf_set_open_errno (errp, ECTF_SYMTAB));
1220
1221   if (symsect != NULL && symsect->cts_data == NULL)
1222     return (ctf_set_open_errno (errp, ECTF_SYMBAD));
1223
1224   if (strsect != NULL && strsect->cts_data == NULL)
1225     return (ctf_set_open_errno (errp, ECTF_STRBAD));
1226
1227   if (ctfsect->cts_size < sizeof (ctf_preamble_t))
1228     return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1229
1230   pp = (const ctf_preamble_t *) ctfsect->cts_data;
1231
1232   ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1233                pp->ctp_magic, pp->ctp_version);
1234
1235   /* Validate each part of the CTF header.
1236
1237      First, we validate the preamble (common to all versions).  At that point,
1238      we know the endianness and specific header version, and can validate the
1239      version-specific parts including section offsets and alignments.
1240
1241      We specifically do not support foreign-endian old versions.  */
1242
1243   if (_libctf_unlikely_ (pp->ctp_magic != CTF_MAGIC))
1244     {
1245       if (pp->ctp_magic == bswap_16 (CTF_MAGIC))
1246         {
1247           if (pp->ctp_version != CTF_VERSION_3)
1248             return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1249           foreign_endian = 1;
1250         }
1251       else
1252         return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1253     }
1254
1255   if (_libctf_unlikely_ ((pp->ctp_version < CTF_VERSION_1)
1256                          || (pp->ctp_version > CTF_VERSION_3)))
1257     return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1258
1259   if ((symsect != NULL) && (pp->ctp_version < CTF_VERSION_2))
1260     {
1261       /* The symtab can contain function entries which contain embedded ctf
1262          info.  We do not support dynamically upgrading such entries (none
1263          should exist in any case, since dwarf2ctf does not create them).  */
1264
1265       ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1266                    "supported\n", pp->ctp_version);
1267       return (ctf_set_open_errno (errp, ECTF_NOTSUP));
1268     }
1269
1270   if (ctfsect->cts_size < sizeof (ctf_header_t))
1271     return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1272
1273   memcpy (&hp, ctfsect->cts_data, sizeof (hp));
1274
1275   if (foreign_endian)
1276     flip_header (&hp);
1277
1278   ctf_dprintf ("header offsets: %x/%x/%x/%x/%x/%x/%x\n",
1279                hp.cth_lbloff, hp.cth_objtoff, hp.cth_funcoff, hp.cth_varoff,
1280                hp.cth_typeoff, hp.cth_stroff, hp.cth_strlen);
1281   hdrsz = sizeof (ctf_header_t);
1282
1283   size = hp.cth_stroff + hp.cth_strlen;
1284
1285   ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", (unsigned long) size);
1286
1287   if (hp.cth_lbloff > size || hp.cth_objtoff > size
1288       || hp.cth_funcoff > size || hp.cth_typeoff > size || hp.cth_stroff > size)
1289     return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1290
1291   if (hp.cth_lbloff > hp.cth_objtoff
1292       || hp.cth_objtoff > hp.cth_funcoff
1293       || hp.cth_funcoff > hp.cth_typeoff
1294       || hp.cth_funcoff > hp.cth_varoff
1295       || hp.cth_varoff > hp.cth_typeoff || hp.cth_typeoff > hp.cth_stroff)
1296     return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1297
1298   if ((hp.cth_lbloff & 3) || (hp.cth_objtoff & 1)
1299       || (hp.cth_funcoff & 1) || (hp.cth_varoff & 3) || (hp.cth_typeoff & 3))
1300     return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1301
1302   /* Once everything is determined to be valid, attempt to decompress the CTF
1303      data buffer if it is compressed, or copy it into new storage if it is not
1304      compressed but needs endian-flipping.  Otherwise we just put the data
1305      section's buffer pointer into ctf_buf, below.  */
1306
1307   /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1308      init_types().  */
1309
1310   if (hp.cth_flags & CTF_F_COMPRESS)
1311     {
1312       size_t srclen;
1313       uLongf dstlen;
1314       const void *src;
1315       int rc = Z_OK;
1316
1317       if ((base = ctf_alloc (size + hdrsz)) == NULL)
1318         return (ctf_set_open_errno (errp, ECTF_ZALLOC));
1319
1320       memcpy (base, ctfsect->cts_data, hdrsz);
1321       ((ctf_preamble_t *) base)->ctp_flags &= ~CTF_F_COMPRESS;
1322       buf = (unsigned char *) base + hdrsz;
1323
1324       src = (unsigned char *) ctfsect->cts_data + hdrsz;
1325       srclen = ctfsect->cts_size - hdrsz;
1326       dstlen = size;
1327
1328       if ((rc = uncompress (buf, &dstlen, src, srclen)) != Z_OK)
1329         {
1330           ctf_dprintf ("zlib inflate err: %s\n", zError (rc));
1331           free (base);
1332           return (ctf_set_open_errno (errp, ECTF_DECOMPRESS));
1333         }
1334
1335       if ((size_t) dstlen != size)
1336         {
1337           ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1338                        "bytes\n", (unsigned long) dstlen, (unsigned long) size);
1339           free (base);
1340           return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1341         }
1342
1343     }
1344   else if (foreign_endian)
1345     {
1346       if ((base = ctf_alloc (size + hdrsz)) == NULL)
1347         return (ctf_set_open_errno (errp, ECTF_ZALLOC));
1348     }
1349   else
1350     {
1351       base = (void *) ctfsect->cts_data;
1352       buf = (unsigned char *) base + hdrsz;
1353     }
1354
1355   /* Once we have uncompressed and validated the CTF data buffer, we can
1356      proceed with allocating a ctf_file_t and initializing it.
1357
1358      Nothing that depends on buf or base should be set directly in this function
1359      before the init_types() call, because it may be reallocated during
1360      transparent upgrade if this recension of libctf is so configured: see
1361      ctf_set_base() and ctf_realloc_base().  */
1362
1363   if ((fp = ctf_alloc (sizeof (ctf_file_t))) == NULL)
1364     return (ctf_set_open_errno (errp, ENOMEM));
1365
1366   memset (fp, 0, sizeof (ctf_file_t));
1367   ctf_set_version (fp, &hp, hp.cth_version);
1368
1369   if (_libctf_unlikely_ (hp.cth_version < CTF_VERSION_2))
1370     fp->ctf_parmax = CTF_MAX_PTYPE_V1;
1371   else
1372     fp->ctf_parmax = CTF_MAX_PTYPE;
1373
1374   memcpy (&fp->ctf_data, ctfsect, sizeof (ctf_sect_t));
1375
1376   if (symsect != NULL)
1377     {
1378       memcpy (&fp->ctf_symtab, symsect, sizeof (ctf_sect_t));
1379       memcpy (&fp->ctf_strtab, strsect, sizeof (ctf_sect_t));
1380     }
1381
1382   if (fp->ctf_data.cts_name != NULL)
1383     fp->ctf_data.cts_name = ctf_strdup (fp->ctf_data.cts_name);
1384   if (fp->ctf_symtab.cts_name != NULL)
1385     fp->ctf_symtab.cts_name = ctf_strdup (fp->ctf_symtab.cts_name);
1386   if (fp->ctf_strtab.cts_name != NULL)
1387     fp->ctf_strtab.cts_name = ctf_strdup (fp->ctf_strtab.cts_name);
1388
1389   if (fp->ctf_data.cts_name == NULL)
1390     fp->ctf_data.cts_name = _CTF_NULLSTR;
1391   if (fp->ctf_symtab.cts_name == NULL)
1392     fp->ctf_symtab.cts_name = _CTF_NULLSTR;
1393   if (fp->ctf_strtab.cts_name == NULL)
1394     fp->ctf_strtab.cts_name = _CTF_NULLSTR;
1395
1396   if (strsect != NULL)
1397     {
1398       fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data;
1399       fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size;
1400     }
1401
1402   if (foreign_endian &&
1403       (err = flip_ctf (&hp, base)) != 0)
1404     {
1405       /* We can be certain that flip_ctf() will have endian-flipped everything
1406          other than the types table when we return.  In particular the header
1407          is fine, so set it, to allow freeing to use the usual code path.  */
1408
1409       (void) ctf_set_open_errno (errp, err);
1410       ctf_set_base (fp, &hp, base);
1411       goto bad;
1412     }
1413
1414   ctf_set_base (fp, &hp, base);
1415   fp->ctf_size = size + hdrsz;
1416
1417   if ((err = init_types (fp, &hp)) != 0)
1418     {
1419       (void) ctf_set_open_errno (errp, err);
1420       goto bad;
1421     }
1422
1423   /* If we have a symbol table section, allocate and initialize
1424      the symtab translation table, pointed to by ctf_sxlate.  */
1425
1426   if (symsect != NULL)
1427     {
1428       fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
1429       fp->ctf_sxlate = ctf_alloc (fp->ctf_nsyms * sizeof (uint32_t));
1430
1431       if (fp->ctf_sxlate == NULL)
1432         {
1433           (void) ctf_set_open_errno (errp, ENOMEM);
1434           goto bad;
1435         }
1436
1437       if ((err = init_symtab (fp, &hp, symsect, strsect)) != 0)
1438         {
1439           (void) ctf_set_open_errno (errp, err);
1440           goto bad;
1441         }
1442     }
1443
1444   /* Initialize the ctf_lookup_by_name top-level dictionary.  We keep an
1445      array of type name prefixes and the corresponding ctf_hash to use.
1446      NOTE: This code must be kept in sync with the code in ctf_update().  */
1447   fp->ctf_lookups[0].ctl_prefix = "struct";
1448   fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
1449   fp->ctf_lookups[0].ctl_hash = fp->ctf_structs;
1450   fp->ctf_lookups[1].ctl_prefix = "union";
1451   fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
1452   fp->ctf_lookups[1].ctl_hash = fp->ctf_unions;
1453   fp->ctf_lookups[2].ctl_prefix = "enum";
1454   fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
1455   fp->ctf_lookups[2].ctl_hash = fp->ctf_enums;
1456   fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
1457   fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
1458   fp->ctf_lookups[3].ctl_hash = fp->ctf_names;
1459   fp->ctf_lookups[4].ctl_prefix = NULL;
1460   fp->ctf_lookups[4].ctl_len = 0;
1461   fp->ctf_lookups[4].ctl_hash = NULL;
1462
1463   if (symsect != NULL)
1464     {
1465       if (symsect->cts_entsize == sizeof (Elf64_Sym))
1466         (void) ctf_setmodel (fp, CTF_MODEL_LP64);
1467       else
1468         (void) ctf_setmodel (fp, CTF_MODEL_ILP32);
1469     }
1470   else
1471     (void) ctf_setmodel (fp, CTF_MODEL_NATIVE);
1472
1473   fp->ctf_refcnt = 1;
1474   return fp;
1475
1476 bad:
1477   ctf_file_close (fp);
1478   return NULL;
1479 }
1480
1481 /* Close the specified CTF container and free associated data structures.  Note
1482    that ctf_file_close() is a reference counted operation: if the specified file
1483    is the parent of other active containers, its reference count will be greater
1484    than one and it will be freed later when no active children exist.  */
1485
1486 void
1487 ctf_file_close (ctf_file_t *fp)
1488 {
1489   ctf_dtdef_t *dtd, *ntd;
1490   ctf_dvdef_t *dvd, *nvd;
1491
1492   if (fp == NULL)
1493     return;                /* Allow ctf_file_close(NULL) to simplify caller code.  */
1494
1495   ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp, fp->ctf_refcnt);
1496
1497   if (fp->ctf_refcnt > 1)
1498     {
1499       fp->ctf_refcnt--;
1500       return;
1501     }
1502
1503   if (fp->ctf_dynparname != NULL)
1504     ctf_free (fp->ctf_dynparname);
1505
1506   if (fp->ctf_parent != NULL)
1507     ctf_file_close (fp->ctf_parent);
1508
1509   for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
1510     {
1511       ntd = ctf_list_next (dtd);
1512       ctf_dtd_delete (fp, dtd);
1513     }
1514   ctf_dynhash_destroy (fp->ctf_dthash);
1515   ctf_dynhash_destroy (fp->ctf_dtbyname);
1516
1517   for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
1518     {
1519       nvd = ctf_list_next (dvd);
1520       ctf_dvd_delete (fp, dvd);
1521     }
1522   ctf_dynhash_destroy (fp->ctf_dvhash);
1523
1524   ctf_free (fp->ctf_tmp_typeslice);
1525
1526   if (fp->ctf_data.cts_name != _CTF_NULLSTR &&
1527       fp->ctf_data.cts_name != NULL)
1528     ctf_free ((char *) fp->ctf_data.cts_name);
1529
1530   if (fp->ctf_symtab.cts_name != _CTF_NULLSTR &&
1531       fp->ctf_symtab.cts_name != NULL)
1532     ctf_free ((char *) fp->ctf_symtab.cts_name);
1533
1534   if (fp->ctf_strtab.cts_name != _CTF_NULLSTR &&
1535       fp->ctf_strtab.cts_name != NULL)
1536     ctf_free ((char *) fp->ctf_strtab.cts_name);
1537
1538   else if (fp->ctf_data_mmapped)
1539     ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
1540
1541   ctf_free_base (fp, NULL);
1542
1543   if (fp->ctf_sxlate != NULL)
1544     ctf_free (fp->ctf_sxlate);
1545
1546   if (fp->ctf_txlate != NULL)
1547     ctf_free (fp->ctf_txlate);
1548
1549   if (fp->ctf_ptrtab != NULL)
1550     ctf_free (fp->ctf_ptrtab);
1551
1552   ctf_hash_destroy (fp->ctf_structs);
1553   ctf_hash_destroy (fp->ctf_unions);
1554   ctf_hash_destroy (fp->ctf_enums);
1555   ctf_hash_destroy (fp->ctf_names);
1556
1557   ctf_free (fp);
1558 }
1559
1560 /* The converse of ctf_open().  ctf_open() disguises whatever it opens as an
1561    archive, so closing one is just like closing an archive.  */
1562 void
1563 ctf_close (ctf_archive_t *arc)
1564 {
1565   ctf_arc_close (arc);
1566 }
1567
1568 /* Get the CTF archive from which this ctf_file_t is derived.  */
1569 ctf_archive_t *
1570 ctf_get_arc (const ctf_file_t *fp)
1571 {
1572   return fp->ctf_archive;
1573 }
1574
1575 /* Return the ctfsect out of the core ctf_impl.  Useful for freeing the
1576    ctfsect's data * after ctf_file_close(), which is why we return the actual
1577    structure, not a pointer to it, since that is likely to become a pointer to
1578    freed data before the return value is used under the expected use case of
1579    ctf_getsect()/ ctf_file_close()/free().  */
1580 extern ctf_sect_t
1581 ctf_getdatasect (const ctf_file_t *fp)
1582 {
1583   return fp->ctf_data;
1584 }
1585
1586 /* Return the CTF handle for the parent CTF container, if one exists.
1587    Otherwise return NULL to indicate this container has no imported parent.  */
1588 ctf_file_t *
1589 ctf_parent_file (ctf_file_t *fp)
1590 {
1591   return fp->ctf_parent;
1592 }
1593
1594 /* Return the name of the parent CTF container, if one exists.  Otherwise
1595    return NULL to indicate this container is a root container.  */
1596 const char *
1597 ctf_parent_name (ctf_file_t *fp)
1598 {
1599   return fp->ctf_parname;
1600 }
1601
1602 /* Set the parent name.  It is an error to call this routine without calling
1603    ctf_import() at some point.  */
1604 void
1605 ctf_parent_name_set (ctf_file_t *fp, const char *name)
1606 {
1607   if (fp->ctf_dynparname != NULL)
1608     ctf_free (fp->ctf_dynparname);
1609
1610   fp->ctf_dynparname = ctf_strdup (name);
1611   fp->ctf_parname = fp->ctf_dynparname;
1612 }
1613
1614 /* Import the types from the specified parent container by storing a pointer
1615    to it in ctf_parent and incrementing its reference count.  Only one parent
1616    is allowed: if a parent already exists, it is replaced by the new parent.  */
1617 int
1618 ctf_import (ctf_file_t *fp, ctf_file_t *pfp)
1619 {
1620   if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
1621     return (ctf_set_errno (fp, EINVAL));
1622
1623   if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
1624     return (ctf_set_errno (fp, ECTF_DMODEL));
1625
1626   if (fp->ctf_parent != NULL)
1627     ctf_file_close (fp->ctf_parent);
1628
1629   if (pfp != NULL)
1630     {
1631       fp->ctf_flags |= LCTF_CHILD;
1632       pfp->ctf_refcnt++;
1633
1634       if (fp->ctf_parname == NULL)
1635         ctf_parent_name_set (fp, "PARENT");
1636     }
1637   fp->ctf_parent = pfp;
1638   return 0;
1639 }
1640
1641 /* Set the data model constant for the CTF container.  */
1642 int
1643 ctf_setmodel (ctf_file_t *fp, int model)
1644 {
1645   const ctf_dmodel_t *dp;
1646
1647   for (dp = _libctf_models; dp->ctd_name != NULL; dp++)
1648     {
1649       if (dp->ctd_code == model)
1650         {
1651           fp->ctf_dmodel = dp;
1652           return 0;
1653         }
1654     }
1655
1656   return (ctf_set_errno (fp, EINVAL));
1657 }
1658
1659 /* Return the data model constant for the CTF container.  */
1660 int
1661 ctf_getmodel (ctf_file_t *fp)
1662 {
1663   return fp->ctf_dmodel->ctd_code;
1664 }
1665
1666 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1667    function.  */
1668 void
1669 ctf_setspecific (ctf_file_t *fp, void *data)
1670 {
1671   fp->ctf_specific = data;
1672 }
1673
1674 /* Retrieve the arbitrary pointer again.  */
1675 void *
1676 ctf_getspecific (ctf_file_t *fp)
1677 {
1678   return fp->ctf_specific;
1679 }