Commit | Line | Data |
---|---|---|
30d1f018 WP |
1 | /* Compact ANSI-C Type Format (CTF) support in GDB. |
2 | ||
3 | Copyright (C) 2019 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
19 | ||
20 | /* This file format can be used to compactly represent the information needed | |
21 | by a debugger to interpret the ANSI-C types used by a given program. | |
22 | Traditionally, this kind of information is generated by the compiler when | |
23 | invoked with the -g flag and is stored in "stabs" strings or in the more | |
24 | modern DWARF format. A new -gtLEVEL option has been added in gcc to generate | |
25 | such information. CTF provides a representation of only the information | |
26 | that is relevant to debugging a complex, optimized C program such as the | |
27 | operating system kernel in a form that is significantly more compact than | |
28 | the equivalent stabs or DWARF representation. The format is data-model | |
29 | independent, so consumers do not need different code depending on whether | |
30 | they are 32-bit or 64-bit programs. CTF assumes that a standard ELF symbol | |
31 | table is available for use in the debugger, and uses the structure and data | |
32 | of the symbol table to avoid storing redundant information. The CTF data | |
33 | may be compressed on disk or in memory, indicated by a bit in the header. | |
34 | CTF may be interpreted in a raw disk file, or it may be stored in an ELF | |
35 | section, typically named .ctf. Data structures are aligned so that a raw | |
36 | CTF file or CTF ELF section may be manipulated using mmap(2). | |
37 | ||
38 | The CTF file or section itself has the following structure: | |
39 | ||
40 | +--------+--------+---------+----------+----------+-------+--------+ | |
41 | | file | type | data | function | variable | data | string | | |
42 | | header | labels | objects | info | info | types | table | | |
43 | +--------+--------+---------+----------+----------+-------+--------+ | |
44 | ||
45 | The file header stores a magic number and version information, encoding | |
46 | flags, and the byte offset of each of the sections relative to the end of the | |
47 | header itself. If the CTF data has been uniquified against another set of | |
48 | CTF data, a reference to that data also appears in the the header. This | |
49 | reference is the name of the label corresponding to the types uniquified | |
50 | against. | |
51 | ||
52 | Following the header is a list of labels, used to group the types included in | |
53 | the data types section. Each label is accompanied by a type ID i. A given | |
54 | label refers to the group of types whose IDs are in the range [0, i]. | |
55 | ||
56 | Data object and function records are stored in the same order as they appear | |
57 | in the corresponding symbol table, except that symbols marked SHN_UNDEF are | |
58 | not stored and symbols that have no type data are padded out with zeroes. | |
59 | For each data object, the type ID (a small integer) is recorded. For each | |
60 | function, the type ID of the return type and argument types is recorded. | |
61 | ||
62 | Variable records (as distinct from data objects) provide a modicum of support | |
63 | for non-ELF systems, mapping a variable name to a CTF type ID. The variable | |
64 | names are sorted into ASCIIbetical order, permitting binary searching. | |
65 | ||
66 | The data types section is a list of variable size records that represent each | |
67 | type, in order by their ID. The types themselves form a directed graph, | |
68 | where each node may contain one or more outgoing edges to other type nodes, | |
69 | denoted by their ID. | |
70 | ||
71 | Strings are recorded as a string table ID (0 or 1) and a byte offset into the | |
72 | string table. String table 0 is the internal CTF string table. String table | |
73 | 1 is the external string table, which is the string table associated with the | |
74 | ELF symbol table for this object. CTF does not record any strings that are | |
75 | already in the symbol table, and the CTF string table does not contain any | |
76 | duplicated strings. */ | |
77 | ||
78 | #include "defs.h" | |
79 | #include "buildsym.h" | |
80 | #include "complaints.h" | |
81 | #include "block.h" | |
82 | #include "ctfread.h" | |
83 | #include "psympriv.h" | |
84 | #include "ctf.h" | |
85 | #include "ctf-api.h" | |
86 | ||
87 | static const struct objfile_key<htab, htab_deleter> ctf_tid_key; | |
88 | static const struct objfile_data *ctf_file_key; | |
89 | ||
90 | /* A CTF context consists of a file pointer and an objfile pointer. */ | |
91 | ||
92 | typedef struct ctf_context | |
93 | { | |
94 | ctf_file_t *fp; | |
95 | struct objfile *of; | |
96 | struct buildsym_compunit *builder; | |
97 | } ctf_context_t; | |
98 | ||
99 | /* The routines that read and process fields/members of a C struct, union, | |
100 | or enumeration, pass lists of data member fields in an instance of a | |
b2caee6a | 101 | ctf_field_info structure. It is derived from dwarf2read.c. */ |
30d1f018 | 102 | |
b2caee6a | 103 | struct ctf_nextfield |
30d1f018 WP |
104 | { |
105 | struct field field {}; | |
106 | }; | |
107 | ||
b2caee6a | 108 | struct ctf_field_info |
30d1f018 WP |
109 | { |
110 | /* List of data member fields. */ | |
b2caee6a | 111 | std::vector<struct ctf_nextfield> fields; |
30d1f018 WP |
112 | |
113 | /* Context. */ | |
114 | ctf_context_t *cur_context; | |
115 | ||
116 | /* Parent type. */ | |
117 | struct type *ptype; | |
118 | ||
119 | /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head | |
120 | of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */ | |
121 | std::vector<struct decl_field> typedef_field_list; | |
122 | ||
123 | /* Nested types defined by this struct and the number of elements in | |
124 | this list. */ | |
125 | std::vector<struct decl_field> nested_types_list; | |
126 | }; | |
127 | ||
128 | ||
129 | /* Local function prototypes */ | |
130 | ||
131 | static void psymtab_to_symtab (struct partial_symtab *); | |
132 | ||
133 | static int ctf_add_type_cb (ctf_id_t tid, void *arg); | |
134 | ||
135 | static struct type *read_array_type (ctf_context_t *ccp, ctf_id_t tid); | |
136 | ||
137 | static struct type *read_pointer_type (ctf_context_t *ccp, ctf_id_t tid, | |
138 | ctf_id_t btid); | |
139 | ||
140 | static struct type *read_structure_type (ctf_context_t *ccp, ctf_id_t tid); | |
141 | ||
142 | static struct type *read_enum_type (ctf_context_t *ccp, ctf_id_t tid); | |
143 | ||
144 | static struct type *read_typedef_type (ctf_context_t *ccp, ctf_id_t tid, | |
145 | ctf_id_t btid, const char *name); | |
146 | ||
147 | static struct type *read_type_record (ctf_context_t *ccp, ctf_id_t tid); | |
148 | ||
149 | static void process_structure_type (ctf_context_t *ccp, ctf_id_t tid); | |
150 | ||
151 | static void process_struct_members (ctf_context_t *ccp, ctf_id_t tid, | |
152 | struct type *type); | |
153 | ||
154 | static struct symbol *new_symbol (ctf_context_t *ccp, struct type *type, | |
155 | ctf_id_t tid); | |
156 | ||
157 | struct ctf_tid_and_type | |
158 | { | |
159 | ctf_id_t tid; | |
160 | struct type *type; | |
161 | }; | |
162 | ||
163 | /* Hash function for a ctf_tid_and_type. */ | |
164 | ||
165 | static hashval_t | |
166 | tid_and_type_hash (const void *item) | |
167 | { | |
168 | const struct ctf_tid_and_type *ids | |
169 | = (const struct ctf_tid_and_type *) item; | |
170 | ||
171 | return ids->tid; | |
172 | } | |
173 | ||
174 | /* Equality function for a ctf_tid_and_type. */ | |
175 | ||
176 | static int | |
177 | tid_and_type_eq (const void *item_lhs, const void *item_rhs) | |
178 | { | |
179 | const struct ctf_tid_and_type *ids_lhs | |
180 | = (const struct ctf_tid_and_type *) item_lhs; | |
181 | const struct ctf_tid_and_type *ids_rhs | |
182 | = (const struct ctf_tid_and_type *) item_rhs; | |
183 | ||
184 | return ids_lhs->tid == ids_rhs->tid; | |
185 | } | |
186 | ||
187 | /* Set the type associated with TID to TYP. */ | |
188 | ||
189 | static struct type * | |
190 | set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ) | |
191 | { | |
192 | htab_t htab; | |
193 | ||
194 | htab = (htab_t) ctf_tid_key.get (of); | |
195 | if (htab == NULL) | |
196 | { | |
197 | htab = htab_create_alloc (1, tid_and_type_hash, | |
198 | tid_and_type_eq, | |
199 | NULL, xcalloc, xfree); | |
200 | ctf_tid_key.set (of, htab); | |
201 | } | |
202 | ||
203 | struct ctf_tid_and_type **slot, ids; | |
204 | ids.tid = tid; | |
205 | ids.type = typ; | |
206 | slot = (struct ctf_tid_and_type **) htab_find_slot (htab, &ids, INSERT); | |
207 | if (*slot) | |
208 | complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"), | |
209 | (tid)); | |
210 | *slot = XOBNEW (&of->objfile_obstack, struct ctf_tid_and_type); | |
211 | **slot = ids; | |
212 | return typ; | |
213 | } | |
214 | ||
215 | /* Look up the type for TID in tid_and_type hash, return NULL if hash is | |
216 | empty or TID does not have a saved type. */ | |
217 | ||
218 | static struct type * | |
219 | get_tid_type (struct objfile *of, ctf_id_t tid) | |
220 | { | |
221 | struct ctf_tid_and_type *slot, ids; | |
222 | htab_t htab; | |
223 | ||
224 | htab = (htab_t) ctf_tid_key.get (of); | |
225 | if (htab == NULL) | |
226 | return NULL; | |
227 | ||
228 | ids.tid = tid; | |
229 | ids.type = NULL; | |
230 | slot = (struct ctf_tid_and_type *) htab_find (htab, &ids); | |
231 | if (slot) | |
232 | return slot->type; | |
233 | else | |
234 | return NULL; | |
235 | } | |
236 | ||
237 | /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */ | |
238 | ||
239 | static int | |
240 | get_bitsize (ctf_file_t *fp, ctf_id_t tid, uint32_t kind) | |
241 | { | |
242 | ctf_encoding_t cet; | |
243 | ||
244 | if ((kind == CTF_K_INTEGER || kind == CTF_K_ENUM | |
245 | || kind == CTF_K_FLOAT) | |
246 | && ctf_type_reference (fp, tid) != CTF_ERR | |
247 | && ctf_type_encoding (fp, tid, &cet) != CTF_ERR) | |
248 | return cet.cte_bits; | |
249 | ||
250 | return 0; | |
251 | } | |
252 | ||
253 | /* Set SYM's address, with NAME, from its minimal symbol entry. */ | |
254 | ||
255 | static void | |
256 | set_symbol_address (struct objfile *of, struct symbol *sym, const char *name) | |
257 | { | |
258 | struct bound_minimal_symbol msym; | |
259 | ||
260 | msym = lookup_minimal_symbol (name, NULL, of); | |
261 | if (msym.minsym != NULL) | |
262 | { | |
263 | SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym)); | |
264 | SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; | |
265 | SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msym.minsym); | |
266 | } | |
267 | } | |
268 | ||
269 | /* Create the vector of fields, and attach it to TYPE. */ | |
270 | ||
271 | static void | |
b2caee6a | 272 | attach_fields_to_type (struct ctf_field_info *fip, struct type *type) |
30d1f018 WP |
273 | { |
274 | int nfields = fip->fields.size (); | |
275 | ||
276 | if (nfields == 0) | |
277 | return; | |
278 | ||
279 | /* Record the field count, allocate space for the array of fields. */ | |
280 | TYPE_NFIELDS (type) = nfields; | |
281 | TYPE_FIELDS (type) | |
282 | = (struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields); | |
283 | ||
284 | /* Copy the saved-up fields into the field vector. */ | |
285 | for (int i = 0; i < nfields; ++i) | |
286 | { | |
b2caee6a | 287 | struct ctf_nextfield &field = fip->fields[i]; |
30d1f018 WP |
288 | TYPE_FIELD (type, i) = field.field; |
289 | } | |
290 | } | |
291 | ||
292 | /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT | |
293 | (which may be different from NAME) to the architecture back-end to allow | |
294 | it to guess the correct format if necessary. */ | |
295 | ||
296 | static struct type * | |
297 | ctf_init_float_type (struct objfile *objfile, | |
298 | int bits, | |
299 | const char *name, | |
300 | const char *name_hint) | |
301 | { | |
302 | struct gdbarch *gdbarch = get_objfile_arch (objfile); | |
303 | const struct floatformat **format; | |
304 | struct type *type; | |
305 | ||
306 | format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits); | |
307 | if (format != NULL) | |
308 | type = init_float_type (objfile, bits, name, format); | |
309 | else | |
310 | type = init_type (objfile, TYPE_CODE_ERROR, bits, name); | |
311 | ||
312 | return type; | |
313 | } | |
314 | ||
315 | /* Callback to add member NAME to a struct/union type. TID is the type | |
316 | of struct/union member, OFFSET is the offset of member in bits, | |
b2caee6a | 317 | and ARG contains the ctf_field_info. */ |
30d1f018 WP |
318 | |
319 | static int | |
320 | ctf_add_member_cb (const char *name, | |
321 | ctf_id_t tid, | |
322 | unsigned long offset, | |
323 | void *arg) | |
324 | { | |
b2caee6a | 325 | struct ctf_field_info *fip = (struct ctf_field_info *) arg; |
30d1f018 | 326 | ctf_context_t *ccp = fip->cur_context; |
b2caee6a | 327 | struct ctf_nextfield new_field; |
30d1f018 WP |
328 | struct field *fp; |
329 | struct type *t; | |
330 | uint32_t kind; | |
331 | ||
332 | fp = &new_field.field; | |
333 | FIELD_NAME (*fp) = name; | |
334 | ||
335 | kind = ctf_type_kind (ccp->fp, tid); | |
336 | t = get_tid_type (ccp->of, tid); | |
337 | if (t == NULL) | |
338 | { | |
339 | t = read_type_record (ccp, tid); | |
340 | if (t == NULL) | |
341 | { | |
342 | complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid); | |
343 | t = objfile_type (ccp->of)->builtin_error; | |
344 | set_tid_type (ccp->of, tid, t); | |
345 | } | |
346 | } | |
347 | ||
348 | if (kind == CTF_K_STRUCT || kind == CTF_K_UNION) | |
349 | process_struct_members (ccp, tid, t); | |
350 | ||
351 | FIELD_TYPE (*fp) = t; | |
352 | SET_FIELD_BITPOS (*fp, offset / TARGET_CHAR_BIT); | |
353 | FIELD_BITSIZE (*fp) = get_bitsize (ccp->fp, tid, kind); | |
354 | ||
355 | fip->fields.emplace_back (new_field); | |
356 | ||
357 | return 0; | |
358 | } | |
359 | ||
360 | /* Callback to add member NAME of EVAL to an enumeration type. | |
b2caee6a | 361 | ARG contains the ctf_field_info. */ |
30d1f018 WP |
362 | |
363 | static int | |
364 | ctf_add_enum_member_cb (const char *name, int enum_value, void *arg) | |
365 | { | |
b2caee6a AB |
366 | struct ctf_field_info *fip = (struct ctf_field_info *) arg; |
367 | struct ctf_nextfield new_field; | |
30d1f018 WP |
368 | struct field *fp; |
369 | ctf_context_t *ccp = fip->cur_context; | |
370 | ||
371 | fp = &new_field.field; | |
372 | FIELD_NAME (*fp) = name; | |
373 | FIELD_TYPE (*fp) = NULL; | |
374 | SET_FIELD_ENUMVAL (*fp, enum_value); | |
375 | FIELD_BITSIZE (*fp) = 0; | |
376 | ||
377 | if (name != NULL) | |
378 | { | |
379 | struct symbol *sym = allocate_symbol (ccp->of); | |
380 | OBJSTAT (ccp->of, n_syms++); | |
381 | ||
382 | SYMBOL_SET_LANGUAGE (sym, language_c, &ccp->of->objfile_obstack); | |
383 | SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); | |
384 | SYMBOL_ACLASS_INDEX (sym) = LOC_CONST; | |
385 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; | |
386 | SYMBOL_TYPE (sym) = fip->ptype; | |
387 | add_symbol_to_list (sym, ccp->builder->get_global_symbols ()); | |
388 | } | |
389 | ||
390 | fip->fields.emplace_back (new_field); | |
391 | ||
392 | return 0; | |
393 | } | |
394 | ||
395 | /* Add a new symbol entry, with its name from TID, its access index and | |
396 | domain from TID's kind, and its type from TYPE. */ | |
397 | ||
398 | static struct symbol * | |
399 | new_symbol (ctf_context_t *ccp, struct type *type, ctf_id_t tid) | |
400 | { | |
401 | struct objfile *objfile = ccp->of; | |
402 | ctf_file_t *fp = ccp->fp; | |
403 | struct symbol *sym = NULL; | |
404 | ||
405 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid)); | |
406 | if (name != NULL) | |
407 | { | |
408 | sym = allocate_symbol (objfile); | |
409 | OBJSTAT (objfile, n_syms++); | |
410 | ||
411 | SYMBOL_SET_LANGUAGE (sym, language_c, &objfile->objfile_obstack); | |
412 | SYMBOL_SET_NAMES (sym, name.get (), strlen (name.get ()), 1, objfile); | |
413 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; | |
414 | SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT; | |
415 | ||
416 | if (type != NULL) | |
417 | SYMBOL_TYPE (sym) = type; | |
418 | ||
419 | uint32_t kind = ctf_type_kind (fp, tid); | |
420 | switch (kind) | |
421 | { | |
422 | case CTF_K_STRUCT: | |
423 | case CTF_K_UNION: | |
424 | case CTF_K_ENUM: | |
425 | SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; | |
426 | SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; | |
427 | break; | |
428 | case CTF_K_FUNCTION: | |
429 | SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; | |
430 | break; | |
431 | case CTF_K_CONST: | |
432 | if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID) | |
433 | SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int; | |
434 | break; | |
435 | case CTF_K_TYPEDEF: | |
436 | case CTF_K_INTEGER: | |
437 | case CTF_K_FLOAT: | |
438 | SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; | |
439 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; | |
440 | break; | |
441 | case CTF_K_POINTER: | |
442 | break; | |
443 | case CTF_K_VOLATILE: | |
444 | case CTF_K_RESTRICT: | |
445 | break; | |
446 | case CTF_K_SLICE: | |
447 | case CTF_K_ARRAY: | |
448 | case CTF_K_UNKNOWN: | |
449 | break; | |
450 | } | |
451 | ||
452 | add_symbol_to_list (sym, ccp->builder->get_global_symbols ()); | |
453 | } | |
454 | ||
455 | return sym; | |
456 | } | |
457 | ||
458 | /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation | |
459 | and create the symbol for it. */ | |
460 | ||
461 | static struct type * | |
462 | read_base_type (ctf_context_t *ccp, ctf_id_t tid) | |
463 | { | |
464 | struct objfile *of = ccp->of; | |
465 | ctf_file_t *fp = ccp->fp; | |
466 | ctf_encoding_t cet; | |
467 | struct type *type = NULL; | |
468 | char *name; | |
469 | uint32_t kind; | |
470 | ||
471 | if (ctf_type_encoding (fp, tid, &cet)) | |
472 | { | |
473 | complaint (_("ctf_type_encoding read_base_type failed - %s"), | |
474 | ctf_errmsg (ctf_errno (fp))); | |
475 | return NULL; | |
476 | } | |
477 | ||
478 | gdb::unique_xmalloc_ptr<char> copied_name (ctf_type_aname_raw (fp, tid)); | |
479 | if (copied_name == NULL || strlen (copied_name.get ()) == 0) | |
480 | { | |
481 | name = ctf_type_aname (fp, tid); | |
482 | if (name == NULL) | |
483 | complaint (_("ctf_type_aname read_base_type failed - %s"), | |
484 | ctf_errmsg (ctf_errno (fp))); | |
485 | } | |
486 | else | |
487 | name = obstack_strdup (&of->objfile_obstack, copied_name.get ()); | |
488 | ||
489 | kind = ctf_type_kind (fp, tid); | |
490 | if (kind == CTF_K_INTEGER) | |
491 | { | |
492 | uint32_t issigned, ischar, isbool; | |
493 | struct gdbarch *gdbarch = get_objfile_arch (of); | |
494 | ||
495 | issigned = cet.cte_format & CTF_INT_SIGNED; | |
496 | ischar = cet.cte_format & CTF_INT_CHAR; | |
497 | isbool = cet.cte_format & CTF_INT_BOOL; | |
498 | if (ischar) | |
499 | type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name); | |
500 | else if (isbool) | |
501 | type = init_boolean_type (of, gdbarch_int_bit (gdbarch), | |
502 | !issigned, name); | |
503 | else | |
504 | { | |
505 | int bits; | |
506 | if (cet.cte_bits && ((cet.cte_bits % TARGET_CHAR_BIT) == 0)) | |
507 | bits = cet.cte_bits; | |
508 | else | |
509 | bits = gdbarch_int_bit (gdbarch); | |
510 | type = init_integer_type (of, bits, !issigned, name); | |
511 | } | |
512 | } | |
513 | else if (kind == CTF_K_FLOAT) | |
514 | { | |
515 | uint32_t isflt; | |
516 | isflt = !((cet.cte_format & CTF_FP_IMAGRY) == CTF_FP_IMAGRY | |
517 | || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY | |
518 | || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY); | |
519 | if (isflt) | |
520 | type = ctf_init_float_type (of, cet.cte_bits, name, name); | |
521 | else | |
522 | { | |
523 | struct type *t | |
524 | = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name); | |
525 | type = init_complex_type (of, name, t); | |
526 | } | |
527 | } | |
528 | else | |
529 | { | |
530 | complaint (_("read_base_type: unsupported base kind (%d)"), kind); | |
531 | type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name); | |
532 | } | |
533 | ||
534 | if (name != NULL && strcmp (name, "char") == 0) | |
535 | TYPE_NOSIGN (type) = 1; | |
536 | ||
537 | return set_tid_type (of, tid, type); | |
538 | } | |
539 | ||
540 | static void | |
541 | process_base_type (ctf_context_t *ccp, ctf_id_t tid) | |
542 | { | |
543 | struct type *type; | |
544 | ||
545 | type = read_base_type (ccp, tid); | |
546 | new_symbol (ccp, type, tid); | |
547 | } | |
548 | ||
549 | /* Start a structure or union scope (definition) with TID to create a type | |
550 | for the structure or union. | |
551 | ||
552 | Fill in the type's name and general properties. The members will not be | |
553 | processed, nor a symbol table entry be done until process_structure_type | |
554 | (assuming the type has a name). */ | |
555 | ||
556 | static struct type * | |
557 | read_structure_type (ctf_context_t *ccp, ctf_id_t tid) | |
558 | { | |
559 | struct objfile *of = ccp->of; | |
560 | ctf_file_t *fp = ccp->fp; | |
561 | struct type *type; | |
562 | uint32_t kind; | |
563 | ||
564 | type = alloc_type (of); | |
565 | ||
566 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid)); | |
567 | if (name != NULL && strlen (name.get() ) != 0) | |
568 | TYPE_NAME (type) = obstack_strdup (&of->objfile_obstack, name.get ()); | |
569 | ||
570 | kind = ctf_type_kind (fp, tid); | |
571 | if (kind == CTF_K_UNION) | |
572 | TYPE_CODE (type) = TYPE_CODE_UNION; | |
573 | else | |
574 | TYPE_CODE (type) = TYPE_CODE_STRUCT; | |
575 | ||
576 | TYPE_LENGTH (type) = ctf_type_size (fp, tid); | |
577 | set_type_align (type, ctf_type_align (fp, tid)); | |
578 | ||
579 | return set_tid_type (ccp->of, tid, type); | |
580 | } | |
581 | ||
582 | /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members | |
583 | and create the symbol for it. */ | |
584 | ||
585 | static void | |
586 | process_struct_members (ctf_context_t *ccp, | |
587 | ctf_id_t tid, | |
588 | struct type *type) | |
589 | { | |
b2caee6a | 590 | struct ctf_field_info fi; |
30d1f018 WP |
591 | |
592 | fi.cur_context = ccp; | |
593 | if (ctf_member_iter (ccp->fp, tid, ctf_add_member_cb, &fi) == CTF_ERR) | |
594 | complaint (_("ctf_member_iter process_struct_members failed - %s"), | |
595 | ctf_errmsg (ctf_errno (ccp->fp))); | |
596 | ||
597 | /* Attach fields to the type. */ | |
598 | attach_fields_to_type (&fi, type); | |
599 | ||
600 | new_symbol (ccp, type, tid); | |
601 | } | |
602 | ||
603 | static void | |
604 | process_structure_type (ctf_context_t *ccp, ctf_id_t tid) | |
605 | { | |
606 | struct type *type; | |
607 | ||
608 | type = read_structure_type (ccp, tid); | |
609 | process_struct_members (ccp, tid, type); | |
610 | } | |
611 | ||
612 | /* Create a function type for TID and set its return type. */ | |
613 | ||
614 | static struct type * | |
615 | read_func_kind_type (ctf_context_t *ccp, ctf_id_t tid) | |
616 | { | |
617 | struct objfile *of = ccp->of; | |
618 | ctf_file_t *fp = ccp->fp; | |
619 | struct type *type, *rettype; | |
620 | ctf_funcinfo_t cfi; | |
621 | ||
622 | type = alloc_type (of); | |
623 | ||
624 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid)); | |
625 | if (name != NULL && strlen (name.get ()) != 0) | |
626 | TYPE_NAME (type) = obstack_strdup (&of->objfile_obstack, name.get ()); | |
627 | ||
628 | TYPE_CODE (type) = TYPE_CODE_FUNC; | |
629 | ctf_func_type_info (fp, tid, &cfi); | |
630 | rettype = get_tid_type (of, cfi.ctc_return); | |
631 | TYPE_TARGET_TYPE (type) = rettype; | |
632 | set_type_align (type, ctf_type_align (fp, tid)); | |
633 | ||
634 | return set_tid_type (of, tid, type); | |
635 | } | |
636 | ||
637 | /* Given a TID of CTF_K_ENUM, process all the members of the | |
638 | enumeration, and create the symbol for the enumeration type. */ | |
639 | ||
640 | static struct type * | |
641 | read_enum_type (ctf_context_t *ccp, ctf_id_t tid) | |
642 | { | |
643 | struct objfile *of = ccp->of; | |
644 | ctf_file_t *fp = ccp->fp; | |
645 | struct type *type, *target_type; | |
646 | ctf_funcinfo_t fi; | |
647 | ||
648 | type = alloc_type (of); | |
649 | ||
650 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid)); | |
651 | if (name != NULL && strlen (name.get ()) != 0) | |
652 | TYPE_NAME (type) = obstack_strdup (&of->objfile_obstack, name.get ()); | |
653 | ||
654 | TYPE_CODE (type) = TYPE_CODE_ENUM; | |
655 | TYPE_LENGTH (type) = ctf_type_size (fp, tid); | |
656 | ctf_func_type_info (fp, tid, &fi); | |
657 | target_type = get_tid_type (of, fi.ctc_return); | |
658 | TYPE_TARGET_TYPE (type) = target_type; | |
659 | set_type_align (type, ctf_type_align (fp, tid)); | |
660 | ||
661 | return set_tid_type (of, tid, type); | |
662 | } | |
663 | ||
664 | static void | |
665 | process_enum_type (ctf_context_t *ccp, ctf_id_t tid) | |
666 | { | |
667 | struct type *type; | |
b2caee6a | 668 | struct ctf_field_info fi; |
30d1f018 WP |
669 | |
670 | type = read_enum_type (ccp, tid); | |
671 | ||
672 | fi.cur_context = ccp; | |
673 | fi.ptype = type; | |
674 | if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR) | |
675 | complaint (_("ctf_enum_iter process_enum_type failed - %s"), | |
676 | ctf_errmsg (ctf_errno (ccp->fp))); | |
677 | ||
678 | /* Attach fields to the type. */ | |
679 | attach_fields_to_type (&fi, type); | |
680 | ||
681 | new_symbol (ccp, type, tid); | |
682 | } | |
683 | ||
684 | /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */ | |
685 | ||
686 | static struct type * | |
687 | add_array_cv_type (ctf_context_t *ccp, | |
688 | ctf_id_t tid, | |
689 | struct type *base_type, | |
690 | int cnst, | |
691 | int voltl) | |
692 | { | |
693 | struct type *el_type, *inner_array; | |
694 | ||
695 | base_type = copy_type (base_type); | |
696 | inner_array = base_type; | |
697 | ||
698 | while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) | |
699 | { | |
700 | TYPE_TARGET_TYPE (inner_array) | |
701 | = copy_type (TYPE_TARGET_TYPE (inner_array)); | |
702 | inner_array = TYPE_TARGET_TYPE (inner_array); | |
703 | } | |
704 | ||
705 | el_type = TYPE_TARGET_TYPE (inner_array); | |
706 | cnst |= TYPE_CONST (el_type); | |
707 | voltl |= TYPE_VOLATILE (el_type); | |
708 | TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); | |
709 | ||
710 | return set_tid_type (ccp->of, tid, base_type); | |
711 | } | |
712 | ||
713 | /* Read all information from a TID of CTF_K_ARRAY. */ | |
714 | ||
715 | static struct type * | |
716 | read_array_type (ctf_context_t *ccp, ctf_id_t tid) | |
717 | { | |
718 | struct objfile *objfile = ccp->of; | |
719 | ctf_file_t *fp = ccp->fp; | |
720 | struct type *element_type, *range_type, *idx_type; | |
721 | struct type *type; | |
722 | ctf_arinfo_t ar; | |
723 | ||
724 | if (ctf_array_info (fp, tid, &ar) == CTF_ERR) | |
725 | { | |
726 | complaint (_("ctf_array_info read_array_type failed - %s"), | |
727 | ctf_errmsg (ctf_errno (fp))); | |
728 | return NULL; | |
729 | } | |
730 | ||
731 | element_type = get_tid_type (objfile, ar.ctr_contents); | |
732 | if (element_type == NULL) | |
733 | return NULL; | |
734 | ||
735 | idx_type = get_tid_type (objfile, ar.ctr_index); | |
736 | if (idx_type == NULL) | |
737 | idx_type = objfile_type (objfile)->builtin_int; | |
738 | ||
739 | range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1); | |
740 | type = create_array_type (NULL, element_type, range_type); | |
741 | if (ar.ctr_nelems <= 1) /* Check if undefined upper bound. */ | |
742 | { | |
743 | TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED; | |
744 | TYPE_LENGTH (type) = 0; | |
745 | TYPE_TARGET_STUB (type) = 1; | |
746 | } | |
747 | else | |
748 | TYPE_LENGTH (type) = ctf_type_size (fp, tid); | |
749 | ||
750 | set_type_align (type, ctf_type_align (fp, tid)); | |
751 | ||
752 | return set_tid_type (objfile, tid, type); | |
753 | } | |
754 | ||
755 | /* Read TID of kind CTF_K_CONST with base type BTID. */ | |
756 | ||
757 | static struct type * | |
758 | read_const_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) | |
759 | { | |
760 | struct objfile *objfile = ccp->of; | |
761 | struct type *base_type, *cv_type; | |
762 | ||
763 | base_type = get_tid_type (objfile, btid); | |
764 | if (base_type == NULL) | |
765 | { | |
766 | base_type = read_type_record (ccp, btid); | |
767 | if (base_type == NULL) | |
768 | { | |
769 | complaint (_("read_const_type: NULL base type (%ld)"), btid); | |
770 | base_type = objfile_type (objfile)->builtin_error; | |
771 | } | |
772 | } | |
773 | cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); | |
774 | ||
775 | return set_tid_type (objfile, tid, cv_type); | |
776 | } | |
777 | ||
778 | /* Read TID of kind CTF_K_VOLATILE with base type BTID. */ | |
779 | ||
780 | static struct type * | |
781 | read_volatile_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) | |
782 | { | |
783 | struct objfile *objfile = ccp->of; | |
784 | ctf_file_t *fp = ccp->fp; | |
785 | struct type *base_type, *cv_type; | |
786 | ||
787 | base_type = get_tid_type (objfile, btid); | |
788 | if (base_type == NULL) | |
789 | { | |
790 | base_type = read_type_record (ccp, btid); | |
791 | if (base_type == NULL) | |
792 | { | |
793 | complaint (_("read_volatile_type: NULL base type (%ld)"), btid); | |
794 | base_type = objfile_type (objfile)->builtin_error; | |
795 | } | |
796 | } | |
797 | ||
798 | if (ctf_type_kind (fp, btid) == CTF_K_ARRAY) | |
799 | return add_array_cv_type (ccp, tid, base_type, 0, 1); | |
800 | cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); | |
801 | ||
802 | return set_tid_type (objfile, tid, cv_type); | |
803 | } | |
804 | ||
805 | /* Read TID of kind CTF_K_RESTRICT with base type BTID. */ | |
806 | ||
807 | static struct type * | |
808 | read_restrict_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) | |
809 | { | |
810 | struct objfile *objfile = ccp->of; | |
811 | struct type *base_type, *cv_type; | |
812 | ||
813 | base_type = get_tid_type (objfile, btid); | |
814 | if (base_type == NULL) | |
815 | { | |
816 | base_type = read_type_record (ccp, btid); | |
817 | if (base_type == NULL) | |
818 | { | |
819 | complaint (_("read_restrict_type: NULL base type (%ld)"), btid); | |
820 | base_type = objfile_type (objfile)->builtin_error; | |
821 | } | |
822 | } | |
823 | cv_type = make_restrict_type (base_type); | |
824 | ||
825 | return set_tid_type (objfile, tid, cv_type); | |
826 | } | |
827 | ||
828 | /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */ | |
829 | ||
830 | static struct type * | |
831 | read_typedef_type (ctf_context_t *ccp, ctf_id_t tid, | |
832 | ctf_id_t btid, const char *name) | |
833 | { | |
834 | struct objfile *objfile = ccp->of; | |
835 | struct type *this_type, *target_type; | |
836 | ||
837 | char *aname = obstack_strdup (&objfile->objfile_obstack, name); | |
838 | this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname); | |
839 | set_tid_type (objfile, tid, this_type); | |
840 | target_type = get_tid_type (objfile, btid); | |
841 | if (target_type != this_type) | |
842 | TYPE_TARGET_TYPE (this_type) = target_type; | |
843 | else | |
844 | TYPE_TARGET_TYPE (this_type) = NULL; | |
845 | TYPE_TARGET_STUB (this_type) = TYPE_TARGET_TYPE (this_type) ? 1 : 0; | |
846 | ||
847 | return set_tid_type (objfile, tid, this_type); | |
848 | } | |
849 | ||
850 | /* Read TID of kind CTF_K_POINTER with base type BTID. */ | |
851 | ||
852 | static struct type * | |
853 | read_pointer_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) | |
854 | { | |
855 | struct objfile *of = ccp->of; | |
856 | struct type *target_type, *type; | |
857 | ||
858 | target_type = get_tid_type (of, btid); | |
859 | if (target_type == NULL) | |
860 | { | |
861 | target_type = read_type_record (ccp, btid); | |
862 | if (target_type == NULL) | |
863 | { | |
864 | complaint (_("read_pointer_type: NULL target type (%ld)"), btid); | |
865 | target_type = objfile_type (ccp->of)->builtin_error; | |
866 | } | |
867 | } | |
868 | ||
869 | type = lookup_pointer_type (target_type); | |
870 | set_type_align (type, ctf_type_align (ccp->fp, tid)); | |
871 | ||
872 | return set_tid_type (of, tid, type); | |
873 | } | |
874 | ||
875 | /* Read information associated with type TID. */ | |
876 | ||
877 | static struct type * | |
878 | read_type_record (ctf_context_t *ccp, ctf_id_t tid) | |
879 | { | |
880 | ctf_file_t *fp = ccp->fp; | |
881 | uint32_t kind; | |
882 | struct type *type = NULL; | |
883 | ctf_id_t btid; | |
884 | ||
885 | kind = ctf_type_kind (fp, tid); | |
886 | switch (kind) | |
887 | { | |
888 | case CTF_K_STRUCT: | |
889 | case CTF_K_UNION: | |
890 | type = read_structure_type (ccp, tid); | |
891 | break; | |
892 | case CTF_K_ENUM: | |
893 | type = read_enum_type (ccp, tid); | |
894 | break; | |
895 | case CTF_K_FUNCTION: | |
896 | type = read_func_kind_type (ccp, tid); | |
897 | break; | |
898 | case CTF_K_CONST: | |
899 | btid = ctf_type_reference (fp, tid); | |
900 | type = read_const_type (ccp, tid, btid); | |
901 | break; | |
902 | case CTF_K_TYPEDEF: | |
903 | { | |
904 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid)); | |
905 | btid = ctf_type_reference (fp, tid); | |
906 | type = read_typedef_type (ccp, tid, btid, name.get ()); | |
907 | } | |
908 | break; | |
909 | case CTF_K_VOLATILE: | |
910 | btid = ctf_type_reference (fp, tid); | |
911 | type = read_volatile_type (ccp, tid, btid); | |
912 | break; | |
913 | case CTF_K_RESTRICT: | |
914 | btid = ctf_type_reference (fp, tid); | |
915 | type = read_restrict_type (ccp, tid, btid); | |
916 | break; | |
917 | case CTF_K_POINTER: | |
918 | btid = ctf_type_reference (fp, tid); | |
919 | type = read_pointer_type (ccp, tid, btid); | |
920 | break; | |
921 | case CTF_K_INTEGER: | |
922 | case CTF_K_FLOAT: | |
923 | type = read_base_type (ccp, tid); | |
924 | break; | |
925 | case CTF_K_ARRAY: | |
926 | type = read_array_type (ccp, tid); | |
927 | break; | |
928 | case CTF_K_UNKNOWN: | |
929 | break; | |
930 | default: | |
931 | break; | |
932 | } | |
933 | ||
934 | return type; | |
935 | } | |
936 | ||
937 | /* Callback to add type TID to the symbol table. */ | |
938 | ||
939 | static int | |
940 | ctf_add_type_cb (ctf_id_t tid, void *arg) | |
941 | { | |
942 | ctf_context_t *ccp = (ctf_context_t *) arg; | |
943 | struct type *type; | |
944 | uint32_t kind; | |
945 | ||
946 | /* Check if tid's type has already been defined. */ | |
947 | type = get_tid_type (ccp->of, tid); | |
948 | if (type != NULL) | |
949 | return 0; | |
950 | ||
951 | ctf_id_t btid = ctf_type_reference (ccp->fp, tid); | |
952 | kind = ctf_type_kind (ccp->fp, tid); | |
953 | switch (kind) | |
954 | { | |
955 | case CTF_K_STRUCT: | |
956 | case CTF_K_UNION: | |
957 | process_structure_type (ccp, tid); | |
958 | break; | |
959 | case CTF_K_ENUM: | |
960 | process_enum_type (ccp, tid); | |
961 | break; | |
962 | case CTF_K_FUNCTION: | |
963 | type = read_func_kind_type (ccp, tid); | |
964 | new_symbol (ccp, type, tid); | |
965 | break; | |
966 | case CTF_K_INTEGER: | |
967 | case CTF_K_FLOAT: | |
968 | process_base_type (ccp, tid); | |
969 | break; | |
970 | case CTF_K_TYPEDEF: | |
971 | new_symbol (ccp, read_type_record (ccp, tid), tid); | |
972 | break; | |
973 | case CTF_K_CONST: | |
974 | type = read_const_type (ccp, tid, btid); | |
975 | new_symbol (ccp, type, tid); | |
976 | break; | |
977 | case CTF_K_VOLATILE: | |
978 | type = read_volatile_type (ccp, tid, btid); | |
979 | new_symbol (ccp, type, tid); | |
980 | break; | |
981 | case CTF_K_RESTRICT: | |
982 | type = read_restrict_type (ccp, tid, btid); | |
983 | new_symbol (ccp, type, tid); | |
984 | break; | |
985 | case CTF_K_POINTER: | |
986 | type = read_pointer_type (ccp, tid, btid); | |
987 | new_symbol (ccp, type, tid); | |
988 | break; | |
989 | case CTF_K_ARRAY: | |
990 | type = read_array_type (ccp, tid); | |
991 | new_symbol (ccp, type, tid); | |
992 | break; | |
993 | case CTF_K_UNKNOWN: | |
994 | break; | |
995 | default: | |
996 | break; | |
997 | } | |
998 | ||
999 | return 0; | |
1000 | } | |
1001 | ||
1002 | /* Callback to add variable NAME with TID to the symbol table. */ | |
1003 | ||
1004 | static int | |
1005 | ctf_add_var_cb (const char *name, ctf_id_t id, void *arg) | |
1006 | { | |
1007 | ctf_context_t *ccp = (ctf_context_t *) arg; | |
1008 | struct symbol *sym = NULL; | |
1009 | struct type *type; | |
1010 | uint32_t kind; | |
1011 | ||
1012 | type = get_tid_type (ccp->of, id); | |
1013 | ||
1014 | kind = ctf_type_kind (ccp->fp, id); | |
1015 | switch (kind) | |
1016 | { | |
1017 | case CTF_K_FUNCTION: | |
1018 | if (name && !strcmp(name, "main")) | |
1019 | set_objfile_main_name (ccp->of, name, language_c); | |
1020 | break; | |
1021 | case CTF_K_INTEGER: | |
1022 | case CTF_K_FLOAT: | |
1023 | case CTF_K_VOLATILE: | |
1024 | case CTF_K_RESTRICT: | |
1025 | case CTF_K_TYPEDEF: | |
1026 | case CTF_K_CONST: | |
1027 | case CTF_K_POINTER: | |
1028 | case CTF_K_ARRAY: | |
1029 | if (type) | |
1030 | { | |
1031 | sym = new_symbol (ccp, type, id); | |
1032 | SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); | |
1033 | } | |
1034 | break; | |
1035 | case CTF_K_STRUCT: | |
1036 | case CTF_K_UNION: | |
1037 | case CTF_K_ENUM: | |
1038 | if (type == NULL) | |
1039 | { | |
1040 | complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id); | |
1041 | type = objfile_type (ccp->of)->builtin_error; | |
1042 | } | |
1043 | sym = allocate_symbol (ccp->of); | |
1044 | OBJSTAT (ccp->of, n_syms++); | |
1045 | SYMBOL_TYPE (sym) = type; | |
1046 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; | |
1047 | SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT; | |
1048 | SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); | |
1049 | add_symbol_to_list (sym, ccp->builder->get_global_symbols ()); | |
1050 | break; | |
1051 | default: | |
1052 | complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind); | |
1053 | break; | |
1054 | } | |
1055 | ||
1056 | if (sym) | |
1057 | set_symbol_address (ccp->of, sym, name); | |
1058 | ||
1059 | return 0; | |
1060 | } | |
1061 | ||
1062 | /* Add an ELF STT_OBJ symbol with index IDX to the symbol table. */ | |
1063 | ||
1064 | static struct symbol * | |
1065 | add_stt_obj (ctf_context_t *ccp, unsigned long idx) | |
1066 | { | |
1067 | struct symbol *sym; | |
1068 | struct type *type; | |
1069 | ctf_id_t tid; | |
1070 | ||
1071 | if ((tid = ctf_lookup_by_symbol (ccp->fp, idx)) == CTF_ERR) | |
1072 | return NULL; | |
1073 | ||
1074 | type = get_tid_type (ccp->of, tid); | |
1075 | if (type == NULL) | |
1076 | return NULL; | |
1077 | ||
1078 | sym = new_symbol (ccp, type, tid); | |
1079 | ||
1080 | return sym; | |
1081 | } | |
1082 | ||
1083 | /* Add an ELF STT_FUNC symbol with index IDX to the symbol table. */ | |
1084 | ||
1085 | static struct symbol * | |
1086 | add_stt_func (ctf_context_t *ccp, unsigned long idx) | |
1087 | { | |
1088 | struct type *ftype, *atyp, *rettyp; | |
1089 | struct symbol *sym; | |
1090 | ctf_funcinfo_t finfo; | |
1091 | ctf_id_t argv[32]; | |
1092 | uint32_t argc; | |
1093 | ctf_id_t tid; | |
1094 | struct type *void_type = objfile_type (ccp->of)->builtin_void; | |
1095 | ||
1096 | if (ctf_func_info (ccp->fp, idx, &finfo) == CTF_ERR) | |
1097 | return NULL; | |
1098 | ||
1099 | argc = finfo.ctc_argc; | |
1100 | if (ctf_func_args (ccp->fp, idx, argc, argv) == CTF_ERR) | |
1101 | return NULL; | |
1102 | ||
1103 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (ccp->fp, idx)); | |
1104 | if (name == NULL) | |
1105 | return NULL; | |
1106 | ||
1107 | tid = ctf_lookup_by_symbol (ccp->fp, idx); | |
1108 | ftype = get_tid_type (ccp->of, tid); | |
1109 | if (finfo.ctc_flags & CTF_FUNC_VARARG) | |
1110 | TYPE_VARARGS (ftype) = 1; | |
1111 | TYPE_NFIELDS (ftype) = argc; | |
1112 | ||
1113 | /* If argc is 0, it has a "void" type. */ | |
1114 | if (argc != 0) | |
1115 | TYPE_FIELDS (ftype) | |
1116 | = (struct field *) TYPE_ZALLOC (ftype, argc * sizeof (struct field)); | |
1117 | ||
1118 | /* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed | |
1119 | to find the argument type. */ | |
1120 | for (int iparam = 0; iparam < argc; iparam++) | |
1121 | { | |
1122 | atyp = get_tid_type (ccp->of, argv[iparam]); | |
1123 | if (atyp) | |
1124 | TYPE_FIELD_TYPE (ftype, iparam) = atyp; | |
1125 | else | |
1126 | TYPE_FIELD_TYPE (ftype, iparam) = void_type; | |
1127 | } | |
1128 | ||
1129 | sym = new_symbol (ccp, ftype, tid); | |
1130 | rettyp = get_tid_type (ccp->of, finfo.ctc_return); | |
1131 | if (rettyp != NULL) | |
1132 | SYMBOL_TYPE (sym) = rettyp; | |
1133 | else | |
1134 | SYMBOL_TYPE (sym) = void_type; | |
1135 | ||
1136 | return sym; | |
1137 | } | |
1138 | ||
1139 | /* Get text segment base for OBJFILE, TSIZE contains the segment size. */ | |
1140 | ||
1141 | static CORE_ADDR | |
1142 | get_objfile_text_range (struct objfile *of, int *tsize) | |
1143 | { | |
1144 | CORE_ADDR text_base; | |
1145 | bfd *abfd = of->obfd; | |
1146 | const asection *codes; | |
1147 | ||
1148 | codes = bfd_get_section_by_name (abfd, ".text"); | |
1149 | if (codes == NULL) | |
1150 | { | |
1151 | text_base = 0; | |
1152 | *tsize = 0; | |
1153 | } | |
1154 | else | |
1155 | { | |
1156 | text_base = bfd_section_vma (codes); | |
1157 | *tsize = codes->size; | |
1158 | } | |
1159 | ||
1160 | return text_base; | |
1161 | } | |
1162 | ||
1163 | /* Start a symtab for OBJFILE in CTF format. */ | |
1164 | ||
1165 | static void | |
1166 | ctf_start_symtab (struct partial_symtab *pst, | |
1167 | struct objfile *of, CORE_ADDR text_offset) | |
1168 | { | |
1169 | ctf_context_t *ccp; | |
1170 | ||
1171 | ccp = (ctf_context_t *) pst->read_symtab_private; | |
1172 | ccp->builder = new buildsym_compunit | |
1173 | (of, of->original_name, NULL, | |
1174 | language_c, text_offset); | |
1175 | ccp->builder->record_debugformat ("ctf"); | |
1176 | } | |
1177 | ||
1178 | /* Finish reading symbol/type definitions in CTF format. | |
1179 | END_ADDR is the end address of the file's text. SECTION is | |
1180 | the .text section number. */ | |
1181 | ||
1182 | static struct compunit_symtab * | |
1183 | ctf_end_symtab (struct partial_symtab *pst, | |
1184 | CORE_ADDR end_addr, int section) | |
1185 | { | |
1186 | ctf_context_t *ccp; | |
1187 | ||
1188 | ccp = (ctf_context_t *) pst->read_symtab_private; | |
1189 | struct compunit_symtab *result | |
1190 | = ccp->builder->end_symtab (end_addr, section); | |
1191 | delete ccp->builder; | |
1192 | ccp->builder = NULL; | |
1193 | return result; | |
1194 | } | |
1195 | ||
1196 | /* Read in full symbols for PST, and anything it depends on. */ | |
1197 | ||
1198 | static void | |
1199 | psymtab_to_symtab (struct partial_symtab *pst) | |
1200 | { | |
1201 | struct symbol *sym; | |
1202 | ctf_context_t *ccp; | |
1203 | ||
1204 | gdb_assert (!pst->readin); | |
1205 | ||
1206 | ccp = (ctf_context_t *) pst->read_symtab_private; | |
1207 | ||
1208 | /* Iterate over entries in data types section. */ | |
1209 | if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR) | |
1210 | complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"), | |
1211 | ctf_errmsg (ctf_errno (ccp->fp))); | |
1212 | ||
1213 | ||
1214 | /* Iterate over entries in variable info section. */ | |
1215 | if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR) | |
1216 | complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"), | |
1217 | ctf_errmsg (ctf_errno (ccp->fp))); | |
1218 | ||
1219 | /* Add entries in data objects and function info sections. */ | |
1220 | for (unsigned long i = 0; ; i++) | |
1221 | { | |
1222 | sym = add_stt_obj (ccp, i); | |
1223 | if (sym == NULL) | |
1224 | { | |
1225 | if (ctf_errno (ccp->fp) == EINVAL | |
1226 | || ctf_errno (ccp->fp) == ECTF_NOSYMTAB) | |
1227 | break; | |
1228 | sym = add_stt_func (ccp, i); | |
1229 | } | |
1230 | if (sym == NULL) | |
1231 | continue; | |
1232 | ||
1233 | set_symbol_address (ccp->of, sym, SYMBOL_LINKAGE_NAME (sym)); | |
1234 | } | |
1235 | ||
1236 | pst->readin = 1; | |
1237 | } | |
1238 | ||
1239 | /* Expand partial symbol table PST into a full symbol table. | |
1240 | PST is not NULL. */ | |
1241 | ||
1242 | static void | |
1243 | ctf_read_symtab (struct partial_symtab *pst, struct objfile *objfile) | |
1244 | { | |
1245 | if (pst->readin) | |
1246 | warning (_("bug: psymtab for %s is already read in."), pst->filename); | |
1247 | else | |
1248 | { | |
1249 | if (info_verbose) | |
1250 | { | |
1251 | printf_filtered (_("Reading in CTF data for %s..."), pst->filename); | |
1252 | gdb_flush (gdb_stdout); | |
1253 | } | |
1254 | ||
1255 | /* Start a symtab. */ | |
1256 | CORE_ADDR text_offset; /* Start of text segment. */ | |
1257 | int tsize; | |
1258 | ||
1259 | text_offset = get_objfile_text_range (objfile, &tsize); | |
1260 | ctf_start_symtab (pst, objfile, text_offset); | |
1261 | psymtab_to_symtab (pst); | |
1262 | ||
1263 | pst->set_text_low (text_offset); | |
1264 | pst->set_text_high (text_offset + tsize); | |
1265 | pst->compunit_symtab = ctf_end_symtab (pst, text_offset + tsize, | |
1266 | SECT_OFF_TEXT (objfile)); | |
1267 | ||
1268 | /* Finish up the debug error message. */ | |
1269 | if (info_verbose) | |
1270 | printf_filtered (_("done.\n")); | |
1271 | } | |
1272 | } | |
1273 | ||
1274 | /* Cleanup function for the ctf_file_key data. */ | |
1275 | ||
1276 | static void | |
1277 | ctf_close_objfile (struct objfile *of, void *datum) | |
1278 | { | |
1279 | ctf_file_t *fp = static_cast<ctf_file_t *> (datum); | |
1280 | ctf_archive_t *arc = ctf_get_arc (fp); | |
1281 | ctf_file_close (fp); | |
1282 | ctf_close (arc); | |
1283 | } | |
1284 | ||
1285 | /* Allocate a new partial_symtab NAME. | |
1286 | ||
1287 | Each source file that has not been fully read in is represented by | |
1288 | a partial_symtab. This contains the information on where in the | |
1289 | executable the debugging symbols for a specific file are, and a | |
1290 | list of names of global symbols which are located in this file. | |
1291 | They are all chained on partial symtab lists. | |
1292 | ||
1293 | Even after the source file has been read into a symtab, the | |
1294 | partial_symtab remains around. They are allocated on an obstack, | |
1295 | objfile_obstack. */ | |
1296 | ||
1297 | static struct partial_symtab * | |
1298 | create_partial_symtab (const char *name, | |
1299 | ctf_file_t *cfp, | |
1300 | struct objfile *objfile) | |
1301 | { | |
1302 | struct partial_symtab *pst; | |
1303 | ctf_context_t *ccx; | |
1304 | ||
1305 | pst = start_psymtab_common (objfile, name, 0); | |
1306 | ||
1307 | ccx = XOBNEW (&objfile->objfile_obstack, ctf_context_t); | |
1308 | ccx->fp = cfp; | |
1309 | ccx->of = objfile; | |
1310 | pst->read_symtab_private = (void *) ccx; | |
1311 | pst->read_symtab = ctf_read_symtab; | |
1312 | ||
1313 | return pst; | |
1314 | } | |
1315 | ||
1316 | /* Callback to add type TID to partial symbol table. */ | |
1317 | ||
1318 | static int | |
1319 | ctf_psymtab_type_cb (ctf_id_t tid, void *arg) | |
1320 | { | |
1321 | ctf_context_t *ccp; | |
1322 | uint32_t kind; | |
1323 | short section = -1; | |
1324 | ||
1325 | ccp = (ctf_context_t *) arg; | |
1326 | gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (ccp->fp, tid)); | |
1327 | if (name == NULL || strlen (name.get ()) == 0) | |
1328 | return 0; | |
1329 | ||
1330 | domain_enum domain = UNDEF_DOMAIN; | |
1331 | enum address_class aclass = LOC_UNDEF; | |
1332 | kind = ctf_type_kind (ccp->fp, tid); | |
1333 | switch (kind) | |
1334 | { | |
1335 | case CTF_K_STRUCT: | |
1336 | case CTF_K_UNION: | |
1337 | case CTF_K_ENUM: | |
1338 | domain = STRUCT_DOMAIN; | |
1339 | aclass = LOC_TYPEDEF; | |
1340 | break; | |
1341 | case CTF_K_FUNCTION: | |
1342 | case CTF_K_FORWARD: | |
1343 | domain = VAR_DOMAIN; | |
1344 | aclass = LOC_STATIC; | |
1345 | section = SECT_OFF_TEXT (ccp->of); | |
1346 | break; | |
1347 | case CTF_K_CONST: | |
1348 | domain = VAR_DOMAIN; | |
1349 | aclass = LOC_STATIC; | |
1350 | break; | |
1351 | case CTF_K_TYPEDEF: | |
1352 | case CTF_K_POINTER: | |
1353 | case CTF_K_VOLATILE: | |
1354 | case CTF_K_RESTRICT: | |
1355 | domain = VAR_DOMAIN; | |
1356 | aclass = LOC_TYPEDEF; | |
1357 | break; | |
1358 | case CTF_K_INTEGER: | |
1359 | case CTF_K_FLOAT: | |
1360 | domain = VAR_DOMAIN; | |
1361 | aclass = LOC_TYPEDEF; | |
1362 | break; | |
1363 | case CTF_K_ARRAY: | |
1364 | case CTF_K_UNKNOWN: | |
1365 | return 0; | |
1366 | } | |
1367 | ||
1368 | add_psymbol_to_list (name.get (), strlen (name.get ()), true, | |
1369 | domain, aclass, section, | |
1370 | psymbol_placement::GLOBAL, | |
1371 | 0, language_c, ccp->of); | |
1372 | ||
1373 | return 0; | |
1374 | } | |
1375 | ||
1376 | /* Callback to add variable NAME with ID to partial symbol table. */ | |
1377 | ||
1378 | static int | |
1379 | ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg) | |
1380 | { | |
1381 | ctf_context_t *ccp = (ctf_context_t *) arg; | |
1382 | ||
1383 | add_psymbol_to_list (name, strlen (name), true, | |
1384 | VAR_DOMAIN, LOC_STATIC, -1, | |
1385 | psymbol_placement::GLOBAL, | |
1386 | 0, language_c, ccp->of); | |
1387 | return 0; | |
1388 | } | |
1389 | ||
1390 | /* Setup partial_symtab's describing each source file for which | |
1391 | debugging information is available. */ | |
1392 | ||
1393 | static void | |
1394 | scan_partial_symbols (ctf_file_t *cfp, struct objfile *of) | |
1395 | { | |
1396 | ctf_context_t ccx; | |
1397 | bfd *abfd = of->obfd; | |
1398 | const char *name = bfd_get_filename (abfd); | |
1399 | struct partial_symtab *pst = create_partial_symtab (name, cfp, of); | |
1400 | ||
1401 | ccx.fp = cfp; | |
1402 | ccx.of = of; | |
1403 | ||
1404 | if (ctf_type_iter (cfp, ctf_psymtab_type_cb, &ccx) == CTF_ERR) | |
1405 | complaint (_("ctf_type_iter scan_partial_symbols failed - %s"), | |
1406 | ctf_errmsg (ctf_errno (cfp))); | |
1407 | ||
1408 | if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, &ccx) == CTF_ERR) | |
1409 | complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"), | |
1410 | ctf_errmsg (ctf_errno (cfp))); | |
1411 | ||
1412 | /* Scan CTF object and function sections which correspond to each | |
1413 | STT_FUNC or STT_OBJECT entry in the symbol table, | |
1414 | pick up what init_symtab has done. */ | |
1415 | for (unsigned long idx = 0; ; idx++) | |
1416 | { | |
1417 | ctf_id_t tid; | |
1418 | if ((tid = ctf_lookup_by_symbol (cfp, idx)) == CTF_ERR) | |
1419 | { | |
1420 | if (ctf_errno (cfp) == EINVAL || ctf_errno (cfp) == ECTF_NOSYMTAB) | |
1421 | break; // Done, reach end of the section. | |
1422 | else | |
1423 | continue; | |
1424 | } | |
1425 | gdb::unique_xmalloc_ptr<char> tname (ctf_type_aname_raw (cfp, tid)); | |
1426 | uint32_t kind = ctf_type_kind (cfp, tid); | |
1427 | address_class aclass; | |
1428 | domain_enum tdomain; | |
1429 | switch (kind) | |
1430 | { | |
1431 | case CTF_K_STRUCT: | |
1432 | case CTF_K_UNION: | |
1433 | case CTF_K_ENUM: | |
1434 | tdomain = STRUCT_DOMAIN; | |
1435 | break; | |
1436 | default: | |
1437 | tdomain = VAR_DOMAIN; | |
1438 | break; | |
1439 | } | |
1440 | ||
1441 | if (kind == CTF_K_FUNCTION) | |
1442 | aclass = LOC_STATIC; | |
1443 | else if (kind == CTF_K_CONST) | |
1444 | aclass = LOC_CONST; | |
1445 | else | |
1446 | aclass = LOC_TYPEDEF; | |
1447 | ||
1448 | add_psymbol_to_list (tname.get (), strlen (tname.get ()), true, | |
1449 | tdomain, aclass, -1, | |
1450 | psymbol_placement::STATIC, | |
1451 | 0, language_c, of); | |
1452 | } | |
1453 | ||
1454 | end_psymtab_common (of, pst); | |
1455 | } | |
1456 | ||
1457 | /* Read CTF debugging information from a BFD section. This is | |
1458 | called from elfread.c. It does a quick pass through the | |
1459 | .ctf section to set up the partial symbol table. */ | |
1460 | ||
1461 | void | |
1462 | elfctf_build_psymtabs (struct objfile *of) | |
1463 | { | |
1464 | bfd *abfd = of->obfd; | |
1465 | int err; | |
1466 | ||
1467 | ctf_archive_t *arc = ctf_bfdopen (abfd, &err); | |
1468 | if (arc == NULL) | |
1469 | error (_("ctf_bfdopen failed on %s - %s"), | |
1470 | bfd_get_filename (abfd), ctf_errmsg (err)); | |
1471 | ||
1472 | ctf_file_t *fp = ctf_arc_open_by_name (arc, NULL, &err); | |
1473 | if (fp == NULL) | |
1474 | error (_("ctf_arc_open_by_name failed on %s - %s"), | |
1475 | bfd_get_filename (abfd), ctf_errmsg (err)); | |
1476 | set_objfile_data (of, ctf_file_key, fp); | |
1477 | ||
1478 | scan_partial_symbols (fp, of); | |
1479 | } | |
1480 | ||
1481 | void | |
1482 | _initialize_ctfread (void) | |
1483 | { | |
1484 | ctf_file_key | |
1485 | = register_objfile_data_with_cleanup (NULL, ctf_close_objfile); | |
1486 | } |