include/ctf-api.h

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