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