]>
Commit | Line | Data |
---|---|---|
b7e215a8 IB |
1 | /* CTF format description. |
2 | Copyright (C) 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 | #ifndef _CTF_H | |
21 | #define _CTF_H | |
22 | ||
23 | #include <sys/types.h> | |
24 | #include <limits.h> | |
25 | #include <stdint.h> | |
26 | ||
27 | ||
28 | #ifdef __cplusplus | |
29 | extern "C" | |
30 | { | |
31 | #endif | |
32 | ||
33 | /* CTF - Compact ANSI-C Type Format | |
34 | ||
35 | This file format can be used to compactly represent the information needed | |
36 | by a debugger to interpret the ANSI-C types used by a given program. | |
37 | Traditionally, this kind of information is generated by the compiler when | |
38 | invoked with the -g flag and is stored in "stabs" strings or in the more | |
39 | modern DWARF format. CTF provides a representation of only the information | |
40 | that is relevant to debugging a complex, optimized C program such as the | |
41 | operating system kernel in a form that is significantly more compact than | |
42 | the equivalent stabs or DWARF representation. The format is data-model | |
43 | independent, so consumers do not need different code depending on whether | |
44 | they are 32-bit or 64-bit programs; libctf automatically compensates for | |
45 | endianness variations. CTF assumes that a standard ELF symbol table is | |
46 | available for use in the debugger, and uses the structure and data of the | |
47 | symbol table to avoid storing redundant information. The CTF data may be | |
48 | compressed on disk or in memory, indicated by a bit in the header. CTF may | |
49 | be interpreted in a raw disk file, or it may be stored in an ELF section, | |
50 | typically named .ctf. Data structures are aligned so that a raw CTF file or | |
51 | CTF ELF section may be manipulated using mmap(2). | |
52 | ||
53 | The CTF file or section itself has the following structure: | |
54 | ||
55 | +--------+--------+---------+----------+--------+----------+... | |
56 | | file | type | data | function | object | function |... | |
57 | | header | labels | objects | info | index | index |... | |
58 | +--------+--------+---------+----------+--------+----------+... | |
59 | ||
60 | ...+----------+-------+--------+ | |
61 | ...| variable | data | string | | |
62 | ...| info | types | table | | |
63 | +----------+-------+--------+ | |
64 | ||
65 | The file header stores a magic number and version information, encoding | |
66 | flags, and the byte offset of each of the sections relative to the end of the | |
67 | header itself. If the CTF data has been uniquified against another set of | |
68 | CTF data, a reference to that data also appears in the the header. This | |
69 | reference is the name of the label corresponding to the types uniquified | |
70 | against. | |
71 | ||
72 | Following the header is a list of labels, used to group the types included in | |
73 | the data types section. Each label is accompanied by a type ID i. A given | |
74 | label refers to the group of types whose IDs are in the range [0, i]. | |
75 | ||
76 | Data object and function records (collectively, "symtypetabs") are stored in | |
77 | the same order as they appear in the corresponding symbol table, except that | |
78 | symbols marked SHN_UNDEF are not stored and symbols that have no type data | |
79 | are padded out with zeroes. For each entry in these tables, the type ID (a | |
80 | small integer) is recorded. (Functions get CTF_K_FUNCTION types, just like | |
81 | data objects that are function pointers.) | |
82 | ||
83 | For situations in which the order of the symbols in the symtab is not known, | |
84 | or most symbols have no type in this dict and most entries would be | |
85 | zero-pads, a pair of optional indexes follow the data object and function | |
86 | info sections: each of these is an array of strtab indexes, mapped 1:1 to the | |
87 | corresponding data object / function info section, giving each entry in those | |
88 | sections a name so that the linker can correlate them with final symtab | |
89 | entries and reorder them accordingly (dropping the indexes in the process). | |
90 | ||
91 | Variable records (as distinct from data objects) provide a modicum of support | |
92 | for non-ELF systems, mapping a variable name to a CTF type ID. The variable | |
93 | names are sorted into ASCIIbetical order, permitting binary searching. We do | |
94 | not define how the consumer maps these variable names to addresses or | |
95 | anything else, or indeed what these names represent: they might be names | |
96 | looked up at runtime via dlsym() or names extracted at runtime by a debugger | |
97 | or anything else the consumer likes. Variable records with identically- | |
98 | named entries in the data object section are removed. | |
99 | ||
100 | The data types section is a list of variable size records that represent each | |
101 | type, in order by their ID. The types themselves form a directed graph, | |
102 | where each node may contain one or more outgoing edges to other type nodes, | |
103 | denoted by their ID. Most type nodes are standalone or point backwards to | |
104 | earlier nodes, but this is not required: nodes can point to later nodes, | |
105 | particularly structure and union members. | |
106 | ||
107 | Strings are recorded as a string table ID (0 or 1) and a byte offset into the | |
108 | string table. String table 0 is the internal CTF string table. String table | |
109 | 1 is the external string table, which is the string table associated with the | |
110 | ELF dynamic symbol table for this object. CTF does not record any strings | |
111 | that are already in the symbol table, and the CTF string table does not | |
112 | contain any duplicated strings. | |
113 | ||
114 | If the CTF data has been merged with another parent CTF object, some outgoing | |
115 | edges may refer to type nodes that exist in another CTF object. The debugger | |
116 | and libctf library are responsible for connecting the appropriate objects | |
117 | together so that the full set of types can be explored and manipulated. | |
118 | ||
119 | This connection is done purely using the ctf_import() function. The | |
120 | ctf_archive machinery (and thus ctf_open et al) automatically imports archive | |
121 | members named ".ctf" into child dicts if available in the same archive, to | |
122 | match the relationship set up by the linker, but callers can call ctf_import | |
123 | themselves as well if need be, if they know a different relationship is in | |
124 | force. */ | |
125 | ||
126 | #define CTF_MAX_TYPE 0xfffffffe /* Max type identifier value. */ | |
127 | #define CTF_MAX_PTYPE 0x7fffffff /* Max parent type identifier value. */ | |
128 | #define CTF_MAX_NAME 0x7fffffff /* Max offset into a string table. */ | |
129 | #define CTF_MAX_VLEN 0xffffff /* Max struct, union, enum members or args. */ | |
130 | ||
131 | /* See ctf_type_t */ | |
132 | #define CTF_MAX_SIZE 0xfffffffe /* Max size of a v2 type in bytes. */ | |
133 | #define CTF_LSIZE_SENT 0xffffffff /* Sentinel for v2 ctt_size. */ | |
134 | ||
135 | /* Start of actual data structure definitions. | |
136 | ||
137 | Every field in these structures must have corresponding code in the | |
138 | endianness-swapping machinery in libctf/ctf-open.c. */ | |
139 | ||
140 | typedef struct ctf_preamble | |
141 | { | |
142 | unsigned short ctp_magic; /* Magic number (CTF_MAGIC). */ | |
143 | unsigned char ctp_version; /* Data format version number (CTF_VERSION). */ | |
144 | unsigned char ctp_flags; /* Flags (see below). */ | |
145 | } ctf_preamble_t; | |
146 | ||
147 | typedef struct ctf_header | |
148 | { | |
149 | ctf_preamble_t cth_preamble; | |
150 | uint32_t cth_parlabel; /* Ref to name of parent lbl uniq'd against. */ | |
151 | uint32_t cth_parname; /* Ref to basename of parent. */ | |
152 | uint32_t cth_cuname; /* Ref to CU name (may be 0). */ | |
153 | uint32_t cth_lbloff; /* Offset of label section. */ | |
154 | uint32_t cth_objtoff; /* Offset of object section. */ | |
155 | uint32_t cth_funcoff; /* Offset of function section. */ | |
156 | uint32_t cth_objtidxoff; /* Offset of object index section. */ | |
157 | uint32_t cth_funcidxoff; /* Offset of function index section. */ | |
158 | uint32_t cth_varoff; /* Offset of variable section. */ | |
159 | uint32_t cth_typeoff; /* Offset of type section. */ | |
160 | uint32_t cth_stroff; /* Offset of string section. */ | |
161 | uint32_t cth_strlen; /* Length of string section in bytes. */ | |
162 | } ctf_header_t; | |
163 | ||
164 | #define cth_magic cth_preamble.ctp_magic | |
165 | #define cth_version cth_preamble.ctp_version | |
166 | #define cth_flags cth_preamble.ctp_flags | |
167 | ||
168 | #define CTF_MAGIC 0xdff2 /* Magic number identifying header. */ | |
169 | ||
170 | /* Data format version number. */ | |
171 | ||
172 | /* v1 upgraded to a later version is not quite the same as the native form, | |
173 | because the boundary between parent and child types is different but not | |
174 | recorded anywhere, and you can write it out again via ctf_compress_write(), | |
175 | so we must track whether the thing was originally v1 or not. If we were | |
176 | writing the header from scratch, we would add a *pair* of version number | |
177 | fields to allow for this, but this will do for now. (A flag will not do, | |
178 | because we need to encode both the version we came from and the version we | |
179 | went to, not just "we were upgraded".) */ | |
180 | ||
181 | # define CTF_VERSION_1 1 | |
182 | # define CTF_VERSION_1_UPGRADED_3 2 | |
183 | # define CTF_VERSION_2 3 | |
184 | ||
185 | /* Note: some flags may be valid only in particular format versions. */ | |
186 | ||
187 | #define CTF_VERSION_3 4 | |
188 | #define CTF_VERSION CTF_VERSION_3 /* Current version. */ | |
189 | ||
190 | #define CTF_F_COMPRESS 0x1 /* Data buffer is compressed by libctf. */ | |
191 | #define CTF_F_NEWFUNCINFO 0x2 /* New v3 func info section format. */ | |
192 | ||
193 | typedef struct ctf_lblent | |
194 | { | |
195 | uint32_t ctl_label; /* Ref to name of label. */ | |
196 | uint32_t ctl_type; /* Last type associated with this label. */ | |
197 | } ctf_lblent_t; | |
198 | ||
199 | typedef struct ctf_varent | |
200 | { | |
201 | uint32_t ctv_name; /* Reference to name in string table. */ | |
202 | uint32_t ctv_type; /* Index of type of this variable. */ | |
203 | } ctf_varent_t; | |
204 | ||
205 | /* In format v2, type sizes, measured in bytes, come in two flavours. Nearly | |
206 | all of them fit into a (UINT_MAX - 1), and thus can be stored in the ctt_size | |
207 | member of a ctf_stype_t. The maximum value for these sizes is CTF_MAX_SIZE. | |
208 | Types larger than this must be stored in the ctf_lsize member of a | |
209 | ctf_type_t. Use of this member is indicated by the presence of | |
210 | CTF_LSIZE_SENT in ctt_size. */ | |
211 | ||
212 | typedef struct ctf_stype | |
213 | { | |
214 | uint32_t ctt_name; /* Reference to name in string table. */ | |
215 | uint32_t ctt_info; /* Encoded kind, variant length (see below). */ | |
216 | #ifndef __GNUC__ | |
217 | union | |
218 | { | |
219 | uint32_t _size; /* Size of entire type in bytes. */ | |
220 | uint32_t _type; /* Reference to another type. */ | |
221 | } _u; | |
222 | #else | |
223 | __extension__ | |
224 | union | |
225 | { | |
226 | uint32_t ctt_size; /* Size of entire type in bytes. */ | |
227 | uint32_t ctt_type; /* Reference to another type. */ | |
228 | }; | |
229 | #endif | |
230 | } ctf_stype_t; | |
231 | ||
232 | typedef struct ctf_type | |
233 | { | |
234 | uint32_t ctt_name; /* Reference to name in string table. */ | |
235 | uint32_t ctt_info; /* Encoded kind, variant length (see below). */ | |
236 | #ifndef __GNUC__ | |
237 | union | |
238 | { | |
239 | uint32_t _size; /* Always CTF_LSIZE_SENT. */ | |
240 | uint32_t _type; /* Do not use. */ | |
241 | } _u; | |
242 | #else | |
243 | __extension__ | |
244 | union | |
245 | { | |
246 | uint32_t ctt_size; /* Always CTF_LSIZE_SENT. */ | |
247 | uint32_t ctt_type; /* Do not use. */ | |
248 | }; | |
249 | #endif | |
250 | uint32_t ctt_lsizehi; /* High 32 bits of type size in bytes. */ | |
251 | uint32_t ctt_lsizelo; /* Low 32 bits of type size in bytes. */ | |
252 | } ctf_type_t; | |
253 | ||
254 | #ifndef __GNUC__ | |
255 | #define ctt_size _u._size /* For fundamental types that have a size. */ | |
256 | #define ctt_type _u._type /* For types that reference another type. */ | |
257 | #endif | |
258 | ||
259 | /* The following macros and inline functions compose and decompose values for | |
260 | ctt_info and ctt_name, as well as other structures that contain name | |
261 | references. Use outside libdtrace-ctf itself is explicitly for access to CTF | |
262 | files directly: types returned from the library will always appear to be | |
263 | CTF_V2. | |
264 | ||
265 | v1: (transparently upgraded to v2 at open time: may be compiled out of the | |
266 | library) | |
267 | ------------------------ | |
268 | ctt_info: | kind | isroot | vlen | | |
269 | ------------------------ | |
270 | 15 11 10 9 0 | |
271 | ||
272 | v2: | |
273 | ------------------------ | |
274 | ctt_info: | kind | isroot | vlen | | |
275 | ------------------------ | |
276 | 31 26 25 24 0 | |
277 | ||
278 | CTF_V1 and V2 _INFO_VLEN have the same interface: | |
279 | ||
280 | kind = CTF_*_INFO_KIND(c.ctt_info); <-- CTF_K_* value (see below) | |
281 | vlen = CTF_*_INFO_VLEN(fp, c.ctt_info); <-- length of variable data list | |
282 | ||
283 | stid = CTF_NAME_STID(c.ctt_name); <-- string table id number (0 or 1) | |
284 | offset = CTF_NAME_OFFSET(c.ctt_name); <-- string table byte offset | |
285 | ||
286 | c.ctt_info = CTF_TYPE_INFO(kind, vlen); | |
287 | c.ctt_name = CTF_TYPE_NAME(stid, offset); */ | |
288 | ||
289 | #define CTF_V1_INFO_KIND(info) (((info) & 0xf800) >> 11) | |
290 | #define CTF_V1_INFO_ISROOT(info) (((info) & 0x0400) >> 10) | |
291 | #define CTF_V1_INFO_VLEN(info) (((info) & CTF_MAX_VLEN_V1)) | |
292 | ||
293 | #define CTF_V2_INFO_KIND(info) (((info) & 0xfc000000) >> 26) | |
294 | #define CTF_V2_INFO_ISROOT(info) (((info) & 0x2000000) >> 25) | |
295 | #define CTF_V2_INFO_VLEN(info) (((info) & CTF_MAX_VLEN)) | |
296 | ||
297 | #define CTF_NAME_STID(name) ((name) >> 31) | |
298 | #define CTF_NAME_OFFSET(name) ((name) & CTF_MAX_NAME) | |
299 | #define CTF_SET_STID(name, stid) ((name) | ((unsigned int) stid) << 31) | |
300 | ||
301 | /* V2 only. */ | |
302 | #define CTF_TYPE_INFO(kind, isroot, vlen) \ | |
303 | (((kind) << 26) | (((isroot) ? 1 : 0) << 25) | ((vlen) & CTF_MAX_VLEN)) | |
304 | ||
305 | #define CTF_TYPE_NAME(stid, offset) \ | |
306 | (((stid) << 31) | ((offset) & CTF_MAX_NAME)) | |
307 | ||
308 | /* The next set of macros are for public consumption only. Not used internally, | |
309 | since the relevant type boundary is dependent upon the version of the file at | |
310 | *opening* time, not the version after transparent upgrade. Use | |
311 | ctf_type_isparent() / ctf_type_ischild() for that. */ | |
312 | ||
313 | #define CTF_V2_TYPE_ISPARENT(fp, id) ((id) <= CTF_MAX_PTYPE) | |
314 | #define CTF_V2_TYPE_ISCHILD(fp, id) ((id) > CTF_MAX_PTYPE) | |
315 | #define CTF_V2_TYPE_TO_INDEX(id) ((id) & CTF_MAX_PTYPE) | |
316 | #define CTF_V2_INDEX_TO_TYPE(id, child) ((child) ? ((id) | (CTF_MAX_PTYPE+1)) : (id)) | |
317 | ||
318 | #define CTF_V1_TYPE_ISPARENT(fp, id) ((id) <= CTF_MAX_PTYPE_V1) | |
319 | #define CTF_V1_TYPE_ISCHILD(fp, id) ((id) > CTF_MAX_PTYPE_V1) | |
320 | #define CTF_V1_TYPE_TO_INDEX(id) ((id) & CTF_MAX_PTYPE_V1) | |
321 | #define CTF_V1_INDEX_TO_TYPE(id, child) ((child) ? ((id) | (CTF_MAX_PTYPE_V1+1)) : (id)) | |
322 | ||
323 | /* Valid for both V1 and V2. */ | |
324 | #define CTF_TYPE_LSIZE(cttp) \ | |
325 | (((uint64_t)(cttp)->ctt_lsizehi) << 32 | (cttp)->ctt_lsizelo) | |
326 | #define CTF_SIZE_TO_LSIZE_HI(size) ((uint32_t)((uint64_t)(size) >> 32)) | |
327 | #define CTF_SIZE_TO_LSIZE_LO(size) ((uint32_t)(size)) | |
328 | ||
329 | #define CTF_STRTAB_0 0 /* String table id 0 (in-CTF). */ | |
330 | #define CTF_STRTAB_1 1 /* String table id 1 (ELF strtab). */ | |
331 | ||
332 | /* Values for CTF_TYPE_KIND(). If the kind has an associated data list, | |
333 | CTF_INFO_VLEN() will extract the number of elements in the list, and | |
334 | the type of each element is shown in the comments below. */ | |
335 | ||
336 | #define CTF_K_UNKNOWN 0 /* Unknown type (used for padding and | |
337 | unrepresentable types). */ | |
338 | #define CTF_K_INTEGER 1 /* Variant data is CTF_INT_DATA (see below). */ | |
339 | #define CTF_K_FLOAT 2 /* Variant data is CTF_FP_DATA (see below). */ | |
340 | #define CTF_K_POINTER 3 /* ctt_type is referenced type. */ | |
341 | #define CTF_K_ARRAY 4 /* Variant data is single ctf_array_t. */ | |
342 | #define CTF_K_FUNCTION 5 /* ctt_type is return type, variant data is | |
343 | list of argument types (unsigned short's for v1, | |
344 | uint32_t's for v2). */ | |
345 | #define CTF_K_STRUCT 6 /* Variant data is list of ctf_member_t's. */ | |
346 | #define CTF_K_UNION 7 /* Variant data is list of ctf_member_t's. */ | |
347 | #define CTF_K_ENUM 8 /* Variant data is list of ctf_enum_t's. */ | |
348 | #define CTF_K_FORWARD 9 /* No additional data; ctt_name is tag. */ | |
349 | #define CTF_K_TYPEDEF 10 /* ctt_type is referenced type. */ | |
350 | #define CTF_K_VOLATILE 11 /* ctt_type is base type. */ | |
351 | #define CTF_K_CONST 12 /* ctt_type is base type. */ | |
352 | #define CTF_K_RESTRICT 13 /* ctt_type is base type. */ | |
353 | #define CTF_K_SLICE 14 /* Variant data is a ctf_slice_t. */ | |
354 | ||
355 | #define CTF_K_MAX 63 /* Maximum possible (V2) CTF_K_* value. */ | |
356 | ||
357 | /* Values for ctt_type when kind is CTF_K_INTEGER. The flags, offset in bits, | |
358 | and size in bits are encoded as a single word using the following macros. | |
359 | (However, you can also encode the offset and bitness in a slice.) */ | |
360 | ||
361 | #define CTF_INT_ENCODING(data) (((data) & 0xff000000) >> 24) | |
362 | #define CTF_INT_OFFSET(data) (((data) & 0x00ff0000) >> 16) | |
363 | #define CTF_INT_BITS(data) (((data) & 0x0000ffff)) | |
364 | ||
365 | #define CTF_INT_DATA(encoding, offset, bits) \ | |
366 | (((encoding) << 24) | ((offset) << 16) | (bits)) | |
367 | ||
368 | #define CTF_INT_SIGNED 0x01 /* Integer is signed (otherwise unsigned). */ | |
369 | #define CTF_INT_CHAR 0x02 /* Character display format. */ | |
370 | #define CTF_INT_BOOL 0x04 /* Boolean display format. */ | |
371 | #define CTF_INT_VARARGS 0x08 /* Varargs display format. */ | |
372 | ||
373 | /* Use CTF_CHAR to produce a char that agrees with the system's native | |
374 | char signedness. */ | |
375 | #if CHAR_MIN == 0 | |
376 | # define CTF_CHAR (CTF_INT_CHAR) | |
377 | #else | |
378 | # define CTF_CHAR (CTF_INT_CHAR | CTF_INT_SIGNED) | |
379 | #endif | |
380 | ||
381 | /* Values for ctt_type when kind is CTF_K_FLOAT. The encoding, offset in bits, | |
382 | and size in bits are encoded as a single word using the following macros. | |
383 | (However, you can also encode the offset and bitness in a slice.) */ | |
384 | ||
385 | #define CTF_FP_ENCODING(data) (((data) & 0xff000000) >> 24) | |
386 | #define CTF_FP_OFFSET(data) (((data) & 0x00ff0000) >> 16) | |
387 | #define CTF_FP_BITS(data) (((data) & 0x0000ffff)) | |
388 | ||
389 | #define CTF_FP_DATA(encoding, offset, bits) \ | |
390 | (((encoding) << 24) | ((offset) << 16) | (bits)) | |
391 | ||
392 | /* Variant data when kind is CTF_K_FLOAT is an encoding in the top eight bits. */ | |
393 | #define CTF_FP_ENCODING(data) (((data) & 0xff000000) >> 24) | |
394 | ||
395 | #define CTF_FP_SINGLE 1 /* IEEE 32-bit float encoding. */ | |
396 | #define CTF_FP_DOUBLE 2 /* IEEE 64-bit float encoding. */ | |
397 | #define CTF_FP_CPLX 3 /* Complex encoding. */ | |
398 | #define CTF_FP_DCPLX 4 /* Double complex encoding. */ | |
399 | #define CTF_FP_LDCPLX 5 /* Long double complex encoding. */ | |
400 | #define CTF_FP_LDOUBLE 6 /* Long double encoding. */ | |
401 | #define CTF_FP_INTRVL 7 /* Interval (2x32-bit) encoding. */ | |
402 | #define CTF_FP_DINTRVL 8 /* Double interval (2x64-bit) encoding. */ | |
403 | #define CTF_FP_LDINTRVL 9 /* Long double interval (2x128-bit) encoding. */ | |
404 | #define CTF_FP_IMAGRY 10 /* Imaginary (32-bit) encoding. */ | |
405 | #define CTF_FP_DIMAGRY 11 /* Long imaginary (64-bit) encoding. */ | |
406 | #define CTF_FP_LDIMAGRY 12 /* Long double imaginary (128-bit) encoding. */ | |
407 | ||
408 | #define CTF_FP_MAX 12 /* Maximum possible CTF_FP_* value */ | |
409 | ||
410 | /* A slice increases the offset and reduces the bitness of the referenced | |
411 | ctt_type, which must be a type which has an encoding (fp, int, or enum). We | |
412 | also store the referenced type in here, because it is easier to keep the | |
413 | ctt_size correct for the slice than to shuffle the size into here and keep | |
414 | the ctt_type where it is for other types. | |
415 | ||
416 | In a future version, where we loosen requirements on alignment in the CTF | |
417 | file, the cts_offset and cts_bits will be chars: but for now they must be | |
418 | shorts or everything after a slice will become unaligned. */ | |
419 | ||
420 | typedef struct ctf_slice | |
421 | { | |
422 | uint32_t cts_type; | |
423 | unsigned short cts_offset; | |
424 | unsigned short cts_bits; | |
425 | } ctf_slice_t; | |
426 | ||
427 | typedef struct ctf_array | |
428 | { | |
429 | uint32_t cta_contents; /* Reference to type of array contents. */ | |
430 | uint32_t cta_index; /* Reference to type of array index. */ | |
431 | uint32_t cta_nelems; /* Number of elements. */ | |
432 | } ctf_array_t; | |
433 | ||
434 | /* Most structure members have bit offsets that can be expressed using a short. | |
435 | Some don't. ctf_member_t is used for structs which cannot contain any of | |
436 | these large offsets, whereas ctf_lmember_t is used in the latter case. If | |
437 | any member of a given struct has an offset that cannot be expressed using a | |
438 | uint32_t, all members will be stored as type ctf_lmember_t. This is expected | |
439 | to be very rare (but nonetheless possible). */ | |
440 | ||
441 | #define CTF_LSTRUCT_THRESH 536870912 | |
442 | ||
443 | typedef struct ctf_member_v2 | |
444 | { | |
445 | uint32_t ctm_name; /* Reference to name in string table. */ | |
446 | uint32_t ctm_offset; /* Offset of this member in bits. */ | |
447 | uint32_t ctm_type; /* Reference to type of member. */ | |
448 | } ctf_member_t; | |
449 | ||
450 | typedef struct ctf_lmember_v2 | |
451 | { | |
452 | uint32_t ctlm_name; /* Reference to name in string table. */ | |
453 | uint32_t ctlm_offsethi; /* High 32 bits of member offset in bits. */ | |
454 | uint32_t ctlm_type; /* Reference to type of member. */ | |
455 | uint32_t ctlm_offsetlo; /* Low 32 bits of member offset in bits. */ | |
456 | } ctf_lmember_t; | |
457 | ||
458 | #define CTF_LMEM_OFFSET(ctlmp) \ | |
459 | (((uint64_t)(ctlmp)->ctlm_offsethi) << 32 | (ctlmp)->ctlm_offsetlo) | |
460 | #define CTF_OFFSET_TO_LMEMHI(offset) ((uint32_t)((uint64_t)(offset) >> 32)) | |
461 | #define CTF_OFFSET_TO_LMEMLO(offset) ((uint32_t)(offset)) | |
462 | ||
463 | typedef struct ctf_enum | |
464 | { | |
465 | uint32_t cte_name; /* Reference to name in string table. */ | |
466 | int32_t cte_value; /* Value associated with this name. */ | |
467 | } ctf_enum_t; | |
468 | ||
469 | /* The ctf_archive is a collection of ctf_dict_t's stored together. The format | |
470 | is suitable for mmap()ing: this control structure merely describes the | |
471 | mmap()ed archive (and overlaps the first few bytes of it), hence the | |
472 | greater care taken with integral types. All CTF files in an archive | |
473 | must have the same data model. (This is not validated.) | |
474 | ||
475 | All integers in this structure are stored in little-endian byte order. | |
476 | ||
477 | The code relies on the fact that everything in this header is a uint64_t | |
478 | and thus the header needs no padding (in particular, that no padding is | |
479 | needed between ctfa_ctfs and the unnamed ctfa_archive_modent array | |
480 | that follows it). | |
481 | ||
482 | This is *not* the same as the data structure returned by the ctf_arc_*() | |
483 | functions: this is the low-level on-disk representation. */ | |
484 | ||
485 | #define CTFA_MAGIC 0x8b47f2a4d7623eeb /* Random. */ | |
486 | struct ctf_archive | |
487 | { | |
488 | /* Magic number. (In loaded files, overwritten with the file size | |
489 | so ctf_arc_close() knows how much to munmap()). */ | |
490 | uint64_t ctfa_magic; | |
491 | ||
492 | /* CTF data model. */ | |
493 | uint64_t ctfa_model; | |
494 | ||
495 | /* Number of CTF dicts in the archive. */ | |
496 | uint64_t ctfa_ndicts; | |
497 | ||
498 | /* Offset of the name table. */ | |
499 | uint64_t ctfa_names; | |
500 | ||
501 | /* Offset of the CTF table. Each element starts with a size (a uint64_t | |
502 | in network byte order) then a ctf_dict_t of that size. */ | |
503 | uint64_t ctfa_ctfs; | |
504 | }; | |
505 | ||
506 | /* An array of ctfa_nnamed of this structure lies at | |
507 | ctf_archive[ctf_archive->ctfa_modents] and gives the ctfa_ctfs or | |
508 | ctfa_names-relative offsets of each name or ctf_dict_t. */ | |
509 | ||
510 | typedef struct ctf_archive_modent | |
511 | { | |
512 | uint64_t name_offset; | |
513 | uint64_t ctf_offset; | |
514 | } ctf_archive_modent_t; | |
515 | ||
516 | #ifdef __cplusplus | |
517 | } | |
518 | #endif | |
519 | ||
520 | #endif /* _CTF_H */ |