| /* CTF format description. |
| Copyright (C) 2021-2022 Free Software Foundation, Inc. |
| |
| This file is part of libctf. |
| |
| libctf is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| This program is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; see the file COPYING. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #ifndef _CTF_H |
| #define _CTF_H |
| |
| #include <sys/types.h> |
| #include <limits.h> |
| #include <stdint.h> |
| |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| /* CTF - Compact ANSI-C Type Format |
| |
| This file format can be used to compactly represent the information needed |
| by a debugger to interpret the ANSI-C types used by a given program. |
| Traditionally, this kind of information is generated by the compiler when |
| invoked with the -g flag and is stored in "stabs" strings or in the more |
| modern DWARF format. CTF provides a representation of only the information |
| that is relevant to debugging a complex, optimized C program such as the |
| operating system kernel in a form that is significantly more compact than |
| the equivalent stabs or DWARF representation. The format is data-model |
| independent, so consumers do not need different code depending on whether |
| they are 32-bit or 64-bit programs; libctf automatically compensates for |
| endianness variations. CTF assumes that a standard ELF symbol table is |
| available for use in the debugger, and uses the structure and data of the |
| symbol table to avoid storing redundant information. The CTF data may be |
| compressed on disk or in memory, indicated by a bit in the header. CTF may |
| be interpreted in a raw disk file, or it may be stored in an ELF section, |
| typically named .ctf. Data structures are aligned so that a raw CTF file or |
| CTF ELF section may be manipulated using mmap(2). |
| |
| The CTF file or section itself has the following structure: |
| |
| +--------+--------+---------+----------+--------+----------+... |
| | file | type | data | function | object | function |... |
| | header | labels | objects | info | index | index |... |
| +--------+--------+---------+----------+--------+----------+... |
| |
| ...+----------+-------+--------+ |
| ...| variable | data | string | |
| ...| info | types | table | |
| +----------+-------+--------+ |
| |
| The file header stores a magic number and version information, encoding |
| flags, and the byte offset of each of the sections relative to the end of the |
| header itself. If the CTF data has been uniquified against another set of |
| CTF data, a reference to that data also appears in the the header. This |
| reference is the name of the label corresponding to the types uniquified |
| against. |
| |
| Following the header is a list of labels, used to group the types included in |
| the data types section. Each label is accompanied by a type ID i. A given |
| label refers to the group of types whose IDs are in the range [0, i]. |
| |
| Data object and function records (collectively, "symtypetabs") are stored in |
| the same order as they appear in the corresponding symbol table, except that |
| symbols marked SHN_UNDEF are not stored and symbols that have no type data |
| are padded out with zeroes. For each entry in these tables, the type ID (a |
| small integer) is recorded. (Functions get CTF_K_FUNCTION types, just like |
| data objects that are function pointers.) |
| |
| For situations in which the order of the symbols in the symtab is not known, |
| or most symbols have no type in this dict and most entries would be |
| zero-pads, a pair of optional indexes follow the data object and function |
| info sections: each of these is an array of strtab indexes, mapped 1:1 to the |
| corresponding data object / function info section, giving each entry in those |
| sections a name so that the linker can correlate them with final symtab |
| entries and reorder them accordingly (dropping the indexes in the process). |
| |
| Variable records (as distinct from data objects) provide a modicum of support |
| for non-ELF systems, mapping a variable name to a CTF type ID. The variable |
| names are sorted into ASCIIbetical order, permitting binary searching. We do |
| not define how the consumer maps these variable names to addresses or |
| anything else, or indeed what these names represent: they might be names |
| looked up at runtime via dlsym() or names extracted at runtime by a debugger |
| or anything else the consumer likes. Variable records with identically- |
| named entries in the data object section are removed. |
| |
| The data types section is a list of variable size records that represent each |
| type, in order by their ID. The types themselves form a directed graph, |
| where each node may contain one or more outgoing edges to other type nodes, |
| denoted by their ID. Most type nodes are standalone or point backwards to |
| earlier nodes, but this is not required: nodes can point to later nodes, |
| particularly structure and union members. |
| |
| Strings are recorded as a string table ID (0 or 1) and a byte offset into the |
| string table. String table 0 is the internal CTF string table. String table |
| 1 is the external string table, which is the string table associated with the |
| ELF dynamic symbol table for this object. CTF does not record any strings |
| that are already in the symbol table, and the CTF string table does not |
| contain any duplicated strings. |
| |
| If the CTF data has been merged with another parent CTF object, some outgoing |
| edges may refer to type nodes that exist in another CTF object. The debugger |
| and libctf library are responsible for connecting the appropriate objects |
| together so that the full set of types can be explored and manipulated. |
| |
| This connection is done purely using the ctf_import() function. The |
| ctf_archive machinery (and thus ctf_open et al) automatically imports archive |
| members named ".ctf" into child dicts if available in the same archive, to |
| match the relationship set up by the linker, but callers can call ctf_import |
| themselves as well if need be, if they know a different relationship is in |
| force. */ |
| |
| #define CTF_MAX_TYPE 0xfffffffe /* Max type identifier value. */ |
| #define CTF_MAX_PTYPE 0x7fffffff /* Max parent type identifier value. */ |
| #define CTF_MAX_NAME 0x7fffffff /* Max offset into a string table. */ |
| #define CTF_MAX_VLEN 0xffffff /* Max struct, union, enum members or args. */ |
| |
| /* See ctf_type_t */ |
| #define CTF_MAX_SIZE 0xfffffffe /* Max size of a v2 type in bytes. */ |
| #define CTF_LSIZE_SENT 0xffffffff /* Sentinel for v2 ctt_size. */ |
| |
| /* Start of actual data structure definitions. |
| |
| Every field in these structures must have corresponding code in the |
| endianness-swapping machinery in libctf/ctf-open.c. */ |
| |
| typedef struct ctf_preamble |
| { |
| unsigned short ctp_magic; /* Magic number (CTF_MAGIC). */ |
| unsigned char ctp_version; /* Data format version number (CTF_VERSION). */ |
| unsigned char ctp_flags; /* Flags (see below). */ |
| } ctf_preamble_t; |
| |
| typedef struct ctf_header |
| { |
| ctf_preamble_t cth_preamble; |
| uint32_t cth_parlabel; /* Ref to name of parent lbl uniq'd against. */ |
| uint32_t cth_parname; /* Ref to basename of parent. */ |
| uint32_t cth_cuname; /* Ref to CU name (may be 0). */ |
| uint32_t cth_lbloff; /* Offset of label section. */ |
| uint32_t cth_objtoff; /* Offset of object section. */ |
| uint32_t cth_funcoff; /* Offset of function section. */ |
| uint32_t cth_objtidxoff; /* Offset of object index section. */ |
| uint32_t cth_funcidxoff; /* Offset of function index section. */ |
| uint32_t cth_varoff; /* Offset of variable section. */ |
| uint32_t cth_typeoff; /* Offset of type section. */ |
| uint32_t cth_stroff; /* Offset of string section. */ |
| uint32_t cth_strlen; /* Length of string section in bytes. */ |
| } ctf_header_t; |
| |
| #define cth_magic cth_preamble.ctp_magic |
| #define cth_version cth_preamble.ctp_version |
| #define cth_flags cth_preamble.ctp_flags |
| |
| #define CTF_MAGIC 0xdff2 /* Magic number identifying header. */ |
| |
| /* Data format version number. */ |
| |
| /* v1 upgraded to a later version is not quite the same as the native form, |
| because the boundary between parent and child types is different but not |
| recorded anywhere, and you can write it out again via ctf_compress_write(), |
| so we must track whether the thing was originally v1 or not. If we were |
| writing the header from scratch, we would add a *pair* of version number |
| fields to allow for this, but this will do for now. (A flag will not do, |
| because we need to encode both the version we came from and the version we |
| went to, not just "we were upgraded".) */ |
| |
| # define CTF_VERSION_1 1 |
| # define CTF_VERSION_1_UPGRADED_3 2 |
| # define CTF_VERSION_2 3 |
| |
| /* Note: some flags may be valid only in particular format versions. */ |
| |
| #define CTF_VERSION_3 4 |
| #define CTF_VERSION CTF_VERSION_3 /* Current version. */ |
| |
| #define CTF_F_COMPRESS 0x1 /* Data buffer is compressed by libctf. */ |
| #define CTF_F_NEWFUNCINFO 0x2 /* New v3 func info section format. */ |
| |
| typedef struct ctf_lblent |
| { |
| uint32_t ctl_label; /* Ref to name of label. */ |
| uint32_t ctl_type; /* Last type associated with this label. */ |
| } ctf_lblent_t; |
| |
| typedef struct ctf_varent |
| { |
| uint32_t ctv_name; /* Reference to name in string table. */ |
| uint32_t ctv_type; /* Index of type of this variable. */ |
| } ctf_varent_t; |
| |
| /* In format v2, type sizes, measured in bytes, come in two flavours. Nearly |
| all of them fit into a (UINT_MAX - 1), and thus can be stored in the ctt_size |
| member of a ctf_stype_t. The maximum value for these sizes is CTF_MAX_SIZE. |
| Types larger than this must be stored in the ctf_lsize member of a |
| ctf_type_t. Use of this member is indicated by the presence of |
| CTF_LSIZE_SENT in ctt_size. */ |
| |
| typedef struct ctf_stype |
| { |
| uint32_t ctt_name; /* Reference to name in string table. */ |
| uint32_t ctt_info; /* Encoded kind, variant length (see below). */ |
| #ifndef __GNUC__ |
| union |
| { |
| uint32_t _size; /* Size of entire type in bytes. */ |
| uint32_t _type; /* Reference to another type. */ |
| } _u; |
| #else |
| __extension__ |
| union |
| { |
| uint32_t ctt_size; /* Size of entire type in bytes. */ |
| uint32_t ctt_type; /* Reference to another type. */ |
| }; |
| #endif |
| } ctf_stype_t; |
| |
| typedef struct ctf_type |
| { |
| uint32_t ctt_name; /* Reference to name in string table. */ |
| uint32_t ctt_info; /* Encoded kind, variant length (see below). */ |
| #ifndef __GNUC__ |
| union |
| { |
| uint32_t _size; /* Always CTF_LSIZE_SENT. */ |
| uint32_t _type; /* Do not use. */ |
| } _u; |
| #else |
| __extension__ |
| union |
| { |
| uint32_t ctt_size; /* Always CTF_LSIZE_SENT. */ |
| uint32_t ctt_type; /* Do not use. */ |
| }; |
| #endif |
| uint32_t ctt_lsizehi; /* High 32 bits of type size in bytes. */ |
| uint32_t ctt_lsizelo; /* Low 32 bits of type size in bytes. */ |
| } ctf_type_t; |
| |
| #ifndef __GNUC__ |
| #define ctt_size _u._size /* For fundamental types that have a size. */ |
| #define ctt_type _u._type /* For types that reference another type. */ |
| #endif |
| |
| /* The following macros and inline functions compose and decompose values for |
| ctt_info and ctt_name, as well as other structures that contain name |
| references. Use outside libdtrace-ctf itself is explicitly for access to CTF |
| files directly: types returned from the library will always appear to be |
| CTF_V2. |
| |
| v1: (transparently upgraded to v2 at open time: may be compiled out of the |
| library) |
| ------------------------ |
| ctt_info: | kind | isroot | vlen | |
| ------------------------ |
| 15 11 10 9 0 |
| |
| v2: |
| ------------------------ |
| ctt_info: | kind | isroot | vlen | |
| ------------------------ |
| 31 26 25 24 0 |
| |
| CTF_V1 and V2 _INFO_VLEN have the same interface: |
| |
| kind = CTF_*_INFO_KIND(c.ctt_info); <-- CTF_K_* value (see below) |
| vlen = CTF_*_INFO_VLEN(fp, c.ctt_info); <-- length of variable data list |
| |
| stid = CTF_NAME_STID(c.ctt_name); <-- string table id number (0 or 1) |
| offset = CTF_NAME_OFFSET(c.ctt_name); <-- string table byte offset |
| |
| c.ctt_info = CTF_TYPE_INFO(kind, vlen); |
| c.ctt_name = CTF_TYPE_NAME(stid, offset); */ |
| |
| #define CTF_V1_INFO_KIND(info) (((info) & 0xf800) >> 11) |
| #define CTF_V1_INFO_ISROOT(info) (((info) & 0x0400) >> 10) |
| #define CTF_V1_INFO_VLEN(info) (((info) & CTF_MAX_VLEN_V1)) |
| |
| #define CTF_V2_INFO_KIND(info) (((info) & 0xfc000000) >> 26) |
| #define CTF_V2_INFO_ISROOT(info) (((info) & 0x2000000) >> 25) |
| #define CTF_V2_INFO_VLEN(info) (((info) & CTF_MAX_VLEN)) |
| |
| #define CTF_NAME_STID(name) ((name) >> 31) |
| #define CTF_NAME_OFFSET(name) ((name) & CTF_MAX_NAME) |
| #define CTF_SET_STID(name, stid) ((name) | ((unsigned int) stid) << 31) |
| |
| /* V2 only. */ |
| #define CTF_TYPE_INFO(kind, isroot, vlen) \ |
| (((kind) << 26) | (((isroot) ? 1 : 0) << 25) | ((vlen) & CTF_MAX_VLEN)) |
| |
| #define CTF_TYPE_NAME(stid, offset) \ |
| (((stid) << 31) | ((offset) & CTF_MAX_NAME)) |
| |
| /* The next set of macros are for public consumption only. Not used internally, |
| since the relevant type boundary is dependent upon the version of the file at |
| *opening* time, not the version after transparent upgrade. Use |
| ctf_type_isparent() / ctf_type_ischild() for that. */ |
| |
| #define CTF_V2_TYPE_ISPARENT(fp, id) ((id) <= CTF_MAX_PTYPE) |
| #define CTF_V2_TYPE_ISCHILD(fp, id) ((id) > CTF_MAX_PTYPE) |
| #define CTF_V2_TYPE_TO_INDEX(id) ((id) & CTF_MAX_PTYPE) |
| #define CTF_V2_INDEX_TO_TYPE(id, child) ((child) ? ((id) | (CTF_MAX_PTYPE+1)) : (id)) |
| |
| #define CTF_V1_TYPE_ISPARENT(fp, id) ((id) <= CTF_MAX_PTYPE_V1) |
| #define CTF_V1_TYPE_ISCHILD(fp, id) ((id) > CTF_MAX_PTYPE_V1) |
| #define CTF_V1_TYPE_TO_INDEX(id) ((id) & CTF_MAX_PTYPE_V1) |
| #define CTF_V1_INDEX_TO_TYPE(id, child) ((child) ? ((id) | (CTF_MAX_PTYPE_V1+1)) : (id)) |
| |
| /* Valid for both V1 and V2. */ |
| #define CTF_TYPE_LSIZE(cttp) \ |
| (((uint64_t)(cttp)->ctt_lsizehi) << 32 | (cttp)->ctt_lsizelo) |
| #define CTF_SIZE_TO_LSIZE_HI(size) ((uint32_t)((uint64_t)(size) >> 32)) |
| #define CTF_SIZE_TO_LSIZE_LO(size) ((uint32_t)(size)) |
| |
| #define CTF_STRTAB_0 0 /* String table id 0 (in-CTF). */ |
| #define CTF_STRTAB_1 1 /* String table id 1 (ELF strtab). */ |
| |
| /* Values for CTF_TYPE_KIND(). If the kind has an associated data list, |
| CTF_INFO_VLEN() will extract the number of elements in the list, and |
| the type of each element is shown in the comments below. */ |
| |
| #define CTF_K_UNKNOWN 0 /* Unknown type (used for padding and |
| unrepresentable types). */ |
| #define CTF_K_INTEGER 1 /* Variant data is CTF_INT_DATA (see below). */ |
| #define CTF_K_FLOAT 2 /* Variant data is CTF_FP_DATA (see below). */ |
| #define CTF_K_POINTER 3 /* ctt_type is referenced type. */ |
| #define CTF_K_ARRAY 4 /* Variant data is single ctf_array_t. */ |
| #define CTF_K_FUNCTION 5 /* ctt_type is return type, variant data is |
| list of argument types (unsigned short's for v1, |
| uint32_t's for v2). */ |
| #define CTF_K_STRUCT 6 /* Variant data is list of ctf_member_t's. */ |
| #define CTF_K_UNION 7 /* Variant data is list of ctf_member_t's. */ |
| #define CTF_K_ENUM 8 /* Variant data is list of ctf_enum_t's. */ |
| #define CTF_K_FORWARD 9 /* No additional data; ctt_name is tag. */ |
| #define CTF_K_TYPEDEF 10 /* ctt_type is referenced type. */ |
| #define CTF_K_VOLATILE 11 /* ctt_type is base type. */ |
| #define CTF_K_CONST 12 /* ctt_type is base type. */ |
| #define CTF_K_RESTRICT 13 /* ctt_type is base type. */ |
| #define CTF_K_SLICE 14 /* Variant data is a ctf_slice_t. */ |
| |
| #define CTF_K_MAX 63 /* Maximum possible (V2) CTF_K_* value. */ |
| |
| /* Values for ctt_type when kind is CTF_K_INTEGER. The flags, offset in bits, |
| and size in bits are encoded as a single word using the following macros. |
| (However, you can also encode the offset and bitness in a slice.) */ |
| |
| #define CTF_INT_ENCODING(data) (((data) & 0xff000000) >> 24) |
| #define CTF_INT_OFFSET(data) (((data) & 0x00ff0000) >> 16) |
| #define CTF_INT_BITS(data) (((data) & 0x0000ffff)) |
| |
| #define CTF_INT_DATA(encoding, offset, bits) \ |
| (((encoding) << 24) | ((offset) << 16) | (bits)) |
| |
| #define CTF_INT_SIGNED 0x01 /* Integer is signed (otherwise unsigned). */ |
| #define CTF_INT_CHAR 0x02 /* Character display format. */ |
| #define CTF_INT_BOOL 0x04 /* Boolean display format. */ |
| #define CTF_INT_VARARGS 0x08 /* Varargs display format. */ |
| |
| /* Use CTF_CHAR to produce a char that agrees with the system's native |
| char signedness. */ |
| #if CHAR_MIN == 0 |
| # define CTF_CHAR (CTF_INT_CHAR) |
| #else |
| # define CTF_CHAR (CTF_INT_CHAR | CTF_INT_SIGNED) |
| #endif |
| |
| /* Values for ctt_type when kind is CTF_K_FLOAT. The encoding, offset in bits, |
| and size in bits are encoded as a single word using the following macros. |
| (However, you can also encode the offset and bitness in a slice.) */ |
| |
| #define CTF_FP_ENCODING(data) (((data) & 0xff000000) >> 24) |
| #define CTF_FP_OFFSET(data) (((data) & 0x00ff0000) >> 16) |
| #define CTF_FP_BITS(data) (((data) & 0x0000ffff)) |
| |
| #define CTF_FP_DATA(encoding, offset, bits) \ |
| (((encoding) << 24) | ((offset) << 16) | (bits)) |
| |
| /* Variant data when kind is CTF_K_FLOAT is an encoding in the top eight bits. */ |
| #define CTF_FP_ENCODING(data) (((data) & 0xff000000) >> 24) |
| |
| #define CTF_FP_SINGLE 1 /* IEEE 32-bit float encoding. */ |
| #define CTF_FP_DOUBLE 2 /* IEEE 64-bit float encoding. */ |
| #define CTF_FP_CPLX 3 /* Complex encoding. */ |
| #define CTF_FP_DCPLX 4 /* Double complex encoding. */ |
| #define CTF_FP_LDCPLX 5 /* Long double complex encoding. */ |
| #define CTF_FP_LDOUBLE 6 /* Long double encoding. */ |
| #define CTF_FP_INTRVL 7 /* Interval (2x32-bit) encoding. */ |
| #define CTF_FP_DINTRVL 8 /* Double interval (2x64-bit) encoding. */ |
| #define CTF_FP_LDINTRVL 9 /* Long double interval (2x128-bit) encoding. */ |
| #define CTF_FP_IMAGRY 10 /* Imaginary (32-bit) encoding. */ |
| #define CTF_FP_DIMAGRY 11 /* Long imaginary (64-bit) encoding. */ |
| #define CTF_FP_LDIMAGRY 12 /* Long double imaginary (128-bit) encoding. */ |
| |
| #define CTF_FP_MAX 12 /* Maximum possible CTF_FP_* value */ |
| |
| /* A slice increases the offset and reduces the bitness of the referenced |
| ctt_type, which must be a type which has an encoding (fp, int, or enum). We |
| also store the referenced type in here, because it is easier to keep the |
| ctt_size correct for the slice than to shuffle the size into here and keep |
| the ctt_type where it is for other types. |
| |
| In a future version, where we loosen requirements on alignment in the CTF |
| file, the cts_offset and cts_bits will be chars: but for now they must be |
| shorts or everything after a slice will become unaligned. */ |
| |
| typedef struct ctf_slice |
| { |
| uint32_t cts_type; |
| unsigned short cts_offset; |
| unsigned short cts_bits; |
| } ctf_slice_t; |
| |
| typedef struct ctf_array |
| { |
| uint32_t cta_contents; /* Reference to type of array contents. */ |
| uint32_t cta_index; /* Reference to type of array index. */ |
| uint32_t cta_nelems; /* Number of elements. */ |
| } ctf_array_t; |
| |
| /* Most structure members have bit offsets that can be expressed using a short. |
| Some don't. ctf_member_t is used for structs which cannot contain any of |
| these large offsets, whereas ctf_lmember_t is used in the latter case. If |
| any member of a given struct has an offset that cannot be expressed using a |
| uint32_t, all members will be stored as type ctf_lmember_t. This is expected |
| to be very rare (but nonetheless possible). */ |
| |
| #define CTF_LSTRUCT_THRESH 536870912 |
| |
| typedef struct ctf_member_v2 |
| { |
| uint32_t ctm_name; /* Reference to name in string table. */ |
| uint32_t ctm_offset; /* Offset of this member in bits. */ |
| uint32_t ctm_type; /* Reference to type of member. */ |
| } ctf_member_t; |
| |
| typedef struct ctf_lmember_v2 |
| { |
| uint32_t ctlm_name; /* Reference to name in string table. */ |
| uint32_t ctlm_offsethi; /* High 32 bits of member offset in bits. */ |
| uint32_t ctlm_type; /* Reference to type of member. */ |
| uint32_t ctlm_offsetlo; /* Low 32 bits of member offset in bits. */ |
| } ctf_lmember_t; |
| |
| #define CTF_LMEM_OFFSET(ctlmp) \ |
| (((uint64_t)(ctlmp)->ctlm_offsethi) << 32 | (ctlmp)->ctlm_offsetlo) |
| #define CTF_OFFSET_TO_LMEMHI(offset) ((uint32_t)((uint64_t)(offset) >> 32)) |
| #define CTF_OFFSET_TO_LMEMLO(offset) ((uint32_t)(offset)) |
| |
| typedef struct ctf_enum |
| { |
| uint32_t cte_name; /* Reference to name in string table. */ |
| int32_t cte_value; /* Value associated with this name. */ |
| } ctf_enum_t; |
| |
| /* The ctf_archive is a collection of ctf_dict_t's stored together. The format |
| is suitable for mmap()ing: this control structure merely describes the |
| mmap()ed archive (and overlaps the first few bytes of it), hence the |
| greater care taken with integral types. All CTF files in an archive |
| must have the same data model. (This is not validated.) |
| |
| All integers in this structure are stored in little-endian byte order. |
| |
| The code relies on the fact that everything in this header is a uint64_t |
| and thus the header needs no padding (in particular, that no padding is |
| needed between ctfa_ctfs and the unnamed ctfa_archive_modent array |
| that follows it). |
| |
| This is *not* the same as the data structure returned by the ctf_arc_*() |
| functions: this is the low-level on-disk representation. */ |
| |
| #define CTFA_MAGIC 0x8b47f2a4d7623eeb /* Random. */ |
| struct ctf_archive |
| { |
| /* Magic number. (In loaded files, overwritten with the file size |
| so ctf_arc_close() knows how much to munmap()). */ |
| uint64_t ctfa_magic; |
| |
| /* CTF data model. */ |
| uint64_t ctfa_model; |
| |
| /* Number of CTF dicts in the archive. */ |
| uint64_t ctfa_ndicts; |
| |
| /* Offset of the name table. */ |
| uint64_t ctfa_names; |
| |
| /* Offset of the CTF table. Each element starts with a size (a uint64_t |
| in network byte order) then a ctf_dict_t of that size. */ |
| uint64_t ctfa_ctfs; |
| }; |
| |
| /* An array of ctfa_nnamed of this structure lies at |
| ctf_archive[ctf_archive->ctfa_modents] and gives the ctfa_ctfs or |
| ctfa_names-relative offsets of each name or ctf_dict_t. */ |
| |
| typedef struct ctf_archive_modent |
| { |
| uint64_t name_offset; |
| uint64_t ctf_offset; |
| } ctf_archive_modent_t; |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* _CTF_H */ |