[deliverable/binutils-gdb.git] / libctf / ctf-impl.h

/* Implementation header.
   Copyright (C) 2019 Free Software Foundation, Inc.

   This file is part of libctf.

   libctf is free software; you can redistribute it and/or modify it under
   the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 3, or (at your option) any later
   version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.  If not see
   <http://www.gnu.org/licenses/>.  */

#ifndef	_CTF_IMPL_H
#define	_CTF_IMPL_H

#include "config.h"
#include <sys/errno.h>
#include <ctf-api.h>
#include <sys/types.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdint.h>
#include <limits.h>
#include <ctype.h>
#include <elf.h>

#ifdef	__cplusplus
extern "C"
  {
#endif

/* Compiler attributes.  */

#if defined (__GNUC__)

/* GCC.  We assume that all compilers claiming to be GCC support sufficiently
   many GCC attributes that the code below works.  If some non-GCC compilers
   masquerading as GCC in fact do not implement these attributes, version checks
   may be required.  */

/* We use the _libctf_*_ pattern to avoid clashes with any future attribute
   macros glibc may introduce, which have names of the pattern
   __attribute_blah__.  */

#define _libctf_printflike_(string_index,first_to_check) \
    __attribute__ ((__format__ (__printf__, (string_index), (first_to_check))))
#define _libctf_unlikely_(x) __builtin_expect ((x), 0)
#define _libctf_unused_ __attribute__ ((__unused__))
#define _libctf_malloc_ __attribute__((__malloc__))

#endif

/* libctf in-memory state.  */

typedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c.  */
typedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c.  */

typedef struct ctf_strs
{
  const char *cts_strs;		/* Base address of string table.  */
  size_t cts_len;		/* Size of string table in bytes.  */
} ctf_strs_t;

typedef struct ctf_dmodel
{
  const char *ctd_name;		/* Data model name.  */
  int ctd_code;			/* Data model code.  */
  size_t ctd_pointer;		/* Size of void * in bytes.  */
  size_t ctd_char;		/* Size of char in bytes.  */
  size_t ctd_short;		/* Size of short in bytes.  */
  size_t ctd_int;		/* Size of int in bytes.  */
  size_t ctd_long;		/* Size of long in bytes.  */
} ctf_dmodel_t;

typedef struct ctf_lookup
{
  const char *ctl_prefix;	/* String prefix for this lookup.  */
  size_t ctl_len;		/* Length of prefix string in bytes.  */
  ctf_hash_t *ctl_hash;		/* Pointer to hash table for lookup.  */
} ctf_lookup_t;

typedef struct ctf_fileops
{
  uint32_t (*ctfo_get_kind) (uint32_t);
  uint32_t (*ctfo_get_root) (uint32_t);
  uint32_t (*ctfo_get_vlen) (uint32_t);
  ssize_t (*ctfo_get_ctt_size) (const ctf_file_t *, const ctf_type_t *,
				ssize_t *, ssize_t *);
  ssize_t (*ctfo_get_vbytes) (unsigned short, ssize_t, size_t);
} ctf_fileops_t;

typedef struct ctf_list
{
  struct ctf_list *l_prev;	/* Previous pointer or tail pointer.  */
  struct ctf_list *l_next;	/* Next pointer or head pointer.  */
} ctf_list_t;

typedef enum
  {
   CTF_PREC_BASE,
   CTF_PREC_POINTER,
   CTF_PREC_ARRAY,
   CTF_PREC_FUNCTION,
   CTF_PREC_MAX
  } ctf_decl_prec_t;

typedef struct ctf_decl_node
{
  ctf_list_t cd_list;		/* Linked list pointers.  */
  ctf_id_t cd_type;		/* Type identifier.  */
  uint32_t cd_kind;		/* Type kind.  */
  uint32_t cd_n;		/* Type dimension if array.  */
} ctf_decl_node_t;

typedef struct ctf_decl
{
  ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks.  */
  int cd_order[CTF_PREC_MAX];	     /* Storage order of decls.  */
  ctf_decl_prec_t cd_qualp;	     /* Qualifier precision.  */
  ctf_decl_prec_t cd_ordp;	     /* Ordered precision.  */
  char *cd_buf;			     /* Buffer for output.  */
  int cd_err;			     /* Saved error value.  */
  int cd_enomem;		     /* Nonzero if OOM during printing.  */
} ctf_decl_t;

typedef struct ctf_dmdef
{
  ctf_list_t dmd_list;		/* List forward/back pointers.  */
  char *dmd_name;		/* Name of this member.  */
  ctf_id_t dmd_type;		/* Type of this member (for sou).  */
  unsigned long dmd_offset;	/* Offset of this member in bits (for sou).  */
  int dmd_value;		/* Value of this member (for enum).  */
} ctf_dmdef_t;

typedef struct ctf_dtdef
{
  ctf_list_t dtd_list;		/* List forward/back pointers.  */
  char *dtd_name;		/* Name associated with definition (if any).  */
  ctf_id_t dtd_type;		/* Type identifier for this definition.  */
  ctf_type_t dtd_data;		/* Type node (see <ctf.h>).  */
  union
  {
    ctf_list_t dtu_members;	/* struct, union, or enum */
    ctf_arinfo_t dtu_arr;	/* array */
    ctf_encoding_t dtu_enc;	/* integer or float */
    ctf_id_t *dtu_argv;		/* function */
    ctf_slice_t dtu_slice;	/* slice */
  } dtd_u;
} ctf_dtdef_t;

typedef struct ctf_dvdef
{
  ctf_list_t dvd_list;		/* List forward/back pointers.  */
  char *dvd_name;		/* Name associated with variable.  */
  ctf_id_t dvd_type;		/* Type of variable.  */
  unsigned long dvd_snapshots;	/* Snapshot count when inserted.  */
} ctf_dvdef_t;

typedef struct ctf_bundle
{
  ctf_file_t *ctb_file;		/* CTF container handle.  */
  ctf_id_t ctb_type;		/* CTF type identifier.  */
  ctf_dtdef_t *ctb_dtd;		/* CTF dynamic type definition (if any).  */
} ctf_bundle_t;

/* The ctf_file is the structure used to represent a CTF container to library
   clients, who see it only as an opaque pointer.  Modifications can therefore
   be made freely to this structure without regard to client versioning.  The
   ctf_file_t typedef appears in <ctf-api.h> and declares a forward tag.

   NOTE: ctf_update() requires that everything inside of ctf_file either be an
   immediate value, a pointer to dynamically allocated data *outside* of the
   ctf_file itself, or a pointer to statically allocated data.  If you add a
   pointer to ctf_file that points to something within the ctf_file itself,
   you must make corresponding changes to ctf_update().  */

struct ctf_file
{
  const ctf_fileops_t *ctf_fileops; /* Version-specific file operations.  */
  ctf_sect_t ctf_data;		    /* CTF data from object file.  */
  ctf_sect_t ctf_symtab;	    /* Symbol table from object file.  */
  ctf_sect_t ctf_strtab;	    /* String table from object file.  */
  ctf_hash_t *ctf_structs;	    /* Hash table of struct types.  */
  ctf_hash_t *ctf_unions;	    /* Hash table of union types.  */
  ctf_hash_t *ctf_enums;	    /* Hash table of enum types.  */
  ctf_hash_t *ctf_names;	    /* Hash table of remaining type names.  */
  ctf_lookup_t ctf_lookups[5];	    /* Pointers to hashes for name lookup.  */
  ctf_strs_t ctf_str[2];	    /* Array of string table base and bounds.  */
  const unsigned char *ctf_base;  /* Base of CTF header + uncompressed buffer.  */
  const unsigned char *ctf_buf;	  /* Uncompressed CTF data buffer.  */
  size_t ctf_size;		  /* Size of CTF header + uncompressed data.  */
  uint32_t *ctf_sxlate;		  /* Translation table for symtab entries.  */
  unsigned long ctf_nsyms;	  /* Number of entries in symtab xlate table.  */
  uint32_t *ctf_txlate;		  /* Translation table for type IDs.  */
  uint32_t *ctf_ptrtab;		  /* Translation table for pointer-to lookups.  */
  struct ctf_varent *ctf_vars;	  /* Sorted variable->type mapping.  */
  unsigned long ctf_nvars;	  /* Number of variables in ctf_vars.  */
  unsigned long ctf_typemax;	  /* Maximum valid type ID number.  */
  const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above).  */
  struct ctf_file *ctf_parent;	  /* Parent CTF container (if any).  */
  const char *ctf_parlabel;	  /* Label in parent container (if any).  */
  const char *ctf_parname;	  /* Basename of parent (if any).  */
  char *ctf_dynparname;		  /* Dynamically allocated name of parent.  */
  uint32_t ctf_parmax;		  /* Highest type ID of a parent type.  */
  uint32_t ctf_refcnt;		  /* Reference count (for parent links).  */
  uint32_t ctf_flags;		  /* Libctf flags (see below).  */
  int ctf_errno;		  /* Error code for most recent error.  */
  int ctf_version;		  /* CTF data version.  */
  ctf_dynhash_t *ctf_dthash;	  /* Hash of dynamic type definitions.  */
  ctf_dynhash_t *ctf_dtbyname;	  /* DTDs, indexed by name.  */
  ctf_list_t ctf_dtdefs;	  /* List of dynamic type definitions.  */
  ctf_dynhash_t *ctf_dvhash;	  /* Hash of dynamic variable mappings.  */
  ctf_list_t ctf_dvdefs;	  /* List of dynamic variable definitions.  */
  size_t ctf_dtvstrlen;		  /* Total length of dynamic type+var strings.  */
  unsigned long ctf_dtnextid;	  /* Next dynamic type id to assign.  */
  unsigned long ctf_dtoldid;	  /* Oldest id that has been committed.  */
  unsigned long ctf_snapshots;	  /* ctf_snapshot() plus ctf_update() count.  */
  unsigned long ctf_snapshot_lu;  /* ctf_snapshot() call count at last update.  */
  ctf_archive_t *ctf_archive;	  /* Archive this ctf_file_t came from.  */
  char *ctf_tmp_typeslice;	  /* Storage for slicing up type names.  */
  size_t ctf_tmp_typeslicelen;	  /* Size of the typeslice.  */
  void *ctf_specific;		  /* Data for ctf_get/setspecific().  */
};

