libctf/ctf-impl.h

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