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         default:
 860           ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
 861                        kind);
 862           return ECTF_CORRUPT;
 863         }
 864
 865       *xp = (uint32_t) ((uintptr_t) tp - (uintptr_t) fp->ctf_buf);
 866       tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes);
 867     }
 868
 869   ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax);
 870   ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp->ctf_enums));
 871   ctf_dprintf ("%u struct names hashed (%d long)\n",
 872                ctf_hash_size (fp->ctf_structs), nlstructs);
 873   ctf_dprintf ("%u union names hashed (%d long)\n",
 874                ctf_hash_size (fp->ctf_unions), nlunions);
 875   ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp->ctf_names));
 876
 877   /* Make an additional pass through the pointer table to find pointers that
 878      point to anonymous typedef nodes.  If we find one, modify the pointer table
 879      so that the pointer is also known to point to the node that is referenced
 880      by the anonymous typedef node.  */
 881
 882   for (id = 1; id <= fp->ctf_typemax; id++)
 883     {
 884       if ((dst = fp->ctf_ptrtab[id]) != 0)
 885         {
 886           tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
 887
 888           if (LCTF_INFO_KIND (fp, tp->ctt_info) == CTF_K_TYPEDEF &&
 889               strcmp (ctf_strptr (fp, tp->ctt_name), "") == 0 &&
 890               LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child &&
 891               LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
 892             fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = dst;
 893         }
 894     }
 895
 896   return 0;
 897 }
 898
 899 /* Endianness-flipping routines.
 900
 901    We flip everything, mindlessly, even 1-byte entities, so that future
 902    expansions do not require changes to this code.  */
 903
 904 /* < C11? define away static assertions.  */
 905
 906 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
 907 #define _Static_assert(cond, err)
 908 #endif
 909
 910 /* Swap the endianness of something.  */
 911
 912 #define swap_thing(x)                                                   \
 913   do {                                                                  \
 914     _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0             \
 915                                         && sizeof (x) <= 8),            \
 916                     "Invalid size, update endianness code");            \
 917     switch (sizeof (x)) {                                               \
 918     case 2: x = bswap_16 (x); break;                                    \
 919     case 4: x = bswap_32 (x); break;                                    \
 920     case 8: x = bswap_64 (x); break;                                    \
 921     case 1: /* Nothing needs doing */                                   \
 922       break;                                                            \
 923     }                                                                   \
 924   } while (0);
 925
 926 /* Flip the endianness of the CTF header.  */
 927
 928 static void
 929 flip_header (ctf_header_t *cth)
 930 {
 931   swap_thing (cth->cth_preamble.ctp_magic);
 932   swap_thing (cth->cth_preamble.ctp_version);
 933   swap_thing (cth->cth_preamble.ctp_flags);
 934   swap_thing (cth->cth_parlabel);
 935   swap_thing (cth->cth_parname);
 936   swap_thing (cth->cth_objtoff);
 937   swap_thing (cth->cth_funcoff);
 938   swap_thing (cth->cth_varoff);
 939   swap_thing (cth->cth_typeoff);
 940   swap_thing (cth->cth_stroff);
 941   swap_thing (cth->cth_strlen);
 942 }
 943
 944 /* Flip the endianness of the label section, an array of ctf_lblent_t.  */
 945
 946 static void
 947 flip_lbls (void *start, size_t len)
 948 {
 949   ctf_lblent_t *lbl = start;
 950
 951   for (ssize_t i = len / sizeof (struct ctf_lblent); i > 0; lbl++, i--)
 952     {
 953       swap_thing (lbl->ctl_label);
 954       swap_thing (lbl->ctl_type);
 955     }
 956 }
 957
 958 /* Flip the endianness of the data-object or function sections, an array of
 959    uint32_t.  (The function section has more internal structure, but that
 960    structure is an array of uint32_t, so can be treated as one big array for
 961    byte-swapping.)  */
 962
 963 static void
 964 flip_objts (void *start, size_t len)
 965 {
 966   uint32_t *obj = start;
 967
 968   for (ssize_t i = len / sizeof (uint32_t); i > 0; obj++, i--)
 969       swap_thing (*obj);
 970 }
 971
 972 /* Flip the endianness of the variable section, an array of ctf_varent_t.  */
 973
 974 static void
 975 flip_vars (void *start, size_t len)
 976 {
 977   ctf_varent_t *var = start;
 978
 979   for (ssize_t i = len / sizeof (struct ctf_varent); i > 0; var++, i--)
 980     {
 981       swap_thing (var->ctv_name);
 982       swap_thing (var->ctv_type);
 983     }
 984 }
 985
 986 /* Flip the endianness of the type section, a tagged array of ctf_type or
 987    ctf_stype followed by variable data.  */
 988
 989 static int
 990 flip_types (void *start, size_t len)
 991 {
 992   ctf_type_t *t = start;
 993
 994   while ((uintptr_t) t < ((uintptr_t) start) + len)
 995     {
 996       swap_thing (t->ctt_name);
 997       swap_thing (t->ctt_info);
 998       swap_thing (t->ctt_size);
 999
1000       uint32_t kind = CTF_V2_INFO_KIND (t->ctt_info);
1001       size_t size = t->ctt_size;
1002       uint32_t vlen = CTF_V2_INFO_VLEN (t->ctt_info);
1003       size_t vbytes = get_vbytes_v2 (kind, size, vlen);
1004
1005       if (_libctf_unlikely_ (size == CTF_LSIZE_SENT))
1006         {
1007           swap_thing (t->ctt_lsizehi);
1008           swap_thing (t->ctt_lsizelo);
1009           size = CTF_TYPE_LSIZE (t);
1010           t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t));
1011         }
1012       else
1013         t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_stype_t));
1014
1015       switch (kind)
1016         {
1017         case CTF_K_FORWARD:
1018         case CTF_K_UNKNOWN:
1019         case CTF_K_POINTER:
1020         case CTF_K_TYPEDEF:
1021         case CTF_K_VOLATILE:
1022         case CTF_K_CONST:
1023         case CTF_K_RESTRICT:
1024           /* These types have no vlen data to swap.  */
1025           assert (vbytes == 0);
1026           break;
1027
1028         case CTF_K_INTEGER:
1029         case CTF_K_FLOAT:
1030           {
1031             /* These types have a single uint32_t.  */
1032
1033             uint32_t *item = (uint32_t *) t;
1034
1035             swap_thing (*item);
1036             break;
1037           }
1038
1039         case CTF_K_FUNCTION:
1040           {
1041             /* This type has a bunch of uint32_ts.  */
1042
1043             uint32_t *item = (uint32_t *) t;
1044
1045             for (ssize_t i = vlen; i > 0; item++, i--)
1046               swap_thing (*item);
1047             break;
1048           }
1049
1050         case CTF_K_ARRAY:
1051           {
1052             /* This has a single ctf_array_t.  */
1053
1054             ctf_array_t *a = (ctf_array_t *) t;
1055
1056             assert (vbytes == sizeof (ctf_array_t));
1057             swap_thing (a->cta_contents);
1058             swap_thing (a->cta_index);
1059             swap_thing (a->cta_nelems);
1060
1061             break;
1062           }
1063
1064         case CTF_K_SLICE:
1065           {
1066             /* This has a single ctf_slice_t.  */
1067
1068             ctf_slice_t *s = (ctf_slice_t *) t;
1069
1070             assert (vbytes == sizeof (ctf_slice_t));
1071             swap_thing (s->cts_type);
1072             swap_thing (s->cts_offset);
1073             swap_thing (s->cts_bits);
1074
1075             break;
1076           }
1077
1078         case CTF_K_STRUCT:
1079         case CTF_K_UNION:
1080           {
1081             /* This has an array of ctf_member or ctf_lmember, depending on
1082                size.  We could consider it to be a simple array of uint32_t,
1083                but for safety's sake in case these structures ever acquire
1084                non-uint32_t members, do it member by member.  */
1085
1086             if (_libctf_unlikely_ (size >= CTF_LSTRUCT_THRESH))
1087               {
1088                 ctf_lmember_t *lm = (ctf_lmember_t *) t;
1089                 for (ssize_t i = vlen; i > 0; i--, lm++)
1090                   {
1091                     swap_thing (lm->ctlm_name);
1092                     swap_thing (lm->ctlm_offsethi);
1093                     swap_thing (lm->ctlm_type);
1094                     swap_thing (lm->ctlm_offsetlo);
1095                   }
1096               }
1097             else
1098               {
1099                 ctf_member_t *m = (ctf_member_t *) t;
1100                 for (ssize_t i = vlen; i > 0; i--, m++)
1101                   {
1102                     swap_thing (m->ctm_name);
1103                     swap_thing (m->ctm_offset);
1104                     swap_thing (m->ctm_type);
1105                   }
1106               }
1107             break;
1108           }
1109
1110         case CTF_K_ENUM:
1111           {
1112             /* This has an array of ctf_enum_t.  */
1113
1114             ctf_enum_t *item = (ctf_enum_t *) t;
1115
1116             for (ssize_t i = vlen; i > 0; item++, i--)
1117               {
1118                 swap_thing (item->cte_name);
1119                 swap_thing (item->cte_value);
1120               }
1121             break;
1122           }
1123         default:
1124           ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1125                        kind);
1126           return ECTF_CORRUPT;
1127         }
1128
1129       t = (ctf_type_t *) ((uintptr_t) t + vbytes);
1130     }
1131
1132   return 0;
1133 }
1134
1135 /* Flip the endianness of BASE, given the offsets in the (already endian-
1136    converted) CTH.
1137
1138    All of this stuff happens before the header is fully initialized, so the
1139    LCTF_*() macros cannot be used yet.  Since we do not try to endian-convert v1
1140    data, this is no real loss.  */
1141
1142 static int
1143 flip_ctf (ctf_header_t *cth, unsigned char *base)
1144 {
1145   base += sizeof (ctf_header_t);
1146
1147   flip_lbls (base + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff);
1148   flip_objts (base + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff);
1149   flip_objts (base + cth->cth_funcoff, cth->cth_varoff - cth->cth_funcoff);
1150   flip_vars (base + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff);
1151   return flip_types (base + cth->cth_typeoff, cth->cth_stroff - cth->cth_typeoff);
1152 }
1153
1154 /* Open a CTF file, mocking up a suitable ctf_sect.  */
1155 ctf_file_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
1156                              const char *symsect, size_t symsect_size,
1157                              size_t symsect_entsize,
1158                              const char *strsect, size_t strsect_size,
1159                              int *errp)
1160 {
1161   ctf_sect_t skeleton;
1162
1163   ctf_sect_t ctf_sect, sym_sect, str_sect;
1164   ctf_sect_t *ctfsectp = NULL;
1165   ctf_sect_t *symsectp = NULL;
1166   ctf_sect_t *strsectp = NULL;
1167
1168   skeleton.cts_name = _CTF_SECTION;
1169   skeleton.cts_entsize = 1;
1170
1171   if (ctfsect)
1172     {
1173       memcpy (&ctf_sect, &skeleton, sizeof (struct ctf_sect));
1174       ctf_sect.cts_data = ctfsect;
1175       ctf_sect.cts_size = ctfsect_size;
1176       ctfsectp = &ctf_sect;
1177     }
1178
1179   if (symsect)
1180     {
1181       memcpy (&sym_sect, &skeleton, sizeof (struct ctf_sect));
1182       sym_sect.cts_data = symsect;
1183       sym_sect.cts_size = symsect_size;
1184       sym_sect.cts_entsize = symsect_entsize;
1185       symsectp = &sym_sect;
1186     }
1187
1188   if (strsect)
1189     {
1190       memcpy (&str_sect, &skeleton, sizeof (struct ctf_sect));
1191       str_sect.cts_data = strsect;
1192       str_sect.cts_size = strsect_size;
1193       strsectp = &str_sect;
1194     }
1195
1196   return ctf_bufopen (ctfsectp, symsectp, strsectp, errp);
1197 }
1198
1199 /* Decode the specified CTF buffer and optional symbol table, and create a new
1200    CTF container representing the symbolic debugging information.  This code can
1201    be used directly by the debugger, or it can be used as the engine for
1202    ctf_fdopen() or ctf_open(), below.  */
1203
1204 ctf_file_t *
1205 ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
1206              const ctf_sect_t *strsect, int *errp)
1207 {
1208   const ctf_preamble_t *pp;
1209   ctf_header_t hp;
1210   ctf_file_t *fp;
1211   void *buf, *base;
1212   size_t size, hdrsz;
1213   int foreign_endian = 0;
1214   int err;
1215
1216   libctf_init_debug();
1217
1218   if (ctfsect == NULL || ((symsect == NULL) != (strsect == NULL)))
1219     return (ctf_set_open_errno (errp, EINVAL));
1220
1221   if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) &&
1222       symsect->cts_entsize != sizeof (Elf64_Sym))
1223     return (ctf_set_open_errno (errp, ECTF_SYMTAB));
1224
1225   if (symsect != NULL && symsect->cts_data == NULL)
1226     return (ctf_set_open_errno (errp, ECTF_SYMBAD));
1227
1228   if (strsect != NULL && strsect->cts_data == NULL)
1229     return (ctf_set_open_errno (errp, ECTF_STRBAD));
1230
1231   if (ctfsect->cts_size < sizeof (ctf_preamble_t))
1232     return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1233
1234   pp = (const ctf_preamble_t *) ctfsect->cts_data;
1235
1236   ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1237                pp->ctp_magic, pp->ctp_version);
1238
1239   /* Validate each part of the CTF header.
1240
1241      First, we validate the preamble (common to all versions).  At that point,
1242      we know the endianness and specific header version, and can validate the
1243      version-specific parts including section offsets and alignments.
1244
1245      We specifically do not support foreign-endian old versions.  */
1246
1247   if (_libctf_unlikely_ (pp->ctp_magic != CTF_MAGIC))
1248     {
1249       if (pp->ctp_magic == bswap_16 (CTF_MAGIC))
1250         {
1251           if (pp->ctp_version != CTF_VERSION_3)
1252             return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1253           foreign_endian = 1;
1254         }
1255       else
1256         return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1257     }
1258
1259   if (_libctf_unlikely_ ((pp->ctp_version < CTF_VERSION_1)
1260                          || (pp->ctp_version > CTF_VERSION_3)))
1261     return (ctf_set_open_errno (errp, ECTF_CTFVERS));
1262
1263   if ((symsect != NULL) && (pp->ctp_version < CTF_VERSION_2))
1264     {
1265       /* The symtab can contain function entries which contain embedded ctf
1266          info.  We do not support dynamically upgrading such entries (none
1267          should exist in any case, since dwarf2ctf does not create them).  */
1268
1269       ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1270                    "supported\n", pp->ctp_version);
1271       return (ctf_set_open_errno (errp, ECTF_NOTSUP));
1272     }
1273
1274   if (ctfsect->cts_size < sizeof (ctf_header_t))
1275     return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
1276
1277   memcpy (&hp, ctfsect->cts_data, sizeof (hp));
1278
1279   if (foreign_endian)
1280     flip_header (&hp);
1281
1282   ctf_dprintf ("header offsets: %x/%x/%x/%x/%x/%x/%x\n",
1283                hp.cth_lbloff, hp.cth_objtoff, hp.cth_funcoff, hp.cth_varoff,
1284                hp.cth_typeoff, hp.cth_stroff, hp.cth_strlen);
1285   hdrsz = sizeof (ctf_header_t);
1286
1287   size = hp.cth_stroff + hp.cth_strlen;
1288
1289   ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", (unsigned long) size);
1290
1291   if (hp.cth_lbloff > size || hp.cth_objtoff > size
1292       || hp.cth_funcoff > size || hp.cth_typeoff > size || hp.cth_stroff > size)
1293     return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1294
1295   if (hp.cth_lbloff > hp.cth_objtoff
1296       || hp.cth_objtoff > hp.cth_funcoff
1297       || hp.cth_funcoff > hp.cth_typeoff
1298       || hp.cth_funcoff > hp.cth_varoff
1299       || hp.cth_varoff > hp.cth_typeoff || hp.cth_typeoff > hp.cth_stroff)
1300     return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1301
1302   if ((hp.cth_lbloff & 3) || (hp.cth_objtoff & 1)
1303       || (hp.cth_funcoff & 1) || (hp.cth_varoff & 3) || (hp.cth_typeoff & 3))
1304     return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1305
1306   /* Once everything is determined to be valid, attempt to decompress the CTF
1307      data buffer if it is compressed, or copy it into new storage if it is not
1308      compressed but needs endian-flipping.  Otherwise we just put the data
1309      section's buffer pointer into ctf_buf, below.  */
1310
1311   /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1312      init_types().  */
1313
1314   if (hp.cth_flags & CTF_F_COMPRESS)
1315     {
1316       size_t srclen;
1317       uLongf dstlen;
1318       const void *src;
1319       int rc = Z_OK;
1320
1321       if ((base = ctf_alloc (size + hdrsz)) == NULL)
1322         return (ctf_set_open_errno (errp, ECTF_ZALLOC));
1323
1324       memcpy (base, ctfsect->cts_data, hdrsz);
1325       ((ctf_preamble_t *) base)->ctp_flags &= ~CTF_F_COMPRESS;
1326       buf = (unsigned char *) base + hdrsz;
1327
1328       src = (unsigned char *) ctfsect->cts_data + hdrsz;
1329       srclen = ctfsect->cts_size - hdrsz;
1330       dstlen = size;
1331
1332       if ((rc = uncompress (buf, &dstlen, src, srclen)) != Z_OK)
1333         {
1334           ctf_dprintf ("zlib inflate err: %s\n", zError (rc));
1335           free (base);
1336           return (ctf_set_open_errno (errp, ECTF_DECOMPRESS));
1337         }
1338
1339       if ((size_t) dstlen != size)
1340         {
1341           ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1342                        "bytes\n", (unsigned long) dstlen, (unsigned long) size);
1343           free (base);
1344           return (ctf_set_open_errno (errp, ECTF_CORRUPT));
1345         }
1346
1347     }
1348   else if (foreign_endian)
1349     {
1350       if ((base = ctf_alloc (size + hdrsz)) == NULL)
1351         return (ctf_set_open_errno (errp, ECTF_ZALLOC));
1352     }
1353   else
1354     {
1355       base = (void *) ctfsect->cts_data;
1356       buf = (unsigned char *) base + hdrsz;
1357     }
1358
1359   /* Once we have uncompressed and validated the CTF data buffer, we can
1360      proceed with allocating a ctf_file_t and initializing it.
1361
1362      Nothing that depends on buf or base should be set directly in this function
1363      before the init_types() call, because it may be reallocated during
1364      transparent upgrade if this recension of libctf is so configured: see
1365      ctf_set_base() and ctf_realloc_base().  */
1366
1367   if ((fp = ctf_alloc (sizeof (ctf_file_t))) == NULL)
1368     return (ctf_set_open_errno (errp, ENOMEM));
1369
1370   memset (fp, 0, sizeof (ctf_file_t));
1371   ctf_set_version (fp, &hp, hp.cth_version);
1372
1373   if (_libctf_unlikely_ (hp.cth_version < CTF_VERSION_2))
1374     fp->ctf_parmax = CTF_MAX_PTYPE_V1;
1375   else
1376     fp->ctf_parmax = CTF_MAX_PTYPE;
1377
1378   memcpy (&fp->ctf_data, ctfsect, sizeof (ctf_sect_t));
1379
1380   if (symsect != NULL)
1381     {
1382       memcpy (&fp->ctf_symtab, symsect, sizeof (ctf_sect_t));
1383       memcpy (&fp->ctf_strtab, strsect, sizeof (ctf_sect_t));
1384     }
1385
1386   if (fp->ctf_data.cts_name != NULL)
1387     fp->ctf_data.cts_name = ctf_strdup (fp->ctf_data.cts_name);
1388   if (fp->ctf_symtab.cts_name != NULL)
1389     fp->ctf_symtab.cts_name = ctf_strdup (fp->ctf_symtab.cts_name);
1390   if (fp->ctf_strtab.cts_name != NULL)
1391     fp->ctf_strtab.cts_name = ctf_strdup (fp->ctf_strtab.cts_name);
1392
1393   if (fp->ctf_data.cts_name == NULL)
1394     fp->ctf_data.cts_name = _CTF_NULLSTR;
1395   if (fp->ctf_symtab.cts_name == NULL)
1396     fp->ctf_symtab.cts_name = _CTF_NULLSTR;
1397   if (fp->ctf_strtab.cts_name == NULL)
1398     fp->ctf_strtab.cts_name = _CTF_NULLSTR;
1399
1400   if (strsect != NULL)
1401     {
1402       fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data;
1403       fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size;
1404     }
1405
1406   if (foreign_endian &&
1407       (err = flip_ctf (&hp, base)) != 0)
1408     {
1409       /* We can be certain that flip_ctf() will have endian-flipped everything
1410          other than the types table when we return.  In particular the header
1411          is fine, so set it, to allow freeing to use the usual code path.  */
1412
1413       (void) ctf_set_open_errno (errp, err);
1414       ctf_set_base (fp, &hp, base);
1415       goto bad;
1416     }
1417
1418   ctf_set_base (fp, &hp, base);
1419   fp->ctf_size = size + hdrsz;
1420
1421   if ((err = init_types (fp, &hp)) != 0)
1422     {
1423       (void) ctf_set_open_errno (errp, err);
1424       goto bad;
1425     }
1426
1427   /* If we have a symbol table section, allocate and initialize
1428      the symtab translation table, pointed to by ctf_sxlate.  */
1429
1430   if (symsect != NULL)
1431     {
1432       fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
1433       fp->ctf_sxlate = ctf_alloc (fp->ctf_nsyms * sizeof (uint32_t));
1434
1435       if (fp->ctf_sxlate == NULL)
1436         {
1437           (void) ctf_set_open_errno (errp, ENOMEM);
1438           goto bad;
1439         }
1440
1441       if ((err = init_symtab (fp, &hp, symsect, strsect)) != 0)
1442         {
1443           (void) ctf_set_open_errno (errp, err);
1444           goto bad;
1445         }
1446     }
1447
1448   /* Initialize the ctf_lookup_by_name top-level dictionary.  We keep an
1449      array of type name prefixes and the corresponding ctf_hash to use.
1450      NOTE: This code must be kept in sync with the code in ctf_update().  */
1451   fp->ctf_lookups[0].ctl_prefix = "struct";
1452   fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
1453   fp->ctf_lookups[0].ctl_hash = fp->ctf_structs;
1454   fp->ctf_lookups[1].ctl_prefix = "union";
1455   fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
1456   fp->ctf_lookups[1].ctl_hash = fp->ctf_unions;
1457   fp->ctf_lookups[2].ctl_prefix = "enum";
1458   fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
1459   fp->ctf_lookups[2].ctl_hash = fp->ctf_enums;
1460   fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
1461   fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
1462   fp->ctf_lookups[3].ctl_hash = fp->ctf_names;
1463   fp->ctf_lookups[4].ctl_prefix = NULL;
1464   fp->ctf_lookups[4].ctl_len = 0;
1465   fp->ctf_lookups[4].ctl_hash = NULL;
1466
1467   if (symsect != NULL)
1468     {
1469       if (symsect->cts_entsize == sizeof (Elf64_Sym))
1470         (void) ctf_setmodel (fp, CTF_MODEL_LP64);
1471       else
1472         (void) ctf_setmodel (fp, CTF_MODEL_ILP32);
1473     }
1474   else
1475     (void) ctf_setmodel (fp, CTF_MODEL_NATIVE);
1476
1477   fp->ctf_refcnt = 1;
1478   return fp;
1479
1480 bad:
1481   ctf_file_close (fp);
1482   return NULL;
1483 }
1484
1485 /* Close the specified CTF container and free associated data structures.  Note
1486    that ctf_file_close() is a reference counted operation: if the specified file
1487    is the parent of other active containers, its reference count will be greater
1488    than one and it will be freed later when no active children exist.  */
1489
1490 void
1491 ctf_file_close (ctf_file_t *fp)
1492 {
1493   ctf_dtdef_t *dtd, *ntd;
1494   ctf_dvdef_t *dvd, *nvd;
1495
1496   if (fp == NULL)
1497     return;                /* Allow ctf_file_close(NULL) to simplify caller code.  */
1498
1499   ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp, fp->ctf_refcnt);
1500
1501   if (fp->ctf_refcnt > 1)
1502     {
1503       fp->ctf_refcnt--;
1504       return;
1505     }
1506
1507   if (fp->ctf_dynparname != NULL)
1508     ctf_free (fp->ctf_dynparname);
1509
1510   if (fp->ctf_parent != NULL)
1511     ctf_file_close (fp->ctf_parent);
1512
1513   for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
1514     {
1515       ntd = ctf_list_next (dtd);
1516       ctf_dtd_delete (fp, dtd);
1517     }
1518   ctf_dynhash_destroy (fp->ctf_dthash);
1519   ctf_dynhash_destroy (fp->ctf_dtbyname);
1520
1521   for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
1522     {
1523       nvd = ctf_list_next (dvd);
1524       ctf_dvd_delete (fp, dvd);
1525     }
1526   ctf_dynhash_destroy (fp->ctf_dvhash);
1527
1528   ctf_free (fp->ctf_tmp_typeslice);
1529
1530   if (fp->ctf_data.cts_name != _CTF_NULLSTR &&
1531       fp->ctf_data.cts_name != NULL)
1532     ctf_free ((char *) fp->ctf_data.cts_name);
1533
1534   if (fp->ctf_symtab.cts_name != _CTF_NULLSTR &&
1535       fp->ctf_symtab.cts_name != NULL)
1536     ctf_free ((char *) fp->ctf_symtab.cts_name);
1537
1538   if (fp->ctf_strtab.cts_name != _CTF_NULLSTR &&
1539       fp->ctf_strtab.cts_name != NULL)
1540     ctf_free ((char *) fp->ctf_strtab.cts_name);
1541
1542   else if (fp->ctf_data_mmapped)
1543     ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
1544
1545   ctf_free_base (fp, NULL);
1546
1547   if (fp->ctf_sxlate != NULL)
1548     ctf_free (fp->ctf_sxlate);
1549
1550   if (fp->ctf_txlate != NULL)
1551     ctf_free (fp->ctf_txlate);
1552
1553   if (fp->ctf_ptrtab != NULL)
1554     ctf_free (fp->ctf_ptrtab);
1555
1556   ctf_hash_destroy (fp->ctf_structs);
1557   ctf_hash_destroy (fp->ctf_unions);
1558   ctf_hash_destroy (fp->ctf_enums);
1559   ctf_hash_destroy (fp->ctf_names);
1560
1561   ctf_free (fp);
1562 }
1563
1564 /* The converse of ctf_open().  ctf_open() disguises whatever it opens as an
1565    archive, so closing one is just like closing an archive.  */
1566 void
1567 ctf_close (ctf_archive_t *arc)
1568 {
1569   ctf_arc_close (arc);
1570 }
1571
1572 /* Get the CTF archive from which this ctf_file_t is derived.  */
1573 ctf_archive_t *
1574 ctf_get_arc (const ctf_file_t *fp)
1575 {
1576   return fp->ctf_archive;
1577 }
1578
1579 /* Return the ctfsect out of the core ctf_impl.  Useful for freeing the
1580    ctfsect's data * after ctf_file_close(), which is why we return the actual
1581    structure, not a pointer to it, since that is likely to become a pointer to
1582    freed data before the return value is used under the expected use case of
1583    ctf_getsect()/ ctf_file_close()/free().  */
1584 extern ctf_sect_t
1585 ctf_getdatasect (const ctf_file_t *fp)
1586 {
1587   return fp->ctf_data;
1588 }
1589
1590 /* Return the CTF handle for the parent CTF container, if one exists.
1591    Otherwise return NULL to indicate this container has no imported parent.  */
1592 ctf_file_t *
1593 ctf_parent_file (ctf_file_t *fp)
1594 {
1595   return fp->ctf_parent;
1596 }
1597
1598 /* Return the name of the parent CTF container, if one exists.  Otherwise
1599    return NULL to indicate this container is a root container.  */
1600 const char *
1601 ctf_parent_name (ctf_file_t *fp)
1602 {
1603   return fp->ctf_parname;
1604 }
1605
1606 /* Set the parent name.  It is an error to call this routine without calling
1607    ctf_import() at some point.  */
1608 void
1609 ctf_parent_name_set (ctf_file_t *fp, const char *name)
1610 {
1611   if (fp->ctf_dynparname != NULL)
1612     ctf_free (fp->ctf_dynparname);
1613
1614   fp->ctf_dynparname = ctf_strdup (name);
1615   fp->ctf_parname = fp->ctf_dynparname;
1616 }
1617
1618 /* Import the types from the specified parent container by storing a pointer
1619    to it in ctf_parent and incrementing its reference count.  Only one parent
1620    is allowed: if a parent already exists, it is replaced by the new parent.  */
1621 int
1622 ctf_import (ctf_file_t *fp, ctf_file_t *pfp)
1623 {
1624   if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0))
1625     return (ctf_set_errno (fp, EINVAL));
1626
1627   if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel)
1628     return (ctf_set_errno (fp, ECTF_DMODEL));
1629
1630   if (fp->ctf_parent != NULL)
1631     ctf_file_close (fp->ctf_parent);
1632
1633   if (pfp != NULL)
1634     {
1635       fp->ctf_flags |= LCTF_CHILD;
1636       pfp->ctf_refcnt++;
1637
1638       if (fp->ctf_parname == NULL)
1639         ctf_parent_name_set (fp, "PARENT");
1640     }
1641   fp->ctf_parent = pfp;
1642   return 0;
1643 }
1644
1645 /* Set the data model constant for the CTF container.  */
1646 int
1647 ctf_setmodel (ctf_file_t *fp, int model)
1648 {
1649   const ctf_dmodel_t *dp;
1650
1651   for (dp = _libctf_models; dp->ctd_name != NULL; dp++)
1652     {
1653       if (dp->ctd_code == model)
1654         {
1655           fp->ctf_dmodel = dp;
1656           return 0;
1657         }
1658     }
1659
1660   return (ctf_set_errno (fp, EINVAL));
1661 }
1662
1663 /* Return the data model constant for the CTF container.  */
1664 int
1665 ctf_getmodel (ctf_file_t *fp)
1666 {
1667   return fp->ctf_dmodel->ctd_code;
1668 }
1669
1670 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1671    function.  */
1672 void
1673 ctf_setspecific (ctf_file_t *fp, void *data)
1674 {
1675   fp->ctf_specific = data;
1676 }
1677
1678 /* Retrieve the arbitrary pointer again.  */
1679 void *
1680 ctf_getspecific (ctf_file_t *fp)
1681 {
1682   return fp->ctf_specific;
1683 }