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 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_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
.get (), true, 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
;
492 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
493 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
498 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
499 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
512 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
518 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
519 and create the symbol for it. */
522 read_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
524 struct objfile
*of
= ccp
->of
;
525 ctf_dict_t
*fp
= ccp
->fp
;
527 struct type
*type
= nullptr;
531 if (ctf_type_encoding (fp
, tid
, &cet
))
533 complaint (_("ctf_type_encoding read_base_type failed - %s"),
534 ctf_errmsg (ctf_errno (fp
)));
538 gdb::unique_xmalloc_ptr
<char> copied_name (ctf_type_aname_raw (fp
, tid
));
539 if (copied_name
== nullptr || strlen (copied_name
.get ()) == 0)
541 name
= ctf_type_aname (fp
, tid
);
543 complaint (_("ctf_type_aname read_base_type failed - %s"),
544 ctf_errmsg (ctf_errno (fp
)));
547 name
= obstack_strdup (&of
->objfile_obstack
, copied_name
.get ());
549 kind
= ctf_type_kind (fp
, tid
);
550 if (kind
== CTF_K_INTEGER
)
552 uint32_t issigned
, ischar
, isbool
;
553 struct gdbarch
*gdbarch
= of
->arch ();
555 issigned
= cet
.cte_format
& CTF_INT_SIGNED
;
556 ischar
= cet
.cte_format
& CTF_INT_CHAR
;
557 isbool
= cet
.cte_format
& CTF_INT_BOOL
;
559 type
= init_character_type (of
, TARGET_CHAR_BIT
, !issigned
, name
);
561 type
= init_boolean_type (of
, gdbarch_int_bit (gdbarch
),
566 if (cet
.cte_bits
&& ((cet
.cte_bits
% TARGET_CHAR_BIT
) == 0))
569 bits
= gdbarch_int_bit (gdbarch
);
570 type
= init_integer_type (of
, bits
, !issigned
, name
);
573 else if (kind
== CTF_K_FLOAT
)
576 isflt
= !((cet
.cte_format
& CTF_FP_IMAGRY
) == CTF_FP_IMAGRY
577 || (cet
.cte_format
& CTF_FP_DIMAGRY
) == CTF_FP_DIMAGRY
578 || (cet
.cte_format
& CTF_FP_LDIMAGRY
) == CTF_FP_LDIMAGRY
);
580 type
= ctf_init_float_type (of
, cet
.cte_bits
, name
, name
);
584 = ctf_init_float_type (of
, cet
.cte_bits
/ 2, NULL
, name
);
585 type
= init_complex_type (name
, t
);
590 complaint (_("read_base_type: unsupported base kind (%d)"), kind
);
591 type
= init_type (of
, TYPE_CODE_ERROR
, cet
.cte_bits
, name
);
594 if (name
!= nullptr && strcmp (name
, "char") == 0)
595 type
->set_has_no_signedness (true);
597 return set_tid_type (of
, tid
, type
);
601 process_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
605 type
= read_base_type (ccp
, tid
);
606 new_symbol (ccp
, type
, tid
);
609 /* Start a structure or union scope (definition) with TID to create a type
610 for the structure or union.
612 Fill in the type's name and general properties. The members will not be
613 processed, nor a symbol table entry be done until process_structure_type
614 (assuming the type has a name). */
617 read_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
619 struct objfile
*of
= ccp
->of
;
620 ctf_dict_t
*fp
= ccp
->fp
;
624 type
= alloc_type (of
);
626 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
627 if (name
!= nullptr && strlen (name
.get ()) != 0)
628 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
630 kind
= ctf_type_kind (fp
, tid
);
631 if (kind
== CTF_K_UNION
)
632 type
->set_code (TYPE_CODE_UNION
);
634 type
->set_code (TYPE_CODE_STRUCT
);
636 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
637 set_type_align (type
, ctf_type_align (fp
, tid
));
639 return set_tid_type (ccp
->of
, tid
, type
);
642 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
643 and create the symbol for it. */
646 process_struct_members (struct ctf_context
*ccp
,
650 struct ctf_field_info fi
;
652 fi
.cur_context
= ccp
;
653 if (ctf_member_iter (ccp
->fp
, tid
, ctf_add_member_cb
, &fi
) == CTF_ERR
)
654 complaint (_("ctf_member_iter process_struct_members failed - %s"),
655 ctf_errmsg (ctf_errno (ccp
->fp
)));
657 /* Attach fields to the type. */
658 attach_fields_to_type (&fi
, type
);
660 new_symbol (ccp
, type
, tid
);
664 process_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
668 type
= read_structure_type (ccp
, tid
);
669 process_struct_members (ccp
, tid
, type
);
672 /* Create a function type for TID and set its return type. */
675 read_func_kind_type (struct ctf_context
*ccp
, ctf_id_t tid
)
677 struct objfile
*of
= ccp
->of
;
678 ctf_dict_t
*fp
= ccp
->fp
;
679 struct type
*type
, *rettype
, *atype
;
683 type
= alloc_type (of
);
685 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
686 if (name
!= nullptr && strlen (name
.get ()) != 0)
687 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
689 type
->set_code (TYPE_CODE_FUNC
);
690 ctf_func_type_info (fp
, tid
, &cfi
);
691 rettype
= fetch_tid_type (ccp
, cfi
.ctc_return
);
692 TYPE_TARGET_TYPE (type
) = rettype
;
693 set_type_align (type
, ctf_type_align (fp
, tid
));
695 /* Set up function's arguments. */
697 type
->set_num_fields (argc
);
698 if ((cfi
.ctc_flags
& CTF_FUNC_VARARG
) != 0)
699 type
->set_has_varargs (true);
703 std::vector
<ctf_id_t
> argv (argc
);
704 if (ctf_func_type_args (fp
, tid
, argc
, argv
.data ()) == CTF_ERR
)
708 ((struct field
*) TYPE_ZALLOC (type
, argc
* sizeof (struct field
)));
709 struct type
*void_type
= objfile_type (of
)->builtin_void
;
710 /* If failed to find the argument type, fill it with void_type. */
711 for (int iparam
= 0; iparam
< argc
; iparam
++)
713 atype
= get_tid_type (of
, argv
[iparam
]);
714 if (atype
!= nullptr)
715 type
->field (iparam
).set_type (atype
);
717 type
->field (iparam
).set_type (void_type
);
721 return set_tid_type (of
, tid
, type
);
724 /* Given a TID of CTF_K_ENUM, process all the members of the
725 enumeration, and create the symbol for the enumeration type. */
728 read_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
730 struct objfile
*of
= ccp
->of
;
731 ctf_dict_t
*fp
= ccp
->fp
;
732 struct type
*type
, *target_type
;
735 type
= alloc_type (of
);
737 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
738 if (name
!= nullptr && strlen (name
.get ()) != 0)
739 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
741 type
->set_code (TYPE_CODE_ENUM
);
742 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
743 ctf_func_type_info (fp
, tid
, &fi
);
744 target_type
= get_tid_type (of
, fi
.ctc_return
);
745 TYPE_TARGET_TYPE (type
) = target_type
;
746 set_type_align (type
, ctf_type_align (fp
, tid
));
748 return set_tid_type (of
, tid
, type
);
752 process_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
755 struct ctf_field_info fi
;
757 type
= read_enum_type (ccp
, tid
);
759 fi
.cur_context
= ccp
;
761 if (ctf_enum_iter (ccp
->fp
, tid
, ctf_add_enum_member_cb
, &fi
) == CTF_ERR
)
762 complaint (_("ctf_enum_iter process_enum_type failed - %s"),
763 ctf_errmsg (ctf_errno (ccp
->fp
)));
765 /* Attach fields to the type. */
766 attach_fields_to_type (&fi
, type
);
768 new_symbol (ccp
, type
, tid
);
771 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */
774 add_array_cv_type (struct ctf_context
*ccp
,
776 struct type
*base_type
,
780 struct type
*el_type
, *inner_array
;
782 base_type
= copy_type (base_type
);
783 inner_array
= base_type
;
785 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
787 TYPE_TARGET_TYPE (inner_array
)
788 = copy_type (TYPE_TARGET_TYPE (inner_array
));
789 inner_array
= TYPE_TARGET_TYPE (inner_array
);
792 el_type
= TYPE_TARGET_TYPE (inner_array
);
793 cnst
|= TYPE_CONST (el_type
);
794 voltl
|= TYPE_VOLATILE (el_type
);
795 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, nullptr);
797 return set_tid_type (ccp
->of
, tid
, base_type
);
800 /* Read all information from a TID of CTF_K_ARRAY. */
803 read_array_type (struct ctf_context
*ccp
, ctf_id_t tid
)
805 struct objfile
*objfile
= ccp
->of
;
806 ctf_dict_t
*fp
= ccp
->fp
;
807 struct type
*element_type
, *range_type
, *idx_type
;
811 if (ctf_array_info (fp
, tid
, &ar
) == CTF_ERR
)
813 complaint (_("ctf_array_info read_array_type failed - %s"),
814 ctf_errmsg (ctf_errno (fp
)));
818 element_type
= fetch_tid_type (ccp
, ar
.ctr_contents
);
819 if (element_type
== nullptr)
822 idx_type
= fetch_tid_type (ccp
, ar
.ctr_index
);
823 if (idx_type
== nullptr)
824 idx_type
= objfile_type (objfile
)->builtin_int
;
826 range_type
= create_static_range_type (NULL
, idx_type
, 0, ar
.ctr_nelems
- 1);
827 type
= create_array_type (NULL
, element_type
, range_type
);
828 if (ar
.ctr_nelems
<= 1) /* Check if undefined upper bound. */
830 range_type
->bounds ()->high
.set_undefined ();
831 TYPE_LENGTH (type
) = 0;
832 type
->set_target_is_stub (true);
835 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
837 set_type_align (type
, ctf_type_align (fp
, tid
));
839 return set_tid_type (objfile
, tid
, type
);
842 /* Read TID of kind CTF_K_CONST with base type BTID. */
845 read_const_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
847 struct objfile
*objfile
= ccp
->of
;
848 struct type
*base_type
, *cv_type
;
850 base_type
= fetch_tid_type (ccp
, btid
);
851 if (base_type
== nullptr)
853 base_type
= read_type_record (ccp
, btid
);
854 if (base_type
== nullptr)
856 complaint (_("read_const_type: NULL base type (%ld)"), btid
);
857 base_type
= objfile_type (objfile
)->builtin_error
;
860 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
862 return set_tid_type (objfile
, tid
, cv_type
);
865 /* Read TID of kind CTF_K_VOLATILE with base type BTID. */
868 read_volatile_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
870 struct objfile
*objfile
= ccp
->of
;
871 ctf_dict_t
*fp
= ccp
->fp
;
872 struct type
*base_type
, *cv_type
;
874 base_type
= fetch_tid_type (ccp
, btid
);
875 if (base_type
== nullptr)
877 base_type
= read_type_record (ccp
, btid
);
878 if (base_type
== nullptr)
880 complaint (_("read_volatile_type: NULL base type (%ld)"), btid
);
881 base_type
= objfile_type (objfile
)->builtin_error
;
885 if (ctf_type_kind (fp
, btid
) == CTF_K_ARRAY
)
886 return add_array_cv_type (ccp
, tid
, base_type
, 0, 1);
887 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
889 return set_tid_type (objfile
, tid
, cv_type
);
892 /* Read TID of kind CTF_K_RESTRICT with base type BTID. */
895 read_restrict_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
897 struct objfile
*objfile
= ccp
->of
;
898 struct type
*base_type
, *cv_type
;
900 base_type
= fetch_tid_type (ccp
, btid
);
901 if (base_type
== nullptr)
903 base_type
= read_type_record (ccp
, btid
);
904 if (base_type
== nullptr)
906 complaint (_("read_restrict_type: NULL base type (%ld)"), btid
);
907 base_type
= objfile_type (objfile
)->builtin_error
;
910 cv_type
= make_restrict_type (base_type
);
912 return set_tid_type (objfile
, tid
, cv_type
);
915 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */
918 read_typedef_type (struct ctf_context
*ccp
, ctf_id_t tid
,
919 ctf_id_t btid
, const char *name
)
921 struct objfile
*objfile
= ccp
->of
;
922 struct type
*this_type
, *target_type
;
924 char *aname
= obstack_strdup (&objfile
->objfile_obstack
, name
);
925 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, aname
);
926 set_tid_type (objfile
, tid
, this_type
);
927 target_type
= fetch_tid_type (ccp
, btid
);
928 if (target_type
!= this_type
)
929 TYPE_TARGET_TYPE (this_type
) = target_type
;
931 TYPE_TARGET_TYPE (this_type
) = nullptr;
933 this_type
->set_target_is_stub (TYPE_TARGET_TYPE (this_type
) != nullptr);
935 return set_tid_type (objfile
, tid
, this_type
);
938 /* Read TID of kind CTF_K_POINTER with base type BTID. */
941 read_pointer_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
943 struct objfile
*of
= ccp
->of
;
944 struct type
*target_type
, *type
;
946 target_type
= fetch_tid_type (ccp
, btid
);
947 if (target_type
== nullptr)
949 target_type
= read_type_record (ccp
, btid
);
950 if (target_type
== nullptr)
952 complaint (_("read_pointer_type: NULL target type (%ld)"), btid
);
953 target_type
= objfile_type (ccp
->of
)->builtin_error
;
957 type
= lookup_pointer_type (target_type
);
958 set_type_align (type
, ctf_type_align (ccp
->fp
, tid
));
960 return set_tid_type (of
, tid
, type
);
963 /* Read information from a TID of CTF_K_FORWARD. */
966 read_forward_type (struct ctf_context
*ccp
, ctf_id_t tid
)
968 struct objfile
*of
= ccp
->of
;
969 ctf_dict_t
*fp
= ccp
->fp
;
973 type
= alloc_type (of
);
975 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
976 if (name
!= NULL
&& strlen (name
.get()) != 0)
977 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
979 kind
= ctf_type_kind_forwarded (fp
, tid
);
980 if (kind
== CTF_K_UNION
)
981 type
->set_code (TYPE_CODE_UNION
);
983 type
->set_code (TYPE_CODE_STRUCT
);
985 TYPE_LENGTH (type
) = 0;
986 type
->set_is_stub (true);
988 return set_tid_type (of
, tid
, type
);
991 /* Read information associated with type TID. */
994 read_type_record (struct ctf_context
*ccp
, ctf_id_t tid
)
996 ctf_dict_t
*fp
= ccp
->fp
;
998 struct type
*type
= nullptr;
1001 kind
= ctf_type_kind (fp
, tid
);
1006 type
= read_structure_type (ccp
, tid
);
1009 type
= read_enum_type (ccp
, tid
);
1011 case CTF_K_FUNCTION
:
1012 type
= read_func_kind_type (ccp
, tid
);
1015 btid
= ctf_type_reference (fp
, tid
);
1016 type
= read_const_type (ccp
, tid
, btid
);
1020 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
1021 btid
= ctf_type_reference (fp
, tid
);
1022 type
= read_typedef_type (ccp
, tid
, btid
, name
.get ());
1025 case CTF_K_VOLATILE
:
1026 btid
= ctf_type_reference (fp
, tid
);
1027 type
= read_volatile_type (ccp
, tid
, btid
);
1029 case CTF_K_RESTRICT
:
1030 btid
= ctf_type_reference (fp
, tid
);
1031 type
= read_restrict_type (ccp
, tid
, btid
);
1034 btid
= ctf_type_reference (fp
, tid
);
1035 type
= read_pointer_type (ccp
, tid
, btid
);
1039 type
= read_base_type (ccp
, tid
);
1042 type
= read_array_type (ccp
, tid
);
1045 type
= read_forward_type (ccp
, tid
);
1056 /* Callback to add type TID to the symbol table. */
1059 ctf_add_type_cb (ctf_id_t tid
, void *arg
)
1061 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1065 /* Check if tid's type has already been defined. */
1066 type
= get_tid_type (ccp
->of
, tid
);
1067 if (type
!= nullptr)
1070 ctf_id_t btid
= ctf_type_reference (ccp
->fp
, tid
);
1071 kind
= ctf_type_kind (ccp
->fp
, tid
);
1076 process_structure_type (ccp
, tid
);
1079 process_enum_type (ccp
, tid
);
1081 case CTF_K_FUNCTION
:
1082 type
= read_func_kind_type (ccp
, tid
);
1083 new_symbol (ccp
, type
, tid
);
1087 process_base_type (ccp
, tid
);
1090 new_symbol (ccp
, read_type_record (ccp
, tid
), tid
);
1093 type
= read_const_type (ccp
, tid
, btid
);
1094 new_symbol (ccp
, type
, tid
);
1096 case CTF_K_VOLATILE
:
1097 type
= read_volatile_type (ccp
, tid
, btid
);
1098 new_symbol (ccp
, type
, tid
);
1100 case CTF_K_RESTRICT
:
1101 type
= read_restrict_type (ccp
, tid
, btid
);
1102 new_symbol (ccp
, type
, tid
);
1105 type
= read_pointer_type (ccp
, tid
, btid
);
1106 new_symbol (ccp
, type
, tid
);
1109 type
= read_array_type (ccp
, tid
);
1110 new_symbol (ccp
, type
, tid
);
1121 /* Callback to add variable NAME with TID to the symbol table. */
1124 ctf_add_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1126 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1127 struct symbol
*sym
= nullptr;
1131 type
= get_tid_type (ccp
->of
, id
);
1133 kind
= ctf_type_kind (ccp
->fp
, id
);
1136 case CTF_K_FUNCTION
:
1137 if (name
!= nullptr && strcmp (name
, "main") == 0)
1138 set_objfile_main_name (ccp
->of
, name
, language_c
);
1142 case CTF_K_VOLATILE
:
1143 case CTF_K_RESTRICT
:
1150 sym
= new_symbol (ccp
, type
, id
);
1151 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1157 if (type
== nullptr)
1159 complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name
, id
);
1160 type
= objfile_type (ccp
->of
)->builtin_error
;
1162 sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
1163 OBJSTAT (ccp
->of
, n_syms
++);
1164 SYMBOL_TYPE (sym
) = type
;
1165 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1166 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
1167 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1168 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
1171 complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind
);
1176 set_symbol_address (ccp
->of
, sym
, name
);
1181 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table. */
1183 static struct symbol
*
1184 add_stt_obj (struct ctf_context
*ccp
, unsigned long idx
)
1190 if ((tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
)) == CTF_ERR
)
1193 type
= fetch_tid_type (ccp
, tid
);
1194 if (type
== nullptr)
1197 sym
= new_symbol (ccp
, type
, tid
);
1202 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table. */
1204 static struct symbol
*
1205 add_stt_func (struct ctf_context
*ccp
, unsigned long idx
)
1207 struct type
*ftype
, *atyp
, *rettyp
;
1209 ctf_funcinfo_t finfo
;
1213 struct type
*void_type
= objfile_type (ccp
->of
)->builtin_void
;
1215 if (ctf_func_info (ccp
->fp
, idx
, &finfo
) == CTF_ERR
)
1218 argc
= finfo
.ctc_argc
;
1219 if (ctf_func_args (ccp
->fp
, idx
, argc
, argv
) == CTF_ERR
)
1222 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, idx
));
1223 if (name
== nullptr)
1226 tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
);
1227 ftype
= fetch_tid_type (ccp
, tid
);
1228 if ((finfo
.ctc_flags
& CTF_FUNC_VARARG
) != 0)
1229 ftype
->set_has_varargs (true);
1230 ftype
->set_num_fields (argc
);
1232 /* If argc is 0, it has a "void" type. */
1235 ((struct field
*) TYPE_ZALLOC (ftype
, argc
* sizeof (struct field
)));
1237 /* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed
1238 to find the argument type. */
1239 for (int iparam
= 0; iparam
< argc
; iparam
++)
1241 atyp
= fetch_tid_type (ccp
, argv
[iparam
]);
1243 ftype
->field (iparam
).set_type (atyp
);
1245 ftype
->field (iparam
).set_type (void_type
);
1248 sym
= new_symbol (ccp
, ftype
, tid
);
1249 rettyp
= fetch_tid_type (ccp
, finfo
.ctc_return
);
1250 if (rettyp
!= nullptr)
1251 SYMBOL_TYPE (sym
) = rettyp
;
1253 SYMBOL_TYPE (sym
) = void_type
;
1258 /* Get text segment base for OBJFILE, TSIZE contains the segment size. */
1261 get_objfile_text_range (struct objfile
*of
, int *tsize
)
1263 bfd
*abfd
= of
->obfd
;
1264 const asection
*codes
;
1266 codes
= bfd_get_section_by_name (abfd
, ".text");
1267 *tsize
= codes
? bfd_section_size (codes
) : 0;
1268 return of
->text_section_offset ();
1271 /* Start a symtab for OBJFILE in CTF format. */
1274 ctf_start_symtab (ctf_psymtab
*pst
,
1275 struct objfile
*of
, CORE_ADDR text_offset
)
1277 struct ctf_context
*ccp
;
1280 ccp
->builder
= new buildsym_compunit
1281 (of
, of
->original_name
, nullptr,
1282 language_c
, text_offset
);
1283 ccp
->builder
->record_debugformat ("ctf");
1286 /* Finish reading symbol/type definitions in CTF format.
1287 END_ADDR is the end address of the file's text. SECTION is
1288 the .text section number. */
1290 static struct compunit_symtab
*
1291 ctf_end_symtab (ctf_psymtab
*pst
,
1292 CORE_ADDR end_addr
, int section
)
1294 struct ctf_context
*ccp
;
1297 struct compunit_symtab
*result
1298 = ccp
->builder
->end_symtab (end_addr
, section
);
1299 delete ccp
->builder
;
1300 ccp
->builder
= nullptr;
1304 /* Add all members of an enum with type TID to partial symbol table. */
1307 ctf_psymtab_add_enums (struct ctf_context
*ccp
, ctf_id_t tid
)
1311 ctf_next_t
*i
= nullptr;
1313 while ((ename
= ctf_enum_next (ccp
->fp
, tid
, &i
, &val
)) != nullptr)
1315 ccp
->pst
->add_psymbol (ename
, true,
1316 VAR_DOMAIN
, LOC_CONST
, -1,
1317 psymbol_placement::GLOBAL
,
1318 0, language_c
, ccp
->partial_symtabs
, ccp
->of
);
1320 if (ctf_errno (ccp
->fp
) != ECTF_NEXT_END
)
1321 complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1322 ctf_errmsg (ctf_errno (ccp
->fp
)));
1325 /* Read in full symbols for PST, and anything it depends on. */
1328 ctf_psymtab::expand_psymtab (struct objfile
*objfile
)
1331 struct ctf_context
*ccp
;
1333 gdb_assert (!readin
);
1337 /* Iterate over entries in data types section. */
1338 if (ctf_type_iter (ccp
->fp
, ctf_add_type_cb
, ccp
) == CTF_ERR
)
1339 complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1340 ctf_errmsg (ctf_errno (ccp
->fp
)));
1343 /* Iterate over entries in variable info section. */
1344 if (ctf_variable_iter (ccp
->fp
, ctf_add_var_cb
, ccp
) == CTF_ERR
)
1345 complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1346 ctf_errmsg (ctf_errno (ccp
->fp
)));
1348 /* Add entries in data objects and function info sections. */
1349 for (unsigned long i
= 0; ; i
++)
1351 sym
= add_stt_obj (ccp
, i
);
1354 if (ctf_errno (ccp
->fp
) == EINVAL
1355 || ctf_errno (ccp
->fp
) == ECTF_NOSYMTAB
)
1357 sym
= add_stt_func (ccp
, i
);
1362 set_symbol_address (ccp
->of
, sym
, sym
->linkage_name ());
1368 /* Expand partial symbol table PST into a full symbol table.
1372 ctf_psymtab::read_symtab (struct objfile
*objfile
)
1375 warning (_("bug: psymtab for %s is already read in."), filename
);
1380 printf_filtered (_("Reading in CTF data for %s..."), filename
);
1381 gdb_flush (gdb_stdout
);
1384 /* Start a symtab. */
1385 CORE_ADDR offset
; /* Start of text segment. */
1388 offset
= get_objfile_text_range (objfile
, &tsize
);
1389 ctf_start_symtab (this, objfile
, offset
);
1390 expand_psymtab (objfile
);
1392 set_text_low (offset
);
1393 set_text_high (offset
+ tsize
);
1394 compunit_symtab
= ctf_end_symtab (this, offset
+ tsize
,
1395 SECT_OFF_TEXT (objfile
));
1397 /* Finish up the debug error message. */
1399 printf_filtered (_("done.\n"));
1403 /* Allocate a new partial_symtab NAME.
1405 Each source file that has not been fully read in is represented by
1406 a partial_symtab. This contains the information on where in the
1407 executable the debugging symbols for a specific file are, and a
1408 list of names of global symbols which are located in this file.
1409 They are all chained on partial symtab lists.
1411 Even after the source file has been read into a symtab, the
1412 partial_symtab remains around. They are allocated on an obstack,
1415 static ctf_psymtab
*
1416 create_partial_symtab (const char *name
,
1418 psymtab_storage
*partial_symtabs
,
1419 struct objfile
*objfile
)
1422 struct ctf_context
*ccx
;
1424 pst
= new ctf_psymtab (name
, partial_symtabs
, objfile
->per_bfd
, 0);
1426 ccx
= XOBNEW (&objfile
->objfile_obstack
, struct ctf_context
);
1429 ccx
->partial_symtabs
= partial_symtabs
;
1431 ccx
->builder
= nullptr;
1437 /* Callback to add type TID to partial symbol table. */
1440 ctf_psymtab_type_cb (ctf_id_t tid
, void *arg
)
1442 struct ctf_context
*ccp
;
1446 ccp
= (struct ctf_context
*) arg
;
1447 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, tid
));
1449 domain_enum domain
= UNDEF_DOMAIN
;
1450 enum address_class aclass
= LOC_UNDEF
;
1451 kind
= ctf_type_kind (ccp
->fp
, tid
);
1455 ctf_psymtab_add_enums (ccp
, tid
);
1459 domain
= STRUCT_DOMAIN
;
1460 aclass
= LOC_TYPEDEF
;
1462 case CTF_K_FUNCTION
:
1464 domain
= VAR_DOMAIN
;
1465 aclass
= LOC_STATIC
;
1466 section
= SECT_OFF_TEXT (ccp
->of
);
1469 domain
= VAR_DOMAIN
;
1470 aclass
= LOC_STATIC
;
1474 case CTF_K_VOLATILE
:
1475 case CTF_K_RESTRICT
:
1476 domain
= VAR_DOMAIN
;
1477 aclass
= LOC_TYPEDEF
;
1481 domain
= VAR_DOMAIN
;
1482 aclass
= LOC_TYPEDEF
;
1489 if (name
== nullptr || strlen (name
.get ()) == 0)
1492 ccp
->pst
->add_psymbol (name
.get (), true,
1493 domain
, aclass
, section
,
1494 psymbol_placement::GLOBAL
,
1495 0, language_c
, ccp
->partial_symtabs
, ccp
->of
);
1500 /* Callback to add variable NAME with ID to partial symbol table. */
1503 ctf_psymtab_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1505 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1507 ccp
->pst
->add_psymbol (name
, true,
1508 VAR_DOMAIN
, LOC_STATIC
, -1,
1509 psymbol_placement::GLOBAL
,
1510 0, language_c
, ccp
->partial_symtabs
, ccp
->of
);
1514 /* Setup partial_symtab's describing each source file for which
1515 debugging information is available. */
1518 scan_partial_symbols (ctf_dict_t
*cfp
, psymtab_storage
*partial_symtabs
,
1521 bfd
*abfd
= of
->obfd
;
1522 const char *name
= bfd_get_filename (abfd
);
1523 ctf_psymtab
*pst
= create_partial_symtab (name
, cfp
, partial_symtabs
, of
);
1525 struct ctf_context
*ccx
= pst
->context
;
1527 if (ctf_type_iter (cfp
, ctf_psymtab_type_cb
, ccx
) == CTF_ERR
)
1528 complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1529 ctf_errmsg (ctf_errno (cfp
)));
1531 if (ctf_variable_iter (cfp
, ctf_psymtab_var_cb
, ccx
) == CTF_ERR
)
1532 complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1533 ctf_errmsg (ctf_errno (cfp
)));
1535 /* Scan CTF object and function sections which correspond to each
1536 STT_FUNC or STT_OBJECT entry in the symbol table,
1537 pick up what init_symtab has done. */
1538 for (unsigned long idx
= 0; ; idx
++)
1541 if ((tid
= ctf_lookup_by_symbol (cfp
, idx
)) == CTF_ERR
)
1543 if (ctf_errno (cfp
) == EINVAL
|| ctf_errno (cfp
) == ECTF_NOSYMTAB
)
1544 break; // Done, reach end of the section.
1548 gdb::unique_xmalloc_ptr
<char> tname (ctf_type_aname_raw (cfp
, tid
));
1549 uint32_t kind
= ctf_type_kind (cfp
, tid
);
1550 address_class aclass
;
1551 domain_enum tdomain
;
1557 tdomain
= STRUCT_DOMAIN
;
1560 tdomain
= VAR_DOMAIN
;
1564 if (kind
== CTF_K_FUNCTION
)
1565 aclass
= LOC_STATIC
;
1566 else if (kind
== CTF_K_CONST
)
1569 aclass
= LOC_TYPEDEF
;
1571 pst
->add_psymbol (tname
.get (), true,
1572 tdomain
, aclass
, -1,
1573 psymbol_placement::STATIC
,
1574 0, language_c
, partial_symtabs
, of
);
1580 /* Read CTF debugging information from a BFD section. This is
1581 called from elfread.c. It does a quick pass through the
1582 .ctf section to set up the partial symbol table. */
1585 elfctf_build_psymtabs (struct objfile
*of
)
1587 bfd
*abfd
= of
->obfd
;
1590 ctf_archive_t
*arc
= ctf_bfdopen (abfd
, &err
);
1592 error (_("ctf_bfdopen failed on %s - %s"),
1593 bfd_get_filename (abfd
), ctf_errmsg (err
));
1595 ctf_dict_t
*fp
= ctf_dict_open (arc
, NULL
, &err
);
1597 error (_("ctf_dict_open failed on %s - %s"),
1598 bfd_get_filename (abfd
), ctf_errmsg (err
));
1599 ctf_dict_key
.emplace (of
, fp
);
1601 psymbol_functions
*psf
= new psymbol_functions ();
1602 psymtab_storage
*partial_symtabs
= psf
->get_partial_symtabs ().get ();
1603 of
->qf
.emplace_front (psf
);
1604 scan_partial_symbols (fp
, partial_symtabs
, of
);
1610 elfctf_build_psymtabs (struct objfile
*of
)
1612 /* Nothing to do if CTF is disabled. */
1615 #endif /* ENABLE_LIBCTF */