libctf/ctf-impl.h

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