1 /* Compact ANSI-C Type Format (CTF) support in GDB.
3 Copyright (C) 2019-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
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).
38 The CTF file or section itself has the following structure:
40 +--------+--------+---------+----------+----------+-------+--------+
41 | file | type | data | function | variable | data | string |
42 | header | labels | objects | info | info | types | table |
43 +--------+--------+---------+----------+----------+-------+--------+
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
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].
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.
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.
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,
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. */
80 #include "complaints.h"
90 static const struct objfile_key<htab, htab_deleter> ctf_tid_key;
94 explicit ctf_fp_info (ctf_dict_t *cfp) : fp (cfp) {}
99 /* Cleanup function for the ctf_dict_key data. */
100 ctf_fp_info::~ctf_fp_info ()
105 ctf_archive_t *arc = ctf_get_arc (fp);
110 static const objfile_key<ctf_fp_info> ctf_dict_key;
112 /* A CTF context consists of a file pointer and an objfile pointer. */
118 psymtab_storage *partial_symtabs;
121 struct buildsym_compunit *builder;
124 /* A partial symtab, specialized for this module. */
125 struct ctf_psymtab : public standard_psymtab
127 ctf_psymtab (const char *filename,
128 psymtab_storage *partial_symtabs,
129 objfile_per_bfd_storage *objfile_per_bfd,
131 : standard_psymtab (filename, partial_symtabs, objfile_per_bfd, addr)
135 void read_symtab (struct objfile *) override;
136 void expand_psymtab (struct objfile *) override;
138 struct ctf_context context;
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. */
147 struct field field {};
150 struct ctf_field_info
152 /* List of data member fields. */
153 std::vector<struct ctf_nextfield> fields;
156 struct ctf_context *cur_context;
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;
165 /* Nested types defined by this struct and the number of elements in
167 std::vector<struct decl_field> nested_types_list;
170 /* Data held for a translation unit. */
172 struct ctf_per_tu_data
177 psymtab_storage *pss;
178 psymbol_functions *psf;
181 /* Local function prototypes */
183 static int ctf_add_type_cb (ctf_id_t tid, void *arg);
185 static struct type *read_array_type (struct ctf_context *cp, ctf_id_t tid);
187 static struct type *read_pointer_type (struct ctf_context *cp, ctf_id_t tid,
190 static struct type *read_structure_type (struct ctf_context *cp, ctf_id_t tid);
192 static struct type *read_enum_type (struct ctf_context *cp, ctf_id_t tid);
194 static struct type *read_typedef_type (struct ctf_context *cp, ctf_id_t tid,
195 ctf_id_t btid, const char *name);
197 static struct type *read_type_record (struct ctf_context *cp, ctf_id_t tid);
199 static void process_structure_type (struct ctf_context *cp, ctf_id_t tid);
201 static void process_struct_members (struct ctf_context *cp, ctf_id_t tid,
204 static struct type *read_forward_type (struct ctf_context *cp, ctf_id_t tid);
206 static struct symbol *new_symbol (struct ctf_context *cp, struct type *type,
209 struct ctf_tid_and_type
215 /* Hash function for a ctf_tid_and_type. */
218 tid_and_type_hash (const void *item)
220 const struct ctf_tid_and_type *ids
221 = (const struct ctf_tid_and_type *) item;
226 /* Equality function for a ctf_tid_and_type. */
229 tid_and_type_eq (const void *item_lhs, const void *item_rhs)
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;
236 return ids_lhs->tid == ids_rhs->tid;
239 /* Set the type associated with TID to TYP. */
242 set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
246 htab = (htab_t) ctf_tid_key.get (of);
249 htab = htab_create_alloc (1, tid_and_type_hash,
251 NULL, xcalloc, xfree);
252 ctf_tid_key.set (of, htab);
255 struct ctf_tid_and_type **slot, ids;
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);
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. */
269 get_tid_type (struct objfile *of, ctf_id_t tid)
271 struct ctf_tid_and_type *slot, ids;
274 htab = (htab_t) ctf_tid_key.get (of);
280 slot = (struct ctf_tid_and_type *) htab_find (htab, &ids);
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. */
291 fetch_tid_type (struct ctf_context *ccp, ctf_id_t tid)
293 struct objfile *of = ccp->of;
296 typ = get_tid_type (of, tid);
299 ctf_add_type_cb (tid, ccp);
300 typ = get_tid_type (of, tid);
306 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */
309 get_bitsize (ctf_dict_t *fp, ctf_id_t tid, uint32_t kind)
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)
322 /* Set SYM's address, with NAME, from its minimal symbol entry. */
325 set_symbol_address (struct objfile *of, struct symbol *sym, const char *name)
327 struct bound_minimal_symbol msym;
329 msym = lookup_minimal_symbol (name, nullptr, of);
330 if (msym.minsym != NULL)
332 SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym));
333 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
334 sym->set_section_index (msym.minsym->section_index ());
338 /* Create the vector of fields, and attach it to TYPE. */
341 attach_fields_to_type (struct ctf_field_info *fip, struct type *type)
343 int nfields = fip->fields.size ();
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));
353 /* Copy the saved-up fields into the field vector. */
354 for (int i = 0; i < nfields; ++i)
356 struct ctf_nextfield &field = fip->fields[i];
357 type->field (i) = field.field;
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. */
366 ctf_init_float_type (struct objfile *objfile,
369 const char *name_hint)
371 struct gdbarch *gdbarch = objfile->arch ();
372 const struct floatformat **format;
375 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
376 if (format != nullptr)
377 type = init_float_type (objfile, bits, name, format);
379 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
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. */
389 ctf_add_member_cb (const char *name,
391 unsigned long offset,
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;
401 fp = &new_field.field;
404 kind = ctf_type_kind (ccp->fp, tid);
405 t = fetch_tid_type (ccp, tid);
408 t = read_type_record (ccp, tid);
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);
417 if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
418 process_struct_members (ccp, tid, t);
421 SET_FIELD_BITPOS (*fp, offset / TARGET_CHAR_BIT);
422 FIELD_BITSIZE (*fp) = get_bitsize (ccp->fp, tid, kind);
424 fip->fields.emplace_back (new_field);
429 /* Callback to add member NAME of EVAL to an enumeration type.
430 ARG contains the ctf_field_info. */
433 ctf_add_enum_member_cb (const char *name, int enum_value, void *arg)
435 struct ctf_field_info *fip = (struct ctf_field_info *) arg;
436 struct ctf_nextfield new_field;
438 struct ctf_context *ccp = fip->cur_context;
440 fp = &new_field.field;
442 fp->set_type (nullptr);
443 SET_FIELD_ENUMVAL (*fp, enum_value);
444 FIELD_BITSIZE (*fp) = 0;
448 struct symbol *sym = new (&ccp->of->objfile_obstack) symbol;
449 OBJSTAT (ccp->of, n_syms++);
451 sym->set_language (language_c, &ccp->of->objfile_obstack);
452 sym->compute_and_set_names (name, false, ccp->of->per_bfd);
453 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
454 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
455 SYMBOL_TYPE (sym) = fip->ptype;
456 add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
459 fip->fields.emplace_back (new_field);
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. */
467 static struct symbol *
468 new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
470 struct objfile *objfile = ccp->of;
471 ctf_dict_t *fp = ccp->fp;
472 struct symbol *sym = nullptr;
474 const char *name = ctf_type_name_raw (fp, tid);
477 sym = new (&objfile->objfile_obstack) symbol;
478 OBJSTAT (objfile, n_syms++);
480 sym->set_language (language_c, &objfile->objfile_obstack);
481 sym->compute_and_set_names (name, false, objfile->per_bfd);
482 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
483 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
486 SYMBOL_TYPE (sym) = type;
488 uint32_t kind = ctf_type_kind (fp, tid);
494 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
495 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
498 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
499 set_symbol_address (objfile, sym, sym->linkage_name ());
502 if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_VOID)
503 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
508 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
509 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
522 add_symbol_to_list (sym, ccp->builder->get_file_symbols ());
528 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
529 and create the symbol for it. */
532 read_base_type (struct ctf_context *ccp, ctf_id_t tid)
534 struct objfile *of = ccp->of;
535 ctf_dict_t *fp = ccp->fp;
537 struct type *type = nullptr;
541 if (ctf_type_encoding (fp, tid, &cet))
543 complaint (_("ctf_type_encoding read_base_type failed - %s"),
544 ctf_errmsg (ctf_errno (fp)));
548 name = ctf_type_name_raw (fp, tid);
549 if (name == nullptr || strlen (name) == 0)
551 name = ctf_type_aname (fp, tid);
553 complaint (_("ctf_type_aname read_base_type failed - %s"),
554 ctf_errmsg (ctf_errno (fp)));
557 kind = ctf_type_kind (fp, tid);
558 if (kind == CTF_K_INTEGER)
560 uint32_t issigned, ischar, isbool;
561 struct gdbarch *gdbarch = of->arch ();
563 issigned = cet.cte_format & CTF_INT_SIGNED;
564 ischar = cet.cte_format & CTF_INT_CHAR;
565 isbool = cet.cte_format & CTF_INT_BOOL;
567 type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name);
569 type = init_boolean_type (of, gdbarch_int_bit (gdbarch),
574 if (cet.cte_bits && ((cet.cte_bits % TARGET_CHAR_BIT) == 0))
577 bits = gdbarch_int_bit (gdbarch);
578 type = init_integer_type (of, bits, !issigned, name);
581 else if (kind == CTF_K_FLOAT)
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);
588 type = ctf_init_float_type (of, cet.cte_bits, name, name);
592 = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
593 type = init_complex_type (name, t);
598 complaint (_("read_base_type: unsupported base kind (%d)"), kind);
599 type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name);
602 if (name != nullptr && strcmp (name, "char") == 0)
603 type->set_has_no_signedness (true);
605 return set_tid_type (of, tid, type);
609 process_base_type (struct ctf_context *ccp, ctf_id_t tid)
613 type = read_base_type (ccp, tid);
614 new_symbol (ccp, type, tid);
617 /* Start a structure or union scope (definition) with TID to create a type
618 for the structure or union.
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). */
625 read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
627 struct objfile *of = ccp->of;
628 ctf_dict_t *fp = ccp->fp;
632 type = alloc_type (of);
634 const char *name = ctf_type_name_raw (fp, tid);
635 if (name != nullptr && strlen (name) != 0)
636 type->set_name (name);
638 kind = ctf_type_kind (fp, tid);
639 if (kind == CTF_K_UNION)
640 type->set_code (TYPE_CODE_UNION);
642 type->set_code (TYPE_CODE_STRUCT);
644 TYPE_LENGTH (type) = ctf_type_size (fp, tid);
645 set_type_align (type, ctf_type_align (fp, tid));
647 return set_tid_type (ccp->of, tid, type);
650 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
651 and create the symbol for it. */
654 process_struct_members (struct ctf_context *ccp,
658 struct ctf_field_info fi;
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)));
665 /* Attach fields to the type. */
666 attach_fields_to_type (&fi, type);
668 new_symbol (ccp, type, tid);
672 process_structure_type (struct ctf_context *ccp, ctf_id_t tid)
676 type = read_structure_type (ccp, tid);
677 process_struct_members (ccp, tid, type);
680 /* Create a function type for TID and set its return type. */
683 read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
685 struct objfile *of = ccp->of;
686 ctf_dict_t *fp = ccp->fp;
687 struct type *type, *rettype, *atype;
691 type = alloc_type (of);
693 type->set_code (TYPE_CODE_FUNC);
694 ctf_func_type_info (fp, tid, &cfi);
695 rettype = fetch_tid_type (ccp, cfi.ctc_return);
696 TYPE_TARGET_TYPE (type) = rettype;
697 set_type_align (type, ctf_type_align (fp, tid));
699 /* Set up function's arguments. */
701 type->set_num_fields (argc);
702 if ((cfi.ctc_flags & CTF_FUNC_VARARG) != 0)
703 type->set_has_varargs (true);
707 std::vector<ctf_id_t> argv (argc);
708 if (ctf_func_type_args (fp, tid, argc, argv.data ()) == CTF_ERR)
712 ((struct field *) TYPE_ZALLOC (type, argc * sizeof (struct field)));
713 struct type *void_type = objfile_type (of)->builtin_void;
714 /* If failed to find the argument type, fill it with void_type. */
715 for (int iparam = 0; iparam < argc; iparam++)
717 atype = fetch_tid_type (ccp, argv[iparam]);
718 if (atype != nullptr)
719 type->field (iparam).set_type (atype);
721 type->field (iparam).set_type (void_type);
725 return set_tid_type (of, tid, type);
728 /* Given a TID of CTF_K_ENUM, process all the members of the
729 enumeration, and create the symbol for the enumeration type. */
732 read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
734 struct objfile *of = ccp->of;
735 ctf_dict_t *fp = ccp->fp;
736 struct type *type, *target_type;
739 type = alloc_type (of);
741 const char *name = ctf_type_name_raw (fp, tid);
742 if (name != nullptr && strlen (name) != 0)
743 type->set_name (name);
745 type->set_code (TYPE_CODE_ENUM);
746 TYPE_LENGTH (type) = ctf_type_size (fp, tid);
747 ctf_func_type_info (fp, tid, &fi);
748 target_type = get_tid_type (of, fi.ctc_return);
749 TYPE_TARGET_TYPE (type) = target_type;
750 set_type_align (type, ctf_type_align (fp, tid));
752 return set_tid_type (of, tid, type);
756 process_enum_type (struct ctf_context *ccp, ctf_id_t tid)
759 struct ctf_field_info fi;
761 type = read_enum_type (ccp, tid);
763 fi.cur_context = ccp;
765 if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
766 complaint (_("ctf_enum_iter process_enum_type failed - %s"),
767 ctf_errmsg (ctf_errno (ccp->fp)));
769 /* Attach fields to the type. */
770 attach_fields_to_type (&fi, type);
772 new_symbol (ccp, type, tid);
775 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */
778 add_array_cv_type (struct ctf_context *ccp,
780 struct type *base_type,
784 struct type *el_type, *inner_array;
786 base_type = copy_type (base_type);
787 inner_array = base_type;
789 while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
791 TYPE_TARGET_TYPE (inner_array)
792 = copy_type (TYPE_TARGET_TYPE (inner_array));
793 inner_array = TYPE_TARGET_TYPE (inner_array);
796 el_type = TYPE_TARGET_TYPE (inner_array);
797 cnst |= TYPE_CONST (el_type);
798 voltl |= TYPE_VOLATILE (el_type);
799 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, nullptr);
801 return set_tid_type (ccp->of, tid, base_type);
804 /* Read all information from a TID of CTF_K_ARRAY. */
807 read_array_type (struct ctf_context *ccp, ctf_id_t tid)
809 struct objfile *objfile = ccp->of;
810 ctf_dict_t *fp = ccp->fp;
811 struct type *element_type, *range_type, *idx_type;
815 if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
817 complaint (_("ctf_array_info read_array_type failed - %s"),
818 ctf_errmsg (ctf_errno (fp)));
822 element_type = fetch_tid_type (ccp, ar.ctr_contents);
823 if (element_type == nullptr)
826 idx_type = fetch_tid_type (ccp, ar.ctr_index);
827 if (idx_type == nullptr)
828 idx_type = objfile_type (objfile)->builtin_int;
830 range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
831 type = create_array_type (NULL, element_type, range_type);
832 if (ar.ctr_nelems <= 1) /* Check if undefined upper bound. */
834 range_type->bounds ()->high.set_undefined ();
835 TYPE_LENGTH (type) = 0;
836 type->set_target_is_stub (true);
839 TYPE_LENGTH (type) = ctf_type_size (fp, tid);
841 set_type_align (type, ctf_type_align (fp, tid));
843 return set_tid_type (objfile, tid, type);
846 /* Read TID of kind CTF_K_CONST with base type BTID. */
849 read_const_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
851 struct objfile *objfile = ccp->of;
852 struct type *base_type, *cv_type;
854 base_type = fetch_tid_type (ccp, btid);
855 if (base_type == nullptr)
857 base_type = read_type_record (ccp, btid);
858 if (base_type == nullptr)
860 complaint (_("read_const_type: NULL base type (%ld)"), btid);
861 base_type = objfile_type (objfile)->builtin_error;
864 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
866 return set_tid_type (objfile, tid, cv_type);
869 /* Read TID of kind CTF_K_VOLATILE with base type BTID. */
872 read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
874 struct objfile *objfile = ccp->of;
875 ctf_dict_t *fp = ccp->fp;
876 struct type *base_type, *cv_type;
878 base_type = fetch_tid_type (ccp, btid);
879 if (base_type == nullptr)
881 base_type = read_type_record (ccp, btid);
882 if (base_type == nullptr)
884 complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
885 base_type = objfile_type (objfile)->builtin_error;
889 if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
890 return add_array_cv_type (ccp, tid, base_type, 0, 1);
891 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
893 return set_tid_type (objfile, tid, cv_type);
896 /* Read TID of kind CTF_K_RESTRICT with base type BTID. */
899 read_restrict_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
901 struct objfile *objfile = ccp->of;
902 struct type *base_type, *cv_type;
904 base_type = fetch_tid_type (ccp, btid);
905 if (base_type == nullptr)
907 base_type = read_type_record (ccp, btid);
908 if (base_type == nullptr)
910 complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
911 base_type = objfile_type (objfile)->builtin_error;
914 cv_type = make_restrict_type (base_type);
916 return set_tid_type (objfile, tid, cv_type);
919 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */
922 read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
923 ctf_id_t btid, const char *name)
925 struct objfile *objfile = ccp->of;
926 struct type *this_type, *target_type;
928 char *aname = obstack_strdup (&objfile->objfile_obstack, name);
929 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname);
930 set_tid_type (objfile, tid, this_type);
931 target_type = fetch_tid_type (ccp, btid);
932 if (target_type != this_type)
933 TYPE_TARGET_TYPE (this_type) = target_type;
935 TYPE_TARGET_TYPE (this_type) = nullptr;
937 this_type->set_target_is_stub (TYPE_TARGET_TYPE (this_type) != nullptr);
939 return set_tid_type (objfile, tid, this_type);
942 /* Read TID of kind CTF_K_POINTER with base type BTID. */
945 read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
947 struct objfile *of = ccp->of;
948 struct type *target_type, *type;
950 target_type = fetch_tid_type (ccp, btid);
951 if (target_type == nullptr)
953 target_type = read_type_record (ccp, btid);
954 if (target_type == nullptr)
956 complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
957 target_type = objfile_type (ccp->of)->builtin_error;
961 type = lookup_pointer_type (target_type);
962 set_type_align (type, ctf_type_align (ccp->fp, tid));
964 return set_tid_type (of, tid, type);
967 /* Read information from a TID of CTF_K_FORWARD. */
970 read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
972 struct objfile *of = ccp->of;
973 ctf_dict_t *fp = ccp->fp;
977 type = alloc_type (of);
979 const char *name = ctf_type_name_raw (fp, tid);
980 if (name != nullptr && strlen (name) != 0)
981 type->set_name (name);
983 kind = ctf_type_kind_forwarded (fp, tid);
984 if (kind == CTF_K_UNION)
985 type->set_code (TYPE_CODE_UNION);
987 type->set_code (TYPE_CODE_STRUCT);
989 TYPE_LENGTH (type) = 0;
990 type->set_is_stub (true);
992 return set_tid_type (of, tid, type);
995 /* Read information associated with type TID. */
998 read_type_record (struct ctf_context *ccp, ctf_id_t tid)
1000 ctf_dict_t *fp = ccp->fp;
1002 struct type *type = nullptr;
1005 kind = ctf_type_kind (fp, tid);
1010 type = read_structure_type (ccp, tid);
1013 type = read_enum_type (ccp, tid);
1015 case CTF_K_FUNCTION:
1016 type = read_func_kind_type (ccp, tid);
1019 btid = ctf_type_reference (fp, tid);
1020 type = read_const_type (ccp, tid, btid);
1024 const char *name = ctf_type_name_raw (fp, tid);
1025 btid = ctf_type_reference (fp, tid);
1026 type = read_typedef_type (ccp, tid, btid, name);
1029 case CTF_K_VOLATILE:
1030 btid = ctf_type_reference (fp, tid);
1031 type = read_volatile_type (ccp, tid, btid);
1033 case CTF_K_RESTRICT:
1034 btid = ctf_type_reference (fp, tid);
1035 type = read_restrict_type (ccp, tid, btid);
1038 btid = ctf_type_reference (fp, tid);
1039 type = read_pointer_type (ccp, tid, btid);
1043 type = read_base_type (ccp, tid);
1046 type = read_array_type (ccp, tid);
1049 type = read_forward_type (ccp, tid);
1060 /* Callback to add type TID to the symbol table. */
1063 ctf_add_type_cb (ctf_id_t tid, void *arg)
1065 struct ctf_context *ccp = (struct ctf_context *) arg;
1069 /* Check if tid's type has already been defined. */
1070 type = get_tid_type (ccp->of, tid);
1071 if (type != nullptr)
1074 ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
1075 kind = ctf_type_kind (ccp->fp, tid);
1080 process_structure_type (ccp, tid);
1083 process_enum_type (ccp, tid);
1085 case CTF_K_FUNCTION:
1086 type = read_func_kind_type (ccp, tid);
1087 new_symbol (ccp, type, tid);
1091 process_base_type (ccp, tid);
1094 new_symbol (ccp, read_type_record (ccp, tid), tid);
1097 type = read_const_type (ccp, tid, btid);
1098 new_symbol (ccp, type, tid);
1100 case CTF_K_VOLATILE:
1101 type = read_volatile_type (ccp, tid, btid);
1102 new_symbol (ccp, type, tid);
1104 case CTF_K_RESTRICT:
1105 type = read_restrict_type (ccp, tid, btid);
1106 new_symbol (ccp, type, tid);
1109 type = read_pointer_type (ccp, tid, btid);
1110 new_symbol (ccp, type, tid);
1113 type = read_array_type (ccp, tid);
1114 new_symbol (ccp, type, tid);
1125 /* Callback to add variable NAME with TID to the symbol table. */
1128 ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
1130 struct ctf_context *ccp = (struct ctf_context *) arg;
1131 struct symbol *sym = nullptr;
1135 type = get_tid_type (ccp->of, id);
1137 kind = ctf_type_kind (ccp->fp, id);
1140 case CTF_K_FUNCTION:
1141 if (name != nullptr && strcmp (name, "main") == 0)
1142 set_objfile_main_name (ccp->of, name, language_c);
1146 case CTF_K_VOLATILE:
1147 case CTF_K_RESTRICT:
1152 if (type != nullptr)
1154 sym = new_symbol (ccp, type, id);
1156 sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1162 if (type == nullptr)
1164 complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
1165 type = objfile_type (ccp->of)->builtin_error;
1167 sym = new (&ccp->of->objfile_obstack) symbol;
1168 OBJSTAT (ccp->of, n_syms++);
1169 SYMBOL_TYPE (sym) = type;
1170 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1171 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
1172 sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1173 add_symbol_to_list (sym, ccp->builder->get_file_symbols ());
1176 complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
1181 set_symbol_address (ccp->of, sym, name);
1186 /* Add entries in either data objects or function info section, controlled
1190 add_stt_entries (struct ctf_context *ccp, int functions)
1192 ctf_next_t *i = nullptr;
1195 struct symbol *sym = nullptr;
1198 while ((tid = ctf_symbol_next (ccp->fp, &i, &tname, functions)) != CTF_ERR)
1200 type = get_tid_type (ccp->of, tid);
1201 if (type == nullptr)
1203 sym = new (&ccp->of->objfile_obstack) symbol;
1204 OBJSTAT (ccp->of, n_syms++);
1205 SYMBOL_TYPE (sym) = type;
1206 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1207 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1208 sym->compute_and_set_names (tname, false, ccp->of->per_bfd);
1209 add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
1210 set_symbol_address (ccp->of, sym, tname);
1214 /* Add entries in data objects section. */
1217 add_stt_obj (struct ctf_context *ccp)
1219 add_stt_entries (ccp, 0);
1222 /* Add entries in function info section. */
1225 add_stt_func (struct ctf_context *ccp)
1227 add_stt_entries (ccp, 1);
1230 /* Get text segment base for OBJFILE, TSIZE contains the segment size. */
1233 get_objfile_text_range (struct objfile *of, int *tsize)
1235 bfd *abfd = of->obfd;
1236 const asection *codes;
1238 codes = bfd_get_section_by_name (abfd, ".text");
1239 *tsize = codes ? bfd_section_size (codes) : 0;
1240 return of->text_section_offset ();
1243 /* Start a symtab for OBJFILE in CTF format. */
1246 ctf_start_symtab (ctf_psymtab *pst,
1247 struct objfile *of, CORE_ADDR text_offset)
1249 struct ctf_context *ccp;
1251 ccp = &pst->context;
1252 ccp->builder = new buildsym_compunit
1253 (of, of->original_name, nullptr,
1254 language_c, text_offset);
1255 ccp->builder->record_debugformat ("ctf");
1258 /* Finish reading symbol/type definitions in CTF format.
1259 END_ADDR is the end address of the file's text. SECTION is
1260 the .text section number. */
1262 static struct compunit_symtab *
1263 ctf_end_symtab (ctf_psymtab *pst,
1264 CORE_ADDR end_addr, int section)
1266 struct ctf_context *ccp;
1268 ccp = &pst->context;
1269 struct compunit_symtab *result
1270 = ccp->builder->end_symtab (end_addr, section);
1271 delete ccp->builder;
1272 ccp->builder = nullptr;
1276 /* Add all members of an enum with type TID to partial symbol table. */
1279 ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid)
1283 ctf_next_t *i = nullptr;
1285 while ((ename = ctf_enum_next (ccp->fp, tid, &i, &val)) != nullptr)
1287 ccp->pst->add_psymbol (ename, true,
1288 VAR_DOMAIN, LOC_CONST, -1,
1289 psymbol_placement::GLOBAL,
1290 0, language_c, ccp->partial_symtabs, ccp->of);
1292 if (ctf_errno (ccp->fp) != ECTF_NEXT_END)
1293 complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1294 ctf_errmsg (ctf_errno (ccp->fp)));
1297 /* Add entries in either data objects or function info section, controlled
1298 by FUNCTIONS, to psymtab. */
1301 ctf_psymtab_add_stt_entries (ctf_dict_t *cfp, ctf_psymtab *pst,
1302 struct objfile *of, int functions)
1304 ctf_next_t *i = nullptr;
1308 while ((tid = ctf_symbol_next (cfp, &i, &tname, functions)) != CTF_ERR)
1310 uint32_t kind = ctf_type_kind (cfp, tid);
1311 address_class aclass;
1312 domain_enum tdomain;
1318 tdomain = STRUCT_DOMAIN;
1321 tdomain = VAR_DOMAIN;
1325 if (kind == CTF_K_FUNCTION)
1326 aclass = LOC_STATIC;
1327 else if (kind == CTF_K_CONST)
1330 aclass = LOC_TYPEDEF;
1332 pst->add_psymbol (tname, true,
1333 tdomain, aclass, -1,
1334 psymbol_placement::GLOBAL,
1335 0, language_c, pst->context.partial_symtabs, of);
1339 /* Add entries in data objects section to psymtab. */
1342 ctf_psymtab_add_stt_obj (ctf_dict_t *cfp, ctf_psymtab *pst,
1345 ctf_psymtab_add_stt_entries (cfp, pst, of, 0);
1348 /* Add entries in function info section to psymtab. */
1351 ctf_psymtab_add_stt_func (ctf_dict_t *cfp, ctf_psymtab *pst,
1354 ctf_psymtab_add_stt_entries (cfp, pst, of, 1);
1357 /* Read in full symbols for PST, and anything it depends on. */
1360 ctf_psymtab::expand_psymtab (struct objfile *objfile)
1362 struct ctf_context *ccp;
1364 gdb_assert (!readin);
1368 /* Iterate over entries in data types section. */
1369 if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
1370 complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1371 ctf_errmsg (ctf_errno (ccp->fp)));
1374 /* Iterate over entries in variable info section. */
1375 if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
1376 complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1377 ctf_errmsg (ctf_errno (ccp->fp)));
1379 /* Add entries in data objects and function info sections. */
1386 /* Expand partial symbol table PST into a full symbol table.
1390 ctf_psymtab::read_symtab (struct objfile *objfile)
1393 warning (_("bug: psymtab for %s is already read in."), filename);
1398 printf_filtered (_("Reading in CTF data for %s..."), filename);
1399 gdb_flush (gdb_stdout);
1402 /* Start a symtab. */
1403 CORE_ADDR offset; /* Start of text segment. */
1406 offset = get_objfile_text_range (objfile, &tsize);
1407 ctf_start_symtab (this, objfile, offset);
1408 expand_psymtab (objfile);
1410 set_text_low (offset);
1411 set_text_high (offset + tsize);
1412 compunit_symtab = ctf_end_symtab (this, offset + tsize,
1413 SECT_OFF_TEXT (objfile));
1415 /* Finish up the debug error message. */
1417 printf_filtered (_("done.\n"));
1421 /* Allocate a new partial_symtab NAME.
1423 Each source file that has not been fully read in is represented by
1424 a partial_symtab. This contains the information on where in the
1425 executable the debugging symbols for a specific file are, and a
1426 list of names of global symbols which are located in this file.
1427 They are all chained on partial symtab lists.
1429 Even after the source file has been read into a symtab, the
1430 partial_symtab remains around. They are allocated on an obstack,
1433 static ctf_psymtab *
1434 create_partial_symtab (const char *name,
1437 psymtab_storage *partial_symtabs,
1438 struct objfile *objfile)
1442 pst = new ctf_psymtab (name, partial_symtabs, objfile->per_bfd, 0);
1444 pst->context.arc = arc;
1445 pst->context.fp = cfp;
1446 pst->context.of = objfile;
1447 pst->context.partial_symtabs = partial_symtabs;
1448 pst->context.pst = pst;
1453 /* Callback to add type TID to partial symbol table. */
1456 ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
1458 struct ctf_context *ccp;
1462 ccp = (struct ctf_context *) arg;
1464 domain_enum domain = UNDEF_DOMAIN;
1465 enum address_class aclass = LOC_UNDEF;
1466 kind = ctf_type_kind (ccp->fp, tid);
1470 ctf_psymtab_add_enums (ccp, tid);
1474 domain = STRUCT_DOMAIN;
1475 aclass = LOC_TYPEDEF;
1477 case CTF_K_FUNCTION:
1479 domain = VAR_DOMAIN;
1480 aclass = LOC_STATIC;
1481 section = SECT_OFF_TEXT (ccp->of);
1484 domain = VAR_DOMAIN;
1485 aclass = LOC_STATIC;
1489 case CTF_K_VOLATILE:
1490 case CTF_K_RESTRICT:
1491 domain = VAR_DOMAIN;
1492 aclass = LOC_TYPEDEF;
1496 domain = VAR_DOMAIN;
1497 aclass = LOC_TYPEDEF;
1504 const char *name = ctf_type_name_raw (ccp->fp, tid);
1505 if (name == nullptr || strlen (name) == 0)
1508 ccp->pst->add_psymbol (name, false,
1509 domain, aclass, section,
1510 psymbol_placement::STATIC,
1511 0, language_c, ccp->partial_symtabs, ccp->of);
1516 /* Callback to add variable NAME with ID to partial symbol table. */
1519 ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg)
1521 struct ctf_context *ccp = (struct ctf_context *) arg;
1523 ccp->pst->add_psymbol (name, true,
1524 VAR_DOMAIN, LOC_STATIC, -1,
1525 psymbol_placement::GLOBAL,
1526 0, language_c, ccp->partial_symtabs, ccp->of);
1530 /* Start a subfile for CTF. FNAME is the name of the archive. */
1533 ctf_start_archive (struct ctf_context *ccx, struct objfile *of,
1536 if (ccx->builder == nullptr)
1538 ccx->builder = new buildsym_compunit (of,
1539 of->original_name, nullptr, language_c, 0);
1540 ccx->builder->record_debugformat ("ctf");
1542 ccx->builder->start_subfile (fname);
1545 /* Setup partial_symtab's describing each source file for which
1546 debugging information is available. */
1549 scan_partial_symbols (ctf_dict_t *cfp, psymtab_storage *partial_symtabs,
1550 struct ctf_per_tu_data *tup, const char *fname)
1552 struct objfile *of = tup->of;
1553 bool isparent = false;
1555 if (strcmp (fname, ".ctf") == 0)
1557 fname = bfd_get_filename (of->obfd);
1561 ctf_psymtab *pst = create_partial_symtab (fname, tup->arc, cfp,
1562 partial_symtabs, of);
1564 struct ctf_context *ccx = &pst->context;
1565 if (isparent == false)
1567 ctf_start_archive (ccx, of, fname);
1571 if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
1572 complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1573 ctf_errmsg (ctf_errno (cfp)));
1575 if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
1576 complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1577 ctf_errmsg (ctf_errno (cfp)));
1579 /* Scan CTF object and function sections which correspond to each
1580 STT_FUNC or STT_OBJECT entry in the symbol table,
1581 pick up what init_symtab has done. */
1582 ctf_psymtab_add_stt_obj (cfp, pst, of);
1583 ctf_psymtab_add_stt_func (cfp, pst, of);
1588 /* Callback to build the psymtab for archive member NAME. */
1591 build_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
1593 struct ctf_per_tu_data *tup = (struct ctf_per_tu_data *) arg;
1594 ctf_dict_t *parent = tup->fp;
1596 if (strcmp (name, ".ctf") != 0)
1597 ctf_import (ctf, parent);
1601 printf_filtered (_("Scanning archive member %s..."), name);
1602 gdb_flush (gdb_stdout);
1605 psymtab_storage *pss = tup->psf->get_partial_symtabs ().get ();
1606 scan_partial_symbols (ctf, pss, tup, name);
1611 /* Read CTF debugging information from a BFD section. This is
1612 called from elfread.c. It does a quick pass through the
1613 .ctf section to set up the partial symbol table. */
1616 elfctf_build_psymtabs (struct objfile *of)
1618 struct ctf_per_tu_data pcu;
1619 bfd *abfd = of->obfd;
1622 ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
1624 error (_("ctf_bfdopen failed on %s - %s"),
1625 bfd_get_filename (abfd), ctf_errmsg (err));
1627 ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
1629 error (_("ctf_dict_open failed on %s - %s"),
1630 bfd_get_filename (abfd), ctf_errmsg (err));
1631 ctf_dict_key.emplace (of, fp);
1637 psymbol_functions *psf = new psymbol_functions ();
1638 of->qf.emplace_front (psf);
1641 if (ctf_archive_iter (arc, build_ctf_archive_member, &pcu) < 0)
1642 error (_("ctf_archive_iter failed in input file %s: - %s"),
1643 bfd_get_filename (abfd), ctf_errmsg (err));
1649 elfctf_build_psymtabs (struct objfile *of)
1651 /* Nothing to do if CTF is disabled. */
1654 #endif /* ENABLE_LIBCTF */