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