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