/* Return x rounded up to an alignment boundary.
   eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
   eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align)  */
#define P2ROUNDUP(x, align)		(-(-(x) & -(align)))

/* * If an offs is not aligned already then round it up and align it. */
#define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))

#define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
#define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
#define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
#define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \
					   (id))

#define LCTF_INDEX_TO_TYPEPTR(fp, i) \
  ((ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))

#define LCTF_INFO_KIND(fp, info)	((fp)->ctf_fileops->ctfo_get_kind(info))
#define LCTF_INFO_ISROOT(fp, info)	((fp)->ctf_fileops->ctfo_get_root(info))
#define LCTF_INFO_VLEN(fp, info)	((fp)->ctf_fileops->ctfo_get_vlen(info))
#define LCTF_VBYTES(fp, kind, size, vlen) \
  ((fp)->ctf_fileops->ctfo_get_vbytes(kind, size, vlen))

static inline ssize_t ctf_get_ctt_size (const ctf_file_t *fp,
					const ctf_type_t *tp,
					ssize_t *sizep,
					ssize_t *incrementp)
{
  return (fp->ctf_fileops->ctfo_get_ctt_size (fp, tp, sizep, incrementp));
}

#define LCTF_CHILD	0x0001	/* CTF container is a child */
#define LCTF_RDWR	0x0002	/* CTF container is writable */
#define LCTF_DIRTY	0x0004	/* CTF container has been modified */

