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