libctf/ctf-impl.h

   1 /* Implementation header.
   2    Copyright (C) 2019-2020 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 #ifndef _CTF_IMPL_H
  21 #define _CTF_IMPL_H
  22
  23 #include "config.h"
  24 #include <errno.h>
  25 #include <sys/param.h>
  26 #include "ctf-decls.h"
  27 #include <ctf-api.h>
  28 #include "ctf-sha1.h"
  29 #include <sys/types.h>
  30 #include <stdlib.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <stdint.h>
  34 #include <limits.h>
  35 #include <ctype.h>
  36 #include <elf.h>
  37 #include <bfd.h>
  38 #include "hashtab.h"
  39 #include "ctf-intl.h"
  40
  41 #ifdef  __cplusplus
  42 extern "C"
  43 {
  44 #endif
  45
  46 /* Compiler attributes.  */
  47
  48 #if defined (__GNUC__)
  49
  50 /* GCC.  We assume that all compilers claiming to be GCC support sufficiently
  51    many GCC attributes that the code below works.  If some non-GCC compilers
  52    masquerading as GCC in fact do not implement these attributes, version checks
  53    may be required.  */
  54
  55 /* We use the _libctf_*_ pattern to avoid clashes with any future attribute
  56    macros glibc may introduce, which have names of the pattern
  57    __attribute_blah__.  */
  58
  59 #define _libctf_printflike_(string_index,first_to_check) \
  60     __attribute__ ((__format__ (__printf__, (string_index), (first_to_check))))
  61 #define _libctf_unlikely_(x) __builtin_expect ((x), 0)
  62 #define _libctf_unused_ __attribute__ ((__unused__))
  63 #define _libctf_malloc_ __attribute__((__malloc__))
  64
  65 #else
  66
  67 #define _libctf_printflike_(string_index,first_to_check)
  68 #define _libctf_unlikely_(x) (x)
  69 #define _libctf_unused_
  70 #define _libctf_malloc_
  71 #define __extension__
  72
  73 #endif
  74
  75 #if defined (ENABLE_LIBCTF_HASH_DEBUGGING) && !defined (NDEBUG)
  76 #include <assert.h>
  77 #define ctf_assert(fp, expr) (assert (expr), 1)
  78 #else
  79 #define ctf_assert(fp, expr)                                            \
  80   _libctf_unlikely_ (ctf_assert_internal (fp, __FILE__, __LINE__,       \
  81                                           #expr, !!(expr)))
  82 #endif
  83
  84 /* libctf in-memory state.  */
  85
  86 typedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c.  */
  87 typedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c.  */
  88 typedef struct ctf_dynset ctf_dynset_t;   /* Private to ctf-hash.c.  */
  89
  90 typedef struct ctf_strs
  91 {
  92   const char *cts_strs;         /* Base address of string table.  */
  93   size_t cts_len;               /* Size of string table in bytes.  */
  94 } ctf_strs_t;
  95
  96 typedef struct ctf_strs_writable
  97 {
  98   char *cts_strs;               /* Base address of string table.  */
  99   size_t cts_len;               /* Size of string table in bytes.  */
 100 } ctf_strs_writable_t;
 101
 102 typedef struct ctf_dmodel
 103 {
 104   const char *ctd_name;         /* Data model name.  */
 105   int ctd_code;                 /* Data model code.  */
 106   size_t ctd_pointer;           /* Size of void * in bytes.  */
 107   size_t ctd_char;              /* Size of char in bytes.  */
 108   size_t ctd_short;             /* Size of short in bytes.  */
 109   size_t ctd_int;               /* Size of int in bytes.  */
 110   size_t ctd_long;              /* Size of long in bytes.  */
 111 } ctf_dmodel_t;
 112
 113 typedef struct ctf_names
 114 {
 115   ctf_hash_t *ctn_readonly;     /* Hash table when readonly.  */
 116   ctf_dynhash_t *ctn_writable;  /* Hash table when writable.  */
 117 } ctf_names_t;
 118
 119 typedef struct ctf_lookup
 120 {
 121   const char *ctl_prefix;       /* String prefix for this lookup.  */
 122   size_t ctl_len;               /* Length of prefix string in bytes.  */
 123   ctf_names_t *ctl_hash;        /* Pointer to hash table for lookup.  */
 124 } ctf_lookup_t;
 125
 126 typedef struct ctf_fileops
 127 {
 128   uint32_t (*ctfo_get_kind) (uint32_t);
 129   uint32_t (*ctfo_get_root) (uint32_t);
 130   uint32_t (*ctfo_get_vlen) (uint32_t);
 131   ssize_t (*ctfo_get_ctt_size) (const ctf_file_t *, const ctf_type_t *,
 132                                 ssize_t *, ssize_t *);
 133   ssize_t (*ctfo_get_vbytes) (unsigned short, ssize_t, size_t);
 134 } ctf_fileops_t;
 135
 136 typedef struct ctf_list
 137 {
 138   struct ctf_list *l_prev;      /* Previous pointer or tail pointer.  */
 139   struct ctf_list *l_next;      /* Next pointer or head pointer.  */
 140 } ctf_list_t;
 141
 142 typedef enum
 143   {
 144    CTF_PREC_BASE,
 145    CTF_PREC_POINTER,
 146    CTF_PREC_ARRAY,
 147    CTF_PREC_FUNCTION,
 148    CTF_PREC_MAX
 149   } ctf_decl_prec_t;
 150
 151 typedef struct ctf_decl_node
 152 {
 153   ctf_list_t cd_list;           /* Linked list pointers.  */
 154   ctf_id_t cd_type;             /* Type identifier.  */
 155   uint32_t cd_kind;             /* Type kind.  */
 156   uint32_t cd_n;                /* Type dimension if array.  */
 157 } ctf_decl_node_t;
 158
 159 typedef struct ctf_decl
 160 {
 161   ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks.  */
 162   int cd_order[CTF_PREC_MAX];        /* Storage order of decls.  */
 163   ctf_decl_prec_t cd_qualp;          /* Qualifier precision.  */
 164   ctf_decl_prec_t cd_ordp;           /* Ordered precision.  */
 165   char *cd_buf;                      /* Buffer for output.  */
 166   int cd_err;                        /* Saved error value.  */
 167   int cd_enomem;                     /* Nonzero if OOM during printing.  */
 168 } ctf_decl_t;
 169
 170 typedef struct ctf_dmdef
 171 {
 172   ctf_list_t dmd_list;          /* List forward/back pointers.  */
 173   char *dmd_name;               /* Name of this member.  */
 174   ctf_id_t dmd_type;            /* Type of this member (for sou).  */
 175   unsigned long dmd_offset;     /* Offset of this member in bits (for sou).  */
 176   int dmd_value;                /* Value of this member (for enum).  */
 177 } ctf_dmdef_t;
 178
 179 typedef struct ctf_dtdef
 180 {
 181   ctf_list_t dtd_list;          /* List forward/back pointers.  */
 182   ctf_id_t dtd_type;            /* Type identifier for this definition.  */
 183   ctf_type_t dtd_data;          /* Type node, including name.  */
 184   union
 185   {
 186     ctf_list_t dtu_members;     /* struct, union, or enum */
 187     ctf_arinfo_t dtu_arr;       /* array */
 188     ctf_encoding_t dtu_enc;     /* integer or float */
 189     uint32_t *dtu_argv;         /* function */
 190     ctf_slice_t dtu_slice;      /* slice */
 191   } dtd_u;
 192 } ctf_dtdef_t;
 193
 194 typedef struct ctf_dvdef
 195 {
 196   ctf_list_t dvd_list;          /* List forward/back pointers.  */
 197   char *dvd_name;               /* Name associated with variable.  */
 198   ctf_id_t dvd_type;            /* Type of variable.  */
 199   unsigned long dvd_snapshots;  /* Snapshot count when inserted.  */
 200 } ctf_dvdef_t;
 201
 202 typedef struct ctf_bundle
 203 {
 204   ctf_file_t *ctb_file;         /* CTF container handle.  */
 205   ctf_id_t ctb_type;            /* CTF type identifier.  */
 206   ctf_dtdef_t *ctb_dtd;         /* CTF dynamic type definition (if any).  */
 207 } ctf_bundle_t;
 208
 209 typedef struct ctf_err_warning
 210 {
 211   ctf_list_t cew_list;          /* List forward/back pointers.  */
 212   int cew_is_warning;           /* 1 if warning, 0 if error.  */
 213   char *cew_text;               /* Error/warning text.  */
 214 } ctf_err_warning_t;
 215
 216 /* Atoms associate strings with a list of the CTF items that reference that
 217    string, so that ctf_update() can instantiate all the strings using the
 218    ctf_str_atoms and then reassociate them with the real string later.
 219
 220    Strings can be interned into ctf_str_atom without having refs associated
 221    with them, for values that are returned to callers, etc.  Items are only
 222    removed from this table on ctf_close(), but on every ctf_update(), all the
 223    csa_refs in all entries are purged.  */
 224
 225 typedef struct ctf_str_atom
 226 {
 227   const char *csa_str;          /* Backpointer to string (hash key).  */
 228   ctf_list_t csa_refs;          /* This string's refs.  */
 229   uint32_t csa_offset;          /* Strtab offset, if any.  */
 230   uint32_t csa_external_offset; /* External strtab offset, if any.  */
 231   unsigned long csa_snapshot_id; /* Snapshot ID at time of creation.  */
 232 } ctf_str_atom_t;
 233
 234 /* The refs of a single string in the atoms table.  */
 235
 236 typedef struct ctf_str_atom_ref
 237 {
 238   ctf_list_t caf_list;          /* List forward/back pointers.  */
 239   uint32_t *caf_ref;            /* A single ref to this string.  */
 240 } ctf_str_atom_ref_t;
 241
 242 /* The structure used as the key in a ctf_link_type_mapping.  The value is a
 243    type index, not a type ID.  */
 244
 245 typedef struct ctf_link_type_key
 246 {
 247   ctf_file_t *cltk_fp;
 248   ctf_id_t cltk_idx;
 249 } ctf_link_type_key_t;
 250
 251 /* The structure used as the key in a cd_id_to_file_t on 32-bit platforms.  */
 252 typedef struct ctf_type_id_key
 253 {
 254   int ctii_input_num;
 255   ctf_id_t ctii_type;
 256 } ctf_type_id_key_t;
 257
 258 /* Deduplicator state.
 259
 260    The dedup state below uses three terms consistently. A "hash" is a
 261    ctf_dynhash_t; a "hash value" is the hash value of a type as returned by
 262    ctf_dedup_hash_type; a "global type ID" or "global ID" is a packed-together
 263    reference to a single ctf_file_t (by array index in an array of inputs) and
 264    ctf_id_t, i.e. a single instance of some hash value in some input.
 265
 266    The deduplication algorithm takes a bunch of inputs and yields a single
 267    shared "output" and possibly many outputs corresponding to individual inputs
 268    that still contain types after sharing of unconflicted types.  Almost all
 269    deduplicator state is stored in the struct ctf_dedup in the output, though a
 270    (very) few things are stored in inputs for simplicity's sake, usually if they
 271    are linking together things within the scope of a single TU.
 272
 273    Flushed at the end of every ctf_dedup run.  */
 274
 275 typedef struct ctf_dedup
 276 {
 277   /* The CTF linker flags in force for this dedup run.  */
 278   int cd_link_flags;
 279
 280   /* On 32-bit platforms only, a hash of global type IDs, in the form of
 281      a ctf_link_type_id_key_t.  */
 282   ctf_dynhash_t *cd_id_to_file_t;
 283
 284   /* Atoms tables of decorated names: maps undecorated name to decorated name.
 285      (The actual allocations are in the CTF file for the former and the real
 286      atoms table for the latter).  Uses the same namespaces as ctf_lookups,
 287      below, but has no need for null-termination.  */
 288   ctf_dynhash_t *cd_decorated_names[4];
 289
 290   /* Map type names to a hash from type hash value -> number of times each value
 291      has appeared.  */
 292   ctf_dynhash_t *cd_name_counts;
 293
 294   /* Map global type IDs to type hash values.  Used to determine if types are
 295      already hashed without having to recompute their hash values again, and to
 296      link types together at later stages.  Forwards that are peeked through to
 297      structs and unions are not represented in here, so lookups that might be
 298      such a type (in practice, all lookups) must go via cd_replaced_types first
 299      to take this into account.  Discarded before each rehashing.  */
 300   ctf_dynhash_t *cd_type_hashes;
 301
 302   /* Maps from the names of structs/unions/enums to a a single GID which is the
 303      only appearance of that type in any input: if it appears in more than one
 304      input, a value which is a GID with an input_num of -1 appears.  Used in
 305      share-duplicated link mode link modes to determine whether structs/unions
 306      can be cited from multiple TUs.  Only populated in that link mode.  */
 307   ctf_dynhash_t *cd_struct_origin;
 308
 309   /* Maps type hash values to a set of hash values of the types that cite them:
 310      i.e., pointing backwards up the type graph.  Used for recursive conflict
 311      marking.  Citations from tagged structures, unions, and forwards do not
 312      appear in this graph.  */
 313   ctf_dynhash_t *cd_citers;
 314
 315   /* Maps type hash values to input global type IDs.  The value is a set (a
 316      hash) of global type IDs.  Discarded before each rehashing.  The result of
 317      the ctf_dedup function.  */
 318   ctf_dynhash_t *cd_output_mapping;
 319
 320   /* A map giving the GID of the first appearance of each type for each type
 321      hash value.  */
 322   ctf_dynhash_t *cd_output_first_gid;
 323
 324   /* Used to ensure that we never try to map a single type ID to more than one
 325      hash.  */
 326   ctf_dynhash_t *cd_output_mapping_guard;
 327
 328   /* Maps the global type IDs of structures in input TUs whose members still
 329      need emission to the global type ID of the already-emitted target type
 330      (which has no members yet) in the appropriate target.  Uniquely, the latter
 331      ID represents a *target* ID (i.e. the cd_output_mapping of some specified
 332      input): we encode the shared (parent) dict with an ID of -1.  */
 333   ctf_dynhash_t *cd_emission_struct_members;
 334
 335   /* A set (a hash) of hash values of conflicting types.  */
 336   ctf_dynset_t *cd_conflicting_types;
 337
 338   /* Maps type hashes to ctf_id_t's in this dictionary.  Populated only at
 339      emission time, in the dictionary where emission is taking place.  */
 340   ctf_dynhash_t *cd_output_emission_hashes;
 341
 342   /* Maps the decorated names of conflicted cross-TU forwards that were forcibly
 343      emitted in this TU to their emitted ctf_id_ts.  Populated only at emission
 344      time, in the dictionary where emission is taking place. */
 345   ctf_dynhash_t *cd_output_emission_conflicted_forwards;
 346
 347   /* Points to the output counterpart of this input dictionary, at emission
 348      time.  */
 349   ctf_file_t *cd_output;
 350 } ctf_dedup_t;
 351
 352 /* The ctf_file is the structure used to represent a CTF container to library
 353    clients, who see it only as an opaque pointer.  Modifications can therefore
 354    be made freely to this structure without regard to client versioning.  The
 355    ctf_file_t typedef appears in <ctf-api.h> and declares a forward tag.
 356
 357    NOTE: ctf_update() requires that everything inside of ctf_file either be an
 358    immediate value, a pointer to dynamically allocated data *outside* of the
 359    ctf_file itself, or a pointer to statically allocated data.  If you add a
 360    pointer to ctf_file that points to something within the ctf_file itself,
 361    you must make corresponding changes to ctf_update().  */
 362
 363 struct ctf_file
 364 {
 365   const ctf_fileops_t *ctf_fileops; /* Version-specific file operations.  */
 366   struct ctf_header *ctf_header;    /* The header from this CTF file.  */
 367   unsigned char ctf_openflags;      /* Flags the file had when opened.  */
 368   ctf_sect_t ctf_data;              /* CTF data from object file.  */
 369   ctf_sect_t ctf_symtab;            /* Symbol table from object file.  */
 370   ctf_sect_t ctf_strtab;            /* String table from object file.  */
 371   ctf_dynhash_t *ctf_prov_strtab;   /* Maps provisional-strtab offsets
 372                                        to names.  */
 373   ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names.  */
 374   void *ctf_data_mmapped;           /* CTF data we mmapped, to free later.  */
 375   size_t ctf_data_mmapped_len;      /* Length of CTF data we mmapped.  */
 376   ctf_names_t ctf_structs;          /* Hash table of struct types.  */
 377   ctf_names_t ctf_unions;           /* Hash table of union types.  */
 378   ctf_names_t ctf_enums;            /* Hash table of enum types.  */
 379   ctf_names_t ctf_names;            /* Hash table of remaining type names.  */
 380   ctf_lookup_t ctf_lookups[5];      /* Pointers to nametabs for name lookup.  */
 381   ctf_strs_t ctf_str[2];            /* Array of string table base and bounds.  */
 382   ctf_dynhash_t *ctf_str_atoms;   /* Hash table of ctf_str_atoms_t.  */
 383   uint64_t ctf_str_num_refs;      /* Number of refs to cts_str_atoms.  */
 384   uint32_t ctf_str_prov_offset;   /* Latest provisional offset assigned so far.  */
 385   unsigned char *ctf_base;        /* CTF file pointer.  */
 386   unsigned char *ctf_dynbase;     /* Freeable CTF file pointer. */
 387   unsigned char *ctf_buf;         /* Uncompressed CTF data buffer.  */
 388   size_t ctf_size;                /* Size of CTF header + uncompressed data.  */
 389   uint32_t *ctf_sxlate;           /* Translation table for symtab entries.  */
 390   unsigned long ctf_nsyms;        /* Number of entries in symtab xlate table.  */
 391   uint32_t *ctf_txlate;           /* Translation table for type IDs.  */
 392   uint32_t *ctf_ptrtab;           /* Translation table for pointer-to lookups.  */
 393   size_t ctf_ptrtab_len;          /* Num types storable in ptrtab currently.  */
 394   struct ctf_varent *ctf_vars;    /* Sorted variable->type mapping.  */
 395   unsigned long ctf_nvars;        /* Number of variables in ctf_vars.  */
 396   unsigned long ctf_typemax;      /* Maximum valid type ID number.  */
 397   const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above).  */
 398   const char *ctf_cuname;         /* Compilation unit name (if any).  */
 399   char *ctf_dyncuname;            /* Dynamically allocated name of CU.  */
 400   struct ctf_file *ctf_parent;    /* Parent CTF container (if any).  */
 401   int ctf_parent_unreffed;        /* Parent set by ctf_import_unref?  */
 402   const char *ctf_parlabel;       /* Label in parent container (if any).  */
 403   const char *ctf_parname;        /* Basename of parent (if any).  */
 404   char *ctf_dynparname;           /* Dynamically allocated name of parent.  */
 405   uint32_t ctf_parmax;            /* Highest type ID of a parent type.  */
 406   uint32_t ctf_refcnt;            /* Reference count (for parent links).  */
 407   uint32_t ctf_flags;             /* Libctf flags (see below).  */
 408   int ctf_errno;                  /* Error code for most recent error.  */
 409   int ctf_version;                /* CTF data version.  */
 410   ctf_dynhash_t *ctf_dthash;      /* Hash of dynamic type definitions.  */
 411   ctf_list_t ctf_dtdefs;          /* List of dynamic type definitions.  */
 412   ctf_dynhash_t *ctf_dvhash;      /* Hash of dynamic variable mappings.  */
 413   ctf_list_t ctf_dvdefs;          /* List of dynamic variable definitions.  */
 414   unsigned long ctf_dtoldid;      /* Oldest id that has been committed.  */
 415   unsigned long ctf_snapshots;    /* ctf_snapshot() plus ctf_update() count.  */
 416   unsigned long ctf_snapshot_lu;  /* ctf_snapshot() call count at last update.  */
 417   ctf_archive_t *ctf_archive;     /* Archive this ctf_file_t came from.  */
 418   ctf_list_t ctf_errs_warnings;   /* CTF errors and warnings.  */
 419   ctf_dynhash_t *ctf_link_inputs; /* Inputs to this link.  */
 420   ctf_dynhash_t *ctf_link_outputs; /* Additional outputs from this link.  */
 421
 422   /* Map input types to output types: populated in each output dict.
 423      Key is a ctf_link_type_key_t: value is a type ID.  Used by
 424      nondeduplicating links and ad-hoc ctf_add_type calls only.  */
 425   ctf_dynhash_t *ctf_link_type_mapping;
 426
 427   /* Map input CU names to output CTF dict names: populated in the top-level
 428      output dict.
 429
 430      Key and value are dynamically-allocated strings.  */
 431   ctf_dynhash_t *ctf_link_in_cu_mapping;
 432
 433   /* Map output CTF dict names to input CU names: populated in the top-level
 434      output dict.  A hash of string to hash (set) of strings.  Key and
 435      individual value members are shared with ctf_link_in_cu_mapping.  */
 436   ctf_dynhash_t *ctf_link_out_cu_mapping;
 437
 438   /* CTF linker flags.  */
 439   int ctf_link_flags;
 440
 441   /* Allow the caller to change the name of link archive members.  */
 442   ctf_link_memb_name_changer_f *ctf_link_memb_name_changer;
 443   void *ctf_link_memb_name_changer_arg;         /* Argument for it.  */
 444
 445   /* Allow the caller to filter out variables they don't care about.  */
 446   ctf_link_variable_filter_f *ctf_link_variable_filter;
 447   void *ctf_link_variable_filter_arg;           /* Argument for it. */
 448
 449   ctf_dynhash_t *ctf_add_processing; /* Types ctf_add_type is working on now.  */
 450
 451   /* Atoms table for dedup string storage.  All strings in the ctf_dedup_t are
 452      stored here.  Only the _alloc copy is allocated or freed: the
 453      ctf_dedup_atoms may be pointed to some other CTF dict, to share its atoms.
 454      We keep the atoms table outside the ctf_dedup so that atoms can be
 455      preserved across multiple similar links, such as when doing cu-mapped
 456      links.  */
 457   ctf_dynset_t *ctf_dedup_atoms;
 458   ctf_dynset_t *ctf_dedup_atoms_alloc;
 459
 460   ctf_dedup_t ctf_dedup;          /* Deduplicator state.  */
 461
 462   char *ctf_tmp_typeslice;        /* Storage for slicing up type names.  */
 463   size_t ctf_tmp_typeslicelen;    /* Size of the typeslice.  */
 464   void *ctf_specific;             /* Data for ctf_get/setspecific().  */
 465 };
 466
 467 /* An abstraction over both a ctf_file_t and a ctf_archive_t.  */
 468
 469 struct ctf_archive_internal
 470 {
 471   int ctfi_is_archive;
 472   int ctfi_unmap_on_close;
 473   ctf_file_t *ctfi_file;
 474   struct ctf_archive *ctfi_archive;
 475   ctf_sect_t ctfi_symsect;
 476   ctf_sect_t ctfi_strsect;
 477   int ctfi_free_symsect;
 478   int ctfi_free_strsect;
 479   void *ctfi_data;
 480   bfd *ctfi_abfd;                   /* Optional source of section data.  */
 481   void (*ctfi_bfd_close) (struct ctf_archive_internal *);
 482 };
 483
 484 /* Iterator state for the *_next() functions.  */
 485
 486 /* A single hash key/value pair.  */
 487 typedef struct ctf_next_hkv
 488 {
 489   void *hkv_key;
 490   void *hkv_value;
 491 } ctf_next_hkv_t;
 492
 493 struct ctf_next
 494 {
 495   void (*ctn_iter_fun) (void);
 496   ctf_id_t ctn_type;
 497   ssize_t ctn_size;
 498   ssize_t ctn_increment;
 499   uint32_t ctn_n;
 500   /* We can save space on this side of things by noting that a container is
 501      either dynamic or not, as a whole, and a given iterator can only iterate
 502      over one kind of thing at once: so we can overlap the DTD and non-DTD
 503      members, and the structure, variable and enum members, etc.  */
 504   union
 505   {
 506     const ctf_member_t *ctn_mp;
 507     const ctf_lmember_t *ctn_lmp;
 508     const ctf_dmdef_t *ctn_dmd;
 509     const ctf_enum_t *ctn_en;
 510     const ctf_dvdef_t *ctn_dvd;
 511     ctf_next_hkv_t *ctn_sorted_hkv;
 512     void **ctn_hash_slot;
 513   } u;
 514   /* This union is of various sorts of container we can iterate over:
 515      currently dictionaries and archives, dynhashes, and dynsets.  */
 516   union
 517   {
 518     const ctf_file_t *ctn_fp;
 519     const ctf_archive_t *ctn_arc;
 520     const ctf_dynhash_t *ctn_h;
 521     const ctf_dynset_t *ctn_s;
 522   } cu;
 523 };
 524
 525 /* Return x rounded up to an alignment boundary.
 526    eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
 527    eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align)  */
 528 #define P2ROUNDUP(x, align)             (-(-(x) & -(align)))
 529
 530 /* * If an offs is not aligned already then round it up and align it. */
 531 #define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
 532
 533 #define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
 534 #define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
 535 #define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
 536 #define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \
 537                                            (id))
 538
 539 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
 540     ((fp->ctf_flags & LCTF_RDWR) ?                                      \
 541      &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE                           \
 542                        (fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \
 543      (ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
 544
 545 #define LCTF_INFO_KIND(fp, info)        ((fp)->ctf_fileops->ctfo_get_kind(info))
 546 #define LCTF_INFO_ISROOT(fp, info)      ((fp)->ctf_fileops->ctfo_get_root(info))
 547 #define LCTF_INFO_VLEN(fp, info)        ((fp)->ctf_fileops->ctfo_get_vlen(info))
 548 #define LCTF_VBYTES(fp, kind, size, vlen) \
 549   ((fp)->ctf_fileops->ctfo_get_vbytes(kind, size, vlen))
 550
 551 #define LCTF_CHILD      0x0001  /* CTF container is a child */
 552 #define LCTF_RDWR       0x0002  /* CTF container is writable */
 553 #define LCTF_DIRTY      0x0004  /* CTF container has been modified */
 554
 555 extern ctf_names_t *ctf_name_table (ctf_file_t *, int);
 556 extern const ctf_type_t *ctf_lookup_by_id (ctf_file_t **, ctf_id_t);
 557 extern ctf_id_t ctf_lookup_by_rawname (ctf_file_t *, int, const char *);
 558 extern ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *, ctf_names_t *, const char *);
 559 extern void ctf_set_ctl_hashes (ctf_file_t *);
 560
 561 extern ctf_file_t *ctf_get_dict (ctf_file_t *fp, ctf_id_t type);
 562
 563 typedef unsigned int (*ctf_hash_fun) (const void *ptr);
 564 extern unsigned int ctf_hash_integer (const void *ptr);
 565 extern unsigned int ctf_hash_string (const void *ptr);
 566 extern unsigned int ctf_hash_type_key (const void *ptr);
 567 extern unsigned int ctf_hash_type_id_key (const void *ptr);
 568
 569 typedef int (*ctf_hash_eq_fun) (const void *, const void *);
 570 extern int ctf_hash_eq_integer (const void *, const void *);
 571 extern int ctf_hash_eq_string (const void *, const void *);
 572 extern int ctf_hash_eq_type_key (const void *, const void *);
 573 extern int ctf_hash_eq_type_id_key (const void *, const void *);
 574
 575 extern int ctf_dynset_eq_string (const void *, const void *);
 576
 577 typedef void (*ctf_hash_free_fun) (void *);
 578
 579 typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg);
 580 typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg);
 581 typedef int (*ctf_hash_iter_find_f) (void *key, void *value, void *arg);
 582 typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *,
 583                                 void *arg);
 584
 585 extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun);
 586 extern int ctf_hash_insert_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
 587 extern int ctf_hash_define_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
 588 extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_file_t *, const char *);
 589 extern uint32_t ctf_hash_size (const ctf_hash_t *);
 590 extern void ctf_hash_destroy (ctf_hash_t *);
 591
 592 extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun,
 593                                           ctf_hash_free_fun, ctf_hash_free_fun);
 594 extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *);
 595 extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *);
 596 extern size_t ctf_dynhash_elements (ctf_dynhash_t *);
 597 extern void ctf_dynhash_empty (ctf_dynhash_t *);
 598 extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *);
 599 extern int ctf_dynhash_lookup_kv (ctf_dynhash_t *, const void *key,
 600                                   const void **orig_key, void **value);
 601 extern void ctf_dynhash_destroy (ctf_dynhash_t *);
 602 extern void ctf_dynhash_iter (ctf_dynhash_t *, ctf_hash_iter_f, void *);
 603 extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f,
 604                                      void *);
 605 extern void *ctf_dynhash_iter_find (ctf_dynhash_t *, ctf_hash_iter_find_f,
 606                                     void *);
 607 extern int ctf_dynhash_next (ctf_dynhash_t *, ctf_next_t **,
 608                              void **key, void **value);
 609 extern int ctf_dynhash_next_sorted (ctf_dynhash_t *, ctf_next_t **,
 610                                     void **key, void **value, ctf_hash_sort_f,
 611                                     void *);
 612
 613 extern ctf_dynset_t *ctf_dynset_create (htab_hash, htab_eq, ctf_hash_free_fun);
 614 extern int ctf_dynset_insert (ctf_dynset_t *, void *);
 615 extern void ctf_dynset_remove (ctf_dynset_t *, const void *);
 616 extern void ctf_dynset_destroy (ctf_dynset_t *);
 617 extern void *ctf_dynset_lookup (ctf_dynset_t *, const void *);
 618 extern int ctf_dynset_exists (ctf_dynset_t *, const void *key,
 619                               const void **orig_key);
 620 extern int ctf_dynset_next (ctf_dynset_t *, ctf_next_t **, void **key);
 621 extern void *ctf_dynset_lookup_any (ctf_dynset_t *);
 622
 623 extern void ctf_sha1_init (ctf_sha1_t *);
 624 extern void ctf_sha1_add (ctf_sha1_t *, const void *, size_t);
 625 extern char *ctf_sha1_fini (ctf_sha1_t *, char *);
 626
 627 #define ctf_list_prev(elem)     ((void *)(((ctf_list_t *)(elem))->l_prev))
 628 #define ctf_list_next(elem)     ((void *)(((ctf_list_t *)(elem))->l_next))
 629
 630 extern void ctf_list_append (ctf_list_t *, void *);
 631 extern void ctf_list_prepend (ctf_list_t *, void *);
 632 extern void ctf_list_delete (ctf_list_t *, void *);
 633 extern void ctf_list_splice (ctf_list_t *, ctf_list_t *);
 634 extern int ctf_list_empty_p (ctf_list_t *lp);
 635
 636 extern int ctf_dtd_insert (ctf_file_t *, ctf_dtdef_t *, int flag, int kind);
 637 extern void ctf_dtd_delete (ctf_file_t *, ctf_dtdef_t *);
 638 extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_file_t *, ctf_id_t);
 639 extern ctf_dtdef_t *ctf_dynamic_type (const ctf_file_t *, ctf_id_t);
 640
 641 extern int ctf_dvd_insert (ctf_file_t *, ctf_dvdef_t *);
 642 extern void ctf_dvd_delete (ctf_file_t *, ctf_dvdef_t *);
 643 extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_file_t *, const char *);
 644
 645 extern ctf_id_t ctf_add_encoded (ctf_file_t *, uint32_t, const char *,
 646                                  const ctf_encoding_t *, uint32_t kind);
 647 extern ctf_id_t ctf_add_reftype (ctf_file_t *, uint32_t, ctf_id_t,
 648                                  uint32_t kind);
 649
 650 extern void ctf_add_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
 651                                   ctf_file_t *dst_fp, ctf_id_t dst_type);
 652 extern ctf_id_t ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
 653                                   ctf_file_t **dst_fp);
 654
 655 extern int ctf_dedup_atoms_init (ctf_file_t *);
 656 extern int ctf_dedup (ctf_file_t *, ctf_file_t **, uint32_t ninputs,
 657                       uint32_t *parents, int cu_mapped);
 658 extern void ctf_dedup_fini (ctf_file_t *, ctf_file_t **, uint32_t);
 659 extern ctf_file_t **ctf_dedup_emit (ctf_file_t *, ctf_file_t **,
 660                                     uint32_t ninputs, uint32_t *parents,
 661                                     uint32_t *noutputs, int cu_mapped);
 662
 663 extern void ctf_decl_init (ctf_decl_t *);
 664 extern void ctf_decl_fini (ctf_decl_t *);
 665 extern void ctf_decl_push (ctf_decl_t *, ctf_file_t *, ctf_id_t);
 666
 667 _libctf_printflike_ (2, 3)
 668 extern void ctf_decl_sprintf (ctf_decl_t *, const char *, ...);
 669 extern char *ctf_decl_buf (ctf_decl_t *cd);
 670
 671 extern const char *ctf_strptr (ctf_file_t *, uint32_t);
 672 extern const char *ctf_strraw (ctf_file_t *, uint32_t);
 673 extern const char *ctf_strraw_explicit (ctf_file_t *, uint32_t,
 674                                         ctf_strs_t *);
 675 extern int ctf_str_create_atoms (ctf_file_t *);
 676 extern void ctf_str_free_atoms (ctf_file_t *);
 677 extern uint32_t ctf_str_add (ctf_file_t *, const char *);
 678 extern uint32_t ctf_str_add_ref (ctf_file_t *, const char *, uint32_t *ref);
 679 extern int ctf_str_add_external (ctf_file_t *, const char *, uint32_t offset);
 680 extern void ctf_str_remove_ref (ctf_file_t *, const char *, uint32_t *ref);
 681 extern void ctf_str_rollback (ctf_file_t *, ctf_snapshot_id_t);
 682 extern void ctf_str_purge_refs (ctf_file_t *);
 683 extern ctf_strs_writable_t ctf_str_write_strtab (ctf_file_t *);
 684
 685 extern struct ctf_archive_internal *
 686 ctf_new_archive_internal (int is_archive, int unmap_on_close,
 687                           struct ctf_archive *, ctf_file_t *,
 688                           const ctf_sect_t *symsect,
 689                           const ctf_sect_t *strsect, int *errp);
 690 extern struct ctf_archive *ctf_arc_open_internal (const char *, int *);
 691 extern void ctf_arc_close_internal (struct ctf_archive *);
 692 extern void *ctf_set_open_errno (int *, int);
 693 extern unsigned long ctf_set_errno (ctf_file_t *, int);
 694
 695 extern ctf_file_t *ctf_simple_open_internal (const char *, size_t, const char *,
 696                                              size_t, size_t,
 697                                              const char *, size_t,
 698                                              ctf_dynhash_t *, int, int *);
 699 extern ctf_file_t *ctf_bufopen_internal (const ctf_sect_t *, const ctf_sect_t *,
 700                                          const ctf_sect_t *, ctf_dynhash_t *,
 701                                          int, int *);
 702 extern int ctf_import_unref (ctf_file_t *fp, ctf_file_t *pfp);
 703 extern int ctf_serialize (ctf_file_t *);
 704
 705 _libctf_malloc_
 706 extern void *ctf_mmap (size_t length, size_t offset, int fd);
 707 extern void ctf_munmap (void *, size_t);
 708 extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
 709
 710 extern void *ctf_realloc (ctf_file_t *, void *, size_t);
 711 extern char *ctf_str_append (char *, const char *);
 712 extern char *ctf_str_append_noerr (char *, const char *);
 713
 714 extern ctf_id_t ctf_type_resolve_unsliced (ctf_file_t *, ctf_id_t);
 715 extern int ctf_type_kind_unsliced (ctf_file_t *, ctf_id_t);
 716
 717 _libctf_printflike_ (1, 2)
 718 extern void ctf_dprintf (const char *, ...);
 719 extern void libctf_init_debug (void);
 720
 721 _libctf_printflike_ (3, 4)
 722 extern void ctf_err_warn (ctf_file_t *, int is_warning, const char *, ...);
 723 extern void ctf_assert_fail_internal (ctf_file_t *, const char *,
 724                                       size_t, const char *);
 725 extern const char *ctf_link_input_name (ctf_file_t *);
 726
 727 extern Elf64_Sym *ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst);
 728 extern const char *ctf_lookup_symbol_name (ctf_file_t *fp, unsigned long symidx);
 729
 730 /* Variables, all underscore-prepended. */
 731
 732 extern const char _CTF_SECTION[];       /* name of CTF ELF section */
 733 extern const char _CTF_NULLSTR[];       /* empty string */
 734
 735 extern int _libctf_version;     /* library client version */
 736 extern int _libctf_debug;       /* debugging messages enabled */
 737
 738 #include "ctf-inlines.h"
 739
 740 #ifdef  __cplusplus
 741 }
 742 #endif
 743
 744 #endif /* _CTF_IMPL_H */