include/ctf-api.h

   1 /* Public API to libctf.
   2    Copyright (C) 2019-2024 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 /* This header file defines the interfaces available from the CTF debugger
  21    library, libctf.  This API can be used by a debugger to operate on data in
  22    the Compact ANSI-C Type Format (CTF).  */
  23
  24 #ifndef _CTF_API_H
  25 #define _CTF_API_H
  26
  27 #include <sys/types.h>
  28 #include <ctf.h>
  29 #include <zlib.h>
  30
  31 #ifdef  __cplusplus
  32 extern "C"
  33 {
  34 #endif
  35
  36 /* Clients can open one or more CTF containers and obtain a pointer to an
  37    opaque ctf_dict_t.  Types are identified by an opaque ctf_id_t token.
  38    They can also open or create read-only archives of CTF containers in a
  39    ctf_archive_t.
  40
  41    These opaque definitions allow libctf to evolve without breaking clients.  */
  42
  43 typedef struct ctf_dict ctf_dict_t;
  44 typedef struct ctf_archive_internal ctf_archive_t;
  45 typedef unsigned long ctf_id_t;
  46
  47 /* This opaque definition allows libctf to accept BFD data structures without
  48    importing all the BFD noise into users' namespaces.  */
  49
  50 struct bfd;
  51
  52 /* If the debugger needs to provide the CTF library with a set of raw buffers
  53    for use as the CTF data, symbol table, and string table, it can do so by
  54    filling in ctf_sect_t structures and passing them to ctf_bufopen.
  55
  56    The contents of this structure must always be in native endianness.  At read
  57    time, the symbol table endianness is derived from the BFD target (if BFD is
  58    in use): if a BFD target is not in use, please call ctf_symsect_endianness or
  59    ctf_arc_symsect_endianness.  */
  60
  61 typedef struct ctf_sect
  62 {
  63   const char *cts_name;           /* Section name (if any).  */
  64   const void *cts_data;           /* Pointer to section data.  */
  65   size_t cts_size;                /* Size of data in bytes.  */
  66   size_t cts_entsize;             /* Size of each section entry (symtab only).  */
  67 } ctf_sect_t;
  68
  69 /* A minimal symbol extracted from a linker's internal symbol table
  70    representation.  The symbol name can be given either via st_name or via a
  71    strtab offset in st_nameidx, which corresponds to one of the string offsets
  72    communicated via the ctf_link_add_strtab callback.   */
  73
  74 typedef struct ctf_link_sym
  75 {
  76   /* The st_name and st_nameidx will not be accessed outside the call to
  77      ctf_link_shuffle_syms.  If you set st_nameidx to offset zero, make sure
  78      to set st_nameidx_set as well.  */
  79
  80   const char *st_name;
  81   size_t st_nameidx;
  82   int st_nameidx_set;
  83   uint32_t st_symidx;
  84   uint32_t st_shndx;
  85   uint32_t st_type;
  86   uint32_t st_value;
  87 } ctf_link_sym_t;
  88
  89 /* Flags applying to this specific link.  */
  90
  91 /* Share all types that are not in conflict.  The default.  */
  92 #define CTF_LINK_SHARE_UNCONFLICTED 0x0
  93
  94 /* Share only types that are used by multiple inputs.  */
  95 #define CTF_LINK_SHARE_DUPLICATED 0x1
  96
  97 /* Do a nondeduplicating link, or otherwise deduplicate "less hard", trading off
  98    CTF output size for link time.  */
  99 #define CTF_LINK_NONDEDUP 0x2
 100
 101 /* Create empty outputs for all registered CU mappings even if no types are
 102    emitted into them.  */
 103 #define CTF_LINK_EMPTY_CU_MAPPINGS 0x4
 104
 105 /* Omit the content of the variables section.  */
 106 #define CTF_LINK_OMIT_VARIABLES_SECTION 0x8
 107
 108 /* If *unset*, filter out entries corresponding to linker-reported symbols
 109    from the variable section, and filter out all entries with no linker-reported
 110    symbols from the data object and function info sections: if set, do no
 111    filtering and leave all entries in place.  (This is a negative-sense flag
 112    because it is rare to want symbols the linker has not reported as present to
 113    stick around in the symtypetab sections nonetheless: relocatable links are
 114    the only likely case.)  */
 115 #define CTF_LINK_NO_FILTER_REPORTED_SYMS 0x10
 116
 117 /* Symbolic names for CTF sections.  */
 118
 119 typedef enum ctf_sect_names
 120   {
 121    CTF_SECT_HEADER,
 122    CTF_SECT_LABEL,
 123    CTF_SECT_OBJT,
 124    CTF_SECT_OBJTIDX = CTF_SECT_OBJT,
 125    CTF_SECT_FUNC,
 126    CTF_SECT_FUNCIDX = CTF_SECT_FUNC,
 127    CTF_SECT_VAR,
 128    CTF_SECT_TYPE,
 129    CTF_SECT_STR
 130   } ctf_sect_names_t;
 131
 132 /* Encoding information for integers, floating-point values, and certain other
 133    intrinsics can be obtained by calling ctf_type_encoding, below.  The flags
 134    field will contain values appropriate for the type defined in <ctf.h>.  */
 135
 136 typedef struct ctf_encoding
 137 {
 138   uint32_t cte_format;           /* Data format (CTF_INT_* or CTF_FP_* flags).  */
 139   uint32_t cte_offset;           /* Offset of value in bits.  */
 140   uint32_t cte_bits;             /* Size of storage in bits.  */
 141 } ctf_encoding_t;
 142
 143 typedef struct ctf_membinfo
 144 {
 145   ctf_id_t ctm_type;            /* Type of struct or union member.  */
 146   unsigned long ctm_offset;     /* Offset of member in bits.  */
 147 } ctf_membinfo_t;
 148
 149 typedef struct ctf_arinfo
 150 {
 151   ctf_id_t ctr_contents;        /* Type of array contents.  */
 152   ctf_id_t ctr_index;           /* Type of array index.  */
 153   uint32_t ctr_nelems;          /* Number of elements.  */
 154 } ctf_arinfo_t;
 155
 156 typedef struct ctf_funcinfo
 157 {
 158   ctf_id_t ctc_return;          /* Function return type.  */
 159   uint32_t ctc_argc;            /* Number of typed arguments to function.  */
 160   uint32_t ctc_flags;           /* Function attributes (see below).  */
 161 } ctf_funcinfo_t;
 162
 163 typedef struct ctf_lblinfo
 164 {
 165   ctf_id_t ctb_type;            /* Last type associated with the label.  */
 166 } ctf_lblinfo_t;
 167
 168 typedef struct ctf_snapshot_id
 169 {
 170   unsigned long dtd_id;         /* Highest DTD ID at time of snapshot.  */
 171   unsigned long snapshot_id;    /* Snapshot id at time of snapshot.  */
 172 } ctf_snapshot_id_t;
 173
 174 #define CTF_FUNC_VARARG 0x1     /* Function arguments end with varargs.  */
 175
 176 /* Functions that return a ctf_id_t use the following value to indicate failure.
 177    ctf_errno can be used to obtain an error code.  Functions that return
 178    a straight integral -1 also use ctf_errno.  */
 179 #define CTF_ERR ((ctf_id_t) -1L)
 180
 181 /* This macro holds information about all the available ctf errors.
 182    It is used to form both an enum holding all the error constants,
 183    and also the error strings themselves.  To use, define _CTF_FIRST
 184    and _CTF_ITEM to expand as you like, then mention the macro name.
 185    See the enum after this for an example.  */
 186 #define _CTF_ERRORS \
 187   _CTF_FIRST (ECTF_FMT, "File is not in CTF or ELF format.")    \
 188   _CTF_ITEM (ECTF_BFDERR, "BFD error.")                         \
 189   _CTF_ITEM (ECTF_CTFVERS, "CTF dict version is too new for libctf.") \
 190   _CTF_ITEM (ECTF_BFD_AMBIGUOUS, "Ambiguous BFD target.")       \
 191   _CTF_ITEM (ECTF_SYMTAB, "Symbol table uses invalid entry size.") \
 192   _CTF_ITEM (ECTF_SYMBAD, "Symbol table data buffer is not valid.") \
 193   _CTF_ITEM (ECTF_STRBAD, "String table data buffer is not valid.") \
 194   _CTF_ITEM (ECTF_CORRUPT, "File data structure corruption detected.") \
 195   _CTF_ITEM (ECTF_NOCTFDATA, "File does not contain CTF data.") \
 196   _CTF_ITEM (ECTF_NOCTFBUF, "Buffer does not contain CTF data.") \
 197   _CTF_ITEM (ECTF_NOSYMTAB, "Symbol table information is not available.") \
 198   _CTF_ITEM (ECTF_NOPARENT, "The parent CTF dictionary is unavailable.") \
 199   _CTF_ITEM (ECTF_DMODEL, "Data model mismatch.") \
 200   _CTF_ITEM (ECTF_LINKADDEDLATE, "File added to link too late.") \
 201   _CTF_ITEM (ECTF_ZALLOC, "Failed to allocate (de)compression buffer.") \
 202   _CTF_ITEM (ECTF_DECOMPRESS, "Failed to decompress CTF data.") \
 203   _CTF_ITEM (ECTF_STRTAB, "External string table is not available.") \
 204   _CTF_ITEM (ECTF_BADNAME, "String name offset is corrupt.") \
 205   _CTF_ITEM (ECTF_BADID, "Invalid type identifier.") \
 206   _CTF_ITEM (ECTF_NOTSOU, "Type is not a struct or union.") \
 207   _CTF_ITEM (ECTF_NOTENUM, "Type is not an enum.") \
 208   _CTF_ITEM (ECTF_NOTSUE, "Type is not a struct, union, or enum.") \
 209   _CTF_ITEM (ECTF_NOTINTFP, "Type is not an integer, float, or enum.") \
 210   _CTF_ITEM (ECTF_NOTARRAY, "Type is not an array.") \
 211   _CTF_ITEM (ECTF_NOTREF, "Type does not reference another type.") \
 212   _CTF_ITEM (ECTF_NAMELEN, "Buffer is too small to hold type name.") \
 213   _CTF_ITEM (ECTF_NOTYPE, "No type found corresponding to name.") \
 214   _CTF_ITEM (ECTF_SYNTAX, "Syntax error in type name.") \
 215   _CTF_ITEM (ECTF_NOTFUNC, "Symbol table entry or type is not a function.") \
 216   _CTF_ITEM (ECTF_NOFUNCDAT, "No function information available for function.") \
 217   _CTF_ITEM (ECTF_NOTDATA, "Symbol table entry does not refer to a data object.") \
 218   _CTF_ITEM (ECTF_NOTYPEDAT, "No type information available for symbol.") \
 219   _CTF_ITEM (ECTF_NOLABEL, "No label found corresponding to name.") \
 220   _CTF_ITEM (ECTF_NOLABELDATA, "File does not contain any labels.") \
 221   _CTF_ITEM (ECTF_NOTSUP, "Feature not supported.") \
 222   _CTF_ITEM (ECTF_NOENUMNAM, "Enum element name not found.") \
 223   _CTF_ITEM (ECTF_NOMEMBNAM, "Member name not found.") \
 224   _CTF_ITEM (ECTF_RDONLY, "CTF container is read-only.") \
 225   _CTF_ITEM (ECTF_DTFULL, "CTF type is full (no more members allowed).") \
 226   _CTF_ITEM (ECTF_FULL, "CTF container is full.") \
 227   _CTF_ITEM (ECTF_DUPLICATE, "Duplicate member or variable name.") \
 228   _CTF_ITEM (ECTF_CONFLICT, "Conflicting type is already defined.") \
 229   _CTF_ITEM (ECTF_OVERROLLBACK, "Attempt to roll back past a ctf_update.") \
 230   _CTF_ITEM (ECTF_COMPRESS, "Failed to compress CTF data.") \
 231   _CTF_ITEM (ECTF_ARCREATE, "Error creating CTF archive.") \
 232   _CTF_ITEM (ECTF_ARNNAME, "Name not found in CTF archive.") \
 233   _CTF_ITEM (ECTF_SLICEOVERFLOW, "Overflow of type bitness or offset in slice.") \
 234   _CTF_ITEM (ECTF_DUMPSECTUNKNOWN, "Unknown section number in dump.") \
 235   _CTF_ITEM (ECTF_DUMPSECTCHANGED, "Section changed in middle of dump.") \
 236   _CTF_ITEM (ECTF_NOTYET, "Feature not yet implemented.") \
 237   _CTF_ITEM (ECTF_INTERNAL, "Internal error: assertion failure.") \
 238   _CTF_ITEM (ECTF_NONREPRESENTABLE, "Type not representable in CTF.") \
 239   _CTF_ITEM (ECTF_NEXT_END, "End of iteration.") \
 240   _CTF_ITEM (ECTF_NEXT_WRONGFUN, "Wrong iteration function called.") \
 241   _CTF_ITEM (ECTF_NEXT_WRONGFP, "Iteration entity changed in mid-iterate.") \
 242   _CTF_ITEM (ECTF_FLAGS, "CTF header contains flags unknown to libctf.") \
 243   _CTF_ITEM (ECTF_NEEDSBFD, "This feature needs a libctf with BFD support.") \
 244   _CTF_ITEM (ECTF_INCOMPLETE, "Type is not a complete type.") \
 245   _CTF_ITEM (ECTF_NONAME, "Type name must not be empty.")
 246
 247 #define ECTF_BASE       1000    /* Base value for libctf errnos.  */
 248
 249 enum
 250   {
 251 #define _CTF_FIRST(NAME, STR) NAME = ECTF_BASE
 252 #define _CTF_ITEM(NAME, STR) , NAME
 253 _CTF_ERRORS
 254 #undef _CTF_ITEM
 255 #undef _CTF_FIRST
 256   };
 257
 258 #define ECTF_NERR (ECTF_NONAME - ECTF_BASE + 1) /* Count of CTF errors.  */
 259
 260 /* The CTF data model is inferred to be the caller's data model or the data
 261    model of the given object, unless ctf_setmodel is explicitly called.  */
 262 #define CTF_MODEL_ILP32 1       /* Object data model is ILP32.  */
 263 #define CTF_MODEL_LP64  2       /* Object data model is LP64.  */
 264 #ifdef _LP64
 265 # define CTF_MODEL_NATIVE CTF_MODEL_LP64
 266 #else
 267 # define CTF_MODEL_NATIVE CTF_MODEL_ILP32
 268 #endif
 269
 270 /* Dynamic CTF containers can be created using ctf_create.  The ctf_add_*
 271    routines can be used to add new definitions to the dynamic container.
 272    New types are labeled as root or non-root to determine whether they are
 273    visible at the top-level program scope when subsequently doing a lookup.  */
 274
 275 #define CTF_ADD_NONROOT 0       /* Type only visible in nested scope.  */
 276 #define CTF_ADD_ROOT    1       /* Type visible at top-level scope.  */
 277
 278 /* Flags for ctf_member_next.  */
 279
 280 #define CTF_MN_RECURSE 0x1      /* Recurse into unnamed members.  */
 281
 282 /* These typedefs are used to define the signature for callback functions that
 283    can be used with the iteration and visit functions below.  There is also a
 284    family of iteration functions that do not require callbacks.  */
 285
 286 typedef int ctf_visit_f (const char *name, ctf_id_t type, unsigned long offset,
 287                          int depth, void *arg);
 288 typedef int ctf_member_f (const char *name, ctf_id_t membtype,
 289                           unsigned long offset, void *arg);
 290 typedef int ctf_enum_f (const char *name, int val, void *arg);
 291 typedef int ctf_variable_f (const char *name, ctf_id_t type, void *arg);
 292 typedef int ctf_type_f (ctf_id_t type, void *arg);
 293 typedef int ctf_type_all_f (ctf_id_t type, int flag, void *arg);
 294 typedef int ctf_label_f (const char *name, const ctf_lblinfo_t *info,
 295                          void *arg);
 296 typedef int ctf_archive_member_f (ctf_dict_t *fp, const char *name, void *arg);
 297 typedef int ctf_archive_raw_member_f (const char *name, const void *content,
 298                                       size_t len, void *arg);
 299 typedef char *ctf_dump_decorate_f (ctf_sect_names_t sect,
 300                                    char *line, void *arg);
 301
 302 typedef struct ctf_dump_state ctf_dump_state_t;
 303
 304 /* Iteration state for the _next functions, and allocators/copiers/freers for
 305    it.  (None of these are needed for the simple case of iterating to the end:
 306    the _next function allocate and free the iterators for you.)  */
 307
 308 typedef struct ctf_next ctf_next_t;
 309 extern ctf_next_t *ctf_next_create (void);
 310 extern void ctf_next_destroy (ctf_next_t *);
 311 extern ctf_next_t *ctf_next_copy (ctf_next_t *);
 312
 313 /* Opening.  These mostly return an abstraction over both CTF files and CTF
 314    archives: so they can be used to open both.  CTF files will appear to be an
 315    archive with one member named '.ctf'.  The low-level functions
 316    ctf_simple_open and ctf_bufopen return ctf_dict_t's directly, and cannot
 317    be used on CTF archives.
 318
 319    Some of these functions take raw symtab and strtab section content in the
 320    form of ctf_sect_t structures.  For CTF in ELF files, these should be
 321    extracted from .dynsym and its associated string table (usually .dynsym)
 322    whenever the CTF_F_DYNSTR flag is set in the CTF preamble (which it almost
 323    always will be for linked objects, but not for .o files).  */
 324
 325 extern ctf_archive_t *ctf_bfdopen (struct bfd *, int *);
 326 extern ctf_archive_t *ctf_bfdopen_ctfsect (struct bfd *, const ctf_sect_t *,
 327                                            int *);
 328 extern ctf_archive_t *ctf_fdopen (int fd, const char *filename,
 329                                   const char *target, int *errp);
 330 extern ctf_archive_t *ctf_open (const char *filename,
 331                                 const char *target, int *errp);
 332 extern void ctf_close (ctf_archive_t *);
 333 extern ctf_sect_t ctf_getdatasect (const ctf_dict_t *);
 334 extern ctf_sect_t ctf_getsymsect (const ctf_dict_t *);
 335 extern ctf_sect_t ctf_getstrsect (const ctf_dict_t *);
 336 extern void ctf_symsect_endianness (ctf_dict_t *, int little_endian);
 337 extern ctf_archive_t *ctf_get_arc (const ctf_dict_t *);
 338 extern ctf_archive_t *ctf_arc_open (const char *, int *);
 339 extern ctf_archive_t *ctf_arc_bufopen (const ctf_sect_t *,
 340                                        const ctf_sect_t *,
 341                                        const ctf_sect_t *,
 342                                        int *);
 343 extern void ctf_arc_symsect_endianness (ctf_archive_t *, int little_endian);
 344 extern void ctf_arc_close (ctf_archive_t *);
 345 extern ctf_dict_t *ctf_arc_lookup_symbol (ctf_archive_t *,
 346                                           unsigned long symidx,
 347                                           ctf_id_t *, int *errp);
 348 extern ctf_dict_t *ctf_arc_lookup_symbol_name (ctf_archive_t *,
 349                                                const char *name,
 350                                                ctf_id_t *, int *errp);
 351 extern void ctf_arc_flush_caches (ctf_archive_t *);
 352 extern ctf_dict_t *ctf_dict_open (const ctf_archive_t *,
 353                                   const char *, int *);
 354 extern ctf_dict_t *ctf_dict_open_sections (const ctf_archive_t *,
 355                                            const ctf_sect_t *,
 356                                            const ctf_sect_t *,
 357                                            const char *, int *);
 358 extern size_t ctf_archive_count (const ctf_archive_t *);
 359
 360 /* The next functions return or close real CTF files, or write out CTF archives,
 361    not opaque containers around either.  */
 362
 363 extern ctf_dict_t *ctf_simple_open (const char *, size_t, const char *, size_t,
 364                                    size_t, const char *, size_t, int *);
 365 extern ctf_dict_t *ctf_bufopen (const ctf_sect_t *, const ctf_sect_t *,
 366                                 const ctf_sect_t *, int *);
 367 extern void ctf_ref (ctf_dict_t *);
 368 extern void ctf_dict_close (ctf_dict_t *);
 369
 370 extern int ctf_arc_write (const char *, ctf_dict_t **, size_t,
 371                           const char **, size_t);
 372 extern int ctf_arc_write_fd (int, ctf_dict_t **, size_t, const char **,
 373                              size_t);
 374
 375 extern const char *ctf_cuname (ctf_dict_t *);
 376 extern int ctf_cuname_set (ctf_dict_t *, const char *);
 377 extern ctf_dict_t *ctf_parent_dict (ctf_dict_t *);
 378 extern const char *ctf_parent_name (ctf_dict_t *);
 379 extern int ctf_parent_name_set (ctf_dict_t *, const char *);
 380 extern int ctf_type_isparent (ctf_dict_t *, ctf_id_t);
 381 extern int ctf_type_ischild (ctf_dict_t *, ctf_id_t);
 382
 383 extern int ctf_import (ctf_dict_t *, ctf_dict_t *);
 384 extern int ctf_setmodel (ctf_dict_t *, int);
 385 extern int ctf_getmodel (ctf_dict_t *);
 386
 387 extern void ctf_setspecific (ctf_dict_t *, void *);
 388 extern void *ctf_getspecific (ctf_dict_t *);
 389
 390 extern int ctf_errno (ctf_dict_t *);
 391 extern const char *ctf_errmsg (int);
 392 extern int ctf_version (int);
 393
 394 extern int ctf_func_info (ctf_dict_t *, unsigned long, ctf_funcinfo_t *);
 395 extern int ctf_func_args (ctf_dict_t *, unsigned long, uint32_t, ctf_id_t *);
 396 extern int ctf_func_type_info (ctf_dict_t *, ctf_id_t, ctf_funcinfo_t *);
 397 extern int ctf_func_type_args (ctf_dict_t *, ctf_id_t, uint32_t, ctf_id_t *);
 398
 399 extern ctf_id_t ctf_lookup_by_name (ctf_dict_t *, const char *);
 400 extern ctf_id_t ctf_lookup_by_symbol (ctf_dict_t *, unsigned long);
 401 extern ctf_id_t ctf_lookup_by_symbol_name (ctf_dict_t *, const char *);
 402 extern ctf_id_t ctf_symbol_next (ctf_dict_t *, ctf_next_t **,
 403                                  const char **name, int functions);
 404 extern ctf_id_t ctf_lookup_variable (ctf_dict_t *, const char *);
 405
 406 extern ctf_id_t ctf_type_resolve (ctf_dict_t *, ctf_id_t);
 407 extern char *ctf_type_aname (ctf_dict_t *, ctf_id_t);
 408 extern char *ctf_type_aname_raw (ctf_dict_t *, ctf_id_t);
 409 extern ssize_t ctf_type_lname (ctf_dict_t *, ctf_id_t, char *, size_t);
 410 extern char *ctf_type_name (ctf_dict_t *, ctf_id_t, char *, size_t);
 411 extern const char *ctf_type_name_raw (ctf_dict_t *, ctf_id_t);
 412 extern ssize_t ctf_type_size (ctf_dict_t *, ctf_id_t);
 413 extern ssize_t ctf_type_align (ctf_dict_t *, ctf_id_t);
 414 extern int ctf_type_kind (ctf_dict_t *, ctf_id_t);
 415 extern int ctf_type_kind_forwarded (ctf_dict_t *, ctf_id_t);
 416 extern ctf_id_t ctf_type_reference (ctf_dict_t *, ctf_id_t);
 417 extern ctf_id_t ctf_type_pointer (ctf_dict_t *, ctf_id_t);
 418 extern int ctf_type_encoding (ctf_dict_t *, ctf_id_t, ctf_encoding_t *);
 419 extern int ctf_type_visit (ctf_dict_t *, ctf_id_t, ctf_visit_f *, void *);
 420 extern int ctf_type_cmp (ctf_dict_t *, ctf_id_t, ctf_dict_t *, ctf_id_t);
 421 extern int ctf_type_compat (ctf_dict_t *, ctf_id_t, ctf_dict_t *, ctf_id_t);
 422
 423 extern int ctf_member_info (ctf_dict_t *, ctf_id_t, const char *,
 424                             ctf_membinfo_t *);
 425 extern int ctf_array_info (ctf_dict_t *, ctf_id_t, ctf_arinfo_t *);
 426
 427 extern const char *ctf_enum_name (ctf_dict_t *, ctf_id_t, int);
 428 extern int ctf_enum_value (ctf_dict_t *, ctf_id_t, const char *, int *);
 429
 430 extern void ctf_label_set (ctf_dict_t *, const char *);
 431 extern const char *ctf_label_get (ctf_dict_t *);
 432
 433 extern const char *ctf_label_topmost (ctf_dict_t *);
 434 extern int ctf_label_info (ctf_dict_t *, const char *, ctf_lblinfo_t *);
 435
 436 extern int ctf_member_count (ctf_dict_t *, ctf_id_t);
 437 extern int ctf_member_iter (ctf_dict_t *, ctf_id_t, ctf_member_f *, void *);
 438 extern ssize_t ctf_member_next (ctf_dict_t *, ctf_id_t, ctf_next_t **,
 439                                 const char **name, ctf_id_t *membtype,
 440                                 int flags);
 441 extern int ctf_enum_iter (ctf_dict_t *, ctf_id_t, ctf_enum_f *, void *);
 442 extern const char *ctf_enum_next (ctf_dict_t *, ctf_id_t, ctf_next_t **,
 443                                   int *);
 444 extern int ctf_type_iter (ctf_dict_t *, ctf_type_f *, void *);
 445 extern int ctf_type_iter_all (ctf_dict_t *, ctf_type_all_f *, void *);
 446 extern ctf_id_t ctf_type_next (ctf_dict_t *, ctf_next_t **,
 447                                int *flag, int want_hidden);
 448 extern int ctf_label_iter (ctf_dict_t *, ctf_label_f *, void *);
 449 extern int ctf_label_next (ctf_dict_t *, ctf_next_t **, const char **); /* TBD */
 450 extern int ctf_variable_iter (ctf_dict_t *, ctf_variable_f *, void *);
 451 extern ctf_id_t ctf_variable_next (ctf_dict_t *, ctf_next_t **,
 452                                    const char **);
 453 extern int ctf_archive_iter (const ctf_archive_t *, ctf_archive_member_f *,
 454                              void *);
 455 extern ctf_dict_t *ctf_archive_next (const ctf_archive_t *, ctf_next_t **,
 456                                      const char **, int skip_parent, int *errp);
 457
 458 /* This function alone does not currently operate on CTF files masquerading
 459    as archives, and returns -EINVAL: the raw data is no longer available.  It is
 460    expected to be used only by archiving tools, in any case, which have no need
 461    to deal with non-archives at all.  */
 462 extern int ctf_archive_raw_iter (const ctf_archive_t *,
 463                                  ctf_archive_raw_member_f *, void *);
 464 extern char *ctf_dump (ctf_dict_t *, ctf_dump_state_t **state,
 465                        ctf_sect_names_t sect, ctf_dump_decorate_f *,
 466                        void *arg);
 467
 468 /* Error-warning reporting: an 'iterator' that returns errors and warnings from
 469    the error/warning list, in order of emission.  Errors and warnings are popped
 470    after return: the caller must free the returned error-text pointer.  */
 471 extern char *ctf_errwarning_next (ctf_dict_t *, ctf_next_t **,
 472                                   int *is_warning, int *errp);
 473
 474 extern ctf_id_t ctf_add_array (ctf_dict_t *, uint32_t,
 475                                const ctf_arinfo_t *);
 476 extern ctf_id_t ctf_add_const (ctf_dict_t *, uint32_t, ctf_id_t);
 477 extern ctf_id_t ctf_add_enum_encoded (ctf_dict_t *, uint32_t, const char *,
 478                                       const ctf_encoding_t *);
 479 extern ctf_id_t ctf_add_enum (ctf_dict_t *, uint32_t, const char *);
 480 extern ctf_id_t ctf_add_float (ctf_dict_t *, uint32_t,
 481                                const char *, const ctf_encoding_t *);
 482 extern ctf_id_t ctf_add_forward (ctf_dict_t *, uint32_t, const char *,
 483                                  uint32_t);
 484 extern ctf_id_t ctf_add_function (ctf_dict_t *, uint32_t,
 485                                   const ctf_funcinfo_t *, const ctf_id_t *);
 486 extern ctf_id_t ctf_add_integer (ctf_dict_t *, uint32_t, const char *,
 487                                  const ctf_encoding_t *);
 488 extern ctf_id_t ctf_add_slice (ctf_dict_t *, uint32_t, ctf_id_t, const ctf_encoding_t *);
 489 extern ctf_id_t ctf_add_pointer (ctf_dict_t *, uint32_t, ctf_id_t);
 490 extern ctf_id_t ctf_add_type (ctf_dict_t *, ctf_dict_t *, ctf_id_t);
 491 extern ctf_id_t ctf_add_typedef (ctf_dict_t *, uint32_t, const char *,
 492                                  ctf_id_t);
 493 extern ctf_id_t ctf_add_restrict (ctf_dict_t *, uint32_t, ctf_id_t);
 494 extern ctf_id_t ctf_add_struct (ctf_dict_t *, uint32_t, const char *);
 495 extern ctf_id_t ctf_add_union (ctf_dict_t *, uint32_t, const char *);
 496 extern ctf_id_t ctf_add_struct_sized (ctf_dict_t *, uint32_t, const char *,
 497                                       size_t);
 498 extern ctf_id_t ctf_add_union_sized (ctf_dict_t *, uint32_t, const char *,
 499                                      size_t);
 500 extern ctf_id_t ctf_add_unknown (ctf_dict_t *, uint32_t, const char *);
 501 extern ctf_id_t ctf_add_volatile (ctf_dict_t *, uint32_t, ctf_id_t);
 502
 503 extern int ctf_add_enumerator (ctf_dict_t *, ctf_id_t, const char *, int);
 504 extern int ctf_add_member (ctf_dict_t *, ctf_id_t, const char *, ctf_id_t);
 505 extern int ctf_add_member_offset (ctf_dict_t *, ctf_id_t, const char *,
 506                                   ctf_id_t, unsigned long);
 507 extern int ctf_add_member_encoded (ctf_dict_t *, ctf_id_t, const char *,
 508                                    ctf_id_t, unsigned long,
 509                                    const ctf_encoding_t);
 510
 511 extern int ctf_add_variable (ctf_dict_t *, const char *, ctf_id_t);
 512
 513 extern int ctf_add_objt_sym (ctf_dict_t *, const char *, ctf_id_t);
 514 extern int ctf_add_func_sym (ctf_dict_t *, const char *, ctf_id_t);
 515
 516 extern int ctf_set_array (ctf_dict_t *, ctf_id_t, const ctf_arinfo_t *);
 517
 518 extern ctf_dict_t *ctf_create (int *);
 519 extern int ctf_update (ctf_dict_t *);
 520 extern ctf_snapshot_id_t ctf_snapshot (ctf_dict_t *);
 521 extern int ctf_rollback (ctf_dict_t *, ctf_snapshot_id_t);
 522 extern int ctf_discard (ctf_dict_t *);
 523 extern int ctf_write (ctf_dict_t *, int);
 524 extern int ctf_gzwrite (ctf_dict_t *fp, gzFile fd);
 525 extern int ctf_compress_write (ctf_dict_t * fp, int fd);
 526 extern unsigned char *ctf_write_mem (ctf_dict_t *, size_t *, size_t threshold);
 527
 528 extern int ctf_link_add_ctf (ctf_dict_t *, ctf_archive_t *, const char *);
 529 /* The variable filter should return nonzero if a variable should not
 530    appear in the output.  */
 531 typedef int ctf_link_variable_filter_f (ctf_dict_t *, const char *, ctf_id_t,
 532                                         void *);
 533 extern int ctf_link_set_variable_filter (ctf_dict_t *,
 534                                          ctf_link_variable_filter_f *, void *);
 535 extern int ctf_link (ctf_dict_t *, int flags);
 536 typedef const char *ctf_link_strtab_string_f (uint32_t *offset, void *arg);
 537 extern int ctf_link_add_strtab (ctf_dict_t *, ctf_link_strtab_string_f *,
 538                                 void *);
 539 extern int ctf_link_add_linker_symbol (ctf_dict_t *, ctf_link_sym_t *);
 540 extern int ctf_link_shuffle_syms (ctf_dict_t *);
 541 extern unsigned char *ctf_link_write (ctf_dict_t *, size_t *size,
 542                                       size_t threshold);
 543
 544 /* Specialist linker functions.  These functions are not used by ld, but can be
 545    used by other programs making use of the linker machinery for other purposes
 546    to customize its output.  */
 547 extern int ctf_link_add_cu_mapping (ctf_dict_t *, const char *from,
 548                                     const char *to);
 549 typedef char *ctf_link_memb_name_changer_f (ctf_dict_t *,
 550                                             const char *, void *);
 551 extern void ctf_link_set_memb_name_changer
 552   (ctf_dict_t *, ctf_link_memb_name_changer_f *, void *);
 553
 554 extern void ctf_setdebug (int debug);
 555 extern int ctf_getdebug (void);
 556
 557 /* Deprecated aliases for existing functions and types.  */
 558
 559 struct ctf_file;
 560 typedef struct ctf_dict ctf_file_t;
 561 extern void ctf_file_close (ctf_file_t *);
 562 extern ctf_dict_t *ctf_parent_file (ctf_dict_t *);
 563 extern ctf_dict_t *ctf_arc_open_by_name (const ctf_archive_t *,
 564                                          const char *, int *);
 565 extern ctf_dict_t *ctf_arc_open_by_name_sections (const ctf_archive_t *,
 566                                                   const ctf_sect_t *,
 567                                                   const ctf_sect_t *,
 568                                                   const char *, int *);
 569
 570 #ifdef  __cplusplus
 571 }
 572 #endif
 573
 574 #endif                          /* _CTF_API_H */