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