From: Tom Tromey Date: Tue, 23 Sep 2025 00:33:54 +0000 (-0600) Subject: Rename "fp" in ctfread.c X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=d8f40958cb68608afbf8128d51797f1ff468f854;p=thirdparty%2Fbinutils-gdb.git Rename "fp" in ctfread.c Earlier reviews pointed out that "fp" is a poor choice of name in ctfread.c. Nick suggested "dict" instead, so this patch makes this change. --- diff --git a/gdb/ctfread.c b/gdb/ctfread.c index 3ac56fdd282..860894bf0a0 100644 --- a/gdb/ctfread.c +++ b/gdb/ctfread.c @@ -88,36 +88,36 @@ using ctf_type_map = gdb::unordered_map; -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::key ctf_dict_key; +static const registry::key 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; @@ -175,7 +175,7 @@ struct ctf_field_info struct ctf_per_tu_data { - ctf_dict_t *fp; + ctf_dict_t *dict; struct objfile *of; ctf_archive_t *arc; psymbol_functions *psf; @@ -211,7 +211,7 @@ static struct type *read_forward_type (struct ctf_context *cp, ctf_id_t tid); 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; @@ -223,7 +223,7 @@ set_tid_type (struct objfile *of, ctf_id_t tid, struct type *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); @@ -254,14 +254,14 @@ fetch_tid_type (struct ctf_context *ccp, ctf_id_t 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; @@ -347,7 +347,7 @@ ctf_add_member_cb (const char *name, 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) { @@ -365,7 +365,7 @@ ctf_add_member_cb (const char *name, 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); @@ -413,9 +413,9 @@ ctf_add_enum_member_cb (const char *name, int enum_value, void *arg) 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; @@ -430,7 +430,7 @@ new_type_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid) 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: @@ -451,30 +451,30 @@ static struct type * 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; @@ -545,24 +545,24 @@ static struct type * 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); } @@ -578,9 +578,9 @@ process_struct_members (struct ctf_context *ccp, 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); @@ -603,7 +603,7 @@ static struct 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; @@ -611,15 +611,15 @@ read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid) 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; @@ -630,7 +630,7 @@ read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid) if (argc != 0) { std::vector 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); @@ -656,20 +656,20 @@ static struct type * 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); } @@ -684,9 +684,9 @@ process_enum_type (struct ctf_context *ccp, ctf_id_t tid) 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); @@ -728,15 +728,15 @@ static struct 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; } @@ -758,9 +758,9 @@ read_array_type (struct ctf_context *ccp, ctf_id_t tid) 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); } @@ -794,7 +794,7 @@ static struct 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); @@ -808,7 +808,7 @@ read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t 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); @@ -882,7 +882,7 @@ read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid) } 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); } @@ -893,17 +893,17 @@ static struct 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 @@ -920,12 +920,12 @@ read_forward_type (struct ctf_context *ccp, ctf_id_t tid) 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: @@ -939,26 +939,26 @@ read_type_record (struct ctf_context *ccp, ctf_id_t tid) 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: @@ -994,8 +994,8 @@ ctf_add_type_cb (ctf_id_t tid, void *arg) 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: @@ -1057,7 +1057,7 @@ ctf_add_var_cb (const char *name, ctf_id_t id, void *arg) type = get_tid_type (ccp->of, id); - kind = ctf_type_kind (ccp->fp, id); + kind = ctf_type_kind (ccp->dict, id); if (type == nullptr) { @@ -1097,7 +1097,7 @@ add_stt_entries (struct ctf_context *ccp, int functions) 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) @@ -1151,7 +1151,7 @@ ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid) 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, @@ -1159,25 +1159,25 @@ ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid) 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; @@ -1197,19 +1197,19 @@ ctf_psymtab_add_stt_entries (ctf_dict_t *cfp, ctf_psymtab *pst, /* 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. */ @@ -1224,15 +1224,15 @@ ctf_psymtab::expand_psymtab (struct objfile *objfile) 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); @@ -1296,7 +1296,7 @@ ctf_psymtab::read_symtab (struct objfile *objfile) 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) { @@ -1306,7 +1306,7 @@ create_partial_symtab (const char *name, 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; @@ -1328,7 +1328,7 @@ ctf_psymtab_type_cb (ctf_id_t tid, void *arg) 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: @@ -1356,7 +1356,7 @@ ctf_psymtab_type_cb (ctf_id_t tid, void *arg) 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; @@ -1376,7 +1376,7 @@ ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg) { 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 @@ -1392,7 +1392,7 @@ ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg) 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; @@ -1404,26 +1404,26 @@ scan_partial_symbols (ctf_dict_t *cfp, psymtab_storage *partial_symtabs, 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 (); } @@ -1434,7 +1434,7 @@ static int 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); @@ -1467,13 +1467,13 @@ elfctf_build_psymtabs (struct objfile *of) 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;