libctf/ctf-impl.h

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