extern const ctf_type_t *ctf_lookup_by_id (ctf_file_t **, ctf_id_t);

typedef unsigned int (*ctf_hash_fun) (const void *ptr);
extern unsigned int ctf_hash_integer (const void *ptr);
extern unsigned int ctf_hash_string (const void *ptr);

typedef int (*ctf_hash_eq_fun) (const void *, const void *);
extern int ctf_hash_eq_integer (const void *, const void *);
extern int ctf_hash_eq_string (const void *, const void *);

typedef void (*ctf_hash_free_fun) (void *);

extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun);
extern int ctf_hash_insert_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
extern int ctf_hash_define_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_file_t *, const char *);
extern uint32_t ctf_hash_size (const ctf_hash_t *);
extern void ctf_hash_destroy (ctf_hash_t *);

extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun,
					  ctf_hash_free_fun, ctf_hash_free_fun);
extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *);
extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *);
extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *);
extern void ctf_dynhash_destroy (ctf_dynhash_t *);

#define	ctf_list_prev(elem)	((void *)(((ctf_list_t *)(elem))->l_prev))
#define	ctf_list_next(elem)	((void *)(((ctf_list_t *)(elem))->l_next))

extern void ctf_list_append (ctf_list_t *, void *);
extern void ctf_list_prepend (ctf_list_t *, void *);
extern void ctf_list_delete (ctf_list_t *, void *);

