libctf/ctf-impl.h

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