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. */
119 struct buildsym_compunit
*builder
;
122 /* A partial symtab, specialized for this module. */
123 struct ctf_psymtab
: public standard_psymtab
125 ctf_psymtab (const char *filename
, struct objfile
*objfile
, CORE_ADDR addr
)
126 : standard_psymtab (filename
, objfile
, addr
)
130 void read_symtab (struct objfile
*) override
;
131 void expand_psymtab (struct objfile
*) override
;
133 struct ctf_context
*context
;
136 /* The routines that read and process fields/members of a C struct, union,
137 or enumeration, pass lists of data member fields in an instance of a
138 ctf_field_info structure. It is derived from dwarf2read.c. */
142 struct field field
{};
145 struct ctf_field_info
147 /* List of data member fields. */
148 std::vector
<struct ctf_nextfield
> fields
;
151 struct ctf_context
*cur_context
;
156 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head
157 of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
158 std::vector
<struct decl_field
> typedef_field_list
;
160 /* Nested types defined by this struct and the number of elements in
162 std::vector
<struct decl_field
> nested_types_list
;
166 /* Local function prototypes */
168 static int ctf_add_type_cb (ctf_id_t tid
, void *arg
);
170 static struct type
*read_array_type (struct ctf_context
*cp
, ctf_id_t tid
);
172 static struct type
*read_pointer_type (struct ctf_context
*cp
, ctf_id_t tid
,
175 static struct type
*read_structure_type (struct ctf_context
*cp
, ctf_id_t tid
);
177 static struct type
*read_enum_type (struct ctf_context
*cp
, ctf_id_t tid
);
179 static struct type
*read_typedef_type (struct ctf_context
*cp
, ctf_id_t tid
,
180 ctf_id_t btid
, const char *name
);
182 static struct type
*read_type_record (struct ctf_context
*cp
, ctf_id_t tid
);
184 static void process_structure_type (struct ctf_context
*cp
, ctf_id_t tid
);
186 static void process_struct_members (struct ctf_context
*cp
, ctf_id_t tid
,
189 static struct symbol
*new_symbol (struct ctf_context
*cp
, struct type
*type
,
192 struct ctf_tid_and_type
198 /* Hash function for a ctf_tid_and_type. */
201 tid_and_type_hash (const void *item
)
203 const struct ctf_tid_and_type
*ids
204 = (const struct ctf_tid_and_type
*) item
;
209 /* Equality function for a ctf_tid_and_type. */
212 tid_and_type_eq (const void *item_lhs
, const void *item_rhs
)
214 const struct ctf_tid_and_type
*ids_lhs
215 = (const struct ctf_tid_and_type
*) item_lhs
;
216 const struct ctf_tid_and_type
*ids_rhs
217 = (const struct ctf_tid_and_type
*) item_rhs
;
219 return ids_lhs
->tid
== ids_rhs
->tid
;
222 /* Set the type associated with TID to TYP. */
225 set_tid_type (struct objfile
*of
, ctf_id_t tid
, struct type
*typ
)
229 htab
= (htab_t
) ctf_tid_key
.get (of
);
232 htab
= htab_create_alloc (1, tid_and_type_hash
,
234 NULL
, xcalloc
, xfree
);
235 ctf_tid_key
.set (of
, htab
);
238 struct ctf_tid_and_type
**slot
, ids
;
241 slot
= (struct ctf_tid_and_type
**) htab_find_slot (htab
, &ids
, INSERT
);
243 complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"),
245 *slot
= XOBNEW (&of
->objfile_obstack
, struct ctf_tid_and_type
);
250 /* Look up the type for TID in tid_and_type hash, return NULL if hash is
251 empty or TID does not have a saved type. */
254 get_tid_type (struct objfile
*of
, ctf_id_t tid
)
256 struct ctf_tid_and_type
*slot
, ids
;
259 htab
= (htab_t
) ctf_tid_key
.get (of
);
265 slot
= (struct ctf_tid_and_type
*) htab_find (htab
, &ids
);
272 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */
275 get_bitsize (ctf_dict_t
*fp
, ctf_id_t tid
, uint32_t kind
)
279 if ((kind
== CTF_K_INTEGER
|| kind
== CTF_K_ENUM
280 || kind
== CTF_K_FLOAT
)
281 && ctf_type_reference (fp
, tid
) != CTF_ERR
282 && ctf_type_encoding (fp
, tid
, &cet
) != CTF_ERR
)
288 /* Set SYM's address, with NAME, from its minimal symbol entry. */
291 set_symbol_address (struct objfile
*of
, struct symbol
*sym
, const char *name
)
293 struct bound_minimal_symbol msym
;
295 msym
= lookup_minimal_symbol (name
, nullptr, of
);
296 if (msym
.minsym
!= NULL
)
298 SET_SYMBOL_VALUE_ADDRESS (sym
, BMSYMBOL_VALUE_ADDRESS (msym
));
299 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
300 sym
->set_section_index (msym
.minsym
->section_index ());
304 /* Create the vector of fields, and attach it to TYPE. */
307 attach_fields_to_type (struct ctf_field_info
*fip
, struct type
*type
)
309 int nfields
= fip
->fields
.size ();
314 /* Record the field count, allocate space for the array of fields. */
315 type
->set_num_fields (nfields
);
317 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
319 /* Copy the saved-up fields into the field vector. */
320 for (int i
= 0; i
< nfields
; ++i
)
322 struct ctf_nextfield
&field
= fip
->fields
[i
];
323 type
->field (i
) = field
.field
;
327 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
328 (which may be different from NAME) to the architecture back-end to allow
329 it to guess the correct format if necessary. */
332 ctf_init_float_type (struct objfile
*objfile
,
335 const char *name_hint
)
337 struct gdbarch
*gdbarch
= objfile
->arch ();
338 const struct floatformat
**format
;
341 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
342 if (format
!= nullptr)
343 type
= init_float_type (objfile
, bits
, name
, format
);
345 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
350 /* Callback to add member NAME to a struct/union type. TID is the type
351 of struct/union member, OFFSET is the offset of member in bits,
352 and ARG contains the ctf_field_info. */
355 ctf_add_member_cb (const char *name
,
357 unsigned long offset
,
360 struct ctf_field_info
*fip
= (struct ctf_field_info
*) arg
;
361 struct ctf_context
*ccp
= fip
->cur_context
;
362 struct ctf_nextfield new_field
;
367 fp
= &new_field
.field
;
368 FIELD_NAME (*fp
) = name
;
370 kind
= ctf_type_kind (ccp
->fp
, tid
);
371 t
= get_tid_type (ccp
->of
, tid
);
374 t
= read_type_record (ccp
, tid
);
377 complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name
, tid
);
378 t
= objfile_type (ccp
->of
)->builtin_error
;
379 set_tid_type (ccp
->of
, tid
, t
);
383 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
)
384 process_struct_members (ccp
, tid
, t
);
387 SET_FIELD_BITPOS (*fp
, offset
/ TARGET_CHAR_BIT
);
388 FIELD_BITSIZE (*fp
) = get_bitsize (ccp
->fp
, tid
, kind
);
390 fip
->fields
.emplace_back (new_field
);
395 /* Callback to add member NAME of EVAL to an enumeration type.
396 ARG contains the ctf_field_info. */
399 ctf_add_enum_member_cb (const char *name
, int enum_value
, void *arg
)
401 struct ctf_field_info
*fip
= (struct ctf_field_info
*) arg
;
402 struct ctf_nextfield new_field
;
404 struct ctf_context
*ccp
= fip
->cur_context
;
406 fp
= &new_field
.field
;
407 FIELD_NAME (*fp
) = name
;
408 fp
->set_type (nullptr);
409 SET_FIELD_ENUMVAL (*fp
, enum_value
);
410 FIELD_BITSIZE (*fp
) = 0;
414 struct symbol
*sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
415 OBJSTAT (ccp
->of
, n_syms
++);
417 sym
->set_language (language_c
, &ccp
->of
->objfile_obstack
);
418 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
419 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
420 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
421 SYMBOL_TYPE (sym
) = fip
->ptype
;
422 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
425 fip
->fields
.emplace_back (new_field
);
430 /* Add a new symbol entry, with its name from TID, its access index and
431 domain from TID's kind, and its type from TYPE. */
433 static struct symbol
*
434 new_symbol (struct ctf_context
*ccp
, struct type
*type
, ctf_id_t tid
)
436 struct objfile
*objfile
= ccp
->of
;
437 ctf_dict_t
*fp
= ccp
->fp
;
438 struct symbol
*sym
= nullptr;
440 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
443 sym
= new (&objfile
->objfile_obstack
) symbol
;
444 OBJSTAT (objfile
, n_syms
++);
446 sym
->set_language (language_c
, &objfile
->objfile_obstack
);
447 sym
->compute_and_set_names (name
.get (), true, objfile
->per_bfd
);
448 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
449 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
452 SYMBOL_TYPE (sym
) = type
;
454 uint32_t kind
= ctf_type_kind (fp
, tid
);
460 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
461 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
464 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
467 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
468 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
473 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
474 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
487 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
493 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
494 and create the symbol for it. */
497 read_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
499 struct objfile
*of
= ccp
->of
;
500 ctf_dict_t
*fp
= ccp
->fp
;
502 struct type
*type
= nullptr;
506 if (ctf_type_encoding (fp
, tid
, &cet
))
508 complaint (_("ctf_type_encoding read_base_type failed - %s"),
509 ctf_errmsg (ctf_errno (fp
)));
513 gdb::unique_xmalloc_ptr
<char> copied_name (ctf_type_aname_raw (fp
, tid
));
514 if (copied_name
== nullptr || strlen (copied_name
.get ()) == 0)
516 name
= ctf_type_aname (fp
, tid
);
518 complaint (_("ctf_type_aname read_base_type failed - %s"),
519 ctf_errmsg (ctf_errno (fp
)));
522 name
= obstack_strdup (&of
->objfile_obstack
, copied_name
.get ());
524 kind
= ctf_type_kind (fp
, tid
);
525 if (kind
== CTF_K_INTEGER
)
527 uint32_t issigned
, ischar
, isbool
;
528 struct gdbarch
*gdbarch
= of
->arch ();
530 issigned
= cet
.cte_format
& CTF_INT_SIGNED
;
531 ischar
= cet
.cte_format
& CTF_INT_CHAR
;
532 isbool
= cet
.cte_format
& CTF_INT_BOOL
;
534 type
= init_character_type (of
, TARGET_CHAR_BIT
, !issigned
, name
);
536 type
= init_boolean_type (of
, gdbarch_int_bit (gdbarch
),
541 if (cet
.cte_bits
&& ((cet
.cte_bits
% TARGET_CHAR_BIT
) == 0))
544 bits
= gdbarch_int_bit (gdbarch
);
545 type
= init_integer_type (of
, bits
, !issigned
, name
);
548 else if (kind
== CTF_K_FLOAT
)
551 isflt
= !((cet
.cte_format
& CTF_FP_IMAGRY
) == CTF_FP_IMAGRY
552 || (cet
.cte_format
& CTF_FP_DIMAGRY
) == CTF_FP_DIMAGRY
553 || (cet
.cte_format
& CTF_FP_LDIMAGRY
) == CTF_FP_LDIMAGRY
);
555 type
= ctf_init_float_type (of
, cet
.cte_bits
, name
, name
);
559 = ctf_init_float_type (of
, cet
.cte_bits
/ 2, NULL
, name
);
560 type
= init_complex_type (name
, t
);
565 complaint (_("read_base_type: unsupported base kind (%d)"), kind
);
566 type
= init_type (of
, TYPE_CODE_ERROR
, cet
.cte_bits
, name
);
569 if (name
!= nullptr && strcmp (name
, "char") == 0)
570 type
->set_has_no_signedness (true);
572 return set_tid_type (of
, tid
, type
);
576 process_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
580 type
= read_base_type (ccp
, tid
);
581 new_symbol (ccp
, type
, tid
);
584 /* Start a structure or union scope (definition) with TID to create a type
585 for the structure or union.
587 Fill in the type's name and general properties. The members will not be
588 processed, nor a symbol table entry be done until process_structure_type
589 (assuming the type has a name). */
592 read_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
594 struct objfile
*of
= ccp
->of
;
595 ctf_dict_t
*fp
= ccp
->fp
;
599 type
= alloc_type (of
);
601 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
602 if (name
!= nullptr && strlen (name
.get ()) != 0)
603 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
605 kind
= ctf_type_kind (fp
, tid
);
606 if (kind
== CTF_K_UNION
)
607 type
->set_code (TYPE_CODE_UNION
);
609 type
->set_code (TYPE_CODE_STRUCT
);
611 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
612 set_type_align (type
, ctf_type_align (fp
, tid
));
614 return set_tid_type (ccp
->of
, tid
, type
);
617 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
618 and create the symbol for it. */
621 process_struct_members (struct ctf_context
*ccp
,
625 struct ctf_field_info fi
;
627 fi
.cur_context
= ccp
;
628 if (ctf_member_iter (ccp
->fp
, tid
, ctf_add_member_cb
, &fi
) == CTF_ERR
)
629 complaint (_("ctf_member_iter process_struct_members failed - %s"),
630 ctf_errmsg (ctf_errno (ccp
->fp
)));
632 /* Attach fields to the type. */
633 attach_fields_to_type (&fi
, type
);
635 new_symbol (ccp
, type
, tid
);
639 process_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
643 type
= read_structure_type (ccp
, tid
);
644 process_struct_members (ccp
, tid
, type
);
647 /* Create a function type for TID and set its return type. */
650 read_func_kind_type (struct ctf_context
*ccp
, ctf_id_t tid
)
652 struct objfile
*of
= ccp
->of
;
653 ctf_dict_t
*fp
= ccp
->fp
;
654 struct type
*type
, *rettype
, *atype
;
658 type
= alloc_type (of
);
660 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
661 if (name
!= nullptr && strlen (name
.get ()) != 0)
662 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
664 type
->set_code (TYPE_CODE_FUNC
);
665 ctf_func_type_info (fp
, tid
, &cfi
);
666 rettype
= get_tid_type (of
, cfi
.ctc_return
);
667 TYPE_TARGET_TYPE (type
) = rettype
;
668 set_type_align (type
, ctf_type_align (fp
, tid
));
670 /* Set up function's arguments. */
672 type
->set_num_fields (argc
);
673 if ((cfi
.ctc_flags
& CTF_FUNC_VARARG
) != 0)
674 type
->set_has_varargs (true);
678 std::vector
<ctf_id_t
> argv (argc
);
679 if (ctf_func_type_args (fp
, tid
, argc
, argv
.data ()) == CTF_ERR
)
683 ((struct field
*) TYPE_ZALLOC (type
, argc
* sizeof (struct field
)));
684 struct type
*void_type
= objfile_type (of
)->builtin_void
;
685 /* If failed to find the argument type, fill it with void_type. */
686 for (int iparam
= 0; iparam
< argc
; iparam
++)
688 atype
= get_tid_type (of
, argv
[iparam
]);
689 if (atype
!= nullptr)
690 type
->field (iparam
).set_type (atype
);
692 type
->field (iparam
).set_type (void_type
);
696 return set_tid_type (of
, tid
, type
);
699 /* Given a TID of CTF_K_ENUM, process all the members of the
700 enumeration, and create the symbol for the enumeration type. */
703 read_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
705 struct objfile
*of
= ccp
->of
;
706 ctf_dict_t
*fp
= ccp
->fp
;
707 struct type
*type
, *target_type
;
710 type
= alloc_type (of
);
712 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
713 if (name
!= nullptr && strlen (name
.get ()) != 0)
714 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
716 type
->set_code (TYPE_CODE_ENUM
);
717 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
718 ctf_func_type_info (fp
, tid
, &fi
);
719 target_type
= get_tid_type (of
, fi
.ctc_return
);
720 TYPE_TARGET_TYPE (type
) = target_type
;
721 set_type_align (type
, ctf_type_align (fp
, tid
));
723 return set_tid_type (of
, tid
, type
);
727 process_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
730 struct ctf_field_info fi
;
732 type
= read_enum_type (ccp
, tid
);
734 fi
.cur_context
= ccp
;
736 if (ctf_enum_iter (ccp
->fp
, tid
, ctf_add_enum_member_cb
, &fi
) == CTF_ERR
)
737 complaint (_("ctf_enum_iter process_enum_type failed - %s"),
738 ctf_errmsg (ctf_errno (ccp
->fp
)));
740 /* Attach fields to the type. */
741 attach_fields_to_type (&fi
, type
);
743 new_symbol (ccp
, type
, tid
);
746 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */
749 add_array_cv_type (struct ctf_context
*ccp
,
751 struct type
*base_type
,
755 struct type
*el_type
, *inner_array
;
757 base_type
= copy_type (base_type
);
758 inner_array
= base_type
;
760 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
762 TYPE_TARGET_TYPE (inner_array
)
763 = copy_type (TYPE_TARGET_TYPE (inner_array
));
764 inner_array
= TYPE_TARGET_TYPE (inner_array
);
767 el_type
= TYPE_TARGET_TYPE (inner_array
);
768 cnst
|= TYPE_CONST (el_type
);
769 voltl
|= TYPE_VOLATILE (el_type
);
770 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, nullptr);
772 return set_tid_type (ccp
->of
, tid
, base_type
);
775 /* Read all information from a TID of CTF_K_ARRAY. */
778 read_array_type (struct ctf_context
*ccp
, ctf_id_t tid
)
780 struct objfile
*objfile
= ccp
->of
;
781 ctf_dict_t
*fp
= ccp
->fp
;
782 struct type
*element_type
, *range_type
, *idx_type
;
786 if (ctf_array_info (fp
, tid
, &ar
) == CTF_ERR
)
788 complaint (_("ctf_array_info read_array_type failed - %s"),
789 ctf_errmsg (ctf_errno (fp
)));
793 element_type
= get_tid_type (objfile
, ar
.ctr_contents
);
794 if (element_type
== nullptr)
797 idx_type
= get_tid_type (objfile
, ar
.ctr_index
);
798 if (idx_type
== nullptr)
799 idx_type
= objfile_type (objfile
)->builtin_int
;
801 range_type
= create_static_range_type (NULL
, idx_type
, 0, ar
.ctr_nelems
- 1);
802 type
= create_array_type (NULL
, element_type
, range_type
);
803 if (ar
.ctr_nelems
<= 1) /* Check if undefined upper bound. */
805 range_type
->bounds ()->high
.set_undefined ();
806 TYPE_LENGTH (type
) = 0;
807 type
->set_target_is_stub (true);
810 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
812 set_type_align (type
, ctf_type_align (fp
, tid
));
814 return set_tid_type (objfile
, tid
, type
);
817 /* Read TID of kind CTF_K_CONST with base type BTID. */
820 read_const_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
822 struct objfile
*objfile
= ccp
->of
;
823 struct type
*base_type
, *cv_type
;
825 base_type
= get_tid_type (objfile
, btid
);
826 if (base_type
== nullptr)
828 base_type
= read_type_record (ccp
, btid
);
829 if (base_type
== nullptr)
831 complaint (_("read_const_type: NULL base type (%ld)"), btid
);
832 base_type
= objfile_type (objfile
)->builtin_error
;
835 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
837 return set_tid_type (objfile
, tid
, cv_type
);
840 /* Read TID of kind CTF_K_VOLATILE with base type BTID. */
843 read_volatile_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
845 struct objfile
*objfile
= ccp
->of
;
846 ctf_dict_t
*fp
= ccp
->fp
;
847 struct type
*base_type
, *cv_type
;
849 base_type
= get_tid_type (objfile
, btid
);
850 if (base_type
== nullptr)
852 base_type
= read_type_record (ccp
, btid
);
853 if (base_type
== nullptr)
855 complaint (_("read_volatile_type: NULL base type (%ld)"), btid
);
856 base_type
= objfile_type (objfile
)->builtin_error
;
860 if (ctf_type_kind (fp
, btid
) == CTF_K_ARRAY
)
861 return add_array_cv_type (ccp
, tid
, base_type
, 0, 1);
862 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
864 return set_tid_type (objfile
, tid
, cv_type
);
867 /* Read TID of kind CTF_K_RESTRICT with base type BTID. */
870 read_restrict_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
872 struct objfile
*objfile
= ccp
->of
;
873 struct type
*base_type
, *cv_type
;
875 base_type
= get_tid_type (objfile
, btid
);
876 if (base_type
== nullptr)
878 base_type
= read_type_record (ccp
, btid
);
879 if (base_type
== nullptr)
881 complaint (_("read_restrict_type: NULL base type (%ld)"), btid
);
882 base_type
= objfile_type (objfile
)->builtin_error
;
885 cv_type
= make_restrict_type (base_type
);
887 return set_tid_type (objfile
, tid
, cv_type
);
890 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */
893 read_typedef_type (struct ctf_context
*ccp
, ctf_id_t tid
,
894 ctf_id_t btid
, const char *name
)
896 struct objfile
*objfile
= ccp
->of
;
897 struct type
*this_type
, *target_type
;
899 char *aname
= obstack_strdup (&objfile
->objfile_obstack
, name
);
900 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, aname
);
901 set_tid_type (objfile
, tid
, this_type
);
902 target_type
= get_tid_type (objfile
, btid
);
903 if (target_type
!= this_type
)
904 TYPE_TARGET_TYPE (this_type
) = target_type
;
906 TYPE_TARGET_TYPE (this_type
) = nullptr;
908 this_type
->set_target_is_stub (TYPE_TARGET_TYPE (this_type
) != nullptr);
910 return set_tid_type (objfile
, tid
, this_type
);
913 /* Read TID of kind CTF_K_POINTER with base type BTID. */
916 read_pointer_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
918 struct objfile
*of
= ccp
->of
;
919 struct type
*target_type
, *type
;
921 target_type
= get_tid_type (of
, btid
);
922 if (target_type
== nullptr)
924 target_type
= read_type_record (ccp
, btid
);
925 if (target_type
== nullptr)
927 complaint (_("read_pointer_type: NULL target type (%ld)"), btid
);
928 target_type
= objfile_type (ccp
->of
)->builtin_error
;
932 type
= lookup_pointer_type (target_type
);
933 set_type_align (type
, ctf_type_align (ccp
->fp
, tid
));
935 return set_tid_type (of
, tid
, type
);
938 /* Read information associated with type TID. */
941 read_type_record (struct ctf_context
*ccp
, ctf_id_t tid
)
943 ctf_dict_t
*fp
= ccp
->fp
;
945 struct type
*type
= nullptr;
948 kind
= ctf_type_kind (fp
, tid
);
953 type
= read_structure_type (ccp
, tid
);
956 type
= read_enum_type (ccp
, tid
);
959 type
= read_func_kind_type (ccp
, tid
);
962 btid
= ctf_type_reference (fp
, tid
);
963 type
= read_const_type (ccp
, tid
, btid
);
967 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
968 btid
= ctf_type_reference (fp
, tid
);
969 type
= read_typedef_type (ccp
, tid
, btid
, name
.get ());
973 btid
= ctf_type_reference (fp
, tid
);
974 type
= read_volatile_type (ccp
, tid
, btid
);
977 btid
= ctf_type_reference (fp
, tid
);
978 type
= read_restrict_type (ccp
, tid
, btid
);
981 btid
= ctf_type_reference (fp
, tid
);
982 type
= read_pointer_type (ccp
, tid
, btid
);
986 type
= read_base_type (ccp
, tid
);
989 type
= read_array_type (ccp
, tid
);
1000 /* Callback to add type TID to the symbol table. */
1003 ctf_add_type_cb (ctf_id_t tid
, void *arg
)
1005 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1009 /* Check if tid's type has already been defined. */
1010 type
= get_tid_type (ccp
->of
, tid
);
1011 if (type
!= nullptr)
1014 ctf_id_t btid
= ctf_type_reference (ccp
->fp
, tid
);
1015 kind
= ctf_type_kind (ccp
->fp
, tid
);
1020 process_structure_type (ccp
, tid
);
1023 process_enum_type (ccp
, tid
);
1025 case CTF_K_FUNCTION
:
1026 type
= read_func_kind_type (ccp
, tid
);
1027 new_symbol (ccp
, type
, tid
);
1031 process_base_type (ccp
, tid
);
1034 new_symbol (ccp
, read_type_record (ccp
, tid
), tid
);
1037 type
= read_const_type (ccp
, tid
, btid
);
1038 new_symbol (ccp
, type
, tid
);
1040 case CTF_K_VOLATILE
:
1041 type
= read_volatile_type (ccp
, tid
, btid
);
1042 new_symbol (ccp
, type
, tid
);
1044 case CTF_K_RESTRICT
:
1045 type
= read_restrict_type (ccp
, tid
, btid
);
1046 new_symbol (ccp
, type
, tid
);
1049 type
= read_pointer_type (ccp
, tid
, btid
);
1050 new_symbol (ccp
, type
, tid
);
1053 type
= read_array_type (ccp
, tid
);
1054 new_symbol (ccp
, type
, tid
);
1065 /* Callback to add variable NAME with TID to the symbol table. */
1068 ctf_add_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1070 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1071 struct symbol
*sym
= nullptr;
1075 type
= get_tid_type (ccp
->of
, id
);
1077 kind
= ctf_type_kind (ccp
->fp
, id
);
1080 case CTF_K_FUNCTION
:
1081 if (name
!= nullptr && strcmp (name
, "main") == 0)
1082 set_objfile_main_name (ccp
->of
, name
, language_c
);
1086 case CTF_K_VOLATILE
:
1087 case CTF_K_RESTRICT
:
1094 sym
= new_symbol (ccp
, type
, id
);
1095 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1101 if (type
== nullptr)
1103 complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name
, id
);
1104 type
= objfile_type (ccp
->of
)->builtin_error
;
1106 sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
1107 OBJSTAT (ccp
->of
, n_syms
++);
1108 SYMBOL_TYPE (sym
) = type
;
1109 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1110 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
1111 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1112 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
1115 complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind
);
1120 set_symbol_address (ccp
->of
, sym
, name
);
1125 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table. */
1127 static struct symbol
*
1128 add_stt_obj (struct ctf_context
*ccp
, unsigned long idx
)
1134 if ((tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
)) == CTF_ERR
)
1137 type
= get_tid_type (ccp
->of
, tid
);
1138 if (type
== nullptr)
1141 sym
= new_symbol (ccp
, type
, tid
);
1146 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table. */
1148 static struct symbol
*
1149 add_stt_func (struct ctf_context
*ccp
, unsigned long idx
)
1151 struct type
*ftype
, *atyp
, *rettyp
;
1153 ctf_funcinfo_t finfo
;
1157 struct type
*void_type
= objfile_type (ccp
->of
)->builtin_void
;
1159 if (ctf_func_info (ccp
->fp
, idx
, &finfo
) == CTF_ERR
)
1162 argc
= finfo
.ctc_argc
;
1163 if (ctf_func_args (ccp
->fp
, idx
, argc
, argv
) == CTF_ERR
)
1166 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, idx
));
1167 if (name
== nullptr)
1170 tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
);
1171 ftype
= get_tid_type (ccp
->of
, tid
);
1172 if ((finfo
.ctc_flags
& CTF_FUNC_VARARG
) != 0)
1173 ftype
->set_has_varargs (true);
1174 ftype
->set_num_fields (argc
);
1176 /* If argc is 0, it has a "void" type. */
1179 ((struct field
*) TYPE_ZALLOC (ftype
, argc
* sizeof (struct field
)));
1181 /* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed
1182 to find the argument type. */
1183 for (int iparam
= 0; iparam
< argc
; iparam
++)
1185 atyp
= get_tid_type (ccp
->of
, argv
[iparam
]);
1187 ftype
->field (iparam
).set_type (atyp
);
1189 ftype
->field (iparam
).set_type (void_type
);
1192 sym
= new_symbol (ccp
, ftype
, tid
);
1193 rettyp
= get_tid_type (ccp
->of
, finfo
.ctc_return
);
1194 if (rettyp
!= nullptr)
1195 SYMBOL_TYPE (sym
) = rettyp
;
1197 SYMBOL_TYPE (sym
) = void_type
;
1202 /* Get text segment base for OBJFILE, TSIZE contains the segment size. */
1205 get_objfile_text_range (struct objfile
*of
, int *tsize
)
1207 bfd
*abfd
= of
->obfd
;
1208 const asection
*codes
;
1210 codes
= bfd_get_section_by_name (abfd
, ".text");
1211 *tsize
= codes
? bfd_section_size (codes
) : 0;
1212 return of
->text_section_offset ();
1215 /* Start a symtab for OBJFILE in CTF format. */
1218 ctf_start_symtab (ctf_psymtab
*pst
,
1219 struct objfile
*of
, CORE_ADDR text_offset
)
1221 struct ctf_context
*ccp
;
1224 ccp
->builder
= new buildsym_compunit
1225 (of
, of
->original_name
, nullptr,
1226 language_c
, text_offset
);
1227 ccp
->builder
->record_debugformat ("ctf");
1230 /* Finish reading symbol/type definitions in CTF format.
1231 END_ADDR is the end address of the file's text. SECTION is
1232 the .text section number. */
1234 static struct compunit_symtab
*
1235 ctf_end_symtab (ctf_psymtab
*pst
,
1236 CORE_ADDR end_addr
, int section
)
1238 struct ctf_context
*ccp
;
1241 struct compunit_symtab
*result
1242 = ccp
->builder
->end_symtab (end_addr
, section
);
1243 delete ccp
->builder
;
1244 ccp
->builder
= nullptr;
1248 /* Add all members of an enum with type TID to partial symbol table. */
1251 ctf_psymtab_add_enums (struct ctf_context
*ccp
, ctf_id_t tid
)
1255 ctf_next_t
*i
= nullptr;
1257 while ((ename
= ctf_enum_next (ccp
->fp
, tid
, &i
, &val
)) != nullptr)
1259 ccp
->pst
->add_psymbol (ename
, true,
1260 VAR_DOMAIN
, LOC_CONST
, -1,
1261 psymbol_placement::GLOBAL
,
1262 0, language_c
, ccp
->of
);
1264 if (ctf_errno (ccp
->fp
) != ECTF_NEXT_END
)
1265 complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1266 ctf_errmsg (ctf_errno (ccp
->fp
)));
1269 /* Read in full symbols for PST, and anything it depends on. */
1272 ctf_psymtab::expand_psymtab (struct objfile
*objfile
)
1275 struct ctf_context
*ccp
;
1277 gdb_assert (!readin
);
1281 /* Iterate over entries in data types section. */
1282 if (ctf_type_iter (ccp
->fp
, ctf_add_type_cb
, ccp
) == CTF_ERR
)
1283 complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1284 ctf_errmsg (ctf_errno (ccp
->fp
)));
1287 /* Iterate over entries in variable info section. */
1288 if (ctf_variable_iter (ccp
->fp
, ctf_add_var_cb
, ccp
) == CTF_ERR
)
1289 complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1290 ctf_errmsg (ctf_errno (ccp
->fp
)));
1292 /* Add entries in data objects and function info sections. */
1293 for (unsigned long i
= 0; ; i
++)
1295 sym
= add_stt_obj (ccp
, i
);
1298 if (ctf_errno (ccp
->fp
) == EINVAL
1299 || ctf_errno (ccp
->fp
) == ECTF_NOSYMTAB
)
1301 sym
= add_stt_func (ccp
, i
);
1306 set_symbol_address (ccp
->of
, sym
, sym
->linkage_name ());
1312 /* Expand partial symbol table PST into a full symbol table.
1316 ctf_psymtab::read_symtab (struct objfile
*objfile
)
1319 warning (_("bug: psymtab for %s is already read in."), filename
);
1324 printf_filtered (_("Reading in CTF data for %s..."), filename
);
1325 gdb_flush (gdb_stdout
);
1328 /* Start a symtab. */
1329 CORE_ADDR offset
; /* Start of text segment. */
1332 offset
= get_objfile_text_range (objfile
, &tsize
);
1333 ctf_start_symtab (this, objfile
, offset
);
1334 expand_psymtab (objfile
);
1336 set_text_low (offset
);
1337 set_text_high (offset
+ tsize
);
1338 compunit_symtab
= ctf_end_symtab (this, offset
+ tsize
,
1339 SECT_OFF_TEXT (objfile
));
1341 /* Finish up the debug error message. */
1343 printf_filtered (_("done.\n"));
1347 /* Allocate a new partial_symtab NAME.
1349 Each source file that has not been fully read in is represented by
1350 a partial_symtab. This contains the information on where in the
1351 executable the debugging symbols for a specific file are, and a
1352 list of names of global symbols which are located in this file.
1353 They are all chained on partial symtab lists.
1355 Even after the source file has been read into a symtab, the
1356 partial_symtab remains around. They are allocated on an obstack,
1359 static ctf_psymtab
*
1360 create_partial_symtab (const char *name
,
1362 struct objfile
*objfile
)
1365 struct ctf_context
*ccx
;
1367 pst
= new ctf_psymtab (name
, objfile
, 0);
1369 ccx
= XOBNEW (&objfile
->objfile_obstack
, struct ctf_context
);
1373 ccx
->builder
= nullptr;
1379 /* Callback to add type TID to partial symbol table. */
1382 ctf_psymtab_type_cb (ctf_id_t tid
, void *arg
)
1384 struct ctf_context
*ccp
;
1388 ccp
= (struct ctf_context
*) arg
;
1389 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, tid
));
1391 domain_enum domain
= UNDEF_DOMAIN
;
1392 enum address_class aclass
= LOC_UNDEF
;
1393 kind
= ctf_type_kind (ccp
->fp
, tid
);
1397 ctf_psymtab_add_enums (ccp
, tid
);
1401 domain
= STRUCT_DOMAIN
;
1402 aclass
= LOC_TYPEDEF
;
1404 case CTF_K_FUNCTION
:
1406 domain
= VAR_DOMAIN
;
1407 aclass
= LOC_STATIC
;
1408 section
= SECT_OFF_TEXT (ccp
->of
);
1411 domain
= VAR_DOMAIN
;
1412 aclass
= LOC_STATIC
;
1416 case CTF_K_VOLATILE
:
1417 case CTF_K_RESTRICT
:
1418 domain
= VAR_DOMAIN
;
1419 aclass
= LOC_TYPEDEF
;
1423 domain
= VAR_DOMAIN
;
1424 aclass
= LOC_TYPEDEF
;
1431 if (name
== nullptr || strlen (name
.get ()) == 0)
1434 ccp
->pst
->add_psymbol (name
.get (), true,
1435 domain
, aclass
, section
,
1436 psymbol_placement::GLOBAL
,
1437 0, language_c
, ccp
->of
);
1442 /* Callback to add variable NAME with ID to partial symbol table. */
1445 ctf_psymtab_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1447 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1449 ccp
->pst
->add_psymbol (name
, true,
1450 VAR_DOMAIN
, LOC_STATIC
, -1,
1451 psymbol_placement::GLOBAL
,
1452 0, language_c
, ccp
->of
);
1456 /* Setup partial_symtab's describing each source file for which
1457 debugging information is available. */
1460 scan_partial_symbols (ctf_dict_t
*cfp
, struct objfile
*of
)
1462 bfd
*abfd
= of
->obfd
;
1463 const char *name
= bfd_get_filename (abfd
);
1464 ctf_psymtab
*pst
= create_partial_symtab (name
, cfp
, of
);
1466 struct ctf_context
*ccx
= pst
->context
;
1468 if (ctf_type_iter (cfp
, ctf_psymtab_type_cb
, ccx
) == CTF_ERR
)
1469 complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1470 ctf_errmsg (ctf_errno (cfp
)));
1472 if (ctf_variable_iter (cfp
, ctf_psymtab_var_cb
, ccx
) == CTF_ERR
)
1473 complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1474 ctf_errmsg (ctf_errno (cfp
)));
1476 /* Scan CTF object and function sections which correspond to each
1477 STT_FUNC or STT_OBJECT entry in the symbol table,
1478 pick up what init_symtab has done. */
1479 for (unsigned long idx
= 0; ; idx
++)
1482 if ((tid
= ctf_lookup_by_symbol (cfp
, idx
)) == CTF_ERR
)
1484 if (ctf_errno (cfp
) == EINVAL
|| ctf_errno (cfp
) == ECTF_NOSYMTAB
)
1485 break; // Done, reach end of the section.
1489 gdb::unique_xmalloc_ptr
<char> tname (ctf_type_aname_raw (cfp
, tid
));
1490 uint32_t kind
= ctf_type_kind (cfp
, tid
);
1491 address_class aclass
;
1492 domain_enum tdomain
;
1498 tdomain
= STRUCT_DOMAIN
;
1501 tdomain
= VAR_DOMAIN
;
1505 if (kind
== CTF_K_FUNCTION
)
1506 aclass
= LOC_STATIC
;
1507 else if (kind
== CTF_K_CONST
)
1510 aclass
= LOC_TYPEDEF
;
1512 pst
->add_psymbol (tname
.get (), true,
1513 tdomain
, aclass
, -1,
1514 psymbol_placement::STATIC
,
1521 /* Read CTF debugging information from a BFD section. This is
1522 called from elfread.c. It does a quick pass through the
1523 .ctf section to set up the partial symbol table. */
1526 elfctf_build_psymtabs (struct objfile
*of
)
1528 bfd
*abfd
= of
->obfd
;
1531 ctf_archive_t
*arc
= ctf_bfdopen (abfd
, &err
);
1533 error (_("ctf_bfdopen failed on %s - %s"),
1534 bfd_get_filename (abfd
), ctf_errmsg (err
));
1536 ctf_dict_t
*fp
= ctf_dict_open (arc
, NULL
, &err
);
1538 error (_("ctf_dict_open failed on %s - %s"),
1539 bfd_get_filename (abfd
), ctf_errmsg (err
));
1540 ctf_dict_key
.emplace (of
, fp
);
1542 scan_partial_symbols (fp
, of
);
1548 elfctf_build_psymtabs (struct objfile
*of
)
1550 /* Nothing to do if CTF is disabled. */
1553 #endif /* ENABLE_LIBCTF */