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