extern void ctf_dtd_insert (ctf_file_t *, ctf_dtdef_t *);
extern void ctf_dtd_delete (ctf_file_t *, ctf_dtdef_t *);
extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_file_t *, ctf_id_t);
extern ctf_dtdef_t *ctf_dynamic_type (const ctf_file_t *, ctf_id_t);

extern void ctf_dvd_insert (ctf_file_t *, ctf_dvdef_t *);
extern void ctf_dvd_delete (ctf_file_t *, ctf_dvdef_t *);
extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_file_t *, const char *);

extern const char *ctf_strraw (ctf_file_t *, uint32_t);
extern const char *ctf_strptr (ctf_file_t *, uint32_t);

extern void *ctf_set_open_errno (int *, int);
extern long ctf_set_errno (ctf_file_t *, int);

_libctf_malloc_
extern void *ctf_data_alloc (size_t);
extern void ctf_data_free (void *, size_t);
extern void ctf_data_protect (void *, size_t);

_libctf_malloc_
extern void *ctf_mmap (size_t length, size_t offset, int fd);
extern void ctf_munmap (void *, size_t);
extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);

_libctf_malloc_
extern void *ctf_alloc (size_t);
extern void ctf_free (void *);

_libctf_malloc_
extern char *ctf_strdup (const char *);
extern char *ctf_str_append (char *, const char *);
extern const char *ctf_strerror (int);

extern ctf_id_t ctf_type_resolve_unsliced (ctf_file_t *, ctf_id_t);
extern int ctf_type_kind_unsliced (ctf_file_t *, ctf_id_t);

_libctf_printflike_ (1, 2)
extern void ctf_dprintf (const char *, ...);
extern void libctf_init_debug (void);

extern Elf64_Sym *ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst);

/* Variables, all underscore-prepended. */

extern const char _CTF_NULLSTR[];	/* empty string */

extern int _libctf_debug;	/* debugging messages enabled */

#ifdef	__cplusplus
}
#endif

#endif /* _CTF_IMPL_H */
Commit	Line	Data
60da9d95 NA	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>
94585e7f NA	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>
60da9d95 NA	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
c0754cdd NA	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
a5be9bbe NA	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
94585e7f NA	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
a5be9bbe NA	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	/* Return x rounded up to an alignment boundary.
234	eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
235	eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56align) /
236	#define P2ROUNDUP(x, align) (-(-(x) & -(align)))
237
238	/* * If an offs is not aligned already then round it up and align it. */
239	#define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
240
241	#define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
242	#define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
243	#define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
244	#define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) \| (fp->ctf_parmax+1)) : \
245	(id))
246
247	#define LCTF_INDEX_TO_TYPEPTR(fp, i) \
248	((ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
249
250	#define LCTF_INFO_KIND(fp, info) ((fp)->ctf_fileops->ctfo_get_kind(info))
251	#define LCTF_INFO_ISROOT(fp, info) ((fp)->ctf_fileops->ctfo_get_root(info))
252	#define LCTF_INFO_VLEN(fp, info) ((fp)->ctf_fileops->ctfo_get_vlen(info))
253	#define LCTF_VBYTES(fp, kind, size, vlen) \
254	((fp)->ctf_fileops->ctfo_get_vbytes(kind, size, vlen))
255
256	static inline ssize_t ctf_get_ctt_size (const ctf_file_t *fp,
257	const ctf_type_t *tp,
258	ssize_t *sizep,
259	ssize_t *incrementp)
260	{
261	return (fp->ctf_fileops->ctfo_get_ctt_size (fp, tp, sizep, incrementp));
262	}
263
264	#define LCTF_CHILD 0x0001 /* CTF container is a child */
265	#define LCTF_RDWR 0x0002 /* CTF container is writable */
266	#define LCTF_DIRTY 0x0004 /* CTF container has been modified */
267
268	extern const ctf_type_t ctf_lookup_by_id (ctf_file_t *, ctf_id_t);
269
c0754cdd NA	270	typedef unsigned int (ctf_hash_fun) (const void ptr);
	271	extern unsigned int ctf_hash_integer (const void *ptr);
	272	extern unsigned int ctf_hash_string (const void *ptr);
	273
	274	typedef int (ctf_hash_eq_fun) (const void , const void *);
	275	extern int ctf_hash_eq_integer (const void , const void );
	276	extern int ctf_hash_eq_string (const void , const void );
	277
	278	typedef void (ctf_hash_free_fun) (void );
	279
	280	extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun);
	281	extern int ctf_hash_insert_type (ctf_hash_t , ctf_file_t , uint32_t, uint32_t);
	282	extern int ctf_hash_define_type (ctf_hash_t , ctf_file_t , uint32_t, uint32_t);
	283	extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t , ctf_file_t , const char *);
	284	extern uint32_t ctf_hash_size (const ctf_hash_t *);
	285	extern void ctf_hash_destroy (ctf_hash_t *);
	286
	287	extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun,
	288	ctf_hash_free_fun, ctf_hash_free_fun);
	289	extern int ctf_dynhash_insert (ctf_dynhash_t , void , void *);
	290	extern void ctf_dynhash_remove (ctf_dynhash_t , const void );
	291	extern void ctf_dynhash_lookup (ctf_dynhash_t , const void *);
	292	extern void ctf_dynhash_destroy (ctf_dynhash_t *);
	293
