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