using ctf_type_map = gdb::unordered_map<ctf_id_t, struct type *>;
-struct ctf_fp_info
+struct ctf_dict_info
{
- explicit ctf_fp_info (ctf_dict_t *cfp) : fp (cfp) {}
- ~ctf_fp_info ();
+ explicit ctf_dict_info (ctf_dict_t *dict) : dict (dict) {}
+ ~ctf_dict_info ();
/* Map from IDs to types. */
ctf_type_map type_map;
/* The dictionary. */
- ctf_dict_t *fp;
+ ctf_dict_t *dict;
};
/* Cleanup function for the ctf_dict_key data. */
-ctf_fp_info::~ctf_fp_info ()
+ctf_dict_info::~ctf_dict_info ()
{
- if (fp == nullptr)
+ if (dict == nullptr)
return;
- ctf_archive_t *arc = ctf_get_arc (fp);
- ctf_dict_close (fp);
+ ctf_archive_t *arc = ctf_get_arc (dict);
+ ctf_dict_close (dict);
ctf_close (arc);
}
-static const registry<objfile>::key<ctf_fp_info> ctf_dict_key;
+static const registry<objfile>::key<ctf_dict_info> ctf_dict_key;
/* A CTF context consists of a file pointer and an objfile pointer. */
struct ctf_context
{
- ctf_dict_t *fp;
+ ctf_dict_t *dict;
struct objfile *of;
psymtab_storage *partial_symtabs;
partial_symtab *pst;
struct ctf_per_tu_data
{
- ctf_dict_t *fp;
+ ctf_dict_t *dict;
struct objfile *of;
ctf_archive_t *arc;
psymbol_functions *psf;
static struct type *
set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
{
- ctf_fp_info *info = ctf_dict_key.get (of);
+ ctf_dict_info *info = ctf_dict_key.get (of);
gdb_assert (info != nullptr);
info->type_map.emplace (tid, typ);
return typ;
static struct type *
get_tid_type (struct objfile *of, ctf_id_t tid)
{
- ctf_fp_info *info = ctf_dict_key.get (of);
+ ctf_dict_info *info = ctf_dict_key.get (of);
gdb_assert (info != nullptr);
auto iter = info->type_map.find (tid);
/* Return the size of storage in bits for INTEGER, FLOAT, or ENUM. */
static int
-get_bitsize (ctf_dict_t *fp, ctf_id_t tid, uint32_t kind)
+get_bitsize (ctf_dict_t *dict, 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)
+ && ctf_type_reference (dict, tid) != CTF_ERR
+ && ctf_type_encoding (dict, tid, &cet) != CTF_ERR)
return cet.cte_bits;
return 0;
fp = &new_field.field;
fp->set_name (name);
- kind = ctf_type_kind (ccp->fp, tid);
+ kind = ctf_type_kind (ccp->dict, tid);
t = fetch_tid_type (ccp, tid);
if (t == nullptr)
{
fp->set_type (t);
fp->set_loc_bitpos (offset / TARGET_CHAR_BIT);
- fp->set_bitsize (get_bitsize (ccp->fp, tid, kind));
+ fp->set_bitsize (get_bitsize (ccp->dict, tid, kind));
fip->fields.emplace_back (new_field);
static void
new_type_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
{
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
- const char *name = ctf_type_name_raw (fp, tid);
+ const char *name = ctf_type_name_raw (dict, tid);
if (name != nullptr && *name != '\0')
{
struct objfile *objfile = ccp->of;
if (type != nullptr)
sym->set_type (type);
- uint32_t kind = ctf_type_kind (fp, tid);
+ uint32_t kind = ctf_type_kind (dict, tid);
switch (kind)
{
case CTF_K_STRUCT:
read_base_type (struct ctf_context *ccp, ctf_id_t tid)
{
struct objfile *of = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
ctf_encoding_t cet;
struct type *type = nullptr;
const char *name;
uint32_t kind;
- if (ctf_type_encoding (fp, tid, &cet))
+ if (ctf_type_encoding (dict, tid, &cet))
{
complaint (_("ctf_type_encoding read_base_type failed - %s"),
- ctf_errmsg (ctf_errno (fp)));
+ ctf_errmsg (ctf_errno (dict)));
return nullptr;
}
- name = ctf_type_name_raw (fp, tid);
+ name = ctf_type_name_raw (dict, tid);
if (name == nullptr || *name == '\0')
{
- name = ctf_type_aname (fp, tid);
+ name = ctf_type_aname (dict, tid);
if (name == nullptr || *name == '\0')
complaint (_("ctf_type_aname read_base_type failed - %s"),
- ctf_errmsg (ctf_errno (fp)));
+ ctf_errmsg (ctf_errno (dict)));
}
type_allocator alloc (of, language_c);
- kind = ctf_type_kind (fp, tid);
+ kind = ctf_type_kind (dict, tid);
if (kind == CTF_K_INTEGER)
{
uint32_t issigned, ischar, isbool;
read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
{
struct objfile *of = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
struct type *type;
uint32_t kind;
type = type_allocator (of, language_c).new_type ();
- const char *name = ctf_type_name_raw (fp, tid);
+ const char *name = ctf_type_name_raw (dict, tid);
if (name != nullptr && *name != '\0')
type->set_name (name);
- kind = ctf_type_kind (fp, tid);
+ kind = ctf_type_kind (dict, tid);
if (kind == CTF_K_UNION)
type->set_code (TYPE_CODE_UNION);
else
type->set_code (TYPE_CODE_STRUCT);
- type->set_length (ctf_type_size (fp, tid));
- set_type_align (type, ctf_type_align (fp, tid));
+ type->set_length (ctf_type_size (dict, tid));
+ set_type_align (type, ctf_type_align (dict, tid));
return set_tid_type (ccp->of, tid, type);
}
struct ctf_field_info fi;
fi.cur_context = ccp;
- if (ctf_member_iter (ccp->fp, tid, ctf_add_member_cb, &fi) == CTF_ERR)
+ if (ctf_member_iter (ccp->dict, tid, ctf_add_member_cb, &fi) == CTF_ERR)
complaint (_("ctf_member_iter process_struct_members failed - %s"),
- ctf_errmsg (ctf_errno (ccp->fp)));
+ ctf_errmsg (ctf_errno (ccp->dict)));
/* Attach fields to the type. */
attach_fields_to_type (&fi, type);
read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
{
struct objfile *of = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
struct type *type, *rettype, *atype;
ctf_funcinfo_t cfi;
uint32_t argc;
type = type_allocator (of, language_c).new_type ();
type->set_code (TYPE_CODE_FUNC);
- if (ctf_func_type_info (fp, tid, &cfi) < 0)
+ if (ctf_func_type_info (dict, tid, &cfi) < 0)
{
- const char *fname = ctf_type_name_raw (fp, tid);
+ const char *fname = ctf_type_name_raw (dict, tid);
error (_("Error getting function type info: %s"),
fname == nullptr ? "noname" : fname);
}
rettype = fetch_tid_type (ccp, cfi.ctc_return);
type->set_target_type (rettype);
- set_type_align (type, ctf_type_align (fp, tid));
+ set_type_align (type, ctf_type_align (dict, tid));
/* Set up function's arguments. */
argc = cfi.ctc_argc;
if (argc != 0)
{
std::vector<ctf_id_t> argv (argc);
- if (ctf_func_type_args (fp, tid, argc, argv.data ()) == CTF_ERR)
+ if (ctf_func_type_args (dict, tid, argc, argv.data ()) == CTF_ERR)
return nullptr;
type->alloc_fields (argc);
read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
{
struct objfile *of = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
struct type *type;
type = type_allocator (of, language_c).new_type ();
- const char *name = ctf_type_name_raw (fp, tid);
+ const char *name = ctf_type_name_raw (dict, tid);
if (name != nullptr && *name != '\0')
type->set_name (name);
type->set_code (TYPE_CODE_ENUM);
- type->set_length (ctf_type_size (fp, tid));
+ type->set_length (ctf_type_size (dict, tid));
/* Set the underlying type based on its ctf_type_size bits. */
type->set_target_type (objfile_int_type (of, type->length (), false));
- set_type_align (type, ctf_type_align (fp, tid));
+ set_type_align (type, ctf_type_align (dict, tid));
return set_tid_type (of, tid, type);
}
fi.cur_context = ccp;
fi.ptype = type;
- if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
+ if (ctf_enum_iter (ccp->dict, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
complaint (_("ctf_enum_iter process_enum_type failed - %s"),
- ctf_errmsg (ctf_errno (ccp->fp)));
+ ctf_errmsg (ctf_errno (ccp->dict)));
/* Attach fields to the type. */
attach_fields_to_type (&fi, type);
read_array_type (struct ctf_context *ccp, ctf_id_t tid)
{
struct objfile *objfile = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
struct type *element_type, *range_type, *idx_type;
struct type *type;
ctf_arinfo_t ar;
- if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
+ if (ctf_array_info (dict, tid, &ar) == CTF_ERR)
{
complaint (_("ctf_array_info read_array_type failed - %s"),
- ctf_errmsg (ctf_errno (fp)));
+ ctf_errmsg (ctf_errno (dict)));
return nullptr;
}
type->set_target_is_stub (true);
}
else
- type->set_length (ctf_type_size (fp, tid));
+ type->set_length (ctf_type_size (dict, tid));
- set_type_align (type, ctf_type_align (fp, tid));
+ set_type_align (type, ctf_type_align (dict, tid));
return set_tid_type (objfile, tid, type);
}
read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
{
struct objfile *objfile = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
struct type *base_type, *cv_type;
base_type = fetch_tid_type (ccp, btid);
}
}
- if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
+ if (ctf_type_kind (dict, 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);
}
type = lookup_pointer_type (target_type);
- set_type_align (type, ctf_type_align (ccp->fp, tid));
+ set_type_align (type, ctf_type_align (ccp->dict, tid));
return set_tid_type (of, tid, type);
}
read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
{
struct objfile *of = ccp->of;
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
struct type *type;
uint32_t kind;
type = type_allocator (of, language_c).new_type ();
- const char *name = ctf_type_name_raw (fp, tid);
+ const char *name = ctf_type_name_raw (dict, tid);
if (name != nullptr && *name != '\0')
type->set_name (name);
- kind = ctf_type_kind_forwarded (fp, tid);
+ kind = ctf_type_kind_forwarded (dict, tid);
if (kind == CTF_K_UNION)
type->set_code (TYPE_CODE_UNION);
else
static struct type *
read_type_record (struct ctf_context *ccp, ctf_id_t tid)
{
- ctf_dict_t *fp = ccp->fp;
+ ctf_dict_t *dict = ccp->dict;
uint32_t kind;
struct type *type = nullptr;
ctf_id_t btid;
- kind = ctf_type_kind (fp, tid);
+ kind = ctf_type_kind (dict, tid);
switch (kind)
{
case CTF_K_STRUCT:
type = read_func_kind_type (ccp, tid);
break;
case CTF_K_CONST:
- btid = ctf_type_reference (fp, tid);
+ btid = ctf_type_reference (dict, tid);
type = read_const_type (ccp, tid, btid);
break;
case CTF_K_TYPEDEF:
{
- const char *name = ctf_type_name_raw (fp, tid);
- btid = ctf_type_reference (fp, tid);
+ const char *name = ctf_type_name_raw (dict, tid);
+ btid = ctf_type_reference (dict, tid);
type = read_typedef_type (ccp, tid, btid, name);
}
break;
case CTF_K_VOLATILE:
- btid = ctf_type_reference (fp, tid);
+ btid = ctf_type_reference (dict, tid);
type = read_volatile_type (ccp, tid, btid);
break;
case CTF_K_RESTRICT:
- btid = ctf_type_reference (fp, tid);
+ btid = ctf_type_reference (dict, tid);
type = read_restrict_type (ccp, tid, btid);
break;
case CTF_K_POINTER:
- btid = ctf_type_reference (fp, tid);
+ btid = ctf_type_reference (dict, tid);
type = read_pointer_type (ccp, tid, btid);
break;
case CTF_K_INTEGER:
if (type != nullptr)
return 0;
- ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
- kind = ctf_type_kind (ccp->fp, tid);
+ ctf_id_t btid = ctf_type_reference (ccp->dict, tid);
+ kind = ctf_type_kind (ccp->dict, tid);
switch (kind)
{
case CTF_K_STRUCT:
type = get_tid_type (ccp->of, id);
- kind = ctf_type_kind (ccp->fp, id);
+ kind = ctf_type_kind (ccp->dict, id);
if (type == nullptr)
{
struct symbol *sym = nullptr;
struct type *type;
- while ((tid = ctf_symbol_next (ccp->fp, &i, &tname, functions)) != CTF_ERR)
+ while ((tid = ctf_symbol_next (ccp->dict, &i, &tname, functions)) != CTF_ERR)
{
type = get_tid_type (ccp->of, tid);
if (type == nullptr)
const char *ename;
ctf_next_t *i = nullptr;
- while ((ename = ctf_enum_next (ccp->fp, tid, &i, &val)) != nullptr)
+ while ((ename = ctf_enum_next (ccp->dict, tid, &i, &val)) != nullptr)
{
ccp->pst->add_psymbol (ename, true,
VAR_DOMAIN, LOC_CONST, -1,
unrelocated_addr (0),
language_c, ccp->partial_symtabs, ccp->of);
}
- if (ctf_errno (ccp->fp) != ECTF_NEXT_END)
+ if (ctf_errno (ccp->dict) != ECTF_NEXT_END)
complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
- ctf_errmsg (ctf_errno (ccp->fp)));
+ ctf_errmsg (ctf_errno (ccp->dict)));
}
/* Add entries in either data objects or function info section, controlled
by FUNCTIONS, to psymtab. */
static void
-ctf_psymtab_add_stt_entries (ctf_dict_t *cfp, ctf_psymtab *pst,
+ctf_psymtab_add_stt_entries (ctf_dict_t *dict, ctf_psymtab *pst,
struct objfile *of, int functions)
{
ctf_next_t *i = nullptr;
ctf_id_t tid;
const char *tname;
- while ((tid = ctf_symbol_next (cfp, &i, &tname, functions)) != CTF_ERR)
+ while ((tid = ctf_symbol_next (dict, &i, &tname, functions)) != CTF_ERR)
{
- uint32_t kind = ctf_type_kind (cfp, tid);
+ uint32_t kind = ctf_type_kind (dict, tid);
location_class loc_class;
domain_enum tdomain = functions ? FUNCTION_DOMAIN : VAR_DOMAIN;
/* Add entries in data objects section to psymtab. */
static void
-ctf_psymtab_add_stt_obj (ctf_dict_t *cfp, ctf_psymtab *pst,
+ctf_psymtab_add_stt_obj (ctf_dict_t *dict, ctf_psymtab *pst,
struct objfile *of)
{
- ctf_psymtab_add_stt_entries (cfp, pst, of, 0);
+ ctf_psymtab_add_stt_entries (dict, pst, of, 0);
}
/* Add entries in function info section to psymtab. */
static void
-ctf_psymtab_add_stt_func (ctf_dict_t *cfp, ctf_psymtab *pst,
+ctf_psymtab_add_stt_func (ctf_dict_t *dict, ctf_psymtab *pst,
struct objfile *of)
{
- ctf_psymtab_add_stt_entries (cfp, pst, of, 1);
+ ctf_psymtab_add_stt_entries (dict, pst, of, 1);
}
/* Read in full symbols for PST, and anything it depends on. */
ccp = &context;
/* Iterate over entries in data types section. */
- if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
+ if (ctf_type_iter (ccp->dict, ctf_add_type_cb, ccp) == CTF_ERR)
complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
- ctf_errmsg (ctf_errno (ccp->fp)));
+ ctf_errmsg (ctf_errno (ccp->dict)));
/* Iterate over entries in variable info section. */
- if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
+ if (ctf_variable_iter (ccp->dict, ctf_add_var_cb, ccp) == CTF_ERR)
complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
- ctf_errmsg (ctf_errno (ccp->fp)));
+ ctf_errmsg (ctf_errno (ccp->dict)));
/* Add entries in data objects and function info sections. */
add_stt_obj (ccp);
static ctf_psymtab *
create_partial_symtab (const char *name,
ctf_archive_t *arc,
- ctf_dict_t *cfp,
+ ctf_dict_t *dict,
psymtab_storage *partial_symtabs,
struct objfile *objfile)
{
unrelocated_addr (0));
pst->context.arc = arc;
- pst->context.fp = cfp;
+ pst->context.dict = dict;
pst->context.of = objfile;
pst->context.partial_symtabs = partial_symtabs;
pst->context.pst = pst;
domain_enum domain = UNDEF_DOMAIN;
location_class loc_class = LOC_UNDEF;
- kind = ctf_type_kind (ccp->fp, tid);
+ kind = ctf_type_kind (ccp->dict, tid);
switch (kind)
{
case CTF_K_ENUM:
return 0;
}
- const char *name = ctf_type_name_raw (ccp->fp, tid);
+ const char *name = ctf_type_name_raw (ccp->dict, tid);
if (name == nullptr || *name == '\0')
return 0;
{
struct ctf_context *ccp = (struct ctf_context *) arg;
- uint32_t kind = ctf_type_kind (ccp->fp, id);
+ uint32_t kind = ctf_type_kind (ccp->dict, id);
ccp->pst->add_psymbol (name, true,
kind == CTF_K_FUNCTION
? FUNCTION_DOMAIN
debugging information is available. */
static void
-scan_partial_symbols (ctf_dict_t *cfp, psymtab_storage *partial_symtabs,
+scan_partial_symbols (ctf_dict_t *dict, psymtab_storage *partial_symtabs,
struct ctf_per_tu_data *tup, const char *fname)
{
struct objfile *of = tup->of;
isparent = true;
}
- ctf_psymtab *pst = create_partial_symtab (fname, tup->arc, cfp,
+ ctf_psymtab *pst = create_partial_symtab (fname, tup->arc, dict,
partial_symtabs, of);
struct ctf_context *ccx = &pst->context;
if (isparent == false)
ccx->pst = pst;
- if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
+ if (ctf_type_iter (dict, ctf_psymtab_type_cb, ccx) == CTF_ERR)
complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
- ctf_errmsg (ctf_errno (cfp)));
+ ctf_errmsg (ctf_errno (dict)));
- if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
+ if (ctf_variable_iter (dict, ctf_psymtab_var_cb, ccx) == CTF_ERR)
complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
- ctf_errmsg (ctf_errno (cfp)));
+ ctf_errmsg (ctf_errno (dict)));
/* 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. */
- ctf_psymtab_add_stt_obj (cfp, pst, of);
- ctf_psymtab_add_stt_func (cfp, pst, of);
+ ctf_psymtab_add_stt_obj (dict, pst, of);
+ ctf_psymtab_add_stt_func (dict, pst, of);
pst->end ();
}
build_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
{
struct ctf_per_tu_data *tup = (struct ctf_per_tu_data *) arg;
- ctf_dict_t *parent = tup->fp;
+ ctf_dict_t *parent = tup->dict;
if (strcmp (name, ".ctf") != 0)
ctf_import (ctf, parent);
error (_("ctf_bfdopen failed on %s - %s"),
bfd_get_filename (abfd), ctf_errmsg (err));
- ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
- if (fp == nullptr)
+ ctf_dict_t *dict = ctf_dict_open (arc, NULL, &err);
+ if (dict == nullptr)
error (_("ctf_dict_open failed on %s - %s"),
bfd_get_filename (abfd), ctf_errmsg (err));
- ctf_dict_key.emplace (of, fp);
+ ctf_dict_key.emplace (of, dict);
- pcu.fp = fp;
+ pcu.dict = dict;
pcu.of = of;
pcu.arc = arc;
projects / thirdparty / binutils-gdb.git / commitdiff
