diff options
Diffstat (limited to 'gdb/ctfread.c')
| -rw-r--r-- | gdb/ctfread.c | 1522 |
1 files changed, 1522 insertions, 0 deletions
diff --git a/gdb/ctfread.c b/gdb/ctfread.c new file mode 100644 index 0000000..9b6c70e --- /dev/null +++ b/gdb/ctfread.c @@ -0,0 +1,1522 @@ +/* Compact ANSI-C Type Format (CTF) support in GDB. + + Copyright (C) 2019 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +/* This file format can be used to compactly represent the information needed + by a debugger to interpret the ANSI-C types used by a given program. + Traditionally, this kind of information is generated by the compiler when + invoked with the -g flag and is stored in "stabs" strings or in the more + modern DWARF format. A new -gtLEVEL option has been added in gcc to generate + such information. CTF provides a representation of only the information + that is relevant to debugging a complex, optimized C program such as the + operating system kernel in a form that is significantly more compact than + the equivalent stabs or DWARF representation. The format is data-model + independent, so consumers do not need different code depending on whether + they are 32-bit or 64-bit programs. CTF assumes that a standard ELF symbol + table is available for use in the debugger, and uses the structure and data + of the symbol table to avoid storing redundant information. The CTF data + may be compressed on disk or in memory, indicated by a bit in the header. + CTF may be interpreted in a raw disk file, or it may be stored in an ELF + section, typically named .ctf. Data structures are aligned so that a raw + CTF file or CTF ELF section may be manipulated using mmap(2). + + The CTF file or section itself has the following structure: + + +--------+--------+---------+----------+----------+-------+--------+ + | file | type | data | function | variable | data | string | + | header | labels | objects | info | info | types | table | + +--------+--------+---------+----------+----------+-------+--------+ + + The file header stores a magic number and version information, encoding + flags, and the byte offset of each of the sections relative to the end of the + header itself. If the CTF data has been uniquified against another set of + CTF data, a reference to that data also appears in the the header. This + reference is the name of the label corresponding to the types uniquified + against. + + Following the header is a list of labels, used to group the types included in + the data types section. Each label is accompanied by a type ID i. A given + label refers to the group of types whose IDs are in the range [0, i]. + + Data object and function records are stored in the same order as they appear + in the corresponding symbol table, except that symbols marked SHN_UNDEF are + not stored and symbols that have no type data are padded out with zeroes. + For each data object, the type ID (a small integer) is recorded. For each + function, the type ID of the return type and argument types is recorded. + + Variable records (as distinct from data objects) provide a modicum of support + for non-ELF systems, mapping a variable name to a CTF type ID. The variable + names are sorted into ASCIIbetical order, permitting binary searching. + + The data types section is a list of variable size records that represent each + type, in order by their ID. The types themselves form a directed graph, + where each node may contain one or more outgoing edges to other type nodes, + denoted by their ID. + + Strings are recorded as a string table ID (0 or 1) and a byte offset into the + string table. String table 0 is the internal CTF string table. String table + 1 is the external string table, which is the string table associated with the + ELF symbol table for this object. CTF does not record any strings that are + already in the symbol table, and the CTF string table does not contain any + duplicated strings. */ + +#include "defs.h" +#include "buildsym.h" +#include "complaints.h" +#include "block.h" +#include "ctfread.h" +#include "psympriv.h" +#include "ctf.h" +#include "ctf-api.h" + +static const struct objfile_key<htab, htab_deleter> ctf_tid_key; +static const struct objfile_data *ctf_file_key; + +/* A CTF context consists of a file pointer and an objfile pointer. */ + +typedef struct ctf_context +{ + ctf_file_t *fp; + struct objfile *of; + struct buildsym_compunit *builder; +} ctf_context_t; + +/* The routines that read and process fields/members of a C struct, union, + or enumeration, pass lists of data member fields in an instance of a + field_info structure. It is derived from dwarf2read.c. */ + +struct nextfield +{ + struct field field {}; +}; + +struct field_info + { + /* List of data member fields. */ + std::vector<struct nextfield> fields; + + /* Number of fields. */ + int nfields = 0; + + /* Context. */ + ctf_context_t cur_context; + + /* Parent type. */ + struct type *ptype; + + /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head + of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */ + std::vector<struct decl_field> typedef_field_list; + + /* Nested types defined by this struct and the number of elements in + this list. */ + std::vector<struct decl_field> nested_types_list; + }; + + +/* Local function prototypes */ + +static void psymtab_to_symtab (struct partial_symtab *); + +static int ctf_add_type_cb (ctf_id_t tid, void *arg); + +static struct type *read_array_type (ctf_context_t *ccp, ctf_id_t tid); + +static struct type *read_pointer_type (ctf_context_t *ccp, ctf_id_t tid, + ctf_id_t btid); + +static struct type *read_structure_type (ctf_context_t *ccp, ctf_id_t tid); + +static struct type *read_enum_type (ctf_context_t *ccp, ctf_id_t tid); + +static struct type *read_typedef_type (ctf_context_t *ccp, ctf_id_t tid, + ctf_id_t btid, const char *name); + +static struct type *read_type_record (ctf_context_t *ccp, ctf_id_t tid); + +static void process_structure_type (ctf_context_t *ccp, ctf_id_t tid); + +static void process_struct_members (ctf_context_t *ccp, ctf_id_t tid, + struct type *type); + +static struct symbol * new_symbol (ctf_context_t *ccp, struct type *type, + ctf_id_t tid); + +struct ctf_tid_and_type +{ + ctf_id_t tid; + struct type *type; +}; + +/* Hash function for a ctf_tid_and_type. */ + +static hashval_t +tid_and_type_hash (const void *item) +{ + const struct ctf_tid_and_type *ids + = (const struct ctf_tid_and_type *) item; + + return ids->tid; +} + +/* Equality function for a ctf_tid_and_type. */ + +static int +tid_and_type_eq (const void *item_lhs, const void *item_rhs) +{ + const struct ctf_tid_and_type *ids_lhs + = (const struct ctf_tid_and_type *) item_lhs; + const struct ctf_tid_and_type *ids_rhs + = (const struct ctf_tid_and_type *) item_rhs; + + return ids_lhs->tid == ids_rhs->tid; +} + +/* Set the type associated with TID to TYP. */ + +static struct type * +set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ) +{ + htab_t htab; + + htab = (htab_t) ctf_tid_key.get (of); + if (htab == NULL) + { + htab = htab_create_alloc (1, tid_and_type_hash, + tid_and_type_eq, + NULL, xcalloc, xfree); + ctf_tid_key.set (of, htab); + } + + struct ctf_tid_and_type **slot, ids; + ids.tid = tid; + ids.type = typ; + slot = (struct ctf_tid_and_type **) htab_find_slot (htab, &ids, INSERT); + if (*slot) + complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"), + (tid)); + *slot = XOBNEW (&of->objfile_obstack, struct ctf_tid_and_type); + **slot = ids; + return typ; +} + +/* Look up the type for TID in tid_and_type hash, return NULL if hash is + empty or TID does not have a saved type. */ + +static struct type * +get_tid_type (struct objfile *of, ctf_id_t tid) +{ + struct ctf_tid_and_type *slot, ids; + htab_t htab; + + htab = (htab_t) ctf_tid_key.get (of); + if (htab == NULL) + return NULL; + + ids.tid = tid; + ids.type = NULL; + slot = (struct ctf_tid_and_type *) htab_find (htab, &ids); + if (slot) + return slot->type; + else + return NULL; +} + +/* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */ + +static int +get_bitsize (ctf_file_t *fp, ctf_id_t tid, uint32_t kind) +{ + ctf_encoding_t cet; + + if ((kind == CTF_K_INTEGER || kind == CTF_K_ENUM + || kind == CTF_K_FLOAT) + && ctf_type_reference (fp, tid) != CTF_ERR + && ctf_type_encoding (fp, tid, &cet) != CTF_ERR) + { + return cet.cte_bits; + } + + return 0; +} + +/* Set SYM's address, with NAME, from its minimal symbol entry. */ + +static void +set_symbol_address (struct objfile *of, struct symbol *sym, const char *name) +{ + struct bound_minimal_symbol msym; + + msym = lookup_minimal_symbol (name, NULL, of); + if (msym.minsym != NULL) + { + SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym); + SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; + SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msym.minsym); + } +} + +/* Create the vector of fields, and attach it to TYPE. */ + +static void +attach_fields_to_type (struct field_info *fip, struct type *type) +{ + int nfields = fip->nfields; + + if (!nfields) + return; + + /* Record the field count, allocate space for the array of fields. */ + TYPE_NFIELDS (type) = nfields; + TYPE_FIELDS (type) = (struct field *) + TYPE_ZALLOC (type, sizeof (struct field) * nfields); + + /* Copy the saved-up fields into the field vector. */ + for (int i = 0; i < nfields; ++i) + { + struct nextfield &field = fip->fields[i]; + TYPE_FIELD (type, i) = field.field; + } +} + +/* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT + (which may be different from NAME) to the architecture back-end to allow + it to guess the correct format if necessary. */ + +static struct type * +ctf_init_float_type (struct objfile *objfile, + int bits, + const char *name, + const char *name_hint) +{ + struct gdbarch *gdbarch = get_objfile_arch (objfile); + const struct floatformat **format; + struct type *type; + + format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits); + if (format) + type = init_float_type (objfile, bits, name, format); + else + type = init_type (objfile, TYPE_CODE_ERROR, bits, name); + + return type; +} + +/* Callback to add member NAME to a struct/union type. TID is the type + of struct/union member, OFFSET is the offset of member in bits + (gdbarch_bits_big_endian(), and ARG contains the field_info. */ + +static int +ctf_add_member_cb (const char *name, + ctf_id_t tid, + unsigned long offset, + void *arg) +{ + struct field_info *fip = (struct field_info *)arg; + ctf_context_t *ccp = &fip->cur_context; + struct nextfield new_field; + struct field *fp; + struct type *t; + uint32_t kind; + + fp = &new_field.field; + FIELD_NAME (*fp) = name; + + kind = ctf_type_kind (ccp->fp, tid); + t = get_tid_type (ccp->of, tid); + if (!t) + { + t = read_type_record (ccp, tid); + if (!t) + { + complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid); + t = objfile_type (ccp->of)->builtin_error; + set_tid_type (ccp->of, tid, t); + } + } + + if (kind == CTF_K_STRUCT || kind == CTF_K_UNION) + { + process_struct_members (ccp, tid, t); + } + + FIELD_TYPE (*fp) = t; + SET_FIELD_BITPOS (*fp, offset / TARGET_CHAR_BIT); + FIELD_BITSIZE (*fp) = get_bitsize (ccp->fp, tid, kind); + + fip->fields.emplace_back (new_field); + fip->nfields++; + + return 0; +} + +/* Callback to add member NAME of EVAL to an enumeration type. + ARG contains the field_info. */ + +static int +ctf_add_enum_member_cb (const char *name, int eval, void *arg) +{ + struct field_info *fip = (struct field_info *)arg; + struct nextfield new_field; + struct field *fp; + ctf_context_t *ccp = &fip->cur_context; + + fp = &new_field.field; + FIELD_NAME (*fp) = name; + FIELD_TYPE (*fp) = NULL; + SET_FIELD_ENUMVAL (*fp, eval); + FIELD_BITSIZE (*fp) = 0; + + if (name) + { + struct symbol *sym = allocate_symbol (ccp->of); + OBJSTAT (ccp->of, n_syms++); + + SYMBOL_SET_LANGUAGE (sym, language_c, &ccp->of->objfile_obstack); + SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); + SYMBOL_ACLASS_INDEX (sym) = LOC_CONST; + SYMBOL_DOMAIN (sym) = VAR_DOMAIN; + SYMBOL_TYPE (sym) = fip->ptype; + add_symbol_to_list (sym, ccp->builder->get_global_symbols ()); + } + + fip->fields.emplace_back (new_field); + fip->nfields++; + + return 0; +} + +/* Add a new symbol entry, with its name from TP, its access index and + domain from TP's kind, and its type from TPYE. */ + +static struct symbol * +new_symbol (ctf_context_t *ccp, struct type *type, ctf_id_t tid) +{ + struct objfile *objfile = ccp->of; + ctf_file_t *fp = ccp->fp; + struct symbol *sym = NULL; + + const char *name = ctf_type_aname_raw (fp, tid); + if (name) + { + sym = allocate_symbol (objfile); + OBJSTAT (objfile, n_syms++); + + SYMBOL_SET_LANGUAGE (sym, language_c, &objfile->objfile_obstack); + SYMBOL_SET_NAMES (sym, xstrdup (name), strlen (name), 0, objfile); + SYMBOL_DOMAIN (sym) = VAR_DOMAIN; + SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT; + + if (type != NULL) + SYMBOL_TYPE (sym) = type; + + uint32_t kind = ctf_type_kind (fp, tid); + switch (kind) + { + case CTF_K_STRUCT: + case CTF_K_UNION: + case CTF_K_ENUM: + SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; + SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; + break; + case CTF_K_FUNCTION: + SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; + break; + case CTF_K_CONST: + if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID) + SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int; + break; + case CTF_K_TYPEDEF: + case CTF_K_INTEGER: + case CTF_K_FLOAT: + SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; + SYMBOL_DOMAIN (sym) = VAR_DOMAIN; + break; + case CTF_K_POINTER: + break; + case CTF_K_VOLATILE: + case CTF_K_RESTRICT: + break; + case CTF_K_SLICE: + case CTF_K_ARRAY: + case CTF_K_UNKNOWN: + break; + } + + add_symbol_to_list (sym, ccp->builder->get_global_symbols ()); + } + + return sym; +} + +/* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation + and create the symbol for it. */ + +static struct type * +read_base_type (ctf_context_t *ccp, ctf_id_t tid) +{ + struct objfile *of = ccp->of; + ctf_file_t *fp = ccp->fp; + ctf_encoding_t cet; + struct type *type = NULL; + const char *name; + uint32_t kind; + + if (ctf_type_encoding (fp, tid, &cet)) + { + complaint (_("ctf_type_encoding read_base_type failed - %s"), + ctf_errmsg (ctf_errno (fp))); + return NULL; + } + + name = ctf_type_aname_raw (fp, tid); + if (!name || (name && !strlen (name))) + { + name = ctf_type_aname (fp, tid); + if (!name) + complaint (_("ctf_type_aname read_base_type failed - %s"), + ctf_errmsg (ctf_errno (fp))); + } + + kind = ctf_type_kind (fp, tid); + if (kind == CTF_K_INTEGER) + { + uint32_t issigned, ischar, isbool; + struct gdbarch *gdbarch = get_objfile_arch (of); + + issigned = cet.cte_format & CTF_INT_SIGNED; + ischar = cet.cte_format & CTF_INT_CHAR; + isbool = cet.cte_format & CTF_INT_BOOL; + if (ischar) + type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name); + else if (isbool) + type = init_boolean_type (of, gdbarch_int_bit (gdbarch), + !issigned, name); + else + { + int bits; + if (cet.cte_bits && ((cet.cte_bits % TARGET_CHAR_BIT) == 0)) + bits = cet.cte_bits; + else + bits = gdbarch_int_bit (gdbarch); + type = init_integer_type (of, bits, !issigned, name); + } + } + else if (kind == CTF_K_FLOAT) + { + uint32_t isflt; + isflt = !((cet.cte_format & CTF_FP_IMAGRY) == CTF_FP_IMAGRY + || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY + || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY); + if (isflt) + { + type = ctf_init_float_type (of, cet.cte_bits, name, name); + } + else + { + struct type *t; + t = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name); + type = init_complex_type (of, name, t); + } + } + else + { + complaint (_("read_base_type: unsupported base kind (%d)"), kind); + type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name); + } + + if (name && strcmp (name, "char") == 0) + TYPE_NOSIGN (type) = 1; + + return set_tid_type (of, tid, type); +} + +static void +process_base_type (ctf_context_t *ccp, ctf_id_t tid) +{ + struct type *type; + + type = read_base_type (ccp, tid); + new_symbol (ccp, type, tid); +} + +/* Start a structure or union scope (definition) with TID and TP to create + a type for the structure or union. + + Fill in the type's name and general properties. The members will not be + processed, nor a symbol table entry be done until process_structure_type + (assuming the type has a name). */ + +static struct type * +read_structure_type (ctf_context_t *ccp, ctf_id_t tid) +{ + struct objfile *of = ccp->of; + ctf_file_t *fp = ccp->fp; + struct type *type; + const char *name; + uint32_t kind; + + type = alloc_type (of); + name = ctf_type_aname_raw (fp, tid); + if (name && strlen (name)) + TYPE_NAME (type) = name; + kind = ctf_type_kind (fp, tid); + if (kind == CTF_K_UNION) + { + TYPE_CODE (type) = TYPE_CODE_UNION; + } + else + { + TYPE_CODE (type) = TYPE_CODE_STRUCT; + } + TYPE_LENGTH (type) = ctf_type_size (fp, tid); + set_type_align (type, ctf_type_align (fp, tid)); + + return set_tid_type (ccp->of, tid, type); +} + +/* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members + and create the symbol for it. */ + +static void +process_struct_members (ctf_context_t *ccp, + ctf_id_t tid, + struct type *type) +{ + ctf_file_t *fp = ccp->fp; + struct field_info fi; + + fi.cur_context.fp = fp; + fi.cur_context.of = ccp->of; + fi.cur_context.builder = ccp->builder; + if (ctf_member_iter (fp, tid, ctf_add_member_cb, &fi) == CTF_ERR) + { + complaint (_("ctf_member_iter process_struct_members failed - %s"), + ctf_errmsg (ctf_errno (fp))); + } + + /* Attach fields to the type. */ + attach_fields_to_type (&fi, type); + + new_symbol (ccp, type, tid); +} + +static void +process_structure_type (ctf_context_t *ccp, + ctf_id_t tid) +{ + struct type *type; + + type = read_structure_type (ccp, tid); + process_struct_members (ccp, tid, type); +} + +/* Create a function type for TID, set its return type using TP. */ + +static struct type * +read_func_kind_type (ctf_context_t *ccp, ctf_id_t tid) +{ + struct objfile *objfile = ccp->of; + ctf_file_t *fp = ccp->fp; + struct type *type, *rettype; + ctf_funcinfo_t cfi; + const char *name; + + type = alloc_type (objfile); + name = ctf_type_aname_raw (fp, tid); + if (name && strlen (name)) + TYPE_NAME (type) = name; + TYPE_CODE (type) = TYPE_CODE_FUNC; + ctf_func_type_info (fp, tid, &cfi); + rettype = get_tid_type (objfile, cfi.ctc_return); + TYPE_TARGET_TYPE (type) = rettype; + set_type_align (type, ctf_type_align (fp, tid)); + + return set_tid_type (objfile, tid, type); +} + +/* Given a TID of CTF_K_ENUM with type node TP, process all the members of + the enumeration, and create the symbol for the enumeration type. */ + +static struct type * +read_enum_type (ctf_context_t *ccp, + ctf_id_t tid) +{ + struct objfile *of = ccp->of; + ctf_file_t *fp = ccp->fp; + struct type *type, *target_type; + ctf_funcinfo_t fi; + const char *name; + + type = alloc_type (of); + name = ctf_type_aname_raw (fp, tid); + if (name && strlen (name)) + TYPE_NAME (type) = name; + TYPE_CODE (type) = TYPE_CODE_ENUM; + TYPE_LENGTH (type) = ctf_type_size (fp, tid); + ctf_func_type_info (fp, tid, &fi); + target_type = get_tid_type (of, fi.ctc_return); + TYPE_TARGET_TYPE (type) = target_type; + set_type_align (type, ctf_type_align (fp, tid)); + + return set_tid_type (of, tid, type); +} + +static void +process_enum_type (ctf_context_t *ccp, + ctf_id_t tid) +{ + ctf_file_t *fp = ccp->fp; + struct type *type; + struct field_info fi; + + type = read_enum_type (ccp, tid); + + fi.cur_context.fp = fp; + fi.cur_context.of = ccp->of; + fi.cur_context.builder = ccp->builder; + fi.ptype = type; + if (ctf_enum_iter (fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR) + { + complaint (_("ctf_enum_iter process_enum_type failed - %s"), + ctf_errmsg (ctf_errno (fp))); + } + + /* Attach fields to the type. */ + attach_fields_to_type (&fi, type); + + new_symbol (ccp, type, tid); +} + +/* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID. */ + +static struct type * +add_array_cv_type (ctf_context_t *ccp, + ctf_id_t tid, + struct type *base_type, + int cnst, + int voltl) +{ + struct type *el_type, *inner_array; + + base_type = copy_type (base_type); + inner_array = base_type; + + while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) + { + TYPE_TARGET_TYPE (inner_array) = + copy_type (TYPE_TARGET_TYPE (inner_array)); + inner_array = TYPE_TARGET_TYPE (inner_array); + } + + el_type = TYPE_TARGET_TYPE (inner_array); + cnst |= TYPE_CONST (el_type); + voltl |= TYPE_VOLATILE (el_type); + TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); + + return set_tid_type (ccp->of, tid, base_type); +} + +/* Read all information from a CTF_K_ARRAY TID with type node TP. */ + +static struct type * +read_array_type (ctf_context_t *ccp, ctf_id_t tid) +{ + struct objfile *objfile = ccp->of; + ctf_file_t *fp = ccp->fp; + struct type *element_type, *range_type, *idx_type; + struct type *type; + ctf_arinfo_t ar; + + if (ctf_array_info (fp, tid, &ar) == CTF_ERR) + { + complaint (_("ctf_array_info read_array_type failed - %s"), + ctf_errmsg (ctf_errno (fp))); + return NULL; + } + element_type = get_tid_type (objfile, ar.ctr_contents); + if (!element_type) + return NULL; + idx_type = get_tid_type (objfile, ar.ctr_index); + if (!idx_type) + idx_type = objfile_type (objfile)->builtin_int; + + range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems-1); + type = create_array_type (NULL, element_type, range_type); + if (ar.ctr_nelems <= 1) /* Check if undefined upper bound. */ + { + TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED; + TYPE_LENGTH (type) = 0; + TYPE_TARGET_STUB (type) = 1; + } + else + { + TYPE_LENGTH (type) = ctf_type_size (fp, tid); + } + set_type_align (type, ctf_type_align (fp, tid)); + + return set_tid_type (objfile, tid, type); +} + +/* Read TID of kind CTF_K_CONST with base type BTID. */ + +static struct type * +read_const_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) +{ + struct objfile *objfile = ccp->of; + struct type *base_type, *cv_type; + + base_type = get_tid_type (objfile, btid); + if (base_type == NULL) + { + base_type = read_type_record (ccp, btid); + if (!base_type) + { + complaint (_("read_const_type: NULL base type (%ld)"), btid); + base_type = objfile_type (objfile)->builtin_error; + } + } + cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); + + return set_tid_type (objfile, tid, cv_type); +} + +/* Read TID of kind CTF_K_VOLATILE with base type BTID. */ + +static struct type * +read_volatile_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) +{ + struct objfile *objfile = ccp->of; + ctf_file_t *fp = ccp->fp; + struct type *base_type, *cv_type; + + base_type = get_tid_type (objfile, btid); + if (!base_type) + { + complaint (_("read_volatile_type: NULL base type (%ld)"), btid); + base_type = objfile_type (objfile)->builtin_error; + } + + if (ctf_type_kind (fp, btid) == CTF_K_ARRAY) + return add_array_cv_type (ccp, tid, base_type, 0, 1); + cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); + + return set_tid_type (objfile, tid, cv_type); +} + +/* Read TID of kind CTF_K_RESTRICT with base type BTID. */ + +static struct type * +read_restrict_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) +{ + struct objfile *objfile = ccp->of; + struct type *base_type, *cv_type; + + base_type = get_tid_type (objfile, btid); + if (base_type == NULL) + { + base_type = read_type_record (ccp, btid); + if (!base_type) + { + complaint (_("read_restrict_type: NULL base type (%ld)"), btid); + base_type = objfile_type (objfile)->builtin_error; + } + } + cv_type = make_restrict_type (base_type); + + return set_tid_type (objfile, tid, cv_type); +} + +/* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID. */ + +static struct type * +read_typedef_type (ctf_context_t *ccp, ctf_id_t tid, + ctf_id_t btid, const char *name) +{ + struct objfile *objfile = ccp->of; + struct type *this_type, *target_type; + + this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name); + set_tid_type (objfile, tid, this_type); + target_type = get_tid_type (objfile, btid); + if (target_type != this_type) + TYPE_TARGET_TYPE (this_type) = target_type; + else + TYPE_TARGET_TYPE (this_type) = NULL; + TYPE_TARGET_STUB (this_type) = TYPE_TARGET_TYPE (this_type)? 1 : 0; + + return set_tid_type (objfile, tid, this_type); +} + +/* Read TID of kind CTF_K_POINTER with base type BTID. */ + +static struct type * +read_pointer_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid) +{ + struct objfile *of = ccp->of; + struct type *target_type, *type; + + target_type = get_tid_type (of, btid); + if (!target_type) + { + target_type = read_type_record (ccp, btid); + if (!target_type) + { + complaint (_("read_pointer_type: NULL target type (%ld)"), btid); + target_type = objfile_type (ccp->of)->builtin_error; + } + } + + type = lookup_pointer_type (target_type); + set_type_align (type, ctf_type_align (ccp->fp, tid)); + + return set_tid_type (of, tid, type); +} + +/* Read information associated with type TID. */ + +static struct type * +read_type_record (ctf_context_t *ccp, ctf_id_t tid) +{ + ctf_file_t *fp = ccp->fp; + const char *name; + uint32_t kind; + struct type *type = NULL; + ctf_id_t btid; + + kind = ctf_type_kind (fp, tid); + switch (kind) + { + case CTF_K_STRUCT: + case CTF_K_UNION: + type = read_structure_type (ccp, tid); + break; + case CTF_K_ENUM: + type = read_enum_type (ccp, tid); + break; + case CTF_K_FUNCTION: + type = read_func_kind_type (ccp, tid); + break; + case CTF_K_CONST: + btid = ctf_type_reference (fp, tid); + type = read_const_type (ccp, tid, btid); + break; + case CTF_K_TYPEDEF: + name = ctf_type_aname_raw (fp, tid); + btid = ctf_type_reference (fp, tid); + type = read_typedef_type (ccp, tid, btid, name); + break; + case CTF_K_VOLATILE: + btid = ctf_type_reference (fp, tid); + type = read_volatile_type (ccp, tid, btid); + break; + case CTF_K_RESTRICT: + btid = ctf_type_reference (fp, tid); + type = read_restrict_type (ccp, tid, btid); + break; + case CTF_K_POINTER: + btid = ctf_type_reference (fp, tid); + type = read_pointer_type (ccp, tid, btid); + break; + case CTF_K_INTEGER: + case CTF_K_FLOAT: + type = read_base_type (ccp, tid); + break; + case CTF_K_ARRAY: + type = read_array_type (ccp, tid); + break; + case CTF_K_UNKNOWN: + break; + default: + break; + } + + return type; +} + +/* Callback to add type TID to the symbol table. */ + +static int +ctf_add_type_cb (ctf_id_t tid, void *arg) +{ + ctf_context_t *ccp = (ctf_context_t *) arg; + struct type *type; + uint32_t kind; + + /* Check if tid's type has already been defined. */ + type = get_tid_type (ccp->of, tid); + if (type) + return 0; + + ctf_id_t btid = ctf_type_reference (ccp->fp, tid); + kind = ctf_type_kind (ccp->fp, tid); + switch (kind) + { + case CTF_K_STRUCT: + case CTF_K_UNION: + process_structure_type (ccp, tid); + break; + case CTF_K_ENUM: + process_enum_type (ccp, tid); + break; + case CTF_K_FUNCTION: + type = read_func_kind_type (ccp, tid); + new_symbol (ccp, type, tid); + break; + case CTF_K_INTEGER: + case CTF_K_FLOAT: + process_base_type (ccp, tid); + break; + case CTF_K_TYPEDEF: + new_symbol (ccp, read_type_record (ccp, tid), tid); + break; + case CTF_K_CONST: + type = read_const_type (ccp, tid, btid); + new_symbol (ccp, type, tid); + break; + case CTF_K_VOLATILE: + type = read_volatile_type (ccp, tid, btid); + new_symbol (ccp, type, tid); + break; + case CTF_K_RESTRICT: + type = read_restrict_type (ccp, tid, btid); + new_symbol (ccp, type, tid); + break; + case CTF_K_POINTER: + type = read_pointer_type (ccp, tid, btid); + new_symbol (ccp, type, tid); + break; + case CTF_K_ARRAY: + type = read_array_type (ccp, tid); + new_symbol (ccp, type, tid); + break; + case CTF_K_UNKNOWN: + break; + default: + break; + } + + return 0; +} + +/* Callback to add variable NAME with TID to the symbol table. */ + +static int +ctf_add_var_cb (const char *name, ctf_id_t id, void *arg) +{ + ctf_context_t *ccp = (ctf_context_t *) arg; + struct symbol *sym = NULL; + struct type *type; + uint32_t kind; + + type = get_tid_type (ccp->of, id); + + kind = ctf_type_kind (ccp->fp, id); + switch (kind) + { + case CTF_K_FUNCTION: + if (name && !strcmp(name, "main")) + set_objfile_main_name (ccp->of, name, language_c); + break; + case CTF_K_INTEGER: + case CTF_K_FLOAT: + case CTF_K_VOLATILE: + case CTF_K_RESTRICT: + case CTF_K_TYPEDEF: + case CTF_K_CONST: + case CTF_K_POINTER: + case CTF_K_ARRAY: + if (type) + { + sym = new_symbol (ccp, type, id); + SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); + } + break; + case CTF_K_STRUCT: + case CTF_K_UNION: + case CTF_K_ENUM: + if (!type) + { + complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id); + type = objfile_type (ccp->of)->builtin_error; + } + sym = allocate_symbol (ccp->of); + OBJSTAT (ccp->of, n_syms++); + SYMBOL_TYPE (sym) = type; + SYMBOL_DOMAIN (sym) = VAR_DOMAIN; + SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT; + SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); + add_symbol_to_list (sym, ccp->builder->get_global_symbols ()); + break; + default: + complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind); + break; + } + + if (sym) + { + set_symbol_address (ccp->of, sym, name); + } + + return 0; +} + +/* Add an ELF STT_OBJ symbol with index IDX to the symbol table. */ + +struct symbol * +add_stt_obj (ctf_context_t *ccp, unsigned long idx) +{ + const char *name; + struct symbol *sym; + struct type *type; + ctf_id_t tid; + + if ((tid = ctf_lookup_by_symbol (ccp->fp, idx)) == CTF_ERR) + return NULL; + + type = get_tid_type (ccp->of, tid); + if (type == NULL) + return NULL; + + name = ctf_type_aname_raw (ccp->fp, idx); + if (name == NULL) + return NULL; + sym = new_symbol (ccp, type, tid); + SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); + + return sym; +} + +/* Add an ELF STT_FUNC symbol with index IDX to the symbol table. */ + +struct symbol * +add_stt_func (ctf_context_t *ccp, unsigned long idx) +{ + struct type *ftype, *atyp, *rettyp; + const char *name; + struct symbol *sym; + ctf_funcinfo_t finfo; + ctf_id_t argv[32]; + uint32_t argc; + ctf_id_t tid; + struct type *void_type = objfile_type (ccp->of)->builtin_void; + + if (ctf_func_info (ccp->fp, idx, &finfo) == CTF_ERR) + return NULL; + + argc = finfo.ctc_argc; + if (ctf_func_args (ccp->fp, idx, argc, argv) == CTF_ERR) + return NULL; + + name = ctf_type_aname_raw (ccp->fp, idx); + if (name == NULL) + return NULL; + tid = ctf_lookup_by_symbol (ccp->fp, idx); + ftype = get_tid_type (ccp->of, tid); + if (finfo.ctc_flags & CTF_FUNC_VARARG) + TYPE_VARARGS (ftype) = 1; + TYPE_NFIELDS (ftype) = argc; + /* If argc is 0, it has a "void" type. */ + if (argc) + TYPE_FIELDS (ftype) = (struct field *) + TYPE_ZALLOC (ftype, argc * sizeof (struct field)); + + /* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed + to find the argument type. */ + for (int iparam = 0; iparam < argc; iparam++) + { + atyp = get_tid_type (ccp->of, argv[iparam]); + if (atyp) + TYPE_FIELD_TYPE (ftype, iparam) = atyp; + else + TYPE_FIELD_TYPE (ftype, iparam) = void_type; + } + + sym = new_symbol (ccp, ftype, tid); + rettyp = get_tid_type (ccp->of, finfo.ctc_return); + if (rettyp != NULL) + SYMBOL_TYPE (sym) = rettyp; + else + SYMBOL_TYPE (sym) = void_type; + SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of); + + return sym; +} + +/* Get text segment base for OBJFILE, TSIZE contains the segment size. */ + +static CORE_ADDR +get_of_text_range (struct objfile *of, int *tsize) +{ + CORE_ADDR text_base; + bfd *abfd = of->obfd; + const asection *codes; + + codes = bfd_get_section_by_name (abfd, ".text"); + if (!codes) + { + text_base = 0; + *tsize = 0; + } + else + { + text_base = bfd_section_vma (codes); + *tsize = codes->size; + } + + return text_base; +} + +/* Start a symtab for OBJFILE in CTF format. */ + +static void +ctf_start_symtab (struct partial_symtab *pst, + struct objfile *of, CORE_ADDR text_offset) +{ + ctf_context_t *ccp; + + ccp = (ctf_context_t *) pst->read_symtab_private; + ccp->builder = new struct buildsym_compunit + (of, of->original_name, NULL, + language_c, text_offset); + ccp->builder->record_debugformat ("ctf"); +} + +/* Finish reading symbol/type definitions in CTF format. + END_ADDR is the end address of the file's text. SECTION is + the .text section number. */ + +static struct compunit_symtab * +ctf_end_symtab (struct partial_symtab *pst, + CORE_ADDR end_addr, int section) +{ + ctf_context_t *ccp; + + ccp = (ctf_context_t *) pst->read_symtab_private; + struct compunit_symtab *result + = ccp->builder->end_symtab (end_addr, section); + delete ccp->builder; + ccp->builder = NULL; + return result; +} + +/* Read in full symbols for PST, and anything it depends on. */ + +static void +psymtab_to_symtab (struct partial_symtab *pst) +{ + struct symbol *sym; + ctf_context_t *ccp; + + if (pst->readin == 1) + return; + + ccp = (ctf_context_t *) pst->read_symtab_private; + + /* Iterate over entries in data types section. */ + if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR) + { + complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"), + ctf_errmsg (ctf_errno (ccp->fp))); + } + + + /* Iterate over entries in variable info section. */ + if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR) + { + complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"), + ctf_errmsg (ctf_errno (ccp->fp))); + } + + /* Add entries in data objects and function info sections. */ + for (unsigned long i = 0; ; i++) + { + sym = add_stt_obj (ccp, i); + if (!sym) + { + if (ctf_errno (ccp->fp) == EINVAL + || ctf_errno (ccp->fp) == ECTF_NOSYMTAB) + break; + sym = add_stt_func (ccp, i); + } + if (!sym) + continue; + + set_symbol_address (ccp->of, sym, SYMBOL_LINKAGE_NAME (sym)); + } + + pst->readin = 1; +} + +/* Expand partial symbol table PST into a full symbol table. + PST is not NULL. */ + +static void +ctf_read_symtab (struct partial_symtab *pst, + struct objfile *objfile) +{ + if (pst->readin) + { + warning (_("bug: psymtab for %s is already read in."), + pst->filename); + } + else + { + if (info_verbose) + { + printf_filtered (_("Reading in CTF data for %s..."), + pst->filename); + gdb_flush (gdb_stdout); + } + + /* Start a symtab. */ + CORE_ADDR text_offset; /* Start of text segment. */ + int tsize; + + text_offset = get_of_text_range (objfile, &tsize); + ctf_start_symtab (pst, objfile, text_offset); + psymtab_to_symtab (pst); + + pst->set_text_low (text_offset); + pst->set_text_high (text_offset+tsize); + pst->compunit_symtab = ctf_end_symtab (pst, text_offset + tsize, + SECT_OFF_TEXT (objfile)); + + /* Finish up the debug error message. */ + if (info_verbose) + printf_filtered (_("done.\n")); + } +} + +/* Cleanup function for the ctf_file_key data. */ + +static void +ctf_close_objfile (struct objfile *of, void *datum) +{ + ctf_file_t *fp = static_cast<ctf_file_t *> (datum); + ctf_archive_t *arc = ctf_get_arc (fp); + ctf_file_close (fp); + ctf_close (arc); +} + +/* Allocate a new partial_symtab NAME. */ +/* Each source file that has not been fully read in is represented by + a partial_symtab. This contains the information on where in the + executable the debugging symbols for a specific file are, and a + list of names of global symbols which are located in this file. + They are all chained on partial symtab lists. + + Even after the source file has been read into a symtab, the + partial_symtab remains around. They are allocated on an obstack, + objfile_obstack. */ + +static struct partial_symtab * +create_partial_symtab (const char *name, + ctf_file_t *cfp, + struct objfile *objfile) +{ + struct partial_symtab *pst; + static ctf_context_t ccx; + + pst = start_psymtab_common (objfile, name, 0); + + ccx.fp = cfp; + ccx.of = objfile; + pst->read_symtab_private = (void *)&ccx; + pst->read_symtab = ctf_read_symtab; + + return pst; +} + +/* Callback to add type TID to partial symbol table. */ + +static int +ctf_psymtab_type_cb (ctf_id_t tid, void *arg) +{ + ctf_context_t *ccp; + const char *name; + uint32_t kind; + short section = -1; + + ccp = (ctf_context_t *)arg; + name = ctf_type_aname_raw (ccp->fp, tid); + if (!name || (name && !strlen (name))) + return 0; + + domain_enum domain = UNDEF_DOMAIN; + enum address_class aclass = LOC_UNDEF; + kind = ctf_type_kind (ccp->fp, tid); + switch (kind) + { + case CTF_K_STRUCT: + case CTF_K_UNION: + case CTF_K_ENUM: + domain = STRUCT_DOMAIN; + aclass = LOC_TYPEDEF; + break; + case CTF_K_FUNCTION: + case CTF_K_FORWARD: + domain = VAR_DOMAIN; + aclass = LOC_STATIC; + section = SECT_OFF_TEXT (ccp->of); + break; + case CTF_K_CONST: + domain = VAR_DOMAIN; + aclass = LOC_STATIC; + break; + case CTF_K_TYPEDEF: + case CTF_K_POINTER: + case CTF_K_VOLATILE: + case CTF_K_RESTRICT: + domain = VAR_DOMAIN; + aclass = LOC_TYPEDEF; + break; + case CTF_K_INTEGER: + case CTF_K_FLOAT: + domain = VAR_DOMAIN; + aclass = LOC_TYPEDEF; + break; + case CTF_K_ARRAY: + case CTF_K_UNKNOWN: + return 0; + } + + add_psymbol_to_list (name, strlen (name), 1, + domain, aclass, section, + psymbol_placement::GLOBAL, + 0, language_c, ccp->of); + + return 0; +} + +/* Callback to add variable NAME with ID to partial symbol table. */ + +static int +ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg) +{ + ctf_context_t *ccp = (ctf_context_t *) arg; + + add_psymbol_to_list (name, strlen (name), 1, + VAR_DOMAIN, LOC_STATIC, -1, + psymbol_placement::GLOBAL, + 0, language_c, ccp->of); + return 0; +} + +/* Setup partial_symtab's describing each source file for which + debugging information is available. */ + +static void +scan_partial_symbols (ctf_file_t *cfp, struct objfile *of) +{ + ctf_context_t ccx; + bfd *abfd = of->obfd; + const char *name = bfd_get_filename (abfd); + struct partial_symtab *pst = create_partial_symtab (name, cfp, of); + + ccx.fp = cfp; + ccx.of = of; + if (ctf_type_iter (cfp, ctf_psymtab_type_cb, &ccx) == CTF_ERR) + { + complaint (_("ctf_type_iter scan_partial_symbols failed - %s"), + ctf_errmsg (ctf_errno (cfp))); + } + + if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, &ccx) == CTF_ERR) + { + complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"), + ctf_errmsg (ctf_errno (cfp))); + } + + /* Scan CTF object and function sections which correspond to each + STT_FUNC or STT_OBJECT entry in the symbol table, + pick up what init_symtab has done. */ + for (unsigned long idx = 0; ; idx++) + { + ctf_id_t tid; + if ((tid = ctf_lookup_by_symbol (cfp, idx)) == CTF_ERR) + { + if (ctf_errno (cfp) == EINVAL + || ctf_errno (cfp) == ECTF_NOSYMTAB) + // case ECTF_SYMRANGE: + break; + else + continue; + } + const char *tname = ctf_type_aname_raw (cfp, tid); + uint32_t kind = ctf_type_kind (cfp, tid); + address_class aclass; + domain_enum tdomain; + switch (kind) + { + case CTF_K_STRUCT: + case CTF_K_UNION: + case CTF_K_ENUM: + tdomain = STRUCT_DOMAIN; + break; + default: + tdomain = VAR_DOMAIN; + break; + } + + if (kind == CTF_K_FUNCTION) + aclass = LOC_STATIC; + else if (kind == CTF_K_CONST) + aclass = LOC_CONST; + else + aclass = LOC_TYPEDEF; + + add_psymbol_to_list (tname, strlen (name), 1, + tdomain, aclass, -1, + psymbol_placement::STATIC, + 0, language_c, of); + } + + end_psymtab_common (of, pst); +} + +/* Read CTF debugging information from a BFD section. This is + called from elfread.c. It does a quick pass through the + .ctf section to set up the partial symbol table. */ + +void +elfctf_build_psymtabs (struct objfile *of) +{ + bfd *abfd = of->obfd; + int err; + + ctf_archive_t *arc = ctf_bfdopen (abfd, &err); + if (!arc) + error (_("ctf_bfdopen failed on %s - %s"), + bfd_get_filename (abfd), ctf_errmsg (err)); + + ctf_file_t *fp = ctf_arc_open_by_name (arc, NULL, &err); + if (!fp) + error (_("ctf_arc_open_by_name failed on %s - %s"), + bfd_get_filename (abfd), ctf_errmsg (err)); + set_objfile_data (of, ctf_file_key, fp); + + scan_partial_symbols (fp, of); +} + +void +_initialize_ctfread (void) +{ + ctf_file_key + = register_objfile_data_with_cleanup (NULL, ctf_close_objfile); +} |