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