public inbox for gdb-patches@sourceware.org
 help / color / mirror / Atom feed
* [PATCH 1/4] gdb: add type::target_type / type::set_target_type
@ 2022-09-16 15:08 Simon Marchi
  2022-09-16 15:08 ` [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE Simon Marchi
                   ` (4 more replies)
  0 siblings, 5 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-16 15:08 UTC (permalink / raw)
  To: gdb-patches

From: Simon Marchi <simon.marchi@polymtl.ca>

Add the `target_type` and `set_target_type` methods on `struct type`, in order
to remove the `TYPE_TARGET_TYPE` macro.  In this patch, the macro is changed to
use the getter, so all the call sites of the macro that are used as a setter
are changed to use the setter method directly.  The next patch will remove the
macro completely.

Change-Id: I85ce24d847763badd34fdee3e14b8c8c14cb3161
---
 gdb/ada-lang.c     |  9 ++++----
 gdb/ctfread.c      | 13 ++++++-----
 gdb/dwarf2/read.c  | 13 ++++++-----
 gdb/fbsd-tdep.c    |  4 ++--
 gdb/gdbtypes.c     | 54 +++++++++++++++++++++++-----------------------
 gdb/gdbtypes.h     | 14 ++++++++++--
 gdb/linux-tdep.c   |  6 +++---
 gdb/netbsd-tdep.c  |  8 +++----
 gdb/stabsread.c    |  2 +-
 gdb/windows-tdep.c |  8 +++----
 10 files changed, 70 insertions(+), 61 deletions(-)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index d49baf99005..c5657d9d03a 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -8114,7 +8114,7 @@ template_to_static_fixed_type (struct type *type0)
 
   /* Whether or not we cloned TYPE0, cache the result so that we don't do
      recompute all over next time.  */
-  TYPE_TARGET_TYPE (type0) = type;
+  type0->set_target_type (type);
 
   for (f = 0; f < nfields; f += 1)
     {
@@ -8134,7 +8134,8 @@ template_to_static_fixed_type (struct type *type0)
 	  /* Clone TYPE0 only the first time we get a new field type.  */
 	  if (type == type0)
 	    {
-	      TYPE_TARGET_TYPE (type0) = type = alloc_type_copy (type0);
+	      type = alloc_type_copy (type0);
+	      type0->set_target_type (type);
 	      type->set_code (type0->code ());
 	      INIT_NONE_SPECIFIC (type);
 	      type->set_num_fields (nfields);
@@ -10278,8 +10279,8 @@ ada_ternop_slice (struct expression *exp,
      the aligners.  */
   if (value_type (array)->code () == TYPE_CODE_REF
       && ada_is_aligner_type (TYPE_TARGET_TYPE (value_type (array))))
-    TYPE_TARGET_TYPE (value_type (array)) =
-      ada_aligned_type (TYPE_TARGET_TYPE (value_type (array)));
+    value_type (array)->set_target_type
+      (ada_aligned_type (TYPE_TARGET_TYPE (value_type (array))));
 
   if (ada_is_any_packed_array_type (value_type (array)))
     error (_("cannot slice a packed array"));
diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index 9436ce55fc7..b37030b3295 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -698,7 +698,7 @@ read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
 	     fname == nullptr ? "noname" : fname);
     }
   rettype = fetch_tid_type (ccp, cfi.ctc_return);
-  TYPE_TARGET_TYPE (type) = rettype;
+  type->set_target_type (rettype);
   set_type_align (type, ctf_type_align (fp, tid));
 
   /* Set up function's arguments.  */
@@ -749,7 +749,7 @@ read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
   type->set_code (TYPE_CODE_ENUM);
   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
   /* Set the underlying type based on its ctf_type_size bits.  */
-  TYPE_TARGET_TYPE (type) = objfile_int_type (of, TYPE_LENGTH (type), false);
+  type->set_target_type (objfile_int_type (of, TYPE_LENGTH (type), false));
   set_type_align (type, ctf_type_align (fp, tid));
 
   return set_tid_type (of, tid, type);
@@ -791,15 +791,14 @@ add_array_cv_type (struct ctf_context *ccp,
 
   while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
     {
-      TYPE_TARGET_TYPE (inner_array)
-	= copy_type (TYPE_TARGET_TYPE (inner_array));
+      inner_array->set_target_type (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, nullptr);
+  inner_array->set_target_type (make_cv_type (cnst, voltl, el_type, nullptr));
 
   return set_tid_type (ccp->of, tid, base_type);
 }
@@ -933,9 +932,9 @@ read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
   set_tid_type (objfile, tid, this_type);
   target_type = fetch_tid_type (ccp, btid);
   if (target_type != this_type)
-    TYPE_TARGET_TYPE (this_type) = target_type;
+    this_type->set_target_type (target_type);
   else
-    TYPE_TARGET_TYPE (this_type) = nullptr;
+    this_type->set_target_type (nullptr);
 
   this_type->set_target_is_stub (TYPE_TARGET_TYPE (this_type) != nullptr);
 
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 29ccd00a1da..7ef0c1957a7 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -14380,7 +14380,7 @@ rewrite_array_type (struct type *type)
   memcpy (new_fields, copy->fields (), nfields * sizeof (struct field));
   copy->set_fields (new_fields);
   if (new_target != nullptr)
-    TYPE_TARGET_TYPE (copy) = new_target;
+    copy->set_target_type (new_target);
 
   struct type *index_copy = copy_type (index_type);
   range_bounds *bounds
@@ -15196,7 +15196,7 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
     {
       struct type *underlying_type = die_type (die, cu);
 
-      TYPE_TARGET_TYPE (type) = underlying_type;
+      type->set_target_type (underlying_type);
     }
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
@@ -16286,15 +16286,14 @@ add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
 
   while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
     {
-      TYPE_TARGET_TYPE (inner_array) =
-	copy_type (TYPE_TARGET_TYPE (inner_array));
+      inner_array->set_target_type (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);
+  inner_array->set_target_type (make_cv_type (cnst, voltl, el_type, NULL));
 
   return set_die_type (die, base_type, cu);
 }
@@ -16675,7 +16674,7 @@ read_typedef (struct die_info *die, struct dwarf2_cu *cu)
   set_die_type (die, this_type, cu);
   target_type = die_type (die, cu);
   if (target_type != this_type)
-    TYPE_TARGET_TYPE (this_type) = target_type;
+    this_type->set_target_type (target_type);
   else
     {
       /* Self-referential typedefs are, it seems, not allowed by the DWARF
@@ -16683,7 +16682,7 @@ read_typedef (struct die_info *die, struct dwarf2_cu *cu)
       complaint (_("Self-referential DW_TAG_typedef "
 		   "- DIE at %s [in module %s]"),
 		 sect_offset_str (die->sect_off), objfile_name (objfile));
-      TYPE_TARGET_TYPE (this_type) = NULL;
+      this_type->set_target_type (nullptr);
     }
   if (name == NULL)
     {
diff --git a/gdb/fbsd-tdep.c b/gdb/fbsd-tdep.c
index 3a2dbbe6f88..5eec49b62c7 100644
--- a/gdb/fbsd-tdep.c
+++ b/gdb/fbsd-tdep.c
@@ -1609,14 +1609,14 @@ fbsd_get_siginfo_type (struct gdbarch *gdbarch)
   /* __pid_t */
   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
-  TYPE_TARGET_TYPE (pid_type) = int32_type;
+  pid_type->set_target_type (int32_type);
   pid_type->set_target_is_stub (true);
 
   /* __uid_t */
   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
 			"__uid_t");
-  TYPE_TARGET_TYPE (uid_type) = uint32_type;
+  uid_type->set_target_type (uint32_type);
   pid_type->set_target_is_stub (true);
 
   /* _reason */
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index c458b204157..12fc12dd0ac 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -371,7 +371,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
       TYPE_CHAIN (ntype) = chain;
     }
 
-  TYPE_TARGET_TYPE (ntype) = type;
+  ntype->set_target_type (type);
   TYPE_POINTER_TYPE (type) = ntype;
 
   /* FIXME!  Assumes the machine has only one representation for pointers!  */
@@ -449,7 +449,7 @@ make_reference_type (struct type *type, struct type **typeptr,
       TYPE_CHAIN (ntype) = chain;
     }
 
-  TYPE_TARGET_TYPE (ntype) = type;
+  ntype->set_target_type (type);
   reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type)
 	     : &TYPE_RVALUE_REFERENCE_TYPE (type));
 
@@ -522,7 +522,7 @@ make_function_type (struct type *type, struct type **typeptr)
       smash_type (ntype);
     }
 
-  TYPE_TARGET_TYPE (ntype) = type;
+  ntype->set_target_type (type);
 
   TYPE_LENGTH (ntype) = 1;
   ntype->set_code (TYPE_CODE_FUNC);
@@ -876,7 +876,7 @@ allocate_stub_method (struct type *type)
   mtype->set_code (TYPE_CODE_METHOD);
   TYPE_LENGTH (mtype) = 1;
   mtype->set_is_stub (true);
-  TYPE_TARGET_TYPE (mtype) = type;
+  mtype->set_target_type (type);
   /* TYPE_SELF_TYPE (mtype) = unknown yet */
   return mtype;
 }
@@ -941,7 +941,7 @@ create_range_type (struct type *result_type, struct type *index_type,
   if (result_type == NULL)
     result_type = alloc_type_copy (index_type);
   result_type->set_code (TYPE_CODE_RANGE);
-  TYPE_TARGET_TYPE (result_type) = index_type;
+  result_type->set_target_type (index_type);
   if (index_type->is_stub ())
     result_type->set_target_is_stub (true);
   else
@@ -1378,7 +1378,7 @@ create_array_type_with_stride (struct type *result_type,
     result_type = alloc_type_copy (range_type);
 
   result_type->set_code (TYPE_CODE_ARRAY);
-  TYPE_TARGET_TYPE (result_type) = element_type;
+  result_type->set_target_type (element_type);
 
   result_type->set_num_fields (1);
   result_type->set_fields
@@ -1522,7 +1522,7 @@ make_vector_type (struct type *array_type)
       type_instance_flags flags
 	= elt_type->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT;
       elt_type = make_qualified_type (elt_type, flags, NULL);
-      TYPE_TARGET_TYPE (inner_array) = elt_type;
+      inner_array->set_target_type (elt_type);
     }
 
   array_type->set_is_vector (true);
@@ -1610,7 +1610,7 @@ smash_to_memberptr_type (struct type *type, struct type *self_type,
 {
   smash_type (type);
   type->set_code (TYPE_CODE_MEMBERPTR);
-  TYPE_TARGET_TYPE (type) = to_type;
+  type->set_target_type (to_type);
   set_type_self_type (type, self_type);
   /* Assume that a data member pointer is the same size as a normal
      pointer.  */
@@ -1628,7 +1628,7 @@ smash_to_methodptr_type (struct type *type, struct type *to_type)
 {
   smash_type (type);
   type->set_code (TYPE_CODE_METHODPTR);
-  TYPE_TARGET_TYPE (type) = to_type;
+  type->set_target_type (to_type);
   set_type_self_type (type, TYPE_SELF_TYPE (to_type));
   TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
 }
@@ -1647,7 +1647,7 @@ smash_to_method_type (struct type *type, struct type *self_type,
 {
   smash_type (type);
   type->set_code (TYPE_CODE_METHOD);
-  TYPE_TARGET_TYPE (type) = to_type;
+  type->set_target_type (to_type);
   set_type_self_type (type, self_type);
   type->set_fields (args);
   type->set_num_fields (nargs);
@@ -2438,10 +2438,10 @@ resolve_dynamic_array_or_string (struct type *type,
 	  struct type *rank_type = type;
 	  for (int i = 1; i < rank; i++)
 	    {
-	      TYPE_TARGET_TYPE (rank_type) = copy_type (rank_type);
+	      rank_type->set_target_type (copy_type (rank_type));
 	      rank_type = TYPE_TARGET_TYPE (rank_type);
 	    }
-	  TYPE_TARGET_TYPE (rank_type) = element_type;
+	  rank_type->set_target_type (element_type);
 	}
     }
   else
@@ -2782,7 +2782,7 @@ resolve_dynamic_struct (struct type *type,
 
   /* The Ada language uses this field as a cache for static fixed types: reset
      it as RESOLVED_TYPE must have its own static fixed type.  */
-  TYPE_TARGET_TYPE (resolved_type) = NULL;
+  resolved_type->set_target_type (nullptr);
 
   return resolved_type;
 }
@@ -2811,11 +2811,11 @@ resolve_dynamic_type_internal (struct type *type,
   if (type->code () == TYPE_CODE_TYPEDEF)
     {
       resolved_type = copy_type (type);
-      TYPE_TARGET_TYPE (resolved_type)
-	= resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type), addr_stack,
-					 top_level);
+      resolved_type->set_target_type
+	(resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type), addr_stack,
+					top_level));
     }
-  else 
+  else
     {
       /* Before trying to resolve TYPE, make sure it is not a stub.  */
       type = real_type;
@@ -2836,9 +2836,9 @@ resolve_dynamic_type_internal (struct type *type,
 	    pinfo.next = addr_stack;
 
 	    resolved_type = copy_type (type);
-	    TYPE_TARGET_TYPE (resolved_type)
-	      = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type),
-					       &pinfo, top_level);
+	    resolved_type->set_target_type
+	      (resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type),
+					      &pinfo, top_level));
 	    break;
 	  }
 
@@ -3034,9 +3034,9 @@ check_typedef (struct type *type)
 	    }
 	  sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
 	  if (sym)
-	    TYPE_TARGET_TYPE (type) = sym->type ();
+	    type->set_target_type (sym->type ());
 	  else					/* TYPE_CODE_UNDEF */
-	    TYPE_TARGET_TYPE (type) = alloc_type_arch (type->arch ());
+	    type->set_target_type (alloc_type_arch (type->arch ()));
 	}
       type = TYPE_TARGET_TYPE (type);
 
@@ -3582,7 +3582,7 @@ init_complex_type (const char *name, struct type *target_type)
       TYPE_LENGTH (t) = 2 * TYPE_LENGTH (target_type);
       t->set_name (name);
 
-      TYPE_TARGET_TYPE (t) = target_type;
+      t->set_target_type (target_type);
       TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type = t;
     }
 
@@ -3601,7 +3601,7 @@ init_pointer_type (struct objfile *objfile,
   struct type *t;
 
   t = init_type (objfile, TYPE_CODE_PTR, bit, name);
-  TYPE_TARGET_TYPE (t) = target_type;
+  t->set_target_type (target_type);
   t->set_is_unsigned (true);
   return t;
 }
@@ -5728,8 +5728,8 @@ copy_type_recursive (struct type *type, htab_t copied_types)
 
   /* Copy pointers to other types.  */
   if (TYPE_TARGET_TYPE (type))
-    TYPE_TARGET_TYPE (new_type) = 
-      copy_type_recursive (TYPE_TARGET_TYPE (type), copied_types);
+    new_type->set_target_type
+      (copy_type_recursive (TYPE_TARGET_TYPE (type), copied_types));
 
   /* Maybe copy the type_specific bits.
 
@@ -5919,7 +5919,7 @@ arch_pointer_type (struct gdbarch *gdbarch,
   struct type *t;
 
   t = arch_type (gdbarch, TYPE_CODE_PTR, bit, name);
-  TYPE_TARGET_TYPE (t) = target_type;
+  t->set_target_type (target_type);
   t->set_is_unsigned (true);
   return t;
 }
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 8ffcafc6a29..48076749187 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -968,7 +968,7 @@ struct main_type
      the type.
      - Unused otherwise.  */
 
-  struct type *target_type;
+  struct type *m_target_type;
 
   /* * For structure and union types, a description of each field.
      For set and pascal array types, there is one "field",
@@ -1081,6 +1081,16 @@ struct type
     return this->field (0).type ();
   }
 
+  struct type *target_type () const
+  {
+    return this->main_type->m_target_type;
+  }
+
+  void set_target_type (struct type *target_type)
+  {
+    this->main_type->m_target_type = target_type;
+  }
+
   void set_index_type (type *index_type)
   {
     this->field (0).set_type (index_type);
@@ -2087,7 +2097,7 @@ extern void allocate_gnat_aux_type (struct type *);
    allocate_fixed_point_type_info (type))
 
 #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
-#define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type
+#define TYPE_TARGET_TYPE(thistype) ((thistype)->target_type ())
 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 #define TYPE_RVALUE_REFERENCE_TYPE(thistype) (thistype)->rvalue_reference_type
diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c
index 5fe6be16c31..590dd35b38e 100644
--- a/gdb/linux-tdep.c
+++ b/gdb/linux-tdep.c
@@ -294,20 +294,20 @@ linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
   /* __pid_t */
   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			TYPE_LENGTH (int_type) * TARGET_CHAR_BIT, "__pid_t");
-  TYPE_TARGET_TYPE (pid_type) = int_type;
+  pid_type->set_target_type (int_type);
   pid_type->set_target_is_stub (true);
 
   /* __uid_t */
   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			TYPE_LENGTH (uint_type) * TARGET_CHAR_BIT, "__uid_t");
-  TYPE_TARGET_TYPE (uid_type) = uint_type;
+  uid_type->set_target_type (uint_type);
   uid_type->set_target_is_stub (true);
 
   /* __clock_t */
   clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			  TYPE_LENGTH (long_type) * TARGET_CHAR_BIT,
 			  "__clock_t");
-  TYPE_TARGET_TYPE (clock_type) = long_type;
+  clock_type->set_target_type (long_type);
   clock_type->set_target_is_stub (true);
 
   /* _sifields */
diff --git a/gdb/netbsd-tdep.c b/gdb/netbsd-tdep.c
index 2e30aaf52c4..49382eacb2d 100644
--- a/gdb/netbsd-tdep.c
+++ b/gdb/netbsd-tdep.c
@@ -416,23 +416,23 @@ nbsd_get_siginfo_type (struct gdbarch *gdbarch)
   /* pid_t */
   type *pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			      TYPE_LENGTH (int32_type) * char_bits, "pid_t");
-  TYPE_TARGET_TYPE (pid_type) = int32_type;
+  pid_type->set_target_type (int32_type);
 
   /* uid_t */
   type *uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 			      TYPE_LENGTH (uint32_type) * char_bits, "uid_t");
-  TYPE_TARGET_TYPE (uid_type) = uint32_type;
+  uid_type->set_target_type (uint32_type);
 
   /* clock_t */
   type *clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 				TYPE_LENGTH (int_type) * char_bits, "clock_t");
-  TYPE_TARGET_TYPE (clock_type) = int_type;
+  clock_type->set_target_type (int_type);
 
   /* lwpid_t */
   type *lwpid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 				TYPE_LENGTH (int32_type) * char_bits,
 				"lwpid_t");
-  TYPE_TARGET_TYPE (lwpid_type) = int32_type;
+  lwpid_type->set_target_type (int32_type);
 
   /* union sigval */
   type *sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index cd6e6a92f85..3c484cee87b 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1717,7 +1717,7 @@ read_type (const char **pp, struct objfile *objfile)
 	else
 	  {
 	    type->set_target_is_stub (true);
-	    TYPE_TARGET_TYPE (type) = xtype;
+	    type->set_target_type (xtype);
 	  }
       }
       break;
diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c
index 702af65d450..fef04ae9e4b 100644
--- a/gdb/windows-tdep.c
+++ b/gdb/windows-tdep.c
@@ -246,7 +246,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 			    TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 			    NULL);
-  TYPE_TARGET_TYPE (seh_ptr_type) = seh_type;
+  seh_ptr_type->set_target_type (seh_type);
 
   append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
   append_composite_type_field (seh_type, "handler",
@@ -267,7 +267,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 				TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 				NULL);
-  TYPE_TARGET_TYPE (peb_ldr_ptr_type) = peb_ldr_type;
+  peb_ldr_ptr_type->set_target_type (peb_ldr_type);
 
   /* struct UNICODE_STRING */
   uni_str_type = arch_composite_type (gdbarch, "unicode_string",
@@ -337,7 +337,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 			    TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 			    NULL);
-  TYPE_TARGET_TYPE (peb_ptr_type) = peb_type;
+  peb_ptr_type->set_target_type (peb_type);
 
 
   /* struct thread information block */
@@ -381,7 +381,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 			    TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 			    NULL);
-  TYPE_TARGET_TYPE (tib_ptr_type) = tib_type;
+  tib_ptr_type->set_target_type (tib_type);
 
   windows_gdbarch_data->tib_ptr_type = tib_ptr_type;
 
-- 
2.37.3


^ permalink raw reply	[flat|nested] 17+ messages in thread

