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