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 <sys/errno.h>
  25 #include <ctf-api.h>
  26 #include <sys/types.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <stdint.h>
  31 #include <limits.h>
  32 #include <ctype.h>
  33 #include <elf.h>
  34
  35 #ifdef  __cplusplus
  36 extern "C"
  37   {
  38 #endif
  39
  40 /* Compiler attributes.  */
  41
  42 #if defined (__GNUC__)
  43
  44 /* GCC.  We assume that all compilers claiming to be GCC support sufficiently
  45    many GCC attributes that the code below works.  If some non-GCC compilers
  46    masquerading as GCC in fact do not implement these attributes, version checks
  47    may be required.  */
  48
  49 /* We use the _libctf_*_ pattern to avoid clashes with any future attribute
  50    macros glibc may introduce, which have names of the pattern
  51    __attribute_blah__.  */
  52
  53 #define _libctf_printflike_(string_index,first_to_check) \
  54     __attribute__ ((__format__ (__printf__, (string_index), (first_to_check))))
  55 #define _libctf_unlikely_(x) __builtin_expect ((x), 0)
  56 #define _libctf_unused_ __attribute__ ((__unused__))
  57 #define _libctf_malloc_ __attribute__((__malloc__))
  58
  59 #endif
  60
  61 /* libctf in-memory state.  */
  62
  63 typedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c.  */
  64 typedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c.  */
  65
  66 typedef struct ctf_strs
  67 {
  68   const char *cts_strs;         /* Base address of string table.  */
  69   size_t cts_len;               /* Size of string table in bytes.  */
  70 } ctf_strs_t;
  71
  72 typedef struct ctf_dmodel
  73 {
  74   const char *ctd_name;         /* Data model name.  */
  75   int ctd_code;                 /* Data model code.  */
  76   size_t ctd_pointer;           /* Size of void * in bytes.  */
  77   size_t ctd_char;              /* Size of char in bytes.  */
  78   size_t ctd_short;             /* Size of short in bytes.  */
  79   size_t ctd_int;               /* Size of int in bytes.  */
  80   size_t ctd_long;              /* Size of long in bytes.  */
  81 } ctf_dmodel_t;
  82
  83 typedef struct ctf_lookup
  84 {
  85   const char *ctl_prefix;       /* String prefix for this lookup.  */
  86   size_t ctl_len;               /* Length of prefix string in bytes.  */
  87   ctf_hash_t *ctl_hash;         /* Pointer to hash table for lookup.  */
  88 } ctf_lookup_t;
  89
  90 typedef struct ctf_fileops
  91 {
  92   uint32_t (*ctfo_get_kind) (uint32_t);
  93   uint32_t (*ctfo_get_root) (uint32_t);
  94   uint32_t (*ctfo_get_vlen) (uint32_t);
  95   ssize_t (*ctfo_get_ctt_size) (const ctf_file_t *, const ctf_type_t *,
  96                                 ssize_t *, ssize_t *);
  97   ssize_t (*ctfo_get_vbytes) (unsigned short, ssize_t, size_t);
  98 } ctf_fileops_t;
  99
 100 typedef struct ctf_list
 101 {
 102   struct ctf_list *l_prev;      /* Previous pointer or tail pointer.  */
 103   struct ctf_list *l_next;      /* Next pointer or head pointer.  */
 104 } ctf_list_t;
 105
 106 typedef enum
 107   {
 108    CTF_PREC_BASE,
 109    CTF_PREC_POINTER,
 110    CTF_PREC_ARRAY,
 111    CTF_PREC_FUNCTION,
 112    CTF_PREC_MAX
 113   } ctf_decl_prec_t;
 114
 115 typedef struct ctf_decl_node
 116 {
 117   ctf_list_t cd_list;           /* Linked list pointers.  */
 118   ctf_id_t cd_type;             /* Type identifier.  */
 119   uint32_t cd_kind;             /* Type kind.  */
 120   uint32_t cd_n;                /* Type dimension if array.  */
 121 } ctf_decl_node_t;
 122
 123 typedef struct ctf_decl
 124 {
 125   ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks.  */
 126   int cd_order[CTF_PREC_MAX];        /* Storage order of decls.  */
 127   ctf_decl_prec_t cd_qualp;          /* Qualifier precision.  */
 128   ctf_decl_prec_t cd_ordp;           /* Ordered precision.  */
 129   char *cd_buf;                      /* Buffer for output.  */
 130   int cd_err;                        /* Saved error value.  */
 131   int cd_enomem;                     /* Nonzero if OOM during printing.  */
 132 } ctf_decl_t;
 133
 134 typedef struct ctf_dmdef
 135 {
 136   ctf_list_t dmd_list;          /* List forward/back pointers.  */
 137   char *dmd_name;               /* Name of this member.  */
 138   ctf_id_t dmd_type;            /* Type of this member (for sou).  */
 139   unsigned long dmd_offset;     /* Offset of this member in bits (for sou).  */
 140   int dmd_value;                /* Value of this member (for enum).  */
 141 } ctf_dmdef_t;
 142
 143 typedef struct ctf_dtdef
 144 {
 145   ctf_list_t dtd_list;          /* List forward/back pointers.  */
 146   char *dtd_name;               /* Name associated with definition (if any).  */
 147   ctf_id_t dtd_type;            /* Type identifier for this definition.  */
 148   ctf_type_t dtd_data;          /* Type node (see <ctf.h>).  */
 149   union
 150   {
 151     ctf_list_t dtu_members;     /* struct, union, or enum */
 152     ctf_arinfo_t dtu_arr;       /* array */
 153     ctf_encoding_t dtu_enc;     /* integer or float */
 154     ctf_id_t *dtu_argv;         /* function */
 155     ctf_slice_t dtu_slice;      /* slice */
 156   } dtd_u;
 157 } ctf_dtdef_t;
 158
 159 typedef struct ctf_dvdef
 160 {
 161   ctf_list_t dvd_list;          /* List forward/back pointers.  */
 162   char *dvd_name;               /* Name associated with variable.  */
 163   ctf_id_t dvd_type;            /* Type of variable.  */
 164   unsigned long dvd_snapshots;  /* Snapshot count when inserted.  */
 165 } ctf_dvdef_t;
 166
 167 typedef struct ctf_bundle
 168 {
 169   ctf_file_t *ctb_file;         /* CTF container handle.  */
 170   ctf_id_t ctb_type;            /* CTF type identifier.  */
 171   ctf_dtdef_t *ctb_dtd;         /* CTF dynamic type definition (if any).  */
 172 } ctf_bundle_t;
 173
 174 /* The ctf_file is the structure used to represent a CTF container to library
 175    clients, who see it only as an opaque pointer.  Modifications can therefore
 176    be made freely to this structure without regard to client versioning.  The
 177    ctf_file_t typedef appears in <ctf-api.h> and declares a forward tag.
 178
 179    NOTE: ctf_update() requires that everything inside of ctf_file either be an
 180    immediate value, a pointer to dynamically allocated data *outside* of the
 181    ctf_file itself, or a pointer to statically allocated data.  If you add a
 182    pointer to ctf_file that points to something within the ctf_file itself,
 183    you must make corresponding changes to ctf_update().  */
 184
 185 struct ctf_file
 186 {
 187   const ctf_fileops_t *ctf_fileops; /* Version-specific file operations.  */
 188   ctf_sect_t ctf_data;              /* CTF data from object file.  */
 189   ctf_sect_t ctf_symtab;            /* Symbol table from object file.  */
 190   ctf_sect_t ctf_strtab;            /* String table from object file.  */
 191   ctf_hash_t *ctf_structs;          /* Hash table of struct types.  */
 192   ctf_hash_t *ctf_unions;           /* Hash table of union types.  */
 193   ctf_hash_t *ctf_enums;            /* Hash table of enum types.  */
 194   ctf_hash_t *ctf_names;            /* Hash table of remaining type names.  */
 195   ctf_lookup_t ctf_lookups[5];      /* Pointers to hashes for name lookup.  */
 196   ctf_strs_t ctf_str[2];            /* Array of string table base and bounds.  */
 197   const unsigned char *ctf_base;  /* Base of CTF header + uncompressed buffer.  */
 198   const unsigned char *ctf_buf;   /* Uncompressed CTF data buffer.  */
 199   size_t ctf_size;                /* Size of CTF header + uncompressed data.  */
 200   uint32_t *ctf_sxlate;           /* Translation table for symtab entries.  */
 201   unsigned long ctf_nsyms;        /* Number of entries in symtab xlate table.  */
 202   uint32_t *ctf_txlate;           /* Translation table for type IDs.  */
 203   uint32_t *ctf_ptrtab;           /* Translation table for pointer-to lookups.  */
 204   struct ctf_varent *ctf_vars;    /* Sorted variable->type mapping.  */
 205   unsigned long ctf_nvars;        /* Number of variables in ctf_vars.  */
 206   unsigned long ctf_typemax;      /* Maximum valid type ID number.  */
 207   const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above).  */
 208   struct ctf_file *ctf_parent;    /* Parent CTF container (if any).  */
 209   const char *ctf_parlabel;       /* Label in parent container (if any).  */
 210   const char *ctf_parname;        /* Basename of parent (if any).  */
 211   char *ctf_dynparname;           /* Dynamically allocated name of parent.  */
 212   uint32_t ctf_parmax;            /* Highest type ID of a parent type.  */
 213   uint32_t ctf_refcnt;            /* Reference count (for parent links).  */
 214   uint32_t ctf_flags;             /* Libctf flags (see below).  */
 215   int ctf_errno;                  /* Error code for most recent error.  */
 216   int ctf_version;                /* CTF data version.  */
 217   ctf_dynhash_t *ctf_dthash;      /* Hash of dynamic type definitions.  */
 218   ctf_dynhash_t *ctf_dtbyname;    /* DTDs, indexed by name.  */
 219   ctf_list_t ctf_dtdefs;          /* List of dynamic type definitions.  */
 220   ctf_dynhash_t *ctf_dvhash;      /* Hash of dynamic variable mappings.  */
 221   ctf_list_t ctf_dvdefs;          /* List of dynamic variable definitions.  */
 222   size_t ctf_dtvstrlen;           /* Total length of dynamic type+var strings.  */
 223   unsigned long ctf_dtnextid;     /* Next dynamic type id to assign.  */
 224   unsigned long ctf_dtoldid;      /* Oldest id that has been committed.  */
 225   unsigned long ctf_snapshots;    /* ctf_snapshot() plus ctf_update() count.  */
 226   unsigned long ctf_snapshot_lu;  /* ctf_snapshot() call count at last update.  */
 227   ctf_archive_t *ctf_archive;     /* Archive this ctf_file_t came from.  */
 228   char *ctf_tmp_typeslice;        /* Storage for slicing up type names.  */
 229   size_t ctf_tmp_typeslicelen;    /* Size of the typeslice.  */
 230   void *ctf_specific;             /* Data for ctf_get/setspecific().  */
 231 };
 232
 233 /* An abstraction over both a ctf_file_t and a ctf_archive_t.  */
 234
 235 struct ctf_archive_internal
 236 {
 237   int ctfi_is_archive;
 238   ctf_file_t *ctfi_file;
 239   struct ctf_archive *ctfi_archive;
 240   ctf_sect_t ctfi_symsect;
 241   ctf_sect_t ctfi_strsect;
 242   void *ctfi_data;
 243 };
 244
 245 /* Return x rounded up to an alignment boundary.
 246    eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
 247    eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align)  */
 248 #define P2ROUNDUP(x, align)             (-(-(x) & -(align)))
 249
 250 /* * If an offs is not aligned already then round it up and align it. */
 251 #define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
 252
 253 #define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
 254 #define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
 255 #define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
 256 #define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \
 257                                            (id))
 258
 259 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
 260   ((ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
 261
 262 #define LCTF_INFO_KIND(fp, info)        ((fp)->ctf_fileops->ctfo_get_kind(info))
 263 #define LCTF_INFO_ISROOT(fp, info)      ((fp)->ctf_fileops->ctfo_get_root(info))
 264 #define LCTF_INFO_VLEN(fp, info)        ((fp)->ctf_fileops->ctfo_get_vlen(info))
 265 #define LCTF_VBYTES(fp, kind, size, vlen) \
 266   ((fp)->ctf_fileops->ctfo_get_vbytes(kind, size, vlen))
 267
 268 static inline ssize_t ctf_get_ctt_size (const ctf_file_t *fp,
 269                                         const ctf_type_t *tp,
 270                                         ssize_t *sizep,
 271                                         ssize_t *incrementp)
 272 {
 273   return (fp->ctf_fileops->ctfo_get_ctt_size (fp, tp, sizep, incrementp));
 274 }
 275
 276 #define LCTF_CHILD      0x0001  /* CTF container is a child */
 277 #define LCTF_RDWR       0x0002  /* CTF container is writable */
 278 #define LCTF_DIRTY      0x0004  /* CTF container has been modified */
 279
 280 extern const ctf_type_t *ctf_lookup_by_id (ctf_file_t **, ctf_id_t);
 281
 282 typedef unsigned int (*ctf_hash_fun) (const void *ptr);
 283 extern unsigned int ctf_hash_integer (const void *ptr);
 284 extern unsigned int ctf_hash_string (const void *ptr);
 285
 286 typedef int (*ctf_hash_eq_fun) (const void *, const void *);
 287 extern int ctf_hash_eq_integer (const void *, const void *);
 288 extern int ctf_hash_eq_string (const void *, const void *);
 289
 290 typedef void (*ctf_hash_free_fun) (void *);
 291
 292 extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun);
 293 extern int ctf_hash_insert_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
 294 extern int ctf_hash_define_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
 295 extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_file_t *, const char *);
 296 extern uint32_t ctf_hash_size (const ctf_hash_t *);
 297 extern void ctf_hash_destroy (ctf_hash_t *);
 298
 299 extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun,
 300                                           ctf_hash_free_fun, ctf_hash_free_fun);
 301 extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *);
 302 extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *);
 303 extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *);
 304 extern void ctf_dynhash_destroy (ctf_dynhash_t *);
 305
 306 #define ctf_list_prev(elem)     ((void *)(((ctf_list_t *)(elem))->l_prev))
 307 #define ctf_list_next(elem)     ((void *)(((ctf_list_t *)(elem))->l_next))
 308
 309 extern void ctf_list_append (ctf_list_t *, void *);
 310 extern void ctf_list_prepend (ctf_list_t *, void *);
 311 extern void ctf_list_delete (ctf_list_t *, void *);
 312
 313 extern void ctf_dtd_insert (ctf_file_t *, ctf_dtdef_t *);
 314 extern void ctf_dtd_delete (ctf_file_t *, ctf_dtdef_t *);
 315 extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_file_t *, ctf_id_t);
 316 extern ctf_dtdef_t *ctf_dynamic_type (const ctf_file_t *, ctf_id_t);
 317
 318 extern void ctf_dvd_insert (ctf_file_t *, ctf_dvdef_t *);
 319 extern void ctf_dvd_delete (ctf_file_t *, ctf_dvdef_t *);
 320 extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_file_t *, const char *);
 321
 322 extern const char *ctf_strraw (ctf_file_t *, uint32_t);
 323 extern const char *ctf_strptr (ctf_file_t *, uint32_t);
 324
 325 extern struct ctf_archive *ctf_arc_open_internal (const char *, int *);
 326 extern struct ctf_archive *ctf_arc_bufopen (const void *, size_t, int *);
 327 extern void ctf_arc_close_internal (struct ctf_archive *);
 328 extern void *ctf_set_open_errno (int *, int);
 329 extern long ctf_set_errno (ctf_file_t *, int);
 330
 331 _libctf_malloc_
 332 extern void *ctf_data_alloc (size_t);
 333 extern void ctf_data_free (void *, size_t);
 334 extern void ctf_data_protect (void *, size_t);
 335
 336 _libctf_malloc_
 337 extern void *ctf_mmap (size_t length, size_t offset, int fd);
 338 extern void ctf_munmap (void *, size_t);
 339 extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
 340
 341 _libctf_malloc_
 342 extern void *ctf_alloc (size_t);
 343 extern void ctf_free (void *);
 344
 345 _libctf_malloc_
 346 extern char *ctf_strdup (const char *);
 347 extern char *ctf_str_append (char *, const char *);
 348 extern const char *ctf_strerror (int);
 349
 350 extern ctf_id_t ctf_type_resolve_unsliced (ctf_file_t *, ctf_id_t);
 351 extern int ctf_type_kind_unsliced (ctf_file_t *, ctf_id_t);
 352
 353 _libctf_printflike_ (1, 2)
 354 extern void ctf_dprintf (const char *, ...);
 355 extern void libctf_init_debug (void);
 356
 357 extern Elf64_Sym *ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst);
 358
 359 /* Variables, all underscore-prepended. */
 360
 361 extern const char _CTF_NULLSTR[];       /* empty string */
 362
 363 extern int _libctf_debug;       /* debugging messages enabled */
 364
 365 #ifdef  __cplusplus
 366 }
 367 #endif
 368
 369 #endif /* _CTF_IMPL_H */