* [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE
  2022-09-16 15:08 [PATCH 1/4] gdb: add type::target_type / type::set_target_type Simon Marchi
@ 2022-09-16 15:08 ` Simon Marchi
  2022-09-21 14:37   ` Lancelot SIX
  2022-09-21 14:57   ` Tom Tromey
  2022-09-16 15:08 ` [PATCH 3/4] gdb: add type::length / type::set_length Simon Marchi
                   ` (3 subsequent siblings)
  4 siblings, 2 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-16 15:08 UTC (permalink / raw)
  To: gdb-patches

From: Simon Marchi <simon.marchi@polymtl.ca>

Remove the macro, replace all uses by calls to type::length.

Change-Id: Ie51d3e1e22f94130176d6abd723255282bb6d1ed
---
 gdb/aarch64-tdep.c                |   6 +-
 gdb/ada-exp.y                     |   2 +-
 gdb/ada-lang.c                    | 198 +++++++++++++++---------------
 gdb/ada-tasks.c                   |   4 +-
 gdb/ada-typeprint.c               |  26 ++--
 gdb/ada-valprint.c                |  34 ++---
 gdb/ada-varobj.c                  |  20 +--
 gdb/amd64-tdep.c                  |   2 +-
 gdb/amd64-windows-tdep.c          |   2 +-
 gdb/arm-tdep.c                    |   6 +-
 gdb/avr-tdep.c                    |  10 +-
 gdb/ax-gdb.c                      |  14 +--
 gdb/blockframe.c                  |   4 +-
 gdb/c-exp.y                       |  10 +-
 gdb/c-lang.c                      |  14 +--
 gdb/c-typeprint.c                 |  46 +++----
 gdb/c-valprint.c                  |  16 +--
 gdb/c-varobj.c                    |   4 +-
 gdb/coffread.c                    |  10 +-
 gdb/compile/compile-c-symbols.c   |   4 +-
 gdb/compile/compile-c-types.c     |   8 +-
 gdb/compile/compile-cplus-types.c |  12 +-
 gdb/compile/compile-object-load.c |  10 +-
 gdb/cp-namespace.c                |   2 +-
 gdb/cp-support.c                  |   8 +-
 gdb/cp-valprint.c                 |   6 +-
 gdb/ctfread.c                     |  10 +-
 gdb/d-namespace.c                 |   2 +-
 gdb/d-valprint.c                  |   2 +-
 gdb/dwarf2/loc.c                  |  12 +-
 gdb/dwarf2/read.c                 |  35 +++---
 gdb/elfread.c                     |   2 +-
 gdb/eval.c                        |  50 ++++----
 gdb/expop.h                       |   2 +-
 gdb/f-array-walker.h              |   8 +-
 gdb/f-lang.c                      |  38 +++---
 gdb/f-lang.h                      |   2 +-
 gdb/f-typeprint.c                 |  36 +++---
 gdb/f-valprint.c                  |  20 +--
 gdb/frv-tdep.c                    |   2 +-
 gdb/gdbtypes.c                    | 122 +++++++++---------
 gdb/gdbtypes.h                    |   5 +-
 gdb/gnu-v2-abi.c                  |  10 +-
 gdb/gnu-v3-abi.c                  |   8 +-
 gdb/go-lang.c                     |   2 +-
 gdb/go-typeprint.c                |   2 +-
 gdb/go-valprint.c                 |   2 +-
 gdb/guile/scm-lazy-string.c       |   4 +-
 gdb/guile/scm-math.c              |   2 +-
 gdb/guile/scm-type.c              |   6 +-
 gdb/guile/scm-value.c             |   6 +-
 gdb/hppa-tdep.c                   |   2 +-
 gdb/i386-tdep.c                   |   2 +-
 gdb/i386-windows-tdep.c           |   2 +-
 gdb/ia64-tdep.c                   |   6 +-
 gdb/infcall.c                     |  12 +-
 gdb/infcmd.c                      |   4 +-
 gdb/iq2000-tdep.c                 |  10 +-
 gdb/language.c                    |   4 +-
 gdb/loongarch-tdep.c              |   2 +-
 gdb/m2-lang.c                     |   2 +-
 gdb/m2-lang.h                     |   4 +-
 gdb/m2-typeprint.c                |  30 ++---
 gdb/m2-valprint.c                 |  24 ++--
 gdb/m32c-tdep.c                   |   6 +-
 gdb/m68k-tdep.c                   |   2 +-
 gdb/mdebugread.c                  |   4 +-
 gdb/msp430-tdep.c                 |   2 +-
 gdb/opencl-lang.c                 |  26 ++--
 gdb/p-exp.y                       |  14 +--
 gdb/p-lang.c                      |   6 +-
 gdb/p-typeprint.c                 |  50 ++++----
 gdb/p-valprint.c                  |  18 +--
 gdb/ppc-sysv-tdep.c               |  24 ++--
 gdb/python/py-finishbreakpoint.c  |   2 +-
 gdb/python/py-lazy-string.c       |   4 +-
 gdb/python/py-type.c              |   8 +-
 gdb/python/py-value.c             |  10 +-
 gdb/riscv-tdep.c                  |   2 +-
 gdb/rl78-tdep.c                   |   6 +-
 gdb/rust-lang.c                   |  38 +++---
 gdb/rust-lang.h                   |   2 +-
 gdb/rx-tdep.c                     |   4 +-
 gdb/s390-tdep.c                   |   2 +-
 gdb/sh-tdep.c                     |   2 +-
 gdb/sparc-tdep.c                  |   6 +-
 gdb/sparc64-tdep.c                |   2 +-
 gdb/stack.c                       |   2 +-
 gdb/symtab.c                      |   2 +-
 gdb/tic6x-tdep.c                  |   2 +-
 gdb/typeprint.c                   |   6 +-
 gdb/v850-tdep.c                   |   4 +-
 gdb/valarith.c                    |  38 +++---
 gdb/valops.c                      |  66 +++++-----
 gdb/valprint.c                    |  16 +--
 gdb/value.c                       |   6 +-
 gdb/xstormy16-tdep.c              |   4 +-
 97 files changed, 677 insertions(+), 681 deletions(-)

diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c
index 7229b53838e..744348cfcd4 100644
--- a/gdb/aarch64-tdep.c
+++ b/gdb/aarch64-tdep.c
@@ -1496,7 +1496,7 @@ aapcs_is_vfp_call_or_return_candidate_1 (struct type *type,
 
     case TYPE_CODE_COMPLEX:
       {
-	struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+	struct type *target_type = check_typedef (type->target_type ());
 	if (TYPE_LENGTH (target_type) > 16)
 	  return -1;
 
@@ -1526,7 +1526,7 @@ aapcs_is_vfp_call_or_return_candidate_1 (struct type *type,
 	  }
 	else
 	  {
-	    struct type *target_type = TYPE_TARGET_TYPE (type);
+	    struct type *target_type = type->target_type ();
 	    int count = aapcs_is_vfp_call_or_return_candidate_1
 			  (target_type, fundamental_type);
 
@@ -1801,7 +1801,7 @@ pass_in_v_vfp_candidate (struct gdbarch *gdbarch, struct regcache *regcache,
     case TYPE_CODE_COMPLEX:
       {
 	const bfd_byte *buf = value_contents (arg).data ();
-	struct type *target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+	struct type *target_type = check_typedef (arg_type->target_type ());
 
 	if (!pass_in_v (gdbarch, regcache, info, TYPE_LENGTH (target_type),
 			buf))
diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y
index 78aec4e920b..f67c221d873 100644
--- a/gdb/ada-exp.y
+++ b/gdb/ada-exp.y
@@ -873,7 +873,7 @@ primary :	primary TICK_ACCESS
 			  if (!ada_is_modular_type (type_arg))
 			    error (_("'modulus must be applied to modular type"));
 			  write_int (pstate, ada_modulus (type_arg),
-				     TYPE_TARGET_TYPE (type_arg));
+				     type_arg->target_type ());
 			}
 	;
 
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index c5657d9d03a..d0b13a6bed2 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -429,7 +429,7 @@ static struct type *
 ada_typedef_target_type (struct type *type)
 {
   while (type->code () == TYPE_CODE_TYPEDEF)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
   return type;
 }
 
@@ -739,9 +739,9 @@ get_base_type (struct type *type)
 {
   while (type != NULL && type->code () == TYPE_CODE_RANGE)
     {
-      if (type == TYPE_TARGET_TYPE (type) || TYPE_TARGET_TYPE (type) == NULL)
+      if (type == type->target_type () || type->target_type () == NULL)
 	return type;
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
     }
   return type;
 }
@@ -1712,7 +1712,7 @@ desc_base_type (struct type *type)
   if (type != NULL
       && (type->code () == TYPE_CODE_PTR
 	  || type->code () == TYPE_CODE_REF))
-    return ada_check_typedef (TYPE_TARGET_TYPE (type));
+    return ada_check_typedef (type->target_type ());
   else
     return type;
 }
@@ -1800,7 +1800,7 @@ desc_bounds_type (struct type *type)
     {
       r = lookup_struct_elt_type (type, "P_BOUNDS", 1);
       if (r != NULL)
-	return ada_check_typedef (TYPE_TARGET_TYPE (ada_check_typedef (r)));
+	return ada_check_typedef (ada_check_typedef (r)->target_type ());
     }
   return NULL;
 }
@@ -1844,7 +1844,7 @@ desc_bounds (struct value *arr)
       if (p_bounds_type
 	  && p_bounds_type->code () == TYPE_CODE_PTR)
 	{
-	  struct type *target_type = TYPE_TARGET_TYPE (p_bounds_type);
+	  struct type *target_type = p_bounds_type->target_type ();
 
 	  if (target_type->is_stub ())
 	    p_bounds = value_cast (lookup_pointer_type
@@ -1902,7 +1902,7 @@ desc_data_target_type (struct type *type)
 
       if (data_type
 	  && ada_check_typedef (data_type)->code () == TYPE_CODE_PTR)
-	return ada_check_typedef (TYPE_TARGET_TYPE (data_type));
+	return ada_check_typedef (data_type->target_type ());
     }
 
   return NULL;
@@ -2042,7 +2042,7 @@ ada_is_array_type (struct type *type)
   while (type != NULL
 	 && (type->code () == TYPE_CODE_PTR
 	     || type->code () == TYPE_CODE_REF))
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
   return ada_is_direct_array_type (type);
 }
 
@@ -2056,7 +2056,7 @@ ada_is_simple_array_type (struct type *type)
   type = ada_check_typedef (type);
   return (type->code () == TYPE_CODE_ARRAY
 	  || (type->code () == TYPE_CODE_PTR
-	      && (ada_check_typedef (TYPE_TARGET_TYPE (type))->code ()
+	      && (ada_check_typedef (type->target_type ())->code ()
 		  == TYPE_CODE_ARRAY)));
 }
 
@@ -2277,7 +2277,7 @@ ada_is_unconstrained_packed_array_type (struct type *type)
       type = desc_base_type (type);
       /* The structure's first field is a pointer to an array, so this
 	 fetches the array type.  */
-      type = TYPE_TARGET_TYPE (type->field (0).type ());
+      type = type->field (0).type ()->target_type ();
       if (type->code () == TYPE_CODE_TYPEDEF)
 	type = ada_typedef_target_type (type);
       /* Now we can see if the array elements are packed.  */
@@ -2327,7 +2327,7 @@ decode_packed_array_bitsize (struct type *type)
       gdb_assert (is_thick_pntr (type));
       /* The structure's first field is a pointer to an array, so this
 	 fetches the array type.  */
-      type = TYPE_TARGET_TYPE (type->field (0).type ());
+      type = type->field (0).type ()->target_type ();
       /* Now we can see if the array elements are packed.  */
       return TYPE_FIELD_BITSIZE (type, 0);
     }
@@ -2381,7 +2381,7 @@ constrained_packed_array_type (struct type *type, long *elt_bits)
 
   new_type = alloc_type_copy (type);
   new_elt_type =
-    constrained_packed_array_type (ada_check_typedef (TYPE_TARGET_TYPE (type)),
+    constrained_packed_array_type (ada_check_typedef (type->target_type ()),
 				   elt_bits);
   create_array_type (new_type, new_elt_type, index_type);
   TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;
@@ -2464,7 +2464,7 @@ recursively_update_array_bitsize (struct type *type)
     return 0;
   LONGEST our_len = high - low + 1;
 
-  struct type *elt_type = TYPE_TARGET_TYPE (type);
+  struct type *elt_type = type->target_type ();
   if (elt_type->code () == TYPE_CODE_ARRAY)
     {
       LONGEST elt_len = recursively_update_array_bitsize (elt_type);
@@ -2588,7 +2588,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind)
 			 (long) idx);
 	  bits = TYPE_FIELD_BITSIZE (elt_type, 0);
 	  elt_total_bit_offset += (idx - lowerbound) * bits;
-	  elt_type = ada_check_typedef (TYPE_TARGET_TYPE (elt_type));
+	  elt_type = ada_check_typedef (elt_type->target_type ());
 	}
     }
   elt_off = elt_total_bit_offset / HOST_CHAR_BIT;
@@ -3007,7 +3007,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind)
 
   for (k = 0; k < arity; k += 1)
     {
-      struct type *saved_elt_type = TYPE_TARGET_TYPE (elt_type);
+      struct type *saved_elt_type = elt_type->target_type ();
 
       if (elt_type->code () != TYPE_CODE_ARRAY)
 	error (_("too many subscripts (%d expected)"), k);
@@ -3068,11 +3068,11 @@ ada_value_ptr_subscript (struct value *arr, int arity, struct value **ind)
 
       if (type->code () != TYPE_CODE_ARRAY)
 	error (_("too many subscripts (%d expected)"), k);
-      arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+      arr = value_cast (lookup_pointer_type (type->target_type ()),
 			value_copy (arr));
       get_discrete_bounds (type->index_type (), &lwb, &upb);
       arr = value_ptradd (arr, pos_atr (ind[k]) - lwb);
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
     }
 
   return value_ind (arr);
@@ -3087,11 +3087,11 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
 			  int low, int high)
 {
   struct type *type0 = ada_check_typedef (type);
-  struct type *base_index_type = TYPE_TARGET_TYPE (type0->index_type ());
+  struct type *base_index_type = type0->index_type ()->target_type ();
   struct type *index_type
     = create_static_range_type (NULL, base_index_type, low, high);
   struct type *slice_type = create_array_type_with_stride
-			      (NULL, TYPE_TARGET_TYPE (type0), index_type,
+			      (NULL, type0->target_type (), index_type,
 			       type0->dyn_prop (DYN_PROP_BYTE_STRIDE),
 			       TYPE_FIELD_BITSIZE (type0, 0));
   int base_low =  ada_discrete_type_low_bound (type0->index_type ());
@@ -3110,7 +3110,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
 
   ULONGEST stride = TYPE_FIELD_BITSIZE (slice_type, 0) / 8;
   if (stride == 0)
-    stride = TYPE_LENGTH (TYPE_TARGET_TYPE (type0));
+    stride = TYPE_LENGTH (type0->target_type ());
 
   base = value_as_address (array_ptr) + (*low_pos - *base_low_pos) * stride;
   return value_at_lazy (slice_type, base);
@@ -3121,11 +3121,11 @@ static struct value *
 ada_value_slice (struct value *array, int low, int high)
 {
   struct type *type = ada_check_typedef (value_type (array));
-  struct type *base_index_type = TYPE_TARGET_TYPE (type->index_type ());
+  struct type *base_index_type = type->index_type ()->target_type ();
   struct type *index_type
     = create_static_range_type (NULL, type->index_type (), low, high);
   struct type *slice_type = create_array_type_with_stride
-			      (NULL, TYPE_TARGET_TYPE (type), index_type,
+			      (NULL, type->target_type (), index_type,
 			       type->dyn_prop (DYN_PROP_BYTE_STRIDE),
 			       TYPE_FIELD_BITSIZE (type, 0));
   gdb::optional<LONGEST> low_pos, high_pos;
@@ -3167,7 +3167,7 @@ ada_array_arity (struct type *type)
     while (type->code () == TYPE_CODE_ARRAY)
       {
 	arity += 1;
-	type = ada_check_typedef (TYPE_TARGET_TYPE (type));
+	type = ada_check_typedef (type->target_type ());
       }
 
   return arity;
@@ -3199,7 +3199,7 @@ ada_array_element_type (struct type *type, int nindices)
 	k = nindices;
       while (k > 0 && p_array_type != NULL)
 	{
-	  p_array_type = ada_check_typedef (TYPE_TARGET_TYPE (p_array_type));
+	  p_array_type = ada_check_typedef (p_array_type->target_type ());
 	  k -= 1;
 	}
       return p_array_type;
@@ -3208,7 +3208,7 @@ ada_array_element_type (struct type *type, int nindices)
     {
       while (nindices != 0 && type->code () == TYPE_CODE_ARRAY)
 	{
-	  type = TYPE_TARGET_TYPE (type);
+	  type = type->target_type ();
 	  /* A multi-dimensional array is represented using a sequence
 	     of array types.  If one of these types has a name, then
 	     it is not another dimension of the outer array, but
@@ -3242,9 +3242,9 @@ ada_index_type (struct type *type, int n, const char *name)
       for (i = 1; i < n; i += 1)
 	{
 	  type = ada_check_typedef (type);
-	  type = TYPE_TARGET_TYPE (type);
+	  type = type->target_type ();
 	}
-      result_type = TYPE_TARGET_TYPE (ada_check_typedef (type)->index_type ());
+      result_type = ada_check_typedef (type)->index_type ()->target_type ();
       /* FIXME: The stabs type r(0,0);bound;bound in an array type
 	 has a target type of TYPE_CODE_UNDEF.  We compensate here, but
 	 perhaps stabsread.c would make more sense.  */
@@ -3282,7 +3282,7 @@ ada_array_bound_from_type (struct type *arr_type, int n, int which)
     return (LONGEST) - which;
 
   if (arr_type->code () == TYPE_CODE_PTR)
-    type = TYPE_TARGET_TYPE (arr_type);
+    type = arr_type->target_type ();
   else
     type = arr_type;
 
@@ -3307,7 +3307,7 @@ ada_array_bound_from_type (struct type *arr_type, int n, int which)
       struct type *elt_type = check_typedef (type);
 
       for (i = 1; i < n; i++)
-	elt_type = check_typedef (TYPE_TARGET_TYPE (elt_type));
+	elt_type = check_typedef (elt_type->target_type ());
 
       index_type = elt_type->index_type ();
     }
@@ -3376,7 +3376,7 @@ ada_array_length (struct value *arr, int n)
     {
       struct type *base_type;
       if (index_type->code () == TYPE_CODE_RANGE)
-	base_type = TYPE_TARGET_TYPE (index_type);
+	base_type = index_type->target_type ();
       else
 	base_type = index_type;
 
@@ -3396,7 +3396,7 @@ empty_array (struct type *arr_type, int low, int high)
   struct type *arr_type0 = ada_check_typedef (arr_type);
   struct type *index_type
     = create_static_range_type
-	(NULL, TYPE_TARGET_TYPE (arr_type0->index_type ()), low,
+	(NULL, arr_type0->index_type ()->target_type (), low,
 	 high < low ? low - 1 : high);
   struct type *elt_type = ada_array_element_type (arr_type0, 1);
 
@@ -3520,11 +3520,11 @@ ada_print_symbol_signature (struct ui_file *stream, struct symbol *sym,
 	}
       gdb_printf (stream, ")");
     }
-  if (TYPE_TARGET_TYPE (type) != NULL
-      && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+  if (type->target_type () != NULL
+      && type->target_type ()->code () != TYPE_CODE_VOID)
     {
       gdb_printf (stream, " return ");
-      ada_print_type (TYPE_TARGET_TYPE (type), NULL, stream, -1, 0, flags);
+      ada_print_type (type->target_type (), NULL, stream, -1, 0, flags);
     }
 }
 
@@ -3905,9 +3905,9 @@ ada_type_match (struct type *ftype, struct type *atype)
   atype = ada_check_typedef (atype);
 
   if (ftype->code () == TYPE_CODE_REF)
-    ftype = TYPE_TARGET_TYPE (ftype);
+    ftype = ftype->target_type ();
   if (atype->code () == TYPE_CODE_REF)
-    atype = TYPE_TARGET_TYPE (atype);
+    atype = atype->target_type ();
 
   switch (ftype->code ())
     {
@@ -3916,11 +3916,11 @@ ada_type_match (struct type *ftype, struct type *atype)
     case TYPE_CODE_PTR:
       if (atype->code () != TYPE_CODE_PTR)
 	return 0;
-      atype = TYPE_TARGET_TYPE (atype);
+      atype = atype->target_type ();
       /* This can only happen if the actual argument is 'null'.  */
       if (atype->code () == TYPE_CODE_INT && TYPE_LENGTH (atype) == 0)
 	return 1;
-      return ada_type_match (TYPE_TARGET_TYPE (ftype), atype);
+      return ada_type_match (ftype->target_type (), atype);
     case TYPE_CODE_INT:
     case TYPE_CODE_ENUM:
     case TYPE_CODE_RANGE:
@@ -4002,7 +4002,7 @@ return_match (struct type *func_type, struct type *context_type)
     return 1;
 
   if (func_type->code () == TYPE_CODE_FUNC)
-    return_type = get_base_type (TYPE_TARGET_TYPE (func_type));
+    return_type = get_base_type (func_type->target_type ());
   else
     return_type = get_base_type (func_type);
   if (return_type == NULL)
@@ -4094,8 +4094,8 @@ numeric_type_p (struct type *type)
 	case TYPE_CODE_FIXED_POINT:
 	  return 1;
 	case TYPE_CODE_RANGE:
-	  return (type == TYPE_TARGET_TYPE (type)
-		  || numeric_type_p (TYPE_TARGET_TYPE (type)));
+	  return (type == type->target_type ()
+		  || numeric_type_p (type->target_type ()));
 	default:
 	  return 0;
 	}
@@ -4116,8 +4116,8 @@ integer_type_p (struct type *type)
 	case TYPE_CODE_INT:
 	  return 1;
 	case TYPE_CODE_RANGE:
-	  return (type == TYPE_TARGET_TYPE (type)
-		  || integer_type_p (TYPE_TARGET_TYPE (type)));
+	  return (type == type->target_type ()
+		  || integer_type_p (type->target_type ()));
 	default:
 	  return 0;
 	}
@@ -4379,7 +4379,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
   t1 = t = ada_check_typedef (value_type (arg));
   if (t->code () == TYPE_CODE_REF)
     {
-      t1 = TYPE_TARGET_TYPE (t);
+      t1 = t->target_type ();
       if (t1 == NULL)
 	goto BadValue;
       t1 = ada_check_typedef (t1);
@@ -4392,7 +4392,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
 
   while (t->code () == TYPE_CODE_PTR)
     {
-      t1 = TYPE_TARGET_TYPE (t);
+      t1 = t->target_type ();
       if (t1 == NULL)
 	goto BadValue;
       t1 = ada_check_typedef (t1);
@@ -4429,7 +4429,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
 
       if (ada_is_tagged_type (t1, 0)
 	  || (t1->code () == TYPE_CODE_REF
-	      && ada_is_tagged_type (TYPE_TARGET_TYPE (t1), 0)))
+	      && ada_is_tagged_type (t1->target_type (), 0)))
 	{
 	  /* We first try to find the searched field in the current type.
 	     If not found then let's look in the fixed type.  */
@@ -4497,10 +4497,10 @@ ada_convert_actual (struct value *actual, struct type *formal_type0)
   struct type *formal_type = ada_check_typedef (formal_type0);
   struct type *formal_target =
     formal_type->code () == TYPE_CODE_PTR
-    ? ada_check_typedef (TYPE_TARGET_TYPE (formal_type)) : formal_type;
+    ? ada_check_typedef (formal_type->target_type ()) : formal_type;
   struct type *actual_target =
     actual_type->code () == TYPE_CODE_PTR
-    ? ada_check_typedef (TYPE_TARGET_TYPE (actual_type)) : actual_type;
+    ? ada_check_typedef (actual_type->target_type ()) : actual_type;
 
   if (ada_is_array_descriptor_type (formal_target)
       && actual_target->code () == TYPE_CODE_ARRAY)
@@ -6258,7 +6258,7 @@ ada_is_dispatch_table_ptr_type (struct type *type)
   if (type->code () != TYPE_CODE_PTR)
     return 0;
 
-  name = TYPE_TARGET_TYPE (type)->name ();
+  name = type->target_type ()->name ();
   if (name == NULL)
     return 0;
 
@@ -6351,7 +6351,7 @@ ada_is_tag_type (struct type *type)
     return 0;
   else
     {
-      const char *name = ada_type_name (TYPE_TARGET_TYPE (type));
+      const char *name = ada_type_name (type->target_type ());
 
       return (name != NULL
 	      && strcmp (name, "ada__tags__dispatch_table") == 0);
@@ -6665,7 +6665,7 @@ ada_parent_type (struct type *type)
 
 	/* If the _parent field is a pointer, then dereference it.  */
 	if (parent_type->code () == TYPE_CODE_PTR)
-	  parent_type = TYPE_TARGET_TYPE (parent_type);
+	  parent_type = parent_type->target_type ();
 	/* If there is a parallel XVS type, get the actual base type.  */
 	parent_type = ada_get_base_type (parent_type);
 
@@ -6733,7 +6733,7 @@ ada_is_variant_part (struct type *type, int field_num)
 
   return (field_type->code () == TYPE_CODE_UNION
 	  || (is_dynamic_field (type, field_num)
-	      && (TYPE_TARGET_TYPE (field_type)->code ()
+	      && (field_type->target_type ()->code ()
 		  == TYPE_CODE_UNION)));
 }
 
@@ -6776,7 +6776,7 @@ ada_variant_discrim_name (struct type *type0)
   const char *discrim_start;
 
   if (type0->code () == TYPE_CODE_PTR)
-    type = TYPE_TARGET_TYPE (type0);
+    type = type0->target_type ();
   else
     type = type0;
 
@@ -7321,7 +7321,7 @@ ada_lookup_struct_elt_type (struct type *type, const char *name, int refok,
 	type = ada_check_typedef (type);
 	if (type->code () != TYPE_CODE_PTR && type->code () != TYPE_CODE_REF)
 	  break;
-	type = TYPE_TARGET_TYPE (type);
+	type = type->target_type ();
       }
 
   if (type == NULL
@@ -7905,8 +7905,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 	{
 	  const gdb_byte *field_valaddr = valaddr;
 	  CORE_ADDR field_address = address;
-	  struct type *field_type =
-	    TYPE_TARGET_TYPE (type->field (f).type ());
+	  struct type *field_type = type->field (f).type ()->target_type ();
 
 	  if (dval0 == NULL)
 	    {
@@ -8105,8 +8104,8 @@ template_to_static_fixed_type (struct type *type0)
     return type0;
 
   /* Likewise if we already have computed the static approximation.  */
-  if (TYPE_TARGET_TYPE (type0) != NULL)
-    return TYPE_TARGET_TYPE (type0);
+  if (type0->target_type () != NULL)
+    return type0->target_type ();
 
   /* Don't clone TYPE0 until we are sure we are going to need a copy.  */
   type = type0;
@@ -8124,7 +8123,7 @@ template_to_static_fixed_type (struct type *type0)
       if (is_dynamic_field (type0, f))
 	{
 	  field_type = ada_check_typedef (field_type);
-	  new_type = to_static_fixed_type (TYPE_TARGET_TYPE (field_type));
+	  new_type = to_static_fixed_type (field_type->target_type ());
 	}
       else
 	new_type = static_unwrap_type (field_type);
@@ -8294,7 +8293,7 @@ to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr,
   struct type *var_type;
 
   if (var_type0->code () == TYPE_CODE_PTR)
-    var_type = TYPE_TARGET_TYPE (var_type0);
+    var_type = var_type0->target_type ();
   else
     var_type = var_type0;
 
@@ -8311,8 +8310,7 @@ to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr,
     return empty_record (var_type);
   else if (is_dynamic_field (var_type, which))
     return to_fixed_record_type
-      (TYPE_TARGET_TYPE (var_type->field (which).type ()),
-       valaddr, address, dval);
+      (var_type->field (which).type ()->target_type(), valaddr, address, dval);
   else if (variant_field_index (var_type->field (which).type ()) >= 0)
     return
       to_fixed_record_type
@@ -8387,7 +8385,7 @@ ada_is_redundant_index_type_desc (struct type *array_type,
       if (!ada_is_redundant_range_encoding (this_layer->index_type (),
 					    desc_type->field (i).type ()))
 	return 0;
-      this_layer = check_typedef (TYPE_TARGET_TYPE (this_layer));
+      this_layer = check_typedef (this_layer->target_type ());
     }
 
   return 1;
@@ -8460,7 +8458,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 
   if (index_type_desc == NULL)
     {
-      struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0));
+      struct type *elt_type0 = ada_check_typedef (type0->target_type ());
 
       /* NOTE: elt_type---the fixed version of elt_type0---should never
 	 depend on the contents of the array in properly constructed
@@ -8491,7 +8489,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 
       elt_type0 = type0;
       for (i = index_type_desc->num_fields (); i > 0; i -= 1)
-	elt_type0 = TYPE_TARGET_TYPE (elt_type0);
+	elt_type0 = elt_type0->target_type ();
 
       /* NOTE: result---the fixed version of elt_type0---should never
 	 depend on the contents of the array in properly constructed
@@ -8515,7 +8513,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 
 	  result = create_array_type (alloc_type_copy (elt_type0),
 				      result, range_type);
-	  elt_type0 = TYPE_TARGET_TYPE (elt_type0);
+	  elt_type0 = elt_type0->target_type ();
 	}
     }
 
@@ -8530,7 +8528,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 	 type was a regular (non-packed) array type.  As a result, the
 	 bitsize of the array elements needs to be set again, and the array
 	 length needs to be recomputed based on that bitsize.  */
-      int len = TYPE_LENGTH (result) / TYPE_LENGTH (TYPE_TARGET_TYPE (result));
+      int len = TYPE_LENGTH (result) / TYPE_LENGTH (result->target_type ());
       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
 
       TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
@@ -8941,7 +8939,7 @@ val_atr (struct type *type, LONGEST val)
 {
   gdb_assert (discrete_type_p (type));
   if (type->code () == TYPE_CODE_RANGE)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
   if (type->code () == TYPE_CODE_ENUM)
     {
       if (val < 0 || val >= type->num_fields ())
@@ -9088,7 +9086,7 @@ ada_get_base_type (struct type *raw_type)
     }
 
   /* The field in our XVS type is a reference to the base type.  */
-  return TYPE_TARGET_TYPE (real_type_namer->field (0).type ());
+  return real_type_namer->field (0).type ()->target_type ();
 }
 
 /* The type of value designated by TYPE, with all aligners removed.  */
@@ -9272,7 +9270,7 @@ ada_same_array_size_p (struct type *t1, struct type *t2)
 static struct value *
 ada_promote_array_of_integrals (struct type *type, struct value *val)
 {
-  struct type *elt_type = TYPE_TARGET_TYPE (type);
+  struct type *elt_type = type->target_type ();
   LONGEST lo, hi;
   LONGEST i;
 
@@ -9280,11 +9278,11 @@ ada_promote_array_of_integrals (struct type *type, struct value *val)
      that the size of val's elements is smaller than the size
      of type's element.  */
   gdb_assert (type->code () == TYPE_CODE_ARRAY);
-  gdb_assert (is_integral_type (TYPE_TARGET_TYPE (type)));
+  gdb_assert (is_integral_type (type->target_type ()));
   gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);
-  gdb_assert (is_integral_type (TYPE_TARGET_TYPE (value_type (val))));
-  gdb_assert (TYPE_LENGTH (TYPE_TARGET_TYPE (type))
-	      > TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (val))));
+  gdb_assert (is_integral_type (value_type (val)->target_type ()));
+  gdb_assert (TYPE_LENGTH (type->target_type ())
+	      > TYPE_LENGTH (value_type (val)->target_type ()));
 
   if (!get_array_bounds (type, &lo, &hi))
     error (_("unable to determine array bounds"));
@@ -9331,18 +9329,18 @@ coerce_for_assign (struct type *type, struct value *val)
       if (!ada_same_array_size_p (type, type2))
 	error (_("cannot assign arrays of different length"));
 
-      if (is_integral_type (TYPE_TARGET_TYPE (type))
-	  && is_integral_type (TYPE_TARGET_TYPE (type2))
-	  && TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
-	       < TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
+      if (is_integral_type (type->target_type ())
+	  && is_integral_type (type2->target_type ())
+	  && TYPE_LENGTH (type2->target_type ())
+	       < TYPE_LENGTH (type->target_type ()))
 	{
 	  /* Allow implicit promotion of the array elements to
 	     a wider type.  */
 	  return ada_promote_array_of_integrals (type, val);
 	}
 
-      if (TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
-	  != TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
+      if (TYPE_LENGTH (type2->target_type ())
+	  != TYPE_LENGTH (type->target_type ()))
 	error (_("Incompatible types in assignment"));
       deprecated_set_value_type (val, type);
     }
@@ -10193,7 +10191,7 @@ ada_atr_size (struct type *expect_type,
      the user is really asking for the size of the actual object,
      not the size of the pointer.  */
   if (type->code () == TYPE_CODE_REF)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     return value_zero (builtin_type (exp->gdbarch)->builtin_int, not_lval);
@@ -10278,9 +10276,9 @@ ada_ternop_slice (struct expression *exp,
   /* If this is a reference to an aligner type, then remove all
      the aligners.  */
   if (value_type (array)->code () == TYPE_CODE_REF
-      && ada_is_aligner_type (TYPE_TARGET_TYPE (value_type (array))))
+      && ada_is_aligner_type (value_type (array)->target_type ()))
     value_type (array)->set_target_type
-      (ada_aligned_type (TYPE_TARGET_TYPE (value_type (array))));
+      (ada_aligned_type (value_type (array)->target_type ()));
 
   if (ada_is_any_packed_array_type (value_type (array)))
     error (_("cannot slice a packed array"));
@@ -10303,7 +10301,7 @@ ada_ternop_slice (struct expression *exp,
   /* If we have more than one level of pointer indirection,
      dereference the value until we get only one level.  */
   while (value_type (array)->code () == TYPE_CODE_PTR
-	 && (TYPE_TARGET_TYPE (value_type (array))->code ()
+	 && (value_type (array)->target_type ()->code ()
 	     == TYPE_CODE_PTR))
     array = value_ind (array);
 
@@ -10320,11 +10318,11 @@ ada_ternop_slice (struct expression *exp,
       struct type *type0 = ada_check_typedef (value_type (array));
 
       if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)
-	return empty_array (TYPE_TARGET_TYPE (type0), low_bound, high_bound);
+	return empty_array (type0->target_type (), low_bound, high_bound);
       else
 	{
 	  struct type *arr_type0 =
-	    to_fixed_array_type (TYPE_TARGET_TYPE (type0), NULL, 1);
+	    to_fixed_array_type (type0->target_type (), NULL, 1);
 
 	  return ada_value_slice_from_ptr (array, arr_type0,
 					   longest_to_int (low_bound),
@@ -10741,7 +10739,7 @@ ada_concat_operation::evaluate (struct type *expect_type,
       struct type *rhs_type = check_typedef (value_type (rhs));
       struct type *elt_type = nullptr;
       if (rhs_type->code () == TYPE_CODE_ARRAY)
-	elt_type = TYPE_TARGET_TYPE (rhs_type);
+	elt_type = rhs_type->target_type ();
       lhs = lhs_expr->evaluate (elt_type, exp, noside);
     }
   else if (dynamic_cast<ada_string_operation *> (rhs_expr.get ()) != nullptr)
@@ -10755,7 +10753,7 @@ ada_concat_operation::evaluate (struct type *expect_type,
       struct type *lhs_type = check_typedef (value_type (lhs));
       struct type *elt_type = nullptr;
       if (lhs_type->code () == TYPE_CODE_ARRAY)
-	elt_type = TYPE_TARGET_TYPE (lhs_type);
+	elt_type = lhs_type->target_type ();
       rhs = rhs_expr->evaluate (elt_type, exp, noside);
     }
   else
@@ -10812,7 +10810,7 @@ ada_binop_addsub_operation::evaluate (struct type *expect_type,
      a reference type, find its underlying type.  */
   struct type *type = value_type (arg1);
   while (type->code () == TYPE_CODE_REF)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
   binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
   arg1 = value_binop (arg1, arg2, std::get<0> (m_storage));
   /* We need to special-case the result with a range.
@@ -10915,7 +10913,7 @@ ada_var_value_operation::evaluate (struct type *expect_type,
 	 a reference should mostly be transparent to the user.  */
       if (ada_is_tagged_type (type, 0)
 	  || (type->code () == TYPE_CODE_REF
-	      && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0)))
+	      && ada_is_tagged_type (type->target_type (), 0)))
 	{
 	  /* Tagged types are a little special in the fact that the real
 	     type is dynamic and can only be determined by inspecting the
@@ -11045,7 +11043,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 
 	  if ((type->code () == TYPE_CODE_REF
 	       || type->code () == TYPE_CODE_PTR)
-	      && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0))
+	      && ada_is_tagged_type (type->target_type (), 0))
 	    {
 	      arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp,
 							EVAL_NORMAL);
@@ -11055,7 +11053,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 	    {
 	      type = to_static_fixed_type
 		(ada_aligned_type
-		 (ada_check_typedef (TYPE_TARGET_TYPE (type))));
+		 (ada_check_typedef (type->target_type ())));
 	    }
 	  return value_zero (type, lval_memory);
 	}
@@ -11192,17 +11190,17 @@ ada_funcall_operation::evaluate (struct type *expect_type,
 
   if (type->code () == TYPE_CODE_PTR)
     {
-      switch (ada_check_typedef (TYPE_TARGET_TYPE (type))->code ())
+      switch (ada_check_typedef (type->target_type ())->code ())
 	{
 	case TYPE_CODE_FUNC:
-	  type = ada_check_typedef (TYPE_TARGET_TYPE (type));
+	  type = ada_check_typedef (type->target_type ());
 	  break;
 	case TYPE_CODE_ARRAY:
 	  break;
 	case TYPE_CODE_STRUCT:
 	  if (noside != EVAL_AVOID_SIDE_EFFECTS)
 	    callee = ada_value_ind (callee);
-	  type = ada_check_typedef (TYPE_TARGET_TYPE (type));
+	  type = ada_check_typedef (type->target_type ());
 	  break;
 	default:
 	  error (_("cannot subscript or call something of type `%s'"),
@@ -11216,9 +11214,9 @@ ada_funcall_operation::evaluate (struct type *expect_type,
     case TYPE_CODE_FUNC:
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
-	  if (TYPE_TARGET_TYPE (type) == NULL)
+	  if (type->target_type () == NULL)
 	    error_call_unknown_return_type (NULL);
-	  return allocate_value (TYPE_TARGET_TYPE (type));
+	  return allocate_value (type->target_type ());
 	}
       return call_function_by_hand (callee, NULL, argvec);
     case TYPE_CODE_INTERNAL_FUNCTION:
@@ -11265,7 +11263,7 @@ ada_funcall_operation::evaluate (struct type *expect_type,
     case TYPE_CODE_PTR:     /* Pointer to array */
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
-	  type = to_fixed_array_type (TYPE_TARGET_TYPE (type), NULL, 1);
+	  type = to_fixed_array_type (type->target_type (), NULL, 1);
 	  type = ada_array_element_type (type, nargs);
 	  if (type == NULL)
 	    error (_("element type of array unknown"));
@@ -11459,7 +11457,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
   gdb_assert (raw_type->name () != NULL);
 
   if (raw_type->code () == TYPE_CODE_RANGE)
-    base_type = TYPE_TARGET_TYPE (raw_type);
+    base_type = raw_type->target_type ();
   else
     base_type = raw_type;
 
@@ -13769,7 +13767,7 @@ class ada_language : public language_defn
   gdb::unique_xmalloc_ptr<char> watch_location_expression
 	(struct type *type, CORE_ADDR addr) const override
   {
-    type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
+    type = check_typedef (check_typedef (type)->target_type ());
     std::string name = type_to_string (type);
     return xstrprintf ("{%s} %s", name.c_str (), core_addr_to_string (addr));
   }
diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index fda49557a4f..1e617a40158 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -436,7 +436,7 @@ read_fat_string_value (char *dest, struct value *val, int max_len)
 
       bounds_type = type->field (bounds_fieldno).type ();
       if (bounds_type->code () == TYPE_CODE_PTR)
-	bounds_type = TYPE_TARGET_TYPE (bounds_type);
+	bounds_type = bounds_type->target_type ();
       if (bounds_type->code () != TYPE_CODE_STRUCT)
 	error (_("Unknown task name format. Aborting"));
       upper_bound_fieldno = ada_get_field_index (bounds_type, "UB0", 0);
@@ -909,7 +909,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
 	  struct type *idxtype = NULL;
 
 	  if (type->code () == TYPE_CODE_ARRAY)
-	    eltype = check_typedef (TYPE_TARGET_TYPE (type));
+	    eltype = check_typedef (type->target_type ());
 	  if (eltype != NULL
 	      && eltype->code () == TYPE_CODE_PTR)
 	    idxtype = check_typedef (type->index_type ());
diff --git a/gdb/ada-typeprint.c b/gdb/ada-typeprint.c
index b402bfef523..d412c3b3181 100644
--- a/gdb/ada-typeprint.c
+++ b/gdb/ada-typeprint.c
@@ -104,7 +104,7 @@ type_is_full_subrange_of_target_type (struct type *type)
   if (type->code () != TYPE_CODE_RANGE)
     return 0;
 
-  subtype = TYPE_TARGET_TYPE (type);
+  subtype = type->target_type ();
   if (subtype == NULL)
     return 0;
 
@@ -143,7 +143,7 @@ print_range (struct type *type, struct ui_file *stream,
 
 	     array ('["00"]' .. '["ff"]') of ...  */
       while (type_is_full_subrange_of_target_type (type))
-	type = TYPE_TARGET_TYPE (type);
+	type = type->target_type ();
     }
 
   switch (type->code ())
@@ -271,7 +271,7 @@ print_range_type (struct type *raw_type, struct ui_file *stream,
   gdb_assert (name != NULL);
 
   if (raw_type->code () == TYPE_CODE_RANGE)
-    base_type = TYPE_TARGET_TYPE (raw_type);
+    base_type = raw_type->target_type ();
   else
     base_type = raw_type;
 
@@ -390,7 +390,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
 		 name, then it is not another dimension of the outer
 		 array, but rather the element type of the outermost
 		 array.  */
-	      arr_type = TYPE_TARGET_TYPE (arr_type);
+	      arr_type = arr_type->target_type ();
 	      if (arr_type->name () != nullptr)
 		break;
 	    }
@@ -402,7 +402,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
 	  n_indices = range_desc_type->num_fields ();
 	  for (k = 0, arr_type = type;
 	       k < n_indices;
-	       k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
+	       k += 1, arr_type = arr_type->target_type ())
 	    {
 	      if (k > 0)
 		gdb_printf (stream, ", ");
@@ -564,7 +564,7 @@ print_variant_clauses (struct type *type, int field_num,
 
   if (var_type->code () == TYPE_CODE_PTR)
     {
-      var_type = TYPE_TARGET_TYPE (var_type);
+      var_type = var_type->target_type ();
       if (var_type == NULL || var_type->code () != TYPE_CODE_UNION)
 	return;
     }
@@ -884,8 +884,8 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name,
 {
   int i, len = type->num_fields ();
 
-  if (TYPE_TARGET_TYPE (type) != NULL
-      && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID)
+  if (type->target_type () != NULL
+      && type->target_type ()->code () == TYPE_CODE_VOID)
     gdb_printf (stream, "procedure");
   else
     gdb_printf (stream, "function");
@@ -913,12 +913,12 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name,
       gdb_printf (stream, ")");
     }
 
-  if (TYPE_TARGET_TYPE (type) == NULL)
+  if (type->target_type () == NULL)
     gdb_printf (stream, " return <unknown return type>");
-  else if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+  else if (type->target_type ()->code () != TYPE_CODE_VOID)
     {
       gdb_printf (stream, " return ");
-      ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
+      ada_print_type (type->target_type (), "", stream, 0, 0, flags);
     }
 }
 
@@ -998,12 +998,12 @@ ada_print_type (struct type *type0, const char *varstring,
 	if (type->code () != TYPE_CODE_PTR
 	    || strstr (varstring, "___XVL") == nullptr)
 	  gdb_printf (stream, "access ");
-	ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+	ada_print_type (type->target_type (), "", stream, show, level,
 			flags);
 	break;
       case TYPE_CODE_REF:
 	gdb_printf (stream, "<ref> ");
-	ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+	ada_print_type (type->target_type (), "", stream, show, level,
 			flags);
 	break;
       case TYPE_CODE_ARRAY:
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index ed0ce56bca5..938300b8eb7 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -80,7 +80,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type,
 	 of an enumerated type, where the underlying value of the
 	 first element is typically 0, we might test the low bound
 	 against the wrong value.  */
-      index_type = TYPE_TARGET_TYPE (index_type);
+      index_type = index_type->target_type ();
     }
 
   /* Don't print the lower bound if it's the default one.  */
@@ -130,7 +130,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
   struct value *mark = value_mark ();
   LONGEST low = 0;
 
-  elttype = TYPE_TARGET_TYPE (type);
+  elttype = type->target_type ();
   index_type = type->index_type ();
 
   {
@@ -151,7 +151,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
   }
 
   if (index_type->code () == TYPE_CODE_RANGE)
-    index_type = TYPE_TARGET_TYPE (index_type);
+    index_type = index_type->target_type ();
 
   i = 0;
   annotate_array_section_begin (i, elttype);
@@ -421,7 +421,7 @@ ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
       break;
 
     case TYPE_CODE_RANGE:
-      ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
+      ada_print_scalar (type->target_type (), val, stream);
       return;
 
     case TYPE_CODE_UNDEF:
@@ -688,7 +688,7 @@ ada_val_print_string (struct type *type, const gdb_byte *valaddr,
 		      const struct value_print_options *options)
 {
   enum bfd_endian byte_order = type_byte_order (type);
-  struct type *elttype = TYPE_TARGET_TYPE (type);
+  struct type *elttype = type->target_type ();
   unsigned int eltlen;
   unsigned int len;
 
@@ -731,8 +731,8 @@ ada_value_print_ptr (struct value *val,
 		     const struct value_print_options *options)
 {
   if (!options->format
-      && TYPE_TARGET_TYPE (value_type (val))->code () == TYPE_CODE_INT
-      && TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (val))) == 0)
+      && value_type (val)->target_type ()->code () == TYPE_CODE_INT
+      && TYPE_LENGTH (value_type (val)->target_type ()) == 0)
     {
       gdb_puts ("null", stream);
       return;
@@ -761,15 +761,15 @@ ada_value_print_num (struct value *val, struct ui_file *stream, int recurse,
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
 
   if (type->code () == TYPE_CODE_RANGE
-      && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM
-	  || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_BOOL
-	  || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_CHAR))
+      && (type->target_type ()->code () == TYPE_CODE_ENUM
+	  || type->target_type ()->code () == TYPE_CODE_BOOL
+	  || type->target_type ()->code () == TYPE_CODE_CHAR))
     {
       /* For enum-valued ranges, we want to recurse, because we'll end
 	 up printing the constant's name rather than its numeric
 	 value.  Character and fixed-point types are also printed
 	 differently, so recuse for those as well.  */
-      struct type *target_type = TYPE_TARGET_TYPE (type);
+      struct type *target_type = type->target_type ();
       val = value_cast (target_type, val);
       common_val_print (val, stream, recurse + 1, options,
 			language_def (language_ada));
@@ -946,7 +946,7 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
      of the object value would be confusing to an Ada programmer.
      So, for Ada values, we print the actual dereferenced value
      regardless.  */
-  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+  struct type *elttype = check_typedef (type->target_type ());
   struct value *deref_val;
   CORE_ADDR deref_val_int;
 
@@ -1093,14 +1093,14 @@ ada_value_print (struct value *val0, struct ui_file *stream,
   /* If it is a pointer, indicate what it points to; but not for
      "void *" pointers.  */
   if (type->code () == TYPE_CODE_PTR
-      && !(TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_INT
-	   && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == 0))
+      && !(type->target_type ()->code () == TYPE_CODE_INT
+	   && TYPE_LENGTH (type->target_type ()) == 0))
     {
       /* Hack:  don't print (char *) for char strings.  Their
 	 type is indicated by the quoted string anyway.  */
-      if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
-	  || TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_INT
-	  || TYPE_TARGET_TYPE (type)->is_unsigned ())
+      if (TYPE_LENGTH (type->target_type ()) != sizeof (char)
+	  || type->target_type ()->code () != TYPE_CODE_INT
+	  || type->target_type ()->is_unsigned ())
 	{
 	  gdb_printf (stream, "(");
 	  type_print (type, "", stream, -1);
diff --git a/gdb/ada-varobj.c b/gdb/ada-varobj.c
index 3c664687572..e96f6f098e8 100644
--- a/gdb/ada-varobj.c
+++ b/gdb/ada-varobj.c
@@ -137,7 +137,7 @@ ada_varobj_ind (struct value *parent_value,
       /* Decode parent_type by the equivalent pointer to (decoded)
 	 array.  */
       while (parent_type->code () == TYPE_CODE_TYPEDEF)
-	parent_type = TYPE_TARGET_TYPE (parent_type);
+	parent_type = parent_type->target_type ();
       parent_type = ada_coerce_to_simple_array_type (parent_type);
       parent_type = lookup_pointer_type (parent_type);
     }
@@ -153,7 +153,7 @@ ada_varobj_ind (struct value *parent_value,
       type = value_type (value);
     }
   else
-    type = TYPE_TARGET_TYPE (parent_type);
+    type = parent_type->target_type ();
 
   if (child_value)
     *child_value = value;
@@ -184,7 +184,7 @@ ada_varobj_simple_array_elt (struct value *parent_value,
       type = value_type (value);
     }
   else
-    type = TYPE_TARGET_TYPE (parent_type);
+    type = parent_type->target_type ();
 
   if (child_value)
     *child_value = value;
@@ -207,12 +207,12 @@ ada_varobj_adjust_for_child_access (struct value **value,
       the struct/union type.  We handle this situation by dereferencing
       the (value, type) couple.  */
   if ((*type)->code () == TYPE_CODE_PTR
-      && (TYPE_TARGET_TYPE (*type)->code () == TYPE_CODE_STRUCT
-	  || TYPE_TARGET_TYPE (*type)->code () == TYPE_CODE_UNION)
+      && ((*type)->target_type ()->code () == TYPE_CODE_STRUCT
+	  || (*type)->target_type ()->code () == TYPE_CODE_UNION)
       && *value != nullptr
       && value_as_address (*value) != 0
-      && !ada_is_array_descriptor_type (TYPE_TARGET_TYPE (*type))
-      && !ada_is_constrained_packed_array_type (TYPE_TARGET_TYPE (*type)))
+      && !ada_is_array_descriptor_type ((*type)->target_type ())
+      && !ada_is_constrained_packed_array_type ((*type)->target_type ()))
     ada_varobj_ind (*value, *type, value, type);
 
   /* If this is a tagged type, we need to transform it a bit in order
@@ -327,7 +327,7 @@ static int
 ada_varobj_get_ptr_number_of_children (struct value *parent_value,
 				       struct type *parent_type)
 {
-  struct type *child_type = TYPE_TARGET_TYPE (parent_type);
+  struct type *child_type = parent_type->target_type ();
 
   /* Pointer to functions and to void do not have a child, since
      you cannot print what they point to.  */
@@ -634,7 +634,7 @@ ada_varobj_describe_simple_array_child (struct value *parent_value,
 
       /* If the index type is a range type, find the base type.  */
       while (index_type->code () == TYPE_CODE_RANGE)
-	index_type = TYPE_TARGET_TYPE (index_type);
+	index_type = index_type->target_type ();
 
       if (index_type->code () == TYPE_CODE_ENUM
 	  || index_type->code () == TYPE_CODE_BOOL)
@@ -946,7 +946,7 @@ ada_value_is_changeable_p (const struct varobj *var)
 		       ? value_type (var->value.get ()) : var->type);
 
   if (type->code () == TYPE_CODE_REF)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
 
   if (ada_is_access_to_unconstrained_array (type))
     {
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index d89e06d27cb..4d416a44bf3 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -684,7 +684,7 @@ amd64_classify_aggregate (struct type *type, enum amd64_reg_class theclass[2])
 
   if (type->code () == TYPE_CODE_ARRAY)
     {
-      struct type *subtype = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *subtype = check_typedef (type->target_type ());
 
       /* All fields in an array have the same type.  */
       amd64_classify (subtype, theclass);
diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index a9aef0bab88..1f779fb9aa1 100644
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -373,7 +373,7 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
 	/* __m128, __m128i and __m128d are returned via XMM0.  */
 	if (type->is_vector () && len == 16)
 	  {
-	    enum type_code code = TYPE_TARGET_TYPE (type)->code ();
+	    enum type_code code = type->target_type ()->code ();
 	    if (code == TYPE_CODE_INT || code == TYPE_CODE_FLT)
 	      {
 		regnum = AMD64_XMM0_REGNUM;
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index ead9bbf46c5..7333fa6a4c9 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -4296,7 +4296,7 @@ arm_vfp_cprc_sub_candidate (struct type *t,
 	    int count;
 	    unsigned unitlen;
 
-	    count = arm_vfp_cprc_sub_candidate (TYPE_TARGET_TYPE (t),
+	    count = arm_vfp_cprc_sub_candidate (t->target_type (),
 						base_type);
 	    if (count == -1)
 	      return -1;
@@ -4442,7 +4442,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
      applies.  */
   ftype = check_typedef (value_type (function));
   if (ftype->code () == TYPE_CODE_PTR)
-    ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+    ftype = check_typedef (ftype->target_type ());
   use_vfp_abi = arm_vfp_abi_for_function (gdbarch, ftype);
 
   /* Set the return address.  For the ARM, the return breakpoint is
@@ -4485,7 +4485,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
       arg_type = check_typedef (value_type (args[argnum]));
       len = TYPE_LENGTH (arg_type);
-      target_type = TYPE_TARGET_TYPE (arg_type);
+      target_type = arg_type->target_type ();
       typecode = arg_type->code ();
       val = value_contents (args[argnum]).data ();
 
diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index 693d563b911..f020d21e3b8 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -319,8 +319,8 @@ avr_address_to_pointer (struct gdbarch *gdbarch,
 			      avr_convert_iaddr_to_raw (addr));
     }
   /* Is it a code address?  */
-  else if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC
-	   || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD)
+  else if (type->target_type ()->code () == TYPE_CODE_FUNC
+	   || type->target_type ()->code () == TYPE_CODE_METHOD)
     {
       /* A code pointer is word (16 bits) addressed.  We shift the address down
 	 by 1 bit to convert it to a pointer.  */
@@ -350,9 +350,9 @@ avr_pointer_to_address (struct gdbarch *gdbarch,
       return avr_make_iaddr (addr);
     }
   /* Is it a code address?  */
-  else if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC
-	   || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD
-	   || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
+  else if (type->target_type ()->code () == TYPE_CODE_FUNC
+	   || type->target_type ()->code () == TYPE_CODE_METHOD
+	   || TYPE_CODE_SPACE (type->target_type ()))
     {
       /* A code pointer is word (16 bits) addressed so we shift it up
 	 by 1 bit to convert it to an address.  */
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 0d2566f1518..44a2f966995 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -255,7 +255,7 @@ gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
   int string_trace = 0;
   if (ax->trace_string
       && value->type->code () == TYPE_CODE_PTR
-      && c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value->type)),
+      && c_textual_element_type (check_typedef (value->type->target_type ()),
 				 's'))
     string_trace = 1;
 
@@ -367,7 +367,7 @@ gen_fetch (struct agent_expr *ax, struct type *type)
     }
 
   if (type->code () == TYPE_CODE_RANGE)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
 
   switch (type->code ())
     {
@@ -735,7 +735,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
 	 are no longer an lvalue.  */
     case TYPE_CODE_ARRAY:
       {
-	struct type *elements = TYPE_TARGET_TYPE (value->type);
+	struct type *elements = value->type->target_type ();
 
 	value->type = lookup_pointer_type (elements);
 	value->kind = axs_rvalue;
@@ -946,7 +946,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
 static void
 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
 {
-  struct type *element = TYPE_TARGET_TYPE (type);
+  struct type *element = type->target_type ();
 
   if (TYPE_LENGTH (element) != 1)
     {
@@ -997,8 +997,8 @@ gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
   gdb_assert (value1->type->is_pointer_or_reference ());
   gdb_assert (value2->type->is_pointer_or_reference ());
 
-  if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
-      != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))
+  if (TYPE_LENGTH (value1->type->target_type ())
+      != TYPE_LENGTH (value2->type->target_type ()))
     error (_("\
 First argument of `-' is a pointer, but second argument is neither\n\
 an integer nor a pointer of the same type."));
@@ -1104,7 +1104,7 @@ gen_deref (struct axs_value *value)
      actually emit any code; we just change the type from "Pointer to
      T" to "T", and mark the value as an lvalue in memory.  Leave it
      to the consumer to actually dereference it.  */
-  value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
+  value->type = check_typedef (value->type->target_type ());
   if (value->type->code () == TYPE_CODE_VOID)
     error (_("Attempt to dereference a generic pointer."));
   value->kind = ((value->type->code () == TYPE_CODE_FUNC)
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 47772f3b1a6..1c9e5db7eac 100644
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -440,14 +440,14 @@ find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr)
     {
       /* Get the return type of the resolver.  */
       struct type *resolver_ret_type
-	= check_typedef (TYPE_TARGET_TYPE (resolver_type));
+	= check_typedef (resolver_type->target_type ());
 
       /* If we found a pointer to function, then the resolved type
 	 is the type of the pointed-to function.  */
       if (resolver_ret_type->code () == TYPE_CODE_PTR)
 	{
 	  struct type *resolved_type
-	    = TYPE_TARGET_TYPE (resolver_ret_type);
+	    = resolver_ret_type->target_type ();
 	  if (check_typedef (resolved_type)->code () == TYPE_CODE_FUNC)
 	    return resolved_type;
 	}
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 61a61fcba09..abd5b6717a5 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -865,10 +865,10 @@ exp	:	COMPLEX_INT
 			{
 			  operation_up real
 			    = (make_operation<long_const_operation>
-			       (TYPE_TARGET_TYPE ($1.type), 0));
+			       ($1.type->target_type (), 0));
 			  operation_up imag
 			    = (make_operation<long_const_operation>
-			       (TYPE_TARGET_TYPE ($1.type), $1.val));
+			       ($1.type->target_type (), $1.val));
 			  pstate->push_new<complex_operation>
 			    (std::move (real), std::move (imag), $1.type);
 			}
@@ -905,8 +905,7 @@ exp	:	FLOAT
 
 exp	:	COMPLEX_FLOAT
 			{
-			  struct type *underlying
-			    = TYPE_TARGET_TYPE ($1.type);
+			  struct type *underlying = $1.type->target_type ();
 
 			  float_data val;
 			  target_float_from_host_double (val.data (),
@@ -955,7 +954,8 @@ exp	:	SIZEOF '(' type ')'	%prec UNARY
 			       or a reference type, the result is the size of
 			       the referenced type."  */
 			  if (TYPE_IS_REFERENCE (type))
-			    type = check_typedef (TYPE_TARGET_TYPE (type));
+			    type = check_typedef (type->target_type ());
+
 			  pstate->push_new<long_const_operation>
 			    (int_type, TYPE_LENGTH (type));
 			}
diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index 87373085f24..59ecdd38cea 100644
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -118,8 +118,8 @@ classify_type (struct type *elttype, struct gdbarch *gdbarch,
       /* Call for side effects.  */
       check_typedef (elttype);
 
-      if (TYPE_TARGET_TYPE (elttype))
-	elttype = TYPE_TARGET_TYPE (elttype);
+      if (elttype->target_type ())
+	elttype = elttype->target_type ();
       else
 	{
 	  /* Perhaps check_typedef did not update the target type.  In
@@ -247,7 +247,7 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
   int err, width;
   unsigned int fetchlimit;
   struct type *type = check_typedef (value_type (value));
-  struct type *element_type = TYPE_TARGET_TYPE (type);
+  struct type *element_type = type->target_type ();
   int req_length = *length;
   enum bfd_endian byte_order
     = type_byte_order (type);
@@ -625,7 +625,7 @@ c_string_operation::evaluate (struct type *expect_type,
   if (expect_type && expect_type->code () == TYPE_CODE_ARRAY)
     {
       struct type *element_type
-	= check_typedef (TYPE_TARGET_TYPE (expect_type));
+	= check_typedef (expect_type->target_type ());
 
       if (element_type->code () == TYPE_CODE_INT
 	  || element_type->code () == TYPE_CODE_CHAR)
@@ -697,7 +697,7 @@ c_is_string_type_p (struct type *type)
   type = check_typedef (type);
   while (type->code () == TYPE_CODE_REF)
     {
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
       type = check_typedef (type);
     }
 
@@ -706,7 +706,7 @@ c_is_string_type_p (struct type *type)
     case TYPE_CODE_ARRAY:
       {
 	/* See if target type looks like a string.  */
-	struct type *array_target_type = TYPE_TARGET_TYPE (type);
+	struct type *array_target_type = type->target_type ();
 	return (TYPE_LENGTH (type) > 0
 		&& TYPE_LENGTH (array_target_type) > 0
 		&& c_textual_element_type (array_target_type, 0));
@@ -715,7 +715,7 @@ c_is_string_type_p (struct type *type)
       return true;
     case TYPE_CODE_PTR:
       {
-	struct type *element_type = TYPE_TARGET_TYPE (type);
+	struct type *element_type = type->target_type ();
 	return c_textual_element_type (element_type, 0);
       }
     default:
diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index 4f45475dc4a..89ed2ebd97b 100644
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -313,7 +313,7 @@ cp_type_print_method_args (struct type *mtype, const char *prefix,
 
       gdb_assert (nargs > 0);
       gdb_assert (args[0].type ()->code () == TYPE_CODE_PTR);
-      domain = TYPE_TARGET_TYPE (args[0].type ());
+      domain = args[0].type ()->target_type ();
 
       if (TYPE_CONST (domain))
 	gdb_printf (stream, " const");
@@ -366,7 +366,7 @@ c_type_print_varspec_prefix (struct type *type,
   switch (type->code ())
     {
     case TYPE_CODE_PTR:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, 1, 1, language, flags,
 				   podata);
       gdb_printf (stream, "*");
@@ -374,7 +374,7 @@ c_type_print_varspec_prefix (struct type *type,
       break;
 
     case TYPE_CODE_MEMBERPTR:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, 0, 0, language, flags, podata);
       name = TYPE_SELF_TYPE (type)->name ();
       if (name)
@@ -387,7 +387,7 @@ c_type_print_varspec_prefix (struct type *type,
       break;
 
     case TYPE_CODE_METHODPTR:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, 0, 0, language, flags,
 				   podata);
       gdb_printf (stream, "(");
@@ -403,7 +403,7 @@ c_type_print_varspec_prefix (struct type *type,
 
     case TYPE_CODE_REF:
     case TYPE_CODE_RVALUE_REF:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, 1, 0, language, flags,
 				   podata);
       gdb_printf (stream, type->code () == TYPE_CODE_REF ? "&" : "&&");
@@ -412,7 +412,7 @@ c_type_print_varspec_prefix (struct type *type,
 
     case TYPE_CODE_METHOD:
     case TYPE_CODE_FUNC:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, 0, 0, language, flags,
 				   podata);
       if (passed_a_ptr)
@@ -420,7 +420,7 @@ c_type_print_varspec_prefix (struct type *type,
       break;
 
     case TYPE_CODE_ARRAY:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, 0, need_post_space,
 				   language, flags, podata);
       if (passed_a_ptr)
@@ -428,7 +428,7 @@ c_type_print_varspec_prefix (struct type *type,
       break;
 
     case TYPE_CODE_TYPEDEF:
-      c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      c_type_print_varspec_prefix (type->target_type (),
 				   stream, show, passed_a_ptr, 0,
 				   language, flags, podata);
       break;
@@ -775,26 +775,26 @@ c_type_print_varspec_suffix (struct type *type,
 		      plongest (high_bound - low_bound + 1));
 	gdb_printf (stream, (is_vector ? ")))" : "]"));
 
-	c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
+	c_type_print_varspec_suffix (type->target_type (), stream,
 				     show, 0, 0, language, flags);
       }
       break;
 
     case TYPE_CODE_MEMBERPTR:
-      c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
+      c_type_print_varspec_suffix (type->target_type (), stream,
 				   show, 0, 0, language, flags);
       break;
 
     case TYPE_CODE_METHODPTR:
       gdb_printf (stream, ")");
-      c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
+      c_type_print_varspec_suffix (type->target_type (), stream,
 				   show, 0, 0, language, flags);
       break;
 
     case TYPE_CODE_PTR:
     case TYPE_CODE_REF:
     case TYPE_CODE_RVALUE_REF:
-      c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
+      c_type_print_varspec_suffix (type->target_type (), stream,
 				   show, 1, 0, language, flags);
       break;
 
@@ -804,12 +804,12 @@ c_type_print_varspec_suffix (struct type *type,
 	gdb_printf (stream, ")");
       if (!demangled_args)
 	c_type_print_args (type, stream, 0, language, flags);
-      c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
+      c_type_print_varspec_suffix (type->target_type (), stream,
 				   show, passed_a_ptr, 0, language, flags);
       break;
 
     case TYPE_CODE_TYPEDEF:
-      c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
+      c_type_print_varspec_suffix (type->target_type (), stream,
 				   show, passed_a_ptr, 0, language, flags);
       break;
 
@@ -1266,7 +1266,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream,
 		gdb_printf (stream, "virtual ");
 	      else if (TYPE_FN_FIELD_STATIC_P (f, j))
 		gdb_printf (stream, "static ");
-	      if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
+	      if (TYPE_FN_FIELD_TYPE (f, j)->target_type () == 0)
 		{
 		  /* Keep GDB from crashing here.  */
 		  gdb_printf (stream,
@@ -1282,7 +1282,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream,
 		       && !is_type_conversion_operator (type, i, j))
 		{
 		  c_print_type_no_offsets
-		    (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
+		    (TYPE_FN_FIELD_TYPE (f, j)->target_type (),
 		     "", stream, -1, 0, language, &local_flags, podata);
 
 		  gdb_puts (" ", stream);
@@ -1382,7 +1382,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream,
 
 	      /* Dereference the typedef declaration itself.  */
 	      gdb_assert (target->code () == TYPE_CODE_TYPEDEF);
-	      target = TYPE_TARGET_TYPE (target);
+	      target = target->target_type ();
 
 	      if (need_access_label)
 		{
@@ -1497,17 +1497,17 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream,
       /* If we get here, the typedef doesn't have a name, and we
 	 couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
       gdb_assert (type->name () == NULL);
-      gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
+      gdb_assert (type->target_type () == NULL);
       fprintf_styled (stream, metadata_style.style (),
 		      _("<unnamed typedef>"));
       break;
 
     case TYPE_CODE_FUNC:
     case TYPE_CODE_METHOD:
-      if (TYPE_TARGET_TYPE (type) == NULL)
+      if (type->target_type () == NULL)
 	type_print_unknown_return_type (stream);
       else
-	c_type_print_base_1 (TYPE_TARGET_TYPE (type),
+	c_type_print_base_1 (type->target_type (),
 			     stream, show, level, language, flags, podata);
       break;
     case TYPE_CODE_ARRAY:
@@ -1516,7 +1516,7 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream,
     case TYPE_CODE_REF:
     case TYPE_CODE_RVALUE_REF:
     case TYPE_CODE_METHODPTR:
-      c_type_print_base_1 (TYPE_TARGET_TYPE (type),
+      c_type_print_base_1 (type->target_type (),
 			   stream, show, level, language, flags, podata);
       break;
 
@@ -1564,9 +1564,9 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream,
 	     print too much than too little; but conversely not to
 	     print something egregiously outside the current
 	     language's syntax.  */
-	  if (language == language_cplus && TYPE_TARGET_TYPE (type) != NULL)
+	  if (language == language_cplus && type->target_type () != NULL)
 	    {
-	      struct type *underlying = check_typedef (TYPE_TARGET_TYPE (type));
+	      struct type *underlying = check_typedef (type->target_type ());
 
 	      if (underlying->name () != NULL)
 		gdb_printf (stream, ": %s ", underlying->name ());
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index bd445588ca0..a93280c6685 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -87,8 +87,8 @@ c_textual_element_type (struct type *type, char format)
       /* Peel a single typedef.  If the typedef doesn't have a target
 	 type, we use check_typedef and hope the result is ok -- it
 	 might be for C++, where wchar_t is a built-in type.  */
-      if (TYPE_TARGET_TYPE (iter_type))
-	iter_type = TYPE_TARGET_TYPE (iter_type);
+      if (iter_type->target_type ())
+	iter_type = iter_type->target_type ();
       else
 	iter_type = check_typedef (iter_type);
     }
@@ -238,7 +238,7 @@ c_value_print_array (struct value *val,
   struct type *type = check_typedef (value_type (val));
   CORE_ADDR address = value_address (val);
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
-  struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
+  struct type *unresolved_elttype = type->target_type ();
   struct type *elttype = check_typedef (unresolved_elttype);
 
   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
@@ -347,7 +347,7 @@ c_value_print_ptr (struct value *val, struct ui_file *stream, int recurse,
     }
   else
     {
-      struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
+      struct type *unresolved_elttype = type->target_type ();
       struct type *elttype = check_typedef (unresolved_elttype);
       CORE_ADDR addr = unpack_pointer (type, valaddr);
 
@@ -497,15 +497,15 @@ c_value_print (struct value *val, struct ui_file *stream,
 	 are always exactly (char *), (wchar_t *), or the like.  */
       if (original_type->code () == TYPE_CODE_PTR
 	  && original_type->name () == NULL
-	  && TYPE_TARGET_TYPE (original_type)->name () != NULL
-	  && (strcmp (TYPE_TARGET_TYPE (original_type)->name (),
+	  && original_type->target_type ()->name () != NULL
+	  && (strcmp (original_type->target_type ()->name (),
 		      "char") == 0
-	      || textual_name (TYPE_TARGET_TYPE (original_type)->name ())))
+	      || textual_name (original_type->target_type ()->name ())))
 	{
 	  /* Print nothing.  */
 	}
       else if (options->objectprint
-	       && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT))
+	       && (type->target_type ()->code () == TYPE_CODE_STRUCT))
 	{
 	  int is_ref = TYPE_IS_REFERENCE (type);
 	  enum type_code refcode = TYPE_CODE_UNDEF;
diff --git a/gdb/c-varobj.c b/gdb/c-varobj.c
index 8fecbd57e08..957e7f3d72f 100644
--- a/gdb/c-varobj.c
+++ b/gdb/c-varobj.c
@@ -403,7 +403,7 @@ c_describe_child (const struct varobj *parent, int index,
 	 check_typedef and here, we want to show the true
 	 declared type of the variable.  */
       if (ctype)
-	*ctype = TYPE_TARGET_TYPE (type);
+	*ctype = type->target_type ();
 
       if (cfull_expression)
 	*cfull_expression = string_printf ("*(%s)", parent_expression.c_str ());
@@ -482,7 +482,7 @@ c_value_of_variable (const struct varobj *var,
 
   /* Strip top-level references.  */
   while (TYPE_IS_REFERENCE (type))
-    type = check_typedef (TYPE_TARGET_TYPE (type));
+    type = check_typedef (type->target_type ());
 
   switch (type->code ())
     {
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 45d41d08449..27afa11738d 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1468,8 +1468,8 @@ enter_linenos (file_ptr file_offset, int first_line,
 static void
 patch_type (struct type *type, struct type *real_type)
 {
-  struct type *target = TYPE_TARGET_TYPE (type);
-  struct type *real_target = TYPE_TARGET_TYPE (real_type);
+  struct type *target = type->target_type ();
+  struct type *real_target = real_type->target_type ();
   int field_size = real_target->num_fields () * sizeof (struct field);
 
   TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
@@ -1509,7 +1509,7 @@ patch_opaque_types (struct symtab *s)
       if (real_sym->aclass () == LOC_TYPEDEF
 	  && real_sym->domain () == VAR_DOMAIN
 	  && real_sym->type ()->code () == TYPE_CODE_PTR
-	  && TYPE_LENGTH (TYPE_TARGET_TYPE (real_sym->type ())) != 0)
+	  && TYPE_LENGTH (real_sym->type ()->target_type ()) != 0)
 	{
 	  const char *name = real_sym->linkage_name ();
 	  int hash = hashname (name);
@@ -1699,8 +1699,8 @@ process_coff_symbol (struct coff_symbol *cs,
 	     references work themselves out via the magic of
 	     coff_lookup_type.  */
 	  if (sym->type ()->code () == TYPE_CODE_PTR
-	      && TYPE_LENGTH (TYPE_TARGET_TYPE (sym->type ())) == 0
-	      && TYPE_TARGET_TYPE (sym->type ())->code ()
+	      && TYPE_LENGTH (sym->type ()->target_type ()) == 0
+	      && sym->type ()->target_type ()->code ()
 	      != TYPE_CODE_UNDEF)
 	    {
 	      int i = hashname (sym->linkage_name ());
diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c
index e1f94ec2907..dd892b31116 100644
--- a/gdb/compile/compile-c-symbols.c
+++ b/gdb/compile/compile-c-symbols.c
@@ -495,7 +495,7 @@ generate_vla_size (compile_instance *compiler,
   type = check_typedef (type);
 
   if (TYPE_IS_REFERENCE (type))
-    type = check_typedef (TYPE_TARGET_TYPE (type));
+    type = check_typedef (type->target_type ());
 
   switch (type->code ())
     {
@@ -518,7 +518,7 @@ generate_vla_size (compile_instance *compiler,
       generate_vla_size (compiler, stream, gdbarch, registers_used, pc,
 			 type->index_type (), sym);
       generate_vla_size (compiler, stream, gdbarch, registers_used, pc,
-			 TYPE_TARGET_TYPE (type), sym);
+			 type->target_type (), sym);
       break;
 
     case TYPE_CODE_UNION:
diff --git a/gdb/compile/compile-c-types.c b/gdb/compile/compile-c-types.c
index 14dbd9794b5..d92bd204485 100644
--- a/gdb/compile/compile-c-types.c
+++ b/gdb/compile/compile-c-types.c
@@ -29,7 +29,7 @@
 static gcc_type
 convert_pointer (compile_c_instance *context, struct type *type)
 {
-  gcc_type target = context->convert_type (TYPE_TARGET_TYPE (type));
+  gcc_type target = context->convert_type (type->target_type ());
 
   return context->plugin ().build_pointer_type (target);
 }
@@ -42,7 +42,7 @@ convert_array (compile_c_instance *context, struct type *type)
   gcc_type element_type;
   struct type *range = type->index_type ();
 
-  element_type = context->convert_type (TYPE_TARGET_TYPE (type));
+  element_type = context->convert_type (type->target_type ());
 
   if (range->bounds ()->low.kind () != PROP_CONST)
     return context->plugin ().error (_("array type with non-constant"
@@ -155,7 +155,7 @@ convert_func (compile_c_instance *context, struct type *type)
   struct gcc_type_array array;
   int is_varargs = type->has_varargs () || !type->is_prototyped ();
 
-  struct type *target_type = TYPE_TARGET_TYPE (type);
+  struct type *target_type = type->target_type ();
 
   /* Functions with no debug info have no return type.  Ideally we'd
      want to fallback to the type of the cast just before the
@@ -263,7 +263,7 @@ convert_qualified (compile_c_instance *context, struct type *type)
 static gcc_type
 convert_complex (compile_c_instance *context, struct type *type)
 {
-  gcc_type base = context->convert_type (TYPE_TARGET_TYPE (type));
+  gcc_type base = context->convert_type (type->target_type ());
 
   return context->plugin ().build_complex_type (base);
 }
diff --git a/gdb/compile/compile-cplus-types.c b/gdb/compile/compile-cplus-types.c
index e7c940b1355..6f666e24fc3 100644
--- a/gdb/compile/compile-cplus-types.c
+++ b/gdb/compile/compile-cplus-types.c
@@ -410,7 +410,7 @@ static gcc_type
 compile_cplus_convert_reference (compile_cplus_instance *instance,
 				 struct type *type)
 {
-  gcc_type target = instance->convert_type (TYPE_TARGET_TYPE (type));
+  gcc_type target = instance->convert_type (type->target_type ());
 
   enum gcc_cp_ref_qualifiers quals = GCC_CP_REF_QUAL_NONE;
   switch (type->code ())
@@ -442,7 +442,7 @@ static gcc_type
 compile_cplus_convert_pointer (compile_cplus_instance *instance,
 			       struct type *type)
 {
-  gcc_type target = instance->convert_type (TYPE_TARGET_TYPE (type));
+  gcc_type target = instance->convert_type (type->target_type ());
 
   return instance->convert_pointer_base (target);
 }
@@ -454,7 +454,7 @@ compile_cplus_convert_array (compile_cplus_instance *instance,
 			     struct type *type)
 {
   struct type *range = type->index_type ();
-  gcc_type element_type = instance->convert_type (TYPE_TARGET_TYPE (type));
+  gcc_type element_type = instance->convert_type (type->target_type ());
 
   if (range->bounds ()->low.kind () != PROP_CONST)
     {
@@ -697,7 +697,7 @@ compile_cplus_convert_memberptr (compile_cplus_instance *instance,
 
   gcc_type class_type = instance->convert_type (containing_class);
   gcc_type member_type
-    = instance->convert_type (TYPE_TARGET_TYPE (type));
+    = instance->convert_type (type->target_type ());
 
   return instance->plugin ().build_pointer_to_member_type
     (class_type, member_type);
@@ -961,7 +961,7 @@ compile_cplus_convert_func (compile_cplus_instance *instance,
 			    struct type *type, bool strip_artificial)
 {
   int is_varargs = type->has_varargs ();
-  struct type *target_type = TYPE_TARGET_TYPE (type);
+  struct type *target_type = type->target_type ();
 
   /* Functions with no debug info have no return type.  Ideally we'd
      want to fallback to the type of the cast just before the
@@ -1086,7 +1086,7 @@ static gcc_type
 compile_cplus_convert_complex (compile_cplus_instance *instance,
 			       struct type *type)
 {
-  gcc_type base = instance->convert_type (TYPE_TARGET_TYPE (type));
+  gcc_type base = instance->convert_type (type->target_type ());
 
   return instance->plugin ().build_complex_type (base);
 }
diff --git a/gdb/compile/compile-object-load.c b/gdb/compile/compile-object-load.c
index 06e8c850d5e..aede3bc43b3 100644
--- a/gdb/compile/compile-object-load.c
+++ b/gdb/compile/compile-object-load.c
@@ -469,7 +469,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
   gdb_ptr_type = check_typedef (gdb_ptr_type);
   if (gdb_ptr_type->code () != TYPE_CODE_PTR)
     error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
-  gdb_type_from_ptr = check_typedef (TYPE_TARGET_TYPE (gdb_ptr_type));
+  gdb_type_from_ptr = check_typedef (gdb_ptr_type->target_type ());
 
   if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
     {
@@ -489,7 +489,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
   switch (gdb_type_from_ptr->code ())
     {
     case TYPE_CODE_ARRAY:
-      gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
+      gdb_type_from_ptr = gdb_type_from_ptr->target_type ();
       break;
     case TYPE_CODE_FUNC:
       break;
@@ -500,7 +500,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
 	     objfile_name (objfile));
     }
   if (!types_deeply_equal (gdb_type_from_ptr,
-			   TYPE_TARGET_TYPE (gdb_type)))
+			   gdb_type->target_type ()))
     error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
 	     "in compiled module \"%s\"."),
 	   COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL,
@@ -530,7 +530,7 @@ get_regs_type (struct symbol *func_sym, struct objfile *objfile)
 	   regsp_type->code (), GCC_FE_WRAPPER_FUNCTION,
 	   objfile_name (objfile));
 
-  regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
+  regs_type = check_typedef (regsp_type->target_type ());
   if (regs_type->code () != TYPE_CODE_STRUCT)
     error (_("Invalid type code %d of dereferenced first parameter "
 	     "of function \"%s\" in compiled module \"%s\"."),
@@ -685,7 +685,7 @@ compile_object_load (const compile_file_names &file_names,
 	     "module \"%s\"."),
 	   func_type->num_fields (), GCC_FE_WRAPPER_FUNCTION,
 	   objfile_name (objfile));
-  if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
+  if (!types_deeply_equal (expect_return_type, func_type->target_type ()))
     error (_("Invalid return type of function \"%s\" in compiled "
 	     "module \"%s\"."),
 	   GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index e734effe7f0..837eafc52f1 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -220,7 +220,7 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
 	return {};
 
 
-      type = check_typedef (TYPE_TARGET_TYPE (lang_this.symbol->type ()));
+      type = check_typedef (lang_this.symbol->type ()->target_type ());
       /* If TYPE_NAME is NULL, abandon trying to find this symbol.
 	 This can happen for lambda functions compiled with clang++,
 	 which outputs no name for the container class.  */
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index 807c944a97c..1891bac4f9b 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -212,10 +212,10 @@ inspect_type (struct demangle_parse_info *info,
 	      struct type *last = otype;
 
 	      /* Find the last typedef for the type.  */
-	      while (TYPE_TARGET_TYPE (last) != NULL
-		     && (TYPE_TARGET_TYPE (last)->code ()
+	      while (last->target_type () != NULL
+		     && (last->target_type ()->code ()
 			 == TYPE_CODE_TYPEDEF))
-		last = TYPE_TARGET_TYPE (last);
+		last = last->target_type ();
 
 	      /* If there is only one typedef for this anonymous type,
 		 do not substitute it.  */
@@ -1336,7 +1336,7 @@ add_symbol_overload_list_adl_namespace (struct type *type,
       if (type->code () == TYPE_CODE_TYPEDEF)
 	type = check_typedef (type);
       else
-	type = TYPE_TARGET_TYPE (type);
+	type = type->target_type ();
     }
 
   type_name = type->name ();
diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index 1d7dafcb149..07bbb9b262e 100644
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -78,10 +78,10 @@ cp_is_vtbl_member (struct type *type)
      structures.  Nowadays it points directly to the structure.  */
   if (type->code () == TYPE_CODE_PTR)
     {
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
       if (type->code () == TYPE_CODE_ARRAY)
 	{
-	  type = TYPE_TARGET_TYPE (type);
+	  type = type->target_type ();
 	  if (type->code () == TYPE_CODE_STRUCT    /* if not using thunks */
 	      || type->code () == TYPE_CODE_PTR)   /* if using thunks */
 	    {
@@ -589,7 +589,7 @@ cp_print_static_field (struct type *type,
     {
       struct type **first_dont_print;
       int i;
-      struct type *target_type = TYPE_TARGET_TYPE (type);
+      struct type *target_type = type->target_type ();
 
       first_dont_print
 	= (struct type **) obstack_base (&dont_print_stat_array_obstack);
diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index b37030b3295..561534f9ebe 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -789,13 +789,13 @@ add_array_cv_type (struct ctf_context *ccp,
   base_type = copy_type (base_type);
   inner_array = base_type;
 
-  while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
+  while (inner_array->target_type ()->code () == TYPE_CODE_ARRAY)
     {
-      inner_array->set_target_type (copy_type (TYPE_TARGET_TYPE (inner_array)));
-      inner_array = TYPE_TARGET_TYPE (inner_array);
+      inner_array->set_target_type (copy_type (inner_array->target_type ()));
+      inner_array = inner_array->target_type ();
     }
 
-  el_type = TYPE_TARGET_TYPE (inner_array);
+  el_type = inner_array->target_type ();
   cnst |= TYPE_CONST (el_type);
   voltl |= TYPE_VOLATILE (el_type);
   inner_array->set_target_type (make_cv_type (cnst, voltl, el_type, nullptr));
@@ -936,7 +936,7 @@ read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
   else
     this_type->set_target_type (nullptr);
 
-  this_type->set_target_is_stub (TYPE_TARGET_TYPE (this_type) != nullptr);
+  this_type->set_target_is_stub (this_type->target_type () != nullptr);
 
   return set_tid_type (objfile, tid, this_type);
 }
diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index 5af042abb11..eb459a4df76 100644
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -130,7 +130,7 @@ d_lookup_symbol (const struct language_defn *langdef,
 	  if (lang_this.symbol == NULL)
 	    return {};
 
-	  type = check_typedef (TYPE_TARGET_TYPE (lang_this.symbol->type ()));
+	  type = check_typedef (lang_this.symbol->type ()->target_type ());
 	  classname = type->name ();
 	  nested = name;
 	}
diff --git a/gdb/d-valprint.c b/gdb/d-valprint.c
index 647a0288cf0..85b3da378f5 100644
--- a/gdb/d-valprint.c
+++ b/gdb/d-valprint.c
@@ -53,7 +53,7 @@ dynamic_array_type (struct type *type,
       length = unpack_field_as_long (type, valaddr + embedded_offset, 0);
 
       ptr_type = type->field (1).type ();
-      elttype = check_typedef (TYPE_TARGET_TYPE (ptr_type));
+      elttype = check_typedef (ptr_type->target_type ());
       addr = unpack_pointer (ptr_type,
 			     valaddr + type->field (1).loc_bitpos () / 8
 			     + embedded_offset);
diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c
index bf0df613f24..9463f483554 100644
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -1338,7 +1338,7 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
 			  union call_site_parameter_u kind_u)
 {
   struct type *checked_type = check_typedef (type);
-  struct type *target_type = TYPE_TARGET_TYPE (checked_type);
+  struct type *target_type = checked_type->target_type ();
   struct frame_info *caller_frame = get_prev_frame (frame);
   struct value *outer_val, *target_val, *val;
   struct call_site_parameter *parameter;
@@ -1360,7 +1360,7 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
      entry value.  */
 
   if (!TYPE_IS_REFERENCE (checked_type)
-      || TYPE_TARGET_TYPE (checked_type) == NULL)
+      || checked_type->target_type () == NULL)
     return outer_val;
 
   target_val = dwarf_entry_parameter_to_value (parameter,
@@ -1430,16 +1430,16 @@ fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset,
   if (bytes != NULL)
     {
       if (byte_offset >= 0
-	  && byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) <= len)
+	  && byte_offset + TYPE_LENGTH (type->target_type ()) <= len)
 	{
 	  bytes += byte_offset;
-	  result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
+	  result = value_from_contents (type->target_type (), bytes);
 	}
       else
 	invalid_synthetic_pointer ();
     }
   else
-    result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
+    result = allocate_optimized_out_value (type->target_type ());
 
   return result;
 }
@@ -1476,7 +1476,7 @@ indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset,
     return dwarf2_evaluate_loc_desc_full (orig_type, frame, baton.data,
 					  baton.size, baton.per_cu,
 					  baton.per_objfile,
-					  TYPE_TARGET_TYPE (type),
+					  type->target_type (),
 					  byte_offset);
   else
     return fetch_const_value_from_synthetic_pointer (die, byte_offset, per_cu,
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 7ef0c1957a7..8155c7c165b 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -9060,7 +9060,7 @@ dwarf2_compute_name (const char *name,
 		  if (type->num_fields () > 0
 		      && TYPE_FIELD_ARTIFICIAL (type, 0)
 		      && type->field (0).type ()->code () == TYPE_CODE_PTR
-		      && TYPE_CONST (TYPE_TARGET_TYPE (type->field (0).type ())))
+		      && TYPE_CONST (type->field (0).type ()->target_type ()))
 		    buf.puts (" const");
 		}
 	    }
@@ -14125,7 +14125,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
       /* TYPE is the domain of this method, and THIS_TYPE is the type
 	   of the method itself (TYPE_CODE_METHOD).  */
       smash_to_method_type (fnp->type, type,
-			    TYPE_TARGET_TYPE (this_type),
+			    this_type->target_type (),
 			    this_type->fields (),
 			    this_type->num_fields (),
 			    this_type->has_varargs ());
@@ -14226,8 +14226,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
 		}
 	      else
 		{
-		  fnp->fcontext
-		    = TYPE_TARGET_TYPE (this_type->field (0).type ());
+		  fnp->fcontext = this_type->field (0).type ()->target_type ();
 		}
 	    }
 	}
@@ -14328,19 +14327,19 @@ quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
   pfn_type = type->field (0).type ();
   if (pfn_type == NULL
       || pfn_type->code () != TYPE_CODE_PTR
-      || TYPE_TARGET_TYPE (pfn_type)->code () != TYPE_CODE_FUNC)
+      || pfn_type->target_type ()->code () != TYPE_CODE_FUNC)
     return;
 
   /* Look for the "this" argument.  */
-  pfn_type = TYPE_TARGET_TYPE (pfn_type);
+  pfn_type = pfn_type->target_type ();
   if (pfn_type->num_fields () == 0
       /* || pfn_type->field (0).type () == NULL */
       || pfn_type->field (0).type ()->code () != TYPE_CODE_PTR)
     return;
 
-  self_type = TYPE_TARGET_TYPE (pfn_type->field (0).type ());
+  self_type = pfn_type->field (0).type ()->target_type ();
   new_type = alloc_type (objfile);
-  smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
+  smash_to_method_type (new_type, self_type, pfn_type->target_type (),
 			pfn_type->fields (), pfn_type->num_fields (),
 			pfn_type->has_varargs ());
   smash_to_methodptr_type (type, new_type);
@@ -14360,7 +14359,7 @@ rewrite_array_type (struct type *type)
   range_bounds *current_bounds = index_type->bounds ();
 
   /* Handle multi-dimensional arrays.  */
-  struct type *new_target = rewrite_array_type (TYPE_TARGET_TYPE (type));
+  struct type *new_target = rewrite_array_type (type->target_type ());
   if (new_target == nullptr)
     {
       /* Maybe we don't need to rewrite this array.  */
@@ -14428,7 +14427,7 @@ quirk_ada_thick_pointer_struct (struct die_info *die, struct dwarf2_cu *cu,
      because those may be referenced in other contexts where this
      rewriting is undesirable.  */
   struct type *new_ary_type
-    = rewrite_array_type (TYPE_TARGET_TYPE (type->field (0).type ()));
+    = rewrite_array_type (type->field (0).type ()->target_type ());
   if (new_ary_type != nullptr)
     type->field (0).set_type (lookup_pointer_type (new_ary_type));
 }
@@ -15226,9 +15225,9 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
      can tell us the reality.  However, we defer to a local size
      attribute if one exists, because this lets the compiler override
      the underlying type if needed.  */
-  if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_TARGET_TYPE (type)->is_stub ())
+  if (type->target_type () != NULL && !type->target_type ()->is_stub ())
     {
-      struct type *underlying_type = TYPE_TARGET_TYPE (type);
+      struct type *underlying_type = type->target_type ();
       underlying_type = check_typedef (underlying_type);
 
       type->set_is_unsigned (underlying_type->is_unsigned ());
@@ -15543,7 +15542,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
       iter->main_type->dyn_prop_list = nullptr;
       iter->set_index_type
 	(create_static_range_type (NULL, bounds->field (i).type (), 1, 0));
-      iter = TYPE_TARGET_TYPE (iter);
+      iter = iter->target_type ();
     }
 
   struct type *result = alloc_type (objfile);
@@ -16224,7 +16223,7 @@ read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
     {
       struct type *new_type = alloc_type (cu->per_objfile->objfile);
 
-      smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
+      smash_to_method_type (new_type, domain, to_type->target_type (),
 			    to_type->fields (), to_type->num_fields (),
 			    to_type->has_varargs ());
       type = lookup_methodptr_type (new_type);
@@ -16284,13 +16283,13 @@ add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
   base_type = copy_type (base_type);
   inner_array = base_type;
 
-  while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
+  while (inner_array->target_type ()->code () == TYPE_CODE_ARRAY)
     {
-      inner_array->set_target_type (copy_type (TYPE_TARGET_TYPE (inner_array)));
-      inner_array = TYPE_TARGET_TYPE (inner_array);
+      inner_array->set_target_type (copy_type (inner_array->target_type ()));
+      inner_array = inner_array->target_type ();
     }
 
-  el_type = TYPE_TARGET_TYPE (inner_array);
+  el_type = inner_array->target_type ();
   cnst |= TYPE_CONST (el_type);
   voltl |= TYPE_VOLATILE (el_type);
   inner_array->set_target_type (make_cv_type (cnst, voltl, el_type, NULL));
diff --git a/gdb/elfread.c b/gdb/elfread.c
index 13dbaf0227a..77e58655879 100644
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -983,7 +983,7 @@ elf_gnu_ifunc_resolver_return_stop (code_breakpoint *b)
   thread_info *thread = inferior_thread ();
   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
   struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
-  struct type *value_type = TYPE_TARGET_TYPE (func_func_type);
+  struct type *value_type = func_func_type->target_type ();
   struct regcache *regcache = get_thread_regcache (thread);
   struct value *func_func;
   struct value *value;
diff --git a/gdb/eval.c b/gdb/eval.c
index ce1d883aa86..ddbdd95b39c 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -439,7 +439,7 @@ ptrmath_type_p (const struct language_defn *lang, struct type *type)
 {
   type = check_typedef (type);
   if (TYPE_IS_REFERENCE (type))
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
 
   switch (type->code ())
     {
@@ -649,7 +649,7 @@ evaluate_subexp_do_call (expression *exp, enum noside noside,
 		ftype = resolved_type;
 	    }
 
-	  type *return_type = TYPE_TARGET_TYPE (ftype);
+	  type *return_type = ftype->target_type ();
 
 	  if (return_type == NULL)
 	    return_type = default_return_type;
@@ -690,7 +690,7 @@ operation::evaluate_funcall (struct type *expect_type,
   value *callee = evaluate_with_coercion (exp, noside);
   struct type *type = value_type (callee);
   if (type->code () == TYPE_CODE_PTR)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
   for (int i = 0; i < args.size (); ++i)
     {
       if (i < type->num_fields ())
@@ -831,7 +831,7 @@ structop_member_base::evaluate_funcall (struct type *expect_type,
   if (a1_type->code () == TYPE_CODE_METHODPTR)
     {
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
-	callee = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
+	callee = value_zero (a1_type->target_type (), not_lval);
       else
 	callee = cplus_method_ptr_to_value (&lhs, rhs);
 
@@ -842,7 +842,7 @@ structop_member_base::evaluate_funcall (struct type *expect_type,
       struct type *type_ptr
 	= lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
       struct type *target_type_ptr
-	= lookup_pointer_type (TYPE_TARGET_TYPE (a1_type));
+	= lookup_pointer_type (a1_type->target_type ());
 
       /* Now, convert this value to an address.  */
       lhs = value_cast (type_ptr, lhs);
@@ -1038,7 +1038,7 @@ structop_base_operation::complete (struct expression *exp,
       type = check_typedef (type);
       if (!type->is_pointer_or_reference ())
 	break;
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
     }
 
   if (type->code () == TYPE_CODE_UNION
@@ -1068,7 +1068,7 @@ is_integral_or_integral_reference (struct type *type)
   type = check_typedef (type);
   return (type != nullptr
 	  && TYPE_IS_REFERENCE (type)
-	  && is_integral_type (TYPE_TARGET_TYPE (type)));
+	  && is_integral_type (type->target_type ()));
 }
 
 /* Helper function that implements the body of OP_SCOPE.  */
@@ -1258,8 +1258,8 @@ eval_op_structop_ptr (struct type *expect_type, struct expression *exp,
     struct value_print_options opts;
 
     get_user_print_options (&opts);
-    if (opts.objectprint && TYPE_TARGET_TYPE (arg_type)
-	&& (TYPE_TARGET_TYPE (arg_type)->code () == TYPE_CODE_STRUCT))
+    if (opts.objectprint && arg_type->target_type ()
+	&& (arg_type->target_type ()->code () == TYPE_CODE_STRUCT))
       {
 	real_type = value_rtti_indirect_type (arg1, &full, &top,
 					      &using_enc);
@@ -1290,7 +1290,7 @@ eval_op_member (struct type *expect_type, struct expression *exp,
     {
     case TYPE_CODE_METHODPTR:
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
-	return value_zero (TYPE_TARGET_TYPE (type), not_lval);
+	return value_zero (type->target_type (), not_lval);
       else
 	{
 	  arg2 = cplus_method_ptr_to_value (&arg1, arg2);
@@ -1305,7 +1305,7 @@ eval_op_member (struct type *expect_type, struct expression *exp,
 
       mem_offset = value_as_long (arg2);
 
-      arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+      arg3 = value_from_pointer (lookup_pointer_type (type->target_type ()),
 				 value_as_long (arg1) + mem_offset);
       return value_ind (arg3);
 
@@ -1436,7 +1436,7 @@ eval_op_subscript (struct type *expect_type, struct expression *exp,
 	}
 
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
-	return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
+	return value_zero (type->target_type (), VALUE_LVAL (arg1));
       else
 	return value_subscript (arg1, value_as_long (arg2));
     }
@@ -1677,12 +1677,12 @@ eval_op_ind (struct type *expect_type, struct expression *exp,
 	 in the inferior, but being able to print accurate type
 	 information seems worth the risk. */
       if (!type->is_pointer_or_reference ()
-	  || !is_dynamic_type (TYPE_TARGET_TYPE (type)))
+	  || !is_dynamic_type (type->target_type ()))
 	{
 	  if (type->is_pointer_or_reference ()
 	      /* In C you can dereference an array to get the 1st elt.  */
 	      || type->code () == TYPE_CODE_ARRAY)
-	    return value_zero (TYPE_TARGET_TYPE (type),
+	    return value_zero (type->target_type (),
 			       lval_memory);
 	  else if (type->code () == TYPE_CODE_INT)
 	    /* GDB allows dereferencing an int.  */
@@ -2145,8 +2145,8 @@ eval_op_objc_msgcall (struct type *expect_type, struct expression *exp,
       struct type *callee_type = value_type (called_method);
 
       if (callee_type && callee_type->code () == TYPE_CODE_PTR)
-	callee_type = TYPE_TARGET_TYPE (callee_type);
-      callee_type = TYPE_TARGET_TYPE (callee_type);
+	callee_type = callee_type->target_type ();
+      callee_type = callee_type->target_type ();
 
       if (callee_type)
 	{
@@ -2439,7 +2439,7 @@ array_operation::evaluate (struct type *expect_type,
       && type->code () == TYPE_CODE_ARRAY)
     {
       struct type *range_type = type->index_type ();
-      struct type *element_type = TYPE_TARGET_TYPE (type);
+      struct type *element_type = type->target_type ();
       struct value *array = allocate_value (expect_type);
       int element_size = TYPE_LENGTH (check_typedef (element_type));
       LONGEST low_bound, high_bound, index;
@@ -2483,7 +2483,7 @@ array_operation::evaluate (struct type *expect_type,
       /* Get targettype of elementtype.  */
       while (check_type->code () == TYPE_CODE_RANGE
 	     || check_type->code () == TYPE_CODE_TYPEDEF)
-	check_type = TYPE_TARGET_TYPE (check_type);
+	check_type = check_type->target_type ();
 
       if (!get_discrete_bounds (element_type, &low_bound, &high_bound))
 	error (_("(power)set type with unknown size"));
@@ -2503,9 +2503,9 @@ array_operation::evaluate (struct type *expect_type,
 	     different types. Also check if type of element is "compatible"
 	     with element type of powerset.  */
 	  if (range_low_type->code () == TYPE_CODE_RANGE)
-	    range_low_type = TYPE_TARGET_TYPE (range_low_type);
+	    range_low_type = range_low_type->target_type ();
 	  if (range_high_type->code () == TYPE_CODE_RANGE)
-	    range_high_type = TYPE_TARGET_TYPE (range_high_type);
+	    range_high_type = range_high_type->target_type ();
 	  if ((range_low_type->code () != range_high_type->code ())
 	      || (range_low_type->code () == TYPE_CODE_ENUM
 		  && (range_low_type != range_high_type)))
@@ -2577,7 +2577,7 @@ evaluate_subexp_for_address_base (struct expression *exp, enum noside noside,
       struct type *type = check_typedef (value_type (x));
 
       if (TYPE_IS_REFERENCE (type))
-	return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+	return value_zero (lookup_pointer_type (type->target_type ()),
 			   not_lval);
       else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
 	return value_zero (lookup_pointer_type (value_type (x)),
@@ -2709,7 +2709,7 @@ var_value_operation::evaluate_with_coercion (struct expression *exp,
     {
       struct value *val = address_of_variable (var,
 					       std::get<0> (m_storage).block);
-      return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)), val);
+      return value_cast (lookup_pointer_type (type->target_type ()), val);
     }
   return evaluate (nullptr, exp, noside);
 }
@@ -2729,7 +2729,7 @@ evaluate_subexp_for_sizeof_base (struct expression *exp, struct type *type)
   type = check_typedef (type);
   if (exp->language_defn->la_language == language_cplus
       && (TYPE_IS_REFERENCE (type)))
-    type = check_typedef (TYPE_TARGET_TYPE (type));
+    type = check_typedef (type->target_type ());
   return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
 }
 
@@ -2771,7 +2771,7 @@ subscript_operation::evaluate_for_sizeof (struct expression *exp,
       struct type *type = check_typedef (value_type (val));
       if (type->code () == TYPE_CODE_ARRAY)
 	{
-	  type = check_typedef (TYPE_TARGET_TYPE (type));
+	  type = check_typedef (type->target_type ());
 	  if (type->code () == TYPE_CODE_ARRAY)
 	    {
 	      type = type->index_type ();
@@ -2803,7 +2803,7 @@ unop_ind_base_operation::evaluate_for_sizeof (struct expression *exp,
   if (!type->is_pointer_or_reference ()
       && type->code () != TYPE_CODE_ARRAY)
     error (_("Attempt to take contents of a non-pointer value."));
-  type = TYPE_TARGET_TYPE (type);
+  type = type->target_type ();
   if (is_dynamic_type (type))
     type = value_type (value_ind (val));
   /* FIXME: This should be size_t.  */
diff --git a/gdb/expop.h b/gdb/expop.h
index cfe96cbe589..635580da220 100644
--- a/gdb/expop.h
+++ b/gdb/expop.h
@@ -1508,7 +1508,7 @@ class unop_ind_base_operation
 		   enum noside noside) override
   {
     if (expect_type != nullptr && expect_type->code () == TYPE_CODE_PTR)
-      expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
+      expect_type = check_typedef (expect_type)->target_type ();
     value *val = std::get<0> (m_storage)->evaluate (expect_type, exp, noside);
     return eval_op_ind (expect_type, exp, noside, val);
   }
diff --git a/gdb/f-array-walker.h b/gdb/f-array-walker.h
index ad97dd51cd3..b4c8f987bb2 100644
--- a/gdb/f-array-walker.h
+++ b/gdb/f-array-walker.h
@@ -46,7 +46,7 @@ class fortran_array_offset_calculator
       error ("unable to read array bounds");
 
     /* Figure out the stride for this array.  */
-    struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (type));
+    struct type *elt_type = check_typedef (type->target_type ());
     m_stride = type->index_type ()->bounds ()->bit_stride ();
     if (m_stride == 0)
       m_stride = type_length_units (elt_type);
@@ -230,13 +230,13 @@ class fortran_array_walker
 
     m_nss++;
     gdb_assert (range_type->code () == TYPE_CODE_RANGE);
-    m_impl.start_dimension (TYPE_TARGET_TYPE (range_type),
+    m_impl.start_dimension (range_type->target_type (),
 			    upperbound - lowerbound + 1,
 			    m_nss == m_ndimensions);
 
     if (m_nss != m_ndimensions)
       {
-	struct type *subarray_type = TYPE_TARGET_TYPE (check_typedef (type));
+	struct type *subarray_type = check_typedef (type)->target_type ();
 
 	/* For dimensions other than the inner most, walk each element and
 	   recurse while peeling off one more dimension of the array.  */
@@ -258,7 +258,7 @@ class fortran_array_walker
       }
     else
       {
-	struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (type));
+	struct type *elt_type = check_typedef (type)->target_type ();
 
 	/* For the inner most dimension of the array, process each element
 	   within this dimension.  */
diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index 4b15950187e..422e5310e97 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -162,7 +162,7 @@ fortran_bounds_all_dims (bool lbound_p,
       value_contents_copy (result, dst_offset, v, 0, elm_len);
 
       /* Peel another dimension of the array.  */
-      array_type = TYPE_TARGET_TYPE (array_type);
+      array_type = array_type->target_type ();
     }
 
   return result;
@@ -208,7 +208,7 @@ fortran_bounds_for_dimension (bool lbound_p, value *array, value *dim_val,
 	}
 
       /* Peel off another dimension of the array.  */
-      array_type = TYPE_TARGET_TYPE (array_type);
+      array_type = array_type->target_type ();
     }
 
   gdb_assert_not_reached ("failed to find matching dimension");
@@ -230,7 +230,7 @@ calc_f77_array_dims (struct type *array_type)
 
   tmp_type = array_type;
 
-  while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
+  while ((tmp_type = tmp_type->target_type ()))
     {
       if (tmp_type->code () == TYPE_CODE_ARRAY)
 	++ndimen;
@@ -435,13 +435,13 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
 
   struct type *pointer_target_type;
   if (pointer_type->code () == TYPE_CODE_PTR)
-    pointer_target_type = TYPE_TARGET_TYPE (pointer_type);
+    pointer_target_type = pointer_type->target_type ();
   else
     pointer_target_type = pointer_type;
 
   struct type *target_target_type;
   if (target_type->code () == TYPE_CODE_PTR)
-    target_target_type = TYPE_TARGET_TYPE (target_type);
+    target_target_type = target_type->target_type ();
   else
     target_target_type = target_type;
 
@@ -530,12 +530,12 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
 	  if (pointer_stride == 0)
 	    pointer_stride
 	      = type_length_units (check_typedef
-				     (TYPE_TARGET_TYPE (pointer_type))) * 8;
+				     (pointer_type->target_type ())) * 8;
 	  target_stride = target_range->bounds ()->bit_stride ();
 	  if (target_stride == 0)
 	    target_stride
 	      = type_length_units (check_typedef
-				     (TYPE_TARGET_TYPE (target_type))) * 8;
+				     (target_type->target_type ())) * 8;
 	  if (pointer_stride != target_stride)
 	    break;
 
@@ -634,7 +634,7 @@ fortran_array_size (value *array, value *dim_val, type *result_type)
 	}
 
       /* Peel off another dimension of the array.  */
-      array_type = TYPE_TARGET_TYPE (array_type);
+      array_type = array_type->target_type ();
     }
 
   return value_from_longest (result_type, result);
@@ -747,7 +747,7 @@ fortran_array_shape (struct gdbarch *gdbarch, const language_defn *lang,
       value_contents_copy (result, dst_offset, v, 0, elm_len);
 
       /* Peel another dimension of the array.  */
-      val_type = TYPE_TARGET_TYPE (val_type);
+      val_type = val_type->target_type ();
     }
 
   return result;
@@ -1016,11 +1016,11 @@ eval_op_f_kind (struct type *expect_type, struct expression *exp,
       error (_("argument to kind must be an intrinsic type"));
     }
 
-  if (!TYPE_TARGET_TYPE (type))
+  if (!type->target_type ())
     return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
 			       TYPE_LENGTH (type));
   return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
-			     TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
+			     TYPE_LENGTH (type->target_type ()));
 }
 
 /* A helper function for UNOP_FORTRAN_ALLOCATED.  */
@@ -1139,7 +1139,7 @@ fortran_undetermined::value_subarray (value *array,
     for (int i = 0; i < ndimensions; ++i)
       {
 	dim_types.push_back (type);
-	type = TYPE_TARGET_TYPE (type);
+	type = type->target_type ();
       }
     /* TYPE is now the inner element type of the array, we start the new
        array slice off as this type, then as we process the requested slice
@@ -1228,7 +1228,7 @@ fortran_undetermined::value_subarray (value *array,
 	    error (_("stride must not be 0"));
 
 	  /* Get information about this dimension in the original ARRAY.  */
-	  struct type *target_type = TYPE_TARGET_TYPE (dim_type);
+	  struct type *target_type = dim_type->target_type ();
 	  struct type *index_type = dim_type->index_type ();
 	  LONGEST lb = f77_get_lowerbound (dim_type);
 	  LONGEST ub = f77_get_upperbound (dim_type);
@@ -1330,7 +1330,7 @@ fortran_undetermined::value_subarray (value *array,
 	    = value_as_long (ops[i]->evaluate_with_coercion (exp, noside));
 
 	  /* Get information about this dimension in the original ARRAY.  */
-	  struct type *target_type = TYPE_TARGET_TYPE (dim_type);
+	  struct type *target_type = dim_type->target_type ();
 	  struct type *index_type = dim_type->index_type ();
 	  LONGEST lb = f77_get_lowerbound (dim_type);
 	  LONGEST ub = f77_get_upperbound (dim_type);
@@ -1395,7 +1395,7 @@ fortran_undetermined::value_subarray (value *array,
 
       struct type *new_range
 	= create_range_type_with_stride ((struct type *) NULL,
-					 TYPE_TARGET_TYPE (d.index),
+					 d.index->target_type (),
 					 &p_low, &p_high, 0, &p_stride,
 					 true);
       array_slice_type
@@ -1431,7 +1431,7 @@ fortran_undetermined::value_subarray (value *array,
 
 	  struct type *new_range
 	    = create_range_type_with_stride ((struct type *) NULL,
-					     TYPE_TARGET_TYPE (d.index),
+					     d.index->target_type (),
 					     &p_low, &p_high, 0, &p_stride,
 					     true);
 	  repacked_array_type
@@ -1503,7 +1503,7 @@ fortran_undetermined::evaluate (struct type *expect_type,
 	 So we need to look into its target type to see if it is
 	 array, string or function.  If it is, we need to switch
 	 to the target value the original one points to.  */
-      struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *target_type = check_typedef (type->target_type ());
 
       if (target_type->code () == TYPE_CODE_ARRAY
 	  || target_type->code () == TYPE_CODE_STRING
@@ -1989,7 +1989,7 @@ fortran_adjust_dynamic_array_base_address_hack (struct type *type,
 	error ("failed to get range bounds");
 
       /* Figure out the stride for this dimension.  */
-      struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
+      struct type *elt_type = check_typedef (tmp_type->target_type ());
       stride = tmp_type->index_type ()->bounds ()->bit_stride ();
       if (stride == 0)
 	stride = type_length_units (elt_type);
@@ -2007,7 +2007,7 @@ fortran_adjust_dynamic_array_base_address_hack (struct type *type,
       if (stride < 0 && lowerbound < upperbound)
 	offset = (upperbound - lowerbound) * stride;
       total_offset += offset;
-      tmp_type = TYPE_TARGET_TYPE (tmp_type);
+      tmp_type = tmp_type->target_type ();
     }
 
   /* Adjust the address of this object and return it.  */
diff --git a/gdb/f-lang.h b/gdb/f-lang.h
index 181f837f1db..0107a08e98e 100644
--- a/gdb/f-lang.h
+++ b/gdb/f-lang.h
@@ -197,7 +197,7 @@ class f_language : public language_defn
     type = check_typedef (type);
     return (type->code () == TYPE_CODE_STRING
 	    || (type->code () == TYPE_CODE_ARRAY
-		&& TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_CHAR));
+		&& type->target_type ()->code () == TYPE_CODE_CHAR));
   }
 
   /* See language.h.  */
diff --git a/gdb/f-typeprint.c b/gdb/f-typeprint.c
index 170187c6749..2e4c281f96c 100644
--- a/gdb/f-typeprint.c
+++ b/gdb/f-typeprint.c
@@ -64,10 +64,10 @@ f_language::print_type (struct type *type, const char *varstring,
 	      || code == TYPE_CODE_ARRAY
 	      || ((code == TYPE_CODE_PTR
 		   || code == TYPE_CODE_REF)
-		  && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC
-		      || (TYPE_TARGET_TYPE (type)->code ()
+		  && (type->target_type ()->code () == TYPE_CODE_FUNC
+		      || (type->target_type ()->code ()
 			  == TYPE_CODE_METHOD)
-		      || (TYPE_TARGET_TYPE (type)->code ()
+		      || (type->target_type ()->code ()
 			  == TYPE_CODE_ARRAY))))))
     gdb_puts (" ", stream);
   f_type_print_varspec_prefix (type, stream, show, 0);
@@ -105,17 +105,17 @@ f_language::f_type_print_varspec_prefix (struct type *type,
   switch (type->code ())
     {
     case TYPE_CODE_PTR:
-      f_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
+      f_type_print_varspec_prefix (type->target_type (), stream, 0, 1);
       break;
 
     case TYPE_CODE_FUNC:
-      f_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+      f_type_print_varspec_prefix (type->target_type (), stream, 0, 0);
       if (passed_a_ptr)
 	gdb_printf (stream, "(");
       break;
 
     case TYPE_CODE_ARRAY:
-      f_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+      f_type_print_varspec_prefix (type->target_type (), stream, 0, 0);
       break;
 
     case TYPE_CODE_UNDEF:
@@ -187,8 +187,8 @@ f_language::f_type_print_varspec_suffix (struct type *type,
 	  print_rank_only = true;
 	}
 
-      if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY)
-	f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
+      if (type->target_type ()->code () == TYPE_CODE_ARRAY)
+	f_type_print_varspec_suffix (type->target_type (), stream, 0,
 				     0, 0, arrayprint_recurse_level,
 				     print_rank_only);
 
@@ -213,8 +213,8 @@ f_language::f_type_print_varspec_suffix (struct type *type,
 	    }
 	}
 
-      if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_ARRAY)
-	f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
+      if (type->target_type ()->code () != TYPE_CODE_ARRAY)
+	f_type_print_varspec_suffix (type->target_type (), stream, 0,
 				     0, 0, arrayprint_recurse_level,
 				     print_rank_only);
 
@@ -227,7 +227,7 @@ f_language::f_type_print_varspec_suffix (struct type *type,
 
     case TYPE_CODE_PTR:
     case TYPE_CODE_REF:
-      f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0,
+      f_type_print_varspec_suffix (type->target_type (), stream, 0, 1, 0,
 				   arrayprint_recurse_level, false);
       gdb_printf (stream, " )");
       break;
@@ -236,7 +236,7 @@ f_language::f_type_print_varspec_suffix (struct type *type,
       {
 	int i, nfields = type->num_fields ();
 
-	f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
+	f_type_print_varspec_suffix (type->target_type (), stream, 0,
 				     passed_a_ptr, 0,
 				     arrayprint_recurse_level, false);
 	if (passed_a_ptr)
@@ -333,27 +333,27 @@ f_language::f_type_print_base (struct type *type, struct ui_file *stream,
   switch (type->code ())
     {
     case TYPE_CODE_TYPEDEF:
-      f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
+      f_type_print_base (type->target_type (), stream, 0, level);
       break;
 
     case TYPE_CODE_ARRAY:
-      f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
+      f_type_print_base (type->target_type (), stream, show, level);
       break;
     case TYPE_CODE_FUNC:
-      if (TYPE_TARGET_TYPE (type) == NULL)
+      if (type->target_type () == NULL)
 	type_print_unknown_return_type (stream);
       else
-	f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
+	f_type_print_base (type->target_type (), stream, show, level);
       break;
 
     case TYPE_CODE_PTR:
       gdb_printf (stream, "%*sPTR TO -> ( ", level, "");
-      f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, 0);
+      f_type_print_base (type->target_type (), stream, show, 0);
       break;
 
     case TYPE_CODE_REF:
       gdb_printf (stream, "%*sREF TO -> ( ", level, "");
-      f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, 0);
+      f_type_print_base (type->target_type (), stream, show, 0);
       break;
 
     case TYPE_CODE_VOID:
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 6a3f83c2194..544657d5850 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -82,9 +82,9 @@ f77_get_dynamic_length_of_aggregate (struct type *type)
      This function also works for strings which behave very 
      similarly to arrays.  */
 
-  if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
-      || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRING)
-    f77_get_dynamic_length_of_aggregate (TYPE_TARGET_TYPE (type));
+  if (type->target_type ()->code () == TYPE_CODE_ARRAY
+      || type->target_type ()->code () == TYPE_CODE_STRING)
+    f77_get_dynamic_length_of_aggregate (type->target_type ());
 
   /* Recursion ends here, start setting up lengths.  */
   lower_bound = f77_get_lowerbound (type);
@@ -94,7 +94,7 @@ f77_get_dynamic_length_of_aggregate (struct type *type)
 
   TYPE_LENGTH (type) =
     (upper_bound - lower_bound + 1)
-    * TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type)));
+    * TYPE_LENGTH (check_typedef (type->target_type ()));
 }
 
 /* Per-dimension statistics.  */
@@ -339,7 +339,7 @@ class fortran_array_printer_impl : public fortran_array_walker_base_impl
 			 LONGEST offset1, LONGEST offset2)
   {
     if (type->code () == TYPE_CODE_ARRAY
-	&& TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_CHAR)
+	&& type->target_type ()->code () != TYPE_CODE_CHAR)
       {
 	/* Extract the range, and get lower and upper bounds.  */
 	struct type *range_type = check_typedef (type)->index_type ();
@@ -350,7 +350,7 @@ class fortran_array_printer_impl : public fortran_array_walker_base_impl
 	/* CALC is used to calculate the offsets for each element.  */
 	fortran_array_offset_calculator calc (type);
 
-	struct type *subarray_type = check_typedef (TYPE_TARGET_TYPE (type));
+	struct type *subarray_type = check_typedef (type->target_type ());
 	for (LONGEST i = lowerbound; i < upperbound + 1; i++)
 	  {
 	    /* Use the index and the stride to work out a new offset.  */
@@ -452,11 +452,11 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
       break;
 
     case TYPE_CODE_ARRAY:
-      if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_CHAR)
+      if (type->target_type ()->code () != TYPE_CODE_CHAR)
 	fortran_print_array (type, address, stream, recurse, val, options);
       else
 	{
-	  struct type *ch_type = TYPE_TARGET_TYPE (type);
+	  struct type *ch_type = type->target_type ();
 
 	  f77_get_dynamic_length_of_aggregate (type);
 	  printstr (stream, ch_type, valaddr,
@@ -476,7 +476,7 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
 	  int want_space = 0;
 
 	  addr = unpack_pointer (type, valaddr);
-	  elttype = check_typedef (TYPE_TARGET_TYPE (type));
+	  elttype = check_typedef (type->target_type ());
 
 	  if (elttype->code () == TYPE_CODE_FUNC)
 	    {
@@ -503,7 +503,7 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
 	    {
 	      if (want_space)
 		gdb_puts (" ", stream);
-	      val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
+	      val_print_string (type->target_type (), NULL, addr, -1,
 				stream, options);
 	    }
 	  return;
diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index 8029080c043..4a2bf03b0bf 100644
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -1251,7 +1251,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       else if (abi == FRV_ABI_FDPIC
 	       && len == 4
 	       && typecode == TYPE_CODE_PTR
-	       && TYPE_TARGET_TYPE (arg_type)->code () == TYPE_CODE_FUNC)
+	       && arg_type->target_type ()->code () == TYPE_CODE_FUNC)
 	{
 	  /* The FDPIC ABI requires function descriptors to be passed instead
 	     of entry points.  */
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 12fc12dd0ac..843e0efb321 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -266,7 +266,7 @@ get_target_type (struct type *type)
 {
   if (type != NULL)
     {
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
       if (type != NULL)
 	type = check_typedef (type);
     }
@@ -1056,10 +1056,10 @@ get_discrete_low_bound (struct type *type)
 
 	LONGEST low = type->bounds ()->low.const_val ();
 
-	if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM)
+	if (type->target_type ()->code () == TYPE_CODE_ENUM)
 	  {
 	    gdb::optional<LONGEST> low_pos
-	      = discrete_position (TYPE_TARGET_TYPE (type), low);
+	      = discrete_position (type->target_type (), low);
 
 	    if (low_pos.has_value ())
 	      low = *low_pos;
@@ -1127,10 +1127,10 @@ get_discrete_high_bound (struct type *type)
 
 	LONGEST high = type->bounds ()->high.const_val ();
 
-	if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM)
+	if (type->target_type ()->code () == TYPE_CODE_ENUM)
 	  {
 	    gdb::optional<LONGEST> high_pos
-	      = discrete_position (TYPE_TARGET_TYPE (type), high);
+	      = discrete_position (type->target_type (), high);
 
 	    if (high_pos.has_value ())
 	      high = *high_pos;
@@ -1248,7 +1248,7 @@ gdb::optional<LONGEST>
 discrete_position (struct type *type, LONGEST val)
 {
   if (type->code () == TYPE_CODE_RANGE)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
 
   if (type->code () == TYPE_CODE_ENUM)
     {
@@ -1292,7 +1292,7 @@ update_static_array_size (struct type *type)
       if (!get_discrete_bounds (range_type, &low_bound, &high_bound))
 	low_bound = high_bound = 0;
 
-      element_type = check_typedef (TYPE_TARGET_TYPE (type));
+      element_type = check_typedef (type->target_type ());
       /* Be careful when setting the array length.  Ada arrays can be
 	 empty arrays with the high_bound being smaller than the low_bound.
 	 In such cases, the array length should be zero.  */
@@ -1513,10 +1513,10 @@ make_vector_type (struct type *array_type)
   /* Find the innermost array type, in case the array is
      multi-dimensional.  */
   inner_array = array_type;
-  while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
-    inner_array = TYPE_TARGET_TYPE (inner_array);
+  while (inner_array->target_type ()->code () == TYPE_CODE_ARRAY)
+    inner_array = inner_array->target_type ();
 
-  elt_type = TYPE_TARGET_TYPE (inner_array);
+  elt_type = inner_array->target_type ();
   if (elt_type->code () == TYPE_CODE_INT)
     {
       type_instance_flags flags
@@ -1840,7 +1840,7 @@ lookup_struct_elt (struct type *type, const char *name, int noerr)
       if (type->code () != TYPE_CODE_PTR
 	  && type->code () != TYPE_CODE_REF)
 	break;
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
     }
 
   if (type->code () != TYPE_CODE_STRUCT
@@ -2085,7 +2085,7 @@ is_dynamic_type_internal (struct type *type, int top_level)
 
   /* We only want to recognize references at the outermost level.  */
   if (top_level && type->code () == TYPE_CODE_REF)
-    type = check_typedef (TYPE_TARGET_TYPE (type));
+    type = check_typedef (type->target_type ());
 
   /* Types that have a dynamic TYPE_DATA_LOCATION are considered
      dynamic, even if the type itself is statically defined.
@@ -2121,7 +2121,7 @@ is_dynamic_type_internal (struct type *type, int top_level)
 	   of the range type are static.  It allows us to assume that
 	   the subtype of a static range type is also static.  */
 	return (!has_static_range (type->bounds ())
-		|| is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0));
+		|| is_dynamic_type_internal (type->target_type (), 0));
       }
 
     case TYPE_CODE_STRING:
@@ -2135,7 +2135,7 @@ is_dynamic_type_internal (struct type *type, int top_level)
 	if (is_dynamic_type_internal (type->index_type (), 0))
 	  return 1;
 	/* ... or the elements it contains have a dynamic contents...  */
-	if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0))
+	if (is_dynamic_type_internal (type->target_type (), 0))
 	  return 1;
 	/* ... or if it has a dynamic stride...  */
 	if (array_type_has_dynamic_stride (type))
@@ -2259,7 +2259,7 @@ resolve_dynamic_range (struct type *dyn_range_type,
     }
 
   static_target_type
-    = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type),
+    = resolve_dynamic_type_internal (dyn_range_type->target_type (),
 				     addr_stack, 0);
   LONGEST bias = dyn_range_type->bounds ()->bias;
   static_range_type = create_range_type_with_stride
@@ -2340,7 +2340,7 @@ resolve_dynamic_array_or_string_1 (struct type *type,
   range_type
     = resolve_dynamic_range (range_type, addr_stack, rank, resolve_p);
 
-  ary_dim = check_typedef (TYPE_TARGET_TYPE (type));
+  ary_dim = check_typedef (type->target_type ());
   if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY)
     {
       ary_dim = copy_type (ary_dim);
@@ -2348,7 +2348,7 @@ resolve_dynamic_array_or_string_1 (struct type *type,
 						    rank - 1, resolve_p);
     }
   else
-    elt_type = TYPE_TARGET_TYPE (type);
+    elt_type = type->target_type ();
 
   prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
   if (prop != NULL && resolve_p)
@@ -2405,7 +2405,7 @@ resolve_dynamic_array_or_string (struct type *type,
 	     function.  In this case the resolved type should not be an
 	     array, but should instead be that of an array element.  */
 	  struct type *dynamic_array_type = type;
-	  type = copy_type (TYPE_TARGET_TYPE (dynamic_array_type));
+	  type = copy_type (dynamic_array_type->target_type ());
 	  struct dynamic_prop_list *prop_list
 	    = TYPE_MAIN_TYPE (dynamic_array_type)->dyn_prop_list;
 	  if (prop_list != nullptr)
@@ -2434,12 +2434,12 @@ resolve_dynamic_array_or_string (struct type *type,
 	     and so on, until eventually, we have the element type at the
 	     end of the chain.  Create all the additional array types here
 	     by copying the top level array type.  */
-	  struct type *element_type = TYPE_TARGET_TYPE (type);
+	  struct type *element_type = type->target_type ();
 	  struct type *rank_type = type;
 	  for (int i = 1; i < rank; i++)
 	    {
 	      rank_type->set_target_type (copy_type (rank_type));
-	      rank_type = TYPE_TARGET_TYPE (rank_type);
+	      rank_type = rank_type->target_type ();
 	    }
 	  rank_type->set_target_type (element_type);
 	}
@@ -2448,9 +2448,9 @@ resolve_dynamic_array_or_string (struct type *type,
     {
       rank = 1;
 
-      for (struct type *tmp_type = check_typedef (TYPE_TARGET_TYPE (type));
+      for (struct type *tmp_type = check_typedef (type->target_type ());
 	   tmp_type->code () == TYPE_CODE_ARRAY;
-	   tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type)))
+	   tmp_type = check_typedef (tmp_type->target_type ()))
 	++rank;
     }
 
@@ -2812,7 +2812,7 @@ resolve_dynamic_type_internal (struct type *type,
     {
       resolved_type = copy_type (type);
       resolved_type->set_target_type
-	(resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type), addr_stack,
+	(resolve_dynamic_type_internal (type->target_type (), addr_stack,
 					top_level));
     }
   else
@@ -2826,7 +2826,7 @@ resolve_dynamic_type_internal (struct type *type,
 	  {
 	    struct property_addr_info pinfo;
 
-	    pinfo.type = check_typedef (TYPE_TARGET_TYPE (type));
+	    pinfo.type = check_typedef (type->target_type ());
 	    pinfo.valaddr = {};
 	    if (addr_stack->valaddr.data () != NULL)
 	      pinfo.addr = extract_typed_address (addr_stack->valaddr.data (),
@@ -2837,7 +2837,7 @@ resolve_dynamic_type_internal (struct type *type,
 
 	    resolved_type = copy_type (type);
 	    resolved_type->set_target_type
-	      (resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type),
+	      (resolve_dynamic_type_internal (type->target_type (),
 					      &pinfo, top_level));
 	    break;
 	  }
@@ -3014,7 +3014,7 @@ check_typedef (struct type *type)
 
   while (type->code () == TYPE_CODE_TYPEDEF)
     {
-      if (!TYPE_TARGET_TYPE (type))
+      if (!type->target_type ())
 	{
 	  const char *name;
 	  struct symbol *sym;
@@ -3038,7 +3038,7 @@ check_typedef (struct type *type)
 	  else					/* TYPE_CODE_UNDEF */
 	    type->set_target_type (alloc_type_arch (type->arch ()));
 	}
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
 
       /* Preserve the instance flags as we traverse down the typedef chain.
 
@@ -3138,7 +3138,7 @@ check_typedef (struct type *type)
 
   if (type->target_is_stub ())
     {
-      struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *target_type = check_typedef (type->target_type ());
 
       if (target_type->is_stub () || target_type->target_is_stub ())
 	{
@@ -3299,7 +3299,7 @@ check_stub_method (struct type *type, int method_id, int signature_id)
   mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
   /* MTYPE may currently be a function (TYPE_CODE_FUNC).
      We want a method (TYPE_CODE_METHOD).  */
-  smash_to_method_type (mtype, type, TYPE_TARGET_TYPE (mtype),
+  smash_to_method_type (mtype, type, mtype->target_type (),
 			argtypes, argcount, p[-2] == '.');
   mtype->set_is_stub (false);
   TYPE_FN_FIELD_STUB (f, signature_id) = 0;
@@ -3671,7 +3671,7 @@ type_align (struct type *type)
     case TYPE_CODE_ARRAY:
     case TYPE_CODE_COMPLEX:
     case TYPE_CODE_TYPEDEF:
-      align = type_align (TYPE_TARGET_TYPE (type));
+      align = type_align (type->target_type ());
       break;
 
     case TYPE_CODE_STRUCT:
@@ -3760,7 +3760,7 @@ can_dereference (struct type *t)
   return
     (t != NULL
      && t->code () == TYPE_CODE_PTR
-     && TYPE_TARGET_TYPE (t)->code () != TYPE_CODE_VOID);
+     && t->target_type ()->code () != TYPE_CODE_VOID);
 }
 
 int
@@ -3828,7 +3828,7 @@ is_scalar_type_recursive (struct type *t)
 	   && t->index_type ()->code () == TYPE_CODE_RANGE)
     {
       LONGEST low_bound, high_bound;
-      struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
+      struct type *elt_type = check_typedef (t->target_type ());
 
       if (get_discrete_bounds (t->index_type (), &low_bound, &high_bound))
 	return (high_bound == low_bound
@@ -4253,8 +4253,8 @@ types_equal (struct type *a, struct type *b)
      of the same type.  */
   if (a->code () == TYPE_CODE_PTR
       || a->code () == TYPE_CODE_REF)
-    return types_equal (TYPE_TARGET_TYPE (a),
-			TYPE_TARGET_TYPE (b));
+    return types_equal (a->target_type (),
+			b->target_type ());
 
   /* Well, damnit, if the names are exactly the same, I'll say they
      are exactly the same.  This happens when we generate method
@@ -4274,7 +4274,7 @@ types_equal (struct type *a, struct type *b)
       if (a->num_fields () != b->num_fields ())
 	return false;
       
-      if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
+      if (!types_equal (a->target_type (), b->target_type ()))
 	return false;
 
       for (i = 0; i < a->num_fields (); ++i)
@@ -4407,15 +4407,15 @@ check_types_equal (struct type *type1, struct type *type2,
 	}
     }
 
-  if (TYPE_TARGET_TYPE (type1) != NULL)
+  if (type1->target_type () != NULL)
     {
-      if (TYPE_TARGET_TYPE (type2) == NULL)
+      if (type2->target_type () == NULL)
 	return false;
 
-      worklist->emplace_back (TYPE_TARGET_TYPE (type1),
-			      TYPE_TARGET_TYPE (type2));
+      worklist->emplace_back (type1->target_type (),
+			      type2->target_type ());
     }
-  else if (TYPE_TARGET_TYPE (type2) != NULL)
+  else if (type2->target_type () != NULL)
     return false;
 
   return true;
@@ -4504,12 +4504,12 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value
 
       /* Allowed pointer conversions are:
 	 (a) pointer to void-pointer conversion.  */
-      if (TYPE_TARGET_TYPE (parm)->code () == TYPE_CODE_VOID)
+      if (parm->target_type ()->code () == TYPE_CODE_VOID)
 	return VOID_PTR_CONVERSION_BADNESS;
 
       /* (b) pointer to ancestor-pointer conversion.  */
-      rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
-					   TYPE_TARGET_TYPE (arg),
+      rank.subrank = distance_to_ancestor (parm->target_type (),
+					   arg->target_type (),
 					   0);
       if (rank.subrank >= 0)
 	return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
@@ -4517,8 +4517,8 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value
       return INCOMPATIBLE_TYPE_BADNESS;
     case TYPE_CODE_ARRAY:
       {
-	struct type *t1 = TYPE_TARGET_TYPE (parm);
-	struct type *t2 = TYPE_TARGET_TYPE (arg);
+	struct type *t1 = parm->target_type ();
+	struct type *t2 = arg->target_type ();
 
 	if (types_equal (t1, t2))
 	  {
@@ -4534,7 +4534,7 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value
 	return INCOMPATIBLE_TYPE_BADNESS;
       }
     case TYPE_CODE_FUNC:
-      return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
+      return rank_one_type (parm->target_type (), arg, NULL);
     case TYPE_CODE_INT:
       if (value != NULL && value_type (value)->code () == TYPE_CODE_INT)
 	{
@@ -4571,8 +4571,8 @@ rank_one_type_parm_array (struct type *parm, struct type *arg, struct value *val
     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ARRAY:
-      return rank_one_type (TYPE_TARGET_TYPE (parm),
-			    TYPE_TARGET_TYPE (arg), NULL);
+      return rank_one_type (parm->target_type (),
+			    arg->target_type (), NULL);
     default:
       return INCOMPATIBLE_TYPE_BADNESS;
     }
@@ -4586,7 +4586,7 @@ rank_one_type_parm_func (struct type *parm, struct type *arg, struct value *valu
   switch (arg->code ())
     {
     case TYPE_CODE_PTR:	/* funcptr -> func */
-      return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
+      return rank_one_type (parm, arg->target_type (), NULL);
     default:
       return INCOMPATIBLE_TYPE_BADNESS;
     }
@@ -4909,7 +4909,7 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value)
 	     lvalue references.  */
 	  if (parm->code () == TYPE_CODE_RVALUE_REF)
 	    rank.subrank = REFERENCE_CONVERSION_RVALUE;
-	  else if (TYPE_CONST (TYPE_TARGET_TYPE (parm)))
+	  else if (TYPE_CONST (parm->target_type ()))
 	    rank.subrank = REFERENCE_CONVERSION_CONST_LVALUE;
 	  else
 	    return INCOMPATIBLE_TYPE_BADNESS;
@@ -4931,8 +4931,8 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value)
       /* For pointers and references, compare target type.  */
       if (parm->is_pointer_or_reference ())
 	{
-	  t1 = TYPE_TARGET_TYPE (parm);
-	  t2 = TYPE_TARGET_TYPE (arg);
+	  t1 = parm->target_type ();
+	  t2 = arg->target_type ();
 	}
 
       /* Make sure they are CV equal, too.  */
@@ -4949,10 +4949,10 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value)
      references.  */
 
   if (TYPE_IS_REFERENCE (arg))
-    return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
+    return (sum_ranks (rank_one_type (parm, arg->target_type (), NULL),
 		       REFERENCE_SEE_THROUGH_BADNESS));
   if (TYPE_IS_REFERENCE (parm))
-    return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
+    return (sum_ranks (rank_one_type (parm->target_type (), arg, NULL),
 		       REFERENCE_SEE_THROUGH_BADNESS));
   if (overload_debug)
     {
@@ -5354,10 +5354,10 @@ recursive_dump_type (struct type *type, int spaces)
     gdb_printf ("%*sgdbarch %s\n", spaces, "",
 		host_address_to_string (type->arch_owner ()));
   gdb_printf ("%*starget_type %s\n", spaces, "",
-	      host_address_to_string (TYPE_TARGET_TYPE (type)));
-  if (TYPE_TARGET_TYPE (type) != NULL)
+	      host_address_to_string (type->target_type ()));
+  if (type->target_type () != NULL)
     {
-      recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
+      recursive_dump_type (type->target_type (), spaces + 2);
     }
   gdb_printf ("%*spointer_type %s\n", spaces, "",
 	      host_address_to_string (TYPE_POINTER_TYPE (type)));
@@ -5727,9 +5727,9 @@ copy_type_recursive (struct type *type, htab_t copied_types)
 
 
   /* Copy pointers to other types.  */
-  if (TYPE_TARGET_TYPE (type))
+  if (type->target_type ())
     new_type->set_target_type
-      (copy_type_recursive (TYPE_TARGET_TYPE (type), copied_types));
+      (copy_type_recursive (type->target_type (), copied_types));
 
   /* Maybe copy the type_specific bits.
 
@@ -6110,7 +6110,7 @@ bool
 is_fixed_point_type (struct type *type)
 {
   while (check_typedef (type)->code () == TYPE_CODE_RANGE)
-    type = TYPE_TARGET_TYPE (check_typedef (type));
+    type = check_typedef (type)->target_type ();
   type = check_typedef (type);
 
   return type->code () == TYPE_CODE_FIXED_POINT;
@@ -6124,7 +6124,7 @@ type::fixed_point_type_base_type ()
   struct type *type = this;
 
   while (check_typedef (type)->code () == TYPE_CODE_RANGE)
-    type = TYPE_TARGET_TYPE (check_typedef (type));
+    type = check_typedef (type)->target_type ();
   type = check_typedef (type);
 
   gdb_assert (type->code () == TYPE_CODE_FIXED_POINT);
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 48076749187..6f4b2d61ca8 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -105,7 +105,7 @@ enum type_code
        Regardless of the language, GDB represents multidimensional
        array types the way C does: as arrays of arrays.  So an
        instance of a GDB array type T can always be seen as a series
-       of instances of TYPE_TARGET_TYPE (T) laid out sequentially in
+       of instances of T->target_type () laid out sequentially in
        memory.
 
        Row-major languages like C lay out multi-dimensional arrays so
@@ -1256,7 +1256,7 @@ struct type
   }
 
   /* Used only for TYPE_CODE_FUNC where it specifies the real function
-     address is returned by this function call.  TYPE_TARGET_TYPE
+     address is returned by this function call.  The target_type method
      determines the final returned function type to be presented to
      user.  */
 
@@ -2097,7 +2097,6 @@ extern void allocate_gnat_aux_type (struct type *);
    allocate_fixed_point_type_info (type))
 
 #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
-#define TYPE_TARGET_TYPE(thistype) ((thistype)->target_type ())
 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 #define TYPE_RVALUE_REFERENCE_TYPE(thistype) (thistype)->rvalue_reference_type
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index 3c4430dcd46..dd550691489 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -108,7 +108,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
     fcontext = TYPE_VPTR_BASETYPE (type);
   context = lookup_pointer_type (fcontext);
   /* Now context is a pointer to the basetype containing the vtbl.  */
-  if (TYPE_TARGET_TYPE (context) != type1)
+  if (context->target_type () != type1)
     {
       struct value *tmp = value_cast (context, value_addr (arg1));
 
@@ -133,7 +133,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
   /* With older versions of g++, the vtbl field pointed to an array
      of structures.  Nowadays it points directly to the structure.  */
   if (value_type (vtbl)->code () == TYPE_CODE_PTR
-      && TYPE_TARGET_TYPE (value_type (vtbl))->code () == TYPE_CODE_ARRAY)
+      && value_type (vtbl)->target_type ()->code () == TYPE_CODE_ARRAY)
     {
       /* Handle the case where the vtbl field points to an
 	 array of structures.  */
@@ -323,13 +323,13 @@ vb_match (struct type *type, int index, struct type *basetype)
      nameless types) or have the same name.  This is ugly, and a more
      elegant solution should be devised (which would probably just push
      the ugliness into symbol reading unless we change the stabs format).  */
-  if (TYPE_TARGET_TYPE (fieldtype) == basetype)
+  if (fieldtype->target_type () == basetype)
     return 1;
 
   if (basetype->name () != NULL
-      && TYPE_TARGET_TYPE (fieldtype)->name () != NULL
+      && fieldtype->target_type ()->name () != NULL
       && strcmp (basetype->name (),
-		 TYPE_TARGET_TYPE (fieldtype)->name ()) == 0)
+		 fieldtype->target_type ()->name ()) == 0)
     return 1;
   return 0;
 }
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 61666f2353c..cd2f3715913 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -742,7 +742,7 @@ gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
   self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
   final_type = lookup_pointer_type (self_type);
 
-  method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
+  method_type = check_typedef (value_type (method_ptr))->target_type ();
 
   /* Extract the pointer to member.  */
   gdbarch = self_type->arch ();
@@ -1109,7 +1109,7 @@ gnuv3_get_typeid (struct value *value)
   /* In the non_lvalue case, a reference might have slipped through
      here.  */
   if (type->code () == TYPE_CODE_REF)
-    type = check_typedef (TYPE_TARGET_TYPE (type));
+    type = check_typedef (type->target_type ());
 
   /* Ignore top-level cv-qualifiers.  */
   type = make_cv_type (0, 0, type, NULL);
@@ -1341,7 +1341,7 @@ is_copy_or_move_constructor_type (struct type *class_type,
   if (arg_type->code () != expected)
     return false;
 
-  struct type *target = check_typedef (TYPE_TARGET_TYPE (arg_type));
+  struct type *target = check_typedef (arg_type->target_type ());
   if (!(class_types_same_p (target, class_type)))
     return false;
 
@@ -1538,7 +1538,7 @@ gnuv3_pass_by_reference (struct type *type)
 
 	/* For arrays, make the decision based on the element type.  */
 	if (field_type->code () == TYPE_CODE_ARRAY)
-	  field_type = check_typedef (TYPE_TARGET_TYPE (field_type));
+	  field_type = check_typedef (field_type->target_type ());
 
 	struct language_pass_by_ref_info field_info
 	  = gnuv3_pass_by_reference (field_type);
diff --git a/gdb/go-lang.c b/gdb/go-lang.c
index c56db238525..92d7e60cea2 100644
--- a/gdb/go-lang.c
+++ b/gdb/go-lang.c
@@ -86,7 +86,7 @@ gccgo_string_p (struct type *type)
 	  && type1->code () == TYPE_CODE_INT
 	  && strcmp (type->field (1).name (), "__length") == 0)
 	{
-	  struct type *target_type = TYPE_TARGET_TYPE (type0);
+	  struct type *target_type = type0->target_type ();
 
 	  target_type = check_typedef (target_type);
 
diff --git a/gdb/go-typeprint.c b/gdb/go-typeprint.c
index 4995ac39186..aacc824d13b 100644
--- a/gdb/go-typeprint.c
+++ b/gdb/go-typeprint.c
@@ -52,7 +52,7 @@ go_language::print_type (struct type *type, const char *varstring,
 
   /* Print the type of "abc" as "string", not char[4].  */
   if (type->code () == TYPE_CODE_ARRAY
-      && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_CHAR)
+      && type->target_type ()->code () == TYPE_CODE_CHAR)
     {
       gdb_puts ("string", stream);
       return;
diff --git a/gdb/go-valprint.c b/gdb/go-valprint.c
index 45bd529ba95..e104376b49b 100644
--- a/gdb/go-valprint.c
+++ b/gdb/go-valprint.c
@@ -45,7 +45,7 @@ print_go_string (struct type *type,
 {
   struct gdbarch *gdbarch = type->arch ();
   struct type *elt_ptr_type = type->field (0).type ();
-  struct type *elt_type = TYPE_TARGET_TYPE (elt_ptr_type);
+  struct type *elt_type = elt_ptr_type->target_type ();
   LONGEST length;
   /* TODO(dje): The encapsulation of what a pointer is belongs in value.c.
      I.e. If there's going to be unpack_pointer, there should be
diff --git a/gdb/guile/scm-lazy-string.c b/gdb/guile/scm-lazy-string.c
index 39f010b2762..d260e09b91d 100644
--- a/gdb/guile/scm-lazy-string.c
+++ b/gdb/guile/scm-lazy-string.c
@@ -205,7 +205,7 @@ lsscm_elt_type (lazy_string_smob *ls_smob)
     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ARRAY:
-      return TYPE_TARGET_TYPE (realtype);
+      return realtype->target_type ();
     default:
       /* This is done to preserve existing behaviour.  PR 20769.
 	 E.g., gdb.parse_and_eval("my_int_variable").lazy_string().type.  */
@@ -324,7 +324,7 @@ lsscm_safe_lazy_string_to_value (SCM string, int arg_pos,
 	      /* PR 20786: There's no way to specify an array of length zero.
 		 Record a length of [0,-1] which is how Ada does it.  Anything
 		 we do is broken, but this one possible solution.  */
-	      type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
+	      type = lookup_array_range_type (realtype->target_type (),
 					      0, ls_smob->length - 1);
 	      value = value_at_lazy (type, ls_smob->address);
 	    }
diff --git a/gdb/guile/scm-math.c b/gdb/guile/scm-math.c
index 168fe2d9459..914bb5f51a1 100644
--- a/gdb/guile/scm-math.c
+++ b/gdb/guile/scm-math.c
@@ -65,7 +65,7 @@ enum valscm_binary_opcode
 
 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
 #define STRIP_REFERENCE(TYPE) \
-  ((TYPE->code () == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
+  ((TYPE->code () == TYPE_CODE_REF) ? ((TYPE)->target_type ()) : (TYPE))
 
 /* Helper for vlscm_unop.  Contains all the code that may throw a GDB
    exception.  */
diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c
index 5cb1cabe14d..8914307d1ce 100644
--- a/gdb/guile/scm-type.c
+++ b/gdb/guile/scm-type.c
@@ -683,7 +683,7 @@ tyscm_get_composite (struct type *type)
       if (type->code () != TYPE_CODE_PTR
 	  && type->code () != TYPE_CODE_REF)
 	break;
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
     }
 
   /* If this is not a struct, union, or enum type, raise TypeError
@@ -874,9 +874,9 @@ gdbscm_type_target (SCM self)
     = tyscm_get_type_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
   struct type *type = t_smob->type;
 
-  SCM_ASSERT (TYPE_TARGET_TYPE (type), self, SCM_ARG1, FUNC_NAME);
+  SCM_ASSERT (type->target_type (), self, SCM_ARG1, FUNC_NAME);
 
-  return tyscm_scm_from_type (TYPE_TARGET_TYPE (type));
+  return tyscm_scm_from_type (type->target_type ());
 }
 
 /* (type-const <gdb:type>) -> <gdb:type>
diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c
index 1c88a3add34..4417c2d6204 100644
--- a/gdb/guile/scm-value.c
+++ b/gdb/guile/scm-value.c
@@ -576,7 +576,7 @@ gdbscm_value_dynamic_type (SCM self)
 
       if (((type->code () == TYPE_CODE_PTR)
 	   || (type->code () == TYPE_CODE_REF))
-	  && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT))
+	  && (type->target_type ()->code () == TYPE_CODE_STRUCT))
 	{
 	  struct value *target;
 	  int was_pointer = type->code () == TYPE_CODE_PTR;
@@ -1181,7 +1181,7 @@ gdbscm_value_to_lazy_string (SCM self, SCM rest)
 	      length = array_length;
 	    else if (array_length == -1)
 	      {
-		type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
+		type = lookup_array_range_type (realtype->target_type (),
 						0, length - 1);
 	      }
 	    else if (length != array_length)
@@ -1190,7 +1190,7 @@ gdbscm_value_to_lazy_string (SCM self, SCM rest)
 		   specified length.  */
 		if (length > array_length)
 		  error (_("length is larger than array size"));
-		type = lookup_array_range_type (TYPE_TARGET_TYPE (type),
+		type = lookup_array_range_type (type->target_type (),
 						low_bound,
 						low_bound + length - 1);
 	      }
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 91f9cecdcbc..9e50e04efae 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -1051,7 +1051,7 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       /* If we are passing a function pointer, make sure we pass a function
 	 descriptor instead of the function entry address.  */
       if (type->code () == TYPE_CODE_PTR
-	  && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC)
+	  && type->target_type ()->code () == TYPE_CODE_FUNC)
 	{
 	  ULONGEST codeptr, fptr;
 
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index c652fb9c2a1..abb28262747 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -2647,7 +2647,7 @@ i386_16_byte_align_p (struct type *type)
       && TYPE_LENGTH (type) == 16)
     return 1;
   if (type->code () == TYPE_CODE_ARRAY)
-    return i386_16_byte_align_p (TYPE_TARGET_TYPE (type));
+    return i386_16_byte_align_p (type->target_type ());
   if (type->code () == TYPE_CODE_STRUCT
       || type->code () == TYPE_CODE_UNION)
     {
diff --git a/gdb/i386-windows-tdep.c b/gdb/i386-windows-tdep.c
index 9eec6e28109..eda77a3d21f 100644
--- a/gdb/i386-windows-tdep.c
+++ b/gdb/i386-windows-tdep.c
@@ -116,7 +116,7 @@ i386_windows_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   struct type *type = check_typedef (value_type (function));
   if (type->code () == TYPE_CODE_PTR)
-    type = check_typedef (TYPE_TARGET_TYPE (type));
+    type = check_typedef (type->target_type ());
 
   /* read_subroutine_type sets for non-static member functions the
      artificial flag of the first parameter ('this' pointer).  */
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index b7c1c0decae..a4b59d933ad 100644
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -3341,7 +3341,7 @@ is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
       break;
     case TYPE_CODE_ARRAY:
       return
-	is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t)),
+	is_float_or_hfa_type_recurse (check_typedef (t->target_type ()),
 				      etp);
       break;
     case TYPE_CODE_STRUCT:
@@ -3393,7 +3393,7 @@ slot_alignment_is_next_even (struct type *t)
 	return 0;
     case TYPE_CODE_ARRAY:
       return
-	slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t)));
+	slot_alignment_is_next_even (check_typedef (t->target_type ()));
     case TYPE_CODE_STRUCT:
       {
 	int i;
@@ -3747,7 +3747,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       /* Special handling for function parameters.  */
       if (len == 8
 	  && type->code () == TYPE_CODE_PTR
-	  && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC)
+	  && type->target_type ()->code () == TYPE_CODE_FUNC)
 	{
 	  gdb_byte val_buf[8];
 	  ULONGEST faddr = extract_unsigned_integer
diff --git a/gdb/infcall.c b/gdb/infcall.c
index dd70682bc76..471e9cc8b7f 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -183,7 +183,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
 	   convert it back to a reference.  This will issue an error
 	   if the value was not previously in memory - in some cases
 	   we should clearly be allowing this, but how?  */
-	new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
+	new_value = value_cast (type->target_type (), arg);
 	new_value = value_ref (new_value, type->code ());
 	return new_value;
       }
@@ -221,7 +221,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
 	 because they are passed by value.  */
       if (current_language->c_style_arrays_p ())
 	if (!type->is_vector ())
-	  type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+	  type = lookup_pointer_type (type->target_type ());
       break;
     case TYPE_CODE_UNDEF:
     case TYPE_CODE_PTR:
@@ -266,7 +266,7 @@ find_function_addr (struct value *function,
   else if (ftype->code () == TYPE_CODE_PTR)
     {
       funaddr = value_as_address (function);
-      ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+      ftype = check_typedef (ftype->target_type ());
       if (ftype->code () == TYPE_CODE_FUNC
 	  || ftype->code () == TYPE_CODE_METHOD)
 	funaddr = gdbarch_convert_from_func_ptr_addr
@@ -295,13 +295,13 @@ find_function_addr (struct value *function,
 		target_ftype = find_gnu_ifunc_target_type (resolver_addr);
 	      if (target_ftype != NULL)
 		{
-		  value_type = TYPE_TARGET_TYPE (check_typedef (target_ftype));
+		  value_type = check_typedef (target_ftype)->target_type ();
 		  ftype = target_ftype;
 		}
 	    }
 	}
       else
-	value_type = TYPE_TARGET_TYPE (ftype);
+	value_type = ftype->target_type ();
     }
   else if (ftype->code () == TYPE_CODE_INT)
     {
@@ -1027,7 +1027,7 @@ call_function_by_hand_dummy (struct value *function,
 	 prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
       if (ftype->code () == TYPE_CODE_METHOD)
 	prototyped = 1;
-      else if (TYPE_TARGET_TYPE (ftype) == NULL && ftype->num_fields () == 0
+      else if (ftype->target_type () == NULL && ftype->num_fields () == 0
 	       && default_return_type != NULL)
 	{
 	  /* Calling a no-debug function with the return type
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 69a7896b560..a6c5518c955 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1466,7 +1466,7 @@ get_return_value (struct symbol *func_symbol, struct value *function)
   struct value *value;
 
   struct type *value_type
-    = check_typedef (TYPE_TARGET_TYPE (func_symbol->type ()));
+    = check_typedef (func_symbol->type ()->target_type ());
   gdb_assert (value_type->code () != TYPE_CODE_VOID);
 
   if (is_nocall_function (check_typedef (::value_type (function))))
@@ -1626,7 +1626,7 @@ finish_command_fsm::should_stop (struct thread_info *tp)
       /* We're done.  */
       set_finished ();
 
-      rv->type = TYPE_TARGET_TYPE (function->type ());
+      rv->type = function->type ()->target_type ();
       if (rv->type == NULL)
 	internal_error (__FILE__, __LINE__,
 			_("finish_command: function has no target type"));
diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
index e5fe1c62466..3852195f9bb 100644
--- a/gdb/iq2000-tdep.c
+++ b/gdb/iq2000-tdep.c
@@ -89,13 +89,13 @@ iq2000_pointer_to_address (struct gdbarch *gdbarch,
 			   struct type * type, const gdb_byte * buf)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  enum type_code target = TYPE_TARGET_TYPE (type)->code ();
+  enum type_code target = type->target_type ()->code ();
   CORE_ADDR addr
     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 
   if (target == TYPE_CODE_FUNC
       || target == TYPE_CODE_METHOD
-      || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
+      || TYPE_CODE_SPACE (type->target_type ()))
     addr = insn_addr_from_ptr (addr);
 
   return addr;
@@ -109,7 +109,7 @@ iq2000_address_to_pointer (struct gdbarch *gdbarch,
 			   struct type *type, gdb_byte *buf, CORE_ADDR addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  enum type_code target = TYPE_TARGET_TYPE (type)->code ();
+  enum type_code target = type->target_type ()->code ();
 
   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
     addr = insn_ptr_from_addr (addr);
@@ -599,7 +599,7 @@ iq2000_pass_8bytetype_by_address (struct type *type)
 
   /* Skip typedefs.  */
   while (type->code () == TYPE_CODE_TYPEDEF)
-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();
   /* Non-struct and non-union types are always passed by value.  */
   if (type->code () != TYPE_CODE_STRUCT
       && type->code () != TYPE_CODE_UNION)
@@ -614,7 +614,7 @@ iq2000_pass_8bytetype_by_address (struct type *type)
     return 1;
   /* Skip typedefs of field type.  */
   while (ftype->code () == TYPE_CODE_TYPEDEF)
-    ftype = TYPE_TARGET_TYPE (ftype);
+    ftype = ftype->target_type ();
   /* If field is int or float, pass by value.  */
   if (ftype->code () == TYPE_CODE_FLT
       || ftype->code () == TYPE_CODE_INT)
diff --git a/gdb/language.c b/gdb/language.c
index bc784a8ec79..c2217fe5249 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -601,7 +601,7 @@ language_defn::watch_location_expression (struct type *type,
 					  CORE_ADDR addr) const
 {
   /* Generates an expression that assumes a C like syntax is valid.  */
-  type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
+  type = check_typedef (check_typedef (type)->target_type ());
   std::string name = type_to_string (type);
   return xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr));
 }
@@ -850,7 +850,7 @@ class auto_or_unknown_language : public language_defn
     type = check_typedef (type);
     while (type->code () == TYPE_CODE_REF)
       {
-	type = TYPE_TARGET_TYPE (type);
+	type = type->target_type ();
 	type = check_typedef (type);
       }
     return (type->code () == TYPE_CODE_STRING);
diff --git a/gdb/loongarch-tdep.c b/gdb/loongarch-tdep.c
index 71a2cfb0d86..09af71555df 100644
--- a/gdb/loongarch-tdep.c
+++ b/gdb/loongarch-tdep.c
@@ -1026,7 +1026,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
 	  break;
 	case TYPE_CODE_COMPLEX:
 	  {
-	    struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+	    struct type *target_type = check_typedef (type->target_type ());
 	    size_t target_len = TYPE_LENGTH (target_type);
 
 	    if (target_len < regsize)
diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c
index 6a243bd419c..bc986d5dd0e 100644
--- a/gdb/m2-lang.c
+++ b/gdb/m2-lang.c
@@ -104,7 +104,7 @@ eval_op_m2_subscript (struct type *expect_type, struct expression *exp,
       }
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
+    return value_zero (type->target_type (), VALUE_LVAL (arg1));
   else
     return value_subscript (arg1, value_as_long (arg2));
 }
diff --git a/gdb/m2-lang.h b/gdb/m2-lang.h
index 775312f3cb4..ed79cc8fce6 100644
--- a/gdb/m2-lang.h
+++ b/gdb/m2-lang.h
@@ -119,9 +119,9 @@ class m2_language : public language_defn
     type = check_typedef (type);
     if (type->code () == TYPE_CODE_ARRAY
 	&& TYPE_LENGTH (type) > 0
-	&& TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
+	&& TYPE_LENGTH (type->target_type ()) > 0)
       {
-	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+	struct type *elttype = check_typedef (type->target_type ());
 
 	if (TYPE_LENGTH (elttype) == 1
 	    && (elttype->code () == TYPE_CODE_INT
diff --git a/gdb/m2-typeprint.c b/gdb/m2-typeprint.c
index cbd35df0190..53c7db7da70 100644
--- a/gdb/m2-typeprint.c
+++ b/gdb/m2-typeprint.c
@@ -192,12 +192,12 @@ m2_range (struct type *type, struct ui_file *stream, int show,
     {
       /* FIXME: TYPE_TARGET_TYPE used to be TYPE_DOMAIN_TYPE but that was
 	 wrong.  Not sure if TYPE_TARGET_TYPE is correct though.  */
-      m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+      m2_print_type (type->target_type (), "", stream, show, level,
 		     flags);
     }
   else
     {
-      struct type *target = TYPE_TARGET_TYPE (type);
+      struct type *target = type->target_type ();
 
       gdb_printf (stream, "[");
       print_type_scalar (target, type->bounds ()->low.const_val (), stream);
@@ -216,7 +216,7 @@ m2_typedef (struct type *type, struct ui_file *stream, int show,
       gdb_puts (type->name (), stream);
       gdb_puts (" = ", stream);
     }
-  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
+  m2_print_type (type->target_type (), "", stream, show, level, flags);
 }
 
 /* m2_array - prints out a Modula-2 ARRAY ... OF type.  */
@@ -225,7 +225,7 @@ static void m2_array (struct type *type, struct ui_file *stream,
 		      int show, int level, const struct type_print_options *flags)
 {
   gdb_printf (stream, "ARRAY [");
-  if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
+  if (TYPE_LENGTH (type->target_type ()) > 0
       && type->bounds ()->high.kind () != PROP_UNDEFINED)
     {
       if (type->index_type () != 0)
@@ -236,11 +236,11 @@ static void m2_array (struct type *type, struct ui_file *stream,
 	}
       else
 	gdb_puts (pulongest ((TYPE_LENGTH (type)
-			      / TYPE_LENGTH (TYPE_TARGET_TYPE (type)))),
+			      / TYPE_LENGTH (type->target_type ()))),
 		  stream);
     }
   gdb_printf (stream, "] OF ");
-  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
+  m2_print_type (type->target_type (), "", stream, show, level, flags);
 }
 
 static void
@@ -252,7 +252,7 @@ m2_pointer (struct type *type, struct ui_file *stream, int show,
   else
     gdb_printf (stream, "POINTER TO ");
 
-  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
+  m2_print_type (type->target_type (), "", stream, show, level, flags);
 }
 
 static void
@@ -260,7 +260,7 @@ m2_ref (struct type *type, struct ui_file *stream, int show,
 	int level, const struct type_print_options *flags)
 {
   gdb_printf (stream, "VAR");
-  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
+  m2_print_type (type->target_type (), "", stream, show, level, flags);
 }
 
 static void
@@ -281,8 +281,8 @@ m2_procedure (struct type *type, struct ui_file *stream,
 {
   gdb_printf (stream, "PROCEDURE ");
   m2_type_name (type, stream);
-  if (TYPE_TARGET_TYPE (type) == NULL
-      || TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+  if (type->target_type () == NULL
+      || type->target_type ()->code () != TYPE_CODE_VOID)
     {
       int i, len = type->num_fields ();
 
@@ -297,8 +297,8 @@ m2_procedure (struct type *type, struct ui_file *stream,
 	  m2_print_type (type->field (i).type (), "", stream, -1, 0, flags);
 	}
       gdb_printf (stream, ") : ");
-      if (TYPE_TARGET_TYPE (type) != NULL)
-	m2_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
+      if (type->target_type () != NULL)
+	m2_print_type (type->target_type (), "", stream, 0, 0, flags);
       else
 	type_print_unknown_return_type (stream);
     }
@@ -309,7 +309,7 @@ m2_print_bounds (struct type *type,
 		 struct ui_file *stream, int show, int level,
 		 int print_high)
 {
-  struct type *target = TYPE_TARGET_TYPE (type);
+  struct type *target = type->target_type ();
 
   if (type->num_fields () == 0)
     return;
@@ -414,7 +414,7 @@ m2_is_long_set_of_type (struct type *type, struct type **of_type)
       if (len == 0)
 	return 0;
       range = type->field (i).type ()->index_type ();
-      target = TYPE_TARGET_TYPE (range);
+      target = range->target_type ();
 
       l1 = type->field (i).type ()->bounds ()->low.const_val ();
       h1 = type->field (len - 1).type ()->bounds ()->high.const_val ();
@@ -517,7 +517,7 @@ m2_unbounded_array (struct type *type, struct ui_file *stream, int show,
       if (show > 0)
 	{
 	  gdb_puts ("ARRAY OF ", stream);
-	  m2_print_type (TYPE_TARGET_TYPE (type->field (0).type ()),
+	  m2_print_type (type->field (0).type ()->target_type (),
 			 "", stream, 0, level, flags);
 	}
       return 1;
diff --git a/gdb/m2-valprint.c b/gdb/m2-valprint.c
index 9e3f16a896f..3fb7d42542f 100644
--- a/gdb/m2-valprint.c
+++ b/gdb/m2-valprint.c
@@ -95,7 +95,7 @@ m2_print_long_set (struct type *type, const gdb_byte *valaddr,
       return;
     }
 
-  target = TYPE_TARGET_TYPE (range);
+  target = range->target_type ();
 
   if (get_discrete_bounds (range, &field_low, &field_high))
     {
@@ -139,7 +139,7 @@ m2_print_long_set (struct type *type, const gdb_byte *valaddr,
 	      range = type->field (field).type ()->index_type ();
 	      if (!get_discrete_bounds (range, &field_low, &field_high))
 		break;
-	      target = TYPE_TARGET_TYPE (range);
+	      target = range->target_type ();
 	    }
 	}
       if (element_seen)
@@ -171,7 +171,7 @@ m2_print_unbounded_array (struct value *value,
 			 (type->field (0).loc_bitpos () / 8) +
 			 valaddr);
 
-  val = value_at_lazy (TYPE_TARGET_TYPE (type->field (0).type ()),
+  val = value_at_lazy (type->field (0).type ()->target_type (),
 		       addr);
   len = unpack_field_as_long (type, valaddr, 1);
 
@@ -187,7 +187,7 @@ print_unpacked_pointer (struct type *type,
 			struct ui_file *stream)
 {
   struct gdbarch *gdbarch = type->arch ();
-  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+  struct type *elttype = check_typedef (type->target_type ());
   int want_space = 0;
 
   if (elttype->code () == TYPE_CODE_FUNC)
@@ -214,7 +214,7 @@ print_unpacked_pointer (struct type *type,
     {
       if (want_space)
 	gdb_puts (" ", stream);
-      return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
+      return val_print_string (type->target_type (), NULL, addr, -1,
 			       stream, options);
     }
   
@@ -230,7 +230,7 @@ print_variable_at_address (struct type *type,
 {
   struct gdbarch *gdbarch = type->arch ();
   CORE_ADDR addr = unpack_pointer (type, valaddr);
-  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+  struct type *elttype = check_typedef (type->target_type ());
 
   gdb_printf (stream, "[");
   gdb_puts (paddress (gdbarch, addr), stream);
@@ -239,7 +239,7 @@ print_variable_at_address (struct type *type,
   if (elttype->code () != TYPE_CODE_UNDEF)
     {
       struct value *deref_val =
-	value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
+	value_at (type->target_type (), unpack_pointer (type, valaddr));
 
       common_val_print (deref_val, stream, recurse, options, current_language);
     }
@@ -312,9 +312,9 @@ m2_language::value_print_inner (struct value *val, struct ui_file *stream,
   switch (type->code ())
     {
     case TYPE_CODE_ARRAY:
-      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
+      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (type->target_type ()) > 0)
 	{
-	  elttype = check_typedef (TYPE_TARGET_TYPE (type));
+	  elttype = check_typedef (type->target_type ());
 	  len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
 	  /* For an array of chars, print with string syntax.  */
 	  if (TYPE_LENGTH (elttype) == 1 &&
@@ -337,7 +337,7 @@ m2_language::value_print_inner (struct value *val, struct ui_file *stream,
 		  len = temp_len;
 		}
 
-	      printstr (stream, TYPE_TARGET_TYPE (type), valaddr, len,
+	      printstr (stream, type->target_type (), valaddr, len,
 			NULL, 0, options);
 	    }
 	  else
@@ -443,9 +443,9 @@ m2_language::value_print_inner (struct value *val, struct ui_file *stream,
       break;
 
     case TYPE_CODE_RANGE:
-      if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
+      if (TYPE_LENGTH (type) == TYPE_LENGTH (type->target_type ()))
 	{
-	  struct value *v = value_cast (TYPE_TARGET_TYPE (type), val);
+	  struct value *v = value_cast (type->target_type (), val);
 	  value_print_inner (v, stream, recurse, options);
 	  break;
 	}
diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index 83b7432f491..89a73c8274c 100644
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -2033,7 +2033,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
     /* Dereference function pointer types.  */
     if (func_type->code () == TYPE_CODE_PTR)
-      func_type = TYPE_TARGET_TYPE (func_type);
+      func_type = func_type->target_type ();
 
     gdb_assert (func_type->code () == TYPE_CODE_FUNC ||
 		func_type->code () == TYPE_CODE_METHOD);
@@ -2412,7 +2412,7 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch,
   enum type_code target_code;
   gdb_assert (type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type));
 
-  target_code = TYPE_TARGET_TYPE (type)->code ();
+  target_code = type->target_type ()->code ();
 
   if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
     {
@@ -2493,7 +2493,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
 
   ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 
-  target_code = TYPE_TARGET_TYPE (type)->code ();
+  target_code = type->target_type ()->code ();
 
   if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
     {
diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
index 9e59f5904c3..4f96c7884a3 100644
--- a/gdb/m68k-tdep.c
+++ b/gdb/m68k-tdep.c
@@ -404,7 +404,7 @@ m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
   const bool is_vector = code == TYPE_CODE_ARRAY && type->is_vector ();
 
   if (is_vector
-      && check_typedef (TYPE_TARGET_TYPE (type))->code () == TYPE_CODE_FLT)
+      && check_typedef (type->target_type ())->code () == TYPE_CODE_FLT)
     return 0;
 
   /* According to m68k_return_in_memory in the m68k GCC back-end,
diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index bfd5a6f4680..673c370e120 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -1645,7 +1645,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 	 dereference them.  */
       while (tp->code () == TYPE_CODE_PTR
 	     || tp->code () == TYPE_CODE_ARRAY)
-	tp = TYPE_TARGET_TYPE (tp);
+	tp = tp->target_type ();
 
       /* Make sure that TYPE_CODE(tp) has an expected type code.
 	 Any type may be returned from cross_ref if file indirect entries
@@ -2041,7 +2041,7 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
 
   if (processing_gcc_compilation == 0
       && found_ecoff_debugging_info == 0
-      && TYPE_TARGET_TYPE (s->type ())->code () == TYPE_CODE_VOID)
+      && s->type ()->target_type ()->code () == TYPE_CODE_VOID)
     s->set_type (objfile_type (mdebugread_objfile)->nodebug_text_symbol);
 }
 
diff --git a/gdb/msp430-tdep.c b/gdb/msp430-tdep.c
index 35bea093076..67800a2fff2 100644
--- a/gdb/msp430-tdep.c
+++ b/gdb/msp430-tdep.c
@@ -658,7 +658,7 @@ msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Dereference function pointer types.  */
   while (func_type->code () == TYPE_CODE_PTR)
-    func_type = TYPE_TARGET_TYPE (func_type);
+    func_type = func_type->target_type ();
 
   /* The end result had better be a function or a method.  */
   gdb_assert (func_type->code () == TYPE_CODE_FUNC
diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 1034d1c91fe..32aa58c7211 100644
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -53,9 +53,9 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
 
     return (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
 	    && get_array_bounds (type, &lowb, &highb)
-	    && TYPE_TARGET_TYPE (type)->code () == code
-	    && TYPE_TARGET_TYPE (type)->is_unsigned () == flag_unsigned
-	    && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == el_length
+	    && type->target_type ()->code () == code
+	    && type->target_type ()->is_unsigned () == flag_unsigned
+	    && TYPE_LENGTH (type->target_type ()) == el_length
 	    && TYPE_LENGTH (type) == length
 	    && highb - lowb + 1 == n);
   };
@@ -121,7 +121,7 @@ lval_func_read (struct value *v)
 {
   struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
   struct type *type = check_typedef (value_type (v));
-  struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
+  struct type *eltype = check_typedef (value_type (c->val))->target_type ();
   LONGEST offset = value_offset (v);
   LONGEST elsize = TYPE_LENGTH (eltype);
   int n, i, j = 0;
@@ -150,7 +150,7 @@ lval_func_write (struct value *v, struct value *fromval)
   struct value *mark = value_mark ();
   struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
   struct type *type = check_typedef (value_type (v));
-  struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
+  struct type *eltype = check_typedef (value_type (c->val))->target_type ();
   LONGEST offset = value_offset (v);
   LONGEST elsize = TYPE_LENGTH (eltype);
   int n, i, j = 0;
@@ -198,7 +198,7 @@ lval_func_check_synthetic_pointer (const struct value *v,
   struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
   /* Size of the target type in bits.  */
   int elsize =
-      TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+      TYPE_LENGTH (check_typedef (value_type (c->val))->target_type ()) * 8;
   int startrest = offset % elsize;
   int start = offset / elsize;
   int endrest = (offset + length) % elsize;
@@ -271,7 +271,7 @@ create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
 	      int *indices, int n)
 {
   struct type *type = check_typedef (value_type (val));
-  struct type *elm_type = TYPE_TARGET_TYPE (type);
+  struct type *elm_type = type->target_type ();
   struct value *ret;
 
   /* Check if a single component of a vector is requested which means
@@ -453,7 +453,7 @@ opencl_logical_not (struct type *expect_type, struct expression *exp,
 
   if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
-      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *eltype = check_typedef (type->target_type ());
       LONGEST lowb, highb;
       int i;
 
@@ -547,8 +547,8 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
   if (!t1_is_vec || !t2_is_vec)
     error (_("Vector operations are not supported on scalar types"));
 
-  eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
-  eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
+  eltype1 = check_typedef (type1->target_type ());
+  eltype2 = check_typedef (type2->target_type ());
 
   if (!get_array_bounds (type1,&lowb1, &highb1)
       || !get_array_bounds (type2, &lowb2, &highb2))
@@ -622,7 +622,7 @@ opencl_value_cast (struct type *type, struct value *arg)
 	     value_vector_widen will error if the scalar value is
 	     truncated by the cast.  To avoid the error, cast (and
 	     possibly truncate) here.  */
-	  eltype = check_typedef (TYPE_TARGET_TYPE (to_type));
+	  eltype = check_typedef (to_type->target_type ());
 	  arg = value_cast (eltype, arg);
 
 	  return value_vector_widen (arg, type);
@@ -810,8 +810,8 @@ opencl_ternop_cond_operation::evaluate (struct type *expect_type,
 Cannot perform conditional operation on incompatible types"));
 	}
 
-      eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
-      eltype3 = check_typedef (TYPE_TARGET_TYPE (type3));
+      eltype2 = check_typedef (type2->target_type ());
+      eltype3 = check_typedef (type3->target_type ());
 
       if (!get_array_bounds (type1, &lowb1, &highb1)
 	  || !get_array_bounds (type2, &lowb2, &highb2)
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index 2df41b80ec7..a66729d313c 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -220,7 +220,7 @@ exp1	:	exp
 exp	:	exp '^'   %prec UNARY
 			{ pstate->wrap<unop_ind_operation> ();
 			  if (current_type)
-			    current_type = TYPE_TARGET_TYPE (current_type); }
+			    current_type = current_type->target_type (); }
 	;
 
 exp	:	'@' exp    %prec UNARY
@@ -260,7 +260,7 @@ exp	:	field_exp FIELDNAME
 			      while (current_type->code ()
 				     == TYPE_CODE_PTR)
 				current_type =
-				  TYPE_TARGET_TYPE (current_type);
+				  current_type->target_type ();
 			      current_type = lookup_struct_elt_type (
 				current_type, $2.ptr, 0);
 			    }
@@ -278,7 +278,7 @@ exp	:	field_exp name
 			      while (current_type->code ()
 				     == TYPE_CODE_PTR)
 				current_type =
-				  TYPE_TARGET_TYPE (current_type);
+				  current_type->target_type ();
 			      current_type = lookup_struct_elt_type (
 				current_type, $2.ptr, 0);
 			    }
@@ -321,7 +321,7 @@ exp	:	exp '['
 			{ pop_current_type ();
 			  pstate->wrap2<subscript_operation> ();
 			  if (current_type)
-			    current_type = TYPE_TARGET_TYPE (current_type); }
+			    current_type = current_type->target_type (); }
 	;
 
 exp	:	exp '('
@@ -337,7 +337,7 @@ exp	:	exp '('
 			    (pstate->pop (), std::move (args));
 			  pop_current_type ();
 			  if (current_type)
- 	  		    current_type = TYPE_TARGET_TYPE (current_type);
+ 	  		    current_type = current_type->target_type ();
 			}
 	;
 
@@ -353,7 +353,7 @@ exp	:	type '(' exp ')' %prec UNARY
 			    {
 			      /* Allow automatic dereference of classes.  */
 			      if ((current_type->code () == TYPE_CODE_PTR)
-				  && (TYPE_TARGET_TYPE (current_type)->code () == TYPE_CODE_STRUCT)
+				  && (current_type->target_type ()->code () == TYPE_CODE_STRUCT)
 				  && (($1)->code () == TYPE_CODE_STRUCT))
 				pstate->wrap<unop_ind_operation> ();
 			    }
@@ -598,7 +598,7 @@ exp	:	THIS
 			    {
 			      if (this_type->code () == TYPE_CODE_PTR)
 				{
-				  this_type = TYPE_TARGET_TYPE (this_type);
+				  this_type = this_type->target_type ();
 				  pstate->wrap<unop_ind_operation> ();
 				}
 			    }
diff --git a/gdb/p-lang.c b/gdb/p-lang.c
index 1597e9cf2ff..87590c93bc3 100644
--- a/gdb/p-lang.c
+++ b/gdb/p-lang.c
@@ -108,7 +108,7 @@ pascal_is_string_type (struct type *type,int *length_pos, int *length_size,
 	  if (string_pos)
 	    *string_pos = type->field (1).loc_bitpos () / TARGET_CHAR_BIT;
 	  if (char_type)
-	    *char_type = TYPE_TARGET_TYPE (type->field (1).type ());
+	    *char_type = type->field (1).type ()->target_type ();
 	  if (arrayname)
 	    *arrayname = type->field (1).name ();
 	 return 2;
@@ -130,10 +130,10 @@ pascal_is_string_type (struct type *type,int *length_pos, int *length_size,
 	  /* FIXME: how can I detect wide chars in GPC ??  */
 	  if (char_type)
 	    {
-	      *char_type = TYPE_TARGET_TYPE (type->field (2).type ());
+	      *char_type = type->field (2).type ()->target_type ();
 
 	      if ((*char_type)->code () == TYPE_CODE_ARRAY)
-		*char_type = TYPE_TARGET_TYPE (*char_type);
+		*char_type = (*char_type)->target_type ();
 	    }
 	  if (arrayname)
 	    *arrayname = type->field (2).name ();
diff --git a/gdb/p-typeprint.c b/gdb/p-typeprint.c
index f222f01b429..f83c883fb52 100644
--- a/gdb/p-typeprint.c
+++ b/gdb/p-typeprint.c
@@ -184,7 +184,7 @@ pascal_language::type_print_varspec_prefix (struct type *type,
     {
     case TYPE_CODE_PTR:
       gdb_printf (stream, "^");
-      type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1,
+      type_print_varspec_prefix (type->target_type (), stream, 0, 1,
 					flags);
       break;			/* Pointer should be handled normally
 				   in pascal.  */
@@ -192,8 +192,8 @@ pascal_language::type_print_varspec_prefix (struct type *type,
     case TYPE_CODE_METHOD:
       if (passed_a_ptr)
 	gdb_printf (stream, "(");
-      if (TYPE_TARGET_TYPE (type) != NULL
-	  && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+      if (type->target_type () != NULL
+	  && type->target_type ()->code () != TYPE_CODE_VOID)
 	{
 	  gdb_printf (stream, "function  ");
 	}
@@ -212,7 +212,7 @@ pascal_language::type_print_varspec_prefix (struct type *type,
       break;
 
     case TYPE_CODE_REF:
-      type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1,
+      type_print_varspec_prefix (type->target_type (), stream, 0, 1,
 				 flags);
       gdb_printf (stream, "&");
       break;
@@ -221,8 +221,8 @@ pascal_language::type_print_varspec_prefix (struct type *type,
       if (passed_a_ptr)
 	gdb_printf (stream, "(");
 
-      if (TYPE_TARGET_TYPE (type) != NULL
-	  && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+      if (type->target_type () != NULL
+	  && type->target_type ()->code () != TYPE_CODE_VOID)
 	{
 	  gdb_printf (stream, "function  ");
 	}
@@ -237,7 +237,7 @@ pascal_language::type_print_varspec_prefix (struct type *type,
       if (passed_a_ptr)
 	gdb_printf (stream, "(");
       gdb_printf (stream, "array ");
-      if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
+      if (TYPE_LENGTH (type->target_type ()) > 0
 	  && type->bounds ()->high.kind () != PROP_UNDEFINED)
 	gdb_printf (stream, "[%s..%s] ",
 		    plongest (type->bounds ()->low.const_val ()),
@@ -313,20 +313,20 @@ pascal_language::type_print_func_varspec_suffix  (struct type *type,
 						  int demangled_args,
 						  const struct type_print_options *flags) const
 {
-  if (TYPE_TARGET_TYPE (type) == NULL
-      || TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+  if (type->target_type () == NULL
+      || type->target_type ()->code () != TYPE_CODE_VOID)
     {
       gdb_printf (stream, " : ");
-      type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
+      type_print_varspec_prefix (type->target_type (),
 					stream, 0, 0, flags);
 
-      if (TYPE_TARGET_TYPE (type) == NULL)
+      if (type->target_type () == NULL)
 	type_print_unknown_return_type (stream);
       else
-	type_print_base (TYPE_TARGET_TYPE (type), stream, show, 0,
+	type_print_base (type->target_type (), stream, show, 0,
 				flags);
 
-      type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
+      type_print_varspec_suffix (type->target_type (), stream, 0,
 				 passed_a_ptr, 0, flags);
     }
 }
@@ -365,7 +365,7 @@ pascal_language::type_print_varspec_suffix (struct type *type,
 
     case TYPE_CODE_PTR:
     case TYPE_CODE_REF:
-      type_print_varspec_suffix (TYPE_TARGET_TYPE (type),
+      type_print_varspec_suffix (type->target_type (),
 				 stream, 0, 1, 0, flags);
       break;
 
@@ -428,7 +428,7 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
 
   /* void pointer */
   if ((type->code () == TYPE_CODE_PTR)
-      && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID))
+      && (type->target_type ()->code () == TYPE_CODE_VOID))
     {
       gdb_puts (type->name () ? type->name () : "pointer",
 		stream);
@@ -451,12 +451,12 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
     case TYPE_CODE_TYPEDEF:
     case TYPE_CODE_PTR:
     case TYPE_CODE_REF:
-      type_print_base (TYPE_TARGET_TYPE (type), stream, show, level,
+      type_print_base (type->target_type (), stream, show, level,
 		       flags);
       break;
 
     case TYPE_CODE_ARRAY:
-      print_type (TYPE_TARGET_TYPE (type), NULL, stream, 0, 0, flags);
+      print_type (type->target_type (), NULL, stream, 0, 0, flags);
       break;
 
     case TYPE_CODE_FUNC:
@@ -636,7 +636,7 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
 		  print_spaces (level + 4, stream);
 		  if (TYPE_FN_FIELD_STATIC_P (f, j))
 		    gdb_printf (stream, "static ");
-		  if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
+		  if (TYPE_FN_FIELD_TYPE (f, j)->target_type () == 0)
 		    {
 		      /* Keep GDB from crashing here.  */
 		      gdb_printf (stream, "<undefined type> %s;\n",
@@ -652,8 +652,9 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
 		    {
 		      gdb_printf (stream, "destructor  ");
 		    }
-		  else if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0
-			   && TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE(f, j))->code () != TYPE_CODE_VOID)
+		  else if (TYPE_FN_FIELD_TYPE (f, j)->target_type () != 0
+			   && (TYPE_FN_FIELD_TYPE(f, j)->target_type ()->code ()
+			       != TYPE_CODE_VOID))
 		    {
 		      gdb_printf (stream, "function  ");
 		    }
@@ -665,11 +666,12 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
 
 		  type_print_method_args (physname, method_name, stream);
 
-		  if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0
-		      && TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE(f, j))->code () != TYPE_CODE_VOID)
+		  if (TYPE_FN_FIELD_TYPE (f, j)->target_type () != 0
+		      && (TYPE_FN_FIELD_TYPE(f, j)->target_type ()->code ()
+			  != TYPE_CODE_VOID))
 		    {
 		      gdb_puts (" : ", stream);
-		      type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
+		      type_print (TYPE_FN_FIELD_TYPE (f, j)->target_type (),
 				  "", stream, -1);
 		    }
 		  if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
@@ -739,7 +741,7 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
       /* this probably does not work for enums.  */
     case TYPE_CODE_RANGE:
       {
-	struct type *target = TYPE_TARGET_TYPE (type);
+	struct type *target = type->target_type ();
 
 	print_type_scalar (target, type->bounds ()->low.const_val (), stream);
 	gdb_puts ("..", stream);
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index 43c286d6472..2118a37f078 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -91,7 +91,7 @@ pascal_language::value_print_inner (struct value *val,
 	if (get_array_bounds (type, &low_bound, &high_bound))
 	  {
 	    len = high_bound - low_bound + 1;
-	    elttype = check_typedef (TYPE_TARGET_TYPE (type));
+	    elttype = check_typedef (type->target_type ());
 	    eltlen = TYPE_LENGTH (elttype);
 	    /* If 's' format is used, try to print out as string.
 	       If no format is given, print as string if element type
@@ -116,7 +116,7 @@ pascal_language::value_print_inner (struct value *val,
 		    len = temp_len;
 		  }
 
-		printstr (stream, TYPE_TARGET_TYPE (type), valaddr, len,
+		printstr (stream, type->target_type (), valaddr, len,
 			  NULL, 0, options);
 		i = len;
 	      }
@@ -161,11 +161,11 @@ pascal_language::value_print_inner (struct value *val,
 	  print_address_demangle (options, gdbarch, addr, stream, demangle);
 	  break;
 	}
-      check_typedef (TYPE_TARGET_TYPE (type));
+      check_typedef (type->target_type ());
 
       addr = unpack_pointer (type, valaddr);
     print_unpacked_pointer:
-      elttype = check_typedef (TYPE_TARGET_TYPE (type));
+      elttype = check_typedef (type->target_type ());
 
       if (elttype->code () == TYPE_CODE_FUNC)
 	{
@@ -259,7 +259,7 @@ pascal_language::value_print_inner (struct value *val,
 		}
 	      else
 		{
-		  wtype = TYPE_TARGET_TYPE (type);
+		  wtype = type->target_type ();
 		}
 	      vt_val = value_at (wtype, vt_address);
 	      common_val_print (vt_val, stream, recurse + 1, options,
@@ -423,8 +423,8 @@ pascal_language::value_print (struct value *val, struct ui_file *stream,
 	 type is indicated by the quoted string anyway.  */
       if (type->code () == TYPE_CODE_PTR
 	  && type->name () == NULL
-	  && TYPE_TARGET_TYPE (type)->name () != NULL
-	  && strcmp (TYPE_TARGET_TYPE (type)->name (), "char") == 0)
+	  && type->target_type ()->name () != NULL
+	  && strcmp (type->target_type ()->name (), "char") == 0)
 	{
 	  /* Print nothing.  */
 	}
@@ -482,10 +482,10 @@ pascal_object_is_vtbl_member (struct type *type)
 {
   if (type->code () == TYPE_CODE_PTR)
     {
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
       if (type->code () == TYPE_CODE_ARRAY)
 	{
-	  type = TYPE_TARGET_TYPE (type);
+	  type = type->target_type ();
 	  if (type->code () == TYPE_CODE_STRUCT	/* If not using
 							   thunks.  */
 	      || type->code () == TYPE_CODE_PTR)	/* If using thunks.  */
diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 78bb40e49e4..76f29d6c8de 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -41,7 +41,7 @@ ppc_sysv_use_opencl_abi (struct type *ftype)
   ftype = check_typedef (ftype);
 
   if (ftype->code () == TYPE_CODE_PTR)
-    ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+    ftype = check_typedef (ftype->target_type ());
 
   return (ftype->code () == TYPE_CODE_FUNC
 	  && TYPE_CALLING_CONVENTION (ftype) == DW_CC_GDB_IBM_OpenCL);
@@ -340,7 +340,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	    {
 	      /* OpenCL vectors shorter than 16 bytes are passed as if
 		 a series of independent scalars.  */
-	      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+	      struct type *eltype = check_typedef (type->target_type ());
 	      int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
 
 	      for (i = 0; i < nelt; i++)
@@ -813,7 +813,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
       && TYPE_LENGTH (type) < 16
       && opencl_abi)
     {
-      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *eltype = check_typedef (type->target_type ());
       int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
 
       for (i = 0; i < nelt; i++)
@@ -1093,7 +1093,7 @@ ppc64_aggregate_candidate (struct type *type,
       break;
 
     case TYPE_CODE_COMPLEX:
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
       if (type->code () == TYPE_CODE_FLT
 	  || type->code () == TYPE_CODE_DECFLOAT)
 	{
@@ -1119,7 +1119,7 @@ ppc64_aggregate_candidate (struct type *type,
 	  LONGEST count, low_bound, high_bound;
 
 	  count = ppc64_aggregate_candidate
-		   (TYPE_TARGET_TYPE (type), field_type);
+		   (type->target_type (), field_type);
 	  if (count == -1)
 	    return -1;
 
@@ -1497,7 +1497,7 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch,
 		  || type->code () == TYPE_CODE_REF))
 	    {
 	      struct type *target_type
-		= check_typedef (TYPE_TARGET_TYPE (type));
+		= check_typedef (type->target_type ());
 
 	      if (target_type->code () == TYPE_CODE_FUNC
 		  || target_type->code () == TYPE_CODE_METHOD)
@@ -1695,7 +1695,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
 	  if (type->code () == TYPE_CODE_COMPLEX)
 	    {
 	      /* Complex types are passed as if two independent scalars.  */
-	      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+	      struct type *eltype = check_typedef (type->target_type ());
 
 	      ppc64_sysv_abi_push_param (gdbarch, eltype, val, &argpos);
 	      ppc64_sysv_abi_push_param (gdbarch, eltype,
@@ -1711,7 +1711,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
 	      int i, nelt;
 
 	      if (TYPE_LENGTH (type) < 16)
-		eltype = check_typedef (TYPE_TARGET_TYPE (type));
+		eltype = check_typedef (type->target_type ());
 	      else
 		eltype = register_type (gdbarch, tdep->ppc_vr0_regnum);
 
@@ -1999,7 +1999,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
   /* Complex types are returned as if two independent scalars.  */
   if (valtype->code () == TYPE_CODE_COMPLEX)
     {
-      eltype = check_typedef (TYPE_TARGET_TYPE (valtype));
+      eltype = check_typedef (valtype->target_type ());
 
       for (int i = 0; i < 2; i++)
 	{
@@ -2022,7 +2022,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
       && opencl_abi)
     {
       if (TYPE_LENGTH (valtype) < 16)
-	eltype = check_typedef (TYPE_TARGET_TYPE (valtype));
+	eltype = check_typedef (valtype->target_type ());
       else
 	eltype = register_type (gdbarch, tdep->ppc_vr0_regnum);
 
@@ -2057,8 +2057,8 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
   if (valtype->code () == TYPE_CODE_ARRAY
       && !valtype->is_vector ()
       && TYPE_LENGTH (valtype) <= 8
-      && TYPE_TARGET_TYPE (valtype)->code () == TYPE_CODE_INT
-      && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
+      && valtype->target_type ()->code () == TYPE_CODE_INT
+      && TYPE_LENGTH (valtype->target_type ()) == 1)
     {
       int regnum = tdep->ppc_gp0_regnum + 3;
       int offset = (register_size (gdbarch, regnum) - TYPE_LENGTH (valtype));
diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c
index c80096f6810..c4b043f5bfe 100644
--- a/gdb/python/py-finishbreakpoint.c
+++ b/gdb/python/py-finishbreakpoint.c
@@ -254,7 +254,7 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
 	  if (function != nullptr)
 	    {
 	      struct type *ret_type =
-		check_typedef (TYPE_TARGET_TYPE (function->type ()));
+		check_typedef (function->type ()->target_type ());
 
 	      /* Remember only non-void return types.  */
 	      if (ret_type->code () != TYPE_CODE_VOID)
diff --git a/gdb/python/py-lazy-string.c b/gdb/python/py-lazy-string.c
index c49987e2530..8cd8b91e91b 100644
--- a/gdb/python/py-lazy-string.c
+++ b/gdb/python/py-lazy-string.c
@@ -130,7 +130,7 @@ stpy_convert_to_value (PyObject *self, PyObject *args)
 	      /* PR 20786: There's no way to specify an array of length zero.
 		 Record a length of [0,-1] which is how Ada does it.  Anything
 		 we do is broken, but this is one possible solution.  */
-	      type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
+	      type = lookup_array_range_type (realtype->target_type (),
 					      0, self_string->length - 1);
 	      val = value_at_lazy (type, self_string->address);
 	    }
@@ -262,7 +262,7 @@ stpy_lazy_string_elt_type (lazy_string_object *lazy)
     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ARRAY:
-      return TYPE_TARGET_TYPE (realtype);
+      return realtype->target_type ();
     default:
       /* This is done to preserve existing behaviour.  PR 20769.
 	 E.g., gdb.parse_and_eval("my_int_variable").lazy_string().type.  */
diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index d14f9e42853..3d7d2f63d43 100644
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -503,7 +503,7 @@ typy_get_composite (struct type *type)
 
       if (!type->is_pointer_or_reference ())
 	break;
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
     }
 
   /* If this is not a struct, union, or enum type, raise TypeError
@@ -686,14 +686,14 @@ typy_target (PyObject *self, PyObject *args)
 {
   struct type *type = ((type_object *) self)->type;
 
-  if (!TYPE_TARGET_TYPE (type))
+  if (!type->target_type ())
     {
       PyErr_SetString (PyExc_RuntimeError,
 		       _("Type does not have a target."));
       return NULL;
     }
 
-  return type_to_type_object (TYPE_TARGET_TYPE (type));
+  return type_to_type_object (type->target_type ());
 }
 
 /* Return a const-qualified type variant.  */
@@ -1007,7 +1007,7 @@ typy_template_argument (PyObject *self, PyObject *args)
     {
       type = check_typedef (type);
       if (TYPE_IS_REFERENCE (type))
-	type = check_typedef (TYPE_TARGET_TYPE (type));
+	type = check_typedef (type->target_type ());
     }
   catch (const gdb_exception &except)
     {
diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index 3b75cdaae00..cb3346caad9 100644
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -422,7 +422,7 @@ valpy_get_dynamic_type (PyObject *self, void *closure)
       type = check_typedef (type);
 
       if (type->is_pointer_or_reference ()
-	  && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT))
+	  && (type->target_type ()->code () == TYPE_CODE_STRUCT))
 	{
 	  struct value *target;
 	  int was_pointer = type->code () == TYPE_CODE_PTR;
@@ -525,7 +525,7 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
 	      length = array_length;
 	    else if (array_length == -1)
 	      {
-		type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
+		type = lookup_array_range_type (realtype->target_type (),
 						0, length - 1);
 	      }
 	    else if (length != array_length)
@@ -534,7 +534,7 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
 		   specified length.  */
 		if (length > array_length)
 		  error (_("Length is larger than array size."));
-		type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
+		type = lookup_array_range_type (realtype->target_type (),
 						low_bound,
 						low_bound + length - 1);
 	      }
@@ -886,7 +886,7 @@ value_has_field (struct value *v, PyObject *field)
       val_type = value_type (v);
       val_type = check_typedef (val_type);
       if (val_type->is_pointer_or_reference ())
-	val_type = check_typedef (TYPE_TARGET_TYPE (val_type));
+	val_type = check_typedef (val_type->target_type ());
 
       type_code = val_type->code ();
       if ((type_code == TYPE_CODE_STRUCT || type_code == TYPE_CODE_UNION)
@@ -1274,7 +1274,7 @@ enum valpy_opcode
 
 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
 #define STRIP_REFERENCE(TYPE) \
-  (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
+  (TYPE_IS_REFERENCE (TYPE) ? ((TYPE)->target_type ()) : (TYPE))
 
 /* Helper for valpy_binop.  Returns a value object which is the result
    of applying the operation specified by OPCODE to the given
diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c
index 9df527e13e7..e74ea0374f0 100644
--- a/gdb/riscv-tdep.c
+++ b/gdb/riscv-tdep.c
@@ -3049,7 +3049,7 @@ riscv_push_dummy_call (struct gdbarch *gdbarch,
   struct type *ftype = check_typedef (value_type (function));
 
   if (ftype->code () == TYPE_CODE_PTR)
-    ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+    ftype = check_typedef (ftype->target_type ());
 
   /* We'll use register $a0 if we're returning a struct.  */
   if (return_method == return_method_struct)
diff --git a/gdb/rl78-tdep.c b/gdb/rl78-tdep.c
index 3920fa12265..6df64016f68 100644
--- a/gdb/rl78-tdep.c
+++ b/gdb/rl78-tdep.c
@@ -1049,9 +1049,9 @@ rl78_pointer_to_address (struct gdbarch *gdbarch,
     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 
   /* Is it a code address?  */
-  if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC
-      || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD
-      || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type))
+  if (type->target_type ()->code () == TYPE_CODE_FUNC
+      || type->target_type ()->code () == TYPE_CODE_METHOD
+      || TYPE_CODE_SPACE (type->target_type ())
       || TYPE_LENGTH (type) == 4)
     return rl78_make_instruction_address (addr);
   else
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index 746f565947b..36f77907a70 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -331,7 +331,7 @@ rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
 
   struct type *type = check_typedef (value_type (val));
   if (strcmp (type->name (), "&str") == 0)
-    val_print_string (TYPE_TARGET_TYPE (value_type (base)), "UTF-8",
+    val_print_string (value_type (base)->target_type (), "UTF-8",
 		      value_as_address (base), value_as_long (len), stream,
 		      options);
   else
@@ -345,7 +345,7 @@ rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
 	gdb_printf (stream, "[]");
       else
 	{
-	  struct type *elt_type = TYPE_TARGET_TYPE (value_type (base));
+	  struct type *elt_type = value_type (base)->target_type ();
 	  struct type *array_type = lookup_array_range_type (elt_type, 0,
 							     llen - 1);
 	  struct value *array = allocate_value_lazy (array_type);
@@ -536,14 +536,14 @@ rust_language::value_print_inner
       {
 	LONGEST low_bound, high_bound;
 	
-	if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
-	    && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
-	    && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
+	if (type->target_type ()->code () == TYPE_CODE_ARRAY
+	    && rust_u8_type_p (type->target_type ()->target_type ())
+	    && get_array_bounds (type->target_type (), &low_bound,
 				 &high_bound))
 	  {
 	    /* We have a pointer to a byte string, so just print
 	       that.  */
-	    struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+	    struct type *elttype = check_typedef (type->target_type ());
 	    CORE_ADDR addr = value_as_address (val);
 	    struct gdbarch *arch = type->arch ();
 
@@ -554,7 +554,7 @@ rust_language::value_print_inner
 	      }
 
 	    gdb_puts ("b", stream);
-	    val_print_string (TYPE_TARGET_TYPE (elttype), "ASCII", addr,
+	    val_print_string (elttype->target_type (), "ASCII", addr,
 			      high_bound - low_bound + 1, stream,
 			      &opts);
 	    break;
@@ -583,7 +583,7 @@ rust_language::value_print_inner
 	   byte string, hence the choice of "ASCII" as the
 	   encoding.  */
 	gdb_puts ("b", stream);
-	printstr (stream, TYPE_TARGET_TYPE (type),
+	printstr (stream, type->target_type (),
 		  value_contents_for_printing (val).data (),
 		  high_bound - low_bound + 1, "ASCII", 0, &opts);
       }
@@ -839,10 +839,10 @@ rust_internal_print_type (struct type *type, const char *varstring,
 	}
       gdb_puts (")", stream);
       /* If it returns unit, we can omit the return type.  */
-      if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+      if (type->target_type ()->code () != TYPE_CODE_VOID)
 	{
 	  gdb_puts (" -> ", stream);
-	  rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
+	  rust_internal_print_type (type->target_type (), "", stream,
 				    -1, 0, flags, false, podata);
 	}
       break;
@@ -852,7 +852,7 @@ rust_internal_print_type (struct type *type, const char *varstring,
 	LONGEST low_bound, high_bound;
 
 	gdb_puts ("[", stream);
-	rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
+	rust_internal_print_type (type->target_type (), NULL,
 				  stream, show - 1, level, flags, false,
 				  podata);
 
@@ -915,7 +915,7 @@ rust_internal_print_type (struct type *type, const char *varstring,
 	    /* We currently can't distinguish between pointers and
 	       references.  */
 	    gdb_puts ("*mut ", stream);
-	    type_print (TYPE_TARGET_TYPE (type), "", stream, 0);
+	    type_print (type->target_type (), "", stream, 0);
 	  }
       }
       break;
@@ -1168,14 +1168,14 @@ rust_subscript (struct type *expect_type, struct expression *exp,
     {
       struct type *base_type = nullptr;
       if (type->code () == TYPE_CODE_ARRAY)
-	base_type = TYPE_TARGET_TYPE (type);
+	base_type = type->target_type ();
       else if (rust_slice_type_p (type))
 	{
 	  for (int i = 0; i < type->num_fields (); ++i)
 	    {
 	      if (strcmp (type->field (i).name (), "data_ptr") == 0)
 		{
-		  base_type = TYPE_TARGET_TYPE (type->field (i).type ());
+		  base_type = type->field (i).type ()->target_type ();
 		  break;
 		}
 	    }
@@ -1183,7 +1183,7 @@ rust_subscript (struct type *expect_type, struct expression *exp,
 	    error (_("Could not find 'data_ptr' in slice type"));
 	}
       else if (type->code () == TYPE_CODE_PTR)
-	base_type = TYPE_TARGET_TYPE (type);
+	base_type = type->target_type ();
       else
 	error (_("Cannot subscript non-array type"));
 
@@ -1571,7 +1571,7 @@ rust_structop::evaluate_funcall (struct type *expect_type,
     args[i + 1] = ops[i]->evaluate (nullptr, exp, noside);
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    return value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
+    return value_zero (fn_type->target_type (), not_lval);
   return call_function_by_hand (function, NULL, args);
 }
 
@@ -1672,9 +1672,9 @@ rust_language::is_string_type_p (struct type *type) const
   type = check_typedef (type);
   return ((type->code () == TYPE_CODE_STRING)
 	  || (type->code () == TYPE_CODE_PTR
-	      && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
-		  && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
-		  && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
+	      && (type->target_type ()->code () == TYPE_CODE_ARRAY
+		  && rust_u8_type_p (type->target_type ()->target_type ())
+		  && get_array_bounds (type->target_type (), &low_bound,
 				       &high_bound)))
 	  || (type->code () == TYPE_CODE_STRUCT
 	      && !rust_enum_p (type)
diff --git a/gdb/rust-lang.h b/gdb/rust-lang.h
index 6da57f8633f..f4c7b7fc1c8 100644
--- a/gdb/rust-lang.h
+++ b/gdb/rust-lang.h
@@ -116,7 +116,7 @@ class rust_language : public language_defn
   gdb::unique_xmalloc_ptr<char> watch_location_expression
 	(struct type *type, CORE_ADDR addr) const override
   {
-    type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
+    type = check_typedef (check_typedef (type)->target_type ());
     std::string name = type_to_string (type);
     return xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr),
 		       name.c_str ());
diff --git a/gdb/rx-tdep.c b/gdb/rx-tdep.c
index c7e7c3fde2f..62a9ac4c628 100644
--- a/gdb/rx-tdep.c
+++ b/gdb/rx-tdep.c
@@ -672,7 +672,7 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Dereference function pointer types.  */
   while (func_type->code () == TYPE_CODE_PTR)
-    func_type = TYPE_TARGET_TYPE (func_type);
+    func_type = func_type->target_type ();
 
   /* The end result had better be a function or a method.  */
   gdb_assert (func_type->code () == TYPE_CODE_FUNC
@@ -707,7 +707,7 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
       if (return_method == return_method_struct)
 	{
-	  struct type *return_type = TYPE_TARGET_TYPE (func_type);
+	  struct type *return_type = func_type->target_type ();
 
 	  gdb_assert (return_type->code () == TYPE_CODE_STRUCT
 		      || func_type->code () == TYPE_CODE_UNION);
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 7f0ed65c8d2..2b2839460e2 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -1914,7 +1914,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   struct type *ftype = check_typedef (value_type (function));
 
   if (ftype->code () == TYPE_CODE_PTR)
-    ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+    ftype = check_typedef (ftype->target_type ());
 
   arg_prep.copy = sp;
   arg_prep.gr = (return_method == return_method_struct) ? 3 : 2;
diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index 062df860c81..8ed1a423bfb 100644
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -93,7 +93,7 @@ sh_is_renesas_calling_convention (struct type *func_type)
       func_type = check_typedef (func_type);
 
       if (func_type->code () == TYPE_CODE_PTR)
-	func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
+	func_type = check_typedef (func_type->target_type ());
 
       if (func_type->code () == TYPE_CODE_FUNC
 	  && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GNU_renesas_sh)
diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index 0f5da2c393a..e7fb040cc2c 100644
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -302,7 +302,7 @@ sparc_structure_return_p (const struct type *type)
   if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       /* Float vectors are always returned by memory.  */
-      if (sparc_floating_p (check_typedef (TYPE_TARGET_TYPE (type))))
+      if (sparc_floating_p (check_typedef (type->target_type ())))
 	return true;
       /* Integer vectors are returned by memory if the vector size
 	 is greater than 8 bytes long.  */
@@ -330,7 +330,7 @@ sparc_arg_by_memory_p (const struct type *type)
   if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       /* Float vectors are always passed by memory.  */
-      if (sparc_floating_p (check_typedef (TYPE_TARGET_TYPE (type))))
+      if (sparc_floating_p (check_typedef (type->target_type ())))
 	return true;
       /* Integer vectors are passed by memory if the vector size
 	 is greater than 8 bytes long.  */
@@ -1234,7 +1234,7 @@ sparc32_struct_return_from_sym (struct symbol *sym)
 
   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
     {
-      type = check_typedef (TYPE_TARGET_TYPE (type));
+      type = check_typedef (type->target_type ());
       if (sparc_structure_or_union_p (type)
 	  || (sparc_floating_p (type) && TYPE_LENGTH (type) == 16))
 	return 1;
diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index 5ca5f2dca8c..0945083b05a 100644
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -1175,7 +1175,7 @@ sparc64_16_byte_align_p (struct type *type)
 {
   if (type->code () == TYPE_CODE_ARRAY)
     {
-      struct type *t = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *t = check_typedef (type->target_type ());
 
       if (sparc64_floating_p (t))
 	return 1;
diff --git a/gdb/stack.c b/gdb/stack.c
index 80801ccdb01..95aeea24a12 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -2747,7 +2747,7 @@ return_command (const char *retval_exp, int from_tty)
       /* Cast return value to the return type of the function.  Should
 	 the cast fail, this call throws an error.  */
       if (thisfun != NULL)
-	return_type = TYPE_TARGET_TYPE (thisfun->type ());
+	return_type = thisfun->type ()->target_type ();
       if (return_type == NULL)
 	{
 	  if (retval_expr->first_opcode () != UNOP_CAST
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 40887f59d1f..50ee87ee0a9 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -2145,7 +2145,7 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
 	     be typedefed; just be safe.  */
 	  t = check_typedef (t);
 	  if (t->is_pointer_or_reference ())
-	    t = TYPE_TARGET_TYPE (t);
+	    t = t->target_type ();
 
 	  if (t->code () != TYPE_CODE_STRUCT
 	      && t->code () != TYPE_CODE_UNION)
diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c
index 77576834733..df3295edc65 100644
--- a/gdb/tic6x-tdep.c
+++ b/gdb/tic6x-tdep.c
@@ -885,7 +885,7 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Determine the type of this function.  */
   func_type = check_typedef (func_type);
   if (func_type->code () == TYPE_CODE_PTR)
-    func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
+    func_type = check_typedef (func_type->target_type ());
 
   gdb_assert (func_type->code () == TYPE_CODE_FUNC
 	      || func_type->code () == TYPE_CODE_METHOD);
diff --git a/gdb/typeprint.c b/gdb/typeprint.c
index 3356bdde2e7..ff677b2b1a0 100644
--- a/gdb/typeprint.c
+++ b/gdb/typeprint.c
@@ -528,7 +528,7 @@ whatis_exp (const char *exp, int show)
 	     because we do not want to dig past all typedefs.  */
 	  check_typedef (type);
 	  if (type->code () == TYPE_CODE_TYPEDEF)
-	    type = TYPE_TARGET_TYPE (type);
+	    type = type->target_type ();
 
 	  /* If the expression is actually a type, then there's no
 	     value to fetch the dynamic type from.  */
@@ -545,7 +545,7 @@ whatis_exp (const char *exp, int show)
   if (val != NULL && opts.objectprint)
     {
       if (type->is_pointer_or_reference ()
-	  && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT))
+	  && (type->target_type ()->code () == TYPE_CODE_STRUCT))
 	real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
       else if (type->code () == TYPE_CODE_STRUCT)
 	real_type = value_rtti_type (val, &full, &top, &using_enc);
@@ -654,7 +654,7 @@ print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
       break;
 
     case TYPE_CODE_RANGE:
-      print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
+      print_type_scalar (type->target_type (), val, stream);
       return;
 
     case TYPE_CODE_FIXED_POINT:
diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
index 232b92d0a08..73628e18551 100644
--- a/gdb/v850-tdep.c
+++ b/gdb/v850-tdep.c
@@ -542,7 +542,7 @@ v850_use_struct_convention (struct gdbarch *gdbarch, struct type *type)
 
       if (fld_type->code () == TYPE_CODE_ARRAY)
 	{
-	  tgt_type = TYPE_TARGET_TYPE (fld_type);
+	  tgt_type = fld_type->target_type ();
 	  if (v850_type_is_scalar (tgt_type) && TYPE_LENGTH (tgt_type) >= 4)
 	    return 0;
 	}
@@ -560,7 +560,7 @@ v850_use_struct_convention (struct gdbarch *gdbarch, struct type *type)
 	  fld_type = type->field (0).type ();
 	  if (fld_type->code () == TYPE_CODE_ARRAY)
 	    {
-	      tgt_type = TYPE_TARGET_TYPE (fld_type);
+	      tgt_type = fld_type->target_type ();
 	      if (TYPE_LENGTH (tgt_type) > 0
 		  && TYPE_LENGTH (fld_type) / TYPE_LENGTH (tgt_type) > 2)
 		return 1;
diff --git a/gdb/valarith.c b/gdb/valarith.c
index 526cc02599e..940d60ac2dc 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -54,7 +54,7 @@ find_size_for_pointer_math (struct type *ptr_type)
   struct type *ptr_target;
 
   gdb_assert (ptr_type->code () == TYPE_CODE_PTR);
-  ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
+  ptr_target = check_typedef (ptr_type->target_type ());
 
   sz = type_length_units (ptr_target);
   if (sz == 0)
@@ -115,13 +115,13 @@ value_ptrdiff (struct value *arg1, struct value *arg2)
   gdb_assert (type1->code () == TYPE_CODE_PTR);
   gdb_assert (type2->code () == TYPE_CODE_PTR);
 
-  if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
-      != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
+  if (TYPE_LENGTH (check_typedef (type1->target_type ()))
+      != TYPE_LENGTH (check_typedef (type2->target_type ())))
     error (_("First argument of `-' is a pointer and "
 	     "second argument is neither\n"
 	     "an integer nor a pointer of the same type."));
 
-  sz = type_length_units (check_typedef (TYPE_TARGET_TYPE (type1)));
+  sz = type_length_units (check_typedef (type1->target_type ()));
   if (sz == 0) 
     {
       warning (_("Type size unknown, assuming 1. "
@@ -200,7 +200,7 @@ value_subscripted_rvalue (struct value *array, LONGEST index,
 			  LONGEST lowerbound)
 {
   struct type *array_type = check_typedef (value_type (array));
-  struct type *elt_type = TYPE_TARGET_TYPE (array_type);
+  struct type *elt_type = array_type->target_type ();
   LONGEST elt_size = type_length_units (elt_type);
 
   /* Fetch the bit stride and convert it to a byte stride, assuming 8 bits
@@ -257,11 +257,11 @@ binop_types_user_defined_p (enum exp_opcode op,
 
   type1 = check_typedef (type1);
   if (TYPE_IS_REFERENCE (type1))
-    type1 = check_typedef (TYPE_TARGET_TYPE (type1));
+    type1 = check_typedef (type1->target_type ());
 
   type2 = check_typedef (type2);
   if (TYPE_IS_REFERENCE (type2))
-    type2 = check_typedef (TYPE_TARGET_TYPE (type2));
+    type2 = check_typedef (type2->target_type ());
 
   return (type1->code () == TYPE_CODE_STRUCT
 	  || type2->code () == TYPE_CODE_STRUCT);
@@ -295,7 +295,7 @@ unop_user_defined_p (enum exp_opcode op, struct value *arg1)
     return 0;
   type1 = check_typedef (value_type (arg1));
   if (TYPE_IS_REFERENCE (type1))
-    type1 = check_typedef (TYPE_TARGET_TYPE (type1));
+    type1 = check_typedef (type1->target_type ());
   return type1->code () == TYPE_CODE_STRUCT;
 }
 
@@ -525,8 +525,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
 	{
 	  struct type *return_type;
 
-	  return_type
-	    = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
+	  return_type = check_typedef (value_type (argvec[0]))->target_type ();
 	  return value_zero (return_type, VALUE_LVAL (arg1));
 	}
       return call_function_by_hand (argvec[0], NULL,
@@ -639,8 +638,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 	{
 	  struct type *return_type;
 
-	  return_type
-	    = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
+	  return_type = check_typedef (value_type (argvec[0]))->target_type ();
 	  return value_zero (return_type, VALUE_LVAL (arg1));
 	}
       return call_function_by_hand (argvec[0], NULL,
@@ -668,7 +666,7 @@ value_concat (struct value *arg1, struct value *arg2)
   struct type *elttype1 = type1;
   if (elttype1->code () == TYPE_CODE_ARRAY)
     {
-      elttype1 = TYPE_TARGET_TYPE (elttype1);
+      elttype1 = elttype1->target_type ();
       if (!get_array_bounds (type1, &low1, &high1))
 	error (_("could not determine array bounds on left-hand-side of "
 		 "array concatenation"));
@@ -683,7 +681,7 @@ value_concat (struct value *arg1, struct value *arg2)
   struct type *elttype2 = type2;
   if (elttype2->code () == TYPE_CODE_ARRAY)
     {
-      elttype2 = TYPE_TARGET_TYPE (elttype2);
+      elttype2 = elttype2->target_type ();
       if (!get_array_bounds (type2, &low2, &high2))
 	error (_("could not determine array bounds on right-hand-side of "
 		 "array concatenation"));
@@ -1557,7 +1555,7 @@ value_vector_widen (struct value *scalar_value, struct type *vector_type)
   if (!get_array_bounds (vector_type, &low_bound, &high_bound))
     error (_("Could not determine the vector bounds"));
 
-  eltype = check_typedef (TYPE_TARGET_TYPE (vector_type));
+  eltype = check_typedef (vector_type->target_type ());
   elval = value_cast (eltype, scalar_value);
 
   scalar_type = check_typedef (value_type (scalar_value));
@@ -1605,8 +1603,8 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
       || !get_array_bounds (type2, &low_bound2, &high_bound2))
     error (_("Could not determine the vector bounds"));
 
-  eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
-  eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
+  eltype1 = check_typedef (type1->target_type ());
+  eltype2 = check_typedef (type2->target_type ());
   elsize = TYPE_LENGTH (eltype1);
 
   if (eltype1->code () != eltype2->code ()
@@ -1905,7 +1903,7 @@ value_neg (struct value *arg1)
   else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       struct value *val = allocate_value (type);
-      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *eltype = check_typedef (type->target_type ());
       int i;
       LONGEST low_bound, high_bound;
 
@@ -1949,7 +1947,7 @@ value_complement (struct value *arg1)
     val = value_from_longest (type, ~value_as_long (arg1));
   else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
-      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *eltype = check_typedef (type->target_type ());
       int i;
       LONGEST low_bound, high_bound;
 
@@ -2017,7 +2015,7 @@ value_in (struct value *element, struct value *set)
   struct type *eltype = check_typedef (value_type (element));
 
   if (eltype->code () == TYPE_CODE_RANGE)
-    eltype = TYPE_TARGET_TYPE (eltype);
+    eltype = eltype->target_type ();
   if (settype->code () != TYPE_CODE_SET)
     error (_("Second argument of 'IN' has wrong type"));
   if (eltype->code () != TYPE_CODE_INT
diff --git a/gdb/valops.c b/gdb/valops.c
index 27e84d9f6b3..064021f8380 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -297,8 +297,8 @@ value_cast_pointers (struct type *type, struct value *arg2,
 {
   struct type *type1 = check_typedef (type);
   struct type *type2 = check_typedef (value_type (arg2));
-  struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
-  struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
+  struct type *t1 = check_typedef (type1->target_type ());
+  struct type *t2 = check_typedef (type2->target_type ());
 
   if (t1->code () == TYPE_CODE_STRUCT
       && t2->code () == TYPE_CODE_STRUCT
@@ -443,7 +443,7 @@ value_cast (struct type *type, struct value *arg2)
 	 we generate value of the given reference.  Nothing wrong with 
 	 that.  */
       struct type *t1 = check_typedef (type);
-      struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
+      struct type *dereftype = check_typedef (t1->target_type ());
       struct value *val = value_cast (dereftype, arg2);
 
       return value_ref (val, t1->code ());
@@ -472,7 +472,7 @@ value_cast (struct type *type, struct value *arg2)
      where N is sizeof(OBJECT)/sizeof(TYPE).  */
   if (code1 == TYPE_CODE_ARRAY)
     {
-      struct type *element_type = TYPE_TARGET_TYPE (type);
+      struct type *element_type = type->target_type ();
       unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
 
       if (element_length > 0 && type->bounds ()->high.kind () == PROP_UNDEFINED)
@@ -490,7 +490,7 @@ value_cast (struct type *type, struct value *arg2)
 	  /* FIXME-type-allocation: need a way to free this type when
 	     we are done with it.  */
 	  range_type = create_static_range_type (NULL,
-						 TYPE_TARGET_TYPE (range_type),
+						 range_type->target_type (),
 						 low_bound,
 						 new_length + low_bound - 1);
 	  deprecated_set_value_type (arg2, 
@@ -686,7 +686,7 @@ value_reinterpret_cast (struct type *type, struct value *arg)
     {
       is_ref = 1;
       arg = value_addr (arg);
-      dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type));
+      dest_type = lookup_pointer_type (dest_type->target_type ());
       real_type = lookup_pointer_type (real_type);
     }
 
@@ -827,11 +827,11 @@ value_dynamic_cast (struct type *type, struct value *arg)
   if (resolved_type->code () != TYPE_CODE_PTR
       && !TYPE_IS_REFERENCE (resolved_type))
     error (_("Argument to dynamic_cast must be a pointer or reference type"));
-  if (TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_VOID
-      && TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_STRUCT)
+  if (resolved_type->target_type ()->code () != TYPE_CODE_VOID
+      && resolved_type->target_type ()->code () != TYPE_CODE_STRUCT)
     error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
 
-  class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
+  class_type = check_typedef (resolved_type->target_type ());
   if (resolved_type->code () == TYPE_CODE_PTR)
     {
       if (arg_type->code () != TYPE_CODE_PTR
@@ -840,7 +840,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
 	error (_("Argument to dynamic_cast does not have pointer type"));
       if (arg_type->code () == TYPE_CODE_PTR)
 	{
-	  arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+	  arg_type = check_typedef (arg_type->target_type ());
 	  if (arg_type->code () != TYPE_CODE_STRUCT)
 	    error (_("Argument to dynamic_cast does "
 		     "not have pointer to class type"));
@@ -889,19 +889,19 @@ value_dynamic_cast (struct type *type, struct value *arg)
   /* dynamic_cast<void *> means to return a pointer to the
      most-derived object.  */
   if (resolved_type->code () == TYPE_CODE_PTR
-      && TYPE_TARGET_TYPE (resolved_type)->code () == TYPE_CODE_VOID)
+      && resolved_type->target_type ()->code () == TYPE_CODE_VOID)
     return value_at_lazy (type, addr);
 
   tem = value_at (type, addr);
   type = value_type (tem);
 
   /* The first dynamic check specified in 5.2.7.  */
-  if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type)))
+  if (is_public_ancestor (arg_type, resolved_type->target_type ()))
     {
-      if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type)))
+      if (class_types_same_p (rtti_type, resolved_type->target_type ()))
 	return tem;
       result = NULL;
-      if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type),
+      if (dynamic_cast_check_1 (resolved_type->target_type (),
 				value_contents_for_printing (tem).data (),
 				value_embedded_offset (tem),
 				value_address (tem), tem,
@@ -917,7 +917,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
   /* The second dynamic check specified in 5.2.7.  */
   result = NULL;
   if (is_public_ancestor (arg_type, rtti_type)
-      && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type),
+      && dynamic_cast_check_2 (resolved_type->target_type (),
 			       value_contents_for_printing (tem).data (),
 			       value_embedded_offset (tem),
 			       value_address (tem), tem,
@@ -947,7 +947,7 @@ value_one (struct type *type)
     }
   else if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
     {
-      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
+      struct type *eltype = check_typedef (type1->target_type ());
       int i;
       LONGEST low_bound, high_bound;
 
@@ -1515,7 +1515,7 @@ value_coerce_array (struct value *arg1)
   if (VALUE_LVAL (arg1) != lval_memory)
     error (_("Attempt to take address of value not located in memory."));
 
-  return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+  return value_from_pointer (lookup_pointer_type (type->target_type ()),
 			     value_address (arg1));
 }
 
@@ -1556,11 +1556,11 @@ value_addr (struct value *arg1)
 	     allows &(&X) to get the location containing the reference.
 	     Do the same to its enclosing type for consistency.  */
 	  struct type *type_ptr
-	    = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+	    = lookup_pointer_type (type->target_type ());
 	  struct type *enclosing_type
 	    = check_typedef (value_enclosing_type (arg1));
 	  struct type *enclosing_type_ptr
-	    = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type));
+	    = lookup_pointer_type (enclosing_type->target_type ());
 
 	  arg2 = value_copy (arg1);
 	  deprecated_set_value_type (arg2, type_ptr);
@@ -1648,7 +1648,7 @@ value_ind (struct value *arg1)
       /* We may be pointing to something embedded in a larger object.
 	 Get the real type of the enclosing object.  */
       enc_type = check_typedef (value_enclosing_type (arg1));
-      enc_type = TYPE_TARGET_TYPE (enc_type);
+      enc_type = enc_type->target_type ();
 
       CORE_ADDR base_addr;
       if (check_typedef (enc_type)->code () == TYPE_CODE_FUNC
@@ -1811,7 +1811,7 @@ typecmp (bool staticp, bool varargs, int nargs,
 
       if (TYPE_IS_REFERENCE (tt1)
 	  /* We should be doing hairy argument matching, as below.  */
-	  && (check_typedef (TYPE_TARGET_TYPE (tt1))->code ()
+	  && (check_typedef (tt1->target_type ())->code ()
 	      == tt2->code ()))
 	{
 	  if (tt2->code () == TYPE_CODE_ARRAY)
@@ -1829,13 +1829,13 @@ typecmp (bool staticp, bool varargs, int nargs,
 	 and the argument will be a pointer to a char.  */
       while (TYPE_IS_REFERENCE (tt1) || tt1->code () == TYPE_CODE_PTR)
 	{
-	  tt1 = check_typedef ( TYPE_TARGET_TYPE (tt1) );
+	  tt1 = check_typedef ( tt1->target_type () );
 	}
       while (tt2->code () == TYPE_CODE_ARRAY
 	     || tt2->code () == TYPE_CODE_PTR
 	     || TYPE_IS_REFERENCE (tt2))
 	{
-	  tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
+	  tt2 = check_typedef (tt2->target_type ());
 	}
       if (tt1->code () == tt2->code ())
 	continue;
@@ -3580,13 +3580,13 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 		      else
 			{
 			  struct type *p = check_typedef (value_type (this_v));
-			  p = check_typedef (TYPE_TARGET_TYPE (p));
+			  p = check_typedef (p->target_type ());
 			  if (get_baseclass_offset (p, curtype, this_v,
 						    &boff, &isvirt))
 			    mem_offset += boff;
 			}
 		    }
-		  tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+		  tmp = lookup_pointer_type (type->target_type ());
 		  result = value_from_pointer (tmp,
 					       value_as_long (v) + mem_offset);
 		  return value_ind (result);
@@ -3602,7 +3602,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 
   /* Perform all necessary dereferencing.  */
   while (intype && intype->code () == TYPE_CODE_PTR)
-    intype = TYPE_TARGET_TYPE (intype);
+    intype = intype->target_type ();
 
   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
     {
@@ -4014,12 +4014,12 @@ value_slice (struct value *array, int lowbound, int length)
   /* FIXME-type-allocation: need a way to free this type when we are
      done with it.  */
   slice_range_type = create_static_range_type (NULL,
-					       TYPE_TARGET_TYPE (range_type),
+					       range_type->target_type (),
 					       lowbound,
 					       lowbound + length - 1);
 
   {
-    struct type *element_type = TYPE_TARGET_TYPE (array_type);
+    struct type *element_type = array_type->target_type ();
     LONGEST offset
       = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
 
@@ -4052,7 +4052,7 @@ value_literal_complex (struct value *arg1,
 		       struct type *type)
 {
   struct value *val;
-  struct type *real_type = TYPE_TARGET_TYPE (type);
+  struct type *real_type = type->target_type ();
 
   val = allocate_value (type);
   arg1 = value_cast (real_type, arg1);
@@ -4074,7 +4074,7 @@ struct value *
 value_real_part (struct value *value)
 {
   struct type *type = check_typedef (value_type (value));
-  struct type *ttype = TYPE_TARGET_TYPE (type);
+  struct type *ttype = type->target_type ();
 
   gdb_assert (type->code () == TYPE_CODE_COMPLEX);
   return value_from_component (value, ttype, 0);
@@ -4086,7 +4086,7 @@ struct value *
 value_imaginary_part (struct value *value)
 {
   struct type *type = check_typedef (value_type (value));
-  struct type *ttype = TYPE_TARGET_TYPE (type);
+  struct type *ttype = type->target_type ();
 
   gdb_assert (type->code () == TYPE_CODE_COMPLEX);
   return value_from_component (value, ttype,
@@ -4098,11 +4098,11 @@ value_imaginary_part (struct value *value)
 static struct value *
 cast_into_complex (struct type *type, struct value *val)
 {
-  struct type *real_type = TYPE_TARGET_TYPE (type);
+  struct type *real_type = type->target_type ();
 
   if (value_type (val)->code () == TYPE_CODE_COMPLEX)
     {
-      struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
+      struct type *val_real_type = value_type (val)->target_type ();
       struct value *re_val = allocate_value (val_real_type);
       struct value *im_val = allocate_value (val_real_type);
       int len = TYPE_LENGTH (val_real_type);
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 3ad4c0cd357..a926f321bcf 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -298,7 +298,7 @@ val_print_scalar_type_p (struct type *type)
   type = check_typedef (type);
   while (TYPE_IS_REFERENCE (type))
     {
-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();
       type = check_typedef (type);
     }
   switch (type->code ())
@@ -456,7 +456,7 @@ generic_val_print_array (struct value *val,
 			     generic_val_print_decorations *decorations)
 {
   struct type *type = check_typedef (value_type (val));
-  struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
+  struct type *unresolved_elttype = type->target_type ();
   struct type *elttype = check_typedef (unresolved_elttype);
 
   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
@@ -491,7 +491,7 @@ generic_value_print_ptr (struct value *val, struct ui_file *stream,
   else
     {
       struct type *type = check_typedef (value_type (val));
-      struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+      struct type *elttype = check_typedef (type->target_type ());
       const gdb_byte *valaddr = value_contents_for_printing (val).data ();
       CORE_ADDR addr = unpack_pointer (type, valaddr);
 
@@ -544,7 +544,7 @@ generic_val_print_ref (struct type *type,
 		       struct value *original_value,
 		       const struct value_print_options *options)
 {
-  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+  struct type *elttype = check_typedef (type->target_type ());
   struct value *deref_val = NULL;
   const int value_is_synthetic
     = value_bits_synthetic_pointer (original_value,
@@ -565,7 +565,7 @@ generic_val_print_ref (struct type *type,
 	  gdb_assert (embedded_offset == 0);
 	}
       else
-	deref_val = value_at (TYPE_TARGET_TYPE (type),
+	deref_val = value_at (type->target_type (),
 			      unpack_pointer (type, valaddr + embedded_offset));
     }
   /* Else, original_value isn't a synthetic reference or we don't have to print
@@ -900,7 +900,7 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
      printer.  */
   while (type->code () == TYPE_CODE_RANGE)
     {
-      type = check_typedef (TYPE_TARGET_TYPE (type));
+      type = check_typedef (type->target_type ());
       val = value_cast (type, val);
     }
 
@@ -1938,11 +1938,11 @@ value_print_array_elements (struct value *val, struct ui_file *stream,
 
   struct type *type = check_typedef (value_type (val));
 
-  elttype = TYPE_TARGET_TYPE (type);
+  elttype = type->target_type ();
   eltlen = type_length_units (check_typedef (elttype));
   index_type = type->index_type ();
   if (index_type->code () == TYPE_CODE_RANGE)
-    index_type = TYPE_TARGET_TYPE (index_type);
+    index_type = index_type->target_type ();
 
   if (get_array_bounds (type, &low_bound, &high_bound))
     {
diff --git a/gdb/value.c b/gdb/value.c
index 557e22154eb..48db5b064f2 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1199,7 +1199,7 @@ value_actual_type (struct value *value, int resolve_simple_types,
       /* If result's target type is TYPE_CODE_STRUCT, proceed to
 	 fetch its rtti type.  */
       if (result->is_pointer_or_reference ()
-	  && (check_typedef (TYPE_TARGET_TYPE (result))->code ()
+	  && (check_typedef (result->target_type ())->code ()
 	      == TYPE_CODE_STRUCT)
 	  && !value_optimized_out (value))
 	{
@@ -3802,7 +3802,7 @@ readjust_indirect_value_type (struct value *value, struct type *enc_type,
 {
   gdb_assert (original_type->is_pointer_or_reference ());
 
-  struct type *original_target_type = TYPE_TARGET_TYPE (original_type);
+  struct type *original_target_type = original_type->target_type ();
   gdb::array_view<const gdb_byte> view;
   struct type *resolved_original_target_type
     = resolve_dynamic_type (original_target_type, view,
@@ -3834,7 +3834,7 @@ coerce_ref (struct value *arg)
     return arg;
 
   enc_type = check_typedef (value_enclosing_type (arg));
-  enc_type = TYPE_TARGET_TYPE (enc_type);
+  enc_type = enc_type->target_type ();
 
   CORE_ADDR addr = unpack_pointer (value_type (arg), value_contents (arg).data ());
   retval = value_at_lazy (enc_type, addr);
diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
index 10c0d3e6b1c..97ccad48c6f 100644
--- a/gdb/xstormy16-tdep.c
+++ b/gdb/xstormy16-tdep.c
@@ -610,7 +610,7 @@ xstormy16_pointer_to_address (struct gdbarch *gdbarch,
 			      struct type *type, const gdb_byte *buf)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  enum type_code target = TYPE_TARGET_TYPE (type)->code ();
+  enum type_code target = type->target_type ()->code ();
   CORE_ADDR addr
     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 
@@ -629,7 +629,7 @@ xstormy16_address_to_pointer (struct gdbarch *gdbarch,
 			      struct type *type, gdb_byte *buf, CORE_ADDR addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  enum type_code target = TYPE_TARGET_TYPE (type)->code ();
+  enum type_code target = type->target_type ()->code ();
 
   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
     {
-- 
2.37.3


^ permalink raw reply	[flat|nested] 17+ messages in thread

* [PATCH 3/4] gdb: add type::length / type::set_length
  2022-09-16 15:08 [PATCH 1/4] gdb: add type::target_type / type::set_target_type Simon Marchi
  2022-09-16 15:08 ` [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE Simon Marchi
@ 2022-09-16 15:08 ` Simon Marchi
  2022-09-21 15:00   ` Tom Tromey
  2022-09-21 15:01   ` Lancelot SIX
  2022-09-17  9:48 ` [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH Simon Marchi
                   ` (2 subsequent siblings)
  4 siblings, 2 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-16 15:08 UTC (permalink / raw)
  To: gdb-patches

From: Simon Marchi <simon.marchi@polymtl.ca>

Add the `length` and `set_length` methods on `struct type`, in order to remove
the `TYPE_LENGTH` macro.  In this patch, the macro is changed to use the
getter, so all the call sites of the macro that are used as a setter are
changed to use the setter method directly.  The next patch will remove the
macro completely.

Change-Id: Id1090244f15c9856969b9be5006aefe8d8897ca4
---
 gdb/ada-lang.c            | 47 +++++++++++++-------------
 gdb/coffread.c            | 14 ++++----
 gdb/cp-valprint.c         |  2 +-
 gdb/ctfread.c             | 10 +++---
 gdb/dwarf2/read.c         | 44 ++++++++++--------------
 gdb/eval.c                |  2 +-
 gdb/f-valprint.c          |  6 ++--
 gdb/gdbtypes.c            | 71 ++++++++++++++++++++-------------------
 gdb/gdbtypes.h            | 16 +++++++--
 gdb/mdebugread.c          |  4 +--
 gdb/opencl-lang.c         |  2 +-
 gdb/rust-lang.c           |  5 ++-
 gdb/stabsread.c           | 10 +++---
 gdb/target-descriptions.c |  2 +-
 14 files changed, 119 insertions(+), 116 deletions(-)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index d0b13a6bed2..06eab777f57 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -2165,7 +2165,7 @@ ada_type_of_array (struct value *arr, int bounds)
 		  int array_bitsize =
 			(hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
 
-		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
+		  array_type->set_length ((array_bitsize + 7) / 8);
 		}
 	    }
 	}
@@ -2392,12 +2392,14 @@ constrained_packed_array_type (struct type *type, long *elt_bits)
       || !get_discrete_bounds (index_type, &low_bound, &high_bound))
     low_bound = high_bound = 0;
   if (high_bound < low_bound)
-    *elt_bits = TYPE_LENGTH (new_type) = 0;
+    {
+      *elt_bits = 0;
+      new_type->set_length (0);
+    }
   else
     {
       *elt_bits *= (high_bound - low_bound + 1);
-      TYPE_LENGTH (new_type) =
-	(*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
+      new_type->set_length ((*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
     }
 
   new_type->set_is_fixed_instance (true);
@@ -2471,8 +2473,8 @@ recursively_update_array_bitsize (struct type *type)
       LONGEST elt_bitsize = elt_len * TYPE_FIELD_BITSIZE (elt_type, 0);
       TYPE_FIELD_BITSIZE (type, 0) = elt_bitsize;
 
-      TYPE_LENGTH (type) = ((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
-			    / HOST_CHAR_BIT);
+      type->set_length (((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
+			 / HOST_CHAR_BIT));
     }
 
   return our_len;
@@ -7826,7 +7828,7 @@ empty_record (struct type *templ)
   type->set_code (TYPE_CODE_STRUCT);
   INIT_NONE_SPECIFIC (type);
   type->set_name ("<empty>");
-  TYPE_LENGTH (type) = 0;
+  type->set_length (0);
   return type;
 }
 
@@ -7996,8 +7998,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
       if (off + fld_bit_len > bit_len)
 	bit_len = off + fld_bit_len;
       off += fld_bit_len;
-      TYPE_LENGTH (rtype) =
-	align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+      rtype->set_length (align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT);
     }
 
   /* We handle the variant part, if any, at the end because of certain
@@ -8042,8 +8043,9 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 	    TARGET_CHAR_BIT;
 	  if (off + fld_bit_len > bit_len)
 	    bit_len = off + fld_bit_len;
-	  TYPE_LENGTH (rtype) =
-	    align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+
+	  rtype->set_length
+	    (align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT);
 	}
     }
 
@@ -8063,10 +8065,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 		 pulongest (TYPE_LENGTH (type)));
     }
   else
-    {
-      TYPE_LENGTH (rtype) = align_up (TYPE_LENGTH (rtype),
-				      TYPE_LENGTH (type));
-    }
+    rtype->set_length (align_up (TYPE_LENGTH (rtype), TYPE_LENGTH (type)));
 
   value_free_to_mark (mark);
   return rtype;
@@ -8148,7 +8147,7 @@ template_to_static_fixed_type (struct type *type0)
 
 	      type->set_name (ada_type_name (type0));
 	      type->set_is_fixed_instance (true);
-	      TYPE_LENGTH (type) = 0;
+	      type->set_length (0);
 	    }
 	  type->field (f).set_type (new_type);
 	  type->field (f).set_name (type0->field (f).name ());
@@ -8199,7 +8198,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
 
   rtype->set_name (ada_type_name (type));
   rtype->set_is_fixed_instance (true);
-  TYPE_LENGTH (rtype) = TYPE_LENGTH (type);
+  rtype->set_length (TYPE_LENGTH (type));
 
   branch_type = to_fixed_variant_branch_type
     (type->field (variant_field).type (),
@@ -8222,9 +8221,11 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
       rtype->field (variant_field).set_type (branch_type);
       rtype->field (variant_field).set_name ("S");
       TYPE_FIELD_BITSIZE (rtype, variant_field) = 0;
-      TYPE_LENGTH (rtype) += TYPE_LENGTH (branch_type);
+      rtype->set_length (TYPE_LENGTH (rtype) + TYPE_LENGTH (branch_type));
     }
-  TYPE_LENGTH (rtype) -= TYPE_LENGTH (type->field (variant_field).type ());
+
+  rtype->set_length (TYPE_LENGTH (rtype)
+		     - TYPE_LENGTH (type->field (variant_field).type ()));
 
   value_free_to_mark (mark);
   return rtype;
@@ -8532,9 +8533,9 @@ to_fixed_array_type (struct type *type0, struct value *dval,
       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
 
       TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
-      TYPE_LENGTH (result) = len * elt_bitsize / HOST_CHAR_BIT;
+      result->set_length (len * elt_bitsize / HOST_CHAR_BIT);
       if (TYPE_LENGTH (result) * HOST_CHAR_BIT < len * elt_bitsize)
-	TYPE_LENGTH (result)++;
+	result->set_length (TYPE_LENGTH (result) + 1);
     }
 
   result->set_is_fixed_instance (true);
@@ -8630,7 +8631,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
 	    if (xvz_found && TYPE_LENGTH (fixed_record_type) != size)
 	      {
 		fixed_record_type = copy_type (fixed_record_type);
-		TYPE_LENGTH (fixed_record_type) = size;
+		fixed_record_type->set_length (size);
 
 		/* The FIXED_RECORD_TYPE may have be a stub.  We have
 		   observed this when the debugging info is STABS, and
@@ -11528,7 +11529,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
       /* create_static_range_type alters the resulting type's length
 	 to match the size of the base_type, which is not what we want.
 	 Set it back to the original range type's length.  */
-      TYPE_LENGTH (type) = TYPE_LENGTH (raw_type);
+      type->set_length (TYPE_LENGTH (raw_type));
       type->set_name (name);
       return type;
     }
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 27afa11738d..801978978e9 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1472,7 +1472,7 @@ patch_type (struct type *type, struct type *real_type)
   struct type *real_target = real_type->target_type ();
   int field_size = real_target->num_fields () * sizeof (struct field);
 
-  TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
+  target->set_length (real_target->length ());
   target->set_num_fields (real_target->num_fields ());
 
   field *fields = (struct field *) TYPE_ALLOC (target, field_size);
@@ -1887,7 +1887,7 @@ decode_base_type (struct coff_symbol *cs,
 	  type->set_code (TYPE_CODE_STRUCT);
 	  type->set_name (NULL);
 	  INIT_CPLUS_SPECIFIC (type);
-	  TYPE_LENGTH (type) = 0;
+	  type->set_length (0);
 	  type->set_fields (nullptr);
 	  type->set_num_fields (0);
 	}
@@ -1907,7 +1907,7 @@ decode_base_type (struct coff_symbol *cs,
 	  type = coff_alloc_type (cs->c_symnum);
 	  type->set_name (NULL);
 	  INIT_CPLUS_SPECIFIC (type);
-	  TYPE_LENGTH (type) = 0;
+	  type->set_length (0);
 	  type->set_fields (nullptr);
 	  type->set_num_fields (0);
 	}
@@ -1928,7 +1928,7 @@ decode_base_type (struct coff_symbol *cs,
 	  type = coff_alloc_type (cs->c_symnum);
 	  type->set_code (TYPE_CODE_ENUM);
 	  type->set_name (NULL);
-	  TYPE_LENGTH (type) = 0;
+	  type->set_length (0);
 	  type->set_fields (nullptr);
 	  type->set_num_fields (0);
 	}
@@ -1996,7 +1996,7 @@ coff_read_struct_type (int index, int length, int lastsym,
   type = coff_alloc_type (index);
   type->set_code (TYPE_CODE_STRUCT);
   INIT_CPLUS_SPECIFIC (type);
-  TYPE_LENGTH (type) = length;
+  type->set_length (length);
 
   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
     {
@@ -2124,9 +2124,9 @@ coff_read_enum_type (int index, int length, int lastsym,
   /* Now fill in the fields of the type-structure.  */
 
   if (length > 0)
-    TYPE_LENGTH (type) = length;
+    type->set_length (length);
   else /* Assume ints.  */
-    TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
+    type->set_length (gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT);
   type->set_code (TYPE_CODE_ENUM);
   type->set_num_fields (nsyms);
   type->set_fields
diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index 07bbb9b262e..86bc57b5353 100644
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -729,7 +729,7 @@ test_print_fields (gdbarch *arch)
   type *uint8_type = builtin_type (arch)->builtin_uint8;
   type *bool_type = builtin_type (arch)->builtin_bool;
   type *the_struct = arch_composite_type (arch, NULL, TYPE_CODE_STRUCT);
-  TYPE_LENGTH (the_struct) = 4;
+  the_struct->set_length (4);
 
   /* Value:  1110 1001
      Fields: C-BB B-A- */
diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index 561534f9ebe..890cb91aca7 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -641,7 +641,7 @@ read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
   else
     type->set_code (TYPE_CODE_STRUCT);
 
-  TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+  type->set_length (ctf_type_size (fp, tid));
   set_type_align (type, ctf_type_align (fp, tid));
 
   return set_tid_type (ccp->of, tid, type);
@@ -747,7 +747,7 @@ read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
     type->set_name (name);
 
   type->set_code (TYPE_CODE_ENUM);
-  TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+  type->set_length (ctf_type_size (fp, tid));
   /* Set the underlying type based on its ctf_type_size bits.  */
   type->set_target_type (objfile_int_type (of, TYPE_LENGTH (type), false));
   set_type_align (type, ctf_type_align (fp, tid));
@@ -834,11 +834,11 @@ read_array_type (struct ctf_context *ccp, ctf_id_t tid)
   if (ar.ctr_nelems <= 1)	/* Check if undefined upper bound.  */
     {
       range_type->bounds ()->high.set_undefined ();
-      TYPE_LENGTH (type) = 0;
+      type->set_length (0);
       type->set_target_is_stub (true);
     }
   else
-    TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+    type->set_length (ctf_type_size (fp, tid));
 
   set_type_align (type, ctf_type_align (fp, tid));
 
@@ -988,7 +988,7 @@ read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
   else
     type->set_code (TYPE_CODE_STRUCT);
 
-  TYPE_LENGTH (type) = 0;
+  type->set_length (0);
   type->set_is_stub (true);
 
   return set_tid_type (of, tid, type);
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 8155c7c165b..f6c1d5a1a30 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -8191,7 +8191,7 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
 
 	  /* In Rust, each element should have the size of the
 	     enclosing enum.  */
-	  TYPE_LENGTH (type->field (i).type ()) = TYPE_LENGTH (type);
+	  type->field (i).type ()->set_length (TYPE_LENGTH (type));
 
 	  /* Remove the discriminant field, if it exists.  */
 	  struct type *sub_type = type->field (i).type ();
@@ -14640,19 +14640,18 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
   if (attr != nullptr)
     {
       if (attr->form_is_constant ())
-	TYPE_LENGTH (type) = attr->constant_value (0);
+	type->set_length (attr->constant_value (0));
       else
 	{
 	  struct dynamic_prop prop;
 	  if (attr_to_dynamic_prop (attr, die, cu, &prop, cu->addr_type ()))
 	    type->add_dyn_prop (DYN_PROP_BYTE_SIZE, prop);
-	  TYPE_LENGTH (type) = 0;
+
+	  type->set_length (0);
 	}
     }
   else
-    {
-      TYPE_LENGTH (type) = 0;
-    }
+    type->set_length (0);
 
   maybe_set_alignment (cu, die, type);
 
@@ -15200,13 +15199,9 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr)
-    {
-      TYPE_LENGTH (type) = attr->constant_value (0);
-    }
+    type->set_length (attr->constant_value (0));
   else
-    {
-      TYPE_LENGTH (type) = 0;
-    }
+    type->set_length (0);
 
   maybe_set_alignment (cu, die, type);
 
@@ -15233,7 +15228,7 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
       type->set_is_unsigned (underlying_type->is_unsigned ());
 
       if (TYPE_LENGTH (type) == 0)
-	TYPE_LENGTH (type) = TYPE_LENGTH (underlying_type);
+	type->set_length (TYPE_LENGTH (underlying_type));
 
       if (TYPE_RAW_ALIGN (type) == 0
 	  && TYPE_RAW_ALIGN (underlying_type) != 0)
@@ -15530,7 +15525,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
   int last_fieldno = range_fields.size () - 1;
   int bounds_size = (bounds->field (last_fieldno).loc_bitpos () / 8
 		     + TYPE_LENGTH (bounds->field (last_fieldno).type ()));
-  TYPE_LENGTH (bounds) = align_up (bounds_size, max_align);
+  bounds->set_length (align_up (bounds_size, max_align));
 
   /* Rewrite the existing array type in place.  Specifically, we
      remove any dynamic properties we might have read, and we replace
@@ -15564,8 +15559,8 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
   result->field (1).set_loc_bitpos (8 * bounds_offset);
 
   result->set_name (type->name ());
-  TYPE_LENGTH (result) = (TYPE_LENGTH (result->field (0).type ())
-			  + TYPE_LENGTH (result->field (1).type ()));
+  result->set_length (TYPE_LENGTH (result->field (0).type ())
+		      + TYPE_LENGTH (result->field (1).type ()));
 
   return result;
 }
@@ -15706,7 +15701,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
   if (attr != nullptr && attr->form_is_unsigned ())
     {
       if (attr->as_unsigned () >= TYPE_LENGTH (type))
-	TYPE_LENGTH (type) = attr->as_unsigned ();
+	type->set_length (attr->as_unsigned ());
       else
 	complaint (_("DW_AT_byte_size for array type smaller "
 		     "than the total size of elements"));
@@ -15792,7 +15787,7 @@ read_set_type (struct die_info *die, struct dwarf2_cu *cu)
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr && attr->form_is_unsigned ())
-    TYPE_LENGTH (set_type) = attr->as_unsigned ();
+    set_type->set_length (attr->as_unsigned ());
 
   maybe_set_alignment (cu, die, set_type);
 
@@ -16194,7 +16189,7 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
 	}
     }
 
-  TYPE_LENGTH (type) = byte_size;
+  type->set_length (byte_size);
   set_type_align (type, alignment);
   return set_die_type (die, type, cu);
 }
@@ -16257,13 +16252,10 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
   type = lookup_reference_type (target_type, refcode);
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr)
-    {
-      TYPE_LENGTH (type) = attr->constant_value (cu_header->addr_size);
-    }
+    type->set_length (attr->constant_value (cu_header->addr_size));
   else
-    {
-      TYPE_LENGTH (type) = cu_header->addr_size;
-    }
+    type->set_length (cu_header->addr_size);
+
   maybe_set_alignment (cu, die, type);
   return set_die_type (die, type, cu);
 }
@@ -17692,7 +17684,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr)
-    TYPE_LENGTH (range_type) = attr->constant_value (0);
+    range_type->set_length (attr->constant_value (0));
 
   maybe_set_alignment (cu, die, range_type);
 
diff --git a/gdb/eval.c b/gdb/eval.c
index ddbdd95b39c..a6e295d78cd 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -482,7 +482,7 @@ fake_method::fake_method (type_instance_flags flags,
   struct type *type = &m_type;
 
   TYPE_MAIN_TYPE (type) = &m_main_type;
-  TYPE_LENGTH (type) = 1;
+  type->set_length (1);
   type->set_code (TYPE_CODE_METHOD);
   TYPE_CHAIN (type) = type;
   type->set_instance_flags (flags);
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 544657d5850..2dda1b8c67c 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -91,10 +91,8 @@ f77_get_dynamic_length_of_aggregate (struct type *type)
   upper_bound = f77_get_upperbound (type);
 
   /* Patch in a valid length value.  */
-
-  TYPE_LENGTH (type) =
-    (upper_bound - lower_bound + 1)
-    * TYPE_LENGTH (check_typedef (type->target_type ()));
+  type->set_length ((upper_bound - lower_bound + 1)
+		    * TYPE_LENGTH (check_typedef (type->target_type ())));
 }
 
 /* Per-dimension statistics.  */
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 843e0efb321..1bead475f5f 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -376,7 +376,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
 
   /* FIXME!  Assumes the machine has only one representation for pointers!  */
 
-  TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT;
+  ntype->set_length (gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT);
   ntype->set_code (TYPE_CODE_PTR);
 
   /* Mark pointers as unsigned.  The target converts between pointers
@@ -388,7 +388,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
   chain = TYPE_CHAIN (ntype);
   while (chain != ntype)
     {
-      TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
+      chain->set_length (TYPE_LENGTH (ntype));
       chain = TYPE_CHAIN (chain);
     }
 
@@ -459,7 +459,7 @@ make_reference_type (struct type *type, struct type **typeptr,
      references, and that it matches the (only) representation for
      pointers!  */
 
-  TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT;
+  ntype->set_length (gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT);
   ntype->set_code (refcode);
 
   *reftype = ntype;
@@ -468,7 +468,7 @@ make_reference_type (struct type *type, struct type **typeptr,
   chain = TYPE_CHAIN (ntype);
   while (chain != ntype)
     {
-      TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
+      chain->set_length (TYPE_LENGTH (ntype));
       chain = TYPE_CHAIN (chain);
     }
 
@@ -524,7 +524,7 @@ make_function_type (struct type *type, struct type **typeptr)
 
   ntype->set_target_type (type);
 
-  TYPE_LENGTH (ntype) = 1;
+  ntype->set_length (1);
   ntype->set_code (TYPE_CODE_FUNC);
 
   INIT_FUNC_SPECIFIC (ntype);
@@ -671,7 +671,7 @@ make_qualified_type (struct type *type, type_instance_flags new_flags,
   ntype->set_instance_flags (new_flags);
 
   /* Set length of new type to that of the original type.  */
-  TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+  ntype->set_length (TYPE_LENGTH (type));
 
   return ntype;
 }
@@ -824,7 +824,7 @@ replace_type (struct type *ntype, struct type *type)
 	 call replace_type().  */
       gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
 
-      TYPE_LENGTH (chain) = TYPE_LENGTH (type);
+      chain->set_length (TYPE_LENGTH (type));
       chain = TYPE_CHAIN (chain);
     }
   while (ntype != chain);
@@ -874,7 +874,7 @@ allocate_stub_method (struct type *type)
 
   mtype = alloc_type_copy (type);
   mtype->set_code (TYPE_CODE_METHOD);
-  TYPE_LENGTH (mtype) = 1;
+  mtype->set_length (1);
   mtype->set_is_stub (true);
   mtype->set_target_type (type);
   /* TYPE_SELF_TYPE (mtype) = unknown yet */
@@ -945,7 +945,7 @@ create_range_type (struct type *result_type, struct type *index_type,
   if (index_type->is_stub ())
     result_type->set_target_is_stub (true);
   else
-    TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
+    result_type->set_length (TYPE_LENGTH (check_typedef (index_type)));
 
   range_bounds *bounds
     = (struct range_bounds *) TYPE_ZALLOC (result_type, sizeof (range_bounds));
@@ -1297,7 +1297,7 @@ update_static_array_size (struct type *type)
 	 empty arrays with the high_bound being smaller than the low_bound.
 	 In such cases, the array length should be zero.  */
       if (high_bound < low_bound)
-	TYPE_LENGTH (type) = 0;
+	type->set_length (0);
       else if (stride != 0)
 	{
 	  /* Ensure that the type length is always positive, even in the
@@ -1307,12 +1307,11 @@ update_static_array_size (struct type *type)
 	     special, it's still just a single element array) so do
 	     consider that case when touching this code.  */
 	  LONGEST element_count = std::abs (high_bound - low_bound + 1);
-	  TYPE_LENGTH (type)
-	    = ((std::abs (stride) * element_count) + 7) / 8;
+	  type->set_length (((std::abs (stride) * element_count) + 7) / 8);
 	}
       else
-	TYPE_LENGTH (type) =
-	  TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
+	type->set_length (TYPE_LENGTH (element_type)
+			  * (high_bound - low_bound + 1));
 
       /* If this array's element is itself an array with a bit stride,
 	 then we want to update this array's bit stride to reflect the
@@ -1397,7 +1396,7 @@ create_array_type_with_stride (struct type *result_type,
 	 to trust TYPE_LENGTH in this case, setting the size to zero
 	 allows us to avoid allocating objects of random sizes in case
 	 we accidently do.  */
-      TYPE_LENGTH (result_type) = 0;
+      result_type->set_length (0);
     }
 
   /* TYPE_TARGET_STUB will take care of zero length arrays.  */
@@ -1492,8 +1491,8 @@ create_set_type (struct type *result_type, struct type *domain_type)
 	low_bound = high_bound = 0;
 
       bit_length = high_bound - low_bound + 1;
-      TYPE_LENGTH (result_type)
-	= (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+      result_type->set_length ((bit_length + TARGET_CHAR_BIT - 1)
+			       / TARGET_CHAR_BIT);
       if (low_bound >= 0)
 	result_type->set_is_unsigned (true);
     }
@@ -1614,7 +1613,7 @@ smash_to_memberptr_type (struct type *type, struct type *self_type,
   set_type_self_type (type, self_type);
   /* Assume that a data member pointer is the same size as a normal
      pointer.  */
-  TYPE_LENGTH (type) = gdbarch_ptr_bit (to_type->arch ()) / TARGET_CHAR_BIT;
+  type->set_length (gdbarch_ptr_bit (to_type->arch ()) / TARGET_CHAR_BIT);
 }
 
 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
@@ -1630,7 +1629,7 @@ smash_to_methodptr_type (struct type *type, struct type *to_type)
   type->set_code (TYPE_CODE_METHODPTR);
   type->set_target_type (to_type);
   set_type_self_type (type, TYPE_SELF_TYPE (to_type));
-  TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
+  type->set_length (cplus_method_ptr_size (to_type));
 }
 
 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
@@ -1651,9 +1650,12 @@ smash_to_method_type (struct type *type, struct type *self_type,
   set_type_self_type (type, self_type);
   type->set_fields (args);
   type->set_num_fields (nargs);
+
   if (varargs)
     type->set_has_varargs (true);
-  TYPE_LENGTH (type) = 1;	/* In practice, this is never needed.  */
+
+  /* In practice, this is never needed.  */
+  type->set_length (1);
 }
 
 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
@@ -2503,7 +2505,7 @@ resolve_dynamic_union (struct type *type,
 	max_len = TYPE_LENGTH (real_type);
     }
 
-  TYPE_LENGTH (resolved_type) = max_len;
+  resolved_type->set_length (max_len);
   return resolved_type;
 }
 
@@ -2777,8 +2779,8 @@ resolve_dynamic_struct (struct type *type,
      type length of the structure.  If we adapt it, we run into problems
      when calculating the element offset for arrays of structs.  */
   if (current_language->la_language != language_fortran)
-    TYPE_LENGTH (resolved_type)
-      = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+    resolved_type->set_length ((resolved_type_bit_length + TARGET_CHAR_BIT - 1)
+			       / TARGET_CHAR_BIT);
 
   /* The Ada language uses this field as a cache for static fixed types: reset
      it as RESOLVED_TYPE must have its own static fixed type.  */
@@ -2873,7 +2875,7 @@ resolve_dynamic_type_internal (struct type *type,
 
   if (type_length.has_value ())
     {
-      TYPE_LENGTH (resolved_type) = *type_length;
+      resolved_type->set_length (*type_length);
       resolved_type->remove_dyn_prop (DYN_PROP_BYTE_SIZE);
     }
 
@@ -3146,7 +3148,7 @@ check_typedef (struct type *type)
 	}
       else if (type->code () == TYPE_CODE_RANGE)
 	{
-	  TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
+	  type->set_length (TYPE_LENGTH (target_type));
 	  type->set_target_is_stub (false);
 	}
       else if (type->code () == TYPE_CODE_ARRAY
@@ -3157,7 +3159,7 @@ check_typedef (struct type *type)
   type = make_qualified_type (type, instance_flags, NULL);
 
   /* Cache TYPE_LENGTH for future use.  */
-  TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
+  orig_type->set_length (TYPE_LENGTH (type));
 
   return type;
 }
@@ -3430,7 +3432,7 @@ init_type (struct objfile *objfile, enum type_code code, int bit,
   type = alloc_type (objfile);
   set_type_code (type, code);
   gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
-  TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
+  type->set_length (bit / TARGET_CHAR_BIT);
   type->set_name (name);
 
   return type;
@@ -3579,7 +3581,7 @@ init_complex_type (const char *name, struct type *target_type)
 
       t = alloc_type_copy (target_type);
       set_type_code (t, TYPE_CODE_COMPLEX);
-      TYPE_LENGTH (t) = 2 * TYPE_LENGTH (target_type);
+      t->set_length (2 * TYPE_LENGTH (target_type));
       t->set_name (name);
 
       t->set_target_type (target_type);
@@ -5658,7 +5660,7 @@ copy_type_recursive (struct type *type, htab_t copied_types)
     new_type->set_name (xstrdup (type->name ()));
 
   new_type->set_instance_flags (type->instance_flags ());
-  TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
+  new_type->set_length (TYPE_LENGTH (type));
 
   /* Copy the fields.  */
   if (type->num_fields ())
@@ -5787,7 +5789,7 @@ copy_type (const struct type *type)
 {
   struct type *new_type = alloc_type_copy (type);
   new_type->set_instance_flags (type->instance_flags ());
-  TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
+  new_type->set_length (TYPE_LENGTH (type));
   memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
 	  sizeof (struct main_type));
   if (type->main_type->dyn_prop_list != NULL)
@@ -5816,7 +5818,7 @@ arch_type (struct gdbarch *gdbarch,
   type = alloc_type_arch (gdbarch);
   set_type_code (type, code);
   gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
-  TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
+  type->set_length (bit / TARGET_CHAR_BIT);
 
   if (name)
     type->set_name (gdbarch_obstack_strdup (gdbarch, name));
@@ -6026,11 +6028,11 @@ append_composite_type_field_aligned (struct type *t, const char *name,
   if (t->code () == TYPE_CODE_UNION)
     {
       if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
-	TYPE_LENGTH (t) = TYPE_LENGTH (field);
+	t->set_length (TYPE_LENGTH (field));
     }
   else if (t->code () == TYPE_CODE_STRUCT)
     {
-      TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
+      t->set_length (TYPE_LENGTH (t) + TYPE_LENGTH (field));
       if (t->num_fields () > 1)
 	{
 	  f->set_loc_bitpos
@@ -6046,7 +6048,8 @@ append_composite_type_field_aligned (struct type *t, const char *name,
 	      if (left)
 		{
 		  f->set_loc_bitpos (f[0].loc_bitpos () + (alignment - left));
-		  TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
+		  t->set_length
+		    (t->length () + (alignment - left) / TARGET_CHAR_BIT);
 		}
 	    }
 	}
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 6f4b2d61ca8..6d12a489b15 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -1045,6 +1045,16 @@ struct type
     this->main_type->name = name;
   }
 
+  ULONGEST length () const
+  {
+    return this->m_length;
+  }
+
+  void set_length (ULONGEST length)
+  {
+    this->m_length = length;
+  }
+
   /* Get the number of fields of this type.  */
   int num_fields () const
   {
@@ -1443,7 +1453,7 @@ struct type
   bool bit_size_differs_p () const
   {
     return (main_type->type_specific_field == TYPE_SPECIFIC_INT
-	    && main_type->type_specific.int_stuff.bit_size != 8 * length);
+	    && main_type->type_specific.int_stuff.bit_size != 8 * length ());
   }
 
   /* * Return the logical (bit) size for this integer type.  Only
@@ -1528,7 +1538,7 @@ struct type
      type_length_units function should be used in order to get the length
      expressed in target addressable memory units.  */
 
-  ULONGEST length;
+  ULONGEST m_length;
 
   /* * Core type, shared by a group of qualified types.  */
 
@@ -2105,7 +2115,7 @@ extern void allocate_gnat_aux_type (struct type *);
    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
    so you only have to call check_typedef once.  Since allocate_value
    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
-#define TYPE_LENGTH(thistype) (thistype)->length
+#define TYPE_LENGTH(thistype) ((thistype)->length ())
 
 /* * Return the alignment of the type in target addressable memory
    units, or 0 if no alignment was specified.  */
diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 673c370e120..56710cf6041 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -1022,7 +1022,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 				 name, (char *) NULL));
 
 	t->set_code (type_code);
-	TYPE_LENGTH (t) = sh->value;
+	t->set_length (sh->value);
 	t->set_num_fields (nfields);
 	f = ((struct field *) TYPE_ALLOC (t, nfields * sizeof (struct field)));
 	t->set_fields (f);
@@ -1043,7 +1043,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	       that too.  */
 	    if (TYPE_LENGTH (t) == t->num_fields ()
 		|| TYPE_LENGTH (t) == 0)
-	      TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
+	      t->set_length (gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT);
 	    for (ext_tsym = ext_sh + external_sym_size;
 		 ;
 		 ext_tsym += external_sym_size)
diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 32aa58c7211..5bd3edb4adc 100644
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -899,7 +899,7 @@ class opencl_language : public language_defn
 	tmp->set_name (OCL_STRING(TYPE ## 2));			\
 	tmp = add (init_vector_type (ELEMENT_TYPE, 3));		\
 	tmp->set_name (OCL_STRING(TYPE ## 3));			\
-	TYPE_LENGTH (tmp) = 4 * TYPE_LENGTH (ELEMENT_TYPE);	\
+	tmp->set_length (4 * TYPE_LENGTH (ELEMENT_TYPE));	\
 	tmp = add (init_vector_type (ELEMENT_TYPE, 4));		\
 	tmp->set_name (OCL_STRING(TYPE ## 4));			\
 	tmp = add (init_vector_type (ELEMENT_TYPE, 8));		\
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index 36f77907a70..a48996e1b2e 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -989,9 +989,8 @@ rust_composite_type (struct type *original,
     }
 
   if (i > 0)
-    TYPE_LENGTH (result)
-      = (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT +
-	 TYPE_LENGTH (result->field (i - 1).type ()));
+    result->set_length (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT
+			+ TYPE_LENGTH (result->field (i - 1).type ()));
   return result;
 }
 
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 3c484cee87b..af34353903b 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1684,7 +1684,7 @@ read_type (const char **pp, struct objfile *objfile)
 	  {
 	    /* It's being defined as itself.  That means it is "void".  */
 	    type->set_code (TYPE_CODE_VOID);
-	    TYPE_LENGTH (type) = 1;
+	    type->set_length (1);
 	  }
 	else if (type_size >= 0 || is_string)
 	  {
@@ -2008,7 +2008,7 @@ read_type (const char **pp, struct objfile *objfile)
 
   /* Size specified in a type attribute overrides any other size.  */
   if (type_size != -1)
-    TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+    type->set_length ((type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT);
 
   return type;
 }
@@ -3385,7 +3385,7 @@ set_length_in_type_chain (struct type *type)
   while (ntype != type)
     {
       if (TYPE_LENGTH(ntype) == 0)
-	TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+	ntype->set_length (TYPE_LENGTH (type));
       else
 	complain_about_struct_wipeout (ntype);
       ntype = TYPE_CHAIN (ntype);
@@ -3441,7 +3441,7 @@ read_struct_type (const char **pp, struct type *type, enum type_code type_code,
   {
     int nbits;
 
-    TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
+    type->set_length (read_huge_number (pp, 0, &nbits, 0));
     if (nbits != 0)
       return error_type (pp, objfile);
     set_length_in_type_chain (type);
@@ -3606,7 +3606,7 @@ read_enum_type (const char **pp, struct type *type,
 
   /* Now fill in the fields of the type-structure.  */
 
-  TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
+  type->set_length (gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT);
   set_length_in_type_chain (type);
   type->set_code (TYPE_CODE_ENUM);
   type->set_is_stub (false);
diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c
index 044b171ecd2..20a79d5d458 100644
--- a/gdb/target-descriptions.c
+++ b/gdb/target-descriptions.c
@@ -246,7 +246,7 @@ make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
 	}
 
       if (e->size != 0)
-	TYPE_LENGTH (m_type) = e->size;
+	m_type->set_length (e->size);
     }
 
     void make_gdb_type_union (const tdesc_type_with_fields *e)
-- 
2.37.3


^ permalink raw reply	[flat|nested] 17+ messages in thread

* [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH
  2022-09-16 15:08 [PATCH 1/4] gdb: add type::target_type / type::set_target_type Simon Marchi
  2022-09-16 15:08 ` [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE Simon Marchi
  2022-09-16 15:08 ` [PATCH 3/4] gdb: add type::length / type::set_length Simon Marchi
@ 2022-09-17  9:48 ` Simon Marchi
  2022-09-21 15:03   ` Tom Tromey
  2022-09-21 14:52 ` [PATCH 1/4] gdb: add type::target_type / type::set_target_type Tom Tromey
  2022-09-21 14:55 ` Tom Tromey
  4 siblings, 1 reply; 17+ messages in thread
From: Simon Marchi @ 2022-09-17  9:48 UTC (permalink / raw)
  To: Simon Marchi, gdb-patches

[-- Attachment #1: Type: text/plain, Size: 92 bytes --]


Patch 4 was slightly too big for the list, here it is as a compressed
attached file.

Simon

[-- Attachment #2: 0001-gdb-remove-TYPE_LENGTH.patch.gz --]
[-- Type: application/gzip, Size: 93574 bytes --]

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE
  2022-09-16 15:08 ` [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE Simon Marchi
@ 2022-09-21 14:37   ` Lancelot SIX
  2022-09-21 15:01     ` Simon Marchi
  2022-09-21 14:57   ` Tom Tromey
  1 sibling, 1 reply; 17+ messages in thread
From: Lancelot SIX @ 2022-09-21 14:37 UTC (permalink / raw)
  To: Simon Marchi; +Cc: gdb-patches

Hi,

When applying it locally, I have:

    Applying: gdb: remove TYPE_TARGET_TYPE
    .git/rebase-apply/patch:4243: space before tab in indent.
                                current_type = current_type->target_type ();
    warning: 1 line adds whitespace errors.

On Fri, Sep 16, 2022 at 11:08:34AM -0400, Simon Marchi via Gdb-patches wrote:
> From: Simon Marchi <simon.marchi@polymtl.ca>
> 
> Remove the macro, replace all uses by calls to type::length.
                                                       ^
I think you meant type::target_type here.

Also after applying the patch, git grep TYPE_TARGET_TYPE gives me:

    gdb/ada-lang.c:   the result of this function in the TYPE_TARGET_TYPE of the
    gdb/c-typeprint.c:       couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
    gdb/gdbtypes.c:   NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
    gdb/m2-typeprint.c:      /* FIXME: TYPE_TARGET_TYPE used to be TYPE_DOMAIN_TYPE but that was
    gdb/m2-typeprint.c:      wrong.  Not sure if TYPE_TARGET_TYPE is correct though.  */
    gdb/m2-typeprint.c:       *  type of _m2_contents is a pointer.  The TYPE_TARGET_TYPE

All those occurrences are in comments, but I think that it would help
future readers to update those new spots as well.

Otherwise, and for what it is worth considering I am not a maintainer,
this looks reasonable to me.  Thanks for taking the time to make those
tree-wide changes!

Lancelot.

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 1/4] gdb: add type::target_type / type::set_target_type
  2022-09-16 15:08 [PATCH 1/4] gdb: add type::target_type / type::set_target_type Simon Marchi
                   ` (2 preceding siblings ...)
  2022-09-17  9:48 ` [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH Simon Marchi
@ 2022-09-21 14:52 ` Tom Tromey
  2022-09-21 14:55 ` Tom Tromey
  4 siblings, 0 replies; 17+ messages in thread
From: Tom Tromey @ 2022-09-21 14:52 UTC (permalink / raw)
  To: Simon Marchi via Gdb-patches; +Cc: Simon Marchi

Simon> Add the `target_type` and `set_target_type` methods on `struct type`, in order
Simon> to remove the `TYPE_TARGET_TYPE` macro.  In this patch, the macro is changed to
Simon> use the getter, so all the call sites of the macro that are used as a setter
Simon> are changed to use the setter method directly.  The next patch will remove the
Simon> macro completely.

This looks good to me.  Thanks for doing this.

Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 1/4] gdb: add type::target_type / type::set_target_type
  2022-09-16 15:08 [PATCH 1/4] gdb: add type::target_type / type::set_target_type Simon Marchi
                   ` (3 preceding siblings ...)
  2022-09-21 14:52 ` [PATCH 1/4] gdb: add type::target_type / type::set_target_type Tom Tromey
@ 2022-09-21 14:55 ` Tom Tromey
  4 siblings, 0 replies; 17+ messages in thread
From: Tom Tromey @ 2022-09-21 14:55 UTC (permalink / raw)
  To: Simon Marchi via Gdb-patches; +Cc: Simon Marchi

Simon> Add the `target_type` and `set_target_type` methods on `struct type`, in order
Simon> to remove the `TYPE_TARGET_TYPE` macro.  In this patch, the macro is changed to
Simon> use the getter, so all the call sites of the macro that are used as a setter
Simon> are changed to use the setter method directly.  The next patch will remove the
Simon> macro completely.

Looks good.  Thank you.

Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE
  2022-09-16 15:08 ` [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE Simon Marchi
  2022-09-21 14:37   ` Lancelot SIX
@ 2022-09-21 14:57   ` Tom Tromey
  2022-09-21 15:02     ` Simon Marchi
  1 sibling, 1 reply; 17+ messages in thread
From: Tom Tromey @ 2022-09-21 14:57 UTC (permalink / raw)
  To: Simon Marchi via Gdb-patches; +Cc: Simon Marchi

Simon> Remove the macro, replace all uses by calls to type::length.

This patch removes TYPE_TARGET_TYPE but the commit message says
something different.

Other than this, it looks good to me.

Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 3/4] gdb: add type::length / type::set_length
  2022-09-16 15:08 ` [PATCH 3/4] gdb: add type::length / type::set_length Simon Marchi
@ 2022-09-21 15:00   ` Tom Tromey
  2022-09-21 15:01   ` Lancelot SIX
  1 sibling, 0 replies; 17+ messages in thread
From: Tom Tromey @ 2022-09-21 15:00 UTC (permalink / raw)
  To: Simon Marchi via Gdb-patches; +Cc: Simon Marchi

Simon> Add the `length` and `set_length` methods on `struct type`, in order to remove
Simon> the `TYPE_LENGTH` macro.  In this patch, the macro is changed to use the
Simon> getter, so all the call sites of the macro that are used as a setter are
Simon> changed to use the setter method directly.  The next patch will remove the
Simon> macro completely.

Looks good, thank you.

Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE
  2022-09-21 14:37   ` Lancelot SIX
@ 2022-09-21 15:01     ` Simon Marchi
  0 siblings, 0 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-21 15:01 UTC (permalink / raw)
  To: Lancelot SIX, Simon Marchi; +Cc: gdb-patches



On 2022-09-21 10:37, Lancelot SIX via Gdb-patches wrote:
> Hi,
> 
> When applying it locally, I have:
> 
>     Applying: gdb: remove TYPE_TARGET_TYPE
>     .git/rebase-apply/patch:4243: space before tab in indent.
>                                 current_type = current_type->target_type ();
>     warning: 1 line adds whitespace errors.

Not my fault, they were already there!  Fixed anyhow, thanks for
pointing it out.

> On Fri, Sep 16, 2022 at 11:08:34AM -0400, Simon Marchi via Gdb-patches wrote:
>> From: Simon Marchi <simon.marchi@polymtl.ca>
>>
>> Remove the macro, replace all uses by calls to type::length.
>                                                        ^
> I think you meant type::target_type here.

Indeed, thanks.

> Also after applying the patch, git grep TYPE_TARGET_TYPE gives me:
> 
>     gdb/ada-lang.c:   the result of this function in the TYPE_TARGET_TYPE of the
>     gdb/c-typeprint.c:       couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
>     gdb/gdbtypes.c:   NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
>     gdb/m2-typeprint.c:      /* FIXME: TYPE_TARGET_TYPE used to be TYPE_DOMAIN_TYPE but that was
>     gdb/m2-typeprint.c:      wrong.  Not sure if TYPE_TARGET_TYPE is correct though.  */
>     gdb/m2-typeprint.c:       *  type of _m2_contents is a pointer.  The TYPE_TARGET_TYPE
> 
> All those occurrences are in comments, but I think that it would help
> future readers to update those new spots as well.

Yeah, there are some occurences for other macros as well.  I will update
these to say "type::target_type" instead.  There are some occurences
(not of TYPE_TARGET_TYPE but some other macro) that is in some commented
out code that is probably quite stale.  I don't know how relevant it is
to update that, but I guess it doesn't hurt.

> Otherwise, and for what it is worth considering I am not a maintainer,
> this looks reasonable to me.  Thanks for taking the time to make those
> tree-wide changes!

Cool, thanks for taking a look.

Simon

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 3/4] gdb: add type::length / type::set_length
  2022-09-16 15:08 ` [PATCH 3/4] gdb: add type::length / type::set_length Simon Marchi
  2022-09-21 15:00   ` Tom Tromey
@ 2022-09-21 15:01   ` Lancelot SIX
  2022-09-21 16:44     ` Tom Tromey
  1 sibling, 1 reply; 17+ messages in thread
From: Lancelot SIX @ 2022-09-21 15:01 UTC (permalink / raw)
  To: Simon Marchi; +Cc: gdb-patches

Hi,

On Fri, Sep 16, 2022 at 11:08:35AM -0400, Simon Marchi via Gdb-patches wrote:
> From: Simon Marchi <simon.marchi@polymtl.ca>
> 
> Add the `length` and `set_length` methods on `struct type`, in order to remove
> the `TYPE_LENGTH` macro.  In this patch, the macro is changed to use the
> getter, so all the call sites of the macro that are used as a setter are
> changed to use the setter method directly.  The next patch will remove the
> macro completely.
> 
> Change-Id: Id1090244f15c9856969b9be5006aefe8d8897ca4
> ---
>  gdb/ada-lang.c            | 47 +++++++++++++-------------
>  gdb/coffread.c            | 14 ++++----
>  gdb/cp-valprint.c         |  2 +-
>  gdb/ctfread.c             | 10 +++---
>  gdb/dwarf2/read.c         | 44 ++++++++++--------------
>  gdb/eval.c                |  2 +-
>  gdb/f-valprint.c          |  6 ++--
>  gdb/gdbtypes.c            | 71 ++++++++++++++++++++-------------------
>  gdb/gdbtypes.h            | 16 +++++++--
>  gdb/mdebugread.c          |  4 +--
>  gdb/opencl-lang.c         |  2 +-
>  gdb/rust-lang.c           |  5 ++-
>  gdb/stabsread.c           | 10 +++---
>  gdb/target-descriptions.c |  2 +-
>  14 files changed, 119 insertions(+), 116 deletions(-)
> 
> diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
> index d0b13a6bed2..06eab777f57 100644
> --- a/gdb/ada-lang.c
> +++ b/gdb/ada-lang.c
> @@ -2165,7 +2165,7 @@ ada_type_of_array (struct value *arr, int bounds)
>  		  int array_bitsize =
>  			(hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
>  
> -		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
> +		  array_type->set_length ((array_bitsize + 7) / 8);

Do you think that while at it you could also replace the 7 and 8
literals with appropriate configured values?

    array_type->set_length ((array_bitsize + HOST_CHAR_BIT - 1)
                            / HOST_CHAR_BIT);

This is not directly linked to what you are changing, might be done in
a separate patch.

>  		}
>  	    }
>  	}
> diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
> index 843e0efb321..1bead475f5f 100644
> --- a/gdb/gdbtypes.c
> +++ b/gdb/gdbtypes.c
> @@ -1307,12 +1307,11 @@ update_static_array_size (struct type *type)
>  	     special, it's still just a single element array) so do
>  	     consider that case when touching this code.  */
>  	  LONGEST element_count = std::abs (high_bound - low_bound + 1);
> -	  TYPE_LENGTH (type)
> -	    = ((std::abs (stride) * element_count) + 7) / 8;
> +	  type->set_length (((std::abs (stride) * element_count) + 7) / 8);

Same here.

>  	}
>        else
> -	TYPE_LENGTH (type) =
> -	  TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
> +	type->set_length (TYPE_LENGTH (element_type)
> +			  * (high_bound - low_bound + 1));
>  
>        /* If this array's element is itself an array with a bit stride,
>  	 then we want to update this array's bit stride to reflect the
> diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
> index 6f4b2d61ca8..6d12a489b15 100644
> --- a/gdb/gdbtypes.h
> +++ b/gdb/gdbtypes.h
> @@ -1443,7 +1453,7 @@ struct type
>    bool bit_size_differs_p () const
>    {
>      return (main_type->type_specific_field == TYPE_SPECIFIC_INT
> -	    && main_type->type_specific.int_stuff.bit_size != 8 * length);
> +	    && main_type->type_specific.int_stuff.bit_size != 8 * length ());

Same, HOST_CHAR_BIT * length ()

>    }

Best,
Lancelot.

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE
  2022-09-21 14:57   ` Tom Tromey
@ 2022-09-21 15:02     ` Simon Marchi
  0 siblings, 0 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-21 15:02 UTC (permalink / raw)
  To: Tom Tromey, Simon Marchi via Gdb-patches; +Cc: Simon Marchi



On 2022-09-21 10:57, Tom Tromey wrote:
> Simon> Remove the macro, replace all uses by calls to type::length.
> 
> This patch removes TYPE_TARGET_TYPE but the commit message says
> something different.

Yeah, Lancelot pointed it out, thanks.

Simon

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH
  2022-09-17  9:48 ` [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH Simon Marchi
@ 2022-09-21 15:03   ` Tom Tromey
  2022-09-21 15:04     ` Simon Marchi
  0 siblings, 1 reply; 17+ messages in thread
From: Tom Tromey @ 2022-09-21 15:03 UTC (permalink / raw)
  To: Simon Marchi via Gdb-patches; +Cc: Simon Marchi, Simon Marchi

>>>>> "Simon" == Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> writes:

Simon> Patch 4 was slightly too big for the list, here it is as a compressed
Simon> attached file.

This looks good.  Thank you.

Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH
  2022-09-21 15:03   ` Tom Tromey
@ 2022-09-21 15:04     ` Simon Marchi
  0 siblings, 0 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-21 15:04 UTC (permalink / raw)
  To: Tom Tromey, Simon Marchi via Gdb-patches; +Cc: Simon Marchi



On 2022-09-21 11:03, Tom Tromey wrote:
>>>>>> "Simon" == Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> writes:
> 
> Simon> Patch 4 was slightly too big for the list, here it is as a compressed
> Simon> attached file.
> 
> This looks good.  Thank you.
> 
> Tom

Thanks Tom, I will push shortly.

Simon

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 3/4] gdb: add type::length / type::set_length
  2022-09-21 15:01   ` Lancelot SIX
@ 2022-09-21 16:44     ` Tom Tromey
  2022-09-21 17:00       ` Simon Marchi
  2022-09-21 18:48       ` Lancelot SIX
  0 siblings, 2 replies; 17+ messages in thread
From: Tom Tromey @ 2022-09-21 16:44 UTC (permalink / raw)
  To: Lancelot SIX via Gdb-patches; +Cc: Simon Marchi, Lancelot SIX

>>>>> "Lancelot" == Lancelot SIX via Gdb-patches <gdb-patches@sourceware.org> writes:

>> -		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
>> +		  array_type->set_length ((array_bitsize + 7) / 8);

Lancelot> Do you think that while at it you could also replace the 7 and 8
Lancelot> literals with appropriate configured values?

...
Lancelot>                             / HOST_CHAR_BIT);

Normally I think the '8' is a target value, not a host value.
Like, if HOST_CHAR_BIT != 8, would this do the wrong thing?

Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 3/4] gdb: add type::length / type::set_length
  2022-09-21 16:44     ` Tom Tromey
@ 2022-09-21 17:00       ` Simon Marchi
  2022-09-21 18:48       ` Lancelot SIX
  1 sibling, 0 replies; 17+ messages in thread
From: Simon Marchi @ 2022-09-21 17:00 UTC (permalink / raw)
  To: Tom Tromey, Lancelot SIX via Gdb-patches; +Cc: Simon Marchi, Lancelot SIX



On 2022-09-21 12:44, Tom Tromey wrote:
>>>>>> "Lancelot" == Lancelot SIX via Gdb-patches <gdb-patches@sourceware.org> writes:
> 
>>> -		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
>>> +		  array_type->set_length ((array_bitsize + 7) / 8);
> 
> Lancelot> Do you think that while at it you could also replace the 7 and 8
> Lancelot> literals with appropriate configured values?
> 
> ...
> Lancelot>                             / HOST_CHAR_BIT);
> 
> Normally I think the '8' is a target value, not a host value.
> Like, if HOST_CHAR_BIT != 8, would this do the wrong thing?

Sorry, Lancelot, I missed your message before pushing.  In any case, I
wouldn't have done this change in that patch, as it's orthogonal.

I wouldn't worry about HOST_CHAR_BIT every being anything other than 8.

Simon

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 3/4] gdb: add type::length / type::set_length
  2022-09-21 16:44     ` Tom Tromey
  2022-09-21 17:00       ` Simon Marchi
@ 2022-09-21 18:48       ` Lancelot SIX
  1 sibling, 0 replies; 17+ messages in thread
From: Lancelot SIX @ 2022-09-21 18:48 UTC (permalink / raw)
  To: Tom Tromey; +Cc: Lancelot SIX via Gdb-patches, Simon Marchi

On Wed, Sep 21, 2022 at 10:44:08AM -0600, Tom Tromey wrote:
> >>>>> "Lancelot" == Lancelot SIX via Gdb-patches <gdb-patches@sourceware.org> writes:
> 
> >> -		  TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
> >> +		  array_type->set_length ((array_bitsize + 7) / 8);
> 
> Lancelot> Do you think that while at it you could also replace the 7 and 8
> Lancelot> literals with appropriate configured values?
> 
> ...
> Lancelot>                             / HOST_CHAR_BIT);
> 
> Normally I think the '8' is a target value, not a host value.
> Like, if HOST_CHAR_BIT != 8, would this do the wrong thing?

Hi,

In this case I believe we do want the host value.  The description of
the m_length field in struct type says:

  Length of storage for a value of this type.  The value is the
  expression in host bytes of what sizeof(type) would return.
  [...]
  Since this field is expressed in host bytes, its value is appropriate
  to pass to memcpy and such.

My understanding from this is that when doing some_type->set_length ()
the argument should be HOST_CHAR_BIT aware.

That being said, I do not think GDB is ever executed on any non-8bit
bytes hosts.  Part of the comment I quoted above even states:

  it is assumed that GDB itself always runs on an 8-bits addressable
  architecture

As a consequence, I think the current literals are valid, but giving
them an explicit name helps as it reminds that this is not a target
byte.

Also, as there are no non-8bit bytes targets supported to my knowledge,
I am not sure if GDB is currently viable for such use-case.  But since
we have some some infrastructure to support this, I try to account for
it were possible (I am not always sure to what extent I have it right
though).

Lancelot.

> 
> Tom

^ permalink raw reply	[flat|nested] 17+ messages in thread

end of thread, other threads:[~2022-09-21 18:48 UTC | newest]

Thread overview: 17+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-09-16 15:08 [PATCH 1/4] gdb: add type::target_type / type::set_target_type Simon Marchi
2022-09-16 15:08 ` [PATCH 2/4] gdb: remove TYPE_TARGET_TYPE Simon Marchi
2022-09-21 14:37   ` Lancelot SIX
2022-09-21 15:01     ` Simon Marchi
2022-09-21 14:57   ` Tom Tromey
2022-09-21 15:02     ` Simon Marchi
2022-09-16 15:08 ` [PATCH 3/4] gdb: add type::length / type::set_length Simon Marchi
2022-09-21 15:00   ` Tom Tromey
2022-09-21 15:01   ` Lancelot SIX
2022-09-21 16:44     ` Tom Tromey
2022-09-21 17:00       ` Simon Marchi
2022-09-21 18:48       ` Lancelot SIX
2022-09-17  9:48 ` [RESEND PATCH 4/4] gdb: remove TYPE_LENGTH Simon Marchi
2022-09-21 15:03   ` Tom Tromey
2022-09-21 15:04     ` Simon Marchi
2022-09-21 14:52 ` [PATCH 1/4] gdb: add type::target_type / type::set_target_type Tom Tromey
2022-09-21 14:55 ` Tom Tromey

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).