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
;
120 struct buildsym_compunit
*builder
;
123 /* A partial symtab, specialized for this module. */
124 struct ctf_psymtab
: public standard_psymtab
126 ctf_psymtab (const char *filename
,
127 psymtab_storage
*partial_symtabs
,
128 objfile_per_bfd_storage
*objfile_per_bfd
,
130 : standard_psymtab (filename
, partial_symtabs
, objfile_per_bfd
, addr
)
134 void read_symtab (struct objfile
*) override
;
135 void expand_psymtab (struct objfile
*) override
;
137 struct ctf_context
*context
;
140 /* The routines that read and process fields/members of a C struct, union,
141 or enumeration, pass lists of data member fields in an instance of a
142 ctf_field_info structure. It is derived from dwarf2read.c. */
146 struct field field
{};
149 struct ctf_field_info
151 /* List of data member fields. */
152 std::vector
<struct ctf_nextfield
> fields
;
155 struct ctf_context
*cur_context
;
160 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head
161 of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
162 std::vector
<struct decl_field
> typedef_field_list
;
164 /* Nested types defined by this struct and the number of elements in
166 std::vector
<struct decl_field
> nested_types_list
;
170 /* Local function prototypes */
172 static int ctf_add_type_cb (ctf_id_t tid
, void *arg
);
174 static struct type
*read_array_type (struct ctf_context
*cp
, ctf_id_t tid
);
176 static struct type
*read_pointer_type (struct ctf_context
*cp
, ctf_id_t tid
,
179 static struct type
*read_structure_type (struct ctf_context
*cp
, ctf_id_t tid
);
181 static struct type
*read_enum_type (struct ctf_context
*cp
, ctf_id_t tid
);
183 static struct type
*read_typedef_type (struct ctf_context
*cp
, ctf_id_t tid
,
184 ctf_id_t btid
, const char *name
);
186 static struct type
*read_type_record (struct ctf_context
*cp
, ctf_id_t tid
);
188 static void process_structure_type (struct ctf_context
*cp
, ctf_id_t tid
);
190 static void process_struct_members (struct ctf_context
*cp
, ctf_id_t tid
,
193 static struct type
*read_forward_type (struct ctf_context
*cp
, ctf_id_t tid
);
195 static struct symbol
*new_symbol (struct ctf_context
*cp
, struct type
*type
,
198 struct ctf_tid_and_type
204 /* Hash function for a ctf_tid_and_type. */
207 tid_and_type_hash (const void *item
)
209 const struct ctf_tid_and_type
*ids
210 = (const struct ctf_tid_and_type
*) item
;
215 /* Equality function for a ctf_tid_and_type. */
218 tid_and_type_eq (const void *item_lhs
, const void *item_rhs
)
220 const struct ctf_tid_and_type
*ids_lhs
221 = (const struct ctf_tid_and_type
*) item_lhs
;
222 const struct ctf_tid_and_type
*ids_rhs
223 = (const struct ctf_tid_and_type
*) item_rhs
;
225 return ids_lhs
->tid
== ids_rhs
->tid
;
228 /* Set the type associated with TID to TYP. */
231 set_tid_type (struct objfile
*of
, ctf_id_t tid
, struct type
*typ
)
235 htab
= (htab_t
) ctf_tid_key
.get (of
);
238 htab
= htab_create_alloc (1, tid_and_type_hash
,
240 NULL
, xcalloc
, xfree
);
241 ctf_tid_key
.set (of
, htab
);
244 struct ctf_tid_and_type
**slot
, ids
;
247 slot
= (struct ctf_tid_and_type
**) htab_find_slot (htab
, &ids
, INSERT
);
249 complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"),
251 *slot
= XOBNEW (&of
->objfile_obstack
, struct ctf_tid_and_type
);
256 /* Look up the type for TID in tid_and_type hash, return NULL if hash is
257 empty or TID does not have a saved type. */
260 get_tid_type (struct objfile
*of
, ctf_id_t tid
)
262 struct ctf_tid_and_type
*slot
, ids
;
265 htab
= (htab_t
) ctf_tid_key
.get (of
);
271 slot
= (struct ctf_tid_and_type
*) htab_find (htab
, &ids
);
278 /* Fetch the type for TID in CCP OF's tid_and_type hash, add the type to
279 * context CCP if hash is empty or TID does not have a saved type. */
282 fetch_tid_type (struct ctf_context
*ccp
, ctf_id_t tid
)
284 struct objfile
*of
= ccp
->of
;
287 typ
= get_tid_type (of
, tid
);
290 ctf_add_type_cb (tid
, ccp
);
291 typ
= get_tid_type (of
, tid
);
297 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */
300 get_bitsize (ctf_dict_t
*fp
, ctf_id_t tid
, uint32_t kind
)
304 if ((kind
== CTF_K_INTEGER
|| kind
== CTF_K_ENUM
305 || kind
== CTF_K_FLOAT
)
306 && ctf_type_reference (fp
, tid
) != CTF_ERR
307 && ctf_type_encoding (fp
, tid
, &cet
) != CTF_ERR
)
313 /* Set SYM's address, with NAME, from its minimal symbol entry. */
316 set_symbol_address (struct objfile
*of
, struct symbol
*sym
, const char *name
)
318 struct bound_minimal_symbol msym
;
320 msym
= lookup_minimal_symbol (name
, nullptr, of
);
321 if (msym
.minsym
!= NULL
)
323 SET_SYMBOL_VALUE_ADDRESS (sym
, BMSYMBOL_VALUE_ADDRESS (msym
));
324 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
325 sym
->set_section_index (msym
.minsym
->section_index ());
329 /* Create the vector of fields, and attach it to TYPE. */
332 attach_fields_to_type (struct ctf_field_info
*fip
, struct type
*type
)
334 int nfields
= fip
->fields
.size ();
339 /* Record the field count, allocate space for the array of fields. */
340 type
->set_num_fields (nfields
);
342 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
344 /* Copy the saved-up fields into the field vector. */
345 for (int i
= 0; i
< nfields
; ++i
)
347 struct ctf_nextfield
&field
= fip
->fields
[i
];
348 type
->field (i
) = field
.field
;
352 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
353 (which may be different from NAME) to the architecture back-end to allow
354 it to guess the correct format if necessary. */
357 ctf_init_float_type (struct objfile
*objfile
,
360 const char *name_hint
)
362 struct gdbarch
*gdbarch
= objfile
->arch ();
363 const struct floatformat
**format
;
366 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
367 if (format
!= nullptr)
368 type
= init_float_type (objfile
, bits
, name
, format
);
370 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
375 /* Callback to add member NAME to a struct/union type. TID is the type
376 of struct/union member, OFFSET is the offset of member in bits,
377 and ARG contains the ctf_field_info. */
380 ctf_add_member_cb (const char *name
,
382 unsigned long offset
,
385 struct ctf_field_info
*fip
= (struct ctf_field_info
*) arg
;
386 struct ctf_context
*ccp
= fip
->cur_context
;
387 struct ctf_nextfield new_field
;
392 fp
= &new_field
.field
;
393 FIELD_NAME (*fp
) = name
;
395 kind
= ctf_type_kind (ccp
->fp
, tid
);
396 t
= fetch_tid_type (ccp
, tid
);
399 t
= read_type_record (ccp
, tid
);
402 complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name
, tid
);
403 t
= objfile_type (ccp
->of
)->builtin_error
;
404 set_tid_type (ccp
->of
, tid
, t
);
408 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
)
409 process_struct_members (ccp
, tid
, t
);
412 SET_FIELD_BITPOS (*fp
, offset
/ TARGET_CHAR_BIT
);
413 FIELD_BITSIZE (*fp
) = get_bitsize (ccp
->fp
, tid
, kind
);
415 fip
->fields
.emplace_back (new_field
);
420 /* Callback to add member NAME of EVAL to an enumeration type.
421 ARG contains the ctf_field_info. */
424 ctf_add_enum_member_cb (const char *name
, int enum_value
, void *arg
)
426 struct ctf_field_info
*fip
= (struct ctf_field_info
*) arg
;
427 struct ctf_nextfield new_field
;
429 struct ctf_context
*ccp
= fip
->cur_context
;
431 fp
= &new_field
.field
;
432 FIELD_NAME (*fp
) = name
;
433 fp
->set_type (nullptr);
434 SET_FIELD_ENUMVAL (*fp
, enum_value
);
435 FIELD_BITSIZE (*fp
) = 0;
439 struct symbol
*sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
440 OBJSTAT (ccp
->of
, n_syms
++);
442 sym
->set_language (language_c
, &ccp
->of
->objfile_obstack
);
443 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
444 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
445 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
446 SYMBOL_TYPE (sym
) = fip
->ptype
;
447 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
450 fip
->fields
.emplace_back (new_field
);
455 /* Add a new symbol entry, with its name from TID, its access index and
456 domain from TID's kind, and its type from TYPE. */
458 static struct symbol
*
459 new_symbol (struct ctf_context
*ccp
, struct type
*type
, ctf_id_t tid
)
461 struct objfile
*objfile
= ccp
->of
;
462 ctf_dict_t
*fp
= ccp
->fp
;
463 struct symbol
*sym
= nullptr;
465 const char *name
= ctf_type_name_raw (fp
, tid
);
468 sym
= new (&objfile
->objfile_obstack
) symbol
;
469 OBJSTAT (objfile
, n_syms
++);
471 sym
->set_language (language_c
, &objfile
->objfile_obstack
);
472 sym
->compute_and_set_names (name
, false, objfile
->per_bfd
);
473 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
474 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
477 SYMBOL_TYPE (sym
) = type
;
479 uint32_t kind
= ctf_type_kind (fp
, tid
);
485 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
486 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
489 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
490 set_symbol_address (objfile
, sym
, sym
->linkage_name ());
493 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
494 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
499 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
500 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
513 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
519 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
520 and create the symbol for it. */
523 read_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
525 struct objfile
*of
= ccp
->of
;
526 ctf_dict_t
*fp
= ccp
->fp
;
528 struct type
*type
= nullptr;
532 if (ctf_type_encoding (fp
, tid
, &cet
))
534 complaint (_("ctf_type_encoding read_base_type failed - %s"),
535 ctf_errmsg (ctf_errno (fp
)));
539 name
= ctf_type_name_raw (fp
, tid
);
540 if (name
== nullptr || strlen (name
) == 0)
542 name
= ctf_type_aname (fp
, tid
);
544 complaint (_("ctf_type_aname read_base_type failed - %s"),
545 ctf_errmsg (ctf_errno (fp
)));
548 kind
= ctf_type_kind (fp
, tid
);
549 if (kind
== CTF_K_INTEGER
)
551 uint32_t issigned
, ischar
, isbool
;
552 struct gdbarch
*gdbarch
= of
->arch ();
554 issigned
= cet
.cte_format
& CTF_INT_SIGNED
;
555 ischar
= cet
.cte_format
& CTF_INT_CHAR
;
556 isbool
= cet
.cte_format
& CTF_INT_BOOL
;
558 type
= init_character_type (of
, TARGET_CHAR_BIT
, !issigned
, name
);
560 type
= init_boolean_type (of
, gdbarch_int_bit (gdbarch
),
565 if (cet
.cte_bits
&& ((cet
.cte_bits
% TARGET_CHAR_BIT
) == 0))
568 bits
= gdbarch_int_bit (gdbarch
);
569 type
= init_integer_type (of
, bits
, !issigned
, name
);
572 else if (kind
== CTF_K_FLOAT
)
575 isflt
= !((cet
.cte_format
& CTF_FP_IMAGRY
) == CTF_FP_IMAGRY
576 || (cet
.cte_format
& CTF_FP_DIMAGRY
) == CTF_FP_DIMAGRY
577 || (cet
.cte_format
& CTF_FP_LDIMAGRY
) == CTF_FP_LDIMAGRY
);
579 type
= ctf_init_float_type (of
, cet
.cte_bits
, name
, name
);
583 = ctf_init_float_type (of
, cet
.cte_bits
/ 2, NULL
, name
);
584 type
= init_complex_type (name
, t
);
589 complaint (_("read_base_type: unsupported base kind (%d)"), kind
);
590 type
= init_type (of
, TYPE_CODE_ERROR
, cet
.cte_bits
, name
);
593 if (name
!= nullptr && strcmp (name
, "char") == 0)
594 type
->set_has_no_signedness (true);
596 return set_tid_type (of
, tid
, type
);
600 process_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
604 type
= read_base_type (ccp
, tid
);
605 new_symbol (ccp
, type
, tid
);
608 /* Start a structure or union scope (definition) with TID to create a type
609 for the structure or union.
611 Fill in the type's name and general properties. The members will not be
612 processed, nor a symbol table entry be done until process_structure_type
613 (assuming the type has a name). */
616 read_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
618 struct objfile
*of
= ccp
->of
;
619 ctf_dict_t
*fp
= ccp
->fp
;
623 type
= alloc_type (of
);
625 const char *name
= ctf_type_name_raw (fp
, tid
);
626 if (name
!= nullptr && strlen (name
) != 0)
627 type
->set_name (name
);
629 kind
= ctf_type_kind (fp
, tid
);
630 if (kind
== CTF_K_UNION
)
631 type
->set_code (TYPE_CODE_UNION
);
633 type
->set_code (TYPE_CODE_STRUCT
);
635 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
636 set_type_align (type
, ctf_type_align (fp
, tid
));
638 return set_tid_type (ccp
->of
, tid
, type
);
641 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
642 and create the symbol for it. */
645 process_struct_members (struct ctf_context
*ccp
,
649 struct ctf_field_info fi
;
651 fi
.cur_context
= ccp
;
652 if (ctf_member_iter (ccp
->fp
, tid
, ctf_add_member_cb
, &fi
) == CTF_ERR
)
653 complaint (_("ctf_member_iter process_struct_members failed - %s"),
654 ctf_errmsg (ctf_errno (ccp
->fp
)));
656 /* Attach fields to the type. */
657 attach_fields_to_type (&fi
, type
);
659 new_symbol (ccp
, type
, tid
);
663 process_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
667 type
= read_structure_type (ccp
, tid
);
668 process_struct_members (ccp
, tid
, type
);
671 /* Create a function type for TID and set its return type. */
674 read_func_kind_type (struct ctf_context
*ccp
, ctf_id_t tid
)
676 struct objfile
*of
= ccp
->of
;
677 ctf_dict_t
*fp
= ccp
->fp
;
678 struct type
*type
, *rettype
, *atype
;
682 type
= alloc_type (of
);
684 type
->set_code (TYPE_CODE_FUNC
);
685 ctf_func_type_info (fp
, tid
, &cfi
);
686 rettype
= fetch_tid_type (ccp
, cfi
.ctc_return
);
687 TYPE_TARGET_TYPE (type
) = rettype
;
688 set_type_align (type
, ctf_type_align (fp
, tid
));
690 /* Set up function's arguments. */
692 type
->set_num_fields (argc
);
693 if ((cfi
.ctc_flags
& CTF_FUNC_VARARG
) != 0)
694 type
->set_has_varargs (true);
698 std::vector
<ctf_id_t
> argv (argc
);
699 if (ctf_func_type_args (fp
, tid
, argc
, argv
.data ()) == CTF_ERR
)
703 ((struct field
*) TYPE_ZALLOC (type
, argc
* sizeof (struct field
)));
704 struct type
*void_type
= objfile_type (of
)->builtin_void
;
705 /* If failed to find the argument type, fill it with void_type. */
706 for (int iparam
= 0; iparam
< argc
; iparam
++)
708 atype
= get_tid_type (of
, argv
[iparam
]);
709 if (atype
!= nullptr)
710 type
->field (iparam
).set_type (atype
);
712 type
->field (iparam
).set_type (void_type
);
716 return set_tid_type (of
, tid
, type
);
719 /* Given a TID of CTF_K_ENUM, process all the members of the
720 enumeration, and create the symbol for the enumeration type. */
723 read_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
725 struct objfile
*of
= ccp
->of
;
726 ctf_dict_t
*fp
= ccp
->fp
;
727 struct type
*type
, *target_type
;
730 type
= alloc_type (of
);
732 const char *name
= ctf_type_name_raw (fp
, tid
);
733 if (name
!= nullptr && strlen (name
) != 0)
734 type
->set_name (name
);
736 type
->set_code (TYPE_CODE_ENUM
);
737 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
738 ctf_func_type_info (fp
, tid
, &fi
);
739 target_type
= get_tid_type (of
, fi
.ctc_return
);
740 TYPE_TARGET_TYPE (type
) = target_type
;
741 set_type_align (type
, ctf_type_align (fp
, tid
));
743 return set_tid_type (of
, tid
, type
);
747 process_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
750 struct ctf_field_info fi
;
752 type
= read_enum_type (ccp
, tid
);
754 fi
.cur_context
= ccp
;
756 if (ctf_enum_iter (ccp
->fp
, tid
, ctf_add_enum_member_cb
, &fi
) == CTF_ERR
)
757 complaint (_("ctf_enum_iter process_enum_type failed - %s"),
758 ctf_errmsg (ctf_errno (ccp
->fp
)));
760 /* Attach fields to the type. */
761 attach_fields_to_type (&fi
, type
);
763 new_symbol (ccp
, type
, tid
);
766 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */
769 add_array_cv_type (struct ctf_context
*ccp
,
771 struct type
*base_type
,
775 struct type
*el_type
, *inner_array
;
777 base_type
= copy_type (base_type
);
778 inner_array
= base_type
;
780 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
782 TYPE_TARGET_TYPE (inner_array
)
783 = copy_type (TYPE_TARGET_TYPE (inner_array
));
784 inner_array
= TYPE_TARGET_TYPE (inner_array
);
787 el_type
= TYPE_TARGET_TYPE (inner_array
);
788 cnst
|= TYPE_CONST (el_type
);
789 voltl
|= TYPE_VOLATILE (el_type
);
790 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, nullptr);
792 return set_tid_type (ccp
->of
, tid
, base_type
);
795 /* Read all information from a TID of CTF_K_ARRAY. */
798 read_array_type (struct ctf_context
*ccp
, ctf_id_t tid
)
800 struct objfile
*objfile
= ccp
->of
;
801 ctf_dict_t
*fp
= ccp
->fp
;
802 struct type
*element_type
, *range_type
, *idx_type
;
806 if (ctf_array_info (fp
, tid
, &ar
) == CTF_ERR
)
808 complaint (_("ctf_array_info read_array_type failed - %s"),
809 ctf_errmsg (ctf_errno (fp
)));
813 element_type
= fetch_tid_type (ccp
, ar
.ctr_contents
);
814 if (element_type
== nullptr)
817 idx_type
= fetch_tid_type (ccp
, ar
.ctr_index
);
818 if (idx_type
== nullptr)
819 idx_type
= objfile_type (objfile
)->builtin_int
;
821 range_type
= create_static_range_type (NULL
, idx_type
, 0, ar
.ctr_nelems
- 1);
822 type
= create_array_type (NULL
, element_type
, range_type
);
823 if (ar
.ctr_nelems
<= 1) /* Check if undefined upper bound. */
825 range_type
->bounds ()->high
.set_undefined ();
826 TYPE_LENGTH (type
) = 0;
827 type
->set_target_is_stub (true);
830 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
832 set_type_align (type
, ctf_type_align (fp
, tid
));
834 return set_tid_type (objfile
, tid
, type
);
837 /* Read TID of kind CTF_K_CONST with base type BTID. */
840 read_const_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
842 struct objfile
*objfile
= ccp
->of
;
843 struct type
*base_type
, *cv_type
;
845 base_type
= fetch_tid_type (ccp
, btid
);
846 if (base_type
== nullptr)
848 base_type
= read_type_record (ccp
, btid
);
849 if (base_type
== nullptr)
851 complaint (_("read_const_type: NULL base type (%ld)"), btid
);
852 base_type
= objfile_type (objfile
)->builtin_error
;
855 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
857 return set_tid_type (objfile
, tid
, cv_type
);
860 /* Read TID of kind CTF_K_VOLATILE with base type BTID. */
863 read_volatile_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
865 struct objfile
*objfile
= ccp
->of
;
866 ctf_dict_t
*fp
= ccp
->fp
;
867 struct type
*base_type
, *cv_type
;
869 base_type
= fetch_tid_type (ccp
, btid
);
870 if (base_type
== nullptr)
872 base_type
= read_type_record (ccp
, btid
);
873 if (base_type
== nullptr)
875 complaint (_("read_volatile_type: NULL base type (%ld)"), btid
);
876 base_type
= objfile_type (objfile
)->builtin_error
;
880 if (ctf_type_kind (fp
, btid
) == CTF_K_ARRAY
)
881 return add_array_cv_type (ccp
, tid
, base_type
, 0, 1);
882 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
884 return set_tid_type (objfile
, tid
, cv_type
);
887 /* Read TID of kind CTF_K_RESTRICT with base type BTID. */
890 read_restrict_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
892 struct objfile
*objfile
= ccp
->of
;
893 struct type
*base_type
, *cv_type
;
895 base_type
= fetch_tid_type (ccp
, btid
);
896 if (base_type
== nullptr)
898 base_type
= read_type_record (ccp
, btid
);
899 if (base_type
== nullptr)
901 complaint (_("read_restrict_type: NULL base type (%ld)"), btid
);
902 base_type
= objfile_type (objfile
)->builtin_error
;
905 cv_type
= make_restrict_type (base_type
);
907 return set_tid_type (objfile
, tid
, cv_type
);
910 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */
913 read_typedef_type (struct ctf_context
*ccp
, ctf_id_t tid
,
914 ctf_id_t btid
, const char *name
)
916 struct objfile
*objfile
= ccp
->of
;
917 struct type
*this_type
, *target_type
;
919 char *aname
= obstack_strdup (&objfile
->objfile_obstack
, name
);
920 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, aname
);
921 set_tid_type (objfile
, tid
, this_type
);
922 target_type
= fetch_tid_type (ccp
, btid
);
923 if (target_type
!= this_type
)
924 TYPE_TARGET_TYPE (this_type
) = target_type
;
926 TYPE_TARGET_TYPE (this_type
) = nullptr;
928 this_type
->set_target_is_stub (TYPE_TARGET_TYPE (this_type
) != nullptr);
930 return set_tid_type (objfile
, tid
, this_type
);
933 /* Read TID of kind CTF_K_POINTER with base type BTID. */
936 read_pointer_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
938 struct objfile
*of
= ccp
->of
;
939 struct type
*target_type
, *type
;
941 target_type
= fetch_tid_type (ccp
, btid
);
942 if (target_type
== nullptr)
944 target_type
= read_type_record (ccp
, btid
);
945 if (target_type
== nullptr)
947 complaint (_("read_pointer_type: NULL target type (%ld)"), btid
);
948 target_type
= objfile_type (ccp
->of
)->builtin_error
;
952 type
= lookup_pointer_type (target_type
);
953 set_type_align (type
, ctf_type_align (ccp
->fp
, tid
));
955 return set_tid_type (of
, tid
, type
);
958 /* Read information from a TID of CTF_K_FORWARD. */
961 read_forward_type (struct ctf_context
*ccp
, ctf_id_t tid
)
963 struct objfile
*of
= ccp
->of
;
964 ctf_dict_t
*fp
= ccp
->fp
;
968 type
= alloc_type (of
);
970 const char *name
= ctf_type_name_raw (fp
, tid
);
971 if (name
!= nullptr && strlen (name
) != 0)
972 type
->set_name (name
);
974 kind
= ctf_type_kind_forwarded (fp
, tid
);
975 if (kind
== CTF_K_UNION
)
976 type
->set_code (TYPE_CODE_UNION
);
978 type
->set_code (TYPE_CODE_STRUCT
);
980 TYPE_LENGTH (type
) = 0;
981 type
->set_is_stub (true);
983 return set_tid_type (of
, tid
, type
);
986 /* Read information associated with type TID. */
989 read_type_record (struct ctf_context
*ccp
, ctf_id_t tid
)
991 ctf_dict_t
*fp
= ccp
->fp
;
993 struct type
*type
= nullptr;
996 kind
= ctf_type_kind (fp
, tid
);
1001 type
= read_structure_type (ccp
, tid
);
1004 type
= read_enum_type (ccp
, tid
);
1006 case CTF_K_FUNCTION
:
1007 type
= read_func_kind_type (ccp
, tid
);
1010 btid
= ctf_type_reference (fp
, tid
);
1011 type
= read_const_type (ccp
, tid
, btid
);
1015 const char *name
= ctf_type_name_raw (fp
, tid
);
1016 btid
= ctf_type_reference (fp
, tid
);
1017 type
= read_typedef_type (ccp
, tid
, btid
, name
);
1020 case CTF_K_VOLATILE
:
1021 btid
= ctf_type_reference (fp
, tid
);
1022 type
= read_volatile_type (ccp
, tid
, btid
);
1024 case CTF_K_RESTRICT
:
1025 btid
= ctf_type_reference (fp
, tid
);
1026 type
= read_restrict_type (ccp
, tid
, btid
);
1029 btid
= ctf_type_reference (fp
, tid
);
1030 type
= read_pointer_type (ccp
, tid
, btid
);
1034 type
= read_base_type (ccp
, tid
);
1037 type
= read_array_type (ccp
, tid
);
1040 type
= read_forward_type (ccp
, tid
);
1051 /* Callback to add type TID to the symbol table. */
1054 ctf_add_type_cb (ctf_id_t tid
, void *arg
)
1056 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1060 /* Check if tid's type has already been defined. */
1061 type
= get_tid_type (ccp
->of
, tid
);
1062 if (type
!= nullptr)
1065 ctf_id_t btid
= ctf_type_reference (ccp
->fp
, tid
);
1066 kind
= ctf_type_kind (ccp
->fp
, tid
);
1071 process_structure_type (ccp
, tid
);
1074 process_enum_type (ccp
, tid
);
1076 case CTF_K_FUNCTION
:
1077 type
= read_func_kind_type (ccp
, tid
);
1078 new_symbol (ccp
, type
, tid
);
1082 process_base_type (ccp
, tid
);
1085 new_symbol (ccp
, read_type_record (ccp
, tid
), tid
);
1088 type
= read_const_type (ccp
, tid
, btid
);
1089 new_symbol (ccp
, type
, tid
);
1091 case CTF_K_VOLATILE
:
1092 type
= read_volatile_type (ccp
, tid
, btid
);
1093 new_symbol (ccp
, type
, tid
);
1095 case CTF_K_RESTRICT
:
1096 type
= read_restrict_type (ccp
, tid
, btid
);
1097 new_symbol (ccp
, type
, tid
);
1100 type
= read_pointer_type (ccp
, tid
, btid
);
1101 new_symbol (ccp
, type
, tid
);
1104 type
= read_array_type (ccp
, tid
);
1105 new_symbol (ccp
, type
, tid
);
1116 /* Callback to add variable NAME with TID to the symbol table. */
1119 ctf_add_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1121 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1122 struct symbol
*sym
= nullptr;
1126 type
= get_tid_type (ccp
->of
, id
);
1128 kind
= ctf_type_kind (ccp
->fp
, id
);
1131 case CTF_K_FUNCTION
:
1132 if (name
!= nullptr && strcmp (name
, "main") == 0)
1133 set_objfile_main_name (ccp
->of
, name
, language_c
);
1137 case CTF_K_VOLATILE
:
1138 case CTF_K_RESTRICT
:
1145 sym
= new_symbol (ccp
, type
, id
);
1146 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1152 if (type
== nullptr)
1154 complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name
, id
);
1155 type
= objfile_type (ccp
->of
)->builtin_error
;
1157 sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
1158 OBJSTAT (ccp
->of
, n_syms
++);
1159 SYMBOL_TYPE (sym
) = type
;
1160 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1161 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
1162 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1163 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
1166 complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind
);
1171 set_symbol_address (ccp
->of
, sym
, name
);
1176 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table. */
1178 static struct symbol
*
1179 add_stt_obj (struct ctf_context
*ccp
, unsigned long idx
)
1185 if ((tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
)) == CTF_ERR
)
1188 type
= fetch_tid_type (ccp
, tid
);
1189 if (type
== nullptr)
1192 sym
= new_symbol (ccp
, type
, tid
);
1197 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table. */
1199 static struct symbol
*
1200 add_stt_func (struct ctf_context
*ccp
, unsigned long idx
)
1202 struct type
*ftype
, *atyp
, *rettyp
;
1204 ctf_funcinfo_t finfo
;
1208 struct type
*void_type
= objfile_type (ccp
->of
)->builtin_void
;
1210 if (ctf_func_info (ccp
->fp
, idx
, &finfo
) == CTF_ERR
)
1213 argc
= finfo
.ctc_argc
;
1214 if (ctf_func_args (ccp
->fp
, idx
, argc
, argv
) == CTF_ERR
)
1217 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, idx
));
1218 if (name
== nullptr)
1221 tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
);
1222 ftype
= fetch_tid_type (ccp
, tid
);
1223 if ((finfo
.ctc_flags
& CTF_FUNC_VARARG
) != 0)
1224 ftype
->set_has_varargs (true);
1225 ftype
->set_num_fields (argc
);
1227 /* If argc is 0, it has a "void" type. */
1230 ((struct field
*) TYPE_ZALLOC (ftype
, argc
* sizeof (struct field
)));
1232 /* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed
1233 to find the argument type. */
1234 for (int iparam
= 0; iparam
< argc
; iparam
++)
1236 atyp
= fetch_tid_type (ccp
, argv
[iparam
]);
1238 ftype
->field (iparam
).set_type (atyp
);
1240 ftype
->field (iparam
).set_type (void_type
);
1243 sym
= new_symbol (ccp
, ftype
, tid
);
1244 rettyp
= fetch_tid_type (ccp
, finfo
.ctc_return
);
1245 if (rettyp
!= nullptr)
1246 SYMBOL_TYPE (sym
) = rettyp
;
1248 SYMBOL_TYPE (sym
) = void_type
;
1253 /* Get text segment base for OBJFILE, TSIZE contains the segment size. */
1256 get_objfile_text_range (struct objfile
*of
, int *tsize
)
1258 bfd
*abfd
= of
->obfd
;
1259 const asection
*codes
;
1261 codes
= bfd_get_section_by_name (abfd
, ".text");
1262 *tsize
= codes
? bfd_section_size (codes
) : 0;
1263 return of
->text_section_offset ();
1266 /* Start a symtab for OBJFILE in CTF format. */
1269 ctf_start_symtab (ctf_psymtab
*pst
,
1270 struct objfile
*of
, CORE_ADDR text_offset
)
1272 struct ctf_context
*ccp
;
1275 ccp
->builder
= new buildsym_compunit
1276 (of
, of
->original_name
, nullptr,
1277 language_c
, text_offset
);
1278 ccp
->builder
->record_debugformat ("ctf");
1281 /* Finish reading symbol/type definitions in CTF format.
1282 END_ADDR is the end address of the file's text. SECTION is
1283 the .text section number. */
1285 static struct compunit_symtab
*
1286 ctf_end_symtab (ctf_psymtab
*pst
,
1287 CORE_ADDR end_addr
, int section
)
1289 struct ctf_context
*ccp
;
1292 struct compunit_symtab
*result
1293 = ccp
->builder
->end_symtab (end_addr
, section
);
1294 delete ccp
->builder
;
1295 ccp
->builder
= nullptr;
1299 /* Add all members of an enum with type TID to partial symbol table. */
1302 ctf_psymtab_add_enums (struct ctf_context
*ccp
, ctf_id_t tid
)
1306 ctf_next_t
*i
= nullptr;
1308 while ((ename
= ctf_enum_next (ccp
->fp
, tid
, &i
, &val
)) != nullptr)
1310 ccp
->pst
->add_psymbol (ename
, true,
1311 VAR_DOMAIN
, LOC_CONST
, -1,
1312 psymbol_placement::GLOBAL
,
1313 0, language_c
, ccp
->partial_symtabs
, ccp
->of
);
1315 if (ctf_errno (ccp
->fp
) != ECTF_NEXT_END
)
1316 complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1317 ctf_errmsg (ctf_errno (ccp
->fp
)));
1320 /* Read in full symbols for PST, and anything it depends on. */
1323 ctf_psymtab::expand_psymtab (struct objfile
*objfile
)
1326 struct ctf_context
*ccp
;
1328 gdb_assert (!readin
);
1332 /* Iterate over entries in data types section. */
1333 if (ctf_type_iter (ccp
->fp
, ctf_add_type_cb
, ccp
) == CTF_ERR
)
1334 complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1335 ctf_errmsg (ctf_errno (ccp
->fp
)));
1338 /* Iterate over entries in variable info section. */
1339 if (ctf_variable_iter (ccp
->fp
, ctf_add_var_cb
, ccp
) == CTF_ERR
)
1340 complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1341 ctf_errmsg (ctf_errno (ccp
->fp
)));
1343 /* Add entries in data objects and function info sections. */
1344 for (unsigned long i
= 0; ; i
++)
1346 sym
= add_stt_obj (ccp
, i
);
1349 if (ctf_errno (ccp
->fp
) == EINVAL
1350 || ctf_errno (ccp
->fp
) == ECTF_NOSYMTAB
)
1352 sym
= add_stt_func (ccp
, i
);
1357 set_symbol_address (ccp
->of
, sym
, sym
->linkage_name ());
1363 /* Expand partial symbol table PST into a full symbol table.
1367 ctf_psymtab::read_symtab (struct objfile
*objfile
)
1370 warning (_("bug: psymtab for %s is already read in."), filename
);
1375 printf_filtered (_("Reading in CTF data for %s..."), filename
);
1376 gdb_flush (gdb_stdout
);
1379 /* Start a symtab. */
1380 CORE_ADDR offset
; /* Start of text segment. */
1383 offset
= get_objfile_text_range (objfile
, &tsize
);
1384 ctf_start_symtab (this, objfile
, offset
);
1385 expand_psymtab (objfile
);
1387 set_text_low (offset
);
1388 set_text_high (offset
+ tsize
);
1389 compunit_symtab
= ctf_end_symtab (this, offset
+ tsize
,
1390 SECT_OFF_TEXT (objfile
));
1392 /* Finish up the debug error message. */
1394 printf_filtered (_("done.\n"));
1398 /* Allocate a new partial_symtab NAME.
1400 Each source file that has not been fully read in is represented by
1401 a partial_symtab. This contains the information on where in the
1402 executable the debugging symbols for a specific file are, and a
1403 list of names of global symbols which are located in this file.
1404 They are all chained on partial symtab lists.
1406 Even after the source file has been read into a symtab, the
1407 partial_symtab remains around. They are allocated on an obstack,
1410 static ctf_psymtab
*
1411 create_partial_symtab (const char *name
,
1413 psymtab_storage
*partial_symtabs
,
1414 struct objfile
*objfile
)
1417 struct ctf_context
*ccx
;
1419 pst
= new ctf_psymtab (name
, partial_symtabs
, objfile
->per_bfd
, 0);
1421 ccx
= XOBNEW (&objfile
->objfile_obstack
, struct ctf_context
);
1424 ccx
->partial_symtabs
= partial_symtabs
;
1426 ccx
->builder
= nullptr;
1432 /* Callback to add type TID to partial symbol table. */
1435 ctf_psymtab_type_cb (ctf_id_t tid
, void *arg
)
1437 struct ctf_context
*ccp
;
1441 ccp
= (struct ctf_context
*) arg
;
1443 domain_enum domain
= UNDEF_DOMAIN
;
1444 enum address_class aclass
= LOC_UNDEF
;
1445 kind
= ctf_type_kind (ccp
->fp
, tid
);
1449 ctf_psymtab_add_enums (ccp
, tid
);
1453 domain
= STRUCT_DOMAIN
;
1454 aclass
= LOC_TYPEDEF
;
1456 case CTF_K_FUNCTION
:
1458 domain
= VAR_DOMAIN
;
1459 aclass
= LOC_STATIC
;
1460 section
= SECT_OFF_TEXT (ccp
->of
);
1463 domain
= VAR_DOMAIN
;
1464 aclass
= LOC_STATIC
;
1468 case CTF_K_VOLATILE
:
1469 case CTF_K_RESTRICT
:
1470 domain
= VAR_DOMAIN
;
1471 aclass
= LOC_TYPEDEF
;
1475 domain
= VAR_DOMAIN
;
1476 aclass
= LOC_TYPEDEF
;
1483 const char *name
= ctf_type_name_raw (ccp
->fp
, tid
);
1484 if (name
== nullptr || strlen (name
) == 0)
1487 ccp
->pst
->add_psymbol (name
, false,
1488 domain
, aclass
, section
,
1489 psymbol_placement::GLOBAL
,
1490 0, language_c
, ccp
->partial_symtabs
, ccp
->of
);
1495 /* Callback to add variable NAME with ID to partial symbol table. */
1498 ctf_psymtab_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1500 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1502 ccp
->pst
->add_psymbol (name
, true,
1503 VAR_DOMAIN
, LOC_STATIC
, -1,
1504 psymbol_placement::GLOBAL
,
1505 0, language_c
, ccp
->partial_symtabs
, ccp
->of
);
1509 /* Setup partial_symtab's describing each source file for which
1510 debugging information is available. */
1513 scan_partial_symbols (ctf_dict_t
*cfp
, psymtab_storage
*partial_symtabs
,
1516 bfd
*abfd
= of
->obfd
;
1517 const char *name
= bfd_get_filename (abfd
);
1518 ctf_psymtab
*pst
= create_partial_symtab (name
, cfp
, partial_symtabs
, of
);
1520 struct ctf_context
*ccx
= pst
->context
;
1522 if (ctf_type_iter (cfp
, ctf_psymtab_type_cb
, ccx
) == CTF_ERR
)
1523 complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1524 ctf_errmsg (ctf_errno (cfp
)));
1526 if (ctf_variable_iter (cfp
, ctf_psymtab_var_cb
, ccx
) == CTF_ERR
)
1527 complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1528 ctf_errmsg (ctf_errno (cfp
)));
1530 /* Scan CTF object and function sections which correspond to each
1531 STT_FUNC or STT_OBJECT entry in the symbol table,
1532 pick up what init_symtab has done. */
1533 for (unsigned long idx
= 0; ; idx
++)
1536 if ((tid
= ctf_lookup_by_symbol (cfp
, idx
)) == CTF_ERR
)
1538 if (ctf_errno (cfp
) == EINVAL
|| ctf_errno (cfp
) == ECTF_NOSYMTAB
)
1539 break; // Done, reach end of the section.
1543 const char *tname
= ctf_type_name_raw (cfp
, tid
);
1544 uint32_t kind
= ctf_type_kind (cfp
, tid
);
1545 address_class aclass
;
1546 domain_enum tdomain
;
1552 tdomain
= STRUCT_DOMAIN
;
1555 tdomain
= VAR_DOMAIN
;
1559 if (kind
== CTF_K_FUNCTION
)
1560 aclass
= LOC_STATIC
;
1561 else if (kind
== CTF_K_CONST
)
1564 aclass
= LOC_TYPEDEF
;
1566 pst
->add_psymbol (tname
, false,
1567 tdomain
, aclass
, -1,
1568 psymbol_placement::STATIC
,
1569 0, language_c
, partial_symtabs
, of
);
1575 /* Read CTF debugging information from a BFD section. This is
1576 called from elfread.c. It does a quick pass through the
1577 .ctf section to set up the partial symbol table. */
1580 elfctf_build_psymtabs (struct objfile
*of
)
1582 bfd
*abfd
= of
->obfd
;
1585 ctf_archive_t
*arc
= ctf_bfdopen (abfd
, &err
);
1587 error (_("ctf_bfdopen failed on %s - %s"),
1588 bfd_get_filename (abfd
), ctf_errmsg (err
));
1590 ctf_dict_t
*fp
= ctf_dict_open (arc
, NULL
, &err
);
1592 error (_("ctf_dict_open failed on %s - %s"),
1593 bfd_get_filename (abfd
), ctf_errmsg (err
));
1594 ctf_dict_key
.emplace (of
, fp
);
1596 psymbol_functions
*psf
= new psymbol_functions ();
1597 psymtab_storage
*partial_symtabs
= psf
->get_partial_symtabs ().get ();
1598 of
->qf
.emplace_front (psf
);
1599 scan_partial_symbols (fp
, partial_symtabs
, of
);
1605 elfctf_build_psymtabs (struct objfile
*of
)
1607 /* Nothing to do if CTF is disabled. */
1610 #endif /* ENABLE_LIBCTF */