GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/ctfread.c
Go to the documentation of this file.
1/* Compact ANSI-C Type Format (CTF) support in GDB.
2
3 Copyright (C) 2019-2023 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 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
85#if ENABLE_LIBCTF
86
87#include "ctf.h"
88#include "ctf-api.h"
89
90static const registry<objfile>::key<htab, htab_deleter> ctf_tid_key;
91
93{
94 explicit ctf_fp_info (ctf_dict_t *cfp) : fp (cfp) {}
95 ~ctf_fp_info ();
96 ctf_dict_t *fp;
97};
98
99/* Cleanup function for the ctf_dict_key data. */
101{
102 if (fp == nullptr)
103 return;
104
105 ctf_archive_t *arc = ctf_get_arc (fp);
106 ctf_dict_close (fp);
107 ctf_close (arc);
108}
109
111
112/* A CTF context consists of a file pointer and an objfile pointer. */
113
115{
116 ctf_dict_t *fp;
117 struct objfile *of;
120 ctf_archive_t *arc;
122};
123
124/* A partial symtab, specialized for this module. */
126{
127 ctf_psymtab (const char *filename,
128 psymtab_storage *partial_symtabs,
129 objfile_per_bfd_storage *objfile_per_bfd,
130 CORE_ADDR addr)
131 : standard_psymtab (filename, partial_symtabs, objfile_per_bfd, addr)
132 {
133 }
134
135 void read_symtab (struct objfile *) override;
136 void expand_psymtab (struct objfile *) override;
137
139};
140
141/* The routines that read and process fields/members of a C struct, union,
142 or enumeration, pass lists of data member fields in an instance of a
143 ctf_field_info structure. It is derived from dwarf2read.c. */
144
146{
147 struct field field {};
148};
149
151{
152 /* List of data member fields. */
153 std::vector<struct ctf_nextfield> fields;
154
155 /* Context. */
157
158 /* Parent type. */
159 struct type *ptype;
160
161 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head
162 of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
163 std::vector<struct decl_field> typedef_field_list;
164
165 /* Nested types defined by this struct and the number of elements in
166 this list. */
167 std::vector<struct decl_field> nested_types_list;
168};
169
170/* Data held for a translation unit. */
171
173{
174 ctf_dict_t *fp;
175 struct objfile *of;
176 ctf_archive_t *arc;
179};
180
181/* Local function prototypes */
182
183static int ctf_add_type_cb (ctf_id_t tid, void *arg);
184
185static struct type *read_array_type (struct ctf_context *cp, ctf_id_t tid);
186
187static struct type *read_pointer_type (struct ctf_context *cp, ctf_id_t tid,
188 ctf_id_t btid);
189
190static struct type *read_structure_type (struct ctf_context *cp, ctf_id_t tid);
191
192static struct type *read_enum_type (struct ctf_context *cp, ctf_id_t tid);
193
194static struct type *read_typedef_type (struct ctf_context *cp, ctf_id_t tid,
195 ctf_id_t btid, const char *name);
196
197static struct type *read_type_record (struct ctf_context *cp, ctf_id_t tid);
198
199static void process_structure_type (struct ctf_context *cp, ctf_id_t tid);
200
201static void process_struct_members (struct ctf_context *cp, ctf_id_t tid,
202 struct type *type);
203
204static struct type *read_forward_type (struct ctf_context *cp, ctf_id_t tid);
205
206static struct symbol *new_symbol (struct ctf_context *cp, struct type *type,
207 ctf_id_t tid);
208
210{
211 ctf_id_t tid;
212 struct type *type;
213};
214
215/* Hash function for a ctf_tid_and_type. */
216
217static hashval_t
218tid_and_type_hash (const void *item)
219{
220 const struct ctf_tid_and_type *ids
221 = (const struct ctf_tid_and_type *) item;
222
223 return ids->tid;
224}
225
226/* Equality function for a ctf_tid_and_type. */
227
228static int
229tid_and_type_eq (const void *item_lhs, const void *item_rhs)
230{
231 const struct ctf_tid_and_type *ids_lhs
232 = (const struct ctf_tid_and_type *) item_lhs;
233 const struct ctf_tid_and_type *ids_rhs
234 = (const struct ctf_tid_and_type *) item_rhs;
235
236 return ids_lhs->tid == ids_rhs->tid;
237}
238
239/* Set the type associated with TID to TYP. */
240
241static struct type *
242set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
243{
244 htab_t htab;
245
246 htab = ctf_tid_key.get (of);
247 if (htab == NULL)
248 {
249 htab = htab_create_alloc (1, tid_and_type_hash,
251 NULL, xcalloc, xfree);
252 ctf_tid_key.set (of, htab);
253 }
254
255 struct ctf_tid_and_type **slot, ids;
256 ids.tid = tid;
257 ids.type = typ;
258 slot = (struct ctf_tid_and_type **) htab_find_slot (htab, &ids, INSERT);
259 if (*slot == nullptr)
260 *slot = XOBNEW (&of->objfile_obstack, struct ctf_tid_and_type);
261 **slot = ids;
262 return typ;
263}
264
265/* Look up the type for TID in tid_and_type hash, return NULL if hash is
266 empty or TID does not have a saved type. */
267
268static struct type *
269get_tid_type (struct objfile *of, ctf_id_t tid)
270{
271 struct ctf_tid_and_type *slot, ids;
272 htab_t htab;
273
274 htab = ctf_tid_key.get (of);
275 if (htab == NULL)
276 return nullptr;
277
278 ids.tid = tid;
279 ids.type = nullptr;
280 slot = (struct ctf_tid_and_type *) htab_find (htab, &ids);
281 if (slot)
282 return slot->type;
283 else
284 return nullptr;
285}
286
287/* Fetch the type for TID in CCP OF's tid_and_type hash, add the type to
288 * context CCP if hash is empty or TID does not have a saved type. */
289
290static struct type *
291fetch_tid_type (struct ctf_context *ccp, ctf_id_t tid)
292{
293 struct objfile *of = ccp->of;
294 struct type *typ;
295
296 typ = get_tid_type (of, tid);
297 if (typ == nullptr)
298 {
299 ctf_add_type_cb (tid, ccp);
300 typ = get_tid_type (of, tid);
301 }
302
303 return typ;
304}
305
306/* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */
307
308static int
309get_bitsize (ctf_dict_t *fp, ctf_id_t tid, uint32_t kind)
310{
311 ctf_encoding_t cet;
312
313 if ((kind == CTF_K_INTEGER || kind == CTF_K_ENUM
314 || kind == CTF_K_FLOAT)
315 && ctf_type_reference (fp, tid) != CTF_ERR
316 && ctf_type_encoding (fp, tid, &cet) != CTF_ERR)
317 return cet.cte_bits;
318
319 return 0;
320}
321
322/* Set SYM's address, with NAME, from its minimal symbol entry. */
323
324static void
325set_symbol_address (struct objfile *of, struct symbol *sym, const char *name)
326{
327 struct bound_minimal_symbol msym;
328
329 msym = lookup_minimal_symbol (name, nullptr, of);
330 if (msym.minsym != NULL)
331 {
332 sym->set_value_address (msym.value_address ());
334 sym->set_section_index (msym.minsym->section_index ());
335 }
336}
337
338/* Create the vector of fields, and attach it to TYPE. */
339
340static void
342{
343 int nfields = fip->fields.size ();
344
345 if (nfields == 0)
346 return;
347
348 /* Record the field count, allocate space for the array of fields. */
349 type->set_num_fields (nfields);
351 ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields));
352
353 /* Copy the saved-up fields into the field vector. */
354 for (int i = 0; i < nfields; ++i)
355 {
356 struct ctf_nextfield &field = fip->fields[i];
357 type->field (i) = field.field;
358 }
359}
360
361/* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
362 (which may be different from NAME) to the architecture back-end to allow
363 it to guess the correct format if necessary. */
364
365static struct type *
367 int bits,
368 const char *name,
369 const char *name_hint)
370{
371 struct gdbarch *gdbarch = objfile->arch ();
372 const struct floatformat **format;
373 struct type *type;
374
375 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
376 if (format != nullptr)
377 type = init_float_type (objfile, bits, name, format);
378 else
379 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
380
381 return type;
382}
383
384/* Callback to add member NAME to a struct/union type. TID is the type
385 of struct/union member, OFFSET is the offset of member in bits,
386 and ARG contains the ctf_field_info. */
387
388static int
390 ctf_id_t tid,
391 unsigned long offset,
392 void *arg)
393{
394 struct ctf_field_info *fip = (struct ctf_field_info *) arg;
395 struct ctf_context *ccp = fip->cur_context;
396 struct ctf_nextfield new_field;
397 struct field *fp;
398 struct type *t;
399 uint32_t kind;
400
401 fp = &new_field.field;
402 fp->set_name (name);
403
404 kind = ctf_type_kind (ccp->fp, tid);
405 t = fetch_tid_type (ccp, tid);
406 if (t == nullptr)
407 {
408 t = read_type_record (ccp, tid);
409 if (t == nullptr)
410 {
411 complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid);
412 t = objfile_type (ccp->of)->builtin_error;
413 set_tid_type (ccp->of, tid, t);
414 }
415 }
416
417 if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
418 process_struct_members (ccp, tid, t);
419
420 fp->set_type (t);
421 fp->set_loc_bitpos (offset / TARGET_CHAR_BIT);
422 FIELD_BITSIZE (*fp) = get_bitsize (ccp->fp, tid, kind);
423
424 fip->fields.emplace_back (new_field);
425
426 return 0;
427}
428
429/* Callback to add member NAME of EVAL to an enumeration type.
430 ARG contains the ctf_field_info. */
431
432static int
433ctf_add_enum_member_cb (const char *name, int enum_value, void *arg)
434{
435 struct ctf_field_info *fip = (struct ctf_field_info *) arg;
436 struct ctf_nextfield new_field;
437 struct field *fp;
438 struct ctf_context *ccp = fip->cur_context;
439
440 fp = &new_field.field;
441 fp->set_name (name);
442 fp->set_type (nullptr);
443 fp->set_loc_enumval (enum_value);
444 FIELD_BITSIZE (*fp) = 0;
445
446 if (name != nullptr)
447 {
448 struct symbol *sym = new (&ccp->of->objfile_obstack) symbol;
449 OBJSTAT (ccp->of, n_syms++);
450
452 sym->compute_and_set_names (name, false, ccp->of->per_bfd);
454 sym->set_domain (VAR_DOMAIN);
455 sym->set_type (fip->ptype);
457 }
458
459 fip->fields.emplace_back (new_field);
460
461 return 0;
462}
463
464/* Add a new symbol entry, with its name from TID, its access index and
465 domain from TID's kind, and its type from TYPE. */
466
467static struct symbol *
468new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
469{
470 struct objfile *objfile = ccp->of;
471 ctf_dict_t *fp = ccp->fp;
472 struct symbol *sym = nullptr;
473
474 const char *name = ctf_type_name_raw (fp, tid);
475 if (name != nullptr)
476 {
477 sym = new (&objfile->objfile_obstack) symbol;
478 OBJSTAT (objfile, n_syms++);
479
482 sym->set_domain (VAR_DOMAIN);
484
485 if (type != nullptr)
486 sym->set_type (type);
487
488 uint32_t kind = ctf_type_kind (fp, tid);
489 switch (kind)
490 {
491 case CTF_K_STRUCT:
492 case CTF_K_UNION:
493 case CTF_K_ENUM:
496 break;
497 case CTF_K_FUNCTION:
500 break;
501 case CTF_K_CONST:
502 if (sym->type ()->code () == TYPE_CODE_VOID)
503 sym->set_type (objfile_type (objfile)->builtin_int);
504 break;
505 case CTF_K_TYPEDEF:
506 case CTF_K_INTEGER:
507 case CTF_K_FLOAT:
509 sym->set_domain (VAR_DOMAIN);
510 break;
511 case CTF_K_POINTER:
512 break;
513 case CTF_K_VOLATILE:
514 case CTF_K_RESTRICT:
515 break;
516 case CTF_K_SLICE:
517 case CTF_K_ARRAY:
518 case CTF_K_UNKNOWN:
519 break;
520 }
521
523 }
524
525 return sym;
526}
527
528/* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
529 and create the symbol for it. */
530
531static struct type *
532read_base_type (struct ctf_context *ccp, ctf_id_t tid)
533{
534 struct objfile *of = ccp->of;
535 ctf_dict_t *fp = ccp->fp;
536 ctf_encoding_t cet;
537 struct type *type = nullptr;
538 const char *name;
539 uint32_t kind;
540
541 if (ctf_type_encoding (fp, tid, &cet))
542 {
543 complaint (_("ctf_type_encoding read_base_type failed - %s"),
544 ctf_errmsg (ctf_errno (fp)));
545 return nullptr;
546 }
547
548 name = ctf_type_name_raw (fp, tid);
549 if (name == nullptr || strlen (name) == 0)
550 {
551 name = ctf_type_aname (fp, tid);
552 if (name == nullptr)
553 complaint (_("ctf_type_aname read_base_type failed - %s"),
554 ctf_errmsg (ctf_errno (fp)));
555 }
556
557 kind = ctf_type_kind (fp, tid);
558 if (kind == CTF_K_INTEGER)
559 {
560 uint32_t issigned, ischar, isbool;
561 struct gdbarch *gdbarch = of->arch ();
562
563 issigned = cet.cte_format & CTF_INT_SIGNED;
564 ischar = cet.cte_format & CTF_INT_CHAR;
565 isbool = cet.cte_format & CTF_INT_BOOL;
566 if (ischar)
567 type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name);
568 else if (isbool)
570 !issigned, name);
571 else
572 {
573 int bits;
574 if (cet.cte_bits && ((cet.cte_bits % TARGET_CHAR_BIT) == 0))
575 bits = cet.cte_bits;
576 else
578 type = init_integer_type (of, bits, !issigned, name);
579 }
580 }
581 else if (kind == CTF_K_FLOAT)
582 {
583 uint32_t isflt;
584 isflt = !((cet.cte_format & CTF_FP_IMAGRY) == CTF_FP_IMAGRY
585 || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY
586 || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY);
587 if (isflt)
588 type = ctf_init_float_type (of, cet.cte_bits, name, name);
589 else
590 {
591 struct type *t
592 = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
594 }
595 }
596 else
597 {
598 complaint (_("read_base_type: unsupported base kind (%d)"), kind);
599 type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name);
600 }
601
602 if (name != nullptr && strcmp (name, "char") == 0)
604
605 return set_tid_type (of, tid, type);
606}
607
608static void
609process_base_type (struct ctf_context *ccp, ctf_id_t tid)
610{
611 struct type *type;
612
613 type = read_base_type (ccp, tid);
614 new_symbol (ccp, type, tid);
615}
616
617/* Start a structure or union scope (definition) with TID to create a type
618 for the structure or union.
619
620 Fill in the type's name and general properties. The members will not be
621 processed, nor a symbol table entry be done until process_structure_type
622 (assuming the type has a name). */
623
624static struct type *
625read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
626{
627 struct objfile *of = ccp->of;
628 ctf_dict_t *fp = ccp->fp;
629 struct type *type;
630 uint32_t kind;
631
632 type = alloc_type (of);
633
634 const char *name = ctf_type_name_raw (fp, tid);
635 if (name != nullptr && strlen (name) != 0)
636 type->set_name (name);
637
638 kind = ctf_type_kind (fp, tid);
639 if (kind == CTF_K_UNION)
640 type->set_code (TYPE_CODE_UNION);
641 else
642 type->set_code (TYPE_CODE_STRUCT);
643
644 type->set_length (ctf_type_size (fp, tid));
645 set_type_align (type, ctf_type_align (fp, tid));
646
647 return set_tid_type (ccp->of, tid, type);
648}
649
650/* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
651 and create the symbol for it. */
652
653static void
655 ctf_id_t tid,
656 struct type *type)
657{
658 struct ctf_field_info fi;
659
660 fi.cur_context = ccp;
661 if (ctf_member_iter (ccp->fp, tid, ctf_add_member_cb, &fi) == CTF_ERR)
662 complaint (_("ctf_member_iter process_struct_members failed - %s"),
663 ctf_errmsg (ctf_errno (ccp->fp)));
664
665 /* Attach fields to the type. */
667
668 new_symbol (ccp, type, tid);
669}
670
671static void
672process_structure_type (struct ctf_context *ccp, ctf_id_t tid)
673{
674 struct type *type;
675
676 type = read_structure_type (ccp, tid);
677 process_struct_members (ccp, tid, type);
678}
679
680/* Create a function type for TID and set its return type. */
681
682static struct type *
683read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
684{
685 struct objfile *of = ccp->of;
686 ctf_dict_t *fp = ccp->fp;
687 struct type *type, *rettype, *atype;
688 ctf_funcinfo_t cfi;
689 uint32_t argc;
690
691 type = alloc_type (of);
692
693 type->set_code (TYPE_CODE_FUNC);
694 if (ctf_func_type_info (fp, tid, &cfi) < 0)
695 {
696 const char *fname = ctf_type_name_raw (fp, tid);
697 error (_("Error getting function type info: %s"),
698 fname == nullptr ? "noname" : fname);
699 }
700 rettype = fetch_tid_type (ccp, cfi.ctc_return);
701 type->set_target_type (rettype);
702 set_type_align (type, ctf_type_align (fp, tid));
703
704 /* Set up function's arguments. */
705 argc = cfi.ctc_argc;
706 type->set_num_fields (argc);
707 if ((cfi.ctc_flags & CTF_FUNC_VARARG) != 0)
708 type->set_has_varargs (true);
709
710 if (argc != 0)
711 {
712 std::vector<ctf_id_t> argv (argc);
713 if (ctf_func_type_args (fp, tid, argc, argv.data ()) == CTF_ERR)
714 return nullptr;
715
717 ((struct field *) TYPE_ZALLOC (type, argc * sizeof (struct field)));
718 struct type *void_type = objfile_type (of)->builtin_void;
719 /* If failed to find the argument type, fill it with void_type. */
720 for (int iparam = 0; iparam < argc; iparam++)
721 {
722 atype = fetch_tid_type (ccp, argv[iparam]);
723 if (atype != nullptr)
724 type->field (iparam).set_type (atype);
725 else
726 type->field (iparam).set_type (void_type);
727 }
728 }
729
730 return set_tid_type (of, tid, type);
731}
732
733/* Given a TID of CTF_K_ENUM, process all the members of the
734 enumeration, and create the symbol for the enumeration type. */
735
736static struct type *
737read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
738{
739 struct objfile *of = ccp->of;
740 ctf_dict_t *fp = ccp->fp;
741 struct type *type;
742
743 type = alloc_type (of);
744
745 const char *name = ctf_type_name_raw (fp, tid);
746 if (name != nullptr && strlen (name) != 0)
747 type->set_name (name);
748
749 type->set_code (TYPE_CODE_ENUM);
750 type->set_length (ctf_type_size (fp, tid));
751 /* Set the underlying type based on its ctf_type_size bits. */
752 type->set_target_type (objfile_int_type (of, type->length (), false));
753 set_type_align (type, ctf_type_align (fp, tid));
754
755 return set_tid_type (of, tid, type);
756}
757
758static void
759process_enum_type (struct ctf_context *ccp, ctf_id_t tid)
760{
761 struct type *type;
762 struct ctf_field_info fi;
763
764 type = read_enum_type (ccp, tid);
765
766 fi.cur_context = ccp;
767 fi.ptype = type;
768 if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
769 complaint (_("ctf_enum_iter process_enum_type failed - %s"),
770 ctf_errmsg (ctf_errno (ccp->fp)));
771
772 /* Attach fields to the type. */
774
775 new_symbol (ccp, type, tid);
776}
777
778/* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */
779
780static struct type *
782 ctf_id_t tid,
783 struct type *base_type,
784 int cnst,
785 int voltl)
786{
787 struct type *el_type, *inner_array;
788
789 base_type = copy_type (base_type);
790 inner_array = base_type;
791
792 while (inner_array->target_type ()->code () == TYPE_CODE_ARRAY)
793 {
794 inner_array->set_target_type (copy_type (inner_array->target_type ()));
795 inner_array = inner_array->target_type ();
796 }
797
798 el_type = inner_array->target_type ();
799 cnst |= TYPE_CONST (el_type);
800 voltl |= TYPE_VOLATILE (el_type);
801 inner_array->set_target_type (make_cv_type (cnst, voltl, el_type, nullptr));
802
803 return set_tid_type (ccp->of, tid, base_type);
804}
805
806/* Read all information from a TID of CTF_K_ARRAY. */
807
808static struct type *
809read_array_type (struct ctf_context *ccp, ctf_id_t tid)
810{
811 struct objfile *objfile = ccp->of;
812 ctf_dict_t *fp = ccp->fp;
813 struct type *element_type, *range_type, *idx_type;
814 struct type *type;
815 ctf_arinfo_t ar;
816
817 if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
818 {
819 complaint (_("ctf_array_info read_array_type failed - %s"),
820 ctf_errmsg (ctf_errno (fp)));
821 return nullptr;
822 }
823
824 element_type = fetch_tid_type (ccp, ar.ctr_contents);
825 if (element_type == nullptr)
826 return nullptr;
827
828 idx_type = fetch_tid_type (ccp, ar.ctr_index);
829 if (idx_type == nullptr)
830 idx_type = objfile_type (objfile)->builtin_int;
831
832 range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
833 type = create_array_type (NULL, element_type, range_type);
834 if (ar.ctr_nelems <= 1) /* Check if undefined upper bound. */
835 {
836 range_type->bounds ()->high.set_undefined ();
837 type->set_length (0);
838 type->set_target_is_stub (true);
839 }
840 else
841 type->set_length (ctf_type_size (fp, tid));
842
843 set_type_align (type, ctf_type_align (fp, tid));
844
845 return set_tid_type (objfile, tid, type);
846}
847
848/* Read TID of kind CTF_K_CONST with base type BTID. */
849
850static struct type *
851read_const_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
852{
853 struct objfile *objfile = ccp->of;
854 struct type *base_type, *cv_type;
855
856 base_type = fetch_tid_type (ccp, btid);
857 if (base_type == nullptr)
858 {
859 base_type = read_type_record (ccp, btid);
860 if (base_type == nullptr)
861 {
862 complaint (_("read_const_type: NULL base type (%ld)"), btid);
863 base_type = objfile_type (objfile)->builtin_error;
864 }
865 }
866 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
867
868 return set_tid_type (objfile, tid, cv_type);
869}
870
871/* Read TID of kind CTF_K_VOLATILE with base type BTID. */
872
873static struct type *
874read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
875{
876 struct objfile *objfile = ccp->of;
877 ctf_dict_t *fp = ccp->fp;
878 struct type *base_type, *cv_type;
879
880 base_type = fetch_tid_type (ccp, btid);
881 if (base_type == nullptr)
882 {
883 base_type = read_type_record (ccp, btid);
884 if (base_type == nullptr)
885 {
886 complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
887 base_type = objfile_type (objfile)->builtin_error;
888 }
889 }
890
891 if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
892 return add_array_cv_type (ccp, tid, base_type, 0, 1);
893 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
894
895 return set_tid_type (objfile, tid, cv_type);
896}
897
898/* Read TID of kind CTF_K_RESTRICT with base type BTID. */
899
900static struct type *
901read_restrict_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
902{
903 struct objfile *objfile = ccp->of;
904 struct type *base_type, *cv_type;
905
906 base_type = fetch_tid_type (ccp, btid);
907 if (base_type == nullptr)
908 {
909 base_type = read_type_record (ccp, btid);
910 if (base_type == nullptr)
911 {
912 complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
913 base_type = objfile_type (objfile)->builtin_error;
914 }
915 }
916 cv_type = make_restrict_type (base_type);
917
918 return set_tid_type (objfile, tid, cv_type);
919}
920
921/* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */
922
923static struct type *
924read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
925 ctf_id_t btid, const char *name)
926{
927 struct objfile *objfile = ccp->of;
928 struct type *this_type, *target_type;
929
930 char *aname = obstack_strdup (&objfile->objfile_obstack, name);
931 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname);
932 set_tid_type (objfile, tid, this_type);
933 target_type = fetch_tid_type (ccp, btid);
934 if (target_type != this_type)
935 this_type->set_target_type (target_type);
936 else
937 this_type->set_target_type (nullptr);
938
939 this_type->set_target_is_stub (this_type->target_type () != nullptr);
940
941 return set_tid_type (objfile, tid, this_type);
942}
943
944/* Read TID of kind CTF_K_POINTER with base type BTID. */
945
946static struct type *
947read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
948{
949 struct objfile *of = ccp->of;
950 struct type *target_type, *type;
951
952 target_type = fetch_tid_type (ccp, btid);
953 if (target_type == nullptr)
954 {
955 target_type = read_type_record (ccp, btid);
956 if (target_type == nullptr)
957 {
958 complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
960 }
961 }
962
964 set_type_align (type, ctf_type_align (ccp->fp, tid));
965
966 return set_tid_type (of, tid, type);
967}
968
969/* Read information from a TID of CTF_K_FORWARD. */
970
971static struct type *
972read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
973{
974 struct objfile *of = ccp->of;
975 ctf_dict_t *fp = ccp->fp;
976 struct type *type;
977 uint32_t kind;
978
979 type = alloc_type (of);
980
981 const char *name = ctf_type_name_raw (fp, tid);
982 if (name != nullptr && strlen (name) != 0)
983 type->set_name (name);
984
985 kind = ctf_type_kind_forwarded (fp, tid);
986 if (kind == CTF_K_UNION)
987 type->set_code (TYPE_CODE_UNION);
988 else
989 type->set_code (TYPE_CODE_STRUCT);
990
991 type->set_length (0);
992 type->set_is_stub (true);
993
994 return set_tid_type (of, tid, type);
995}
996
997/* Read information associated with type TID. */
998
999static struct type *
1000read_type_record (struct ctf_context *ccp, ctf_id_t tid)
1001{
1002 ctf_dict_t *fp = ccp->fp;
1003 uint32_t kind;
1004 struct type *type = nullptr;
1005 ctf_id_t btid;
1006
1007 kind = ctf_type_kind (fp, tid);
1008 switch (kind)
1009 {
1010 case CTF_K_STRUCT:
1011 case CTF_K_UNION:
1012 type = read_structure_type (ccp, tid);
1013 break;
1014 case CTF_K_ENUM:
1015 type = read_enum_type (ccp, tid);
1016 break;
1017 case CTF_K_FUNCTION:
1018 type = read_func_kind_type (ccp, tid);
1019 break;
1020 case CTF_K_CONST:
1021 btid = ctf_type_reference (fp, tid);
1022 type = read_const_type (ccp, tid, btid);
1023 break;
1024 case CTF_K_TYPEDEF:
1025 {
1026 const char *name = ctf_type_name_raw (fp, tid);
1027 btid = ctf_type_reference (fp, tid);
1028 type = read_typedef_type (ccp, tid, btid, name);
1029 }
1030 break;
1031 case CTF_K_VOLATILE:
1032 btid = ctf_type_reference (fp, tid);
1033 type = read_volatile_type (ccp, tid, btid);
1034 break;
1035 case CTF_K_RESTRICT:
1036 btid = ctf_type_reference (fp, tid);
1037 type = read_restrict_type (ccp, tid, btid);
1038 break;
1039 case CTF_K_POINTER:
1040 btid = ctf_type_reference (fp, tid);
1041 type = read_pointer_type (ccp, tid, btid);
1042 break;
1043 case CTF_K_INTEGER:
1044 case CTF_K_FLOAT:
1045 type = read_base_type (ccp, tid);
1046 break;
1047 case CTF_K_ARRAY:
1048 type = read_array_type (ccp, tid);
1049 break;
1050 case CTF_K_FORWARD:
1051 type = read_forward_type (ccp, tid);
1052 break;
1053 case CTF_K_UNKNOWN:
1054 break;
1055 default:
1056 break;
1057 }
1058
1059 return type;
1060}
1061
1062/* Callback to add type TID to the symbol table. */
1063
1064static int
1065ctf_add_type_cb (ctf_id_t tid, void *arg)
1066{
1067 struct ctf_context *ccp = (struct ctf_context *) arg;
1068 struct type *type;
1069 uint32_t kind;
1070
1071 /* Check if tid's type has already been defined. */
1072 type = get_tid_type (ccp->of, tid);
1073 if (type != nullptr)
1074 return 0;
1075
1076 ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
1077 kind = ctf_type_kind (ccp->fp, tid);
1078 switch (kind)
1079 {
1080 case CTF_K_STRUCT:
1081 case CTF_K_UNION:
1082 process_structure_type (ccp, tid);
1083 break;
1084 case CTF_K_ENUM:
1085 process_enum_type (ccp, tid);
1086 break;
1087 case CTF_K_FUNCTION:
1088 type = read_func_kind_type (ccp, tid);
1089 new_symbol (ccp, type, tid);
1090 break;
1091 case CTF_K_INTEGER:
1092 case CTF_K_FLOAT:
1093 process_base_type (ccp, tid);
1094 break;
1095 case CTF_K_TYPEDEF:
1096 new_symbol (ccp, read_type_record (ccp, tid), tid);
1097 break;
1098 case CTF_K_CONST:
1099 type = read_const_type (ccp, tid, btid);
1100 new_symbol (ccp, type, tid);
1101 break;
1102 case CTF_K_VOLATILE:
1103 type = read_volatile_type (ccp, tid, btid);
1104 new_symbol (ccp, type, tid);
1105 break;
1106 case CTF_K_RESTRICT:
1107 type = read_restrict_type (ccp, tid, btid);
1108 new_symbol (ccp, type, tid);
1109 break;
1110 case CTF_K_POINTER:
1111 type = read_pointer_type (ccp, tid, btid);
1112 new_symbol (ccp, type, tid);
1113 break;
1114 case CTF_K_ARRAY:
1115 type = read_array_type (ccp, tid);
1116 new_symbol (ccp, type, tid);
1117 break;
1118 case CTF_K_UNKNOWN:
1119 break;
1120 default:
1121 break;
1122 }
1123
1124 return 0;
1125}
1126
1127/* Callback to add variable NAME with TID to the symbol table. */
1128
1129static int
1130ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
1131{
1132 struct ctf_context *ccp = (struct ctf_context *) arg;
1133 struct symbol *sym = nullptr;
1134 struct type *type;
1135 uint32_t kind;
1136
1137 type = get_tid_type (ccp->of, id);
1138
1139 kind = ctf_type_kind (ccp->fp, id);
1140 switch (kind)
1141 {
1142 case CTF_K_FUNCTION:
1143 if (name != nullptr && strcmp (name, "main") == 0)
1145 break;
1146 case CTF_K_INTEGER:
1147 case CTF_K_FLOAT:
1148 case CTF_K_VOLATILE:
1149 case CTF_K_RESTRICT:
1150 case CTF_K_TYPEDEF:
1151 case CTF_K_CONST:
1152 case CTF_K_POINTER:
1153 case CTF_K_ARRAY:
1154 if (type != nullptr)
1155 {
1156 sym = new_symbol (ccp, type, id);
1157 if (sym != nullptr)
1158 sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1159 }
1160 break;
1161 case CTF_K_STRUCT:
1162 case CTF_K_UNION:
1163 case CTF_K_ENUM:
1164 if (type == nullptr)
1165 {
1166 complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
1168 }
1169 sym = new (&ccp->of->objfile_obstack) symbol;
1170 OBJSTAT (ccp->of, n_syms++);
1171 sym->set_type (type);
1172 sym->set_domain (VAR_DOMAIN);
1174 sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1176 break;
1177 default:
1178 complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
1179 break;
1180 }
1181
1182 if (sym != nullptr)
1183 set_symbol_address (ccp->of, sym, name);
1184
1185 return 0;
1186}
1187
1188/* Add entries in either data objects or function info section, controlled
1189 by FUNCTIONS. */
1190
1191static void
1192add_stt_entries (struct ctf_context *ccp, int functions)
1193{
1194 ctf_next_t *i = nullptr;
1195 const char *tname;
1196 ctf_id_t tid;
1197 struct symbol *sym = nullptr;
1198 struct type *type;
1199
1200 while ((tid = ctf_symbol_next (ccp->fp, &i, &tname, functions)) != CTF_ERR)
1201 {
1202 type = get_tid_type (ccp->of, tid);
1203 if (type == nullptr)
1204 continue;
1205 sym = new (&ccp->of->objfile_obstack) symbol;
1206 OBJSTAT (ccp->of, n_syms++);
1207 sym->set_type (type);
1208 sym->set_domain (VAR_DOMAIN);
1210 sym->compute_and_set_names (tname, false, ccp->of->per_bfd);
1212 set_symbol_address (ccp->of, sym, tname);
1213 }
1214}
1215
1216/* Add entries in data objects section. */
1217
1218static void
1220{
1221 add_stt_entries (ccp, 0);
1222}
1223
1224/* Add entries in function info section. */
1225
1226static void
1228{
1229 add_stt_entries (ccp, 1);
1230}
1231
1232/* Get text segment base for OBJFILE, TSIZE contains the segment size. */
1233
1234static CORE_ADDR
1235get_objfile_text_range (struct objfile *of, int *tsize)
1236{
1237 bfd *abfd = of->obfd.get ();
1238 const asection *codes;
1239
1240 codes = bfd_get_section_by_name (abfd, ".text");
1241 *tsize = codes ? bfd_section_size (codes) : 0;
1242 return of->text_section_offset ();
1243}
1244
1245/* Start a symtab for OBJFILE in CTF format. */
1246
1247static void
1249 struct objfile *of, CORE_ADDR text_offset)
1250{
1251 struct ctf_context *ccp;
1252
1253 ccp = &pst->context;
1254 ccp->builder = new buildsym_compunit
1255 (of, pst->filename, nullptr,
1256 language_c, text_offset);
1257 ccp->builder->record_debugformat ("ctf");
1258}
1259
1260/* Finish reading symbol/type definitions in CTF format.
1261 END_ADDR is the end address of the file's text. SECTION is
1262 the .text section number. */
1263
1264static struct compunit_symtab *
1266 CORE_ADDR end_addr, int section)
1267{
1268 struct ctf_context *ccp;
1269
1270 ccp = &pst->context;
1271 struct compunit_symtab *result
1272 = ccp->builder->end_compunit_symtab (end_addr, section);
1273 delete ccp->builder;
1274 ccp->builder = nullptr;
1275 return result;
1276}
1277
1278/* Add all members of an enum with type TID to partial symbol table. */
1279
1280static void
1281ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid)
1282{
1283 int val;
1284 const char *ename;
1285 ctf_next_t *i = nullptr;
1286
1287 while ((ename = ctf_enum_next (ccp->fp, tid, &i, &val)) != nullptr)
1288 {
1289 ccp->pst->add_psymbol (ename, true,
1290 VAR_DOMAIN, LOC_CONST, -1,
1292 0, language_c, ccp->partial_symtabs, ccp->of);
1293 }
1294 if (ctf_errno (ccp->fp) != ECTF_NEXT_END)
1295 complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1296 ctf_errmsg (ctf_errno (ccp->fp)));
1297}
1298
1299/* Add entries in either data objects or function info section, controlled
1300 by FUNCTIONS, to psymtab. */
1301
1302static void
1304 struct objfile *of, int functions)
1305{
1306 ctf_next_t *i = nullptr;
1307 ctf_id_t tid;
1308 const char *tname;
1309
1310 while ((tid = ctf_symbol_next (cfp, &i, &tname, functions)) != CTF_ERR)
1311 {
1312 uint32_t kind = ctf_type_kind (cfp, tid);
1313 address_class aclass;
1314 domain_enum tdomain;
1315 switch (kind)
1316 {
1317 case CTF_K_STRUCT:
1318 case CTF_K_UNION:
1319 case CTF_K_ENUM:
1320 tdomain = STRUCT_DOMAIN;
1321 break;
1322 default:
1323 tdomain = VAR_DOMAIN;
1324 break;
1325 }
1326
1327 if (kind == CTF_K_FUNCTION)
1328 aclass = LOC_STATIC;
1329 else if (kind == CTF_K_CONST)
1330 aclass = LOC_CONST;
1331 else
1332 aclass = LOC_TYPEDEF;
1333
1334 pst->add_psymbol (tname, true,
1335 tdomain, aclass, -1,
1337 0, language_c, pst->context.partial_symtabs, of);
1338 }
1339}
1340
1341/* Add entries in data objects section to psymtab. */
1342
1343static void
1345 struct objfile *of)
1346{
1347 ctf_psymtab_add_stt_entries (cfp, pst, of, 0);
1348}
1349
1350/* Add entries in function info section to psymtab. */
1351
1352static void
1354 struct objfile *of)
1355{
1356 ctf_psymtab_add_stt_entries (cfp, pst, of, 1);
1357}
1358
1359/* Read in full symbols for PST, and anything it depends on. */
1360
1361void
1363{
1364 struct ctf_context *ccp;
1365
1366 gdb_assert (!readin);
1367
1368 ccp = &context;
1369
1370 /* Iterate over entries in data types section. */
1371 if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
1372 complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1373 ctf_errmsg (ctf_errno (ccp->fp)));
1374
1375
1376 /* Iterate over entries in variable info section. */
1377 if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
1378 complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1379 ctf_errmsg (ctf_errno (ccp->fp)));
1380
1381 /* Add entries in data objects and function info sections. */
1382 add_stt_obj (ccp);
1383 add_stt_func (ccp);
1384
1385 readin = true;
1386}
1387
1388/* Expand partial symbol table PST into a full symbol table.
1389 PST is not NULL. */
1390
1391void
1393{
1394 if (readin)
1395 warning (_("bug: psymtab for %s is already read in."), filename);
1396 else
1397 {
1398 if (info_verbose)
1399 {
1400 gdb_printf (_("Reading in CTF data for %s..."), filename);
1402 }
1403
1404 /* Start a symtab. */
1405 CORE_ADDR offset; /* Start of text segment. */
1406 int tsize;
1407
1408 offset = get_objfile_text_range (objfile, &tsize);
1409 ctf_start_compunit_symtab (this, objfile, offset);
1411
1412 set_text_low (offset);
1413 set_text_high (offset + tsize);
1414 compunit_symtab = ctf_end_compunit_symtab (this, offset + tsize,
1416
1417 /* Finish up the debug error message. */
1418 if (info_verbose)
1419 gdb_printf (_("done.\n"));
1420 }
1421}
1422
1423/* Allocate a new partial_symtab NAME.
1424
1425 Each source file that has not been fully read in is represented by
1426 a partial_symtab. This contains the information on where in the
1427 executable the debugging symbols for a specific file are, and a
1428 list of names of global symbols which are located in this file.
1429 They are all chained on partial symtab lists.
1430
1431 Even after the source file has been read into a symtab, the
1432 partial_symtab remains around. They are allocated on an obstack,
1433 objfile_obstack. */
1434
1435static ctf_psymtab *
1437 ctf_archive_t *arc,
1438 ctf_dict_t *cfp,
1440 struct objfile *objfile)
1441{
1443
1445
1446 pst->context.arc = arc;
1447 pst->context.fp = cfp;
1448 pst->context.of = objfile;
1449 pst->context.partial_symtabs = partial_symtabs;
1450 pst->context.pst = pst;
1451 pst->context.builder = nullptr;
1452
1453 return pst;
1454}
1455
1456/* Callback to add type TID to partial symbol table. */
1457
1458static int
1459ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
1460{
1461 struct ctf_context *ccp;
1462 uint32_t kind;
1463 short section = -1;
1464
1465 ccp = (struct ctf_context *) arg;
1466
1467 domain_enum domain = UNDEF_DOMAIN;
1468 enum address_class aclass = LOC_UNDEF;
1469 kind = ctf_type_kind (ccp->fp, tid);
1470 switch (kind)
1471 {
1472 case CTF_K_ENUM:
1473 ctf_psymtab_add_enums (ccp, tid);
1474 /* FALL THROUGH */
1475 case CTF_K_STRUCT:
1476 case CTF_K_UNION:
1477 domain = STRUCT_DOMAIN;
1478 aclass = LOC_TYPEDEF;
1479 break;
1480 case CTF_K_FUNCTION:
1481 case CTF_K_FORWARD:
1482 domain = VAR_DOMAIN;
1483 aclass = LOC_STATIC;
1484 section = SECT_OFF_TEXT (ccp->of);
1485 break;
1486 case CTF_K_CONST:
1487 domain = VAR_DOMAIN;
1488 aclass = LOC_STATIC;
1489 break;
1490 case CTF_K_TYPEDEF:
1491 case CTF_K_POINTER:
1492 case CTF_K_VOLATILE:
1493 case CTF_K_RESTRICT:
1494 domain = VAR_DOMAIN;
1495 aclass = LOC_TYPEDEF;
1496 break;
1497 case CTF_K_INTEGER:
1498 case CTF_K_FLOAT:
1499 domain = VAR_DOMAIN;
1500 aclass = LOC_TYPEDEF;
1501 break;
1502 case CTF_K_ARRAY:
1503 case CTF_K_UNKNOWN:
1504 return 0;
1505 }
1506
1507 const char *name = ctf_type_name_raw (ccp->fp, tid);
1508 if (name == nullptr || strlen (name) == 0)
1509 return 0;
1510
1511 ccp->pst->add_psymbol (name, false,
1512 domain, aclass, section,
1514 0, language_c, ccp->partial_symtabs, ccp->of);
1515
1516 return 0;
1517}
1518
1519/* Callback to add variable NAME with ID to partial symbol table. */
1520
1521static int
1522ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg)
1523{
1524 struct ctf_context *ccp = (struct ctf_context *) arg;
1525
1526 ccp->pst->add_psymbol (name, true,
1529 0, language_c, ccp->partial_symtabs, ccp->of);
1530 return 0;
1531}
1532
1533/* Setup partial_symtab's describing each source file for which
1534 debugging information is available. */
1535
1536static void
1538 struct ctf_per_tu_data *tup, const char *fname)
1539{
1540 struct objfile *of = tup->of;
1541 bool isparent = false;
1542
1543 if (strcmp (fname, ".ctf") == 0)
1544 {
1545 fname = bfd_get_filename (of->obfd.get ());
1546 isparent = true;
1547 }
1548
1549 ctf_psymtab *pst = create_partial_symtab (fname, tup->arc, cfp,
1550 partial_symtabs, of);
1551
1552 struct ctf_context *ccx = &pst->context;
1553 if (isparent == false)
1554 ccx->pst = pst;
1555
1556 if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
1557 complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1558 ctf_errmsg (ctf_errno (cfp)));
1559
1560 if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
1561 complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1562 ctf_errmsg (ctf_errno (cfp)));
1563
1564 /* Scan CTF object and function sections which correspond to each
1565 STT_FUNC or STT_OBJECT entry in the symbol table,
1566 pick up what init_symtab has done. */
1569
1570 pst->end ();
1571}
1572
1573/* Callback to build the psymtab for archive member NAME. */
1574
1575static int
1576build_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
1577{
1578 struct ctf_per_tu_data *tup = (struct ctf_per_tu_data *) arg;
1579 ctf_dict_t *parent = tup->fp;
1580
1581 if (strcmp (name, ".ctf") != 0)
1582 ctf_import (ctf, parent);
1583
1584 if (info_verbose)
1585 {
1586 gdb_printf (_("Scanning archive member %s..."), name);
1588 }
1589
1590 psymtab_storage *pss = tup->psf->get_partial_symtabs ().get ();
1591 scan_partial_symbols (ctf, pss, tup, name);
1592
1593 return 0;
1594}
1595
1596/* Read CTF debugging information from a BFD section. This is
1597 called from elfread.c. It does a quick pass through the
1598 .ctf section to set up the partial symbol table. */
1599
1600void
1602{
1603 struct ctf_per_tu_data pcu;
1604 bfd *abfd = of->obfd.get ();
1605 int err;
1606
1607 ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
1608 if (arc == nullptr)
1609 error (_("ctf_bfdopen failed on %s - %s"),
1610 bfd_get_filename (abfd), ctf_errmsg (err));
1611
1612 ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
1613 if (fp == nullptr)
1614 error (_("ctf_dict_open failed on %s - %s"),
1615 bfd_get_filename (abfd), ctf_errmsg (err));
1616 ctf_dict_key.emplace (of, fp);
1617
1618 pcu.fp = fp;
1619 pcu.of = of;
1620 pcu.arc = arc;
1621
1623 of->qf.emplace_front (psf);
1624 pcu.psf = psf;
1625
1626 if (ctf_archive_iter (arc, build_ctf_archive_member, &pcu) < 0)
1627 error (_("ctf_archive_iter failed in input file %s: - %s"),
1628 bfd_get_filename (abfd), ctf_errmsg (err));
1629}
1630
1631#else
1632
1633void
1635{
1636 /* Nothing to do if CTF is disabled. */
1637}
1638
1639#endif /* ENABLE_LIBCTF */
#define bits(obj, st, fn)
Definition: aarch64-insn.h:35
const char *const name
Definition: aarch64-tdep.c:67
void xfree(void *)
void * xcalloc(size_t number, size_t size)
Definition: alloc.c:85
void add_symbol_to_list(struct symbol *symbol, struct pending **listhead)
Definition: buildsym.c:125
void set(unsigned key, void *datum)
Definition: registry.h:204
void * get(unsigned key)
Definition: registry.h:211
#define complaint(FMT,...)
Definition: complaints.h:47
static int ctf_add_type_cb(ctf_id_t tid, void *arg)
Definition: ctfread.c:1065
static void ctf_psymtab_add_stt_func(ctf_dict_t *cfp, ctf_psymtab *pst, struct objfile *of)
Definition: ctfread.c:1353
static int ctf_psymtab_type_cb(ctf_id_t tid, void *arg)
Definition: ctfread.c:1459
static void scan_partial_symbols(ctf_dict_t *cfp, psymtab_storage *partial_symtabs, struct ctf_per_tu_data *tup, const char *fname)
Definition: ctfread.c:1537
static int ctf_add_enum_member_cb(const char *name, int enum_value, void *arg)
Definition: ctfread.c:433
static int tid_and_type_eq(const void *item_lhs, const void *item_rhs)
Definition: ctfread.c:229
static void add_stt_func(struct ctf_context *ccp)
Definition: ctfread.c:1227
static struct type * add_array_cv_type(struct ctf_context *ccp, ctf_id_t tid, struct type *base_type, int cnst, int voltl)
Definition: ctfread.c:781
static int get_bitsize(ctf_dict_t *fp, ctf_id_t tid, uint32_t kind)
Definition: ctfread.c:309
static struct type * get_tid_type(struct objfile *of, ctf_id_t tid)
Definition: ctfread.c:269
static void ctf_psymtab_add_stt_obj(ctf_dict_t *cfp, ctf_psymtab *pst, struct objfile *of)
Definition: ctfread.c:1344
static struct type * read_structure_type(struct ctf_context *cp, ctf_id_t tid)
Definition: ctfread.c:625
static struct type * read_forward_type(struct ctf_context *cp, ctf_id_t tid)
Definition: ctfread.c:972
static hashval_t tid_and_type_hash(const void *item)
Definition: ctfread.c:218
static struct type * set_tid_type(struct objfile *of, ctf_id_t tid, struct type *typ)
Definition: ctfread.c:242
static void add_stt_entries(struct ctf_context *ccp, int functions)
Definition: ctfread.c:1192
static struct compunit_symtab * ctf_end_compunit_symtab(ctf_psymtab *pst, CORE_ADDR end_addr, int section)
Definition: ctfread.c:1265
static struct symbol * new_symbol(struct ctf_context *cp, struct type *type, ctf_id_t tid)
Definition: ctfread.c:468
static struct type * read_const_type(struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
Definition: ctfread.c:851
static void add_stt_obj(struct ctf_context *ccp)
Definition: ctfread.c:1219
static void set_symbol_address(struct objfile *of, struct symbol *sym, const char *name)
Definition: ctfread.c:325
static struct type * read_pointer_type(struct ctf_context *cp, ctf_id_t tid, ctf_id_t btid)
Definition: ctfread.c:947
static const registry< objfile >::key< htab, htab_deleter > ctf_tid_key
Definition: ctfread.c:90
static int ctf_add_var_cb(const char *name, ctf_id_t id, void *arg)
Definition: ctfread.c:1130
static int build_ctf_archive_member(ctf_dict_t *ctf, const char *name, void *arg)
Definition: ctfread.c:1576
static void process_structure_type(struct ctf_context *cp, ctf_id_t tid)
Definition: ctfread.c:672
static struct type * fetch_tid_type(struct ctf_context *ccp, ctf_id_t tid)
Definition: ctfread.c:291
static struct type * read_volatile_type(struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
Definition: ctfread.c:874
static struct type * read_restrict_type(struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
Definition: ctfread.c:901
static const registry< objfile >::key< ctf_fp_info > ctf_dict_key
Definition: ctfread.c:110
static void ctf_psymtab_add_enums(struct ctf_context *ccp, ctf_id_t tid)
Definition: ctfread.c:1281
static struct type * read_array_type(struct ctf_context *cp, ctf_id_t tid)
Definition: ctfread.c:809
static struct type * read_func_kind_type(struct ctf_context *ccp, ctf_id_t tid)
Definition: ctfread.c:683
static struct type * read_typedef_type(struct ctf_context *cp, ctf_id_t tid, ctf_id_t btid, const char *name)
Definition: ctfread.c:924
static int ctf_add_member_cb(const char *name, ctf_id_t tid, unsigned long offset, void *arg)
Definition: ctfread.c:389
static struct type * ctf_init_float_type(struct objfile *objfile, int bits, const char *name, const char *name_hint)
Definition: ctfread.c:366
static struct type * read_type_record(struct ctf_context *cp, ctf_id_t tid)
Definition: ctfread.c:1000
static ctf_psymtab * create_partial_symtab(const char *name, ctf_archive_t *arc, ctf_dict_t *cfp, psymtab_storage *partial_symtabs, struct objfile *objfile)
Definition: ctfread.c:1436
static struct type * read_enum_type(struct ctf_context *cp, ctf_id_t tid)
Definition: ctfread.c:737
static void process_enum_type(struct ctf_context *ccp, ctf_id_t tid)
Definition: ctfread.c:759
static void ctf_psymtab_add_stt_entries(ctf_dict_t *cfp, ctf_psymtab *pst, struct objfile *of, int functions)
Definition: ctfread.c:1303
static struct type * read_base_type(struct ctf_context *ccp, ctf_id_t tid)
Definition: ctfread.c:532
static void process_struct_members(struct ctf_context *cp, ctf_id_t tid, struct type *type)
Definition: ctfread.c:654
static void attach_fields_to_type(struct ctf_field_info *fip, struct type *type)
Definition: ctfread.c:341
static CORE_ADDR get_objfile_text_range(struct objfile *of, int *tsize)
Definition: ctfread.c:1235
static void process_base_type(struct ctf_context *ccp, ctf_id_t tid)
Definition: ctfread.c:609
static int ctf_psymtab_var_cb(const char *name, ctf_id_t id, void *arg)
Definition: ctfread.c:1522
void elfctf_build_psymtabs(struct objfile *of)
Definition: ctfread.c:1601
static void ctf_start_compunit_symtab(ctf_psymtab *pst, struct objfile *of, CORE_ADDR text_offset)
Definition: ctfread.c:1248
bool info_verbose
Definition: top.c:2022
@ language_c
Definition: defs.h:214
const struct floatformat ** gdbarch_floatformat_for_type(struct gdbarch *gdbarch, const char *name, int length)
Definition: gdbarch.c:1674
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1423
struct type * make_restrict_type(struct type *type)
Definition: gdbtypes.c:759
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:402
bool set_type_align(struct type *type, ULONGEST align)
Definition: gdbtypes.c:3737
struct type * init_type(struct objfile *objfile, enum type_code code, int bit, const char *name)
Definition: gdbtypes.c:3430
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:714
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition: gdbtypes.c:1422
struct type * alloc_type(struct objfile *objfile)
Definition: gdbtypes.c:181
struct type * init_complex_type(const char *name, struct type *target_type)
Definition: gdbtypes.c:3566
struct type * init_float_type(struct objfile *objfile, int bit, const char *name, const struct floatformat **floatformats, enum bfd_endian byte_order)
Definition: gdbtypes.c:3521
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1025
struct type * init_character_type(struct objfile *objfile, int bit, int unsigned_p, const char *name)
Definition: gdbtypes.c:3480
struct type * init_boolean_type(struct objfile *objfile, int bit, int unsigned_p, const char *name)
Definition: gdbtypes.c:3497
struct type * init_integer_type(struct objfile *objfile, int bit, int unsigned_p, const char *name)
Definition: gdbtypes.c:3459
struct type * copy_type(const struct type *type)
Definition: gdbtypes.c:5790
#define TYPE_ZALLOC(t, size)
Definition: gdbtypes.h:2415
#define TYPE_CONST(t)
Definition: gdbtypes.h:134
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:139
#define FIELD_BITSIZE(thisfld)
Definition: gdbtypes.h:2120
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1790
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:363
void set_objfile_main_name(struct objfile *objfile, const char *name, enum language lang)
Definition: objfiles.c:152
struct type * objfile_int_type(struct objfile *of, int size_in_bytes, bool unsigned_p)
Definition: objfiles.c:1348
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:148
#define OBJSTAT(objfile, expr)
Definition: objfiles.h:178
CORE_ADDR value_address() const
Definition: minsyms.h:41
struct minimal_symbol * minsym
Definition: minsyms.h:49
struct compunit_symtab * end_compunit_symtab(CORE_ADDR end_addr, int section)
Definition: buildsym.c:1070
struct pending ** get_file_symbols()
Definition: buildsym.h:302
void record_debugformat(const char *format)
Definition: buildsym.h:312
struct pending ** get_global_symbols()
Definition: buildsym.h:307
struct buildsym_compunit * builder
Definition: ctfread.c:121
ctf_archive_t * arc
Definition: ctfread.c:120
partial_symtab * pst
Definition: ctfread.c:119
psymtab_storage * partial_symtabs
Definition: ctfread.c:118
ctf_dict_t * fp
Definition: ctfread.c:116
struct objfile * of
Definition: ctfread.c:117
std::vector< struct decl_field > nested_types_list
Definition: ctfread.c:167
std::vector< struct ctf_nextfield > fields
Definition: ctfread.c:153
struct type * ptype
Definition: ctfread.c:159
struct ctf_context * cur_context
Definition: ctfread.c:156
std::vector< struct decl_field > typedef_field_list
Definition: ctfread.c:163
ctf_dict_t * fp
Definition: ctfread.c:96
~ctf_fp_info()
Definition: ctfread.c:100
ctf_fp_info(ctf_dict_t *cfp)
Definition: ctfread.c:94
ctf_archive_t * arc
Definition: ctfread.c:176
psymbol_functions * psf
Definition: ctfread.c:178
ctf_dict_t * fp
Definition: ctfread.c:174
psymtab_storage * pss
Definition: ctfread.c:177
struct objfile * of
Definition: ctfread.c:175
ctf_psymtab(const char *filename, psymtab_storage *partial_symtabs, objfile_per_bfd_storage *objfile_per_bfd, CORE_ADDR addr)
Definition: ctfread.c:127
void read_symtab(struct objfile *) override
Definition: ctfread.c:1392
void expand_psymtab(struct objfile *) override
Definition: ctfread.c:1362
struct ctf_context context
Definition: ctfread.c:138
struct type * type
Definition: ctfread.c:212
ctf_id_t tid
Definition: ctfread.c:211
void set_undefined()
Definition: gdbtypes.h:342
void set_type(struct type *type)
Definition: gdbtypes.h:564
void set_loc_bitpos(LONGEST bitpos)
Definition: gdbtypes.h:592
void set_name(const char *name)
Definition: gdbtypes.h:574
void set_section_index(short idx)
Definition: symtab.h:597
void compute_and_set_names(gdb::string_view linkage_name, bool copy_name, struct objfile_per_bfd_storage *per_bfd, gdb::optional< hashval_t > hash=gdb::optional< hashval_t >())
Definition: symtab.c:914
void set_language(enum language language, struct obstack *obstack)
Definition: symtab.c:771
short section_index() const
Definition: symtab.h:604
const char * linkage_name() const
Definition: symtab.h:459
struct type * builtin_error
Definition: gdbtypes.h:2362
struct type * builtin_int
Definition: gdbtypes.h:2343
struct type * builtin_void
Definition: gdbtypes.h:2340
struct gdbarch * arch() const
Definition: objfiles.h:482
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:657
gdb_bfd_ref_ptr obfd
Definition: objfiles.h:653
CORE_ADDR text_section_offset() const
Definition: objfiles.h:457
auto_obstack objfile_obstack
Definition: objfiles.h:673
std::forward_list< quick_symbol_functions_up > qf
Definition: objfiles.h:685
void end()
Definition: psymtab.c:1193
const char * filename
Definition: psympriv.h:269
void set_text_low(CORE_ADDR addr)
Definition: psympriv.h:199
void add_psymbol(gdb::string_view name, bool copy_name, domain_enum domain, enum address_class theclass, short section, psymbol_placement where, CORE_ADDR coreaddr, enum language language, psymtab_storage *partial_symtabs, struct objfile *objfile)
Definition: psymtab.c:1280
void set_text_high(CORE_ADDR addr)
Definition: psympriv.h:206
const std::shared_ptr< psymtab_storage > & get_partial_symtabs() const
Definition: psympriv.h:556
struct dynamic_prop high
Definition: gdbtypes.h:696
struct type * type() const
Definition: symtab.h:1285
void set_aclass_index(unsigned int aclass_index)
Definition: symtab.h:1225
void set_type(struct type *type)
Definition: symtab.h:1290
void set_value_address(CORE_ADDR address)
Definition: symtab.h:1323
void set_domain(domain_enum domain)
Definition: symtab.h:1245
Definition: gdbtypes.h:922
struct type * target_type() const
Definition: gdbtypes.h:1000
type_code code() const
Definition: gdbtypes.h:927
void set_code(type_code code)
Definition: gdbtypes.h:933
ULONGEST length() const
Definition: gdbtypes.h:954
struct field & field(int idx) const
Definition: gdbtypes.h:983
void set_has_no_signedness(bool has_no_signedness)
Definition: gdbtypes.h:1082
void set_target_type(struct type *target_type)
Definition: gdbtypes.h:1005
void set_is_stub(bool is_stub)
Definition: gdbtypes.h:1096
void set_has_varargs(bool has_varargs)
Definition: gdbtypes.h:1140
void set_num_fields(int num_fields)
Definition: gdbtypes.h:971
void set_name(const char *name)
Definition: gdbtypes.h:945
void set_length(ULONGEST length)
Definition: gdbtypes.h:959
range_bounds * bounds() const
Definition: gdbtypes.h:1028
void set_fields(struct field *fields)
Definition: gdbtypes.h:990
void set_target_is_stub(bool target_is_stub)
Definition: gdbtypes.h:1112
address_class
Definition: symtab.h:939
@ LOC_STATIC
Definition: symtab.h:950
@ LOC_CONST
Definition: symtab.h:946
@ LOC_UNDEF
Definition: symtab.h:942
@ LOC_OPTIMIZED_OUT
Definition: symtab.h:1033
@ LOC_TYPEDEF
Definition: symtab.h:989
domain_enum
Definition: symtab.h:871
@ VAR_DOMAIN
Definition: symtab.h:881
@ STRUCT_DOMAIN
Definition: symtab.h:887
@ UNDEF_DOMAIN
Definition: symtab.h:876
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865
void gdb_flush(struct ui_file *stream)
Definition: utils.c:1477
#define gdb_stdout
Definition: utils.h:188