1 /* Compact ANSI-C Type Format (CTF) support in GDB.
3 Copyright (C) 2019-2020 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"
87 static const struct objfile_key
<htab
, htab_deleter
> ctf_tid_key
;
91 explicit ctf_fp_info (ctf_file_t
*cfp
) : fp (cfp
) {}
96 /* Cleanup function for the ctf_file_key data. */
97 ctf_fp_info::~ctf_fp_info ()
102 ctf_archive_t
*arc
= ctf_get_arc (fp
);
107 static const objfile_key
<ctf_fp_info
> ctf_file_key
;
109 /* A CTF context consists of a file pointer and an objfile pointer. */
115 struct buildsym_compunit
*builder
;
118 /* A partial symtab, specialized for this module. */
119 struct ctf_psymtab
: public standard_psymtab
121 ctf_psymtab (const char *filename
, struct objfile
*objfile
, CORE_ADDR addr
)
122 : standard_psymtab (filename
, objfile
, addr
)
126 void read_symtab (struct objfile
*) override
;
127 void expand_psymtab (struct objfile
*) override
;
129 struct ctf_context
*context
;
132 /* The routines that read and process fields/members of a C struct, union,
133 or enumeration, pass lists of data member fields in an instance of a
134 ctf_field_info structure. It is derived from dwarf2read.c. */
138 struct field field
{};
141 struct ctf_field_info
143 /* List of data member fields. */
144 std::vector
<struct ctf_nextfield
> fields
;
147 struct ctf_context
*cur_context
;
152 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head
153 of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
154 std::vector
<struct decl_field
> typedef_field_list
;
156 /* Nested types defined by this struct and the number of elements in
158 std::vector
<struct decl_field
> nested_types_list
;
162 /* Local function prototypes */
164 static int ctf_add_type_cb (ctf_id_t tid
, void *arg
);
166 static struct type
*read_array_type (struct ctf_context
*cp
, ctf_id_t tid
);
168 static struct type
*read_pointer_type (struct ctf_context
*cp
, ctf_id_t tid
,
171 static struct type
*read_structure_type (struct ctf_context
*cp
, ctf_id_t tid
);
173 static struct type
*read_enum_type (struct ctf_context
*cp
, ctf_id_t tid
);
175 static struct type
*read_typedef_type (struct ctf_context
*cp
, ctf_id_t tid
,
176 ctf_id_t btid
, const char *name
);
178 static struct type
*read_type_record (struct ctf_context
*cp
, ctf_id_t tid
);
180 static void process_structure_type (struct ctf_context
*cp
, ctf_id_t tid
);
182 static void process_struct_members (struct ctf_context
*cp
, ctf_id_t tid
,
185 static struct symbol
*new_symbol (struct ctf_context
*cp
, struct type
*type
,
188 struct ctf_tid_and_type
194 /* Hash function for a ctf_tid_and_type. */
197 tid_and_type_hash (const void *item
)
199 const struct ctf_tid_and_type
*ids
200 = (const struct ctf_tid_and_type
*) item
;
205 /* Equality function for a ctf_tid_and_type. */
208 tid_and_type_eq (const void *item_lhs
, const void *item_rhs
)
210 const struct ctf_tid_and_type
*ids_lhs
211 = (const struct ctf_tid_and_type
*) item_lhs
;
212 const struct ctf_tid_and_type
*ids_rhs
213 = (const struct ctf_tid_and_type
*) item_rhs
;
215 return ids_lhs
->tid
== ids_rhs
->tid
;
218 /* Set the type associated with TID to TYP. */
221 set_tid_type (struct objfile
*of
, ctf_id_t tid
, struct type
*typ
)
225 htab
= (htab_t
) ctf_tid_key
.get (of
);
228 htab
= htab_create_alloc (1, tid_and_type_hash
,
230 NULL
, xcalloc
, xfree
);
231 ctf_tid_key
.set (of
, htab
);
234 struct ctf_tid_and_type
**slot
, ids
;
237 slot
= (struct ctf_tid_and_type
**) htab_find_slot (htab
, &ids
, INSERT
);
239 complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"),
241 *slot
= XOBNEW (&of
->objfile_obstack
, struct ctf_tid_and_type
);
246 /* Look up the type for TID in tid_and_type hash, return NULL if hash is
247 empty or TID does not have a saved type. */
250 get_tid_type (struct objfile
*of
, ctf_id_t tid
)
252 struct ctf_tid_and_type
*slot
, ids
;
255 htab
= (htab_t
) ctf_tid_key
.get (of
);
261 slot
= (struct ctf_tid_and_type
*) htab_find (htab
, &ids
);
268 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */
271 get_bitsize (ctf_file_t
*fp
, ctf_id_t tid
, uint32_t kind
)
275 if ((kind
== CTF_K_INTEGER
|| kind
== CTF_K_ENUM
276 || kind
== CTF_K_FLOAT
)
277 && ctf_type_reference (fp
, tid
) != CTF_ERR
278 && ctf_type_encoding (fp
, tid
, &cet
) != CTF_ERR
)
284 /* Set SYM's address, with NAME, from its minimal symbol entry. */
287 set_symbol_address (struct objfile
*of
, struct symbol
*sym
, const char *name
)
289 struct bound_minimal_symbol msym
;
291 msym
= lookup_minimal_symbol (name
, NULL
, of
);
292 if (msym
.minsym
!= NULL
)
294 SET_SYMBOL_VALUE_ADDRESS (sym
, BMSYMBOL_VALUE_ADDRESS (msym
));
295 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
296 SYMBOL_SECTION (sym
) = MSYMBOL_SECTION (msym
.minsym
);
300 /* Create the vector of fields, and attach it to TYPE. */
303 attach_fields_to_type (struct ctf_field_info
*fip
, struct type
*type
)
305 int nfields
= fip
->fields
.size ();
310 /* Record the field count, allocate space for the array of fields. */
311 type
->set_num_fields (nfields
);
313 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
315 /* Copy the saved-up fields into the field vector. */
316 for (int i
= 0; i
< nfields
; ++i
)
318 struct ctf_nextfield
&field
= fip
->fields
[i
];
319 type
->field (i
) = field
.field
;
323 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
324 (which may be different from NAME) to the architecture back-end to allow
325 it to guess the correct format if necessary. */
328 ctf_init_float_type (struct objfile
*objfile
,
331 const char *name_hint
)
333 struct gdbarch
*gdbarch
= objfile
->arch ();
334 const struct floatformat
**format
;
337 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
339 type
= init_float_type (objfile
, bits
, name
, format
);
341 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
346 /* Callback to add member NAME to a struct/union type. TID is the type
347 of struct/union member, OFFSET is the offset of member in bits,
348 and ARG contains the ctf_field_info. */
351 ctf_add_member_cb (const char *name
,
353 unsigned long offset
,
356 struct ctf_field_info
*fip
= (struct ctf_field_info
*) arg
;
357 struct ctf_context
*ccp
= fip
->cur_context
;
358 struct ctf_nextfield new_field
;
363 fp
= &new_field
.field
;
364 FIELD_NAME (*fp
) = name
;
366 kind
= ctf_type_kind (ccp
->fp
, tid
);
367 t
= get_tid_type (ccp
->of
, tid
);
370 t
= read_type_record (ccp
, tid
);
373 complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name
, tid
);
374 t
= objfile_type (ccp
->of
)->builtin_error
;
375 set_tid_type (ccp
->of
, tid
, t
);
379 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
)
380 process_struct_members (ccp
, tid
, t
);
383 SET_FIELD_BITPOS (*fp
, offset
/ TARGET_CHAR_BIT
);
384 FIELD_BITSIZE (*fp
) = get_bitsize (ccp
->fp
, tid
, kind
);
386 fip
->fields
.emplace_back (new_field
);
391 /* Callback to add member NAME of EVAL to an enumeration type.
392 ARG contains the ctf_field_info. */
395 ctf_add_enum_member_cb (const char *name
, int enum_value
, void *arg
)
397 struct ctf_field_info
*fip
= (struct ctf_field_info
*) arg
;
398 struct ctf_nextfield new_field
;
400 struct ctf_context
*ccp
= fip
->cur_context
;
402 fp
= &new_field
.field
;
403 FIELD_NAME (*fp
) = name
;
405 SET_FIELD_ENUMVAL (*fp
, enum_value
);
406 FIELD_BITSIZE (*fp
) = 0;
410 struct symbol
*sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
411 OBJSTAT (ccp
->of
, n_syms
++);
413 sym
->set_language (language_c
, &ccp
->of
->objfile_obstack
);
414 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
415 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
416 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
417 SYMBOL_TYPE (sym
) = fip
->ptype
;
418 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
421 fip
->fields
.emplace_back (new_field
);
426 /* Add a new symbol entry, with its name from TID, its access index and
427 domain from TID's kind, and its type from TYPE. */
429 static struct symbol
*
430 new_symbol (struct ctf_context
*ccp
, struct type
*type
, ctf_id_t tid
)
432 struct objfile
*objfile
= ccp
->of
;
433 ctf_file_t
*fp
= ccp
->fp
;
434 struct symbol
*sym
= NULL
;
436 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
439 sym
= new (&objfile
->objfile_obstack
) symbol
;
440 OBJSTAT (objfile
, n_syms
++);
442 sym
->set_language (language_c
, &objfile
->objfile_obstack
);
443 sym
->compute_and_set_names (name
.get (), true, objfile
->per_bfd
);
444 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
445 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
448 SYMBOL_TYPE (sym
) = type
;
450 uint32_t kind
= ctf_type_kind (fp
, tid
);
456 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
457 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
460 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
463 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
464 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
469 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
470 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
483 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
489 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
490 and create the symbol for it. */
493 read_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
495 struct objfile
*of
= ccp
->of
;
496 ctf_file_t
*fp
= ccp
->fp
;
498 struct type
*type
= NULL
;
502 if (ctf_type_encoding (fp
, tid
, &cet
))
504 complaint (_("ctf_type_encoding read_base_type failed - %s"),
505 ctf_errmsg (ctf_errno (fp
)));
509 gdb::unique_xmalloc_ptr
<char> copied_name (ctf_type_aname_raw (fp
, tid
));
510 if (copied_name
== NULL
|| strlen (copied_name
.get ()) == 0)
512 name
= ctf_type_aname (fp
, tid
);
514 complaint (_("ctf_type_aname read_base_type failed - %s"),
515 ctf_errmsg (ctf_errno (fp
)));
518 name
= obstack_strdup (&of
->objfile_obstack
, copied_name
.get ());
520 kind
= ctf_type_kind (fp
, tid
);
521 if (kind
== CTF_K_INTEGER
)
523 uint32_t issigned
, ischar
, isbool
;
524 struct gdbarch
*gdbarch
= of
->arch ();
526 issigned
= cet
.cte_format
& CTF_INT_SIGNED
;
527 ischar
= cet
.cte_format
& CTF_INT_CHAR
;
528 isbool
= cet
.cte_format
& CTF_INT_BOOL
;
530 type
= init_character_type (of
, TARGET_CHAR_BIT
, !issigned
, name
);
532 type
= init_boolean_type (of
, gdbarch_int_bit (gdbarch
),
537 if (cet
.cte_bits
&& ((cet
.cte_bits
% TARGET_CHAR_BIT
) == 0))
540 bits
= gdbarch_int_bit (gdbarch
);
541 type
= init_integer_type (of
, bits
, !issigned
, name
);
544 else if (kind
== CTF_K_FLOAT
)
547 isflt
= !((cet
.cte_format
& CTF_FP_IMAGRY
) == CTF_FP_IMAGRY
548 || (cet
.cte_format
& CTF_FP_DIMAGRY
) == CTF_FP_DIMAGRY
549 || (cet
.cte_format
& CTF_FP_LDIMAGRY
) == CTF_FP_LDIMAGRY
);
551 type
= ctf_init_float_type (of
, cet
.cte_bits
, name
, name
);
555 = ctf_init_float_type (of
, cet
.cte_bits
/ 2, NULL
, name
);
556 type
= init_complex_type (name
, t
);
561 complaint (_("read_base_type: unsupported base kind (%d)"), kind
);
562 type
= init_type (of
, TYPE_CODE_ERROR
, cet
.cte_bits
, name
);
565 if (name
!= NULL
&& strcmp (name
, "char") == 0)
566 TYPE_NOSIGN (type
) = 1;
568 return set_tid_type (of
, tid
, type
);
572 process_base_type (struct ctf_context
*ccp
, ctf_id_t tid
)
576 type
= read_base_type (ccp
, tid
);
577 new_symbol (ccp
, type
, tid
);
580 /* Start a structure or union scope (definition) with TID to create a type
581 for the structure or union.
583 Fill in the type's name and general properties. The members will not be
584 processed, nor a symbol table entry be done until process_structure_type
585 (assuming the type has a name). */
588 read_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
590 struct objfile
*of
= ccp
->of
;
591 ctf_file_t
*fp
= ccp
->fp
;
595 type
= alloc_type (of
);
597 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
598 if (name
!= NULL
&& strlen (name
.get() ) != 0)
599 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
601 kind
= ctf_type_kind (fp
, tid
);
602 if (kind
== CTF_K_UNION
)
603 type
->set_code (TYPE_CODE_UNION
);
605 type
->set_code (TYPE_CODE_STRUCT
);
607 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
608 set_type_align (type
, ctf_type_align (fp
, tid
));
610 return set_tid_type (ccp
->of
, tid
, type
);
613 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
614 and create the symbol for it. */
617 process_struct_members (struct ctf_context
*ccp
,
621 struct ctf_field_info fi
;
623 fi
.cur_context
= ccp
;
624 if (ctf_member_iter (ccp
->fp
, tid
, ctf_add_member_cb
, &fi
) == CTF_ERR
)
625 complaint (_("ctf_member_iter process_struct_members failed - %s"),
626 ctf_errmsg (ctf_errno (ccp
->fp
)));
628 /* Attach fields to the type. */
629 attach_fields_to_type (&fi
, type
);
631 new_symbol (ccp
, type
, tid
);
635 process_structure_type (struct ctf_context
*ccp
, ctf_id_t tid
)
639 type
= read_structure_type (ccp
, tid
);
640 process_struct_members (ccp
, tid
, type
);
643 /* Create a function type for TID and set its return type. */
646 read_func_kind_type (struct ctf_context
*ccp
, ctf_id_t tid
)
648 struct objfile
*of
= ccp
->of
;
649 ctf_file_t
*fp
= ccp
->fp
;
650 struct type
*type
, *rettype
;
653 type
= alloc_type (of
);
655 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
656 if (name
!= NULL
&& strlen (name
.get ()) != 0)
657 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
659 type
->set_code (TYPE_CODE_FUNC
);
660 ctf_func_type_info (fp
, tid
, &cfi
);
661 rettype
= get_tid_type (of
, cfi
.ctc_return
);
662 TYPE_TARGET_TYPE (type
) = rettype
;
663 set_type_align (type
, ctf_type_align (fp
, tid
));
665 return set_tid_type (of
, tid
, type
);
668 /* Given a TID of CTF_K_ENUM, process all the members of the
669 enumeration, and create the symbol for the enumeration type. */
672 read_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
674 struct objfile
*of
= ccp
->of
;
675 ctf_file_t
*fp
= ccp
->fp
;
676 struct type
*type
, *target_type
;
679 type
= alloc_type (of
);
681 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
682 if (name
!= NULL
&& strlen (name
.get ()) != 0)
683 type
->set_name (obstack_strdup (&of
->objfile_obstack
, name
.get ()));
685 type
->set_code (TYPE_CODE_ENUM
);
686 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
687 ctf_func_type_info (fp
, tid
, &fi
);
688 target_type
= get_tid_type (of
, fi
.ctc_return
);
689 TYPE_TARGET_TYPE (type
) = target_type
;
690 set_type_align (type
, ctf_type_align (fp
, tid
));
692 return set_tid_type (of
, tid
, type
);
696 process_enum_type (struct ctf_context
*ccp
, ctf_id_t tid
)
699 struct ctf_field_info fi
;
701 type
= read_enum_type (ccp
, tid
);
703 fi
.cur_context
= ccp
;
705 if (ctf_enum_iter (ccp
->fp
, tid
, ctf_add_enum_member_cb
, &fi
) == CTF_ERR
)
706 complaint (_("ctf_enum_iter process_enum_type failed - %s"),
707 ctf_errmsg (ctf_errno (ccp
->fp
)));
709 /* Attach fields to the type. */
710 attach_fields_to_type (&fi
, type
);
712 new_symbol (ccp
, type
, tid
);
715 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */
718 add_array_cv_type (struct ctf_context
*ccp
,
720 struct type
*base_type
,
724 struct type
*el_type
, *inner_array
;
726 base_type
= copy_type (base_type
);
727 inner_array
= base_type
;
729 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
731 TYPE_TARGET_TYPE (inner_array
)
732 = copy_type (TYPE_TARGET_TYPE (inner_array
));
733 inner_array
= TYPE_TARGET_TYPE (inner_array
);
736 el_type
= TYPE_TARGET_TYPE (inner_array
);
737 cnst
|= TYPE_CONST (el_type
);
738 voltl
|= TYPE_VOLATILE (el_type
);
739 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
741 return set_tid_type (ccp
->of
, tid
, base_type
);
744 /* Read all information from a TID of CTF_K_ARRAY. */
747 read_array_type (struct ctf_context
*ccp
, ctf_id_t tid
)
749 struct objfile
*objfile
= ccp
->of
;
750 ctf_file_t
*fp
= ccp
->fp
;
751 struct type
*element_type
, *range_type
, *idx_type
;
755 if (ctf_array_info (fp
, tid
, &ar
) == CTF_ERR
)
757 complaint (_("ctf_array_info read_array_type failed - %s"),
758 ctf_errmsg (ctf_errno (fp
)));
762 element_type
= get_tid_type (objfile
, ar
.ctr_contents
);
763 if (element_type
== NULL
)
766 idx_type
= get_tid_type (objfile
, ar
.ctr_index
);
767 if (idx_type
== NULL
)
768 idx_type
= objfile_type (objfile
)->builtin_int
;
770 range_type
= create_static_range_type (NULL
, idx_type
, 0, ar
.ctr_nelems
- 1);
771 type
= create_array_type (NULL
, element_type
, range_type
);
772 if (ar
.ctr_nelems
<= 1) /* Check if undefined upper bound. */
774 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
775 TYPE_LENGTH (type
) = 0;
776 TYPE_TARGET_STUB (type
) = 1;
779 TYPE_LENGTH (type
) = ctf_type_size (fp
, tid
);
781 set_type_align (type
, ctf_type_align (fp
, tid
));
783 return set_tid_type (objfile
, tid
, type
);
786 /* Read TID of kind CTF_K_CONST with base type BTID. */
789 read_const_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
791 struct objfile
*objfile
= ccp
->of
;
792 struct type
*base_type
, *cv_type
;
794 base_type
= get_tid_type (objfile
, btid
);
795 if (base_type
== NULL
)
797 base_type
= read_type_record (ccp
, btid
);
798 if (base_type
== NULL
)
800 complaint (_("read_const_type: NULL base type (%ld)"), btid
);
801 base_type
= objfile_type (objfile
)->builtin_error
;
804 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
806 return set_tid_type (objfile
, tid
, cv_type
);
809 /* Read TID of kind CTF_K_VOLATILE with base type BTID. */
812 read_volatile_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
814 struct objfile
*objfile
= ccp
->of
;
815 ctf_file_t
*fp
= ccp
->fp
;
816 struct type
*base_type
, *cv_type
;
818 base_type
= get_tid_type (objfile
, btid
);
819 if (base_type
== NULL
)
821 base_type
= read_type_record (ccp
, btid
);
822 if (base_type
== NULL
)
824 complaint (_("read_volatile_type: NULL base type (%ld)"), btid
);
825 base_type
= objfile_type (objfile
)->builtin_error
;
829 if (ctf_type_kind (fp
, btid
) == CTF_K_ARRAY
)
830 return add_array_cv_type (ccp
, tid
, base_type
, 0, 1);
831 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
833 return set_tid_type (objfile
, tid
, cv_type
);
836 /* Read TID of kind CTF_K_RESTRICT with base type BTID. */
839 read_restrict_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
841 struct objfile
*objfile
= ccp
->of
;
842 struct type
*base_type
, *cv_type
;
844 base_type
= get_tid_type (objfile
, btid
);
845 if (base_type
== NULL
)
847 base_type
= read_type_record (ccp
, btid
);
848 if (base_type
== NULL
)
850 complaint (_("read_restrict_type: NULL base type (%ld)"), btid
);
851 base_type
= objfile_type (objfile
)->builtin_error
;
854 cv_type
= make_restrict_type (base_type
);
856 return set_tid_type (objfile
, tid
, cv_type
);
859 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */
862 read_typedef_type (struct ctf_context
*ccp
, ctf_id_t tid
,
863 ctf_id_t btid
, const char *name
)
865 struct objfile
*objfile
= ccp
->of
;
866 struct type
*this_type
, *target_type
;
868 char *aname
= obstack_strdup (&objfile
->objfile_obstack
, name
);
869 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, aname
);
870 set_tid_type (objfile
, tid
, this_type
);
871 target_type
= get_tid_type (objfile
, btid
);
872 if (target_type
!= this_type
)
873 TYPE_TARGET_TYPE (this_type
) = target_type
;
875 TYPE_TARGET_TYPE (this_type
) = NULL
;
876 TYPE_TARGET_STUB (this_type
) = TYPE_TARGET_TYPE (this_type
) ? 1 : 0;
878 return set_tid_type (objfile
, tid
, this_type
);
881 /* Read TID of kind CTF_K_POINTER with base type BTID. */
884 read_pointer_type (struct ctf_context
*ccp
, ctf_id_t tid
, ctf_id_t btid
)
886 struct objfile
*of
= ccp
->of
;
887 struct type
*target_type
, *type
;
889 target_type
= get_tid_type (of
, btid
);
890 if (target_type
== NULL
)
892 target_type
= read_type_record (ccp
, btid
);
893 if (target_type
== NULL
)
895 complaint (_("read_pointer_type: NULL target type (%ld)"), btid
);
896 target_type
= objfile_type (ccp
->of
)->builtin_error
;
900 type
= lookup_pointer_type (target_type
);
901 set_type_align (type
, ctf_type_align (ccp
->fp
, tid
));
903 return set_tid_type (of
, tid
, type
);
906 /* Read information associated with type TID. */
909 read_type_record (struct ctf_context
*ccp
, ctf_id_t tid
)
911 ctf_file_t
*fp
= ccp
->fp
;
913 struct type
*type
= NULL
;
916 kind
= ctf_type_kind (fp
, tid
);
921 type
= read_structure_type (ccp
, tid
);
924 type
= read_enum_type (ccp
, tid
);
927 type
= read_func_kind_type (ccp
, tid
);
930 btid
= ctf_type_reference (fp
, tid
);
931 type
= read_const_type (ccp
, tid
, btid
);
935 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (fp
, tid
));
936 btid
= ctf_type_reference (fp
, tid
);
937 type
= read_typedef_type (ccp
, tid
, btid
, name
.get ());
941 btid
= ctf_type_reference (fp
, tid
);
942 type
= read_volatile_type (ccp
, tid
, btid
);
945 btid
= ctf_type_reference (fp
, tid
);
946 type
= read_restrict_type (ccp
, tid
, btid
);
949 btid
= ctf_type_reference (fp
, tid
);
950 type
= read_pointer_type (ccp
, tid
, btid
);
954 type
= read_base_type (ccp
, tid
);
957 type
= read_array_type (ccp
, tid
);
968 /* Callback to add type TID to the symbol table. */
971 ctf_add_type_cb (ctf_id_t tid
, void *arg
)
973 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
977 /* Check if tid's type has already been defined. */
978 type
= get_tid_type (ccp
->of
, tid
);
982 ctf_id_t btid
= ctf_type_reference (ccp
->fp
, tid
);
983 kind
= ctf_type_kind (ccp
->fp
, tid
);
988 process_structure_type (ccp
, tid
);
991 process_enum_type (ccp
, tid
);
994 type
= read_func_kind_type (ccp
, tid
);
995 new_symbol (ccp
, type
, tid
);
999 process_base_type (ccp
, tid
);
1002 new_symbol (ccp
, read_type_record (ccp
, tid
), tid
);
1005 type
= read_const_type (ccp
, tid
, btid
);
1006 new_symbol (ccp
, type
, tid
);
1008 case CTF_K_VOLATILE
:
1009 type
= read_volatile_type (ccp
, tid
, btid
);
1010 new_symbol (ccp
, type
, tid
);
1012 case CTF_K_RESTRICT
:
1013 type
= read_restrict_type (ccp
, tid
, btid
);
1014 new_symbol (ccp
, type
, tid
);
1017 type
= read_pointer_type (ccp
, tid
, btid
);
1018 new_symbol (ccp
, type
, tid
);
1021 type
= read_array_type (ccp
, tid
);
1022 new_symbol (ccp
, type
, tid
);
1033 /* Callback to add variable NAME with TID to the symbol table. */
1036 ctf_add_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1038 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1039 struct symbol
*sym
= NULL
;
1043 type
= get_tid_type (ccp
->of
, id
);
1045 kind
= ctf_type_kind (ccp
->fp
, id
);
1048 case CTF_K_FUNCTION
:
1049 if (name
&& !strcmp(name
, "main"))
1050 set_objfile_main_name (ccp
->of
, name
, language_c
);
1054 case CTF_K_VOLATILE
:
1055 case CTF_K_RESTRICT
:
1062 sym
= new_symbol (ccp
, type
, id
);
1063 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1071 complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name
, id
);
1072 type
= objfile_type (ccp
->of
)->builtin_error
;
1074 sym
= new (&ccp
->of
->objfile_obstack
) symbol
;
1075 OBJSTAT (ccp
->of
, n_syms
++);
1076 SYMBOL_TYPE (sym
) = type
;
1077 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1078 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
1079 sym
->compute_and_set_names (name
, false, ccp
->of
->per_bfd
);
1080 add_symbol_to_list (sym
, ccp
->builder
->get_global_symbols ());
1083 complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind
);
1088 set_symbol_address (ccp
->of
, sym
, name
);
1093 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table. */
1095 static struct symbol
*
1096 add_stt_obj (struct ctf_context
*ccp
, unsigned long idx
)
1102 if ((tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
)) == CTF_ERR
)
1105 type
= get_tid_type (ccp
->of
, tid
);
1109 sym
= new_symbol (ccp
, type
, tid
);
1114 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table. */
1116 static struct symbol
*
1117 add_stt_func (struct ctf_context
*ccp
, unsigned long idx
)
1119 struct type
*ftype
, *atyp
, *rettyp
;
1121 ctf_funcinfo_t finfo
;
1125 struct type
*void_type
= objfile_type (ccp
->of
)->builtin_void
;
1127 if (ctf_func_info (ccp
->fp
, idx
, &finfo
) == CTF_ERR
)
1130 argc
= finfo
.ctc_argc
;
1131 if (ctf_func_args (ccp
->fp
, idx
, argc
, argv
) == CTF_ERR
)
1134 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, idx
));
1138 tid
= ctf_lookup_by_symbol (ccp
->fp
, idx
);
1139 ftype
= get_tid_type (ccp
->of
, tid
);
1140 if (finfo
.ctc_flags
& CTF_FUNC_VARARG
)
1141 TYPE_VARARGS (ftype
) = 1;
1142 ftype
->set_num_fields (argc
);
1144 /* If argc is 0, it has a "void" type. */
1147 ((struct field
*) TYPE_ZALLOC (ftype
, argc
* sizeof (struct field
)));
1149 /* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed
1150 to find the argument type. */
1151 for (int iparam
= 0; iparam
< argc
; iparam
++)
1153 atyp
= get_tid_type (ccp
->of
, argv
[iparam
]);
1155 ftype
->field (iparam
).set_type (atyp
);
1157 ftype
->field (iparam
).set_type (void_type
);
1160 sym
= new_symbol (ccp
, ftype
, tid
);
1161 rettyp
= get_tid_type (ccp
->of
, finfo
.ctc_return
);
1163 SYMBOL_TYPE (sym
) = rettyp
;
1165 SYMBOL_TYPE (sym
) = void_type
;
1170 /* Get text segment base for OBJFILE, TSIZE contains the segment size. */
1173 get_objfile_text_range (struct objfile
*of
, int *tsize
)
1175 bfd
*abfd
= of
->obfd
;
1176 const asection
*codes
;
1178 codes
= bfd_get_section_by_name (abfd
, ".text");
1179 *tsize
= codes
? bfd_section_size (codes
) : 0;
1180 return of
->text_section_offset ();
1183 /* Start a symtab for OBJFILE in CTF format. */
1186 ctf_start_symtab (ctf_psymtab
*pst
,
1187 struct objfile
*of
, CORE_ADDR text_offset
)
1189 struct ctf_context
*ccp
;
1192 ccp
->builder
= new buildsym_compunit
1193 (of
, of
->original_name
, NULL
,
1194 language_c
, text_offset
);
1195 ccp
->builder
->record_debugformat ("ctf");
1198 /* Finish reading symbol/type definitions in CTF format.
1199 END_ADDR is the end address of the file's text. SECTION is
1200 the .text section number. */
1202 static struct compunit_symtab
*
1203 ctf_end_symtab (ctf_psymtab
*pst
,
1204 CORE_ADDR end_addr
, int section
)
1206 struct ctf_context
*ccp
;
1209 struct compunit_symtab
*result
1210 = ccp
->builder
->end_symtab (end_addr
, section
);
1211 delete ccp
->builder
;
1212 ccp
->builder
= NULL
;
1216 /* Read in full symbols for PST, and anything it depends on. */
1219 ctf_psymtab::expand_psymtab (struct objfile
*objfile
)
1222 struct ctf_context
*ccp
;
1224 gdb_assert (!readin
);
1228 /* Iterate over entries in data types section. */
1229 if (ctf_type_iter (ccp
->fp
, ctf_add_type_cb
, ccp
) == CTF_ERR
)
1230 complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1231 ctf_errmsg (ctf_errno (ccp
->fp
)));
1234 /* Iterate over entries in variable info section. */
1235 if (ctf_variable_iter (ccp
->fp
, ctf_add_var_cb
, ccp
) == CTF_ERR
)
1236 complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1237 ctf_errmsg (ctf_errno (ccp
->fp
)));
1239 /* Add entries in data objects and function info sections. */
1240 for (unsigned long i
= 0; ; i
++)
1242 sym
= add_stt_obj (ccp
, i
);
1245 if (ctf_errno (ccp
->fp
) == EINVAL
1246 || ctf_errno (ccp
->fp
) == ECTF_NOSYMTAB
)
1248 sym
= add_stt_func (ccp
, i
);
1253 set_symbol_address (ccp
->of
, sym
, sym
->linkage_name ());
1259 /* Expand partial symbol table PST into a full symbol table.
1263 ctf_psymtab::read_symtab (struct objfile
*objfile
)
1266 warning (_("bug: psymtab for %s is already read in."), filename
);
1271 printf_filtered (_("Reading in CTF data for %s..."), filename
);
1272 gdb_flush (gdb_stdout
);
1275 /* Start a symtab. */
1276 CORE_ADDR offset
; /* Start of text segment. */
1279 offset
= get_objfile_text_range (objfile
, &tsize
);
1280 ctf_start_symtab (this, objfile
, offset
);
1281 expand_psymtab (objfile
);
1283 set_text_low (offset
);
1284 set_text_high (offset
+ tsize
);
1285 compunit_symtab
= ctf_end_symtab (this, offset
+ tsize
,
1286 SECT_OFF_TEXT (objfile
));
1288 /* Finish up the debug error message. */
1290 printf_filtered (_("done.\n"));
1294 /* Allocate a new partial_symtab NAME.
1296 Each source file that has not been fully read in is represented by
1297 a partial_symtab. This contains the information on where in the
1298 executable the debugging symbols for a specific file are, and a
1299 list of names of global symbols which are located in this file.
1300 They are all chained on partial symtab lists.
1302 Even after the source file has been read into a symtab, the
1303 partial_symtab remains around. They are allocated on an obstack,
1306 static ctf_psymtab
*
1307 create_partial_symtab (const char *name
,
1309 struct objfile
*objfile
)
1312 struct ctf_context
*ccx
;
1314 pst
= new ctf_psymtab (name
, objfile
, 0);
1316 ccx
= XOBNEW (&objfile
->objfile_obstack
, struct ctf_context
);
1324 /* Callback to add type TID to partial symbol table. */
1327 ctf_psymtab_type_cb (ctf_id_t tid
, void *arg
)
1329 struct ctf_context
*ccp
;
1333 ccp
= (struct ctf_context
*) arg
;
1334 gdb::unique_xmalloc_ptr
<char> name (ctf_type_aname_raw (ccp
->fp
, tid
));
1335 if (name
== NULL
|| strlen (name
.get ()) == 0)
1338 domain_enum domain
= UNDEF_DOMAIN
;
1339 enum address_class aclass
= LOC_UNDEF
;
1340 kind
= ctf_type_kind (ccp
->fp
, tid
);
1346 domain
= STRUCT_DOMAIN
;
1347 aclass
= LOC_TYPEDEF
;
1349 case CTF_K_FUNCTION
:
1351 domain
= VAR_DOMAIN
;
1352 aclass
= LOC_STATIC
;
1353 section
= SECT_OFF_TEXT (ccp
->of
);
1356 domain
= VAR_DOMAIN
;
1357 aclass
= LOC_STATIC
;
1361 case CTF_K_VOLATILE
:
1362 case CTF_K_RESTRICT
:
1363 domain
= VAR_DOMAIN
;
1364 aclass
= LOC_TYPEDEF
;
1368 domain
= VAR_DOMAIN
;
1369 aclass
= LOC_TYPEDEF
;
1376 add_psymbol_to_list (name
.get (), true,
1377 domain
, aclass
, section
,
1378 psymbol_placement::GLOBAL
,
1379 0, language_c
, ccp
->of
);
1384 /* Callback to add variable NAME with ID to partial symbol table. */
1387 ctf_psymtab_var_cb (const char *name
, ctf_id_t id
, void *arg
)
1389 struct ctf_context
*ccp
= (struct ctf_context
*) arg
;
1391 add_psymbol_to_list (name
, true,
1392 VAR_DOMAIN
, LOC_STATIC
, -1,
1393 psymbol_placement::GLOBAL
,
1394 0, language_c
, ccp
->of
);
1398 /* Setup partial_symtab's describing each source file for which
1399 debugging information is available. */
1402 scan_partial_symbols (ctf_file_t
*cfp
, struct objfile
*of
)
1404 struct ctf_context ccx
;
1405 bfd
*abfd
= of
->obfd
;
1406 const char *name
= bfd_get_filename (abfd
);
1407 ctf_psymtab
*pst
= create_partial_symtab (name
, cfp
, of
);
1412 if (ctf_type_iter (cfp
, ctf_psymtab_type_cb
, &ccx
) == CTF_ERR
)
1413 complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1414 ctf_errmsg (ctf_errno (cfp
)));
1416 if (ctf_variable_iter (cfp
, ctf_psymtab_var_cb
, &ccx
) == CTF_ERR
)
1417 complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1418 ctf_errmsg (ctf_errno (cfp
)));
1420 /* Scan CTF object and function sections which correspond to each
1421 STT_FUNC or STT_OBJECT entry in the symbol table,
1422 pick up what init_symtab has done. */
1423 for (unsigned long idx
= 0; ; idx
++)
1426 if ((tid
= ctf_lookup_by_symbol (cfp
, idx
)) == CTF_ERR
)
1428 if (ctf_errno (cfp
) == EINVAL
|| ctf_errno (cfp
) == ECTF_NOSYMTAB
)
1429 break; // Done, reach end of the section.
1433 gdb::unique_xmalloc_ptr
<char> tname (ctf_type_aname_raw (cfp
, tid
));
1434 uint32_t kind
= ctf_type_kind (cfp
, tid
);
1435 address_class aclass
;
1436 domain_enum tdomain
;
1442 tdomain
= STRUCT_DOMAIN
;
1445 tdomain
= VAR_DOMAIN
;
1449 if (kind
== CTF_K_FUNCTION
)
1450 aclass
= LOC_STATIC
;
1451 else if (kind
== CTF_K_CONST
)
1454 aclass
= LOC_TYPEDEF
;
1456 add_psymbol_to_list (tname
.get (), true,
1457 tdomain
, aclass
, -1,
1458 psymbol_placement::STATIC
,
1462 end_psymtab_common (of
, pst
);
1465 /* Read CTF debugging information from a BFD section. This is
1466 called from elfread.c. It does a quick pass through the
1467 .ctf section to set up the partial symbol table. */
1470 elfctf_build_psymtabs (struct objfile
*of
)
1472 bfd
*abfd
= of
->obfd
;
1475 ctf_archive_t
*arc
= ctf_bfdopen (abfd
, &err
);
1477 error (_("ctf_bfdopen failed on %s - %s"),
1478 bfd_get_filename (abfd
), ctf_errmsg (err
));
1480 ctf_file_t
*fp
= ctf_arc_open_by_name (arc
, NULL
, &err
);
1482 error (_("ctf_arc_open_by_name failed on %s - %s"),
1483 bfd_get_filename (abfd
), ctf_errmsg (err
));
1484 ctf_file_key
.emplace (of
, fp
);
1486 scan_partial_symbols (fp
, of
);