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