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.

gdb/ctfread.c

@@ -88,36 +88,36 @@
 
 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;
@@ -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<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);
@@ -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;