/* Public API to libctf.   Copyright (C) 2019-2026 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/>.  */ /* This header file defines the interfaces available from the CTF debugger   library, libctf.  This API can be used by a debugger to operate on data in   the Compact ANSI-C Type Format (CTF).  */ #ifndef	_CTF_API_H#define	_CTF_API_H #include <sys/types.h>#include <inttypes.h>#include <ctf.h>#include <zlib.h> #ifdef	__cplusplusextern "C"{#endif /* Clients can open one or more CTF containers and obtain a pointer to an   opaque ctf_dict_t.  Types are identified by an opaque ctf_id_t token.   They can also open or create read-only archives of CTF containers in a   ctf_archive_t.    These opaque definitions allow libctf to evolve without breaking clients.  */ typedef struct ctf_dict ctf_dict_t;typedef struct ctf_archive_internal ctf_archive_t;typedef unsigned long ctf_id_t; /* This opaque definition allows libctf to accept BFD data structures without   importing all the BFD noise into users' namespaces.  */ struct bfd; /* If the debugger needs to provide the CTF library with a set of raw buffers   for use as the CTF data, symbol table, and string table, it can do so by   filling in ctf_sect_t structures and passing them to ctf_bufopen.    The contents of this structure must always be in native endianness.  At read   time, the symbol table endianness is derived from the BFD target (if BFD is   in use): if a BFD target is not in use, please call ctf_symsect_endianness or   ctf_arc_symsect_endianness.  */ typedef struct ctf_sect{  const char *cts_name;		  /* Section name (if any).  */  const void *cts_data;		  /* Pointer to section data.  */  size_t cts_size;		  /* Size of data in bytes.  */  size_t cts_entsize;		  /* Size of each section entry (symtab only).  */} ctf_sect_t; /* A minimal symbol extracted from a linker's internal symbol table   representation.  The symbol name can be given either via st_name or via a   strtab offset in st_nameidx, which corresponds to one of the string offsets   communicated via the ctf_link_add_strtab callback.   */ typedef struct ctf_link_sym{  /* The st_name and st_nameidx will not be accessed outside the call to     ctf_link_shuffle_syms.  If you set st_nameidx to offset zero, make sure     to set st_nameidx_set as well.  */   const char *st_name;  size_t st_nameidx;  int st_nameidx_set;  uint32_t st_symidx;  uint32_t st_shndx;  uint32_t st_type;  uint32_t st_value;} ctf_link_sym_t; /* Flags applying to this specific link.  */ /* Share all types that are not in conflict.  The default.  */#define CTF_LINK_SHARE_UNCONFLICTED 0x0 /* Share only types that are used by multiple inputs.  */#define CTF_LINK_SHARE_DUPLICATED 0x1 /* Do a nondeduplicating link, or otherwise deduplicate "less hard", trading off   CTF output size for link time.  */#define CTF_LINK_NONDEDUP 0x2 /* Create empty outputs for all registered CU mappings even if no types are   emitted into them.  */#define CTF_LINK_EMPTY_CU_MAPPINGS 0x4 /* Omit the content of the variables section.  */#define CTF_LINK_OMIT_VARIABLES_SECTION 0x8 /* If *unset*, filter out entries corresponding to linker-reported symbols   from the variable section, and filter out all entries with no linker-reported   symbols from the data object and function info sections: if set, do no   filtering and leave all entries in place.  (This is a negative-sense flag   because it is rare to want symbols the linker has not reported as present to   stick around in the symtypetab sections nonetheless: relocatable links are   the only likely case.)  */#define CTF_LINK_NO_FILTER_REPORTED_SYMS 0x10 /* Symbolic names for CTF sections.  */ typedef enum ctf_sect_names  {   CTF_SECT_HEADER,   CTF_SECT_LABEL,   CTF_SECT_OBJT,   CTF_SECT_OBJTIDX = CTF_SECT_OBJT,   CTF_SECT_FUNC,   CTF_SECT_FUNCIDX = CTF_SECT_FUNC,   CTF_SECT_VAR,   CTF_SECT_TYPE,   CTF_SECT_STR  } ctf_sect_names_t; /* Encoding information for integers, floating-point values, and certain other   intrinsics can be obtained by calling ctf_type_encoding, below.  The flags   field will contain values appropriate for the type defined in <ctf.h>.  */ typedef struct ctf_encoding{  uint32_t cte_format;		 /* Data format (CTF_INT_* or CTF_FP_* flags).  */  uint32_t cte_offset;		 /* Offset of value in bits.  */  uint32_t cte_bits;		 /* Size of storage in bits.  */} ctf_encoding_t; typedef struct ctf_membinfo{  ctf_id_t ctm_type;		/* Type of struct or union member.  */  unsigned long ctm_offset;	/* Offset of member in bits.  */} ctf_membinfo_t; typedef struct ctf_arinfo{  ctf_id_t ctr_contents;	/* Type of array contents.  */  ctf_id_t ctr_index;		/* Type of array index.  */  uint32_t ctr_nelems;		/* Number of elements.  */} ctf_arinfo_t; typedef struct ctf_funcinfo{  ctf_id_t ctc_return;		/* Function return type.  */  uint32_t ctc_argc;		/* Number of typed arguments to function.  */  uint32_t ctc_flags;		/* Function attributes (see below).  */} ctf_funcinfo_t; typedef struct ctf_lblinfo{  ctf_id_t ctb_type;		/* Last type associated with the label.  */} ctf_lblinfo_t; typedef struct ctf_snapshot_id{  unsigned long dtd_id;		/* Highest DTD ID at time of snapshot.  */  unsigned long snapshot_id;	/* Snapshot id at time of snapshot.  */} ctf_snapshot_id_t; #define	CTF_FUNC_VARARG	0x1	/* Function arguments end with varargs.  */ /* Functions that return a ctf_id_t use the following value to indicate failure.   ctf_errno can be used to obtain an error code.  Functions that return   a straight integral -1 also use ctf_errno.  */#define	CTF_ERR	((ctf_id_t) -1L) /* This macro holds information about all the available ctf errors.   It is used to form both an enum holding all the error constants,   and also the error strings themselves.  To use, define _CTF_FIRST   and _CTF_ITEM to expand as you like, then mention the macro name.   See the enum after this for an example.  */#define _CTF_ERRORS \  _CTF_FIRST (ECTF_FMT, "File is not in CTF or ELF format.")	\  _CTF_ITEM (ECTF_BFDERR, "BFD error.")				\  _CTF_ITEM (ECTF_CTFVERS, "CTF dict version is too new for libctf.") \  _CTF_ITEM (ECTF_BFD_AMBIGUOUS, "Ambiguous BFD target.")	\  _CTF_ITEM (ECTF_SYMTAB, "Symbol table uses invalid entry size.") \  _CTF_ITEM (ECTF_SYMBAD, "Symbol table data buffer is not valid.") \  _CTF_ITEM (ECTF_STRBAD, "String table data buffer is not valid.") \  _CTF_ITEM (ECTF_CORRUPT, "File data structure corruption detected.") \  _CTF_ITEM (ECTF_NOCTFDATA, "File does not contain CTF data.") \  _CTF_ITEM (ECTF_NOCTFBUF, "Buffer does not contain CTF data.") \  _CTF_ITEM (ECTF_NOSYMTAB, "Symbol table information is not available.") \  _CTF_ITEM (ECTF_NOPARENT, "The parent CTF dictionary is needed but unavailable.") \  _CTF_ITEM (ECTF_DMODEL, "Data model mismatch.") \  _CTF_ITEM (ECTF_LINKADDEDLATE, "File added to link too late.") \  _CTF_ITEM (ECTF_ZALLOC, "Failed to allocate (de)compression buffer.") \  _CTF_ITEM (ECTF_DECOMPRESS, "Failed to decompress CTF data.") \  _CTF_ITEM (ECTF_STRTAB, "External string table is not available.") \  _CTF_ITEM (ECTF_BADNAME, "String name offset is corrupt.") \  _CTF_ITEM (ECTF_BADID, "Invalid type identifier.") \  _CTF_ITEM (ECTF_NOTSOU, "Type is not a struct or union.") \  _CTF_ITEM (ECTF_NOTENUM, "Type is not an enum.") \  _CTF_ITEM (ECTF_NOTSUE, "Type is not a struct, union, or enum.") \  _CTF_ITEM (ECTF_NOTINTFP, "Type is not an integer, float, or enum.") \  _CTF_ITEM (ECTF_NOTARRAY, "Type is not an array.") \  _CTF_ITEM (ECTF_NOTREF, "Type does not reference another type.") \  _CTF_ITEM (ECTF_NAMELEN, "Buffer is too small to hold type name.") \  _CTF_ITEM (ECTF_NOTYPE, "No type found corresponding to name.") \  _CTF_ITEM (ECTF_SYNTAX, "Syntax error in type name.") \  _CTF_ITEM (ECTF_NOTFUNC, "Symbol table entry or type is not a function.") \  _CTF_ITEM (ECTF_NOFUNCDAT, "No function information available for function.") \  _CTF_ITEM (ECTF_NOTDATA, "Symbol table entry does not refer to a data object.") \  _CTF_ITEM (ECTF_NOTYPEDAT, "No type information available for symbol.") \  _CTF_ITEM (ECTF_NOLABEL, "No label found corresponding to name.") \  _CTF_ITEM (ECTF_NOLABELDATA, "File does not contain any labels.") \  _CTF_ITEM (ECTF_NOTSUP, "Feature not supported.") \  _CTF_ITEM (ECTF_NOENUMNAM, "Enumerator name not found.") \  _CTF_ITEM (ECTF_NOMEMBNAM, "Member name not found.") \  _CTF_ITEM (ECTF_RDONLY, "CTF container is read-only.") \  _CTF_ITEM (ECTF_DTFULL, "CTF type is full (no more members allowed).") \  _CTF_ITEM (ECTF_FULL, "CTF container is full.") \  _CTF_ITEM (ECTF_DUPLICATE, "Duplicate member, enumerator, or variable name.") \  _CTF_ITEM (ECTF_CONFLICT, "Conflicting type is already defined.") \  _CTF_ITEM (ECTF_OVERROLLBACK, "Attempt to roll back past a ctf_update.") \  _CTF_ITEM (ECTF_COMPRESS, "Failed to compress CTF data.") \  _CTF_ITEM (ECTF_ARCREATE, "Error creating CTF archive.") \  _CTF_ITEM (ECTF_ARNNAME, "Name not found in CTF archive.") \  _CTF_ITEM (ECTF_SLICEOVERFLOW, "Overflow of type bitness or offset in slice.") \  _CTF_ITEM (ECTF_DUMPSECTUNKNOWN, "Unknown section number in dump.") \  _CTF_ITEM (ECTF_DUMPSECTCHANGED, "Section changed in middle of dump.") \  _CTF_ITEM (ECTF_NOTYET, "Feature not yet implemented.") \  _CTF_ITEM (ECTF_INTERNAL, "Internal error: assertion failure.") \  _CTF_ITEM (ECTF_NONREPRESENTABLE, "Type not representable in CTF.") \  _CTF_ITEM (ECTF_NEXT_END, "End of iteration.") \  _CTF_ITEM (ECTF_NEXT_WRONGFUN, "Wrong iteration function called.") \  _CTF_ITEM (ECTF_NEXT_WRONGFP, "Iteration entity changed in mid-iterate.") \  _CTF_ITEM (ECTF_FLAGS, "CTF header contains flags unknown to libctf.") \  _CTF_ITEM (ECTF_NEEDSBFD, "This feature needs a libctf with BFD support.") \  _CTF_ITEM (ECTF_INCOMPLETE, "Type is not a complete type.") \  _CTF_ITEM (ECTF_NONAME, "Type name must not be empty.") \  _CTF_ITEM (ECTF_BADFLAG, "Invalid CTF dict flag specified.") #define	ECTF_BASE	1000	/* Base value for libctf errnos.  */ enum  {#define _CTF_FIRST(NAME, STR) NAME = ECTF_BASE#define _CTF_ITEM(NAME, STR) , NAME_CTF_ERRORS#undef _CTF_ITEM#undef _CTF_FIRST  }; #define ECTF_NERR (ECTF_BADFLAG - ECTF_BASE + 1) /* Count of CTF errors.  */ /* The CTF data model is inferred to be the caller's data model or the data   model of the given object, unless ctf_setmodel is explicitly called.  */#define	CTF_MODEL_ILP32 1	/* Object data model is ILP32.  */#define	CTF_MODEL_LP64  2	/* Object data model is LP64.  */#ifdef _LP64# define CTF_MODEL_NATIVE CTF_MODEL_LP64#else# define CTF_MODEL_NATIVE CTF_MODEL_ILP32#endif /* Dynamic CTF containers can be created using ctf_create.  The ctf_add_*   routines can be used to add new definitions to the dynamic container.  New   types are labeled as root or non-root to determine whether they are visible   at the top-level program scope when subsequently doing a lookup.   (Identifiers contained within non-root types, like enumeration constants, are   also not visible.)  */ #define	CTF_ADD_NONROOT	0	/* Type only visible in nested scope.  */#define	CTF_ADD_ROOT	1	/* Type visible at top-level scope.  */ /* Flags for ctf_member_next.  */ #define CTF_MN_RECURSE 0x1	/* Recurse into unnamed members.  */ /* Flags for ctf_dict_set_flag.  */ /* If set, duplicate enumerators in a single dict fail with ECTF_DUPLICATE.  */ #define CTF_STRICT_NO_DUP_ENUMERATORS	0x1 /* These typedefs are used to define the signature for callback functions that   can be used with the iteration and visit functions below.  There is also a   family of iteration functions that do not require callbacks.  */ typedef int ctf_visit_f (const char *name, ctf_id_t type, unsigned long offset,			 int depth, void *arg);typedef int ctf_member_f (const char *name, ctf_id_t membtype,			  unsigned long offset, void *arg);typedef int ctf_enum_f (const char *name, int val, void *arg);typedef int ctf_variable_f (const char *name, ctf_id_t type, void *arg);typedef int ctf_type_f (ctf_id_t type, void *arg);typedef int ctf_type_all_f (ctf_id_t type, int flag, void *arg);typedef int ctf_label_f (const char *name, const ctf_lblinfo_t *info,			 void *arg);typedef int ctf_archive_member_f (ctf_dict_t *fp, const char *name, void *arg);typedef int ctf_archive_raw_member_f (const char *name, const void *content,				      size_t len, void *arg);typedef char *ctf_dump_decorate_f (ctf_sect_names_t sect,				   char *line, void *arg); typedef struct ctf_dump_state ctf_dump_state_t; /* Iteration state for the _next functions, and allocators/copiers/freers for   it.  (None of these are needed for the simple case of iterating to the end:   the _next functions allocate and free the iterators for you.)    The _next iterators all work in similar ways: they take things to query (a   dict, a name, a type ID, something like that), then a ctf_next_t iterator   arg which must be the address of a variable whose value is NULL on first   call, and will be set to NULL again once iteration has completed.    They return something important about the thing being iterated over (often a   type ID or a name); on end of iteration they instead return return CTF_ERR,   -1, or NULL and set the error ECTF_NEXT_END on the dict.  They can often   provide more information too: this is done via pointer parameters (e.g. the   membname and membtype in ctf_member_next()).  These parameters are always   optional and can be set to NULL if not needed.    Errors other than end-of-iteration will return CTF_ERR/-1/NULL and set the   error to something other than ECTF_NEXT_END, and *not* destroy the iterator:   you should either recover somehow and continue iterating, or call   ctf_next_destroy() on it.  (You can call ctf_next_destroy() on a NULL   iterator, so it's safe to just unconditionally do it after iteration has   completed.)  */ typedef struct ctf_next ctf_next_t;extern ctf_next_t *ctf_next_create (void);extern void ctf_next_destroy (ctf_next_t *);extern ctf_next_t *ctf_next_copy (ctf_next_t *); /* Opening.  These mostly return an abstraction over both CTF files and CTF   archives: so they can be used to open both.  CTF files will appear to be an   archive with one member named '.ctf'.    All these functions except for ctf_close use BFD and can open anything BFD   can open, hunting down the .ctf section for you, so are not available in the   libctf-nobfd flavour of the library.  If you want to provide the CTF section   yourself, you can do that with ctf_bfdopen_ctfsect.  */ extern ctf_archive_t *ctf_bfdopen (struct bfd *, int *);extern ctf_archive_t *ctf_bfdopen_ctfsect (struct bfd *, const ctf_sect_t *,					   int *);extern ctf_archive_t *ctf_fdopen (int fd, const char *filename,				  const char *target, int *errp);extern ctf_archive_t *ctf_open (const char *filename,				const char *target, int *errp);extern void ctf_close (ctf_archive_t *); /* Set or unset dict-wide boolean flags, and get the value of these flags.  */ extern int ctf_dict_set_flag (ctf_dict_t *, uint64_t flag, int set);extern int ctf_dict_get_flag (ctf_dict_t *, uint64_t flag); /* Return the data, symbol, or string sections used by a given CTF dict.  */extern ctf_sect_t ctf_getdatasect (const ctf_dict_t *);extern ctf_sect_t ctf_getsymsect (const ctf_dict_t *);extern ctf_sect_t ctf_getstrsect (const ctf_dict_t *); /* Set the endianness of the symbol section, which may be different from   the endianness of the CTF dict. Done for you by ctf_open and ctf_fdopen,   but direct calls to ctf_bufopen etc with symbol sections provided must   do so explicitly.  */ extern void ctf_symsect_endianness (ctf_dict_t *, int little_endian);extern void ctf_arc_symsect_endianness (ctf_archive_t *, int little_endian); /* Open CTF archives from files or raw section data, and close them again.   Closing may munmap() the data making up the archive, so should not be   done until all dicts are finished with and closed themselves.    Almost all functions that open archives will also open raw CTF dicts, which   are treated as if they were archives with only one member.    Some of these functions take optional raw symtab and strtab section content   in the form of ctf_sect_t structures.  For CTF in ELF files, the more   convenient opening functions above extract these .dynsym and its associated   string table (usually .dynsym) whenever the CTF_F_DYNSTR flag is set in the   CTF preamble (which it almost always will be for linked objects, but not for   .o files).  If you use ctf_arc_bufopen and do not specify symbol/string   tables, the ctf_*_lookuup_symbol functions will fail with ECTF_NOSYMTAB.    Like many other convenient opening functions, ctf_arc_open needs BFD and is   not available in libctf-nobfd.  */ extern ctf_archive_t *ctf_arc_open (const char *, int *);extern ctf_archive_t *ctf_arc_bufopen (const ctf_sect_t *ctfsect,				       const ctf_sect_t *symsect,				       const ctf_sect_t *strsect,				       int *);extern void ctf_arc_close (ctf_archive_t *); /* Get the archive a given dictionary came from (if any).  */ extern ctf_archive_t *ctf_get_arc (const ctf_dict_t *); /* Return the number of members in an archive.  */ extern size_t ctf_archive_count (const ctf_archive_t *); /* Open a dictionary with a given name, given a CTF archive and   optionally symbol and string table sections to accompany it (if the   archive was oriiginally opened from an ELF file via ctf_open*, or   if string or symbol tables were explicitly passed when the archive   was opened, this can be used to override that choice).  The dict   should be closed with ctf_dict_close() when done.    (The low-level functions ctf_simple_open and ctf_bufopen return   ctf_dict_t's directly, and cannot be used on CTF archives: use these   functions instead.)  */ extern ctf_dict_t *ctf_dict_open (const ctf_archive_t *,				  const char *, int *);extern ctf_dict_t *ctf_dict_open_sections (const ctf_archive_t *,					   const ctf_sect_t *symsect,					   const ctf_sect_t *strsect,					   const char *, int *); /* Look up symbols' types in archives by index or name, returning the dict   and optionally type ID in which the type is found.  Lookup results are   cached so future lookups are faster.  Needs symbol tables and (for name   lookups) string tables to be known for this CTF archive.  */ extern ctf_dict_t *ctf_arc_lookup_symbol (ctf_archive_t *,					  unsigned long symidx,					  ctf_id_t *, int *errp);extern ctf_dict_t *ctf_arc_lookup_symbol_name (ctf_archive_t *,					       const char *name,					       ctf_id_t *, int *errp);extern void ctf_arc_flush_caches (ctf_archive_t *); /* The next functions return or close real CTF files, or write out CTF   archives, not archives or ELF files containing CTF content.  As with   ctf_dict_open_sections, they can be passed symbol and string table   sections.  */ extern ctf_dict_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,				    const char *symsect, size_t symsect_size,				    size_t symsect_entsize,				    const char *strsect, size_t strsect_size,				    int *errp);extern ctf_dict_t *ctf_bufopen (const ctf_sect_t *ctfsect,				const ctf_sect_t *symsect,				const ctf_sect_t *strsect, int *);extern void ctf_ref (ctf_dict_t *);extern void ctf_dict_close (ctf_dict_t *); /* CTF dicts may be in a parent/child relationship, where the child dicts   contain the name of their originating compilation unit and the name of   their parent.  Dicts opened from CTF archives have this relationship set   up already, but if opening via raw low-level calls, you need to figure   out which dict is the parent and set it on the child via ctf_import(). */ extern const char *ctf_cuname (ctf_dict_t *);extern ctf_dict_t *ctf_parent_dict (ctf_dict_t *);extern const char *ctf_parent_name (ctf_dict_t *);extern int ctf_type_isparent (ctf_dict_t *, ctf_id_t);extern int ctf_type_ischild (ctf_dict_t *, ctf_id_t);extern int ctf_import (ctf_dict_t *, ctf_dict_t *); /* Set these names (used when creating dicts).  */ extern int ctf_cuname_set (ctf_dict_t *, const char *);extern int ctf_parent_name_set (ctf_dict_t *, const char *); /* Set and get the CTF data model (see above).  */ extern int ctf_setmodel (ctf_dict_t *, int);extern int ctf_getmodel (ctf_dict_t *); /* CTF dicts can carry a single (in-memory-only) non-persistent pointer to   arbitrary data.  No meaning is attached to this data and the dict does   not own it: nothing is done to it when the dict is closed.  */ extern void ctf_setspecific (ctf_dict_t *, void *);extern void *ctf_getspecific (ctf_dict_t *); /* Error handling.  ctf dicts carry a system errno value or one of the   CTF_ERRORS above, which are returned via ctf_errno.  The return value of   ctf_errno is only meaningful when the immediately preceding CTF function   call returns an error code.    There are four possible sorts of error return:     - From opening functions, a return value of NULL and the error returned      via an errp instead of via ctf_errno; all other functions return return      errors via ctf_errno.     - Functions returning a ctf_id_t are in error if the return value == CTF_ERR    - Functions returning an int are in error if their return value < 0

Lines 1–500 of 1026. Load more