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 #define ctf_assert(fp, expr)                                            \
  75   _libctf_unlikely_ (ctf_assert_internal (fp, __FILE__, __LINE__,       \
  76                                           #expr, !!(expr)))
  77
  78 /* libctf in-memory state.  */
  79
  80 typedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c.  */
  81 typedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c.  */
  82 typedef struct ctf_dynset ctf_dynset_t;   /* Private to ctf-hash.c.  */
  83
  84 typedef struct ctf_strs
  85 {
  86   const char *cts_strs;         /* Base address of string table.  */
  87   size_t cts_len;               /* Size of string table in bytes.  */
  88 } ctf_strs_t;
  89
  90 typedef struct ctf_strs_writable
  91 {
  92   char *cts_strs;               /* Base address of string table.  */
  93   size_t cts_len;               /* Size of string table in bytes.  */
  94 } ctf_strs_writable_t;
  95
  96 typedef struct ctf_dmodel
  97 {
  98   const char *ctd_name;         /* Data model name.  */
  99   int ctd_code;                 /* Data model code.  */
 100   size_t ctd_pointer;           /* Size of void * in bytes.  */
 101   size_t ctd_char;              /* Size of char in bytes.  */
 102   size_t ctd_short;             /* Size of short in bytes.  */
 103   size_t ctd_int;               /* Size of int in bytes.  */
 104   size_t ctd_long;              /* Size of long in bytes.  */
 105 } ctf_dmodel_t;
 106
 107 typedef struct ctf_names
 108 {
 109   ctf_hash_t *ctn_readonly;     /* Hash table when readonly.  */
 110   ctf_dynhash_t *ctn_writable;  /* Hash table when writable.  */
 111 } ctf_names_t;
 112
 113 typedef struct ctf_lookup
 114 {
 115   const char *ctl_prefix;       /* String prefix for this lookup.  */
 116   size_t ctl_len;               /* Length of prefix string in bytes.  */
 117   ctf_names_t *ctl_hash;        /* Pointer to hash table for lookup.  */
 118 } ctf_lookup_t;
 119
 120 typedef struct ctf_fileops
 121 {
 122   uint32_t (*ctfo_get_kind) (uint32_t);
 123   uint32_t (*ctfo_get_root) (uint32_t);
 124   uint32_t (*ctfo_get_vlen) (uint32_t);
 125   ssize_t (*ctfo_get_ctt_size) (const ctf_file_t *, const ctf_type_t *,
 126                                 ssize_t *, ssize_t *);
 127   ssize_t (*ctfo_get_vbytes) (unsigned short, ssize_t, size_t);
 128 } ctf_fileops_t;
 129
 130 typedef struct ctf_list
 131 {
 132   struct ctf_list *l_prev;      /* Previous pointer or tail pointer.  */
 133   struct ctf_list *l_next;      /* Next pointer or head pointer.  */
 134 } ctf_list_t;
 135
 136 typedef enum
 137   {
 138    CTF_PREC_BASE,
 139    CTF_PREC_POINTER,
 140    CTF_PREC_ARRAY,
 141    CTF_PREC_FUNCTION,
 142    CTF_PREC_MAX
 143   } ctf_decl_prec_t;
 144
 145 typedef struct ctf_decl_node
 146 {
 147   ctf_list_t cd_list;           /* Linked list pointers.  */
 148   ctf_id_t cd_type;             /* Type identifier.  */
 149   uint32_t cd_kind;             /* Type kind.  */
 150   uint32_t cd_n;                /* Type dimension if array.  */
 151 } ctf_decl_node_t;
 152
 153 typedef struct ctf_decl
 154 {
 155   ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks.  */
 156   int cd_order[CTF_PREC_MAX];        /* Storage order of decls.  */
 157   ctf_decl_prec_t cd_qualp;          /* Qualifier precision.  */
 158   ctf_decl_prec_t cd_ordp;           /* Ordered precision.  */
 159   char *cd_buf;                      /* Buffer for output.  */
 160   int cd_err;                        /* Saved error value.  */
 161   int cd_enomem;                     /* Nonzero if OOM during printing.  */
 162 } ctf_decl_t;
 163
 164 typedef struct ctf_dmdef
 165 {
 166   ctf_list_t dmd_list;          /* List forward/back pointers.  */
 167   char *dmd_name;               /* Name of this member.  */
 168   ctf_id_t dmd_type;            /* Type of this member (for sou).  */
 169   unsigned long dmd_offset;     /* Offset of this member in bits (for sou).  */
 170   int dmd_value;                /* Value of this member (for enum).  */
 171 } ctf_dmdef_t;
 172
 173 typedef struct ctf_dtdef
 174 {
 175   ctf_list_t dtd_list;          /* List forward/back pointers.  */
 176   ctf_id_t dtd_type;            /* Type identifier for this definition.  */
 177   ctf_type_t dtd_data;          /* Type node, including name.  */
 178   union
 179   {
 180     ctf_list_t dtu_members;     /* struct, union, or enum */
 181     ctf_arinfo_t dtu_arr;       /* array */
 182     ctf_encoding_t dtu_enc;     /* integer or float */
 183     uint32_t *dtu_argv;         /* function */
 184     ctf_slice_t dtu_slice;      /* slice */
 185   } dtd_u;
 186 } ctf_dtdef_t;
 187
 188 typedef struct ctf_dvdef
 189 {
 190   ctf_list_t dvd_list;          /* List forward/back pointers.  */
 191   char *dvd_name;               /* Name associated with variable.  */
 192   ctf_id_t dvd_type;            /* Type of variable.  */
 193   unsigned long dvd_snapshots;  /* Snapshot count when inserted.  */
 194 } ctf_dvdef_t;
 195
 196 typedef struct ctf_bundle
 197 {
 198   ctf_file_t *ctb_file;         /* CTF container handle.  */
 199   ctf_id_t ctb_type;            /* CTF type identifier.  */
 200   ctf_dtdef_t *ctb_dtd;         /* CTF dynamic type definition (if any).  */
 201 } ctf_bundle_t;
 202
 203 typedef struct ctf_err_warning
 204 {
 205   ctf_list_t cew_list;          /* List forward/back pointers.  */
 206   int cew_is_warning;           /* 1 if warning, 0 if error.  */
 207   char *cew_text;               /* Error/warning text.  */
 208 } ctf_err_warning_t;
 209
 210 /* Atoms associate strings with a list of the CTF items that reference that
 211    string, so that ctf_update() can instantiate all the strings using the
 212    ctf_str_atoms and then reassociate them with the real string later.
 213
 214    Strings can be interned into ctf_str_atom without having refs associated
 215    with them, for values that are returned to callers, etc.  Items are only
 216    removed from this table on ctf_close(), but on every ctf_update(), all the
 217    csa_refs in all entries are purged.  */
 218
 219 typedef struct ctf_str_atom
 220 {
 221   const char *csa_str;          /* Backpointer to string (hash key).  */
 222   ctf_list_t csa_refs;          /* This string's refs.  */
 223   uint32_t csa_offset;          /* Strtab offset, if any.  */
 224   uint32_t csa_external_offset; /* External strtab offset, if any.  */
 225   unsigned long csa_snapshot_id; /* Snapshot ID at time of creation.  */
 226 } ctf_str_atom_t;
 227
 228 /* The refs of a single string in the atoms table.  */
 229
 230 typedef struct ctf_str_atom_ref
 231 {
 232   ctf_list_t caf_list;          /* List forward/back pointers.  */
 233   uint32_t *caf_ref;            /* A single ref to this string.  */
 234 } ctf_str_atom_ref_t;
 235
 236 /* The structure used as the key in a ctf_link_type_mapping.  The value is a
 237    type index, not a type ID.  */
 238
 239 typedef struct ctf_link_type_key
 240 {
 241   ctf_file_t *cltk_fp;
 242   ctf_id_t cltk_idx;
 243 } ctf_link_type_key_t;
 244
 245
 246 /* The ctf_file is the structure used to represent a CTF container to library
 247    clients, who see it only as an opaque pointer.  Modifications can therefore
 248    be made freely to this structure without regard to client versioning.  The
 249    ctf_file_t typedef appears in <ctf-api.h> and declares a forward tag.
 250
 251    NOTE: ctf_update() requires that everything inside of ctf_file either be an
 252    immediate value, a pointer to dynamically allocated data *outside* of the
 253    ctf_file itself, or a pointer to statically allocated data.  If you add a
 254    pointer to ctf_file that points to something within the ctf_file itself,
 255    you must make corresponding changes to ctf_update().  */
 256
 257 struct ctf_file
 258 {
 259   const ctf_fileops_t *ctf_fileops; /* Version-specific file operations.  */
 260   struct ctf_header *ctf_header;    /* The header from this CTF file.  */
 261   unsigned char ctf_openflags;      /* Flags the file had when opened.  */
 262   ctf_sect_t ctf_data;              /* CTF data from object file.  */
 263   ctf_sect_t ctf_symtab;            /* Symbol table from object file.  */
 264   ctf_sect_t ctf_strtab;            /* String table from object file.  */
 265   ctf_dynhash_t *ctf_prov_strtab;   /* Maps provisional-strtab offsets
 266                                        to names.  */
 267   ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names.  */
 268   void *ctf_data_mmapped;           /* CTF data we mmapped, to free later.  */
 269   size_t ctf_data_mmapped_len;      /* Length of CTF data we mmapped.  */
 270   ctf_names_t ctf_structs;          /* Hash table of struct types.  */
 271   ctf_names_t ctf_unions;           /* Hash table of union types.  */
 272   ctf_names_t ctf_enums;            /* Hash table of enum types.  */
 273   ctf_names_t ctf_names;            /* Hash table of remaining type names.  */
 274   ctf_lookup_t ctf_lookups[5];      /* Pointers to nametabs for name lookup.  */
 275   ctf_strs_t ctf_str[2];            /* Array of string table base and bounds.  */
 276   ctf_dynhash_t *ctf_str_atoms;   /* Hash table of ctf_str_atoms_t.  */
 277   uint64_t ctf_str_num_refs;      /* Number of refs to cts_str_atoms.  */
 278   uint32_t ctf_str_prov_offset;   /* Latest provisional offset assigned so far.  */
 279   unsigned char *ctf_base;        /* CTF file pointer.  */
 280   unsigned char *ctf_dynbase;     /* Freeable CTF file pointer. */
 281   unsigned char *ctf_buf;         /* Uncompressed CTF data buffer.  */
 282   size_t ctf_size;                /* Size of CTF header + uncompressed data.  */
 283   uint32_t *ctf_sxlate;           /* Translation table for symtab entries.  */
 284   unsigned long ctf_nsyms;        /* Number of entries in symtab xlate table.  */
 285   uint32_t *ctf_txlate;           /* Translation table for type IDs.  */
 286   uint32_t *ctf_ptrtab;           /* Translation table for pointer-to lookups.  */
 287   size_t ctf_ptrtab_len;          /* Num types storable in ptrtab currently.  */
 288   struct ctf_varent *ctf_vars;    /* Sorted variable->type mapping.  */
 289   unsigned long ctf_nvars;        /* Number of variables in ctf_vars.  */
 290   unsigned long ctf_typemax;      /* Maximum valid type ID number.  */
 291   const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above).  */
 292   const char *ctf_cuname;         /* Compilation unit name (if any).  */
 293   char *ctf_dyncuname;            /* Dynamically allocated name of CU.  */
 294   struct ctf_file *ctf_parent;    /* Parent CTF container (if any).  */
 295   int ctf_parent_unreffed;        /* Parent set by ctf_import_unref?  */
 296   const char *ctf_parlabel;       /* Label in parent container (if any).  */
 297   const char *ctf_parname;        /* Basename of parent (if any).  */
 298   char *ctf_dynparname;           /* Dynamically allocated name of parent.  */
 299   uint32_t ctf_parmax;            /* Highest type ID of a parent type.  */
 300   uint32_t ctf_refcnt;            /* Reference count (for parent links).  */
 301   uint32_t ctf_flags;             /* Libctf flags (see below).  */
 302   int ctf_errno;                  /* Error code for most recent error.  */
 303   int ctf_version;                /* CTF data version.  */
 304   ctf_dynhash_t *ctf_dthash;      /* Hash of dynamic type definitions.  */
 305   ctf_list_t ctf_dtdefs;          /* List of dynamic type definitions.  */
 306   ctf_dynhash_t *ctf_dvhash;      /* Hash of dynamic variable mappings.  */
 307   ctf_list_t ctf_dvdefs;          /* List of dynamic variable definitions.  */
 308   unsigned long ctf_dtoldid;      /* Oldest id that has been committed.  */
 309   unsigned long ctf_snapshots;    /* ctf_snapshot() plus ctf_update() count.  */
 310   unsigned long ctf_snapshot_lu;  /* ctf_snapshot() call count at last update.  */
 311   ctf_archive_t *ctf_archive;     /* Archive this ctf_file_t came from.  */
 312   ctf_list_t ctf_errs_warnings;   /* CTF errors and warnings.  */
 313   ctf_dynhash_t *ctf_link_inputs; /* Inputs to this link.  */
 314   ctf_dynhash_t *ctf_link_outputs; /* Additional outputs from this link.  */
 315
 316   /* Map input types to output types: populated in each output dict.
 317      Key is a ctf_link_type_key_t: value is a type ID.  Used by
 318      nondeduplicating links and ad-hoc ctf_add_type calls only.  */
 319   ctf_dynhash_t *ctf_link_type_mapping;
 320
 321   /* Map input CU names to output CTF dict names: populated in the top-level
 322      output dict.
 323
 324      Key and value are dynamically-allocated strings.  */
 325   ctf_dynhash_t *ctf_link_in_cu_mapping;
 326
 327   /* Map output CTF dict names to input CU names: populated in the top-level
 328      output dict.  A hash of string to hash (set) of strings.  Key and
 329      individual value members are shared with ctf_link_in_cu_mapping.  */
 330   ctf_dynhash_t *ctf_link_out_cu_mapping;
 331
 332   /* CTF linker flags.  */
 333   int ctf_link_flags;
 334
 335   /* Allow the caller to change the name of link archive members.  */
 336   ctf_link_memb_name_changer_f *ctf_link_memb_name_changer;
 337   void *ctf_link_memb_name_changer_arg;         /* Argument for it.  */
 338
 339   /* Allow the caller to filter out variables they don't care about.  */
 340   ctf_link_variable_filter_f *ctf_link_variable_filter;
 341   void *ctf_link_variable_filter_arg;           /* Argument for it. */
 342
 343   ctf_dynhash_t *ctf_add_processing; /* Types ctf_add_type is working on now.  */
 344   char *ctf_tmp_typeslice;        /* Storage for slicing up type names.  */
 345   size_t ctf_tmp_typeslicelen;    /* Size of the typeslice.  */
 346   void *ctf_specific;             /* Data for ctf_get/setspecific().  */
 347 };
 348
 349 /* An abstraction over both a ctf_file_t and a ctf_archive_t.  */
 350
 351 struct ctf_archive_internal
 352 {
 353   int ctfi_is_archive;
 354   int ctfi_unmap_on_close;
 355   ctf_file_t *ctfi_file;
 356   struct ctf_archive *ctfi_archive;
 357   ctf_sect_t ctfi_symsect;
 358   ctf_sect_t ctfi_strsect;
 359   int ctfi_free_symsect;
 360   int ctfi_free_strsect;
 361   void *ctfi_data;
 362   bfd *ctfi_abfd;                   /* Optional source of section data.  */
 363   void (*ctfi_bfd_close) (struct ctf_archive_internal *);
 364 };
 365
 366 /* Iterator state for the *_next() functions.  */
 367
 368 /* A single hash key/value pair.  */
 369 typedef struct ctf_next_hkv
 370 {
 371   void *hkv_key;
 372   void *hkv_value;
 373 } ctf_next_hkv_t;
 374
 375 struct ctf_next
 376 {
 377   void (*ctn_iter_fun) (void);
 378   ctf_id_t ctn_type;
 379   ssize_t ctn_size;
 380   ssize_t ctn_increment;
 381   uint32_t ctn_n;
 382   /* We can save space on this side of things by noting that a container is
 383      either dynamic or not, as a whole, and a given iterator can only iterate
 384      over one kind of thing at once: so we can overlap the DTD and non-DTD
 385      members, and the structure, variable and enum members, etc.  */
 386   union
 387   {
 388     const ctf_member_t *ctn_mp;
 389     const ctf_lmember_t *ctn_lmp;
 390     const ctf_dmdef_t *ctn_dmd;
 391     const ctf_enum_t *ctn_en;
 392     const ctf_dvdef_t *ctn_dvd;
 393     ctf_next_hkv_t *ctn_sorted_hkv;
 394     void **ctn_hash_slot;
 395   } u;
 396   /* This union is of various sorts of container we can iterate over:
 397      currently dictionaries and archives, dynhashes, and dynsets.  */
 398   union
 399   {
 400     const ctf_file_t *ctn_fp;
 401     const ctf_archive_t *ctn_arc;
 402     const ctf_dynhash_t *ctn_h;
 403     const ctf_dynset_t *ctn_s;
 404   } cu;
 405 };
 406
 407 /* Return x rounded up to an alignment boundary.
 408    eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
 409    eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align)  */
 410 #define P2ROUNDUP(x, align)             (-(-(x) & -(align)))
 411
 412 /* * If an offs is not aligned already then round it up and align it. */
 413 #define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
 414
 415 #define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
 416 #define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
 417 #define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
 418 #define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \
 419                                            (id))
 420
 421 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
 422     ((fp->ctf_flags & LCTF_RDWR) ?                                      \
 423      &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE                           \
 424                        (fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \
 425      (ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
 426
 427 #define LCTF_INFO_KIND(fp, info)        ((fp)->ctf_fileops->ctfo_get_kind(info))
 428 #define LCTF_INFO_ISROOT(fp, info)      ((fp)->ctf_fileops->ctfo_get_root(info))
 429 #define LCTF_INFO_VLEN(fp, info)        ((fp)->ctf_fileops->ctfo_get_vlen(info))
 430 #define LCTF_VBYTES(fp, kind, size, vlen) \
 431   ((fp)->ctf_fileops->ctfo_get_vbytes(kind, size, vlen))
 432
 433 #define LCTF_CHILD      0x0001  /* CTF container is a child */
 434 #define LCTF_RDWR       0x0002  /* CTF container is writable */
 435 #define LCTF_DIRTY      0x0004  /* CTF container has been modified */
 436
 437 extern ctf_names_t *ctf_name_table (ctf_file_t *, int);
 438 extern const ctf_type_t *ctf_lookup_by_id (ctf_file_t **, ctf_id_t);
 439 extern ctf_id_t ctf_lookup_by_rawname (ctf_file_t *, int, const char *);
 440 extern ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *, ctf_names_t *, const char *);
 441 extern void ctf_set_ctl_hashes (ctf_file_t *);
 442
 443 extern ctf_file_t *ctf_get_dict (ctf_file_t *fp, ctf_id_t type);
 444
 445 typedef unsigned int (*ctf_hash_fun) (const void *ptr);
 446 extern unsigned int ctf_hash_integer (const void *ptr);
 447 extern unsigned int ctf_hash_string (const void *ptr);
 448 extern unsigned int ctf_hash_type_key (const void *ptr);
 449
 450 typedef int (*ctf_hash_eq_fun) (const void *, const void *);
 451 extern int ctf_hash_eq_integer (const void *, const void *);
 452 extern int ctf_hash_eq_string (const void *, const void *);
 453 extern int ctf_hash_eq_type_key (const void *, const void *);
 454
 455 extern int ctf_dynset_eq_string (const void *, const void *);
 456
 457 typedef void (*ctf_hash_free_fun) (void *);
 458
 459 typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg);
 460 typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg);
 461 typedef int (*ctf_hash_iter_find_f) (void *key, void *value, void *arg);
 462 typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *,
 463                                 void *arg);
 464
 465 extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun);
 466 extern int ctf_hash_insert_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
 467 extern int ctf_hash_define_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
 468 extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_file_t *, const char *);
 469 extern uint32_t ctf_hash_size (const ctf_hash_t *);
 470 extern void ctf_hash_destroy (ctf_hash_t *);
 471
 472 extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun,
 473                                           ctf_hash_free_fun, ctf_hash_free_fun);
 474 extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *);
 475 extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *);
 476 extern size_t ctf_dynhash_elements (ctf_dynhash_t *);
 477 extern void ctf_dynhash_empty (ctf_dynhash_t *);
 478 extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *);
 479 extern int ctf_dynhash_lookup_kv (ctf_dynhash_t *, const void *key,
 480                                   const void **orig_key, void **value);
 481 extern void ctf_dynhash_destroy (ctf_dynhash_t *);
 482 extern void ctf_dynhash_iter (ctf_dynhash_t *, ctf_hash_iter_f, void *);
 483 extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f,
 484                                      void *);
 485 extern void *ctf_dynhash_iter_find (ctf_dynhash_t *, ctf_hash_iter_find_f,
 486                                     void *);
 487 extern int ctf_dynhash_next (ctf_dynhash_t *, ctf_next_t **,
 488                              void **key, void **value);
 489 extern int ctf_dynhash_next_sorted (ctf_dynhash_t *, ctf_next_t **,
 490                                     void **key, void **value, ctf_hash_sort_f,
 491                                     void *);
 492
 493 extern ctf_dynset_t *ctf_dynset_create (htab_hash, htab_eq, ctf_hash_free_fun);
 494 extern int ctf_dynset_insert (ctf_dynset_t *, void *);
 495 extern void ctf_dynset_remove (ctf_dynset_t *, const void *);
 496 extern void ctf_dynset_destroy (ctf_dynset_t *);
 497 extern void *ctf_dynset_lookup (ctf_dynset_t *, const void *);
 498 extern int ctf_dynset_exists (ctf_dynset_t *, const void *key,
 499                               const void **orig_key);
 500 extern int ctf_dynset_next (ctf_dynset_t *, ctf_next_t **, void **key);
 501 extern void *ctf_dynset_lookup_any (ctf_dynset_t *);
 502
 503 extern void ctf_sha1_init (ctf_sha1_t *);
 504 extern void ctf_sha1_add (ctf_sha1_t *, const void *, size_t);
 505 extern char *ctf_sha1_fini (ctf_sha1_t *, char *);
 506
 507 #define ctf_list_prev(elem)     ((void *)(((ctf_list_t *)(elem))->l_prev))
 508 #define ctf_list_next(elem)     ((void *)(((ctf_list_t *)(elem))->l_next))
 509
 510 extern void ctf_list_append (ctf_list_t *, void *);
 511 extern void ctf_list_prepend (ctf_list_t *, void *);
 512 extern void ctf_list_delete (ctf_list_t *, void *);
 513 extern int ctf_list_empty_p (ctf_list_t *lp);
 514
 515 extern int ctf_dtd_insert (ctf_file_t *, ctf_dtdef_t *, int flag, int kind);
 516 extern void ctf_dtd_delete (ctf_file_t *, ctf_dtdef_t *);
 517 extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_file_t *, ctf_id_t);
 518 extern ctf_dtdef_t *ctf_dynamic_type (const ctf_file_t *, ctf_id_t);
 519
 520 extern int ctf_dvd_insert (ctf_file_t *, ctf_dvdef_t *);
 521 extern void ctf_dvd_delete (ctf_file_t *, ctf_dvdef_t *);
 522 extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_file_t *, const char *);
 523
 524 extern void ctf_add_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
 525                                   ctf_file_t *dst_fp, ctf_id_t dst_type);
 526 extern ctf_id_t ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
 527                                   ctf_file_t **dst_fp);
 528
 529 extern void ctf_decl_init (ctf_decl_t *);
 530 extern void ctf_decl_fini (ctf_decl_t *);
 531 extern void ctf_decl_push (ctf_decl_t *, ctf_file_t *, ctf_id_t);
 532
 533 _libctf_printflike_ (2, 3)
 534 extern void ctf_decl_sprintf (ctf_decl_t *, const char *, ...);
 535 extern char *ctf_decl_buf (ctf_decl_t *cd);
 536
 537 extern const char *ctf_strptr (ctf_file_t *, uint32_t);
 538 extern const char *ctf_strraw (ctf_file_t *, uint32_t);
 539 extern const char *ctf_strraw_explicit (ctf_file_t *, uint32_t,
 540                                         ctf_strs_t *);
 541 extern int ctf_str_create_atoms (ctf_file_t *);
 542 extern void ctf_str_free_atoms (ctf_file_t *);
 543 extern uint32_t ctf_str_add (ctf_file_t *, const char *);
 544 extern uint32_t ctf_str_add_ref (ctf_file_t *, const char *, uint32_t *ref);
 545 extern int ctf_str_add_external (ctf_file_t *, const char *, uint32_t offset);
 546 extern void ctf_str_remove_ref (ctf_file_t *, const char *, uint32_t *ref);
 547 extern void ctf_str_rollback (ctf_file_t *, ctf_snapshot_id_t);
 548 extern void ctf_str_purge_refs (ctf_file_t *);
 549 extern ctf_strs_writable_t ctf_str_write_strtab (ctf_file_t *);
 550
 551 extern struct ctf_archive_internal *
 552 ctf_new_archive_internal (int is_archive, int unmap_on_close,
 553                           struct ctf_archive *, ctf_file_t *,
 554                           const ctf_sect_t *symsect,
 555                           const ctf_sect_t *strsect, int *errp);
 556 extern struct ctf_archive *ctf_arc_open_internal (const char *, int *);
 557 extern void ctf_arc_close_internal (struct ctf_archive *);
 558 extern void *ctf_set_open_errno (int *, int);
 559 extern unsigned long ctf_set_errno (ctf_file_t *, int);
 560
 561 extern ctf_file_t *ctf_simple_open_internal (const char *, size_t, const char *,
 562                                              size_t, size_t,
 563                                              const char *, size_t,
 564                                              ctf_dynhash_t *, int, int *);
 565 extern ctf_file_t *ctf_bufopen_internal (const ctf_sect_t *, const ctf_sect_t *,
 566                                          const ctf_sect_t *, ctf_dynhash_t *,
 567                                          int, int *);
 568 extern int ctf_import_unref (ctf_file_t *fp, ctf_file_t *pfp);
 569 extern int ctf_serialize (ctf_file_t *);
 570
 571 _libctf_malloc_
 572 extern void *ctf_mmap (size_t length, size_t offset, int fd);
 573 extern void ctf_munmap (void *, size_t);
 574 extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
 575
 576 extern void *ctf_realloc (ctf_file_t *, void *, size_t);
 577 extern char *ctf_str_append (char *, const char *);
 578 extern char *ctf_str_append_noerr (char *, const char *);
 579
 580 extern ctf_id_t ctf_type_resolve_unsliced (ctf_file_t *, ctf_id_t);
 581 extern int ctf_type_kind_unsliced (ctf_file_t *, ctf_id_t);
 582
 583 _libctf_printflike_ (1, 2)
 584 extern void ctf_dprintf (const char *, ...);
 585 extern void libctf_init_debug (void);
 586
 587 _libctf_printflike_ (3, 4)
 588 extern void ctf_err_warn (ctf_file_t *, int is_warning, const char *, ...);
 589 extern void ctf_assert_fail_internal (ctf_file_t *, const char *,
 590                                       size_t, const char *);
 591 extern const char *ctf_link_input_name (ctf_file_t *);
 592
 593 extern Elf64_Sym *ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst);
 594 extern const char *ctf_lookup_symbol_name (ctf_file_t *fp, unsigned long symidx);
 595
 596 /* Variables, all underscore-prepended. */
 597
 598 extern const char _CTF_SECTION[];       /* name of CTF ELF section */
 599 extern const char _CTF_NULLSTR[];       /* empty string */
 600
 601 extern int _libctf_version;     /* library client version */
 602 extern int _libctf_debug;       /* debugging messages enabled */
 603
 604 #include "ctf-inlines.h"
 605
 606 #ifdef  __cplusplus
 607 }
 608 #endif
 609
 610 #endif /* _CTF_IMPL_H */