94585e7f NA	294	#define ctf_list_prev(elem) ((void )(((ctf_list_t )(elem))->l_prev))
	295	#define ctf_list_next(elem) ((void )(((ctf_list_t )(elem))->l_next))
	296
	297	extern void ctf_list_append (ctf_list_t , void );
	298	extern void ctf_list_prepend (ctf_list_t , void );
	299	extern void ctf_list_delete (ctf_list_t , void );
	300
a5be9bbe NA	301	extern void ctf_dtd_insert (ctf_file_t , ctf_dtdef_t );
	302	extern void ctf_dtd_delete (ctf_file_t , ctf_dtdef_t );
	303	extern ctf_dtdef_t ctf_dtd_lookup (const ctf_file_t , ctf_id_t);
	304	extern ctf_dtdef_t ctf_dynamic_type (const ctf_file_t , ctf_id_t);
	305
	306	extern void ctf_dvd_insert (ctf_file_t , ctf_dvdef_t );
	307	extern void ctf_dvd_delete (ctf_file_t , ctf_dvdef_t );
	308	extern ctf_dvdef_t ctf_dvd_lookup (const ctf_file_t , const char *);
	309
94585e7f NA	310	extern const char ctf_strraw (ctf_file_t , uint32_t);
	311	extern const char ctf_strptr (ctf_file_t , uint32_t);
	312
	313	extern void ctf_set_open_errno (int , int);
	314	extern long ctf_set_errno (ctf_file_t *, int);
	315
60da9d95 NA	316	_libctf_malloc_
	317	extern void *ctf_data_alloc (size_t);
	318	extern void ctf_data_free (void *, size_t);
	319	extern void ctf_data_protect (void *, size_t);
	320
	321	_libctf_malloc_
	322	extern void *ctf_mmap (size_t length, size_t offset, int fd);
	323	extern void ctf_munmap (void *, size_t);
	324	extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
	325
	326	_libctf_malloc_
	327	extern void *ctf_alloc (size_t);
	328	extern void ctf_free (void *);
	329
94585e7f NA	330	_libctf_malloc_
	331	extern char ctf_strdup (const char );
	332	extern char ctf_str_append (char , const char *);
	333	extern const char *ctf_strerror (int);
	334
a5be9bbe NA	335	extern ctf_id_t ctf_type_resolve_unsliced (ctf_file_t *, ctf_id_t);
	336	extern int ctf_type_kind_unsliced (ctf_file_t *, ctf_id_t);
	337
60da9d95 NA	338	_libctf_printflike_ (1, 2)
	339	extern void ctf_dprintf (const char *, ...);
	340	extern void libctf_init_debug (void);
	341
94585e7f NA	342	extern Elf64_Sym ctf_sym_to_elf64 (const Elf32_Sym src, Elf64_Sym *dst);
94585e7f NA	343
a5be9bbe NA	344	/* Variables, all underscore-prepended. */
	345
	346	extern const char _CTF_NULLSTR[]; /* empty string */
	347
60da9d95 NA	348	extern int _libctf_debug; /* debugging messages enabled */
	349
	350	#ifdef __cplusplus
	351	}
	352	#endif
	353
	354	#endif /* _CTF_IMPL_H */