include/ctf-api.h

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