diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c
index ea93e9ad0d2..058d5bfce85 100644
--- a/gdb/aarch64-tdep.c
+++ b/gdb/aarch64-tdep.c
@@ -1800,7 +1800,7 @@ pass_in_v_vfp_candidate (struct gdbarch *gdbarch, struct regcache *regcache,
 	    continue;
 
 	  struct value *field = value_primitive_field (arg, 0, i, arg_type);
-	  struct type *field_type = check_typedef (value_type (field));
+	  struct type *field_type = check_typedef (field->type ());
 
 	  if (!pass_in_v_vfp_candidate (gdbarch, regcache, info, field_type,
 					field))
@@ -1875,7 +1875,7 @@ aarch64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       struct type *arg_type, *fundamental_type;
       int len, elements;
 
-      arg_type = check_typedef (value_type (arg));
+      arg_type = check_typedef (arg->type ());
       len = arg_type->length ();
 
       /* If arg can be passed in v registers as per the AAPCS64, then do so if
@@ -2767,7 +2767,7 @@ aarch64_pseudo_read_value_1 (struct gdbarch *gdbarch,
 
   if (regcache->raw_read (v_regnum, reg_buf) != REG_VALID)
     mark_value_bytes_unavailable (result_value, 0,
-				  value_type (result_value)->length ());
+				  result_value->type ()->length ());
   else
     memcpy (value_contents_raw (result_value).data (), reg_buf, regsize);
 
diff --git a/gdb/ada-exp.h b/gdb/ada-exp.h
index 36ac3aaddb7..7e59267192a 100644
--- a/gdb/ada-exp.h
+++ b/gdb/ada-exp.h
@@ -249,7 +249,7 @@ class ada_binop_equal_operation
 		   enum noside noside) override
   {
     value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
-    value *arg2 = std::get<2> (m_storage)->evaluate (value_type (arg1),
+    value *arg2 = std::get<2> (m_storage)->evaluate (arg1->type (),
 						     exp, noside);
     return ada_equal_binop (expect_type, exp, noside, std::get<0> (m_storage),
 			    arg1, arg2);
@@ -275,7 +275,7 @@ class ada_bitwise_operation
     value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
     value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
     value *result = eval_op_binary (expect_type, exp, noside, OP, lhs, rhs);
-    return value_cast (value_type (lhs), result);
+    return value_cast (lhs->type (), result);
   }
 
   enum exp_opcode opcode () const override
diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y
index 2f466e4de0a..5436585b73b 100644
--- a/gdb/ada-exp.y
+++ b/gdb/ada-exp.y
@@ -303,7 +303,7 @@ ada_funcall (int nargs)
       struct value *callee_v = callee->evaluate (nullptr,
 						 pstate->expout.get (),
 						 EVAL_AVOID_SIDE_EFFECTS);
-      callee_t = ada_check_typedef (value_type (callee_v));
+      callee_t = ada_check_typedef (callee_v->type ());
       array_arity = ada_array_arity (callee_t);
     }
 
@@ -503,7 +503,7 @@ exp1	:	exp
 			    = lhs->evaluate (nullptr, pstate->expout.get (),
 					     EVAL_AVOID_SIDE_EFFECTS);
 			  rhs = resolve (std::move (rhs), true,
-					 value_type (lhs_val));
+					 lhs_val->type ());
 			  pstate->push_new<ada_assign_operation>
 			    (std::move (lhs), std::move (rhs));
 			}
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 3cd6f73f36f..da49149c56d 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -549,7 +549,7 @@ static struct value *
 coerce_unspec_val_to_type (struct value *val, struct type *type)
 {
   type = ada_check_typedef (type);
-  if (value_type (val) == type)
+  if (val->type () == type)
     return val;
   else
     {
@@ -560,7 +560,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
       else if (value_lazy (val)
 	       /* Be careful not to make a lazy not_lval value.  */
 	       || (VALUE_LVAL (val) != not_lval
-		   && type->length () > value_type (val)->length ()))
+		   && type->length () > val->type ()->length ()))
 	result = allocate_value_lazy (type);
       else
 	{
@@ -754,7 +754,7 @@ get_base_type (struct type *type)
 struct value *
 ada_get_decoded_value (struct value *value)
 {
-  struct type *type = ada_check_typedef (value_type (value));
+  struct type *type = ada_check_typedef (value->type ());
 
   if (ada_is_array_descriptor_type (type)
       || (ada_is_constrained_packed_array_type (type)
@@ -1756,7 +1756,7 @@ thin_descriptor_type (struct type *type)
 static struct value *
 thin_data_pntr (struct value *val)
 {
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
   struct type *data_type = desc_data_target_type (thin_descriptor_type (type));
 
   data_type = lookup_pointer_type (data_type);
@@ -1813,7 +1813,7 @@ desc_bounds_type (struct type *type)
 static struct value *
 desc_bounds (struct value *arr)
 {
-  struct type *type = ada_check_typedef (value_type (arr));
+  struct type *type = ada_check_typedef (arr->type ());
 
   if (is_thin_pntr (type))
     {
@@ -1841,7 +1841,7 @@ desc_bounds (struct value *arr)
     {
       struct value *p_bounds = value_struct_elt (&arr, {}, "P_BOUNDS", NULL,
 					       _("Bad GNAT array descriptor"));
-      struct type *p_bounds_type = value_type (p_bounds);
+      struct type *p_bounds_type = p_bounds->type ();
 
       if (p_bounds_type
 	  && p_bounds_type->code () == TYPE_CODE_PTR)
@@ -1916,7 +1916,7 @@ desc_data_target_type (struct type *type)
 static struct value *
 desc_data (struct value *arr)
 {
-  struct type *type = value_type (arr);
+  struct type *type = arr->type ();
 
   if (is_thin_pntr (type))
     return thin_data_pntr (arr);
@@ -2105,20 +2105,20 @@ ada_is_bogus_array_descriptor (struct type *type)
 static struct type *
 ada_type_of_array (struct value *arr, int bounds)
 {
-  if (ada_is_constrained_packed_array_type (value_type (arr)))
-    return decode_constrained_packed_array_type (value_type (arr));
+  if (ada_is_constrained_packed_array_type (arr->type ()))
+    return decode_constrained_packed_array_type (arr->type ());
 
-  if (!ada_is_array_descriptor_type (value_type (arr)))
-    return value_type (arr);
+  if (!ada_is_array_descriptor_type (arr->type ()))
+    return arr->type ();
 
   if (!bounds)
     {
       struct type *array_type =
-	ada_check_typedef (desc_data_target_type (value_type (arr)));
+	ada_check_typedef (desc_data_target_type (arr->type ()));
 
-      if (ada_is_unconstrained_packed_array_type (value_type (arr)))
+      if (ada_is_unconstrained_packed_array_type (arr->type ()))
 	TYPE_FIELD_BITSIZE (array_type, 0) =
-	  decode_packed_array_bitsize (value_type (arr));
+	  decode_packed_array_bitsize (arr->type ());
       
       return array_type;
     }
@@ -2128,29 +2128,29 @@ ada_type_of_array (struct value *arr, int bounds)
       int arity;
       struct value *descriptor;
 
-      elt_type = ada_array_element_type (value_type (arr), -1);
-      arity = ada_array_arity (value_type (arr));
+      elt_type = ada_array_element_type (arr->type (), -1);
+      arity = ada_array_arity (arr->type ());
 
       if (elt_type == NULL || arity == 0)
-	return ada_check_typedef (value_type (arr));
+	return ada_check_typedef (arr->type ());
 
       descriptor = desc_bounds (arr);
       if (value_as_long (descriptor) == 0)
 	return NULL;
       while (arity > 0)
 	{
-	  struct type *range_type = alloc_type_copy (value_type (arr));
-	  struct type *array_type = alloc_type_copy (value_type (arr));
+	  struct type *range_type = alloc_type_copy (arr->type ());
+	  struct type *array_type = alloc_type_copy (arr->type ());
 	  struct value *low = desc_one_bound (descriptor, arity, 0);
 	  struct value *high = desc_one_bound (descriptor, arity, 1);
 
 	  arity -= 1;
-	  create_static_range_type (range_type, value_type (low),
+	  create_static_range_type (range_type, low->type (),
 				    longest_to_int (value_as_long (low)),
 				    longest_to_int (value_as_long (high)));
 	  elt_type = create_array_type (array_type, elt_type, range_type);
 
-	  if (ada_is_unconstrained_packed_array_type (value_type (arr)))
+	  if (ada_is_unconstrained_packed_array_type (arr->type ()))
 	    {
 	      /* We need to store the element packed bitsize, as well as
 		 recompute the array size, because it was previously
@@ -2159,7 +2159,7 @@ ada_type_of_array (struct value *arr, int bounds)
 	      LONGEST hi = value_as_long (high);
 
 	      TYPE_FIELD_BITSIZE (elt_type, 0) =
-		decode_packed_array_bitsize (value_type (arr));
+		decode_packed_array_bitsize (arr->type ());
 	      /* If the array has no element, then the size is already
 		 zero, and does not need to be recomputed.  */
 	      if (lo < hi)
@@ -2184,7 +2184,7 @@ ada_type_of_array (struct value *arr, int bounds)
 struct value *
 ada_coerce_to_simple_array_ptr (struct value *arr)
 {
-  if (ada_is_array_descriptor_type (value_type (arr)))
+  if (ada_is_array_descriptor_type (arr->type ()))
     {
       struct type *arrType = ada_type_of_array (arr, 1);
 
@@ -2192,7 +2192,7 @@ ada_coerce_to_simple_array_ptr (struct value *arr)
 	return NULL;
       return value_cast (arrType, value_copy (desc_data (arr)));
     }
-  else if (ada_is_constrained_packed_array_type (value_type (arr)))
+  else if (ada_is_constrained_packed_array_type (arr->type ()))
     return decode_constrained_packed_array (arr);
   else
     return arr;
@@ -2205,7 +2205,7 @@ ada_coerce_to_simple_array_ptr (struct value *arr)
 struct value *
 ada_coerce_to_simple_array (struct value *arr)
 {
-  if (ada_is_array_descriptor_type (value_type (arr)))
+  if (ada_is_array_descriptor_type (arr->type ()))
     {
       struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
 
@@ -2213,7 +2213,7 @@ ada_coerce_to_simple_array (struct value *arr)
 	error (_("Bounds unavailable for null array pointer."));
       return value_ind (arrVal);
     }
-  else if (ada_is_constrained_packed_array_type (value_type (arr)))
+  else if (ada_is_constrained_packed_array_type (arr->type ()))
     return decode_constrained_packed_array (arr);
   else
     return arr;
@@ -2501,10 +2501,10 @@ decode_constrained_packed_array (struct value *arr)
      and "value_ind" routines to perform the dereferencing, as opposed
      to using "ada_coerce_ref" or "ada_value_ind".  */
   arr = coerce_ref (arr);
-  if (ada_check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
+  if (ada_check_typedef (arr->type ())->code () == TYPE_CODE_PTR)
     arr = value_ind (arr);
 
-  type = decode_constrained_packed_array_type (value_type (arr));
+  type = decode_constrained_packed_array_type (arr->type ());
   if (type == NULL)
     {
       error (_("can't unpack array"));
@@ -2523,8 +2523,8 @@ decode_constrained_packed_array (struct value *arr)
   type = resolve_dynamic_type (type, view, address);
   recursively_update_array_bitsize (type);
 
-  if (type_byte_order (value_type (arr)) == BFD_ENDIAN_BIG
-      && ada_is_modular_type (value_type (arr)))
+  if (type_byte_order (arr->type ()) == BFD_ENDIAN_BIG
+      && ada_is_modular_type (arr->type ()))
     {
        /* This is a (right-justified) modular type representing a packed
 	  array with no wrapper.  In order to interpret the value through
@@ -2533,14 +2533,14 @@ decode_constrained_packed_array (struct value *arr)
       int bit_size, bit_pos;
       ULONGEST mod;
 
-      mod = ada_modulus (value_type (arr)) - 1;
+      mod = ada_modulus (arr->type ()) - 1;
       bit_size = 0;
       while (mod > 0)
 	{
 	  bit_size += 1;
 	  mod >>= 1;
 	}
-      bit_pos = HOST_CHAR_BIT * value_type (arr)->length () - bit_size;
+      bit_pos = HOST_CHAR_BIT * arr->type ()->length () - bit_size;
       arr = ada_value_primitive_packed_val (arr, NULL,
 					    bit_pos / HOST_CHAR_BIT,
 					    bit_pos % HOST_CHAR_BIT,
@@ -2566,7 +2566,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind)
 
   bits = 0;
   elt_total_bit_offset = 0;
-  elt_type = ada_check_typedef (value_type (arr));
+  elt_type = ada_check_typedef (arr->type ());
   for (i = 0; i < arity; i += 1)
     {
       if (elt_type->code () != TYPE_CODE_ARRAY
@@ -2877,15 +2877,15 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
 static struct value *
 ada_value_assign (struct value *toval, struct value *fromval)
 {
-  struct type *type = value_type (toval);
+  struct type *type = toval->type ();
   int bits = value_bitsize (toval);
 
   toval = ada_coerce_ref (toval);
   fromval = ada_coerce_ref (fromval);
 
-  if (ada_is_direct_array_type (value_type (toval)))
+  if (ada_is_direct_array_type (toval->type ()))
     toval = ada_coerce_to_simple_array (toval);
-  if (ada_is_direct_array_type (value_type (fromval)))
+  if (ada_is_direct_array_type (fromval->type ()))
     fromval = ada_coerce_to_simple_array (fromval);
 
   if (!deprecated_value_modifiable (toval))
@@ -2909,11 +2909,11 @@ ada_value_assign (struct value *toval, struct value *fromval)
       read_memory (to_addr, buffer, len);
       from_size = value_bitsize (fromval);
       if (from_size == 0)
-	from_size = value_type (fromval)->length () * TARGET_CHAR_BIT;
+	from_size = fromval->type ()->length () * TARGET_CHAR_BIT;
 
       const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
       ULONGEST from_offset = 0;
-      if (is_big_endian && is_scalar_type (value_type (fromval)))
+      if (is_big_endian && is_scalar_type (fromval->type ()))
 	from_offset = from_size - bits;
       copy_bitwise (buffer, value_bitpos (toval),
 		    value_contents (fromval).data (), from_offset,
@@ -2954,20 +2954,20 @@ value_assign_to_component (struct value *container, struct value *component,
     value_bitpos (component) - value_bitpos (container);
   int bits;
 
-  val = value_cast (value_type (component), val);
+  val = value_cast (component->type (), val);
 
   if (value_bitsize (component) == 0)
-    bits = TARGET_CHAR_BIT * value_type (component)->length ();
+    bits = TARGET_CHAR_BIT * component->type ()->length ();
   else
     bits = value_bitsize (component);
 
-  if (type_byte_order (value_type (container)) == BFD_ENDIAN_BIG)
+  if (type_byte_order (container->type ()) == BFD_ENDIAN_BIG)
     {
       int src_offset;
 
-      if (is_scalar_type (check_typedef (value_type (component))))
+      if (is_scalar_type (check_typedef (component->type ())))
 	src_offset
-	  = value_type (component)->length () * TARGET_CHAR_BIT - bits;
+	  = component->type ()->length () * TARGET_CHAR_BIT - bits;
       else
 	src_offset = 0;
       copy_bitwise ((value_contents_writeable (container).data ()
@@ -3004,7 +3004,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind)
 
   elt = ada_coerce_to_simple_array (arr);
 
-  elt_type = ada_check_typedef (value_type (elt));
+  elt_type = ada_check_typedef (elt->type ());
   if (elt_type->code () == TYPE_CODE_ARRAY
       && TYPE_FIELD_BITSIZE (elt_type, 0) > 0)
     return value_subscript_packed (elt, arity, ind);
@@ -3019,7 +3019,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind)
       elt = value_subscript (elt, pos_atr (ind[k]));
 
       if (ada_is_access_to_unconstrained_array (saved_elt_type)
-	  && value_type (elt)->code () != TYPE_CODE_TYPEDEF)
+	  && elt->type ()->code () != TYPE_CODE_TYPEDEF)
 	{
 	  /* The element is a typedef to an unconstrained array,
 	     except that the value_subscript call stripped the
@@ -3036,7 +3036,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind)
 	  deprecated_set_value_type (elt, saved_elt_type);
 	}
 
-      elt_type = ada_check_typedef (value_type (elt));
+      elt_type = ada_check_typedef (elt->type ());
     }
 
   return elt;
@@ -3124,7 +3124,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
 static struct value *
 ada_value_slice (struct value *array, int low, int high)
 {
-  struct type *type = ada_check_typedef (value_type (array));
+  struct type *type = ada_check_typedef (array->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);
@@ -3332,7 +3332,7 @@ ada_array_bound (struct value *arr, int n, int which)
 {
   struct type *arr_type;
 
-  if (check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
+  if (check_typedef (arr->type ())->code () == TYPE_CODE_PTR)
     arr = value_ind (arr);
   arr_type = value_enclosing_type (arr);
 
@@ -3356,7 +3356,7 @@ ada_array_length (struct value *arr, int n)
   struct type *arr_type, *index_type;
   int low, high;
 
-  if (check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
+  if (check_typedef (arr->type ())->code () == TYPE_CODE_PTR)
     arr = value_ind (arr);
   arr_type = value_enclosing_type (arr);
 
@@ -3984,7 +3984,7 @@ ada_args_match (struct symbol *func, struct value **actuals, int n_actuals)
       else
 	{
 	  struct type *ftype = ada_check_typedef (func_type->field (i).type ());
-	  struct type *atype = ada_check_typedef (value_type (actuals[i]));
+	  struct type *atype = ada_check_typedef (actuals[i]->type ());
 
 	  if (!ada_type_match (ftype, atype))
 	    return 0;
@@ -4185,9 +4185,9 @@ static int
 possible_user_operator_p (enum exp_opcode op, struct value *args[])
 {
   struct type *type0 =
-    (args[0] == NULL) ? NULL : ada_check_typedef (value_type (args[0]));
+    (args[0] == NULL) ? NULL : ada_check_typedef (args[0]->type ());
   struct type *type1 =
-    (args[1] == NULL) ? NULL : ada_check_typedef (value_type (args[1]));
+    (args[1] == NULL) ? NULL : ada_check_typedef (args[1]->type ());
 
   if (type0 == NULL)
     return 0;
@@ -4352,7 +4352,7 @@ ensure_lval (struct value *val)
   if (VALUE_LVAL (val) == not_lval
       || VALUE_LVAL (val) == lval_internalvar)
     {
-      int len = ada_check_typedef (value_type (val))->length ();
+      int len = ada_check_typedef (val->type ())->length ();
       const CORE_ADDR addr =
 	value_as_long (value_allocate_space_in_inferior (len));
 
@@ -4384,7 +4384,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
   int check_tag;
 
   v = NULL;
-  t1 = t = ada_check_typedef (value_type (arg));
+  t1 = t = ada_check_typedef (arg->type ());
   if (t->code () == TYPE_CODE_REF)
     {
       t1 = t->target_type ();
@@ -4459,7 +4459,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
 
       /* Resolve the dynamic type as well.  */
       arg = value_from_contents_and_address (t1, nullptr, address);
-      t1 = value_type (arg);
+      t1 = arg->type ();
 
       if (find_struct_field (name, t1, 0,
 			     &field_type, &byte_offset, &bit_offset,
@@ -4501,7 +4501,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
 struct value *
 ada_convert_actual (struct value *actual, struct type *formal_type0)
 {
-  struct type *actual_type = ada_check_typedef (value_type (actual));
+  struct type *actual_type = ada_check_typedef (actual->type ());
   struct type *formal_type = ada_check_typedef (formal_type0);
   struct type *formal_target =
     formal_type->code () == TYPE_CODE_PTR
@@ -4527,7 +4527,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0)
 	    {
 	      struct value *val;
 
-	      actual_type = ada_check_typedef (value_type (actual));
+	      actual_type = ada_check_typedef (actual->type ());
 	      val = allocate_value (actual_type);
 	      copy (value_contents (actual), value_contents_raw (val));
 	      actual = ensure_lval (val);
@@ -4588,15 +4588,15 @@ make_array_descriptor (struct type *type, struct value *arr)
   struct value *bounds = allocate_value (bounds_type);
   int i;
 
-  for (i = ada_array_arity (ada_check_typedef (value_type (arr)));
+  for (i = ada_array_arity (ada_check_typedef (arr->type ()));
        i > 0; i -= 1)
     {
-      modify_field (value_type (bounds),
+      modify_field (bounds->type (),
 		    value_contents_writeable (bounds).data (),
 		    ada_array_bound (arr, i, 0),
 		    desc_bound_bitpos (bounds_type, i, 0),
 		    desc_bound_bitsize (bounds_type, i, 0));
-      modify_field (value_type (bounds),
+      modify_field (bounds->type (),
 		    value_contents_writeable (bounds).data (),
 		    ada_array_bound (arr, i, 1),
 		    desc_bound_bitpos (bounds_type, i, 1),
@@ -4605,14 +4605,14 @@ make_array_descriptor (struct type *type, struct value *arr)
 
   bounds = ensure_lval (bounds);
 
-  modify_field (value_type (descriptor),
+  modify_field (descriptor->type (),
 		value_contents_writeable (descriptor).data (),
 		value_pointer (ensure_lval (arr),
 			       desc_type->field (0).type ()),
 		fat_pntr_data_bitpos (desc_type),
 		fat_pntr_data_bitsize (desc_type));
 
-  modify_field (value_type (descriptor),
+  modify_field (descriptor->type (),
 		value_contents_writeable (descriptor).data (),
 		value_pointer (bounds,
 			       desc_type->field (1).type ()),
@@ -6361,7 +6361,7 @@ ada_is_tag_type (struct type *type)
 static struct type *
 ada_tag_type (struct value *val)
 {
-  return ada_lookup_struct_elt_type (value_type (val), "_tag", 1, 0);
+  return ada_lookup_struct_elt_type (val->type (), "_tag", 1, 0);
 }
 
 /* Return 1 if TAG follows the old scheme for Ada tags (used for Ada 95,
@@ -6435,7 +6435,7 @@ ada_tag_value_at_base_address (struct value *obj)
   struct value *tag;
   CORE_ADDR base_address;
 
-  obj_type = value_type (obj);
+  obj_type = obj->type ();
 
   /* It is the responsability of the caller to deref pointers.  */
 
@@ -6618,7 +6618,7 @@ ada_tag_name (struct value *tag)
 {
   gdb::unique_xmalloc_ptr<char> name;
 
-  if (!ada_is_tag_type (value_type (tag)))
+  if (!ada_is_tag_type (tag->type ()))
     return NULL;
 
   /* It is perfectly possible that an exception be raised while trying
@@ -7513,7 +7513,7 @@ ada_value_ind (struct value *val0)
 {
   struct value *val = value_ind (val0);
 
-  if (ada_is_tagged_type (value_type (val), 0))
+  if (ada_is_tagged_type (val->type (), 0))
     val = ada_tag_value_at_base_address (val);
 
   return ada_to_fixed_value (val);
@@ -7525,13 +7525,13 @@ ada_value_ind (struct value *val0)
 static struct value *
 ada_coerce_ref (struct value *val0)
 {
-  if (value_type (val0)->code () == TYPE_CODE_REF)
+  if (val0->type ()->code () == TYPE_CODE_REF)
     {
       struct value *val = val0;
 
       val = coerce_ref (val);
 
-      if (ada_is_tagged_type (value_type (val), 0))
+      if (ada_is_tagged_type (val->type (), 0))
 	val = ada_tag_value_at_base_address (val);
 
       return ada_to_fixed_value (val);
@@ -7832,7 +7832,7 @@ empty_record (struct type *templ)
    the value of type TYPE at VALADDR or ADDRESS (see comments at
    the beginning of this section) VAL according to GNAT conventions.
    DVAL0 should describe the (portion of a) record that contains any
-   necessary discriminants.  It should be NULL if value_type (VAL) is
+   necessary discriminants.  It should be NULL if VAL->type () is
    an outer-level type (i.e., as opposed to a branch of a variant.)  A
    variant field (unless unchecked) is replaced by a particular branch
    of the variant.
@@ -7915,7 +7915,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 	      dval = value_from_contents_and_address_unresolved (rtype,
 								 valaddr,
 								 address);
-	      rtype = value_type (dval);
+	      rtype = dval->type ();
 	    }
 	  else
 	    dval = dval0;
@@ -8014,7 +8014,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 	     that is currently being constructed.  */
 	  dval = value_from_contents_and_address_unresolved (rtype, valaddr,
 							     address);
-	  rtype = value_type (dval);
+	  rtype = dval->type ();
 	}
       else
 	dval = dval0;
@@ -8175,7 +8175,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
   if (dval0 == NULL)
     {
       dval = value_from_contents_and_address (type, valaddr, address);
-      type = value_type (dval);
+      type = dval->type ();
     }
   else
     dval = dval0;
@@ -8296,7 +8296,7 @@ to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr,
   if (templ_type != NULL)
     var_type = templ_type;
 
-  if (is_unchecked_variant (var_type, value_type (dval)))
+  if (is_unchecked_variant (var_type, dval->type ()))
       return var_type0;
   which = ada_which_variant_applies (var_type, dval);
 
@@ -8587,7 +8587,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
 	      value_from_contents_and_address (fixed_record_type,
 					       valaddr,
 					       address);
-	    fixed_record_type = value_type (obj);
+	    fixed_record_type = obj->type ();
 	    if (real_type != NULL)
 	      return to_fixed_record_type
 		(real_type, NULL,
@@ -8860,7 +8860,7 @@ struct value *
 ada_to_fixed_value (struct value *val)
 {
   val = unwrap_value (val);
-  val = ada_to_fixed_value_create (value_type (val), value_address (val), val);
+  val = ada_to_fixed_value_create (val->type (), value_address (val), val);
   return val;
 }
 
@@ -8902,7 +8902,7 @@ static LONGEST
 pos_atr (struct value *arg)
 {
   struct value *val = coerce_ref (arg);
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
 
   if (!discrete_type_p (type))
     error (_("'POS only defined on discrete types"));
@@ -8951,7 +8951,7 @@ ada_val_atr (enum noside noside, struct type *type, struct value *arg)
 
   if (!discrete_type_p (type))
     error (_("'VAL only defined on discrete types"));
-  if (!integer_type_p (value_type (arg)))
+  if (!integer_type_p (arg->type ()))
     error (_("'VAL requires integral argument"));
 
   return val_atr (type, value_as_long (arg));
@@ -9199,12 +9199,12 @@ ada_enum_name (const char *name)
 static struct value *
 unwrap_value (struct value *val)
 {
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
 
   if (ada_is_aligner_type (type))
     {
       struct value *v = ada_value_struct_elt (val, "F", 0);
-      struct type *val_type = ada_check_typedef (value_type (v));
+      struct type *val_type = ada_check_typedef (v->type ());
 
       if (ada_type_name (val_type) == NULL)
 	val_type->set_name (ada_type_name (type));
@@ -9273,10 +9273,10 @@ ada_promote_array_of_integrals (struct type *type, struct value *val)
      of type's element.  */
   gdb_assert (type->code () == TYPE_CODE_ARRAY);
   gdb_assert (is_integral_type (type->target_type ()));
-  gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);
-  gdb_assert (is_integral_type (value_type (val)->target_type ()));
+  gdb_assert (val->type ()->code () == TYPE_CODE_ARRAY);
+  gdb_assert (is_integral_type (val->type ()->target_type ()));
   gdb_assert (type->target_type ()->length ()
-	      > value_type (val)->target_type ()->length ());
+	      > val->type ()->target_type ()->length ());
 
   if (!get_array_bounds (type, &lo, &hi))
     error (_("unable to determine array bounds"));
@@ -9302,7 +9302,7 @@ ada_promote_array_of_integrals (struct type *type, struct value *val)
 static struct value *
 coerce_for_assign (struct type *type, struct value *val)
 {
-  struct type *type2 = value_type (val);
+  struct type *type2 = val->type ();
 
   if (type == type2)
     return val;
@@ -9314,7 +9314,7 @@ coerce_for_assign (struct type *type, struct value *val)
       && type->code () == TYPE_CODE_ARRAY)
     {
       val = ada_value_ind (val);
-      type2 = value_type (val);
+      type2 = val->type ();
     }
 
   if (type2->code () == TYPE_CODE_ARRAY
@@ -9348,8 +9348,8 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 
   arg1 = coerce_ref (arg1);
   arg2 = coerce_ref (arg2);
-  type1 = get_base_type (ada_check_typedef (value_type (arg1)));
-  type2 = get_base_type (ada_check_typedef (value_type (arg2)));
+  type1 = get_base_type (ada_check_typedef (arg1->type ()));
+  type2 = get_base_type (ada_check_typedef (arg2->type ()));
 
   if (type1->code () != TYPE_CODE_INT
       || type2->code () != TYPE_CODE_INT)
@@ -9405,7 +9405,7 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 
   val = allocate_value (type1);
   store_unsigned_integer (value_contents_raw (val).data (),
-			  value_type (val)->length (),
+			  val->type ()->length (),
 			  type_byte_order (type1), v);
   return val;
 }
@@ -9413,8 +9413,8 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 static int
 ada_value_equal (struct value *arg1, struct value *arg2)
 {
-  if (ada_is_direct_array_type (value_type (arg1))
-      || ada_is_direct_array_type (value_type (arg2)))
+  if (ada_is_direct_array_type (arg1->type ())
+      || ada_is_direct_array_type (arg2->type ()))
     {
       struct type *arg1_type, *arg2_type;
 
@@ -9426,8 +9426,8 @@ ada_value_equal (struct value *arg1, struct value *arg2)
       arg1 = ada_coerce_to_simple_array (arg1);
       arg2 = ada_coerce_to_simple_array (arg2);
 
-      arg1_type = ada_check_typedef (value_type (arg1));
-      arg2_type = ada_check_typedef (value_type (arg2));
+      arg1_type = ada_check_typedef (arg1->type ());
+      arg2_type = ada_check_typedef (arg2->type ());
 
       if (arg1_type->code () != TYPE_CODE_ARRAY
 	  || arg2_type->code () != TYPE_CODE_ARRAY)
@@ -9465,7 +9465,7 @@ assign_component (struct value *container, struct value *lhs, LONGEST index,
   scoped_value_mark mark;
 
   struct value *elt;
-  struct type *lhs_type = check_typedef (value_type (lhs));
+  struct type *lhs_type = check_typedef (lhs->type ());
 
   if (lhs_type->code () == TYPE_CODE_ARRAY)
     {
@@ -9476,7 +9476,7 @@ assign_component (struct value *container, struct value *lhs, LONGEST index,
     }
   else
     {
-      elt = ada_index_struct_field (index, lhs, 0, value_type (lhs));
+      elt = ada_index_struct_field (index, lhs, 0, lhs->type ());
       elt = ada_to_fixed_value (elt);
     }
 
@@ -9528,17 +9528,17 @@ ada_aggregate_operation::assign_aggregate (struct value *container,
   LONGEST low_index, high_index;
 
   container = ada_coerce_ref (container);
-  if (ada_is_direct_array_type (value_type (container)))
+  if (ada_is_direct_array_type (container->type ()))
     container = ada_coerce_to_simple_array (container);
   lhs = ada_coerce_ref (lhs);
   if (!deprecated_value_modifiable (lhs))
     error (_("Left operand of assignment is not a modifiable lvalue."));
 
-  lhs_type = check_typedef (value_type (lhs));
+  lhs_type = check_typedef (lhs->type ());
   if (ada_is_direct_array_type (lhs_type))
     {
       lhs = ada_coerce_to_simple_array (lhs);
-      lhs_type = check_typedef (value_type (lhs));
+      lhs_type = check_typedef (lhs->type ());
       low_index = lhs_type->bounds ()->low.const_val ();
       high_index = lhs_type->bounds ()->high.const_val ();
     }
@@ -9654,7 +9654,7 @@ ada_name_association::assign (struct value *container,
 {
   int index;
 
-  if (ada_is_direct_array_type (value_type (lhs)))
+  if (ada_is_direct_array_type (lhs->type ()))
     index = longest_to_int (value_as_long (m_val->evaluate (nullptr, exp,
 							    EVAL_NORMAL)));
   else
@@ -9675,7 +9675,7 @@ ada_name_association::assign (struct value *container,
 	}
 
       index = 0;
-      if (! find_struct_field (name, value_type (lhs), 0,
+      if (! find_struct_field (name, lhs->type (), 0,
 			       NULL, NULL, NULL, NULL, &index))
 	error (_("Unknown component name: %s."), name);
     }
@@ -9770,7 +9770,7 @@ ada_assign_operation::evaluate (struct type *expect_type,
      except if the lhs of our assignment is a convenience variable.
      In the case of assigning to a convenience variable, the lhs
      should be exactly the result of the evaluation of the rhs.  */
-  struct type *type = value_type (arg1);
+  struct type *type = arg1->type ();
   if (VALUE_LVAL (arg1) == lval_internalvar)
     type = NULL;
   value *arg2 = std::get<1> (m_storage)->evaluate (type, exp, noside);
@@ -9781,7 +9781,7 @@ ada_assign_operation::evaluate (struct type *expect_type,
       /* Nothing.  */
     }
   else
-    arg2 = coerce_for_assign (value_type (arg1), arg2);
+    arg2 = coerce_for_assign (arg1->type (), arg2);
   return ada_value_assign (arg1, arg2);
 }
 
@@ -9831,7 +9831,7 @@ add_component_interval (LONGEST low, LONGEST high,
 static struct value *
 ada_value_cast (struct type *type, struct value *arg2)
 {
-  if (type == ada_check_typedef (value_type (arg2)))
+  if (type == ada_check_typedef (arg2->type ()))
     return arg2;
 
   return value_cast (type, arg2);
@@ -10177,7 +10177,7 @@ ada_atr_size (struct type *expect_type,
 	      enum noside noside, enum exp_opcode op,
 	      struct value *arg1)
 {
-  struct type *type = value_type (arg1);
+  struct type *type = arg1->type ();
 
   /* If the argument is a reference, then dereference its type, since
      the user is really asking for the size of the actual object,
@@ -10201,7 +10201,7 @@ ada_abs (struct type *expect_type,
 	 struct value *arg1)
 {
   unop_promote (exp->language_defn, exp->gdbarch, &arg1);
-  if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
+  if (value_less (arg1, value_zero (arg1->type (), not_lval)))
     return value_neg (arg1);
   else
     return arg1;
@@ -10218,7 +10218,7 @@ ada_mult_binop (struct type *expect_type,
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
       binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
-      return value_zero (value_type (arg1), not_lval);
+      return value_zero (arg1->type (), not_lval);
     }
   else
     {
@@ -10267,24 +10267,24 @@ 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 (value_type (array)->target_type ()))
-    value_type (array)->set_target_type
-      (ada_aligned_type (value_type (array)->target_type ()));
+  if (array->type ()->code () == TYPE_CODE_REF
+      && ada_is_aligner_type (array->type ()->target_type ()))
+    array->type ()->set_target_type
+      (ada_aligned_type (array->type ()->target_type ()));
 
-  if (ada_is_any_packed_array_type (value_type (array)))
+  if (ada_is_any_packed_array_type (array->type ()))
     error (_("cannot slice a packed array"));
 
   /* If this is a reference to an array or an array lvalue,
      convert to a pointer.  */
-  if (value_type (array)->code () == TYPE_CODE_REF
-      || (value_type (array)->code () == TYPE_CODE_ARRAY
+  if (array->type ()->code () == TYPE_CODE_REF
+      || (array->type ()->code () == TYPE_CODE_ARRAY
 	  && VALUE_LVAL (array) == lval_memory))
     array = value_addr (array);
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS
       && ada_is_array_descriptor_type (ada_check_typedef
-				       (value_type (array))))
+				       (array->type ())))
     return empty_array (ada_type_of_array (array, 0), low_bound,
 			high_bound);
 
@@ -10292,8 +10292,8 @@ 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
-	 && (value_type (array)->target_type ()->code ()
+  while (array->type ()->code () == TYPE_CODE_PTR
+	 && (array->type ()->target_type ()->code ()
 	     == TYPE_CODE_PTR))
     array = value_ind (array);
 
@@ -10301,13 +10301,13 @@ ada_ternop_slice (struct expression *exp,
      to avoid a SEGV when trying to get the index type or the target
      type later down the road if the debug info generated by
      the compiler is incorrect or incomplete.  */
-  if (!ada_is_simple_array_type (value_type (array)))
+  if (!ada_is_simple_array_type (array->type ()))
     error (_("cannot take slice of non-array"));
 
-  if (ada_check_typedef (value_type (array))->code ()
+  if (ada_check_typedef (array->type ())->code ()
       == TYPE_CODE_PTR)
     {
-      struct type *type0 = ada_check_typedef (value_type (array));
+      struct type *type0 = ada_check_typedef (array->type ());
 
       if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)
 	return empty_array (type0->target_type (), low_bound, high_bound);
@@ -10324,7 +10324,7 @@ ada_ternop_slice (struct expression *exp,
   else if (noside == EVAL_AVOID_SIDE_EFFECTS)
     return array;
   else if (high_bound < low_bound)
-    return empty_array (value_type (array), low_bound, high_bound);
+    return empty_array (array->type (), low_bound, high_bound);
   else
     return ada_value_slice (array, longest_to_int (low_bound),
 			    longest_to_int (high_bound));
@@ -10343,9 +10343,9 @@ ada_binop_in_bounds (struct expression *exp, enum noside noside,
       return value_zero (type, not_lval);
     }
 
-  struct type *type = ada_index_type (value_type (arg2), n, "range");
+  struct type *type = ada_index_type (arg2->type (), n, "range");
   if (!type)
-    type = value_type (arg1);
+    type = arg1->type ();
 
   value *arg3 = value_from_longest (type, ada_array_bound (arg2, n, 1));
   arg2 = value_from_longest (type, ada_array_bound (arg2, n, 0));
@@ -10369,7 +10369,7 @@ ada_unop_atr (struct expression *exp, enum noside noside, enum exp_opcode op,
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
       if (type_arg == NULL)
-	type_arg = value_type (arg1);
+	type_arg = arg1->type ();
 
       if (ada_is_constrained_packed_array_type (type_arg))
 	type_arg = decode_constrained_packed_array_type (type_arg);
@@ -10397,7 +10397,7 @@ ada_unop_atr (struct expression *exp, enum noside noside, enum exp_opcode op,
     {
       arg1 = ada_coerce_ref (arg1);
 
-      if (ada_is_constrained_packed_array_type (value_type (arg1)))
+      if (ada_is_constrained_packed_array_type (arg1->type ()))
 	arg1 = ada_coerce_to_simple_array (arg1);
 
       struct type *type;
@@ -10405,7 +10405,7 @@ ada_unop_atr (struct expression *exp, enum noside noside, enum exp_opcode op,
 	type = builtin_type (exp->gdbarch)->builtin_int;
       else
 	{
-	  type = ada_index_type (value_type (arg1), tem,
+	  type = ada_index_type (arg1->type (), tem,
 				 ada_attribute_name (op));
 	  if (type == NULL)
 	    type = builtin_type (exp->gdbarch)->builtin_int;
@@ -10496,7 +10496,7 @@ ada_binop_minmax (struct type *expect_type,
 		  struct value *arg1, struct value *arg2)
 {
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    return value_zero (value_type (arg1), not_lval);
+    return value_zero (arg1->type (), not_lval);
   else
     {
       binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
@@ -10513,12 +10513,12 @@ ada_binop_exp (struct type *expect_type,
 	       struct value *arg1, struct value *arg2)
 {
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    return value_zero (value_type (arg1), not_lval);
+    return value_zero (arg1->type (), not_lval);
   else
     {
       /* For integer exponentiation operations,
 	 only promote the first argument.  */
-      if (is_integral_type (value_type (arg2)))
+      if (is_integral_type (arg2->type ()))
 	unop_promote (exp->language_defn, exp->gdbarch, &arg1);
       else
 	binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
@@ -10723,12 +10723,12 @@ ada_concat_operation::evaluate (struct type *expect_type,
   if (dynamic_cast<ada_string_operation *> (lhs_expr.get ()) != nullptr)
     {
       rhs = rhs_expr->evaluate (nullptr, exp, noside);
-      lhs = lhs_expr->evaluate (value_type (rhs), exp, noside);
+      lhs = lhs_expr->evaluate (rhs->type (), exp, noside);
     }
   else if (dynamic_cast<ada_char_operation *> (lhs_expr.get ()) != nullptr)
     {
       rhs = rhs_expr->evaluate (nullptr, exp, noside);
-      struct type *rhs_type = check_typedef (value_type (rhs));
+      struct type *rhs_type = check_typedef (rhs->type ());
       struct type *elt_type = nullptr;
       if (rhs_type->code () == TYPE_CODE_ARRAY)
 	elt_type = rhs_type->target_type ();
@@ -10737,12 +10737,12 @@ ada_concat_operation::evaluate (struct type *expect_type,
   else if (dynamic_cast<ada_string_operation *> (rhs_expr.get ()) != nullptr)
     {
       lhs = lhs_expr->evaluate (nullptr, exp, noside);
-      rhs = rhs_expr->evaluate (value_type (lhs), exp, noside);
+      rhs = rhs_expr->evaluate (lhs->type (), exp, noside);
     }
   else if (dynamic_cast<ada_char_operation *> (rhs_expr.get ()) != nullptr)
     {
       lhs = lhs_expr->evaluate (nullptr, exp, noside);
-      struct type *lhs_type = check_typedef (value_type (lhs));
+      struct type *lhs_type = check_typedef (lhs->type ());
       struct type *elt_type = nullptr;
       if (lhs_type->code () == TYPE_CODE_ARRAY)
 	elt_type = lhs_type->target_type ();
@@ -10789,18 +10789,18 @@ ada_binop_addsub_operation::evaluate (struct type *expect_type,
       return x - y;
     };
 
-  if (value_type (arg1)->code () == TYPE_CODE_PTR)
+  if (arg1->type ()->code () == TYPE_CODE_PTR)
     return (value_from_longest
-	    (value_type (arg1),
+	    (arg1->type (),
 	     do_op (value_as_long (arg1), value_as_long (arg2))));
-  if (value_type (arg2)->code () == TYPE_CODE_PTR)
+  if (arg2->type ()->code () == TYPE_CODE_PTR)
     return (value_from_longest
-	    (value_type (arg2),
+	    (arg2->type (),
 	     do_op (value_as_long (arg1), value_as_long (arg2))));
   /* Preserve the original type for use by the range case below.
      We cannot cast the result to a reference type, so if ARG1 is
      a reference type, find its underlying type.  */
-  struct type *type = value_type (arg1);
+  struct type *type = arg1->type ();
   while (type->code () == TYPE_CODE_REF)
     type = type->target_type ();
   binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
@@ -10826,7 +10826,7 @@ ada_unop_atr_operation::evaluate (struct type *expect_type,
     {
       value *tem = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						      EVAL_AVOID_SIDE_EFFECTS);
-      type_arg = value_type (tem);
+      type_arg = tem->type ();
     }
   else
     val = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
@@ -11011,7 +11011,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 {
   value *arg1 = std::get<0> (m_storage)->evaluate (expect_type, exp, noside);
 
-  struct type *type = ada_check_typedef (value_type (arg1));
+  struct type *type = ada_check_typedef (arg1->type ());
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
       if (ada_is_array_descriptor_type (type))
@@ -11039,7 +11039,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 	    {
 	      arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp,
 							EVAL_NORMAL);
-	      type = value_type (ada_value_ind (arg1));
+	      type = ada_value_ind (arg1)->type ();
 	    }
 	  else
 	    {
@@ -11066,7 +11066,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 	error (_("Attempt to take contents of a non-pointer value."));
     }
   arg1 = ada_coerce_ref (arg1);     /* FIXME: What is this for??  */
-  type = ada_check_typedef (value_type (arg1));
+  type = ada_check_typedef (arg1->type ());
 
   if (type->code () == TYPE_CODE_INT)
     /* GDB allows dereferencing an int.  If we were given
@@ -11098,7 +11098,7 @@ ada_structop_operation::evaluate (struct type *expect_type,
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
       struct type *type;
-      struct type *type1 = value_type (arg1);
+      struct type *type1 = arg1->type ();
 
       if (ada_is_tagged_type (type1, 1))
 	{
@@ -11114,7 +11114,7 @@ ada_structop_operation::evaluate (struct type *expect_type,
 							EVAL_NORMAL);
 	      arg1 = ada_value_struct_elt (arg1, str, 0);
 	      arg1 = unwrap_value (arg1);
-	      type = value_type (ada_to_fixed_value (arg1));
+	      type = ada_to_fixed_value (arg1)->type ();
 	    }
 	}
       else
@@ -11152,15 +11152,15 @@ ada_funcall_operation::evaluate (struct type *expect_type,
     argvec[i] = args_up[i]->evaluate (nullptr, exp, noside);
 
   if (ada_is_constrained_packed_array_type
-      (desc_base_type (value_type (callee))))
+      (desc_base_type (callee->type ())))
     callee = ada_coerce_to_simple_array (callee);
-  else if (value_type (callee)->code () == TYPE_CODE_ARRAY
-	   && TYPE_FIELD_BITSIZE (value_type (callee), 0) != 0)
+  else if (callee->type ()->code () == TYPE_CODE_ARRAY
+	   && TYPE_FIELD_BITSIZE (callee->type (), 0) != 0)
     /* This is a packed array that has already been fixed, and
        therefore already coerced to a simple array.  Nothing further
        to do.  */
     ;
-  else if (value_type (callee)->code () == TYPE_CODE_REF)
+  else if (callee->type ()->code () == TYPE_CODE_REF)
     {
       /* Make sure we dereference references so that all the code below
 	 feels like it's really handling the referenced value.  Wrapping
@@ -11168,11 +11168,11 @@ ada_funcall_operation::evaluate (struct type *expect_type,
 	 well.  */
       callee = ada_to_fixed_value (coerce_ref (callee));
     }
-  else if (value_type (callee)->code () == TYPE_CODE_ARRAY
+  else if (callee->type ()->code () == TYPE_CODE_ARRAY
 	   && VALUE_LVAL (callee) == lval_memory)
     callee = value_addr (callee);
 
-  struct type *type = ada_check_typedef (value_type (callee));
+  struct type *type = ada_check_typedef (callee->type ());
 
   /* Ada allows us to implicitly dereference arrays when subscripting
      them.  So, if this is an array typedef (encoding use for array
@@ -11196,7 +11196,7 @@ ada_funcall_operation::evaluate (struct type *expect_type,
 	  break;
 	default:
 	  error (_("cannot subscript or call something of type `%s'"),
-		 ada_type_name (value_type (callee)));
+		 ada_type_name (callee->type ()));
 	  break;
 	}
     }
@@ -11320,7 +11320,7 @@ ada_ternop_slice_operation::resolve (struct expression *exp,
      continue that here.  */
   value *v = std::get<0> (m_storage)->evaluate (context_type, exp,
 						EVAL_AVOID_SIDE_EFFECTS);
-  if (ada_is_any_packed_array_type (value_type (v)))
+  if (ada_is_any_packed_array_type (v->type ()))
     error (_("cannot slice a packed array"));
   return false;
 }
@@ -11375,7 +11375,7 @@ scan_discrim_bound (const char *str, int k, struct value *dval, LONGEST * px,
       k = pend - str;
     }
 
-  bound_val = ada_search_struct_field (bound, dval, 0, value_type (dval));
+  bound_val = ada_search_struct_field (bound, dval, 0, dval->type ());
   if (bound_val == NULL)
     return 0;
 
@@ -12025,7 +12025,7 @@ ada_exception_message_1 (void)
 
   e_msg_val = ada_coerce_to_simple_array (e_msg_val);
   gdb_assert (e_msg_val != NULL);
-  e_msg_len = value_type (e_msg_val)->length ();
+  e_msg_len = e_msg_val->type ()->length ();
 
   /* If the message string is empty, then treat it as if there was
      no exception message.  */
diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index a3a28063daa..979d64a54ad 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -457,7 +457,7 @@ read_fat_string_value (char *dest, struct value *val, int max_len)
      to extract the string from the fat string.  */
   if (initialize_fieldnos)
     {
-      struct type *type = value_type (val);
+      struct type *type = val->type ();
       struct type *bounds_type;
 
       array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
@@ -784,7 +784,7 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
 	value_subscript (entry_calls_value,
 			 value_as_long (atc_nesting_level_value));
       called_task_fieldno =
-	ada_get_field_index (value_type (entry_calls_value_element),
+	ada_get_field_index (entry_calls_value_element->type (),
 			     "called_task", 0);
       task_info->called_task =
 	value_as_address (value_field (entry_calls_value_element,
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 10d3b0a41bf..1f22ab61ce2 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -196,12 +196,12 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
 					       (i * bitsize) / HOST_CHAR_BIT,
 					       (i * bitsize) % HOST_CHAR_BIT,
 					       bitsize, elttype);
-	  if (check_typedef (value_type (v0))->length ()
-	      != check_typedef (value_type (v1))->length ())
+	  if (check_typedef (v0->type ())->length ()
+	      != check_typedef (v1->type ())->length ())
 	    break;
 	  if (!value_contents_eq (v0, value_embedded_offset (v0),
 				  v1, value_embedded_offset (v1),
-				  check_typedef (value_type (v0))->length ()))
+				  check_typedef (v0->type ())->length ()))
 	    break;
 	}
 
@@ -552,7 +552,7 @@ print_variant_part (struct value *value, int field_num,
 		    int comma_needed,
 		    const struct language_defn *language)
 {
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   struct type *var_type = type->field (field_num).type ();
   int which = ada_which_variant_applies (var_type, outer_value);
 
@@ -588,7 +588,7 @@ print_field_values (struct value *value, struct value *outer_value,
 {
   int i, len;
 
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   len = type->num_fields ();
 
   for (i = 0; i < len; i += 1)
@@ -732,8 +732,8 @@ ada_value_print_ptr (struct value *val,
 		     const struct value_print_options *options)
 {
   if (!options->format
-      && value_type (val)->target_type ()->code () == TYPE_CODE_INT
-      && value_type (val)->target_type ()->length () == 0)
+      && val->type ()->target_type ()->code () == TYPE_CODE_INT
+      && val->type ()->target_type ()->length () == 0)
     {
       gdb_puts ("null", stream);
       return;
@@ -741,7 +741,7 @@ ada_value_print_ptr (struct value *val,
 
   common_val_print (val, stream, recurse, options, language_def (language_c));
 
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
   if (ada_is_tag_type (type))
     {
       gdb::unique_xmalloc_ptr<char> name = ada_tag_name (val);
@@ -758,7 +758,7 @@ static void
 ada_value_print_num (struct value *val, struct ui_file *stream, int recurse,
 		     const struct value_print_options *options)
 {
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
 
   if (type->code () == TYPE_CODE_RANGE
@@ -838,7 +838,7 @@ ada_val_print_enum (struct value *value, struct ui_file *stream, int recurse,
       return;
     }
 
-  struct type *type = ada_check_typedef (value_type (value));
+  struct type *type = ada_check_typedef (value->type ());
   const gdb_byte *valaddr = value_contents_for_printing (value).data ();
   int offset_aligned = ada_aligned_value_addr (type, valaddr) - valaddr;
 
@@ -875,7 +875,7 @@ ada_val_print_struct_union (struct value *value,
 			    int recurse,
 			    const struct value_print_options *options)
 {
-  if (ada_is_bogus_array_descriptor (value_type (value)))
+  if (ada_is_bogus_array_descriptor (value->type ()))
     {
       gdb_printf (stream, "(...?)");
       return;
@@ -901,7 +901,7 @@ static void
 ada_value_print_array (struct value *val, struct ui_file *stream, int recurse,
 		       const struct value_print_options *options)
 {
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
 
   /* For an array of characters, print with string syntax.  */
   if (ada_is_string_type (type)
@@ -961,7 +961,7 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
   deref_val = coerce_ref_if_computed (original_value);
   if (deref_val)
     {
-      if (ada_is_tagged_type (value_type (deref_val), 1))
+      if (ada_is_tagged_type (deref_val->type (), 1))
 	deref_val = ada_tag_value_at_base_address (deref_val);
 
       common_val_print (deref_val, stream, recurse + 1, options,
@@ -979,7 +979,7 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
   deref_val
     = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype),
 					 deref_val_int));
-  if (ada_is_tagged_type (value_type (deref_val), 1))
+  if (ada_is_tagged_type (deref_val->type (), 1))
     deref_val = ada_tag_value_at_base_address (deref_val);
 
   if (value_lazy (deref_val))
@@ -997,7 +997,7 @@ void
 ada_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
 		       const struct value_print_options *options)
 {
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
 
   if (ada_is_array_descriptor_type (type)
       || (ada_is_constrained_packed_array_type (type)
@@ -1018,7 +1018,7 @@ ada_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
   else
     val = ada_to_fixed_value (val);
 
-  type = value_type (val);
+  type = val->type ();
   struct type *saved_type = type;
 
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
@@ -1088,7 +1088,7 @@ ada_value_print (struct value *val0, struct ui_file *stream,
 		 const struct value_print_options *options)
 {
   struct value *val = ada_to_fixed_value (val0);
-  struct type *type = ada_check_typedef (value_type (val));
+  struct type *type = ada_check_typedef (val->type ());
   struct value_print_options opts;
 
   /* If it is a pointer, indicate what it points to; but not for
diff --git a/gdb/ada-varobj.c b/gdb/ada-varobj.c
index 6b92b76f092..63e851e7ae5 100644
--- a/gdb/ada-varobj.c
+++ b/gdb/ada-varobj.c
@@ -66,7 +66,7 @@ ada_varobj_decode_var (struct value **value_ptr, struct type **type_ptr)
     *value_ptr = ada_get_decoded_value (*value_ptr);
 
   if (*value_ptr != nullptr)
-    *type_ptr = ada_check_typedef (value_type (*value_ptr));
+    *type_ptr = ada_check_typedef ((*value_ptr)->type ());
   else
     *type_ptr = ada_get_decoded_type (*type_ptr);
 }
@@ -102,7 +102,7 @@ ada_varobj_struct_elt (struct value *parent_value,
   if (parent_value)
     {
       value = value_field (parent_value, fieldno);
-      type = value_type (value);
+      type = value->type ();
     }
   else
     type = parent_type->field (fieldno).type ();
@@ -150,7 +150,7 @@ ada_varobj_ind (struct value *parent_value,
   if (parent_value)
     {
       value = ada_value_ind (parent_value);
-      type = value_type (value);
+      type = value->type ();
     }
   else
     type = parent_type->target_type ();
@@ -181,7 +181,7 @@ ada_varobj_simple_array_elt (struct value *parent_value,
 	value_from_longest (parent_type->index_type (), elt_index);
 
       value = ada_value_subscript (parent_value, 1, &index_value);
-      type = value_type (value);
+      type = value->type ();
     }
   else
     type = parent_type->target_type ();
@@ -221,7 +221,7 @@ ada_varobj_adjust_for_child_access (struct value **value,
   if (*value != NULL && ada_is_tagged_type (*type, 1))
     {
       *value = ada_tag_value_at_base_address (*value);
-      *type = value_type (*value);
+      *type = (*value)->type ();
     }
 }
 
@@ -943,7 +943,7 @@ static bool
 ada_value_is_changeable_p (const struct varobj *var)
 {
   struct type *type = (var->value != nullptr
-		       ? value_type (var->value.get ()) : var->type);
+		       ? var->value.get ()->type () : var->type);
 
   if (type->code () == TYPE_CODE_REF)
     type = type->target_type ();
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 14f5a0492d3..5edde7abcae 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -319,7 +319,7 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
     {
       struct value *arg = args[i];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
 
       /* Cast argument to long if necessary as the compiler does it too.  */
       switch (arg_type->code ())
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 328e001f5bb..5e098b1ce79 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -376,7 +376,7 @@ amd64_pseudo_register_read_value (struct gdbarch *gdbarch,
 	    memcpy (buf, raw_buf + 1, 1);
 	  else
 	    mark_value_bytes_unavailable (result_value, 0,
-					  value_type (result_value)->length ());
+					  result_value->type ()->length ());
 	}
       else
 	{
@@ -386,7 +386,7 @@ amd64_pseudo_register_read_value (struct gdbarch *gdbarch,
 	    memcpy (buf, raw_buf, 1);
 	  else
 	    mark_value_bytes_unavailable (result_value, 0,
-					  value_type (result_value)->length ());
+					  result_value->type ()->length ());
 	}
     }
   else if (i386_dword_regnum_p (gdbarch, regnum))
@@ -399,7 +399,7 @@ amd64_pseudo_register_read_value (struct gdbarch *gdbarch,
 	memcpy (buf, raw_buf, 4);
       else
 	mark_value_bytes_unavailable (result_value, 0,
-				      value_type (result_value)->length ());
+				      result_value->type ()->length ());
     }
   else
     i386_pseudo_register_read_into_value (gdbarch, regcache, regnum,
@@ -962,7 +962,7 @@ if (return_method == return_method_struct)
 
   for (i = 0; i < nargs; i++)
     {
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int len = type->length ();
       enum amd64_reg_class theclass[2];
       int needed_integer_regs = 0;
@@ -1046,7 +1046,7 @@ if (return_method == return_method_struct)
   /* Write out the arguments to the stack.  */
   for (i = 0; i < num_stack_args; i++)
     {
-      struct type *type = value_type (stack_args[i]);
+      struct type *type = stack_args[i]->type ();
       const gdb_byte *valbuf = value_contents (stack_args[i]).data ();
       int len = type->length ();
 
diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index 411a6204a90..5c779cbb118 100644
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -176,9 +176,9 @@ amd64_windows_adjust_args_passed_by_pointer (struct value **args,
   int i;
 
   for (i = 0; i < nargs; i++)
-    if (amd64_windows_passed_by_pointer (value_type (args[i])))
+    if (amd64_windows_passed_by_pointer (args[i]->type ()))
       {
-	struct type *type = value_type (args[i]);
+	struct type *type = args[i]->type ();
 	const gdb_byte *valbuf = value_contents (args[i]).data ();
 	const int len = type->length ();
 
@@ -204,7 +204,7 @@ static void
 amd64_windows_store_arg_in_reg (struct regcache *regcache,
 				struct value *arg, int regno)
 {
-  struct type *type = value_type (arg);
+  struct type *type = arg->type ();
   const gdb_byte *valbuf = value_contents (arg).data ();
   gdb_byte buf[8];
 
@@ -251,7 +251,7 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs,
 
   for (i = 0; i < nargs; i++)
     {
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int len = type->length ();
       int on_stack_p = 1;
 
@@ -294,7 +294,7 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs,
   /* Write out the arguments to the stack.  */
   for (i = 0; i < num_stack_args; i++)
     {
-      struct type *type = value_type (stack_args[i]);
+      struct type *type = stack_args[i]->type ();
       const gdb_byte *valbuf = value_contents (stack_args[i]).data ();
 
       write_memory (sp + element * 8, valbuf, type->length ());
diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
index c232eb98432..f42abc2ec42 100644
--- a/gdb/arc-tdep.c
+++ b/gdb/arc-tdep.c
@@ -761,7 +761,7 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	 argument's size up to an integral number of words.  */
       for (int i = 0; i < nargs; i++)
 	{
-	  unsigned int len = value_type (args[i])->length ();
+	  unsigned int len = args[i]->type ()->length ();
 	  unsigned int space = align_up (len, 4);
 
 	  total_space += space;
@@ -776,7 +776,7 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       gdb_byte *data = memory_image;
       for (int i = 0; i < nargs; i++)
 	{
-	  unsigned int len = value_type (args[i])->length ();
+	  unsigned int len = args[i]->type ()->length ();
 	  unsigned int space = align_up (len, 4);
 
 	  memcpy (data, value_contents (args[i]).data (), (size_t) len);
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 347f3e6b307..a21f7120ab4 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -4635,7 +4635,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Determine the type of this function and whether the VFP ABI
      applies.  */
-  ftype = check_typedef (value_type (function));
+  ftype = check_typedef (function->type ());
   if (ftype->code () == TYPE_CODE_PTR)
     ftype = check_typedef (ftype->target_type ());
   use_vfp_abi = arm_vfp_abi_for_function (gdbarch, ftype);
@@ -4678,7 +4678,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       int vfp_base_count;
       int may_use_core_reg = 1;
 
-      arg_type = check_typedef (value_type (args[argnum]));
+      arg_type = check_typedef (args[argnum]->type ());
       len = arg_type->length ();
       target_type = arg_type->target_type ();
       typecode = arg_type->code ();
@@ -9178,7 +9178,7 @@ arm_return_value (struct gdbarch *gdbarch, struct value *function,
 		  struct value **read_value, const gdb_byte *writebuf)
 {
   arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
-  struct type *func_type = function ? value_type (function) : NULL;
+  struct type *func_type = function ? function->type () : NULL;
   enum arm_vfp_cprc_base_type vfp_base_type;
   int vfp_base_count;
 
diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index fa76a3d24da..023ebc37efb 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -1298,7 +1298,7 @@ avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       int last_regnum;
       int j;
       struct value *arg = args[i];
-      struct type *type = check_typedef (value_type (arg));
+      struct type *type = check_typedef (arg->type ());
       const bfd_byte *contents = value_contents (arg).data ();
       int len = type->length ();
 
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index fc214e7dfe1..3cfe99718a5 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1585,7 +1585,7 @@ operation::generate_ax (struct expression *exp,
       struct value *v = evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS);
       ax_const_l (ax, value_as_long (v));
       value->kind = axs_rvalue;
-      value->type = check_typedef (value_type (v));
+      value->type = check_typedef (v->type ());
     }
   else
     {
@@ -1745,7 +1745,7 @@ repeat_operation::do_generate_ax (struct expression *exp,
   struct value *v
     = std::get<1> (m_storage)->evaluate (nullptr, exp,
 					 EVAL_AVOID_SIDE_EFFECTS);
-  if (value_type (v)->code () != TYPE_CODE_INT)
+  if (v->type ()->code () != TYPE_CODE_INT)
     error (_("Right operand of `@' must be an integer."));
   int length = value_as_long (v);
   if (length <= 0)
@@ -1862,7 +1862,7 @@ unop_memval_type_operation::do_generate_ax (struct expression *exp,
   struct value *val
     = std::get<0> (m_storage)->evaluate (nullptr, exp,
 					 EVAL_AVOID_SIDE_EFFECTS);
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
 
   std::get<1> (m_storage)->generate_ax (exp, ax, value);
 
@@ -1980,7 +1980,7 @@ unop_cast_type_operation::do_generate_ax (struct expression *exp,
   struct value *val
     = std::get<0> (m_storage)->evaluate (nullptr, exp,
 					 EVAL_AVOID_SIDE_EFFECTS);
-  std::get<1> (m_storage)->generate_ax (exp, ax, value, value_type (val));
+  std::get<1> (m_storage)->generate_ax (exp, ax, value, val->type ());
 }
 
 void
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 1c7ae58a23b..3c099d185f3 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1856,7 +1856,7 @@ extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
   if (val == NULL)
     return NULL;
 
-  bit_val = allocate_value (value_type (val));
+  bit_val = allocate_value (val->type ());
 
   unpack_value_bitfield (bit_val,
 			 w->val_bitpos,
@@ -2070,7 +2070,7 @@ update_watchpoint (struct watchpoint *b, bool reparse)
 	  if (VALUE_LVAL (v) == lval_memory
 	      && (v == val_chain[0] || ! value_lazy (v)))
 	    {
-	      struct type *vtype = check_typedef (value_type (v));
+	      struct type *vtype = check_typedef (v->type ());
 
 	      /* We only watch structs and arrays if user asked
 		 for it explicitly, never if they just happen to
@@ -2117,7 +2117,7 @@ update_watchpoint (struct watchpoint *b, bool reparse)
 		  for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
 		    ;
 		  *tmp = loc;
-		  loc->gdbarch = value_type (v)->arch ();
+		  loc->gdbarch = v->type ()->arch ();
 
 		  loc->pspace = frame_pspace;
 		  loc->address
@@ -2129,7 +2129,7 @@ update_watchpoint (struct watchpoint *b, bool reparse)
 		      loc->length = ((bitpos % 8) + bitsize + 7) / 8;
 		    }
 		  else
-		    loc->length = value_type (v)->length ();
+		    loc->length = v->type ()->length ();
 
 		  loc->watchpoint_type = type;
 		}
@@ -10286,7 +10286,7 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   w->cond_exp_valid_block = cond_exp_valid_block;
   if (just_location)
     {
-      struct type *t = value_type (val.get ());
+      struct type *t = val.get ()->type ();
       CORE_ADDR addr = value_as_address (val.get ());
 
       w->exp_string_reparse
@@ -10395,7 +10395,7 @@ can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
 	    {
 	      /* Ahh, memory we actually used!  Check if we can cover
 		 it with hardware watchpoints.  */
-	      struct type *vtype = check_typedef (value_type (v));
+	      struct type *vtype = check_typedef (v->type ());
 
 	      /* We only watch structs and arrays if user asked for it
 		 explicitly, never if they just happen to appear in a
@@ -10410,7 +10410,7 @@ can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
 
 		  len = (target_exact_watchpoints
 			 && is_scalar_type_recursive (vtype))?
-		    1 : value_type (v)->length ();
+		    1 : v->type ()->length ();
 
 		  num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
 		  if (!num_regs)
diff --git a/gdb/c-exp.h b/gdb/c-exp.h
index 20eeaca9a89..51e2d26eb2e 100644
--- a/gdb/c-exp.h
+++ b/gdb/c-exp.h
@@ -138,7 +138,7 @@ class opencl_binop_operation
     value *lhs
       = std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
     value *rhs
-      = std::get<1> (this->m_storage)->evaluate (value_type (lhs), exp,
+      = std::get<1> (this->m_storage)->evaluate (lhs->type (), exp,
 						 noside);
     return FUNC (expect_type, exp, noside, OP, lhs, rhs);
   }
diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index a6d912a7be7..c2c763154c7 100644
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -245,7 +245,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 *type = check_typedef (value->type ());
   struct type *element_type = type->target_type ();
   int req_length = *length;
   enum bfd_endian byte_order
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 69aa91d1ec3..8d28c45cbfc 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -235,7 +235,7 @@ c_value_print_array (struct value *val,
 		     struct ui_file *stream, int recurse,
 		     const struct value_print_options *options)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   CORE_ADDR address = value_address (val);
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
   struct type *unresolved_elttype = type->target_type ();
@@ -333,7 +333,7 @@ c_value_print_ptr (struct value *val, struct ui_file *stream, int recurse,
       return;
     }
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
 
   if (options->vtblprint && cp_is_vtbl_ptr_type (type))
@@ -363,7 +363,7 @@ static void
 c_value_print_struct (struct value *val, struct ui_file *stream, int recurse,
 		      const struct value_print_options *options)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   if (type->code () == TYPE_CODE_UNION && recurse && !options->unionprint)
     gdb_printf (stream, "{...}");
@@ -405,7 +405,7 @@ c_value_print_int (struct value *val, struct ui_file *stream,
 	 instead.  Since we don't know whether the value is really
 	 intended to be used as an integer or a character, print
 	 the character equivalent as well.  */
-      struct type *type = value_type (val);
+      struct type *type = val->type ();
       const gdb_byte *valaddr = value_contents_for_printing (val).data ();
       if (c_textual_element_type (type, options->format))
 	{
@@ -422,7 +422,7 @@ void
 c_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
 		     const struct value_print_options *options)
 {
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
 
   type = check_typedef (type);
   switch (type->code ())
@@ -486,11 +486,11 @@ c_value_print (struct value *val, struct ui_file *stream,
      C++: if it is a member pointer, we will take care
      of that when we print it.  */
 
-  type = check_typedef (value_type (val));
+  type = check_typedef (val->type ());
 
   if (type->is_pointer_or_reference ())
     {
-      struct type *original_type = value_type (val);
+      struct type *original_type = val->type ();
 
       /* Hack:  remove (char *) for char strings.  Their
 	 type is indicated by the quoted string anyway.
@@ -541,7 +541,7 @@ c_value_print (struct value *val, struct ui_file *stream,
 	  if (is_ref)
 	    val = value_ref (value_ind (val), refcode);
 
-	  type = value_type (val);
+	  type = val->type ();
 	  type_print (type, "", stream, -1);
 	  gdb_printf (stream, ") ");
 	}
@@ -549,7 +549,7 @@ c_value_print (struct value *val, struct ui_file *stream,
 	{
 	  /* normal case */
 	  gdb_printf (stream, "(");
-	  type_print (value_type (val), "", stream, -1);
+	  type_print (val->type (), "", stream, -1);
 	  gdb_printf (stream, ") ");
 	}
     }
diff --git a/gdb/c-varobj.c b/gdb/c-varobj.c
index a6b3306d22b..d517c798a6a 100644
--- a/gdb/c-varobj.c
+++ b/gdb/c-varobj.c
@@ -245,7 +245,7 @@ static struct value *
 value_struct_element_index (struct value *value, int type_index)
 {
   struct value *result = NULL;
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
 
   type = check_typedef (type);
 
diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index 6c0d780face..7267d607916 100644
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -2190,7 +2190,7 @@ setting_cmd (const char *fnname, struct cmd_list_element *showlist,
   if (argc != 1)
     error (_("You can only provide one argument to %s"), fnname);
 
-  struct type *type0 = check_typedef (value_type (argv[0]));
+  struct type *type0 = check_typedef (argv[0]->type ());
 
   if (type0->code () != TYPE_CODE_ARRAY
       && type0->code () != TYPE_CODE_STRING)
diff --git a/gdb/cli/cli-dump.c b/gdb/cli/cli-dump.c
index a8811c4b4d7..e1d40c0e0ce 100644
--- a/gdb/cli/cli-dump.c
+++ b/gdb/cli/cli-dump.c
@@ -225,7 +225,7 @@ dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
   /* Have everything.  Open/write the data.  */
   if (file_format == NULL || strcmp (file_format, "binary") == 0)
     dump_binary_file (filename.get (), mode, value_contents (val).data (),
-		      value_type (val)->length ());
+		      val->type ()->length ());
   else
     {
       CORE_ADDR vaddr;
@@ -242,7 +242,7 @@ dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
 
       dump_bfd_file (filename.get (), mode, file_format, vaddr,
 		     value_contents (val).data (), 
-		     value_type (val)->length ());
+		     val->type ()->length ());
     }
 }
 
diff --git a/gdb/cli/cli-utils.c b/gdb/cli/cli-utils.c
index 81c3c728dc6..b78568e3cc6 100644
--- a/gdb/cli/cli-utils.c
+++ b/gdb/cli/cli-utils.c
@@ -37,7 +37,7 @@ get_ulongest (const char **pp, int trailer)
 
       if (val != NULL)	/* Value history reference */
 	{
-	  if (value_type (val)->code () == TYPE_CODE_INT)
+	  if (val->type ()->code () == TYPE_CODE_INT)
 	    retval = value_as_long (val);
 	  else
 	    error (_("History value must have integer type."));
@@ -96,7 +96,7 @@ get_number_trailer (const char **pp, int trailer)
 
       if (val)	/* Value history reference */
 	{
-	  if (value_type (val)->code () == TYPE_CODE_INT)
+	  if (val->type ()->code () == TYPE_CODE_INT)
 	    retval = value_as_long (val);
 	  else
 	    {
diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c
index 87a3b5c0a96..538d314efda 100644
--- a/gdb/cp-abi.c
+++ b/gdb/cp-abi.c
@@ -111,7 +111,7 @@ value_rtti_type (struct value *v, int *full,
   struct type *ret = NULL;
 
   if ((current_cp_abi.rtti_type) == NULL
-      || !HAVE_CPLUS_STRUCT (check_typedef (value_type (v))))
+      || !HAVE_CPLUS_STRUCT (check_typedef (v->type ())))
     return NULL;
   try
     {
diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index ca73882a0ce..33ff17b8d2b 100644
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -129,7 +129,7 @@ cp_print_value_fields (struct value *val, struct ui_file *stream,
   int fields_seen = 0;
   static int last_set_recurse = -1;
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   if (recurse == 0)
     {
@@ -389,7 +389,7 @@ cp_print_value (struct value *val, struct ui_file *stream,
 		int recurse, const struct value_print_options *options,
 		struct type **dont_print_vb)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   CORE_ADDR address = value_address (val);
   struct type **last_dont_print
     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
@@ -461,7 +461,7 @@ cp_print_value (struct value *val, struct ui_file *stream,
 		  base_val = value_from_contents_and_address (baseclass,
 							      buf.data (),
 							      address + boffset);
-		  baseclass = value_type (base_val);
+		  baseclass = base_val->type ();
 		  boffset = 0;
 		}
 	      else
diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index edf4e74715c..cc8d7634c9d 100644
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -821,7 +821,7 @@ cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       int reg_demand;
       int i;
       
-      len = value_type (args[argnum])->length ();
+      len = args[argnum]->type ()->length ();
       val = value_contents (args[argnum]).data ();
       
       /* How may registers worth of storage do we need for this argument?  */
diff --git a/gdb/csky-tdep.c b/gdb/csky-tdep.c
index df9520fe37d..9fa1fb37154 100644
--- a/gdb/csky-tdep.c
+++ b/gdb/csky-tdep.c
@@ -806,7 +806,7 @@ csky_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       struct type *arg_type;
       const gdb_byte *val;
 
-      arg_type = check_typedef (value_type (args[argnum]));
+      arg_type = check_typedef (args[argnum]->type ());
       len = arg_type->length ();
       val = value_contents (args[argnum]).data ();
 
diff --git a/gdb/d-valprint.c b/gdb/d-valprint.c
index 18697545ce8..6c7748efa4c 100644
--- a/gdb/d-valprint.c
+++ b/gdb/d-valprint.c
@@ -61,7 +61,7 @@ dynamic_array_type (struct type *type,
 
       true_type = lookup_array_range_type (true_type, 0, length - 1);
       ival = value_at (true_type, addr);
-      true_type = value_type (ival);
+      true_type = ival->type ();
 
       d_value_print_inner (ival, stream, recurse + 1, options);
       return 0;
@@ -77,7 +77,7 @@ d_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
 {
   int ret;
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   switch (type->code ())
     {
       case TYPE_CODE_STRUCT:
diff --git a/gdb/darwin-nat-info.c b/gdb/darwin-nat-info.c
index d4dba555b6a..9e562074cf8 100644
--- a/gdb/darwin-nat-info.c
+++ b/gdb/darwin-nat-info.c
@@ -724,7 +724,7 @@ info_mach_region_command (const char *exp, int from_tty)
 
   expression_up expr = parse_expression (exp);
   val = evaluate_expression (expr.get ());
-  if (TYPE_IS_REFERENCE (value_type (val)))
+  if (TYPE_IS_REFERENCE (val->type ()))
     {
       val = value_ind (val);
     }
diff --git a/gdb/dtrace-probe.c b/gdb/dtrace-probe.c
index 9805b8a8e78..70fa1a9413e 100644
--- a/gdb/dtrace-probe.c
+++ b/gdb/dtrace-probe.c
@@ -494,7 +494,7 @@ dtrace_process_dof_probe (struct objfile *objfile,
 	    }
 
 	  if (expr != NULL && expr->first_opcode () == OP_TYPE)
-	    type = value_type (evaluate_type (expr.get ()));
+	    type = evaluate_type (expr.get ())->type ();
 
 	  args.emplace_back (type, std::move (type_str), std::move (expr));
 	}
diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index eecd18f59c9..7310295db4d 100644
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -151,7 +151,7 @@ rw_pieced_value (value *v, value *from, bool check_optimized)
   piece_closure *c
     = (piece_closure *) value_computed_closure (v);
   gdb::byte_vector buffer;
-  bool bits_big_endian = type_byte_order (value_type (v)) == BFD_ENDIAN_BIG;
+  bool bits_big_endian = type_byte_order (v->type ()) == BFD_ENDIAN_BIG;
 
   gdb_assert (!check_optimized || from == nullptr);
   if (from != nullptr)
@@ -174,18 +174,18 @@ rw_pieced_value (value *v, value *from, bool check_optimized)
       bits_to_skip += (8 * value_offset (value_parent (v))
 		       + value_bitpos (v));
       if (from != nullptr
-	  && (type_byte_order (value_type (from))
+	  && (type_byte_order (from->type ())
 	      == BFD_ENDIAN_BIG))
 	{
 	  /* Use the least significant bits of FROM.  */
-	  max_offset = 8 * value_type (from)->length ();
+	  max_offset = 8 * from->type ()->length ();
 	  offset = max_offset - value_bitsize (v);
 	}
       else
 	max_offset = value_bitsize (v);
     }
   else
-    max_offset = 8 * value_type (v)->length ();
+    max_offset = 8 * v->type ()->length ();
 
   /* Advance to the first non-skipped piece.  */
   for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++)
@@ -364,7 +364,7 @@ rw_pieced_value (value *v, value *from, bool check_optimized)
 
 	    gdbarch *objfile_gdbarch = c->per_objfile->objfile->arch ();
 	    ULONGEST stack_value_size_bits
-	      = 8 * value_type (p->v.value)->length ();
+	      = 8 * p->v.value->type ()->length ();
 
 	    /* Use zeroes if piece reaches beyond stack value.  */
 	    if (p->offset + p->size > stack_value_size_bits)
@@ -507,7 +507,7 @@ indirect_pieced_value (value *value)
   int i;
   dwarf_expr_piece *piece = NULL;
 
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
   if (type->code () != TYPE_CODE_PTR)
     return NULL;
 
@@ -574,7 +574,7 @@ indirect_pieced_value (value *value)
 static value *
 coerce_pieced_ref (const value *value)
 {
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
 
   if (value_bits_synthetic_pointer (value, value_embedded_offset (value),
 				    TARGET_CHAR_BIT * type->length ()))
@@ -1012,7 +1012,7 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type,
 	case DWARF_VALUE_STACK:
 	  {
 	    value *val = this->fetch (0);
-	    size_t n = value_type (val)->length ();
+	    size_t n = val->type ()->length ();
 	    size_t len = subobj_type->length ();
 	    size_t max = type->length ();
 
@@ -1144,7 +1144,7 @@ dwarf_expr_context::fetch_address (int n)
   bfd_endian byte_order = gdbarch_byte_order (arch);
   ULONGEST result;
 
-  dwarf_require_integral (value_type (result_val));
+  dwarf_require_integral (result_val->type ());
   result = extract_unsigned_integer (value_contents (result_val), byte_order);
 
   /* For most architectures, calling extract_unsigned_integer() alone
@@ -1157,7 +1157,7 @@ dwarf_expr_context::fetch_address (int n)
     {
       gdb_byte *buf = (gdb_byte *) alloca (this->m_addr_size);
       type *int_type = get_unsigned_type (arch,
-					  value_type (result_val));
+					  result_val->type ());
 
       store_unsigned_integer (buf, this->m_addr_size, byte_order, result);
       return gdbarch_integer_to_address (arch, int_type, buf);
@@ -1929,18 +1929,18 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 	      {
 	      case DW_OP_abs:
 		if (value_less (result_val,
-				value_zero (value_type (result_val), not_lval)))
+				value_zero (result_val->type (), not_lval)))
 		  result_val = value_neg (result_val);
 		break;
 	      case DW_OP_neg:
 		result_val = value_neg (result_val);
 		break;
 	      case DW_OP_not:
-		dwarf_require_integral (value_type (result_val));
+		dwarf_require_integral (result_val->type ());
 		result_val = value_complement (result_val);
 		break;
 	      case DW_OP_plus_uconst:
-		dwarf_require_integral (value_type (result_val));
+		dwarf_require_integral (result_val->type ());
 		result = value_as_long (result_val);
 		op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 		result += reg;
@@ -1977,14 +1977,14 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 	    first = fetch (0);
 	    pop ();
 
-	    if (! base_types_equal_p (value_type (first), value_type (second)))
+	    if (! base_types_equal_p (first->type (), second->type ()))
 	      error (_("Incompatible types on DWARF stack"));
 
 	    switch (op)
 	      {
 	      case DW_OP_and:
-		dwarf_require_integral (value_type (first));
-		dwarf_require_integral (value_type (second));
+		dwarf_require_integral (first->type ());
+		dwarf_require_integral (second->type ());
 		result_val = value_binop (first, second, BINOP_BITWISE_AND);
 		break;
 	      case DW_OP_div:
@@ -1996,7 +1996,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 	      case DW_OP_mod:
 		{
 		  int cast_back = 0;
-		  struct type *orig_type = value_type (first);
+		  struct type *orig_type = first->type ();
 
 		  /* We have to special-case "old-style" untyped values
 		     -- these must have mod computed using unsigned
@@ -2020,25 +2020,25 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 		result_val = value_binop (first, second, BINOP_MUL);
 		break;
 	      case DW_OP_or:
-		dwarf_require_integral (value_type (first));
-		dwarf_require_integral (value_type (second));
+		dwarf_require_integral (first->type ());
+		dwarf_require_integral (second->type ());
 		result_val = value_binop (first, second, BINOP_BITWISE_IOR);
 		break;
 	      case DW_OP_plus:
 		result_val = value_binop (first, second, BINOP_ADD);
 		break;
 	      case DW_OP_shl:
-		dwarf_require_integral (value_type (first));
-		dwarf_require_integral (value_type (second));
+		dwarf_require_integral (first->type ());
+		dwarf_require_integral (second->type ());
 		result_val = value_binop (first, second, BINOP_LSH);
 		break;
 	      case DW_OP_shr:
-		dwarf_require_integral (value_type (first));
-		dwarf_require_integral (value_type (second));
-		if (!value_type (first)->is_unsigned ())
+		dwarf_require_integral (first->type ());
+		dwarf_require_integral (second->type ());
+		if (!first->type ()->is_unsigned ())
 		  {
 		    struct type *utype
-		      = get_unsigned_type (arch, value_type (first));
+		      = get_unsigned_type (arch, first->type ());
 
 		    first = value_cast (utype, first);
 		  }
@@ -2046,16 +2046,16 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 		result_val = value_binop (first, second, BINOP_RSH);
 		/* Make sure we wind up with the same type we started
 		   with.  */
-		if (value_type (result_val) != value_type (second))
-		  result_val = value_cast (value_type (second), result_val);
+		if (result_val->type () != second->type ())
+		  result_val = value_cast (second->type (), result_val);
 		break;
 	      case DW_OP_shra:
-		dwarf_require_integral (value_type (first));
-		dwarf_require_integral (value_type (second));
-		if (value_type (first)->is_unsigned ())
+		dwarf_require_integral (first->type ());
+		dwarf_require_integral (second->type ());
+		if (first->type ()->is_unsigned ())
 		  {
 		    struct type *stype
-		      = get_signed_type (arch, value_type (first));
+		      = get_signed_type (arch, first->type ());
 
 		    first = value_cast (stype, first);
 		  }
@@ -2063,12 +2063,12 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 		result_val = value_binop (first, second, BINOP_RSH);
 		/* Make sure we wind up with the same type we started
 		   with.  */
-		if (value_type (result_val) != value_type (second))
-		  result_val = value_cast (value_type (second), result_val);
+		if (result_val->type () != second->type ())
+		  result_val = value_cast (second->type (), result_val);
 		break;
 	      case DW_OP_xor:
-		dwarf_require_integral (value_type (first));
-		dwarf_require_integral (value_type (second));
+		dwarf_require_integral (first->type ());
+		dwarf_require_integral (second->type ());
 		result_val = value_binop (first, second, BINOP_BITWISE_XOR);
 		break;
 	      case DW_OP_le:
@@ -2142,7 +2142,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 	    offset = extract_signed_integer (op_ptr, 2, byte_order);
 	    op_ptr += 2;
 	    val = fetch (0);
-	    dwarf_require_integral (value_type (val));
+	    dwarf_require_integral (val->type ());
 	    if (value_as_long (val) != 0)
 	      op_ptr += offset;
 	    pop ();
@@ -2341,12 +2341,12 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
 
 	    if (op == DW_OP_convert || op == DW_OP_GNU_convert)
 	      result_val = value_cast (type, result_val);
-	    else if (type == value_type (result_val))
+	    else if (type == result_val->type ())
 	      {
 		/* Nothing.  */
 	      }
 	    else if (type->length ()
-		     != value_type (result_val)->length ())
+		     != result_val->type ()->length ())
 	      error (_("DW_OP_reinterpret has wrong size"));
 	    else
 	      result_val
diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c
index 236ad820462..4af4dfde090 100644
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -1273,7 +1273,7 @@ dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
 static struct value *
 entry_data_value_coerce_ref (const struct value *value)
 {
-  struct type *checked_type = check_typedef (value_type (value));
+  struct type *checked_type = check_typedef (value->type ());
   struct value *target_val;
 
   if (!TYPE_IS_REFERENCE (checked_type))
diff --git a/gdb/eval.c b/gdb/eval.c
index bb42e693b17..c24ff258b43 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -241,7 +241,7 @@ unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
   struct type *type1;
 
   *arg1 = coerce_ref (*arg1);
-  type1 = check_typedef (value_type (*arg1));
+  type1 = check_typedef ((*arg1)->type ());
 
   if (is_integral_type (type1))
     {
@@ -278,8 +278,8 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
   *arg1 = coerce_ref (*arg1);
   *arg2 = coerce_ref (*arg2);
 
-  type1 = check_typedef (value_type (*arg1));
-  type2 = check_typedef (value_type (*arg2));
+  type1 = check_typedef ((*arg1)->type ());
+  type2 = check_typedef ((*arg2)->type ());
 
   if ((type1->code () != TYPE_CODE_FLT
        && type1->code () != TYPE_CODE_DECFLOAT
@@ -628,7 +628,7 @@ evaluate_subexp_do_call (expression *exp, enum noside noside,
 	 call an error.  This can happen if somebody tries to turn
 	 a variable into a function call.  */
 
-      type *ftype = value_type (callee);
+      type *ftype = callee->type ();
 
       if (ftype->code () == TYPE_CODE_INTERNAL_FUNCTION)
 	{
@@ -672,7 +672,7 @@ evaluate_subexp_do_call (expression *exp, enum noside noside,
 	error (_("Expression of type other than "
 		 "\"Function returning ...\" used as function"));
     }
-  switch (value_type (callee)->code ())
+  switch (callee->type ()->code ())
     {
     case TYPE_CODE_INTERNAL_FUNCTION:
       return call_internal_function (exp->gdbarch, exp->language_defn,
@@ -697,7 +697,7 @@ operation::evaluate_funcall (struct type *expect_type,
   std::vector<value *> vals (args.size ());
 
   value *callee = evaluate_with_coercion (exp, noside);
-  struct type *type = value_type (callee);
+  struct type *type = callee->type ();
   if (type->code () == TYPE_CODE_PTR)
     type = type->target_type ();
   for (int i = 0; i < args.size (); ++i)
@@ -836,7 +836,7 @@ structop_member_base::evaluate_funcall (struct type *expect_type,
   value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
   value *callee;
 
-  type *a1_type = check_typedef (value_type (rhs));
+  type *a1_type = check_typedef (rhs->type ());
   if (a1_type->code () == TYPE_CODE_METHODPTR)
     {
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -963,7 +963,7 @@ structop_base_operation::evaluate_funcall
       /* value_struct_elt updates temp with the correct value of the
 	 ``this'' pointer if necessary, so modify it to reflect any
 	 ``this'' changes.  */
-      vals[0] = value_from_longest (lookup_pointer_type (value_type (temp)),
+      vals[0] = value_from_longest (lookup_pointer_type (temp->type ()),
 				    value_address (temp)
 				    + value_embedded_offset (temp));
     }
@@ -1041,7 +1041,7 @@ structop_base_operation::complete (struct expression *exp,
 
   value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						  EVAL_AVOID_SIDE_EFFECTS);
-  struct type *type = value_type (lhs);
+  struct type *type = lhs->type ();
   for (;;)
     {
       type = check_typedef (type);
@@ -1122,7 +1122,7 @@ eval_op_var_msym_value (struct type *expect_type, struct expression *exp,
   value *val = evaluate_var_msym_value (noside, msymbol.objfile,
 					msymbol.minsym);
 
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
   if (type->code () == TYPE_CODE_ERROR
       && (noside != EVAL_AVOID_SIDE_EFFECTS || !outermost_p))
     error_unknown_type (msymbol.minsym->print_name ());
@@ -1224,7 +1224,7 @@ eval_op_structop_struct (struct type *expect_type, struct expression *exp,
   struct value *arg3 = value_struct_elt (&arg1, {}, string,
 					 NULL, "structure");
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
+    arg3 = value_zero (arg3->type (), VALUE_LVAL (arg3));
   return arg3;
 }
 
@@ -1260,7 +1260,7 @@ eval_op_structop_ptr (struct type *expect_type, struct expression *exp,
      with rtti type in order to continue on with successful
      lookup of member / method only available in the rtti type.  */
   {
-    struct type *arg_type = value_type (arg1);
+    struct type *arg_type = arg1->type ();
     struct type *real_type;
     int full, using_enc;
     LONGEST top;
@@ -1280,7 +1280,7 @@ eval_op_structop_ptr (struct type *expect_type, struct expression *exp,
   struct value *arg3 = value_struct_elt (&arg1, {}, string,
 					 NULL, "structure pointer");
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
+    arg3 = value_zero (arg3->type (), VALUE_LVAL (arg3));
   return arg3;
 }
 
@@ -1294,7 +1294,7 @@ eval_op_member (struct type *expect_type, struct expression *exp,
   long mem_offset;
 
   struct value *arg3;
-  struct type *type = check_typedef (value_type (arg2));
+  struct type *type = check_typedef (arg2->type ());
   switch (type->code ())
     {
     case TYPE_CODE_METHODPTR:
@@ -1303,13 +1303,13 @@ eval_op_member (struct type *expect_type, struct expression *exp,
       else
 	{
 	  arg2 = cplus_method_ptr_to_value (&arg1, arg2);
-	  gdb_assert (value_type (arg2)->code () == TYPE_CODE_PTR);
+	  gdb_assert (arg2->type ()->code () == TYPE_CODE_PTR);
 	  return value_ind (arg2);
 	}
 
     case TYPE_CODE_MEMBERPTR:
       /* Now, convert these values to an address.  */
-      if (check_typedef (value_type (arg1))->code () != TYPE_CODE_PTR)
+      if (check_typedef (arg1->type ())->code () != TYPE_CODE_PTR)
 	arg1 = value_addr (arg1);
       arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
 				  arg1, 1);
@@ -1335,11 +1335,11 @@ eval_op_add (struct type *expect_type, struct expression *exp,
 {
   if (binop_user_defined_p (BINOP_ADD, arg1, arg2))
     return value_x_binop (arg1, arg2, BINOP_ADD, OP_NULL, noside);
-  else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
-	   && is_integral_or_integral_reference (value_type (arg2)))
+  else if (ptrmath_type_p (exp->language_defn, arg1->type ())
+	   && is_integral_or_integral_reference (arg2->type ()))
     return value_ptradd (arg1, value_as_long (arg2));
-  else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
-	   && is_integral_or_integral_reference (value_type (arg1)))
+  else if (ptrmath_type_p (exp->language_defn, arg2->type ())
+	   && is_integral_or_integral_reference (arg1->type ()))
     return value_ptradd (arg2, value_as_long (arg1));
   else
     {
@@ -1357,15 +1357,15 @@ eval_op_sub (struct type *expect_type, struct expression *exp,
 {
   if (binop_user_defined_p (BINOP_SUB, arg1, arg2))
     return value_x_binop (arg1, arg2, BINOP_SUB, OP_NULL, noside);
-  else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
-	   && ptrmath_type_p (exp->language_defn, value_type (arg2)))
+  else if (ptrmath_type_p (exp->language_defn, arg1->type ())
+	   && ptrmath_type_p (exp->language_defn, arg2->type ()))
     {
       /* FIXME -- should be ptrdiff_t */
       struct type *type = builtin_type (exp->gdbarch)->builtin_long;
       return value_from_longest (type, value_ptrdiff (arg1, arg2));
     }
-  else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
-	   && is_integral_or_integral_reference (value_type (arg2)))
+  else if (ptrmath_type_p (exp->language_defn, arg1->type ())
+	   && is_integral_or_integral_reference (arg2->type ()))
     return value_ptradd (arg1, - value_as_long (arg2));
   else
     {
@@ -1400,7 +1400,7 @@ eval_op_binary (struct type *expect_type, struct expression *exp,
 	{
 	  struct value *v_one;
 
-	  v_one = value_one (value_type (arg2));
+	  v_one = value_one (arg2->type ());
 	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
 	  return value_binop (arg1, v_one, op);
 	}
@@ -1409,7 +1409,7 @@ eval_op_binary (struct type *expect_type, struct expression *exp,
 	  /* For shift and integer exponentiation operations,
 	     only promote the first argument.  */
 	  if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
-	      && is_integral_type (value_type (arg2)))
+	      && is_integral_type (arg2->type ()))
 	    unop_promote (exp->language_defn, exp->gdbarch, &arg1);
 	  else
 	    binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
@@ -1435,7 +1435,7 @@ eval_op_subscript (struct type *expect_type, struct expression *exp,
 	 then report this as an error.  */
 
       arg1 = coerce_ref (arg1);
-      struct type *type = check_typedef (value_type (arg1));
+      struct type *type = check_typedef (arg1->type ());
       if (type->code () != TYPE_CODE_ARRAY
 	  && type->code () != TYPE_CODE_PTR)
 	{
@@ -1586,13 +1586,13 @@ eval_op_repeat (struct type *expect_type, struct expression *exp,
 		enum noside noside, enum exp_opcode op,
 		struct value *arg1, struct value *arg2)
 {
-  struct type *type = check_typedef (value_type (arg2));
+  struct type *type = check_typedef (arg2->type ());
   if (type->code () != TYPE_CODE_INT
       && type->code () != TYPE_CODE_ENUM)
     error (_("Non-integral right operand for \"@\" operator."));
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      return allocate_repeat_value (value_type (arg1),
+      return allocate_repeat_value (arg1->type (),
 				    longest_to_int (value_as_long (arg2)));
     }
   else
@@ -1671,7 +1671,7 @@ eval_op_ind (struct type *expect_type, struct expression *exp,
 	     enum noside noside,
 	     struct value *arg1)
 {
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
   if (type->code () == TYPE_CODE_METHODPTR
       || type->code () == TYPE_CODE_MEMBERPTR)
     error (_("Attempt to dereference pointer "
@@ -1680,7 +1680,7 @@ eval_op_ind (struct type *expect_type, struct expression *exp,
     return value_x_unop (arg1, UNOP_IND, noside);
   else if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      type = check_typedef (value_type (arg1));
+      type = check_typedef (arg1->type ());
 
       /* If the type pointed to is dynamic then in order to resolve the
 	 dynamic properties we must actually dereference the pointer.
@@ -1721,7 +1721,7 @@ eval_op_alignof (struct type *expect_type, struct expression *exp,
 		 enum noside noside,
 		 struct value *arg1)
 {
-  struct type *type = value_type (arg1);
+  struct type *type = arg1->type ();
   /* FIXME: This should be size_t.  */
   struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
   ULONGEST align = type_align (type);
@@ -1759,13 +1759,13 @@ eval_op_preinc (struct type *expect_type, struct expression *exp,
   else
     {
       struct value *arg2;
-      if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+      if (ptrmath_type_p (exp->language_defn, arg1->type ()))
 	arg2 = value_ptradd (arg1, 1);
       else
 	{
 	  struct value *tmp = arg1;
 
-	  arg2 = value_one (value_type (arg1));
+	  arg2 = value_one (arg1->type ());
 	  binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
 	  arg2 = value_binop (tmp, arg2, BINOP_ADD);
 	}
@@ -1790,13 +1790,13 @@ eval_op_predec (struct type *expect_type, struct expression *exp,
   else
     {
       struct value *arg2;
-      if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+      if (ptrmath_type_p (exp->language_defn, arg1->type ()))
 	arg2 = value_ptradd (arg1, -1);
       else
 	{
 	  struct value *tmp = arg1;
 
-	  arg2 = value_one (value_type (arg1));
+	  arg2 = value_one (arg1->type ());
 	  binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
 	  arg2 = value_binop (tmp, arg2, BINOP_SUB);
 	}
@@ -1823,13 +1823,13 @@ eval_op_postinc (struct type *expect_type, struct expression *exp,
       struct value *arg3 = value_non_lval (arg1);
       struct value *arg2;
 
-      if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+      if (ptrmath_type_p (exp->language_defn, arg1->type ()))
 	arg2 = value_ptradd (arg1, 1);
       else
 	{
 	  struct value *tmp = arg1;
 
-	  arg2 = value_one (value_type (arg1));
+	  arg2 = value_one (arg1->type ());
 	  binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
 	  arg2 = value_binop (tmp, arg2, BINOP_ADD);
 	}
@@ -1857,13 +1857,13 @@ eval_op_postdec (struct type *expect_type, struct expression *exp,
       struct value *arg3 = value_non_lval (arg1);
       struct value *arg2;
 
-      if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+      if (ptrmath_type_p (exp->language_defn, arg1->type ()))
 	arg2 = value_ptradd (arg1, -1);
       else
 	{
 	  struct value *tmp = arg1;
 
-	  arg2 = value_one (value_type (arg1));
+	  arg2 = value_one (arg1->type ());
 	  binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
 	  arg2 = value_binop (tmp, arg2, BINOP_SUB);
 	}
@@ -1897,12 +1897,12 @@ eval_binop_assign_modify (struct type *expect_type, struct expression *exp,
   if (binop_user_defined_p (op, arg1, arg2))
     return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
   else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
-					      value_type (arg1))
-	   && is_integral_type (value_type (arg2)))
+					      arg1->type ())
+	   && is_integral_type (arg2->type ()))
     arg2 = value_ptradd (arg1, value_as_long (arg2));
   else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
-					      value_type (arg1))
-	   && is_integral_type (value_type (arg2)))
+					      arg1->type ())
+	   && is_integral_type (arg2->type ()))
     arg2 = value_ptradd (arg1, - value_as_long (arg2));
   else
     {
@@ -1911,7 +1911,7 @@ eval_binop_assign_modify (struct type *expect_type, struct expression *exp,
       /* For shift and integer exponentiation operations,
 	 only promote the first argument.  */
       if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
-	  && is_integral_type (value_type (arg2)))
+	  && is_integral_type (arg2->type ()))
 	unop_promote (exp->language_defn, exp->gdbarch, &tmp);
       else
 	binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
@@ -2115,7 +2115,7 @@ eval_op_objc_msgcall (struct type *expect_type, struct expression *exp,
 
   if (method)
     {
-      if (value_type (method)->code () != TYPE_CODE_FUNC)
+      if (method->type ()->code () != TYPE_CODE_FUNC)
 	error (_("method address has symbol information "
 		 "with non-function type; skipping"));
 
@@ -2127,11 +2127,11 @@ eval_op_objc_msgcall (struct type *expect_type, struct expression *exp,
 	 function descriptors.  */
       if (struct_return)
 	called_method
-	  = value_from_pointer (lookup_pointer_type (value_type (method)),
+	  = value_from_pointer (lookup_pointer_type (method->type ()),
 				value_as_address (msg_send_stret));
       else
 	called_method
-	  = value_from_pointer (lookup_pointer_type (value_type (method)),
+	  = value_from_pointer (lookup_pointer_type (method->type ()),
 				value_as_address (msg_send));
     }
   else
@@ -2153,7 +2153,7 @@ eval_op_objc_msgcall (struct type *expect_type, struct expression *exp,
 	 it's opinion (ie. through "whatis"), it won't offer
 	 it.  */
 
-      struct type *callee_type = value_type (called_method);
+      struct type *callee_type = called_method->type ();
 
       if (callee_type && callee_type->code () == TYPE_CODE_PTR)
 	callee_type = callee_type->target_type ();
@@ -2181,7 +2181,7 @@ eval_op_objc_msgcall (struct type *expect_type, struct expression *exp,
   if (gnu_runtime && (method != NULL))
     {
       /* Function objc_msg_lookup returns a pointer.  */
-      struct type *tem_type = value_type (called_method);
+      struct type *tem_type = called_method->type ();
       tem_type = lookup_pointer_type (lookup_function_type (tem_type));
       deprecated_set_value_type (called_method, tem_type);
       called_method = call_function_by_hand (called_method, NULL, args);
@@ -2206,7 +2206,7 @@ eval_multi_subscript (struct type *expect_type, struct expression *exp,
       else
 	{
 	  arg1 = coerce_ref (arg1);
-	  struct type *type = check_typedef (value_type (arg1));
+	  struct type *type = check_typedef (arg1->type ());
 
 	  switch (type->code ())
 	    {
@@ -2369,7 +2369,7 @@ array_operation::evaluate_struct_tuple (struct value *struct_val,
 					enum noside noside, int nargs)
 {
   const std::vector<operation_up> &in_args = std::get<2> (m_storage);
-  struct type *struct_type = check_typedef (value_type (struct_val));
+  struct type *struct_type = check_typedef (struct_val->type ());
   struct type *field_type;
   int fieldno = -1;
 
@@ -2408,7 +2408,7 @@ array_operation::evaluate_struct_tuple (struct value *struct_val,
       /* Now actually set the field in struct_val.  */
 
       /* Assign val to field fieldno.  */
-      if (value_type (val) != field_type)
+      if (val->type () != field_type)
 	val = value_cast (field_type, val);
 
       bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
@@ -2419,7 +2419,7 @@ array_operation::evaluate_struct_tuple (struct value *struct_val,
 		      value_as_long (val), bitpos % 8, bitsize);
       else
 	memcpy (addr, value_contents (val).data (),
-		value_type (val)->length ());
+		val->type ()->length ());
 
     }
   return struct_val;
@@ -2468,7 +2468,7 @@ array_operation::evaluate (struct type *expect_type,
 
 	  element = in_args[index - low_bound]->evaluate (element_type,
 							  exp, noside);
-	  if (value_type (element) != element_type)
+	  if (element->type () != element_type)
 	    element = value_cast (element_type, element);
 	  if (index > high_bound)
 	    /* To avoid memory corruption.  */
@@ -2507,7 +2507,7 @@ array_operation::evaluate (struct type *expect_type,
 	  struct value *elem_val;
 
 	  elem_val = in_args[idx++]->evaluate (element_type, exp, noside);
-	  range_low_type = range_high_type = value_type (elem_val);
+	  range_low_type = range_high_type = elem_val->type ();
 	  range_low = range_high = value_as_long (elem_val);
 
 	  /* Check types of elements to avoid mixture of elements from
@@ -2566,7 +2566,7 @@ unop_extract_operation::evaluate (struct type *expect_type,
   value *old_value = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
   struct type *type = get_type ();
 
-  if (type->length () > value_type (old_value)->length ())
+  if (type->length () > old_value->type ()->length ())
     error (_("length type is larger than the value type"));
 
   struct value *result = allocate_value (type);
@@ -2585,13 +2585,13 @@ evaluate_subexp_for_address_base (struct expression *exp, enum noside noside,
 {
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      struct type *type = check_typedef (value_type (x));
+      struct type *type = check_typedef (x->type ());
 
       if (TYPE_IS_REFERENCE (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)),
+	return value_zero (lookup_pointer_type (x->type ()),
 			   not_lval);
       else
 	error (_("Attempt to take address of "
@@ -2655,7 +2655,7 @@ var_msym_value_operation::evaluate_for_address (struct expression *exp,
   value *val = evaluate_var_msym_value (noside, b.objfile, b.minsym);
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      struct type *type = lookup_pointer_type (value_type (val));
+      struct type *type = lookup_pointer_type (val->type ());
       return value_zero (type, not_lval);
     }
   else
@@ -2676,7 +2676,7 @@ unop_memval_type_operation::evaluate_for_address (struct expression *exp,
 {
   value *typeval = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						      EVAL_AVOID_SIDE_EFFECTS);
-  struct type *type = value_type (typeval);
+  struct type *type = typeval->type ();
   return value_cast (lookup_pointer_type (type),
 		     std::get<1> (m_storage)->evaluate (nullptr, exp, noside));
 }
@@ -2751,7 +2751,7 @@ value *
 operation::evaluate_for_sizeof (struct expression *exp, enum noside noside)
 {
   value *val = evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS);
-  return evaluate_subexp_for_sizeof_base (exp, value_type (val));
+  return evaluate_subexp_for_sizeof_base (exp, val->type ());
 }
 
 value *
@@ -2762,7 +2762,7 @@ var_msym_value_operation::evaluate_for_sizeof (struct expression *exp,
   const bound_minimal_symbol &b = std::get<0> (m_storage);
   value *mval = evaluate_var_msym_value (noside, b.objfile, b.minsym);
 
-  struct type *type = value_type (mval);
+  struct type *type = mval->type ();
   if (type->code () == TYPE_CODE_ERROR)
     error_unknown_type (b.minsym->print_name ());
 
@@ -2779,7 +2779,7 @@ subscript_operation::evaluate_for_sizeof (struct expression *exp,
     {
       value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						      EVAL_AVOID_SIDE_EFFECTS);
-      struct type *type = check_typedef (value_type (val));
+      struct type *type = check_typedef (val->type ());
       if (type->code () == TYPE_CODE_ARRAY)
 	{
 	  type = check_typedef (type->target_type ());
@@ -2795,7 +2795,7 @@ subscript_operation::evaluate_for_sizeof (struct expression *exp,
 		  struct type *size_type
 		    = builtin_type (exp->gdbarch)->builtin_int;
 		  return value_from_longest
-		    (size_type, (LONGEST) value_type (val)->length ());
+		    (size_type, (LONGEST) val->type ()->length ());
 		}
 	    }
 	}
@@ -2810,13 +2810,13 @@ unop_ind_base_operation::evaluate_for_sizeof (struct expression *exp,
 {
   value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						  EVAL_AVOID_SIDE_EFFECTS);
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   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 ();
   if (is_dynamic_type (type))
-    type = value_type (value_ind (val));
+    type = value_ind (val)->type ();
   /* FIXME: This should be size_t.  */
   struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
   return value_from_longest (size_type, (LONGEST) type->length ());
@@ -2835,7 +2835,7 @@ unop_memval_type_operation::evaluate_for_sizeof (struct expression *exp,
 {
   value *typeval = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						      EVAL_AVOID_SIDE_EFFECTS);
-  return evaluate_subexp_for_sizeof_base (exp, value_type (typeval));
+  return evaluate_subexp_for_sizeof_base (exp, typeval->type ());
 }
 
 value *
@@ -2846,7 +2846,7 @@ var_value_operation::evaluate_for_sizeof (struct expression *exp,
   if (is_dynamic_type (type))
     {
       value *val = evaluate (nullptr, exp, EVAL_NORMAL);
-      type = value_type (val);
+      type = val->type ();
       if (type->code () == TYPE_CODE_ARRAY)
 	{
 	  /* FIXME: This should be size_t.  */
diff --git a/gdb/expop.h b/gdb/expop.h
index bfe55e4f2fd..7460343cb48 100644
--- a/gdb/expop.h
+++ b/gdb/expop.h
@@ -1330,7 +1330,7 @@ class comparison_operation
     value *lhs
       = std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
     value *rhs
-      = std::get<1> (this->m_storage)->evaluate (value_type (lhs), exp,
+      = std::get<1> (this->m_storage)->evaluate (lhs->type (), exp,
 						 noside);
     return FUNC (expect_type, exp, noside, OP, lhs, rhs);
   }
@@ -1613,7 +1613,7 @@ class decltype_operation
 	    || sub_op == STRUCTOP_PTR
 	    || sub_op == OP_SCOPE)
 	  {
-	    struct type *type = value_type (result);
+	    struct type *type = result->type ();
 
 	    if (!TYPE_IS_REFERENCE (type))
 	      {
@@ -1804,7 +1804,7 @@ class unop_memval_type_operation
     value *typeval
       = std::get<0> (m_storage)->evaluate (expect_type, exp,
 					   EVAL_AVOID_SIDE_EFFECTS);
-    struct type *type = value_type (typeval);
+    struct type *type = typeval->type ();
     value *val = std::get<1> (m_storage)->evaluate (expect_type, exp, noside);
     return eval_op_memval (expect_type, exp, noside, val, type);
   }
@@ -1891,7 +1891,7 @@ class assign_operation
        many array elements".  */
     struct type *xtype = (VALUE_LVAL (lhs) == lval_internalvar
 			  ? nullptr
-			  : value_type (lhs));
+			  : lhs->type ());
     value *rhs = std::get<1> (m_storage)->evaluate (xtype, exp, noside);
 
     if (noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -2030,7 +2030,7 @@ class unop_cast_type_operation
   {
     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						    EVAL_AVOID_SIDE_EFFECTS);
-    return std::get<1> (m_storage)->evaluate_for_cast (value_type (val),
+    return std::get<1> (m_storage)->evaluate_for_cast (val->type (),
 						       exp, noside);
   }
 
@@ -2064,7 +2064,7 @@ class cxx_cast_operation
   {
     value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
 						    EVAL_AVOID_SIDE_EFFECTS);
-    struct type *type = value_type (val);
+    struct type *type = val->type ();
     value *rhs = std::get<1> (m_storage)->evaluate (type, exp, noside);
     return FUNC (type, rhs);
   }
diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index a1e425a2d55..bf2471a1e2c 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -127,7 +127,7 @@ fortran_bounds_all_dims (bool lbound_p,
 			 struct gdbarch *gdbarch,
 			 struct value *array)
 {
-  type *array_type = check_typedef (value_type (array));
+  type *array_type = check_typedef (array->type ());
   int ndimensions = calc_f77_array_dims (array_type);
 
   /* Allocate a result value of the correct type.  */
@@ -156,9 +156,9 @@ fortran_bounds_all_dims (bool lbound_p,
 
       /* And copy the value into the result value.  */
       struct value *v = value_from_longest (elm_type, b);
-      gdb_assert (dst_offset + value_type (v)->length ()
-		  <= value_type (result)->length ());
-      gdb_assert (value_type (v)->length () == elm_len);
+      gdb_assert (dst_offset + v->type ()->length ()
+		  <= result->type ()->length ());
+      gdb_assert (v->type ()->length () == elm_len);
       value_contents_copy (result, dst_offset, v, 0, elm_len);
 
       /* Peel another dimension of the array.  */
@@ -178,7 +178,7 @@ fortran_bounds_for_dimension (bool lbound_p, value *array, value *dim_val,
 			      type* result_type)
 {
   /* Check the requested dimension is valid for this array.  */
-  type *array_type = check_typedef (value_type (array));
+  type *array_type = check_typedef (array->type ());
   int ndimensions = calc_f77_array_dims (array_type);
   long dim = value_as_long (dim_val);
   if (dim < 1 || dim > ndimensions)
@@ -283,8 +283,8 @@ class fortran_array_repacker_base_impl
   void copy_element_to_dest (struct value *elt)
   {
     value_contents_copy (m_dest, m_dest_offset, elt, 0,
-			 value_type (elt)->length ());
-    m_dest_offset += value_type (elt)->length ();
+			 elt->type ()->length ());
+    m_dest_offset += elt->type ()->length ();
   }
 
   /* The value being written to.  */
@@ -394,7 +394,7 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
 
   /* All Fortran pointers should have the associated property, this is
      how we know the pointer is pointing at something or not.  */
-  struct type *pointer_type = check_typedef (value_type (pointer));
+  struct type *pointer_type = check_typedef (pointer->type ());
   if (TYPE_ASSOCIATED_PROP (pointer_type) == nullptr
       && pointer_type->code () != TYPE_CODE_PTR)
     error (_("ASSOCIATED can only be applied to pointers"));
@@ -431,7 +431,7 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
 
   /* The two argument case, is POINTER associated with TARGET?  */
 
-  struct type *target_type = check_typedef (value_type (target));
+  struct type *target_type = check_typedef (target->type ());
 
   struct type *pointer_target_type;
   if (pointer_type->code () == TYPE_CODE_PTR)
@@ -588,7 +588,7 @@ static value *
 fortran_array_size (value *array, value *dim_val, type *result_type)
 {
   /* Check that ARRAY is the correct type.  */
-  struct type *array_type = check_typedef (value_type (array));
+  struct type *array_type = check_typedef (array->type ());
   if (array_type->code () != TYPE_CODE_ARRAY)
     error (_("SIZE can only be applied to arrays"));
   if (type_not_allocated (array_type) || type_not_associated (array_type))
@@ -600,7 +600,7 @@ fortran_array_size (value *array, value *dim_val, type *result_type)
 
   if (dim_val != nullptr)
     {
-      if (check_typedef (value_type (dim_val))->code () != TYPE_CODE_INT)
+      if (check_typedef (dim_val->type ())->code () != TYPE_CODE_INT)
 	error (_("DIM argument to SIZE must be an integer"));
       dim = (int) value_as_long (dim_val);
 
@@ -696,7 +696,7 @@ static struct value *
 fortran_array_shape (struct gdbarch *gdbarch, const language_defn *lang,
 		     struct value *val)
 {
-  struct type *val_type = check_typedef (value_type (val));
+  struct type *val_type = check_typedef (val->type ());
 
   /* If we are passed an array that is either not allocated, or not
      associated, then this is explicitly not allowed according to the
@@ -741,9 +741,9 @@ fortran_array_shape (struct gdbarch *gdbarch, const language_defn *lang,
 
       /* And copy the value into the result value.  */
       struct value *v = value_from_longest (elm_type, dim_size);
-      gdb_assert (dst_offset + value_type (v)->length ()
-		  <= value_type (result)->length ());
-      gdb_assert (value_type (v)->length () == elm_len);
+      gdb_assert (dst_offset + v->type ()->length ()
+		  <= result->type ()->length ());
+      gdb_assert (v->type ()->length () == elm_len);
       value_contents_copy (result, dst_offset, v, 0, elm_len);
 
       /* Peel another dimension of the array.  */
@@ -772,14 +772,14 @@ eval_op_f_abs (struct type *expect_type, struct expression *exp,
 	       enum exp_opcode opcode,
 	       struct value *arg1)
 {
-  struct type *type = value_type (arg1);
+  struct type *type = arg1->type ();
   switch (type->code ())
     {
     case TYPE_CODE_FLT:
       {
 	double d
 	  = fabs (target_float_to_host_double (value_contents (arg1).data (),
-					       value_type (arg1)));
+					       arg1->type ()));
 	return value_from_host_double (type, d);
       }
     case TYPE_CODE_INT:
@@ -800,8 +800,8 @@ eval_op_f_mod (struct type *expect_type, struct expression *exp,
 	       enum exp_opcode opcode,
 	       struct value *arg1, struct value *arg2)
 {
-  struct type *type = value_type (arg1);
-  if (type->code () != value_type (arg2)->code ())
+  struct type *type = arg1->type ();
+  if (type->code () != arg2->type ()->code ())
     error (_("non-matching types for parameters to MOD ()"));
   switch (type->code ())
     {
@@ -809,10 +809,10 @@ eval_op_f_mod (struct type *expect_type, struct expression *exp,
       {
 	double d1
 	  = target_float_to_host_double (value_contents (arg1).data (),
-					 value_type (arg1));
+					 arg1->type ());
 	double d2
 	  = target_float_to_host_double (value_contents (arg2).data (),
-					 value_type (arg2));
+					 arg2->type ());
 	double d3 = fmod (d1, d2);
 	return value_from_host_double (type, d3);
       }
@@ -823,7 +823,7 @@ eval_op_f_mod (struct type *expect_type, struct expression *exp,
 	if (v2 == 0)
 	  error (_("calling MOD (N, 0) is undefined"));
 	LONGEST v3 = v1 - (v1 / v2) * v2;
-	return value_from_longest (value_type (arg1), v3);
+	return value_from_longest (arg1->type (), v3);
       }
     }
   error (_("MOD of type %s not supported"), TYPE_SAFE_NAME (type));
@@ -836,10 +836,10 @@ eval_op_f_mod (struct type *expect_type, struct expression *exp,
 static value *
 fortran_ceil_operation (value *arg1, type *result_type)
 {
-  if (value_type (arg1)->code () != TYPE_CODE_FLT)
+  if (arg1->type ()->code () != TYPE_CODE_FLT)
     error (_("argument to CEILING must be of type float"));
   double val = target_float_to_host_double (value_contents (arg1).data (),
-					    value_type (arg1));
+					    arg1->type ());
   val = ceil (val);
   return value_from_longest (result_type, val);
 }
@@ -875,10 +875,10 @@ eval_op_f_ceil (type *expect_type, expression *exp, noside noside,
 static value *
 fortran_floor_operation (value *arg1, type *result_type)
 {
-  if (value_type (arg1)->code () != TYPE_CODE_FLT)
+  if (arg1->type ()->code () != TYPE_CODE_FLT)
     error (_("argument to FLOOR must be of type float"));
   double val = target_float_to_host_double (value_contents (arg1).data (),
-					    value_type (arg1));
+					    arg1->type ());
   val = floor (val);
   return value_from_longest (result_type, val);
 }
@@ -915,8 +915,8 @@ eval_op_f_modulo (struct type *expect_type, struct expression *exp,
 		  enum exp_opcode opcode,
 		  struct value *arg1, struct value *arg2)
 {
-  struct type *type = value_type (arg1);
-  if (type->code () != value_type (arg2)->code ())
+  struct type *type = arg1->type ();
+  if (type->code () != arg2->type ()->code ())
     error (_("non-matching types for parameters to MODULO ()"));
   /* MODULO(A, P) = A - FLOOR (A / P) * P */
   switch (type->code ())
@@ -928,16 +928,16 @@ eval_op_f_modulo (struct type *expect_type, struct expression *exp,
 	LONGEST result = a - (a / p) * p;
 	if (result != 0 && (a < 0) != (p < 0))
 	  result += p;
-	return value_from_longest (value_type (arg1), result);
+	return value_from_longest (arg1->type (), result);
       }
     case TYPE_CODE_FLT:
       {
 	double a
 	  = target_float_to_host_double (value_contents (arg1).data (),
-					 value_type (arg1));
+					 arg1->type ());
 	double p
 	  = target_float_to_host_double (value_contents (arg2).data (),
-					 value_type (arg2));
+					 arg2->type ());
 	double result = fmod (a, p);
 	if (result != 0 && (a < 0.0) != (p < 0.0))
 	  result += p;
@@ -957,11 +957,11 @@ eval_op_f_cmplx (type *expect_type, expression *exp, noside noside,
 
   type *result_type = builtin_f_type (exp->gdbarch)->builtin_complex;
 
-  if (value_type (arg1)->code () == TYPE_CODE_COMPLEX)
+  if (arg1->type ()->code () == TYPE_CODE_COMPLEX)
     return value_cast (result_type, arg1);
   else
     return value_literal_complex (arg1,
-				  value_zero (value_type (arg1), not_lval),
+				  value_zero (arg1->type (), not_lval),
 				  result_type);
 }
 
@@ -973,8 +973,8 @@ eval_op_f_cmplx (struct type *expect_type, struct expression *exp,
 		 enum exp_opcode opcode,
 		 struct value *arg1, struct value *arg2)
 {
-  if (value_type (arg1)->code () == TYPE_CODE_COMPLEX
-      || value_type (arg2)->code () == TYPE_CODE_COMPLEX)
+  if (arg1->type ()->code () == TYPE_CODE_COMPLEX
+      || arg2->type ()->code () == TYPE_CODE_COMPLEX)
     error (_("Types of arguments for CMPLX called with more then one argument "
 	     "must be REAL or INTEGER"));
 
@@ -989,8 +989,8 @@ eval_op_f_cmplx (type *expect_type, expression *exp, noside noside,
 		 exp_opcode opcode, value *arg1, value *arg2, type *kind_arg)
 {
   gdb_assert (kind_arg->code () == TYPE_CODE_COMPLEX);
-  if (value_type (arg1)->code () == TYPE_CODE_COMPLEX
-      || value_type (arg2)->code () == TYPE_CODE_COMPLEX)
+  if (arg1->type ()->code () == TYPE_CODE_COMPLEX
+      || arg2->type ()->code () == TYPE_CODE_COMPLEX)
     error (_("Types of arguments for CMPLX called with more then one argument "
 	     "must be REAL or INTEGER"));
 
@@ -1005,7 +1005,7 @@ eval_op_f_kind (struct type *expect_type, struct expression *exp,
 		enum exp_opcode opcode,
 		struct value *arg1)
 {
-  struct type *type = value_type (arg1);
+  struct type *type = arg1->type ();
 
   switch (type->code ())
     {
@@ -1030,7 +1030,7 @@ eval_op_f_allocated (struct type *expect_type, struct expression *exp,
 		     enum noside noside, enum exp_opcode op,
 		     struct value *arg1)
 {
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
   if (type->code () != TYPE_CODE_ARRAY)
     error (_("ALLOCATED can only be applied to arrays"));
   struct type *result_type
@@ -1052,7 +1052,7 @@ eval_op_f_rank (struct type *expect_type,
 
   struct type *result_type
     = builtin_f_type (exp->gdbarch)->builtin_integer;
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
   if (type->code () != TYPE_CODE_ARRAY)
     return value_from_longest (result_type, 0);
   LONGEST ndim = calc_f77_array_dims (type);
@@ -1092,7 +1092,7 @@ fortran_undetermined::value_subarray (value *array,
 				      struct expression *exp,
 				      enum noside noside)
 {
-  type *original_array_type = check_typedef (value_type (array));
+  type *original_array_type = check_typedef (array->type ());
   bool is_string_p = original_array_type->code () == TYPE_CODE_STRING;
   const std::vector<operation_up> &ops = std::get<1> (m_storage);
   int nargs = ops.size ();
@@ -1443,7 +1443,7 @@ fortran_undetermined::value_subarray (value *array,
       struct value *dest = allocate_value (repacked_array_type);
       if (value_lazy (array)
 	  || (total_offset + array_slice_type->length ()
-	      > check_typedef (value_type (array))->length ()))
+	      > check_typedef (array->type ())->length ()))
 	{
 	  fortran_array_walker<fortran_lazy_array_repacker_impl> p
 	    (array_slice_type, value_address (array) + total_offset, dest);
@@ -1468,7 +1468,7 @@ fortran_undetermined::value_subarray (value *array,
 	     contents we're looking for exist.  */
 	  if (value_lazy (array)
 	      || (total_offset + array_slice_type->length ()
-		  > check_typedef (value_type (array))->length ()))
+		  > check_typedef (array->type ())->length ()))
 	    array = value_at_lazy (array_slice_type,
 				   value_address (array) + total_offset);
 	  else
@@ -1492,9 +1492,9 @@ fortran_undetermined::evaluate (struct type *expect_type,
 {
   value *callee = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
   if (noside == EVAL_AVOID_SIDE_EFFECTS
-      && is_dynamic_type (value_type (callee)))
+      && is_dynamic_type (callee->type ()))
     callee = std::get<0> (m_storage)->evaluate (nullptr, exp, EVAL_NORMAL);
-  struct type *type = check_typedef (value_type (callee));
+  struct type *type = check_typedef (callee->type ());
   enum type_code code = type->code ();
 
   if (code == TYPE_CODE_PTR)
@@ -1510,7 +1510,7 @@ fortran_undetermined::evaluate (struct type *expect_type,
 	  || target_type->code () == TYPE_CODE_FUNC)
 	{
 	  callee = value_ind (callee);
-	  type = check_typedef (value_type (callee));
+	  type = check_typedef (callee->type ());
 	  code = type->code ();
 	}
     }
@@ -1534,7 +1534,7 @@ fortran_undetermined::evaluate (struct type *expect_type,
 	for (int tem = 0; tem < argvec.size (); tem++)
 	  argvec[tem] = fortran_prepare_argument (exp, actual[tem].get (),
 						  tem, is_internal_func,
-						  value_type (callee),
+						  callee->type (),
 						  noside);
 	return evaluate_subexp_do_call (exp, noside, callee, argvec,
 					nullptr, expect_type);
@@ -1552,7 +1552,7 @@ fortran_bound_1arg::evaluate (struct type *expect_type,
 {
   bool lbound_p = std::get<0> (m_storage) == FORTRAN_LBOUND;
   value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
-  fortran_require_array (value_type (arg1), lbound_p);
+  fortran_require_array (arg1->type (), lbound_p);
   return fortran_bounds_all_dims (lbound_p, exp->gdbarch, arg1);
 }
 
@@ -1563,11 +1563,11 @@ fortran_bound_2arg::evaluate (struct type *expect_type,
 {
   bool lbound_p = std::get<0> (m_storage) == FORTRAN_LBOUND;
   value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
-  fortran_require_array (value_type (arg1), lbound_p);
+  fortran_require_array (arg1->type (), lbound_p);
 
   /* User asked for the bounds of a specific dimension of the array.  */
   value *arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
-  type *type_arg2 = check_typedef (value_type (arg2));
+  type *type_arg2 = check_typedef (arg2->type ());
   if (type_arg2->code () != TYPE_CODE_INT)
     {
       if (lbound_p)
@@ -1587,11 +1587,11 @@ fortran_bound_3arg::evaluate (type *expect_type,
 {
   const bool lbound_p = std::get<0> (m_storage) == FORTRAN_LBOUND;
   value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
-  fortran_require_array (value_type (arg1), lbound_p);
+  fortran_require_array (arg1->type (), lbound_p);
 
   /* User asked for the bounds of a specific dimension of the array.  */
   value *arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
-  type *type_arg2 = check_typedef (value_type (arg2));
+  type *type_arg2 = check_typedef (arg2->type ());
   if (type_arg2->code () != TYPE_CODE_INT)
     {
       if (lbound_p)
@@ -1618,7 +1618,7 @@ fortran_structop_operation::evaluate (struct type *expect_type,
   const char *str = std::get<1> (m_storage).c_str ();
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      struct type *type = lookup_struct_elt_type (value_type (arg1), str, 1);
+      struct type *type = lookup_struct_elt_type (arg1->type (), str, 1);
 
       if (type != nullptr && is_dynamic_type (type))
 	arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, EVAL_NORMAL);
@@ -1628,7 +1628,7 @@ fortran_structop_operation::evaluate (struct type *expect_type,
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      struct type *elt_type = value_type (elt);
+      struct type *elt_type = elt->type ();
       if (is_dynamic_type (elt_type))
 	{
 	  const gdb_byte *valaddr = value_contents_for_printing (elt).data ();
@@ -1874,7 +1874,7 @@ fortran_argument_convert (struct value *value, bool is_artificial)
 	 convenience variables and user input.  */
       if (VALUE_LVAL (value) != lval_memory)
 	{
-	  struct type *type = value_type (value);
+	  struct type *type = value->type ();
 	  const int length = type->length ();
 	  const CORE_ADDR addr
 	    = value_as_long (value_allocate_space_in_inferior (length));
@@ -1953,8 +1953,8 @@ fortran_prepare_argument (struct expression *exp,
 struct type *
 fortran_preserve_arg_pointer (struct value *arg, struct type *type)
 {
-  if (value_type (arg)->code () == TYPE_CODE_PTR)
-    return value_type (arg);
+  if (arg->type ()->code () == TYPE_CODE_PTR)
+    return arg->type ();
   return type;
 }
 
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 55dbcc8309f..1be6294fadb 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -432,7 +432,7 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
 			       int recurse,
 			       const struct value_print_options *options) const
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   struct gdbarch *gdbarch = type->arch ();
   int printed_field = 0; /* Number of fields printed.  */
   struct type *elttype;
diff --git a/gdb/findcmd.c b/gdb/findcmd.c
index 637d3fdfaf9..42604b1e85e 100644
--- a/gdb/findcmd.c
+++ b/gdb/findcmd.c
@@ -162,7 +162,7 @@ parse_find_args (const char *args, ULONGEST *max_countp,
       s = skip_spaces (s);
 
       v = parse_to_comma_and_eval (&s);
-      t = value_type (v);
+      t = v->type ();
 
       if (size != '\0')
 	{
diff --git a/gdb/findvar.c b/gdb/findvar.c
index 02d498d8c58..6683bf761ad 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -844,7 +844,7 @@ read_frame_register_value (struct value *value, frame_info_ptr frame)
   LONGEST offset = 0;
   LONGEST reg_offset = value_offset (value);
   int regnum = VALUE_REGNUM (value);
-  int len = type_length_units (check_typedef (value_type (value)));
+  int len = type_length_units (check_typedef (value->type ()));
 
   gdb_assert (VALUE_LVAL (value) == lval_register);
 
@@ -859,7 +859,7 @@ read_frame_register_value (struct value *value, frame_info_ptr frame)
   while (len > 0)
     {
       struct value *regval = get_frame_register_value (frame, regnum);
-      int reg_len = type_length_units (value_type (regval)) - reg_offset;
+      int reg_len = type_length_units (regval->type ()) - reg_offset;
 
       /* If the register length is larger than the number of bytes
 	 remaining to copy, then only copy the appropriate bytes.  */
diff --git a/gdb/frame.c b/gdb/frame.c
index c69a3ea0cb0..61a79231d7a 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -1202,9 +1202,9 @@ frame_register_unwind (frame_info_ptr next_frame, int regnum,
     {
       if (!*optimizedp && !*unavailablep)
 	memcpy (bufferp, value_contents_all (value).data (),
-		value_type (value)->length ());
+		value->type ()->length ());
       else
-	memset (bufferp, 0, value_type (value)->length ());
+	memset (bufferp, 0, value->type ()->length ());
     }
 
   /* Dispose of the new value.  This prevents watchpoints from
diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index 1a709b917c3..0922a8e3afe 100644
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -1211,7 +1211,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   stack_space = 0;
   for (argnum = 0; argnum < nargs; ++argnum)
-    stack_space += align_up (value_type (args[argnum])->length (), 4);
+    stack_space += align_up (args[argnum]->type ()->length (), 4);
 
   stack_space -= (6 * 4);
   if (stack_space > 0)
@@ -1231,7 +1231,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (argnum = 0; argnum < nargs; ++argnum)
     {
       arg = args[argnum];
-      arg_type = check_typedef (value_type (arg));
+      arg_type = check_typedef (arg->type ());
       len = arg_type->length ();
       typecode = arg_type->code ();
 
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 45751c9c895..b14f051c013 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -4006,7 +4006,7 @@ is_unique_ancestor (struct type *base, struct value *val)
 {
   int offset = -1;
 
-  return is_unique_ancestor_worker (base, value_type (val), &offset,
+  return is_unique_ancestor_worker (base, val->type (), &offset,
 				    value_contents_for_printing (val).data (),
 				    value_embedded_offset (val),
 				    value_address (val), val) == 1;
@@ -4177,7 +4177,7 @@ rank_function (gdb::array_view<type *> parms,
   size_t min_len = std::min (parms.size (), args.size ());
 
   for (size_t i = 0; i < min_len; i++)
-    bv.push_back (rank_one_type (parms[i], value_type (args[i]),
+    bv.push_back (rank_one_type (parms[i], args[i]->type (),
 				 args[i]));
 
   /* If more arguments than parameters, add dummy entries.  */
@@ -4541,7 +4541,7 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value
     case TYPE_CODE_FUNC:
       return rank_one_type (parm->target_type (), arg, NULL);
     case TYPE_CODE_INT:
-      if (value != NULL && value_type (value)->code () == TYPE_CODE_INT)
+      if (value != NULL && value->type ()->code () == TYPE_CODE_INT)
 	{
 	  if (value_as_long (value) == 0)
 	    {
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index aaed12f97ee..2a1bf31f290 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -932,7 +932,7 @@ struct type
   /* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
      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, VALUE_TYPE (X)->length () is safe.  */
+     calls check_typedef, X->type ()->length () is safe.  */
   ULONGEST length () const
   {
     return this->m_length;
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index cee45ead123..c28df183c8b 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -85,7 +85,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
 			struct type * type, int offset)
 {
   struct value *arg1 = *arg1p;
-  struct type *type1 = check_typedef (value_type (arg1));
+  struct type *type1 = check_typedef (arg1->type ());
   struct type *entry_type;
   /* First, get the virtual function table pointer.  That comes
      with a strange type, so cast it to type `pointer to long' (which
@@ -113,7 +113,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
       struct value *tmp = value_cast (context, value_addr (arg1));
 
       arg1 = value_ind (tmp);
-      type1 = check_typedef (value_type (arg1));
+      type1 = check_typedef (arg1->type ());
     }
 
   context = type1;
@@ -132,8 +132,8 @@ 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
-      && value_type (vtbl)->target_type ()->code () == TYPE_CODE_ARRAY)
+  if (vtbl->type ()->code () == TYPE_CODE_PTR
+      && vtbl->type ()->target_type ()->code () == TYPE_CODE_ARRAY)
     {
       /* Handle the case where the vtbl field points to an
 	 array of structures.  */
@@ -153,7 +153,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
       entry = value_ind (vtbl);
     }
 
-  entry_type = check_typedef (value_type (entry));
+  entry_type = check_typedef (entry->type ());
 
   if (entry_type->code () == TYPE_CODE_STRUCT)
     {
@@ -203,7 +203,7 @@ gnuv2_value_rtti_type (struct value *v, int *full, LONGEST *top, int *using_enc)
     *using_enc = 0;
 
   /* Get declared type.  */
-  known_type = value_type (v);
+  known_type = v->type ();
   known_type = check_typedef (known_type);
   /* RTTI works only or class objects.  */
   if (known_type->code () != TYPE_CODE_STRUCT)
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 6f5b87f1308..d9e0d579259 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -298,7 +298,7 @@ gnuv3_rtti_type (struct value *value,
 		 int *full_p, LONGEST *top_p, int *using_enc_p)
 {
   struct gdbarch *gdbarch;
-  struct type *values_type = check_typedef (value_type (value));
+  struct type *values_type = check_typedef (value->type ());
   struct value *vtable;
   struct minimal_symbol *vtable_symbol;
   const char *vtable_symbol_name;
@@ -389,7 +389,7 @@ gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
   struct value *vtable, *vfn;
 
   /* Every class with virtual functions must have a vtable.  */
-  vtable = gnuv3_get_vtable (gdbarch, value_type (container),
+  vtable = gnuv3_get_vtable (gdbarch, container->type (),
 			     value_as_address (value_addr (container)));
   gdb_assert (vtable != NULL);
 
@@ -419,7 +419,7 @@ gnuv3_virtual_fn_field (struct value **value_p,
 			struct fn_field *f, int j,
 			struct type *vfn_base, int offset)
 {
-  struct type *values_type = check_typedef (value_type (*value_p));
+  struct type *values_type = check_typedef ((*value_p)->type ());
   struct gdbarch *gdbarch;
 
   /* Some simple sanity checks.  */
@@ -740,10 +740,10 @@ gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
   LONGEST adjustment;
   int vbit;
 
-  self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
+  self_type = TYPE_SELF_TYPE (check_typedef (method_ptr->type ()));
   final_type = lookup_pointer_type (self_type);
 
-  method_type = check_typedef (value_type (method_ptr))->target_type ();
+  method_type = check_typedef (method_ptr->type ())->target_type ();
 
   /* Extract the pointer to member.  */
   gdbarch = self_type->arch ();
@@ -845,7 +845,7 @@ compute_vtable_size (htab_t offset_hash,
 		     struct value *value)
 {
   int i;
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
   void **slot;
   struct value_and_voffset search_vo, *current_vo;
 
@@ -902,7 +902,7 @@ print_one_vtable (struct gdbarch *gdbarch, struct value *value,
 		  struct value_print_options *opts)
 {
   int i;
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
   struct value *vtable;
   CORE_ADDR vt_addr;
 
@@ -963,11 +963,11 @@ gnuv3_print_vtable (struct value *value)
   int count;
 
   value = coerce_ref (value);
-  type = check_typedef (value_type (value));
+  type = check_typedef (value->type ());
   if (type->code () == TYPE_CODE_PTR)
     {
       value = value_ind (value);
-      type = check_typedef (value_type (value));
+      type = check_typedef (value->type ());
     }
 
   get_user_print_options (&opts);
@@ -976,7 +976,7 @@ gnuv3_print_vtable (struct value *value)
   if (opts.objectprint)
     {
       value = value_full_object (value, NULL, 0, 0, 0);
-      type = check_typedef (value_type (value));
+      type = check_typedef (value->type ());
     }
 
   gdbarch = type->arch ();
@@ -1105,7 +1105,7 @@ gnuv3_get_typeid (struct value *value)
   if (value_lval_const (value) == lval_memory)
     value = coerce_ref (value);
 
-  type = check_typedef (value_type (value));
+  type = check_typedef (value->type ());
 
   /* In the non_lvalue case, a reference might have slipped through
      here.  */
@@ -1168,7 +1168,7 @@ gnuv3_get_typeid (struct value *value)
 static std::string
 gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
 {
-  struct gdbarch *gdbarch = value_type (type_info_ptr)->arch ();
+  struct gdbarch *gdbarch = type_info_ptr->type ()->arch ();
   struct bound_minimal_symbol typeinfo_sym;
   CORE_ADDR addr;
   const char *symname;
@@ -1209,7 +1209,7 @@ gnuv3_get_type_from_type_info (struct value *type_info_ptr)
   std::string type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
   expression_up expr (parse_expression (type_name.c_str ()));
   struct value *type_val = evaluate_type (expr.get ());
-  return value_type (type_val);
+  return type_val->type ();
 }
 
 /* Determine if we are currently in a C++ thunk.  If so, get the address
diff --git a/gdb/go-valprint.c b/gdb/go-valprint.c
index 5ded53ec633..4d3185ed7d2 100644
--- a/gdb/go-valprint.c
+++ b/gdb/go-valprint.c
@@ -91,7 +91,7 @@ go_language::value_print_inner (struct value *val, struct ui_file *stream,
 				int recurse,
 				const struct value_print_options *options) const
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   switch (type->code ())
     {
diff --git a/gdb/guile/scm-math.c b/gdb/guile/scm-math.c
index 26019b4df3f..af472c1aff3 100644
--- a/gdb/guile/scm-math.c
+++ b/gdb/guile/scm-math.c
@@ -109,7 +109,7 @@ vlscm_unop_gdbthrow (enum valscm_unary_opcode opcode, SCM x,
       res_val = arg1;
       break;
     case VALSCM_ABS:
-      if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
+      if (value_less (arg1, value_zero (arg1->type (), not_lval)))
 	res_val = value_neg (arg1);
       else
 	res_val = arg1;
@@ -160,8 +160,8 @@ vlscm_binop_gdbthrow (enum valscm_binary_opcode opcode, SCM x, SCM y,
     {
     case VALSCM_ADD:
       {
-	struct type *ltype = value_type (arg1);
-	struct type *rtype = value_type (arg2);
+	struct type *ltype = arg1->type ();
+	struct type *rtype = arg2->type ();
 
 	ltype = check_typedef (ltype);
 	ltype = STRIP_REFERENCE (ltype);
@@ -180,8 +180,8 @@ vlscm_binop_gdbthrow (enum valscm_binary_opcode opcode, SCM x, SCM y,
       break;
     case VALSCM_SUB:
       {
-	struct type *ltype = value_type (arg1);
-	struct type *rtype = value_type (arg2);
+	struct type *ltype = arg1->type ();
+	struct type *rtype = arg2->type ();
 
 	ltype = check_typedef (ltype);
 	ltype = STRIP_REFERENCE (ltype);
diff --git a/gdb/guile/scm-pretty-print.c b/gdb/guile/scm-pretty-print.c
index cb6677c8831..3e93f3523be 100644
--- a/gdb/guile/scm-pretty-print.c
+++ b/gdb/guile/scm-pretty-print.c
@@ -956,7 +956,7 @@ gdbscm_apply_val_pretty_printer (const struct extension_language_defn *extlang,
 				 const struct value_print_options *options,
 				 const struct language_defn *language)
 {
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   struct gdbarch *gdbarch = type->arch ();
   SCM exception = SCM_BOOL_F;
   SCM printer = SCM_BOOL_F;
diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c
index b9948303bc1..0d9e15a7404 100644
--- a/gdb/guile/scm-value.c
+++ b/gdb/guile/scm-value.c
@@ -470,7 +470,7 @@ gdbscm_value_referenced_value (SCM self)
 
       struct value *res_val;
 
-      switch (check_typedef (value_type (value))->code ())
+      switch (check_typedef (value->type ())->code ())
 	{
 	case TYPE_CODE_PTR:
 	  res_val = value_ind (value);
@@ -548,7 +548,7 @@ gdbscm_value_type (SCM self)
   struct value *value = v_smob->value;
 
   if (SCM_UNBNDP (v_smob->type))
-    v_smob->type = tyscm_scm_from_type (value_type (value));
+    v_smob->type = tyscm_scm_from_type (value->type ());
 
   return v_smob->type;
 }
@@ -571,7 +571,7 @@ gdbscm_value_dynamic_type (SCM self)
     {
       scoped_value_mark free_values;
 
-      type = value_type (value);
+      type = value->type ();
       type = check_typedef (type);
 
       if (((type->code () == TYPE_CODE_PTR)
@@ -710,7 +710,7 @@ gdbscm_value_subscript (SCM self, SCM index_scm)
   value_smob *v_smob
     = vlscm_get_value_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
   struct value *value = v_smob->value;
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
 
   SCM_ASSERT (type != NULL, self, SCM_ARG2, FUNC_NAME);
 
@@ -732,7 +732,7 @@ gdbscm_value_subscript (SCM self, SCM index_scm)
 	 Check the value's type is something that can be accessed via
 	 a subscript.  */
       struct value *tmp = coerce_ref (value);
-      struct type *tmp_type = check_typedef (value_type (tmp));
+      struct type *tmp_type = check_typedef (tmp->type ());
       if (tmp_type->code () != TYPE_CODE_ARRAY
 	  && tmp_type->code () != TYPE_CODE_PTR)
 	error (_("Cannot subscript requested type"));
@@ -758,7 +758,7 @@ gdbscm_value_call (SCM self, SCM args)
   gdbscm_gdb_exception exc {};
   try
     {
-      ftype = check_typedef (value_type (function));
+      ftype = check_typedef (function->type ());
     }
   catch (const gdb_exception &except)
     {
@@ -821,7 +821,7 @@ gdbscm_value_to_bytevector (SCM self)
   const gdb_byte *contents = NULL;
   SCM bv;
 
-  type = value_type (value);
+  type = value->type ();
 
   gdbscm_gdb_exception exc {};
   try
@@ -866,7 +866,7 @@ gdbscm_value_to_bool (SCM self)
   struct type *type;
   LONGEST l = 0;
 
-  type = value_type (value);
+  type = value->type ();
 
   gdbscm_gdb_exception exc {};
   try
@@ -910,7 +910,7 @@ gdbscm_value_to_integer (SCM self)
   struct type *type;
   LONGEST l = 0;
 
-  type = value_type (value);
+  type = value->type ();
 
   gdbscm_gdb_exception exc {};
   try
@@ -958,7 +958,7 @@ gdbscm_value_to_real (SCM self)
   double d = 0;
   struct value *check = nullptr;
 
-  type = value_type (value);
+  type = value->type ();
 
   gdbscm_gdb_exception exc {};
   try
@@ -1162,7 +1162,7 @@ gdbscm_value_to_lazy_string (SCM self, SCM rest)
       struct type *type, *realtype;
       CORE_ADDR addr;
 
-      type = value_type (value);
+      type = value->type ();
       realtype = check_typedef (type);
 
       switch (realtype->code ())
diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index 0ac4608fe1e..d53b6857ba5 100644
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -632,7 +632,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Now make sure there's space on the stack for the arguments.  We
      may over-allocate a little here, but that won't hurt anything.  */
   for (argument = 0; argument < nargs; argument++)
-    stack_alloc += align_up (value_type (args[argument])->length (), wordsize);
+    stack_alloc += align_up (args[argument]->type ()->length (), wordsize);
   sp -= stack_alloc;
 
   /* Now load as many arguments as possible into registers, and push
@@ -645,7 +645,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   for (argument = 0; argument < nargs; argument++)
     {
-      struct type *type = value_type (args[argument]);
+      struct type *type = args[argument]->type ();
       int len = type->length ();
       char *contents = (char *) value_contents (args[argument]).data ();
 
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 920b872d12d..08fea0c091b 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -731,7 +731,7 @@ hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       for (i = 0; i < nargs; i++)
 	{
 	  struct value *arg = args[i];
-	  struct type *type = check_typedef (value_type (arg));
+	  struct type *type = check_typedef (arg->type ());
 	  /* The corresponding parameter that is pushed onto the
 	     stack, and [possibly] passed in a register.  */
 	  gdb_byte param_val[8];
@@ -965,7 +965,7 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (i = 0; i < nargs; i++)
     {
       struct value *arg = args[i];
-      struct type *type = value_type (arg);
+      struct type *type = arg->type ();
       int len = type->length ();
       const bfd_byte *valbuf;
       bfd_byte fptrbuf[8];
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 580664d2ce5..f8907f5c4f4 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -3389,7 +3389,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch,
       status = regcache->raw_read (fpnum, raw_buf);
       if (status != REG_VALID)
 	mark_value_bytes_unavailable (result_value, 0,
-				      value_type (result_value)->length ());
+				      result_value->type ()->length ());
       else
 	memcpy (buf, raw_buf, register_size (gdbarch, regnum));
     }
@@ -3526,7 +3526,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch,
 	  status = regcache->raw_read (gpnum, raw_buf);
 	  if (status != REG_VALID)
 	    mark_value_bytes_unavailable (result_value, 0,
-					  value_type (result_value)->length ());
+					  result_value->type ()->length ());
 	  else
 	    memcpy (buf, raw_buf, 2);
 	}
@@ -3539,7 +3539,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch,
 	  status = regcache->raw_read (gpnum % 4, raw_buf);
 	  if (status != REG_VALID)
 	    mark_value_bytes_unavailable (result_value, 0,
-					  value_type (result_value)->length ());
+					  result_value->type ()->length ());
 	  else if (gpnum >= 4)
 	    memcpy (buf, raw_buf + 1, 1);
 	  else
diff --git a/gdb/i386-windows-tdep.c b/gdb/i386-windows-tdep.c
index 595c58e70f5..686004a5d32 100644
--- a/gdb/i386-windows-tdep.c
+++ b/gdb/i386-windows-tdep.c
@@ -114,7 +114,7 @@ i386_windows_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
      calling convention is used, so the 'this' pointer is passed in ECX.  */
   bool thiscall = false;
 
-  struct type *type = check_typedef (value_type (function));
+  struct type *type = check_typedef (function->type ());
   if (type->code () == TYPE_CODE_PTR)
     type = check_typedef (type->target_type ());
 
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index f446c41c411..7f09ce4b835 100644
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -3697,7 +3697,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (argno = 0; argno < nargs; argno++)
     {
       arg = args[argno];
-      type = check_typedef (value_type (arg));
+      type = check_typedef (arg->type ());
       len = type->length ();
 
       if ((nslots & 1) && slot_alignment_is_next_even (type))
@@ -3740,7 +3740,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       struct type *float_elt_type;
 
       arg = args[argno];
-      type = check_typedef (value_type (arg));
+      type = check_typedef (arg->type ());
       len = type->length ();
 
       /* Special handling for function parameters.  */
diff --git a/gdb/infcall.c b/gdb/infcall.c
index 4c2a4e4f400..b58dc201aeb 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -181,7 +181,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
 		  struct type *param_type, int is_prototyped)
 {
   const struct builtin_type *builtin = builtin_type (gdbarch);
-  struct type *arg_type = check_typedef (value_type (arg));
+  struct type *arg_type = check_typedef (arg->type ());
   struct type *type
     = param_type ? check_typedef (param_type) : arg_type;
 
@@ -278,7 +278,7 @@ find_function_addr (struct value *function,
 		    struct type **retval_type,
 		    struct type **function_type)
 {
-  struct type *ftype = check_typedef (value_type (function));
+  struct type *ftype = check_typedef (function->type ());
   struct gdbarch *gdbarch = ftype->arch ();
   struct type *value_type = NULL;
   /* Initialize it just to avoid a GCC false warning.  */
@@ -972,7 +972,7 @@ call_function_by_hand_dummy (struct value *function,
 	    else
 	      {
 		gdb_assert (sp <= lastval_addr);
-		sp = lastval_addr + value_type (lastval)->length ();
+		sp = lastval_addr + lastval->type ()->length ();
 	      }
 
 	    if (gdbarch_frame_align_p (gdbarch))
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 77206fcbfe8..32d30c2a3e8 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1478,7 +1478,7 @@ get_return_value (struct symbol *func_symbol, struct value *function)
     = check_typedef (func_symbol->type ()->target_type ());
   gdb_assert (value_type->code () != TYPE_CODE_VOID);
 
-  if (is_nocall_function (check_typedef (::value_type (function))))
+  if (is_nocall_function (check_typedef (function->type ())))
     {
       warning (_("Function '%s' does not follow the target calling "
 		 "convention, cannot determine its returned value."),
@@ -2158,7 +2158,7 @@ default_print_one_register_info (struct ui_file *file,
 				 const char *name,
 				 struct value *val)
 {
-  struct type *regtype = value_type (val);
+  struct type *regtype = val->type ();
   int print_raw_format;
   string_file format_stream;
   enum tab_stops
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 87ab73c47a4..9e81f83134a 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -9145,9 +9145,9 @@ siginfo_value_read (struct value *v)
 		 nullptr,
 		 value_contents_all_raw (v).data (),
 		 value_offset (v),
-		 value_type (v)->length ());
+		 v->type ()->length ());
 
-  if (transferred != value_type (v)->length ())
+  if (transferred != v->type ()->length ())
     error (_("Unable to read siginfo"));
 }
 
@@ -9168,9 +9168,9 @@ siginfo_value_write (struct value *v, struct value *fromval)
 			      nullptr,
 			      value_contents_all_raw (fromval).data (),
 			      value_offset (v),
-			      value_type (fromval)->length ());
+			      fromval->type ()->length ());
 
-  if (transferred != value_type (fromval)->length ())
+  if (transferred != fromval->type ()->length ())
     error (_("Unable to write siginfo"));
 }
 
diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
index b80ee61e437..f2af69e46cd 100644
--- a/gdb/iq2000-tdep.c
+++ b/gdb/iq2000-tdep.c
@@ -643,7 +643,7 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
        i < nargs;
        i++)
     {
-      type = value_type (args[i]);
+      type = args[i]->type ();
       typelen = type->length ();
       if (typelen <= 4)
 	{
@@ -709,7 +709,7 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   for (i = 0; i < nargs; i++)
     {
-      type = value_type (args[i]);
+      type = args[i]->type ();
       typelen = type->length ();
       val = value_contents (args[i]).data ();
       if (typelen <= 4)
diff --git a/gdb/linespec.c b/gdb/linespec.c
index d3def7ae070..7761feff8d4 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -4081,7 +4081,7 @@ linespec_parse_variable (struct linespec_state *self, const char *variable)
       sscanf ((variable[1] == '$') ? variable + 2 : variable + 1, "%d", &index);
       val_history
 	= access_value_history ((variable[1] == '$') ? -index : index);
-      if (value_type (val_history)->code () != TYPE_CODE_INT)
+      if (val_history->type ()->code () != TYPE_CODE_INT)
 	error (_("History values used in line "
 		 "specs must have integer values."));
       offset.offset = value_as_long (val_history);
diff --git a/gdb/lm32-tdep.c b/gdb/lm32-tdep.c
index 5b69bd06a19..93e2ad940b5 100644
--- a/gdb/lm32-tdep.c
+++ b/gdb/lm32-tdep.c
@@ -238,7 +238,7 @@ lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (i = 0; i < nargs; i++)
     {
       struct value *arg = args[i];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       gdb_byte *contents;
       ULONGEST val;
 
diff --git a/gdb/loongarch-tdep.c b/gdb/loongarch-tdep.c
index 10bbed35585..f40a7b4912e 100644
--- a/gdb/loongarch-tdep.c
+++ b/gdb/loongarch-tdep.c
@@ -566,11 +566,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
     {
       struct value *arg = args[i];
       const gdb_byte *val = value_contents (arg).data ();
-      struct type *type = check_typedef (value_type (arg));
+      struct type *type = check_typedef (arg->type ());
       size_t len = type->length ();
       int align = type_align (type);
       enum type_code code = type->code ();
-      struct type *func_type = check_typedef (value_type (function));
+      struct type *func_type = check_typedef (function->type ());
       bool varargs = (func_type->has_varargs () && i >= func_type->num_fields ());
 
       switch (code)
diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c
index fe02c45fba5..42af96d96f2 100644
--- a/gdb/m2-lang.c
+++ b/gdb/m2-lang.c
@@ -42,7 +42,7 @@ eval_op_m2_high (struct type *expect_type, struct expression *exp,
   else
     {
       arg1 = coerce_ref (arg1);
-      struct type *type = check_typedef (value_type (arg1));
+      struct type *type = check_typedef (arg1->type ());
 
       if (m2_is_unbounded_array (type))
 	{
@@ -54,7 +54,7 @@ eval_op_m2_high (struct type *expect_type, struct expression *exp,
 				   _("unbounded structure "
 				     "missing _m2_high field"));
 
-	  if (value_type (arg1) != type)
+	  if (arg1->type () != type)
 	    arg1 = value_cast (type, arg1);
 	}
     }
@@ -73,7 +73,7 @@ eval_op_m2_subscript (struct type *expect_type, struct expression *exp,
      then report this as an error.  */
 
   arg1 = coerce_ref (arg1);
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
 
   if (m2_is_unbounded_array (type))
     {
@@ -87,10 +87,10 @@ eval_op_m2_subscript (struct type *expect_type, struct expression *exp,
 			       _("unbounded structure "
 				 "missing _m2_contents field"));
 	  
-      if (value_type (arg1) != type)
+      if (arg1->type () != type)
 	arg1 = value_cast (type, arg1);
 
-      check_typedef (value_type (arg1));
+      check_typedef (arg1->type ());
       return value_ind (value_ptradd (arg1, value_as_long (arg2)));
     }
   else
diff --git a/gdb/m2-valprint.c b/gdb/m2-valprint.c
index e4335c188aa..c7187986aeb 100644
--- a/gdb/m2-valprint.c
+++ b/gdb/m2-valprint.c
@@ -164,7 +164,7 @@ m2_print_unbounded_array (struct value *value,
   LONGEST len;
   struct value *val;
 
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
   const gdb_byte *valaddr = value_contents_for_printing (value).data ();
 
   addr = unpack_pointer (type->field (0).type (),
@@ -260,7 +260,7 @@ m2_print_array_contents (struct value *val,
 			 const struct value_print_options *options,
 			 int len)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   if (type->length () > 0)
     {
@@ -308,7 +308,7 @@ m2_language::value_print_inner (struct value *val, struct ui_file *stream,
   const gdb_byte *valaddr = value_contents_for_printing (val).data ();
   const CORE_ADDR address = value_address (val);
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   switch (type->code ())
     {
     case TYPE_CODE_ARRAY:
diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index c2c37145de8..23add82ae90 100644
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -2029,7 +2029,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   int num_prototyped_args = 0;
 
   {
-    struct type *func_type = value_type (function);
+    struct type *func_type = function->type ();
 
     /* Dereference function pointer types.  */
     if (func_type->code () == TYPE_CODE_PTR)
@@ -2062,7 +2062,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       struct value *arg = args[i];
       const gdb_byte *arg_bits = value_contents (arg).data ();
-      struct type *arg_type = value_type (arg);
+      struct type *arg_type = arg->type ();
       ULONGEST arg_size = arg_type->length ();
 
       /* Can it go in r1 or r1l (for m16c) or r0 or r0l (for m32c)?  */
diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
index fb1dc661867..ceab11da67f 100644
--- a/gdb/m32r-tdep.c
+++ b/gdb/m32r-tdep.c
@@ -682,12 +682,12 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Now make sure there's space on the stack.  */
   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
-    stack_alloc += ((value_type (args[argnum])->length () + 3) & ~3);
+    stack_alloc += ((args[argnum]->type ()->length () + 3) & ~3);
   sp -= stack_alloc;		/* Make room on stack for args.  */
 
   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
     {
-      type = value_type (args[argnum]);
+      type = args[argnum]->type ();
       typecode = type->code ();
       len = type->length ();
 
diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index 6625506cc4a..86af4521edd 100644
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -1170,7 +1170,7 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     regcache_cooked_write_unsigned (regcache, HARD_D_REGNUM, struct_addr);
   else if (nargs > 0)
     {
-      type = value_type (args[0]);
+      type = args[0]->type ();
 
       /* First argument is passed in D and X registers.  */
       if (type->length () <= 4)
@@ -1192,7 +1192,7 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   for (argnum = nargs - 1; argnum >= first_stack_argnum; argnum--)
     {
-      type = value_type (args[argnum]);
+      type = args[argnum]->type ();
 
       if (type->length () & 1)
 	{
diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c
index 2b3f6424012..c70699d1c3d 100644
--- a/gdb/mep-tdep.c
+++ b/gdb/mep-tdep.c
@@ -2228,7 +2228,7 @@ push_large_arguments (CORE_ADDR sp, int argc, struct value **argv,
 
   for (i = 0; i < argc; i++)
     {
-      unsigned arg_len = value_type (argv[i])->length ();
+      unsigned arg_len = argv[i]->type ()->length ();
 
       if (arg_len > MEP_GPR_SIZE)
 	{
@@ -2288,9 +2288,9 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       ULONGEST value;
 
       /* Arguments that fit in a GPR get expanded to fill the GPR.  */
-      if (value_type (argv[i])->length () <= MEP_GPR_SIZE)
+      if (argv[i]->type ()->length () <= MEP_GPR_SIZE)
 	value = extract_unsigned_integer (value_contents (argv[i]).data (),
-					  value_type (argv[i])->length (),
+					  argv[i]->type ()->length (),
 					  byte_order);
 
       /* Arguments too large to fit in a GPR get copied to the stack,
diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c
index 4666808a9c9..0ac4d6a63cc 100644
--- a/gdb/mi/mi-cmd-stack.c
+++ b/gdb/mi/mi-cmd-stack.c
@@ -505,10 +505,10 @@ list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
 	  /* A scalar object that does not have all bits available is
 	     also considered unavailable, because all bits contribute
 	     to its representation.  */
-	  || (val_print_scalar_type_p (value_type (arg->val))
+	  || (val_print_scalar_type_p (arg->val->type ())
 	      && !value_bytes_available (arg->val,
 					 value_embedded_offset (arg->val),
-					 value_type (arg->val)->length ()))))
+					 arg->val->type ()->length ()))))
     return;
 
   gdb::optional<ui_out_emit_tuple> tuple_emitter;
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index e0cade2edc3..609872455ff 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -2474,8 +2474,8 @@ print_variable_or_computed (const char *expression, enum print_values values)
   switch (values)
     {
     case PRINT_SIMPLE_VALUES:
-      type = check_typedef (value_type (val));
-      type_print (value_type (val), "", &stb, -1);
+      type = check_typedef (val->type ());
+      type_print (val->type (), "", &stb, -1);
       uiout->field_stream ("type", stb);
       if (type->code () != TYPE_CODE_ARRAY
 	  && type->code () != TYPE_CODE_STRUCT
diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 6088587edbf..38ec39d4cc1 100644
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -4553,7 +4553,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
      than necessary for EABI, because the first few arguments are
      passed in registers, but that's OK.  */
   for (argnum = 0; argnum < nargs; argnum++)
-    arg_space += align_up (value_type (args[argnum])->length (),
+    arg_space += align_up (args[argnum]->type ()->length (),
 			   abi_regsize);
   sp -= align_up (arg_space, 16);
 
@@ -4588,7 +4588,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	 reference.  */
       gdb_byte ref_valbuf[MAX_MIPS_ABI_REGSIZE];
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
@@ -4947,7 +4947,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Now make space on the stack for the args.  */
   for (argnum = 0; argnum < nargs; argnum++)
-    arg_space += align_up (value_type (args[argnum])->length (),
+    arg_space += align_up (args[argnum]->type ()->length (),
 			   MIPS64_REGSIZE);
   sp -= align_up (arg_space, 16);
 
@@ -4979,7 +4979,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       const gdb_byte *val;
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
@@ -5420,7 +5420,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Now make space on the stack for the args.  */
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      struct type *arg_type = check_typedef (value_type (args[argnum]));
+      struct type *arg_type = check_typedef (args[argnum]->type ());
 
       /* Align to double-word if necessary.  */
       if (mips_type_needs_double_align (arg_type))
@@ -5459,7 +5459,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       const gdb_byte *val;
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
@@ -5944,7 +5944,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Now make space on the stack for the args.  */
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      struct type *arg_type = check_typedef (value_type (args[argnum]));
+      struct type *arg_type = check_typedef (args[argnum]->type ());
 
       /* Allocate space on the stack.  */
       arg_space += align_up (arg_type->length (), MIPS64_REGSIZE);
@@ -5980,7 +5980,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       const gdb_byte *val;
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
index fa43e8b9851..ac2b4a7ef71 100644
--- a/gdb/mn10300-tdep.c
+++ b/gdb/mn10300-tdep.c
@@ -1181,7 +1181,7 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
   regs_used = (return_method == return_method_struct) ? 1 : 0;
   for (len = 0, argnum = 0; argnum < nargs; argnum++)
     {
-      arg_len = (value_type (args[argnum])->length () + 3) & ~3;
+      arg_len = (args[argnum]->type ()->length () + 3) & ~3;
       while (regs_used < 2 && arg_len > 0)
 	{
 	  regs_used++;
@@ -1205,8 +1205,8 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
   for (argnum = 0; argnum < nargs; argnum++)
     {
       /* FIXME what about structs?  Unions?  */
-      if (value_type (*args)->code () == TYPE_CODE_STRUCT
-	  && value_type (*args)->length () > 8)
+      if ((*args)->type ()->code () == TYPE_CODE_STRUCT
+	  && (*args)->type ()->length () > 8)
 	{
 	  /* Change to pointer-to-type.  */
 	  arg_len = push_size;
@@ -1217,7 +1217,7 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
 	}
       else
 	{
-	  arg_len = value_type (*args)->length ();
+	  arg_len = (*args)->type ()->length ();
 	  val = value_contents (*args).data ();
 	}
 
diff --git a/gdb/msp430-tdep.c b/gdb/msp430-tdep.c
index 051299078c5..30a28d087d9 100644
--- a/gdb/msp430-tdep.c
+++ b/gdb/msp430-tdep.c
@@ -656,7 +656,7 @@ msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   msp430_gdbarch_tdep *tdep = gdbarch_tdep<msp430_gdbarch_tdep> (gdbarch);
   int code_model = tdep->code_model;
 
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
 
   /* Dereference function pointer types.  */
   while (func_type->code () == TYPE_CODE_PTR)
@@ -690,7 +690,7 @@ msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	{
 	  struct value *arg = args[i];
 	  const gdb_byte *arg_bits = value_contents_all (arg).data ();
-	  struct type *arg_type = check_typedef (value_type (arg));
+	  struct type *arg_type = check_typedef (arg->type ());
 	  ULONGEST arg_size = arg_type->length ();
 	  int offset;
 	  int current_arg_on_stack;
diff --git a/gdb/nds32-tdep.c b/gdb/nds32-tdep.c
index ede1a188fb5..858b72c2509 100644
--- a/gdb/nds32-tdep.c
+++ b/gdb/nds32-tdep.c
@@ -1422,7 +1422,7 @@ nds32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   ULONGEST regval;
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   nds32_gdbarch_tdep *tdep = gdbarch_tdep<nds32_gdbarch_tdep> (gdbarch);
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
   int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
   int abi_split = nds32_abi_split (tdep->elf_abi);
 
@@ -1442,7 +1442,7 @@ nds32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Now make sure there's space on the stack */
   for (i = 0; i < nargs; i++)
     {
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int align = type_align (type);
 
       /* If align is zero, it may be an empty struct.
@@ -1466,7 +1466,7 @@ nds32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       int calling_use_fpr;
       int use_fpr = 0;
 
-      type = value_type (args[i]);
+      type = args[i]->type ();
       calling_use_fpr = nds32_check_calling_use_fpr (type);
       len = type->length ();
       align = type_align (type);
diff --git a/gdb/nios2-tdep.c b/gdb/nios2-tdep.c
index de61c9c2370..e7ec4552827 100644
--- a/gdb/nios2-tdep.c
+++ b/gdb/nios2-tdep.c
@@ -1818,7 +1818,7 @@ nios2_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Now make space on the stack for the args.  */
   for (argnum = 0; argnum < nargs; argnum++)
-    arg_space += align_up (value_type (args[argnum])->length (), 4);
+    arg_space += align_up (args[argnum]->type ()->length (), 4);
   sp -= arg_space;
 
   /* Initialize the register pointer.  */
@@ -1836,7 +1836,7 @@ nios2_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       const gdb_byte *val;
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
 
       val = value_contents (arg).data ();
diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 0052c560dff..f66489bec0f 100644
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -120,8 +120,8 @@ static void
 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 = check_typedef (value_type (c->val))->target_type ();
+  struct type *type = check_typedef (v->type ());
+  struct type *eltype = check_typedef (c->val->type ())->target_type ();
   LONGEST offset = value_offset (v);
   LONGEST elsize = eltype->length ();
   int n, i, j = 0;
@@ -150,8 +150,8 @@ lval_func_write (struct value *v, struct value *fromval)
   scoped_value_mark mark;
 
   struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
-  struct type *type = check_typedef (value_type (v));
-  struct type *eltype = check_typedef (value_type (c->val))->target_type ();
+  struct type *type = check_typedef (v->type ());
+  struct type *eltype = check_typedef (c->val->type ())->target_type ();
   LONGEST offset = value_offset (v);
   LONGEST elsize = eltype->length ();
   int n, i, j = 0;
@@ -197,7 +197,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 =
-      check_typedef (value_type (c->val))->target_type ()->length () * 8;
+    check_typedef (c->val->type ())->target_type ()->length () * 8;
   int startrest = offset % elsize;
   int start = offset / elsize;
   int endrest = (offset + length) % elsize;
@@ -269,7 +269,7 @@ static struct value *
 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 *type = check_typedef (val->type ());
   struct type *elm_type = type->target_type ();
   struct value *ret;
 
@@ -337,7 +337,7 @@ opencl_component_ref (struct expression *exp, struct value *val,
   int indices[16], i;
   int dst_len;
 
-  if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
+  if (!get_array_bounds (check_typedef (val->type ()), &lowb, &highb))
     error (_("Could not determine the vector bounds"));
 
   src_len = highb - lowb + 1;
@@ -446,7 +446,7 @@ opencl_logical_not (struct type *expect_type, struct expression *exp,
 		    enum noside noside, enum exp_opcode op,
 		    struct value *arg)
 {
-  struct type *type = check_typedef (value_type (arg));
+  struct type *type = check_typedef (arg->type ());
   struct type *rettype;
   struct value *ret;
 
@@ -537,8 +537,8 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
   int t1_is_vec, t2_is_vec, i;
   LONGEST lowb1, lowb2, highb1, highb2;
 
-  type1 = check_typedef (value_type (val1));
-  type2 = check_typedef (value_type (val2));
+  type1 = check_typedef (val1->type ());
+  type2 = check_typedef (val2->type ());
 
   t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ());
   t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ());
@@ -589,7 +589,7 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
 struct value *
 opencl_value_cast (struct type *type, struct value *arg)
 {
-  if (type != value_type (arg))
+  if (type != arg->type ())
     {
       /* Casting scalar to vector is a special case for OpenCL, scalar
 	 is cast to element type of vector then replicated into each
@@ -603,10 +603,10 @@ opencl_value_cast (struct type *type, struct value *arg)
       to_type = check_typedef (type);
 
       code1 = to_type->code ();
-      code2 = check_typedef (value_type (arg))->code ();
+      code2 = check_typedef (arg->type ())->code ();
 
       if (code2 == TYPE_CODE_REF)
-	code2 = check_typedef (value_type (coerce_ref(arg)))->code ();
+	code2 = check_typedef (coerce_ref(arg)->type ())->code ();
 
       scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL
 		|| code2 == TYPE_CODE_CHAR || code2 == TYPE_CODE_FLT
@@ -641,8 +641,8 @@ opencl_relop (struct type *expect_type, struct expression *exp,
 	      struct value *arg1, struct value *arg2)
 {
   struct value *val;
-  struct type *type1 = check_typedef (value_type (arg1));
-  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *type1 = check_typedef (arg1->type ());
+  struct type *type2 = check_typedef (arg2->type ());
   int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
 		   && type1->is_vector ());
   int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
@@ -686,7 +686,7 @@ eval_opencl_assign (struct type *expect_type, struct expression *exp,
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     return arg1;
 
-  struct type *type1 = value_type (arg1);
+  struct type *type1 = arg1->type ();
   if (deprecated_value_modifiable (arg1)
       && VALUE_LVAL (arg1) != lval_internalvar)
     arg2 = opencl_value_cast (type1, arg2);
@@ -703,7 +703,7 @@ opencl_structop_operation::evaluate (struct type *expect_type,
 				     enum noside noside)
 {
   value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
-  struct type *type1 = check_typedef (value_type (arg1));
+  struct type *type1 = check_typedef (arg1->type ());
 
   if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
     return opencl_component_ref (exp, arg1, std::get<1> (m_storage).c_str (),
@@ -715,7 +715,7 @@ opencl_structop_operation::evaluate (struct type *expect_type,
 					  NULL, "structure");
 
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
-	v = value_zero (value_type (v), VALUE_LVAL (v));
+	v = value_zero (v->type (), VALUE_LVAL (v));
       return v;
     }
 }
@@ -735,8 +735,8 @@ opencl_logical_binop_operation::evaluate (struct type *expect_type,
      Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS.  */
   value *arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp,
 						   EVAL_AVOID_SIDE_EFFECTS);
-  struct type *type1 = check_typedef (value_type (arg1));
-  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *type1 = check_typedef (arg1->type ());
+  struct type *type2 = check_typedef (arg2->type ());
 
   if ((type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
       || (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ()))
@@ -774,7 +774,7 @@ opencl_ternop_cond_operation::evaluate (struct type *expect_type,
 					enum noside noside)
 {
   value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
-  struct type *type1 = check_typedef (value_type (arg1));
+  struct type *type1 = check_typedef (arg1->type ());
   if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
     {
       struct value *arg2, *arg3, *tmp, *ret;
@@ -784,8 +784,8 @@ opencl_ternop_cond_operation::evaluate (struct type *expect_type,
 
       arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
       arg3 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
-      type2 = check_typedef (value_type (arg2));
-      type3 = check_typedef (value_type (arg3));
+      type2 = check_typedef (arg2->type ());
+      type3 = check_typedef (arg3->type ());
       t2_is_vec
 	= type2->code () == TYPE_CODE_ARRAY && type2->is_vector ();
       t3_is_vec
@@ -795,12 +795,12 @@ opencl_ternop_cond_operation::evaluate (struct type *expect_type,
       if (t2_is_vec || !t3_is_vec)
 	{
 	  arg3 = opencl_value_cast (type2, arg3);
-	  type3 = value_type (arg3);
+	  type3 = arg3->type ();
 	}
       else if (!t2_is_vec || t3_is_vec)
 	{
 	  arg2 = opencl_value_cast (type3, arg2);
-	  type2 = value_type (arg2);
+	  type2 = arg2->type ();
 	}
       else if (!t2_is_vec || !t3_is_vec)
 	{
diff --git a/gdb/or1k-tdep.c b/gdb/or1k-tdep.c
index 3616d7751ca..d8c30435cc5 100644
--- a/gdb/or1k-tdep.c
+++ b/gdb/or1k-tdep.c
@@ -637,7 +637,7 @@ or1k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   or1k_gdbarch_tdep *tdep = gdbarch_tdep<or1k_gdbarch_tdep> (gdbarch);
   int bpa = tdep->bytes_per_address;
   int bpw = tdep->bytes_per_word;
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
 
   /* Return address */
   regcache_cooked_write_unsigned (regcache, OR1K_LR_REGNUM, bp_addr);
@@ -661,7 +661,7 @@ or1k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       gdb_byte valbuf[sizeof (ULONGEST)];
 
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
@@ -751,7 +751,7 @@ or1k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (argnum = first_stack_arg; argnum < nargs; argnum++)
     {
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
@@ -783,7 +783,7 @@ or1k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       gdb_byte valbuf[sizeof (ULONGEST)];
 
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
       /* The EABI passes structures that do not fit in a register by
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index 6e03f1a5381..b5251b932ef 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -542,7 +542,7 @@ exp	:	DOLLAR_VARIABLE
 			      value *val
 				= value_of_internalvar (pstate->gdbarch (),
 							intvar);
-			      current_type = value_type (val);
+			      current_type = val->type ();
 			    }
  			}
  	;
@@ -591,7 +591,7 @@ exp	:	THIS
 			  this_val
 			    = value_of_this_silent (pstate->language ());
 			  if (this_val)
-			    this_type = value_type (this_val);
+			    this_type = this_val->type ();
 			  else
 			    this_type = NULL;
 			  if (this_type)
@@ -707,7 +707,7 @@ variable:	name_not_typename
 			      this_val
 				= value_of_this_silent (pstate->language ());
 			      if (this_val)
-				this_type = value_type (this_val);
+				this_type = this_val->type ();
 			      else
 				this_type = NULL;
 			      if (this_type)
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index 69bfeba1477..2628ebd6bf2 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -69,7 +69,7 @@ pascal_language::value_print_inner (struct value *val,
 				    const struct value_print_options *options) const
 
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   struct gdbarch *gdbarch = type->arch ();
   enum bfd_endian byte_order = type_byte_order (type);
   unsigned int i = 0;	/* Number of characters printed */
@@ -408,7 +408,7 @@ void
 pascal_language::value_print (struct value *val, struct ui_file *stream,
 			      const struct value_print_options *options) const
 {
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
   struct value_print_options opts = *options;
 
   opts.deref_ref = true;
@@ -521,7 +521,7 @@ pascal_object_print_value_fields (struct value *val, struct ui_file *stream,
   char *last_dont_print
     = (char *) obstack_next_free (&dont_print_statmem_obstack);
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   gdb_printf (stream, "{");
   len = type->num_fields ();
@@ -655,7 +655,7 @@ pascal_object_print_value_fields (struct value *val, struct ui_file *stream,
 		  opts.deref_ref = false;
 
 		  struct value *v = value_primitive_field (val, 0, i,
-							   value_type (val));
+							   val->type ());
 		  common_val_print (v, stream, recurse + 1, &opts,
 				    current_language);
 		}
@@ -692,7 +692,7 @@ pascal_object_print_value (struct value *val, struct ui_file *stream,
   struct type **last_dont_print
     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
   struct obstack tmp_obstack = dont_print_vb_obstack;
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 
   if (dont_print_vb == 0)
@@ -757,7 +757,7 @@ pascal_object_print_value (struct value *val, struct ui_file *stream,
 	      base_value = value_from_contents_and_address (baseclass,
 							    buf.data (),
 							    address + boffset);
-	      baseclass = value_type (base_value);
+	      baseclass = base_value->type ();
 	      boffset = 0;
 	    }
 	}
@@ -815,7 +815,7 @@ pascal_object_print_static_field (struct value *val,
 				  int recurse,
 				  const struct value_print_options *options)
 {
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
   struct value_print_options opts;
 
   if (value_entirely_optimized_out (val))
diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index d8a8fbdf706..cb832726ea5 100644
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c
@@ -2516,7 +2516,7 @@ ppc_linux_nat_target::check_condition (CORE_ADDR watch_addr,
 
       /* DATA_VALUE is the constant in RIGHT_VAL, but actually has
 	 the same type as the memory region referenced by LEFT_VAL.  */
-      *len = check_typedef (value_type (left_val))->length ();
+      *len = check_typedef (left_val->type ())->length ();
     }
   else if (num_accesses_left == 0 && num_accesses_right == 1
 	   && VALUE_LVAL (right_val) == lval_memory
@@ -2526,7 +2526,7 @@ ppc_linux_nat_target::check_condition (CORE_ADDR watch_addr,
 
       /* DATA_VALUE is the constant in LEFT_VAL, but actually has
 	 the same type as the memory region referenced by RIGHT_VAL.  */
-      *len = check_typedef (value_type (right_val))->length ();
+      *len = check_typedef (right_val->type ())->length ();
     }
   else
     return 0;
diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 3df56c8b75c..69cc784c558 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -69,7 +69,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 {
   ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
+  int opencl_abi = ppc_sysv_use_opencl_abi (function->type ());
   ULONGEST saved_sp;
   int argspace = 0;		/* 0 is an initial wrong guess.  */
   int write_pass;
@@ -122,7 +122,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       for (argno = 0; argno < nargs; argno++)
 	{
 	  struct value *arg = args[argno];
-	  struct type *type = check_typedef (value_type (arg));
+	  struct type *type = check_typedef (arg->type ());
 	  int len = type->length ();
 	  const bfd_byte *val = value_contents (arg).data ();
 
@@ -1013,7 +1013,7 @@ ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
 			   gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   return do_ppc_sysv_return_value (gdbarch,
-				   function ? value_type (function) : NULL,
+				   function ? function->type () : NULL,
 				   valtype, regcache, readbuf, writebuf, 0);
 }
 
@@ -1025,7 +1025,7 @@ ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch,
 				  gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   return do_ppc_sysv_return_value (gdbarch,
-				   function ? value_type (function) : NULL,
+				   function ? function->type () : NULL,
 				   valtype, regcache, readbuf, writebuf, 1);
 }
 
@@ -1606,7 +1606,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
   CORE_ADDR func_addr = find_function_addr (function, NULL);
   ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
+  int opencl_abi = ppc_sysv_use_opencl_abi (function->type ());
   ULONGEST back_chain;
   /* See for-loop comment below.  */
   int write_pass;
@@ -1691,7 +1691,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
       for (argno = 0; argno < nargs; argno++)
 	{
 	  struct value *arg = args[argno];
-	  struct type *type = check_typedef (value_type (arg));
+	  struct type *type = check_typedef (arg->type ());
 	  const bfd_byte *val = value_contents (arg).data ();
 
 	  if (type->code () == TYPE_CODE_COMPLEX)
@@ -1760,7 +1760,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
      the pointer itself identifies the descriptor.  */
   if (tdep->elf_abi == POWERPC_ELF_V1)
     {
-      struct type *ftype = check_typedef (value_type (function));
+      struct type *ftype = check_typedef (function->type ());
       CORE_ADDR desc_addr = value_as_address (function);
 
       if (ftype->code () == TYPE_CODE_PTR
@@ -1988,7 +1988,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
 			     gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
-  struct type *func_type = function ? value_type (function) : NULL;
+  struct type *func_type = function ? function->type () : NULL;
   int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0;
   struct type *eltype;
   int nelt, ok;
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 7f3551327a8..2962c7111e4 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -294,7 +294,7 @@ print_formatted (struct value *val, int size,
 		 const struct value_print_options *options,
 		 struct ui_file *stream)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   int len = type->length ();
 
   if (VALUE_LVAL (val) == lval_memory)
@@ -306,7 +306,7 @@ print_formatted (struct value *val, int size,
 	{
 	case 's':
 	  {
-	    struct type *elttype = value_type (val);
+	    struct type *elttype = val->type ();
 
 	    next_address = (value_address (val)
 			    + val_print_string (elttype, NULL,
@@ -1244,7 +1244,7 @@ print_value (value *val, const value_print_options &opts)
 {
   int histindex = record_latest_value (val);
 
-  annotate_value_history_begin (histindex, value_type (val));
+  annotate_value_history_begin (histindex, val->type ());
 
   gdb_printf ("$%d = ", histindex);
 
@@ -1261,16 +1261,16 @@ print_value (value *val, const value_print_options &opts)
 static bool
 should_validate_memtags (struct value *value)
 {
-  gdb_assert (value != nullptr && value_type (value) != nullptr);
+  gdb_assert (value != nullptr && value->type () != nullptr);
 
   if (!target_supports_memory_tagging ())
     return false;
 
-  enum type_code code = value_type (value)->code ();
+  enum type_code code = value->type ()->code ();
 
   /* Skip non-address values.  */
   if (code != TYPE_CODE_PTR
-      && !TYPE_IS_REFERENCE (value_type (value)))
+      && !TYPE_IS_REFERENCE (value->type ()))
     return false;
 
   /* OK, we have an address value.  Check we have a complete value we
@@ -1319,8 +1319,8 @@ print_command_1 (const char *args, int voidprint)
 
   struct value *val = process_print_command_args (args, &print_opts, voidprint);
 
-  if (voidprint || (val && value_type (val) &&
-		    value_type (val)->code () != TYPE_CODE_VOID))
+  if (voidprint || (val && val->type () &&
+		    val->type ()->code () != TYPE_CODE_VOID))
     {
       /* If memory tagging validation is on, check if the tag is valid.  */
       if (print_opts.memory_tag_violations)
@@ -1485,7 +1485,7 @@ output_command (const char *exp, int from_tty)
 
   val = evaluate_expression (expr.get ());
 
-  annotate_value_begin (value_type (val));
+  annotate_value_begin (val->type ());
 
   get_formatted_print_options (&opts, format);
   opts.raw = fmt.raw;
@@ -1883,11 +1883,11 @@ x_command (const char *exp, int from_tty)
       if (from_tty)
 	set_repeat_arguments ("");
       val = evaluate_expression (expr.get ());
-      if (TYPE_IS_REFERENCE (value_type (val)))
+      if (TYPE_IS_REFERENCE (val->type ()))
 	val = coerce_ref (val);
       /* In rvalue contexts, such as this, functions are coerced into
 	 pointers to functions.  This makes "x/i main" work.  */
-      if (value_type (val)->code () == TYPE_CODE_FUNC
+      if (val->type ()->code () == TYPE_CODE_FUNC
 	   && VALUE_LVAL (val) == lval_memory)
 	next_address = value_address (val);
       else
@@ -1918,7 +1918,7 @@ x_command (const char *exp, int from_tty)
       /* Make last address examined available to the user as $_.  Use
 	 the correct pointer type.  */
       struct type *pointer_type
-	= lookup_pointer_type (value_type (last_examine_value.get ()));
+	= lookup_pointer_type (last_examine_value.get ()->type ());
       set_internalvar (lookup_internalvar ("_"),
 		       value_from_pointer (pointer_type,
 					   last_examine_address));
@@ -2429,11 +2429,11 @@ printf_c_string (struct ui_file *stream, const char *format,
 {
   const gdb_byte *str;
 
-  if (value_type (value)->code () != TYPE_CODE_PTR
+  if (value->type ()->code () != TYPE_CODE_PTR
       && VALUE_LVAL (value) == lval_internalvar
-      && c_is_string_type_p (value_type (value)))
+      && c_is_string_type_p (value->type ()))
     {
-      size_t len = value_type (value)->length ();
+      size_t len = value->type ()->length ();
 
       /* Copy the internal var value to TEM_STR and append a terminating null
 	 character.  This protects against corrupted C-style strings that lack
@@ -2497,16 +2497,16 @@ printf_wide_c_string (struct ui_file *stream, const char *format,
 {
   const gdb_byte *str;
   size_t len;
-  struct gdbarch *gdbarch = value_type (value)->arch ();
+  struct gdbarch *gdbarch = value->type ()->arch ();
   struct type *wctype = lookup_typename (current_language,
 					 "wchar_t", NULL, 0);
   int wcwidth = wctype->length ();
 
   if (VALUE_LVAL (value) == lval_internalvar
-      && c_is_string_type_p (value_type (value)))
+      && c_is_string_type_p (value->type ()))
     {
       str = value_contents (value).data ();
-      len = value_type (value)->length ();
+      len = value->type ()->length ();
     }
   else
     {
@@ -2564,7 +2564,7 @@ printf_floating (struct ui_file *stream, const char *format,
 		 struct value *value, enum argclass argclass)
 {
   /* Parameter data.  */
-  struct type *param_type = value_type (value);
+  struct type *param_type = value->type ();
   struct gdbarch *gdbarch = param_type->arch ();
 
   /* Determine target type corresponding to the format string.  */
@@ -2613,7 +2613,7 @@ printf_floating (struct ui_file *stream, const char *format,
   if (fmt_type->code () == TYPE_CODE_FLT)
     {
       param_type = float_type_from_length (param_type);
-      if (param_type != value_type (value))
+      if (param_type != value->type ())
 	value = value_from_contents (param_type,
 				     value_contents (value).data ());
     }
@@ -2772,13 +2772,13 @@ ui_printf (const char *arg, struct ui_file *stream)
 	    break;
 	  case wide_char_arg:
 	    {
-	      struct gdbarch *gdbarch = value_type (val_args[i])->arch ();
+	      struct gdbarch *gdbarch = val_args[i]->type ()->arch ();
 	      struct type *wctype = lookup_typename (current_language,
 						     "wchar_t", NULL, 0);
 	      struct type *valtype;
 	      const gdb_byte *bytes;
 
-	      valtype = value_type (val_args[i]);
+	      valtype = val_args[i]->type ();
 	      if (valtype->length () != wctype->length ()
 		  || valtype->code () != TYPE_CODE_INT)
 		error (_("expected wchar_t argument for %%lc"));
diff --git a/gdb/python/py-framefilter.c b/gdb/python/py-framefilter.c
index 10a3adadf2f..0e8b2409636 100644
--- a/gdb/python/py-framefilter.c
+++ b/gdb/python/py-framefilter.c
@@ -206,10 +206,10 @@ mi_should_print (struct symbol *sym, enum mi_print_types type)
 static void
 py_print_type (struct ui_out *out, struct value *val)
 {
-  check_typedef (value_type (val));
+  check_typedef (val->type ());
 
   string_file stb;
-  type_print (value_type (val), "", &stb, -1);
+  type_print (val->type (), "", &stb, -1);
   out->field_stream ("type", stb);
 }
 
@@ -235,7 +235,7 @@ py_print_value (struct ui_out *out, struct value *val,
   if (args_type == MI_PRINT_SIMPLE_VALUES
       || args_type == MI_PRINT_ALL_VALUES)
     {
-      struct type *type = check_typedef (value_type (val));
+      struct type *type = check_typedef (val->type ());
 
       if (args_type == MI_PRINT_ALL_VALUES)
 	should_print = 1;
@@ -378,7 +378,7 @@ py_print_single_arg (struct ui_out *out,
     py_print_type (out, val);
 
   if (val != NULL)
-    annotate_arg_value (value_type (val));
+    annotate_arg_value (val->type ());
 
   /* If the output is to the CLI, and the user option "set print
      frame-arguments" is set to none, just output "...".  */
diff --git a/gdb/python/py-inferior.c b/gdb/python/py-inferior.c
index 9b3385c83b5..1a3dcc23aa3 100644
--- a/gdb/python/py-inferior.c
+++ b/gdb/python/py-inferior.c
@@ -715,7 +715,7 @@ infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
     {
       struct value *val = value_object_to_value (handle_obj);
       bytes = value_contents_all (val).data ();
-      bytes_len = value_type (val)->length ();
+      bytes_len = val->type ()->length ();
     }
   else
     {
diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
index 1a5ce08c477..346395e564e 100644
--- a/gdb/python/py-prettyprint.c
+++ b/gdb/python/py-prettyprint.c
@@ -574,7 +574,7 @@ gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang,
 				const struct value_print_options *options,
 				const struct language_defn *language)
 {
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   struct gdbarch *gdbarch = type->arch ();
   enum gdbpy_string_repr_result print_result;
 
diff --git a/gdb/python/py-unwind.c b/gdb/python/py-unwind.c
index e7ec660e150..442251201f2 100644
--- a/gdb/python/py-unwind.c
+++ b/gdb/python/py-unwind.c
@@ -130,7 +130,7 @@ pyuw_value_obj_to_pointer (PyObject *pyo_value, CORE_ADDR *addr)
     {
       if ((value = value_object_to_value (pyo_value)) != NULL)
 	{
-	  *addr = unpack_pointer (value_type (value),
+	  *addr = unpack_pointer (value->type (),
 				  value_contents (value).data ());
 	  rc = 1;
 	}
@@ -292,13 +292,13 @@ unwind_infopy_add_saved_register (PyObject *self, PyObject *args)
 	return NULL;
       }
     data_size = register_size (pending_frame->gdbarch, regnum);
-    if (data_size != value_type (value)->length ())
+    if (data_size != value->type ()->length ())
       {
 	PyErr_Format (
 	    PyExc_ValueError,
 	    "The value of the register returned by the Python "
 	    "sniffer has unexpected size: %u instead of %u.",
-	    (unsigned) value_type (value)->length (),
+	    (unsigned) value->type ()->length (),
 	    (unsigned) data_size);
 	return NULL;
       }
@@ -620,7 +620,7 @@ pyuw_sniffer (const struct frame_unwind *self, frame_info_ptr this_frame,
 
 	/* `value' validation was done before, just assert.  */
 	gdb_assert (value != NULL);
-	gdb_assert (data_size == value_type (value)->length ());
+	gdb_assert (data_size == value->type ()->length ());
 
 	cached_frame->reg[i].data = (gdb_byte *) xmalloc (data_size);
 	memcpy (cached_frame->reg[i].data,
diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index da2565081e6..c748a87cfc9 100644
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -272,7 +272,7 @@ valpy_referenced_value (PyObject *self, PyObject *args)
       scoped_value_mark free_values;
 
       self_val = ((value_object *) self)->value;
-      switch (check_typedef (value_type (self_val))->code ())
+      switch (check_typedef (self_val->type ())->code ())
 	{
 	case TYPE_CODE_PTR:
 	  res_val = value_ind (self_val);
@@ -391,7 +391,7 @@ valpy_get_type (PyObject *self, void *closure)
 
   if (!obj->type)
     {
-      obj->type = type_to_type_object (value_type (obj->value));
+      obj->type = type_to_type_object (obj->value->type ());
       if (!obj->type)
 	return NULL;
     }
@@ -418,7 +418,7 @@ valpy_get_dynamic_type (PyObject *self, void *closure)
       struct value *val = obj->value;
       scoped_value_mark free_values;
 
-      type = value_type (val);
+      type = val->type ();
       type = check_typedef (type);
 
       if (type->is_pointer_or_reference ()
@@ -506,7 +506,7 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
       struct type *type, *realtype;
       CORE_ADDR addr;
 
-      type = value_type (value);
+      type = value->type ();
       realtype = check_typedef (type);
 
       switch (realtype->code ())
@@ -885,7 +885,7 @@ value_has_field (struct value *v, PyObject *field)
 
   try
     {
-      val_type = value_type (v);
+      val_type = v->type ();
       val_type = check_typedef (val_type);
       if (val_type->is_pointer_or_reference ())
 	val_type = check_typedef (val_type->target_type ());
@@ -1037,7 +1037,7 @@ valpy_getitem (PyObject *self, PyObject *key)
 	{
 	  struct type *val_type;
 
-	  val_type = check_typedef (value_type (tmp));
+	  val_type = check_typedef (tmp->type ());
 	  if (val_type->code () == TYPE_CODE_PTR)
 	    res_val = value_cast (lookup_pointer_type (base_class_type), tmp);
 	  else if (val_type->code () == TYPE_CODE_REF)
@@ -1063,7 +1063,7 @@ valpy_getitem (PyObject *self, PyObject *key)
 	      struct type *type;
 
 	      tmp = coerce_ref (tmp);
-	      type = check_typedef (value_type (tmp));
+	      type = check_typedef (tmp->type ());
 	      if (type->code () != TYPE_CODE_ARRAY
 		  && type->code () != TYPE_CODE_PTR)
 		  error (_("Cannot subscript requested type."));
@@ -1106,7 +1106,7 @@ valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
 
   try
     {
-      ftype = check_typedef (value_type (function));
+      ftype = check_typedef (function->type ());
     }
   catch (const gdb_exception &except)
     {
@@ -1311,8 +1311,8 @@ valpy_binop_throw (enum valpy_opcode opcode, PyObject *self, PyObject *other)
     {
     case VALPY_ADD:
       {
-	struct type *ltype = value_type (arg1);
-	struct type *rtype = value_type (arg2);
+	struct type *ltype = arg1->type ();
+	struct type *rtype = arg2->type ();
 
 	ltype = check_typedef (ltype);
 	ltype = STRIP_REFERENCE (ltype);
@@ -1335,8 +1335,8 @@ valpy_binop_throw (enum valpy_opcode opcode, PyObject *self, PyObject *other)
       break;
     case VALPY_SUB:
       {
-	struct type *ltype = value_type (arg1);
-	struct type *rtype = value_type (arg2);
+	struct type *ltype = arg1->type ();
+	struct type *rtype = arg2->type ();
 
 	ltype = check_typedef (ltype);
 	ltype = STRIP_REFERENCE (ltype);
@@ -1506,7 +1506,7 @@ valpy_absolute (PyObject *self)
     {
       scoped_value_mark free_values;
 
-      if (value_less (value, value_zero (value_type (value), not_lval)))
+      if (value_less (value, value_zero (value->type (), not_lval)))
 	isabs = 0;
     }
   catch (const gdb_exception &except)
@@ -1531,7 +1531,7 @@ valpy_nonzero (PyObject *self)
 
   try
     {
-      type = check_typedef (value_type (self_value->value));
+      type = check_typedef (self_value->value->type ());
 
       if (is_integral_type (type) || type->code () == TYPE_CODE_PTR)
 	nonzero = !!value_as_long (self_value->value);
@@ -1712,7 +1712,7 @@ static PyObject *
 valpy_long (PyObject *self)
 {
   struct value *value = ((value_object *) self)->value;
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   LONGEST l = 0;
 
   try
@@ -1747,7 +1747,7 @@ static PyObject *
 valpy_float (PyObject *self)
 {
   struct value *value = ((value_object *) self)->value;
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   double d = 0;
 
   try
@@ -1995,7 +1995,7 @@ gdbpy_convenience_variable (PyObject *self, PyObject *args)
       if (var != NULL)
 	{
 	  res_val = value_of_internalvar (gdbpy_enter::get_gdbarch (), var);
-	  if (value_type (res_val)->code () == TYPE_CODE_VOID)
+	  if (res_val->type ()->code () == TYPE_CODE_VOID)
 	    res_val = NULL;
 	}
     }
diff --git a/gdb/python/py-xmethods.c b/gdb/python/py-xmethods.c
index d6d607d99d4..d3afd26c26e 100644
--- a/gdb/python/py-xmethods.c
+++ b/gdb/python/py-xmethods.c
@@ -423,7 +423,7 @@ python_xmethod_worker::do_get_result_type (value *obj,
       return EXT_LANG_RC_OK;
     }
 
-  obj_type = check_typedef (value_type (obj));
+  obj_type = check_typedef (obj->type ());
   this_type = check_typedef (type_object_to_type (m_this_type));
   if (obj_type->code () == TYPE_CODE_PTR)
     {
@@ -508,7 +508,7 @@ python_xmethod_worker::invoke (struct value *obj,
   struct type *obj_type, *this_type;
   struct value *res = NULL;
 
-  obj_type = check_typedef (value_type (obj));
+  obj_type = check_typedef (obj->type ());
   this_type = check_typedef (type_object_to_type (m_this_type));
   if (obj_type->code () == TYPE_CODE_PTR)
     {
diff --git a/gdb/regcache.c b/gdb/regcache.c
index 7aee1c16e2e..4de7026fc28 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -753,7 +753,7 @@ readable_regcache::cooked_read_value (int regnum)
       if (cooked_read (regnum,
 		       value_contents_raw (result).data ()) == REG_UNAVAILABLE)
 	mark_value_bytes_unavailable (result, 0,
-				      value_type (result)->length ());
+				      result->type ()->length ());
 
       return result;
     }
diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c
index 60de60382c8..d34eb56c1b6 100644
--- a/gdb/riscv-tdep.c
+++ b/gdb/riscv-tdep.c
@@ -1116,7 +1116,7 @@ riscv_print_one_register_info (struct gdbarch *gdbarch,
   try
     {
       val = value_of_register (regnum, frame);
-      regtype = value_type (val);
+      regtype = val->type ();
     }
   catch (const gdb_exception_error &ex)
     {
@@ -3047,7 +3047,7 @@ riscv_push_dummy_call (struct gdbarch *gdbarch,
 
   CORE_ADDR osp = sp;
 
-  struct type *ftype = check_typedef (value_type (function));
+  struct type *ftype = check_typedef (function->type ());
 
   if (ftype->code () == TYPE_CODE_PTR)
     ftype = check_typedef (ftype->target_type ());
@@ -3063,7 +3063,7 @@ riscv_push_dummy_call (struct gdbarch *gdbarch,
       struct riscv_arg_info *info = &arg_info[i];
 
       arg_value = args[i];
-      arg_type = check_typedef (value_type (arg_value));
+      arg_type = check_typedef (arg_value->type ());
 
       riscv_arg_location (gdbarch, info, &call_info, arg_type,
 			  ftype->has_varargs () && i >= ftype->num_fields ());
@@ -3380,7 +3380,7 @@ riscv_return_value (struct gdbarch  *gdbarch,
 		   type of ABI_VAL will differ from ARG_TYPE due to
 		   dynamic type resolution, and so will most likely
 		   fail.  */
-		arg_type = value_type (abi_val);
+		arg_type = abi_val->type ();
 	      }
 	    if (writebuf != nullptr)
 	      write_memory (addr, writebuf, info.length);
diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c
index 2c610af1613..579f85f3870 100644
--- a/gdb/rs6000-aix-tdep.c
+++ b/gdb/rs6000-aix-tdep.c
@@ -350,7 +350,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       int reg_size = register_size (gdbarch, ii + 3);
 
       arg = args[argno];
-      type = check_typedef (value_type (arg));
+      type = check_typedef (arg->type ());
       len = type->length ();
 
       if (type->code () == TYPE_CODE_FLT)
@@ -447,7 +447,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       for (; jj < nargs; ++jj)
 	{
 	  struct value *val = args[jj];
-	  space += ((value_type (val)->length ()) + 3) & -4;
+	  space += ((val->type ()->length ()) + 3) & -4;
 	}
 
       /* Add location required for the rest of the parameters.  */
@@ -480,7 +480,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	{
 
 	  arg = args[argno];
-	  type = check_typedef (value_type (arg));
+	  type = check_typedef (arg->type ());
 	  len = type->length ();
 
 
diff --git a/gdb/rs6000-lynx178-tdep.c b/gdb/rs6000-lynx178-tdep.c
index 042e6e60d91..4d210737535 100644
--- a/gdb/rs6000-lynx178-tdep.c
+++ b/gdb/rs6000-lynx178-tdep.c
@@ -93,7 +93,7 @@ rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
       int reg_size = register_size (gdbarch, ii + 3);
 
       arg = args[argno];
-      type = check_typedef (value_type (arg));
+      type = check_typedef (arg->type ());
       len = type->length ();
 
       if (type->code () == TYPE_CODE_FLT)
@@ -184,7 +184,7 @@ rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
 	{
 	  struct value *val = args[jj];
 
-	  space += align_up (value_type (val)->length (), 4);
+	  space += align_up (val->type ()->length (), 4);
 	}
 
       /* Add location required for the rest of the parameters.  */
@@ -217,7 +217,7 @@ rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
 	{
 
 	  arg = args[argno];
-	  type = check_typedef (value_type (arg));
+	  type = check_typedef (arg->type ());
 	  len = type->length ();
 
 
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index f2017f95211..f6e5089825c 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -244,7 +244,7 @@ rust_chartype_p (struct type *type)
 static struct value *
 rust_get_trait_object_pointer (struct value *value)
 {
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
 
   if (type->code () != TYPE_CODE_STRUCT || type->num_fields () != 2)
     return NULL;
@@ -330,23 +330,23 @@ rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
 					 "slice");
   struct value *len = value_struct_elt (&val, {}, "length", NULL, "slice");
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   if (strcmp (type->name (), "&str") == 0)
-    val_print_string (value_type (base)->target_type (), "UTF-8",
+    val_print_string (base->type ()->target_type (), "UTF-8",
 		      value_as_address (base), value_as_long (len), stream,
 		      options);
   else
     {
       LONGEST llen = value_as_long (len);
 
-      type_print (value_type (val), "", stream, -1);
+      type_print (val->type (), "", stream, -1);
       gdb_printf (stream, " ");
 
       if (llen == 0)
 	gdb_printf (stream, "[]");
       else
 	{
-	  struct type *elt_type = value_type (base)->target_type ();
+	  struct type *elt_type = base->type ()->target_type ();
 	  struct type *array_type = lookup_array_range_type (elt_type, 0,
 							     llen - 1);
 	  struct value *array = allocate_value_lazy (array_type);
@@ -368,7 +368,7 @@ rust_language::val_print_struct
 {
   int i;
   int first_field;
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   if (rust_slice_type_p (type))
     {
@@ -450,14 +450,14 @@ rust_language::print_enum (struct value *val, struct ui_file *stream,
 			   const struct value_print_options *options) const
 {
   struct value_print_options opts = *options;
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   opts.deref_ref = false;
 
   gdb_assert (rust_enum_p (type));
   gdb::array_view<const gdb_byte> view
     (value_contents_for_printing (val).data (),
-     value_type (val)->length ());
+     val->type ()->length ());
   type = resolve_dynamic_type (type, view, value_address (val));
 
   if (rust_empty_enum_p (type))
@@ -530,7 +530,7 @@ rust_language::value_print_inner
     opts.prettyformat = (opts.prettyformat_structs
 			 ? Val_prettyformat : Val_no_prettyformat);
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   switch (type->code ())
     {
     case TYPE_CODE_PTR:
@@ -635,11 +635,11 @@ rust_language::value_print
   value_print_options opts = *options;
   opts.deref_ref = true;
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   if (type->is_pointer_or_reference ())
     {
       gdb_printf (stream, "(");
-      type_print (value_type (val), "", stream, -1);
+      type_print (val->type (), "", stream, -1);
       gdb_printf (stream, ") ");
     }
 
@@ -1038,7 +1038,7 @@ rust_range (struct type *expect_type, struct expression *exp,
 	}
       else
 	{
-	  index_type = value_type (high);
+	  index_type = high->type ();
 	  name = (inclusive
 		  ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
 	}
@@ -1047,14 +1047,14 @@ rust_range (struct type *expect_type, struct expression *exp,
     {
       if (high == NULL)
 	{
-	  index_type = value_type (low);
+	  index_type = low->type ();
 	  name = "std::ops::RangeFrom";
 	}
       else
 	{
-	  if (!types_equal (value_type (low), value_type (high)))
+	  if (!types_equal (low->type (), high->type ()))
 	    error (_("Range expression with different types"));
-	  index_type = value_type (low);
+	  index_type = low->type ();
 	  name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
 	}
     }
@@ -1152,7 +1152,7 @@ rust_subscript (struct type *expect_type, struct expression *exp,
   LONGEST high = 0;
   int want_slice = 0;
 
-  rhstype = check_typedef (value_type (rhs));
+  rhstype = check_typedef (rhs->type ());
   if (rust_range_type_p (rhstype))
     {
       if (!for_addr)
@@ -1163,7 +1163,7 @@ rust_subscript (struct type *expect_type, struct expression *exp,
   else
     low = value_as_long (rhs);
 
-  struct type *type = check_typedef (value_type (lhs));
+  struct type *type = check_typedef (lhs->type ());
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
       struct type *base_type = nullptr;
@@ -1272,7 +1272,7 @@ rust_subscript (struct type *expect_type, struct expression *exp,
 				   && rust_slice_type_p (type))
 				  ? type->name () : "&[*gdb*]");
 
-	  slice = rust_slice_type (new_name, value_type (result), usize);
+	  slice = rust_slice_type (new_name, result->type (), usize);
 
 	  addrval = value_allocate_space_in_inferior (slice->length ());
 	  addr = value_as_long (addrval);
@@ -1321,8 +1321,8 @@ eval_op_rust_complement (struct type *expect_type, struct expression *exp,
 			 enum exp_opcode opcode,
 			 struct value *value)
 {
-  if (value_type (value)->code () == TYPE_CODE_BOOL)
-    return value_from_longest (value_type (value), value_logical_not (value));
+  if (value->type ()->code () == TYPE_CODE_BOOL)
+    return value_from_longest (value->type (), value_logical_not (value));
   return value_complement (value);
 }
 
@@ -1350,7 +1350,7 @@ eval_op_rust_array (struct type *expect_type, struct expression *exp,
   else
     {
       struct type *arraytype
-	= lookup_array_range_type (value_type (elt), 0, copies - 1);
+	= lookup_array_range_type (elt->type (), 0, copies - 1);
       return allocate_value (arraytype);
     }
 }
@@ -1366,7 +1366,7 @@ rust_struct_anon::evaluate (struct type *expect_type,
   value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
   int field_number = std::get<0> (m_storage);
 
-  struct type *type = value_type (lhs);
+  struct type *type = lhs->type ();
 
   if (type->code () == TYPE_CODE_STRUCT)
     {
@@ -1384,7 +1384,7 @@ rust_struct_anon::evaluate (struct type *expect_type,
 	  int fieldno = rust_enum_variant (type);
 	  lhs = value_primitive_field (lhs, 0, fieldno, type);
 	  outer_type = type;
-	  type = value_type (lhs);
+	  type = lhs->type ();
 	}
 
       /* Tuples and tuple structs */
@@ -1434,7 +1434,7 @@ rust_structop::evaluate (struct type *expect_type,
   const char *field_name = std::get<1> (m_storage).c_str ();
 
   struct value *result;
-  struct type *type = value_type (lhs);
+  struct type *type = lhs->type ();
   if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type))
     {
       type = resolve_dynamic_type (type, value_contents (lhs),
@@ -1448,7 +1448,7 @@ rust_structop::evaluate (struct type *expect_type,
       lhs = value_primitive_field (lhs, 0, fieldno, type);
 
       struct type *outer_type = type;
-      type = value_type (lhs);
+      type = lhs->type ();
       if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
 	error (_("Attempting to access named field %s of tuple "
 		 "variant %s::%s, which has only anonymous fields"),
@@ -1470,7 +1470,7 @@ rust_structop::evaluate (struct type *expect_type,
   else
     result = value_struct_elt (&lhs, {}, field_name, NULL, "structure");
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    result = value_zero (value_type (result), VALUE_LVAL (result));
+    result = value_zero (result->type (), VALUE_LVAL (result));
   return result;
 }
 
@@ -1537,10 +1537,10 @@ rust_structop::evaluate_funcall (struct type *expect_type,
      type in order to look up the method.  */
   args[0] = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
   /* We don't yet implement real Deref semantics.  */
-  while (value_type (args[0])->code () == TYPE_CODE_PTR)
+  while (args[0]->type ()->code () == TYPE_CODE_PTR)
     args[0] = value_ind (args[0]);
 
-  struct type *type = value_type (args[0]);
+  struct type *type = args[0]->type ();
   if ((type->code () != TYPE_CODE_STRUCT
        && type->code () != TYPE_CODE_UNION
        && type->code () != TYPE_CODE_ENUM)
diff --git a/gdb/rx-tdep.c b/gdb/rx-tdep.c
index 675c51cfee9..67db30ace88 100644
--- a/gdb/rx-tdep.c
+++ b/gdb/rx-tdep.c
@@ -668,7 +668,7 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   CORE_ADDR cfa;
   int num_register_candidate_args;
 
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
 
   /* Dereference function pointer types.  */
   while (func_type->code () == TYPE_CODE_PTR)
@@ -726,7 +726,7 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	{
 	  struct value *arg = args[i];
 	  const gdb_byte *arg_bits = value_contents_all (arg).data ();
-	  struct type *arg_type = check_typedef (value_type (arg));
+	  struct type *arg_type = check_typedef (arg->type ());
 	  ULONGEST arg_size = arg_type->length ();
 
 	  if (i == 0 && struct_addr != 0
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 17933997d8c..f33a13e8a55 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -1749,7 +1749,7 @@ s390_handle_arg (struct s390_arg_state *as, struct value *arg,
 		 s390_gdbarch_tdep *tdep, int word_size,
 		 enum bfd_endian byte_order, int is_unnamed)
 {
-  struct type *type = check_typedef (value_type (arg));
+  struct type *type = check_typedef (arg->type ());
   unsigned int length = type->length ();
   int write_mode = as->regcache != NULL;
 
@@ -1911,7 +1911,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   int i;
   struct s390_arg_state arg_state, arg_prep;
   CORE_ADDR param_area_start, new_sp;
-  struct type *ftype = check_typedef (value_type (function));
+  struct type *ftype = check_typedef (function->type ());
 
   if (ftype->code () == TYPE_CODE_PTR)
     ftype = check_typedef (ftype->target_type ());
diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index a816e6b00cd..c98df0223e9 100644
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -897,7 +897,7 @@ sh_stack_allocsize (int nargs, struct value **args)
 {
   int stack_alloc = 0;
   while (nargs-- > 0)
-    stack_alloc += ((value_type (args[nargs])->length () + 3) & ~3);
+    stack_alloc += ((args[nargs]->type ()->length () + 3) & ~3);
   return stack_alloc;
 }
 
@@ -1030,7 +1030,7 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
   int argreg = ARG0_REGNUM;
   int flt_argreg = 0;
   int argnum;
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
   struct type *type;
   CORE_ADDR regval;
   const gdb_byte *val;
@@ -1060,7 +1060,7 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
      in four registers available.  Loop thru args from first to last.  */
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      type = value_type (args[argnum]);
+      type = args[argnum]->type ();
       len = type->length ();
       val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
 
@@ -1172,7 +1172,7 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
   int stack_offset = 0;
   int argreg = ARG0_REGNUM;
   int argnum;
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
   struct type *type;
   CORE_ADDR regval;
   const gdb_byte *val;
@@ -1198,7 +1198,7 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
      in four registers available.  Loop thru args from first to last.  */
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      type = value_type (args[argnum]);
+      type = args[argnum]->type ();
       len = type->length ();
       val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
 
@@ -1364,7 +1364,7 @@ sh_return_value_nofpu (struct gdbarch *gdbarch, struct value *function,
 		       struct type *type, struct regcache *regcache,
 		       gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  struct type *func_type = function ? value_type (function) : NULL;
+  struct type *func_type = function ? function->type () : NULL;
 
   if (sh_use_struct_convention_nofpu
 	(sh_is_renesas_calling_convention (func_type), type))
@@ -1381,7 +1381,7 @@ sh_return_value_fpu (struct gdbarch *gdbarch, struct value *function,
 		     struct type *type, struct regcache *regcache,
 		     gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  struct type *func_type = function ? value_type (function) : NULL;
+  struct type *func_type = function ? function->type () : NULL;
 
   if (sh_use_struct_convention (
 	sh_is_renesas_calling_convention (func_type), type))
diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index bd3dc946f87..6c41cfd04e2 100644
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -621,7 +621,7 @@ sparc32_store_arguments (struct regcache *regcache, int nargs,
 
   for (i = 0; i < nargs; i++)
     {
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int len = type->length ();
 
       if (sparc_arg_by_memory_p (type))
@@ -665,7 +665,7 @@ sparc32_store_arguments (struct regcache *regcache, int nargs,
   for (i = 0; i < nargs; i++)
     {
       const bfd_byte *valbuf = value_contents (args[i]).data ();
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int len = type->length ();
       gdb_byte buf[4];
 
diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index 96910be3f0e..eb6a66315c0 100644
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -1381,7 +1381,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
 
   for (i = 0; i < nargs; i++)
     {
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int len = type->length ();
 
       if (sparc64_structure_or_union_p (type)
@@ -1481,7 +1481,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
   for (i = 0; i < nargs; i++)
     {
       const gdb_byte *valbuf = value_contents (args[i]).data ();
-      struct type *type = value_type (args[i]);
+      struct type *type = args[i]->type ();
       int len = type->length ();
       int regnum = -1;
       gdb_byte buf[16];
diff --git a/gdb/stack.c b/gdb/stack.c
index c36f144f093..9e239ed4f67 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -467,7 +467,7 @@ print_frame_arg (const frame_print_options &fp_opts,
 		 because our standard indentation here is 4 spaces, and
 		 val_print indents 2 for each recurse.  */ 
 
-	      annotate_arg_value (value_type (arg->val));
+	      annotate_arg_value (arg->val->type ());
 
 	      /* Use the appropriate language to display our symbol, unless the
 		 user forced the language to a specific language.  */
@@ -578,7 +578,7 @@ read_frame_arg (const frame_print_options &fp_opts,
 
 	  if (val && entryval && !current_uiout->is_mi_like_p ())
 	    {
-	      struct type *type = value_type (val);
+	      struct type *type = val->type ();
 
 	      if (value_lazy (val))
 		value_fetch_lazy (val);
@@ -601,7 +601,7 @@ read_frame_arg (const frame_print_options &fp_opts,
 		      val_deref = coerce_ref (val);
 		      if (value_lazy (val_deref))
 			value_fetch_lazy (val_deref);
-		      type_deref = value_type (val_deref);
+		      type_deref = val_deref->type ();
 
 		      entryval_deref = coerce_ref (entryval);
 		      if (value_lazy (entryval_deref))
@@ -2742,7 +2742,7 @@ return_command (const char *retval_exp, int from_tty)
 	    error (_("Return value type not available for selected "
 		     "stack frame.\n"
 		     "Please use an explicit cast of the value to return."));
-	  return_type = value_type (return_value);
+	  return_type = return_value->type ();
 	}
       return_type = check_typedef (return_type);
       return_value = value_cast (return_type, return_value);
@@ -2765,7 +2765,7 @@ return_command (const char *retval_exp, int from_tty)
 	return_value = NULL;
       else if (thisfun != NULL)
 	{
-	  if (is_nocall_function (check_typedef (value_type (function))))
+	  if (is_nocall_function (check_typedef (function->type ())))
 	    {
 	      query_prefix =
 		string_printf ("Function '%s' does not follow the target "
@@ -2817,7 +2817,7 @@ return_command (const char *retval_exp, int from_tty)
   /* Store RETURN_VALUE in the just-returned register set.  */
   if (return_value != NULL)
     {
-      struct type *return_type = value_type (return_value);
+      struct type *return_type = return_value->type ();
       struct gdbarch *cache_arch = get_current_regcache ()->arch ();
 
       gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c
index 6c103943b72..000a2a9aaa5 100644
--- a/gdb/tic6x-tdep.c
+++ b/gdb/tic6x-tdep.c
@@ -864,7 +864,7 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   int stack_offset = 4;
   int references_offset = 4;
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  struct type *func_type = value_type (function);
+  struct type *func_type = function->type ();
   /* The first arg passed on stack.  Mostly the first 10 args are passed by
      registers.  */
   int first_arg_on_stack = 10;
@@ -895,7 +895,7 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Now make space on the stack for the args.  */
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      int len = align_up (value_type (args[argnum])->length (), 4);
+      int len = align_up (args[argnum]->type ()->length (), 4);
       if (argnum >= 10 - argreg)
 	references_offset += len;
       stack_offset += len;
@@ -913,7 +913,7 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       const gdb_byte *val;
       struct value *arg = args[argnum];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
       int len = arg_type->length ();
       enum type_code typecode = arg_type->code ();
 
diff --git a/gdb/typeprint.c b/gdb/typeprint.c
index 41b57353ce1..64709b9d1db 100644
--- a/gdb/typeprint.c
+++ b/gdb/typeprint.c
@@ -515,7 +515,7 @@ whatis_exp (const char *exp, int show)
 	 any typedef level.  "ptype" always strips all levels of
 	 typedefs.  */
       val = evaluate_type (expr.get ());
-      type = value_type (val);
+      type = val->type ();
 
       if (show == -1 && expr->first_opcode () == OP_TYPE)
 	{
@@ -536,7 +536,7 @@ whatis_exp (const char *exp, int show)
   else
     {
       val = access_value_history (0);
-      type = value_type (val);
+      type = val->type ();
     }
 
   if (flags.print_offsets && is_dynamic_type (type))
@@ -712,7 +712,7 @@ maintenance_print_type (const char *type_name, int from_tty)
     {
       expression_up expr = parse_expression (type_name);
       struct value *val = evaluate_type (expr.get ());
-      struct type *type = value_type (val);
+      struct type *type = val->type ();
 
       if (type != nullptr)
 	recursive_dump_type (type, 0);
diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
index cc7da907a5e..fd801540757 100644
--- a/gdb/v850-tdep.c
+++ b/gdb/v850-tdep.c
@@ -1037,7 +1037,7 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
 
   /* Now make space on the stack for the args.  */
   for (argnum = 0; argnum < nargs; argnum++)
-    arg_space += ((value_type (args[argnum])->length () + 3) & ~3);
+    arg_space += ((args[argnum]->type ()->length () + 3) & ~3);
   sp -= arg_space + stack_offset;
 
   argreg = E_ARG0_REGNUM;
@@ -1054,9 +1054,9 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
       gdb_byte *val;
       gdb_byte valbuf[v850_reg_size];
 
-      if (!v850_type_is_scalar (value_type (*args))
+      if (!v850_type_is_scalar ((*args)->type ())
 	  && tdep->abi == V850_ABI_GCC
-	  && value_type (*args)->length () > E_MAX_RETTYPE_SIZE_IN_REGS)
+	  && (*args)->type ()->length () > E_MAX_RETTYPE_SIZE_IN_REGS)
 	{
 	  store_unsigned_integer (valbuf, 4, byte_order,
 				  value_address (*args));
@@ -1065,12 +1065,12 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
 	}
       else
 	{
-	  len = value_type (*args)->length ();
+	  len = (*args)->type ()->length ();
 	  val = (gdb_byte *) value_contents (*args).data ();
 	}
 
       if (tdep->eight_byte_align
-	  && v850_eight_byte_align_p (value_type (*args)))
+	  && v850_eight_byte_align_p ((*args)->type ()))
 	{
 	  if (argreg <= E_ARGLAST_REGNUM && (argreg & 1))
 	    argreg++;
diff --git a/gdb/valarith.c b/gdb/valarith.c
index 1dce9d0f613..53dfc82012d 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -88,7 +88,7 @@ value_ptradd (struct value *arg1, LONGEST arg2)
   struct value *result;
 
   arg1 = coerce_array (arg1);
-  valptrtype = check_typedef (value_type (arg1));
+  valptrtype = check_typedef (arg1->type ());
   sz = find_size_for_pointer_math (valptrtype);
 
   result = value_from_pointer (valptrtype,
@@ -109,8 +109,8 @@ value_ptrdiff (struct value *arg1, struct value *arg2)
 
   arg1 = coerce_array (arg1);
   arg2 = coerce_array (arg2);
-  type1 = check_typedef (value_type (arg1));
-  type2 = check_typedef (value_type (arg2));
+  type1 = check_typedef (arg1->type ());
+  type2 = check_typedef (arg2->type ());
 
   gdb_assert (type1->code () == TYPE_CODE_PTR);
   gdb_assert (type2->code () == TYPE_CODE_PTR);
@@ -149,7 +149,7 @@ value_subscript (struct value *array, LONGEST index)
   struct type *tarray;
 
   array = coerce_ref (array);
-  tarray = check_typedef (value_type (array));
+  tarray = check_typedef (array->type ());
 
   if (tarray->code () == TYPE_CODE_ARRAY
       || tarray->code () == TYPE_CODE_STRING)
@@ -199,7 +199,7 @@ static struct value *
 value_subscripted_rvalue (struct value *array, LONGEST index,
 			  LONGEST lowerbound)
 {
-  struct type *array_type = check_typedef (value_type (array));
+  struct type *array_type = check_typedef (array->type ());
   struct type *elt_type = array_type->target_type ();
   LONGEST elt_size = type_length_units (elt_type);
 
@@ -277,7 +277,7 @@ int
 binop_user_defined_p (enum exp_opcode op,
 		      struct value *arg1, struct value *arg2)
 {
-  return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
+  return binop_types_user_defined_p (op, arg1->type (), arg2->type ());
 }
 
 /* Check to see if argument is a structure.  This is called so
@@ -293,7 +293,7 @@ unop_user_defined_p (enum exp_opcode op, struct value *arg1)
 
   if (op == UNOP_ADDR)
     return 0;
-  type1 = check_typedef (value_type (arg1));
+  type1 = check_typedef (arg1->type ());
   if (TYPE_IS_REFERENCE (type1))
     type1 = check_typedef (type1->target_type ());
   return type1->code () == TYPE_CODE_STRUCT;
@@ -379,7 +379,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 
-  if (check_typedef (value_type (arg1))->code () != TYPE_CODE_STRUCT)
+  if (check_typedef (arg1->type ())->code () != TYPE_CODE_STRUCT)
     error (_("Can't do that binary op on that type"));	/* FIXME be explicit */
 
   value *argvec_storage[3];
@@ -506,7 +506,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
 	  argvec[1] = argvec[0];
 	  argvec = argvec.slice (1);
 	}
-      if (value_type (argvec[0])->code () == TYPE_CODE_XMETHOD)
+      if (argvec[0]->type ()->code () == TYPE_CODE_XMETHOD)
 	{
 	  /* Static xmethods are not supported yet.  */
 	  gdb_assert (static_memfuncp == 0);
@@ -525,7 +525,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
 	{
 	  struct type *return_type;
 
-	  return_type = check_typedef (value_type (argvec[0]))->target_type ();
+	  return_type = check_typedef (argvec[0]->type ())->target_type ();
 	  return value_zero (return_type, VALUE_LVAL (arg1));
 	}
       return call_function_by_hand (argvec[0], NULL,
@@ -544,7 +544,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
 struct value *
 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 {
-  struct gdbarch *gdbarch = value_type (arg1)->arch ();
+  struct gdbarch *gdbarch = arg1->type ()->arch ();
   char *ptr;
   char tstr[13], mangle_tstr[13];
   int static_memfuncp, nargs;
@@ -554,7 +554,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 
-  if (check_typedef (value_type (arg1))->code () != TYPE_CODE_STRUCT)
+  if (check_typedef (arg1->type ())->code () != TYPE_CODE_STRUCT)
     error (_("Can't do that unary op on that type"));	/* FIXME be explicit */
 
   value *argvec_storage[3];
@@ -619,7 +619,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 	  argvec[1] = argvec[0];
 	  argvec = argvec.slice (1);
 	}
-      if (value_type (argvec[0])->code () == TYPE_CODE_XMETHOD)
+      if (argvec[0]->type ()->code () == TYPE_CODE_XMETHOD)
 	{
 	  /* Static xmethods are not supported yet.  */
 	  gdb_assert (static_memfuncp == 0);
@@ -638,7 +638,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 	{
 	  struct type *return_type;
 
-	  return_type = check_typedef (value_type (argvec[0]))->target_type ();
+	  return_type = check_typedef (argvec[0]->type ())->target_type ();
 	  return value_zero (return_type, VALUE_LVAL (arg1));
 	}
       return call_function_by_hand (argvec[0], NULL,
@@ -656,8 +656,8 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 struct value *
 value_concat (struct value *arg1, struct value *arg2)
 {
-  struct type *type1 = check_typedef (value_type (arg1));
-  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *type1 = check_typedef (arg1->type ());
+  struct type *type2 = check_typedef (arg2->type ());
 
   if (type1->code () != TYPE_CODE_ARRAY && type2->code () != TYPE_CODE_ARRAY)
     error ("no array provided to concatenation");
@@ -751,8 +751,8 @@ value_args_as_target_float (struct value *arg1, struct value *arg2,
 {
   struct type *type1, *type2;
 
-  type1 = check_typedef (value_type (arg1));
-  type2 = check_typedef (value_type (arg2));
+  type1 = check_typedef (arg1->type ());
+  type2 = check_typedef (arg2->type ());
 
   /* At least one of the arguments must be of floating-point type.  */
   gdb_assert (is_floating_type (type1) || is_floating_type (type2));
@@ -811,8 +811,8 @@ value_args_as_target_float (struct value *arg1, struct value *arg2,
 static struct value *
 fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 {
-  struct type *type1 = check_typedef (value_type (arg1));
-  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *type1 = check_typedef (arg1->type ());
+  struct type *type2 = check_typedef (arg2->type ());
   const struct language_defn *language = current_language;
 
   struct gdbarch *gdbarch = type1->arch ();
@@ -961,8 +961,8 @@ static struct value *scalar_binop (struct value *arg1, struct value *arg2,
 static struct value *
 complex_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 {
-  struct type *arg1_type = check_typedef (value_type (arg1));
-  struct type *arg2_type = check_typedef (value_type (arg2));
+  struct type *arg1_type = check_typedef (arg1->type ());
+  struct type *arg2_type = check_typedef (arg2->type ());
 
   struct value *arg1_real, *arg1_imag, *arg2_real, *arg2_imag;
   if (arg1_type->code () == TYPE_CODE_COMPLEX)
@@ -986,8 +986,8 @@ complex_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
       arg2_imag = value_zero (arg2_type, not_lval);
     }
 
-  struct type *comp_type = promotion_type (value_type (arg1_real),
-					   value_type (arg2_real));
+  struct type *comp_type = promotion_type (arg1_real->type (),
+					   arg2_real->type ());
   if (!can_create_complex_type (comp_type))
     error (_("Argument to complex arithmetic operation not supported."));
 
@@ -1057,7 +1057,7 @@ complex_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 	else
 	  v1 = v1 || v2;
 
-	return value_from_longest (value_type (x1), v1);
+	return value_from_longest (x1->type (), v1);
       }
       break;
 
@@ -1143,8 +1143,8 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
   arg1 = coerce_ref (arg1);
   arg2 = coerce_ref (arg2);
 
-  type1 = check_typedef (value_type (arg1));
-  type2 = check_typedef (value_type (arg2));
+  type1 = check_typedef (arg1->type ());
+  type2 = check_typedef (arg2->type ());
 
   if (type1->code () == TYPE_CODE_COMPLEX
       || type2->code () == TYPE_CODE_COMPLEX)
@@ -1362,7 +1362,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 
 	  val = allocate_value (result_type);
 	  store_unsigned_integer (value_contents_raw (val).data (),
-				  value_type (val)->length (),
+				  val->type ()->length (),
 				  type_byte_order (result_type),
 				  v);
 	}
@@ -1523,7 +1523,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 
 	  val = allocate_value (result_type);
 	  store_signed_integer (value_contents_raw (val).data (),
-				value_type (val)->length (),
+				val->type ()->length (),
 				type_byte_order (result_type),
 				v);
 	}
@@ -1558,7 +1558,7 @@ value_vector_widen (struct value *scalar_value, struct type *vector_type)
   eltype = check_typedef (vector_type->target_type ());
   elval = value_cast (eltype, scalar_value);
 
-  scalar_type = check_typedef (value_type (scalar_value));
+  scalar_type = check_typedef (scalar_value->type ());
 
   /* If we reduced the length of the scalar then check we didn't loose any
      important bits.  */
@@ -1588,8 +1588,8 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
   int t1_is_vec, t2_is_vec, elsize, i;
   LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
 
-  type1 = check_typedef (value_type (val1));
-  type2 = check_typedef (value_type (val2));
+  type1 = check_typedef (val1->type ());
+  type2 = check_typedef (val2->type ());
 
   t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
 	       && type1->is_vector ()) ? 1 : 0;
@@ -1633,8 +1633,8 @@ struct value *
 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 {
   struct value *val;
-  struct type *type1 = check_typedef (value_type (arg1));
-  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *type1 = check_typedef (arg1->type ());
+  struct type *type2 = check_typedef (arg2->type ());
   int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
 		   && type1->is_vector ());
   int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
@@ -1674,7 +1674,7 @@ value_logical_not (struct value *arg1)
   struct type *type1;
 
   arg1 = coerce_array (arg1);
-  type1 = check_typedef (value_type (arg1));
+  type1 = check_typedef (arg1->type ());
 
   if (is_floating_value (arg1))
     return target_float_is_zero (value_contents (arg1).data (), type1);
@@ -1697,8 +1697,8 @@ value_logical_not (struct value *arg1)
 static int
 value_strcmp (struct value *arg1, struct value *arg2)
 {
-  int len1 = value_type (arg1)->length ();
-  int len2 = value_type (arg2)->length ();
+  int len1 = arg1->type ()->length ();
+  int len2 = arg2->type ()->length ();
   const gdb_byte *s1 = value_contents (arg1).data ();
   const gdb_byte *s2 = value_contents (arg2).data ();
   int i, len = len1 < len2 ? len1 : len2;
@@ -1738,8 +1738,8 @@ value_equal (struct value *arg1, struct value *arg2)
   arg1 = coerce_array (arg1);
   arg2 = coerce_array (arg2);
 
-  type1 = check_typedef (value_type (arg1));
-  type2 = check_typedef (value_type (arg2));
+  type1 = check_typedef (arg1->type ());
+  type2 = check_typedef (arg2->type ());
   code1 = type1->code ();
   code2 = type2->code ();
   is_int1 = is_integral_type (type1);
@@ -1801,8 +1801,8 @@ value_equal_contents (struct value *arg1, struct value *arg2)
 {
   struct type *type1, *type2;
 
-  type1 = check_typedef (value_type (arg1));
-  type2 = check_typedef (value_type (arg2));
+  type1 = check_typedef (arg1->type ());
+  type2 = check_typedef (arg2->type ());
 
   return (type1->code () == type2->code ()
 	  && type1->length () == type2->length ()
@@ -1825,8 +1825,8 @@ value_less (struct value *arg1, struct value *arg2)
   arg1 = coerce_array (arg1);
   arg2 = coerce_array (arg2);
 
-  type1 = check_typedef (value_type (arg1));
-  type2 = check_typedef (value_type (arg2));
+  type1 = check_typedef (arg1->type ());
+  type2 = check_typedef (arg2->type ());
   code1 = type1->code ();
   code2 = type2->code ();
   is_int1 = is_integral_type (type1);
@@ -1877,7 +1877,7 @@ value_pos (struct value *arg1)
   struct type *type;
 
   arg1 = coerce_ref (arg1);
-  type = check_typedef (value_type (arg1));
+  type = check_typedef (arg1->type ());
 
   if (is_integral_type (type) || is_floating_value (arg1)
       || (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
@@ -1893,7 +1893,7 @@ value_neg (struct value *arg1)
   struct type *type;
 
   arg1 = coerce_ref (arg1);
-  type = check_typedef (value_type (arg1));
+  type = check_typedef (arg1->type ());
 
   if (is_integral_type (type) || is_floating_type (type))
     return value_binop (value_from_longest (type, 0), arg1, BINOP_SUB);
@@ -1940,7 +1940,7 @@ value_complement (struct value *arg1)
   struct value *val;
 
   arg1 = coerce_ref (arg1);
-  type = check_typedef (value_type (arg1));
+  type = check_typedef (arg1->type ());
 
   if (is_integral_type (type))
     val = value_from_longest (type, ~value_as_long (arg1));
@@ -2010,8 +2010,8 @@ int
 value_in (struct value *element, struct value *set)
 {
   int member;
-  struct type *settype = check_typedef (value_type (set));
-  struct type *eltype = check_typedef (value_type (element));
+  struct type *settype = check_typedef (set->type ());
+  struct type *eltype = check_typedef (element->type ());
 
   if (eltype->code () == TYPE_CODE_RANGE)
     eltype = eltype->target_type ();
diff --git a/gdb/valops.c b/gdb/valops.c
index c5b16f8d400..a56afce0235 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -213,7 +213,7 @@ value_cast_structs (struct type *type, struct value *v2)
   gdb_assert (type != NULL && v2 != NULL);
 
   t1 = check_typedef (type);
-  t2 = check_typedef (value_type (v2));
+  t2 = check_typedef (v2->type ());
 
   /* Check preconditions.  */
   gdb_assert ((t1->code () == TYPE_CODE_STRUCT
@@ -254,7 +254,7 @@ value_cast_structs (struct type *type, struct value *v2)
 	{
 	  v = value_full_object (v2, real_type, full, top, using_enc);
 	  v = value_at_lazy (real_type, value_address (v));
-	  real_type = value_type (v);
+	  real_type = v->type ();
 
 	  /* We might be trying to cast to the outermost enclosing
 	     type, in which case search_struct_field won't work.  */
@@ -297,7 +297,7 @@ value_cast_pointers (struct type *type, struct value *arg2,
 		     int subclass_check)
 {
   struct type *type1 = check_typedef (type);
-  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *type2 = check_typedef (arg2->type ());
   struct type *t1 = check_typedef (type1->target_type ());
   struct type *t2 = check_typedef (type2->target_type ());
 
@@ -311,7 +311,7 @@ value_cast_pointers (struct type *type, struct value *arg2,
 	v2 = coerce_ref (arg2);
       else
 	v2 = value_ind (arg2);
-      gdb_assert (check_typedef (value_type (v2))->code ()
+      gdb_assert (check_typedef (v2->type ())->code ()
 		  == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
       v2 = value_cast_structs (t1, v2);
       /* At this point we have what we can have, un-dereference if needed.  */
@@ -337,7 +337,7 @@ value_cast_pointers (struct type *type, struct value *arg2,
 gdb_mpq
 value_to_gdb_mpq (struct value *value)
 {
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
 
   gdb_mpq result;
   if (is_floating_type (type))
@@ -370,7 +370,7 @@ value_to_gdb_mpq (struct value *value)
 static struct value *
 value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
 {
-  struct type *from_type = value_type (from_val);
+  struct type *from_type = from_val->type ();
 
   if (from_type == to_type)
     return from_val;
@@ -416,17 +416,17 @@ value_cast (struct type *type, struct value *arg2)
 
   /* TYPE might be equal in meaning to the existing type of ARG2, but for
      many reasons, might be a different type object (e.g. TYPE might be a
-     gdbarch owned type, while VALUE_TYPE (ARG2) could be an objfile owned
+     gdbarch owned type, while ARG2->type () could be an objfile owned
      type).
 
      In this case we want to preserve the LVAL of ARG2 as this allows the
      resulting value to be used in more places.  We do this by calling
      VALUE_COPY if appropriate.  */
-  if (types_deeply_equal (value_type (arg2), type))
+  if (types_deeply_equal (arg2->type (), type))
     {
       /* If the types are exactly equal then we can avoid creating a new
 	 value completely.  */
-      if (value_type (arg2) != type)
+      if (arg2->type () != type)
 	{
 	  arg2 = value_copy (arg2);
 	  deprecated_set_value_type (arg2, type);
@@ -450,7 +450,7 @@ value_cast (struct type *type, struct value *arg2)
       return value_ref (val, t1->code ());
     }
 
-  if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2))))
+  if (TYPE_IS_REFERENCE (check_typedef (arg2->type ())))
     /* We deref the value and then do the cast.  */
     return value_cast (type, coerce_ref (arg2)); 
 
@@ -462,7 +462,7 @@ value_cast (struct type *type, struct value *arg2)
   type = check_typedef (type);
   code1 = type->code ();
   arg2 = coerce_ref (arg2);
-  type2 = check_typedef (value_type (arg2));
+  type2 = check_typedef (arg2->type ());
 
   /* You can't cast to a reference type.  See value_cast_pointers
      instead.  */
@@ -510,7 +510,7 @@ value_cast (struct type *type, struct value *arg2)
   if (type2->code () == TYPE_CODE_FUNC)
     arg2 = value_coerce_function (arg2);
 
-  type2 = check_typedef (value_type (arg2));
+  type2 = check_typedef (arg2->type ());
   code2 = type2->code ();
 
   if (code1 == TYPE_CODE_COMPLEX)
@@ -691,7 +691,7 @@ value_reinterpret_cast (struct type *type, struct value *arg)
       real_type = lookup_pointer_type (real_type);
     }
 
-  arg_type = value_type (arg);
+  arg_type = arg->type ();
 
   dest_code = real_type->code ();
   arg_code = arg_type->code ();
@@ -819,7 +819,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
   int full, using_enc;
   LONGEST top;
   struct type *resolved_type = check_typedef (type);
-  struct type *arg_type = check_typedef (value_type (arg));
+  struct type *arg_type = check_typedef (arg->type ());
   struct type *class_type, *rtti_type;
   struct value *result, *tem, *original_arg = arg;
   CORE_ADDR addr;
@@ -894,7 +894,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
     return value_at_lazy (type, addr);
 
   tem = value_at (type, addr);
-  type = value_type (tem);
+  type = tem->type ();
 
   /* The first dynamic check specified in 5.2.7.  */
   if (is_public_ancestor (arg_type, resolved_type->target_type ()))
@@ -1095,7 +1095,7 @@ value_assign (struct value *toval, struct value *fromval)
 
   toval = coerce_ref (toval);
 
-  type = value_type (toval);
+  type = toval->type ();
   if (VALUE_LVAL (toval) != lval_internalvar)
     fromval = value_cast (type, fromval);
   else
@@ -1405,7 +1405,7 @@ address_of_variable (struct symbol *var, const struct block *b)
      Lazy evaluation pays off here.  */
 
   val = value_of_variable (var, b);
-  type = value_type (val);
+  type = val->type ();
 
   if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
       || type->code () == TYPE_CODE_FUNC)
@@ -1458,7 +1458,7 @@ value_must_coerce_to_target (struct value *val)
       && VALUE_LVAL (val) != lval_xcallable)
     return false;
 
-  valtype = check_typedef (value_type (val));
+  valtype = check_typedef (val->type ());
 
   switch (valtype->code ())
     {
@@ -1484,10 +1484,10 @@ value_coerce_to_target (struct value *val)
   if (!value_must_coerce_to_target (val))
     return val;
 
-  length = check_typedef (value_type (val))->length ();
+  length = check_typedef (val->type ())->length ();
   addr = allocate_space_in_inferior (length);
   write_memory (addr, value_contents (val).data (), length);
-  return value_at_lazy (value_type (val), addr);
+  return value_at_lazy (val->type (), addr);
 }
 
 /* Given a value which is an array, return a value which is a pointer
@@ -1516,7 +1516,7 @@ value_coerce_to_target (struct value *val)
 struct value *
 value_coerce_array (struct value *arg1)
 {
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
 
   /* If the user tries to do something requiring a pointer with an
      array that has not yet been pushed to the target, then this would
@@ -1541,7 +1541,7 @@ value_coerce_function (struct value *arg1)
   if (VALUE_LVAL (arg1) != lval_memory)
     error (_("Attempt to take address of value not located in memory."));
 
-  retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
+  retval = value_from_pointer (lookup_pointer_type (arg1->type ()),
 			       value_address (arg1));
   return retval;
 }
@@ -1553,7 +1553,7 @@ struct value *
 value_addr (struct value *arg1)
 {
   struct value *arg2;
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
 
   if (TYPE_IS_REFERENCE (type))
     {
@@ -1591,7 +1591,7 @@ value_addr (struct value *arg1)
     error (_("Attempt to take address of value not located in memory."));
 
   /* Get target memory address.  */
-  arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
+  arg2 = value_from_pointer (lookup_pointer_type (arg1->type ()),
 			     (value_address (arg1)
 			      + value_embedded_offset (arg1)));
 
@@ -1612,7 +1612,7 @@ struct value *
 value_ref (struct value *arg1, enum type_code refcode)
 {
   struct value *arg2;
-  struct type *type = check_typedef (value_type (arg1));
+  struct type *type = check_typedef (arg1->type ());
 
   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
 
@@ -1637,7 +1637,7 @@ value_ind (struct value *arg1)
 
   arg1 = coerce_array (arg1);
 
-  base_type = check_typedef (value_type (arg1));
+  base_type = check_typedef (arg1->type ());
 
   if (VALUE_LVAL (arg1) == lval_computed)
     {
@@ -1676,7 +1676,7 @@ value_ind (struct value *arg1)
 		       - value_pointed_to_offset (arg1));
 	}
       arg2 = value_at_lazy (enc_type, base_addr);
-      enc_type = value_type (arg2);
+      enc_type = arg2->type ();
       return readjust_indirect_value_type (arg2, enc_type, base_type,
 					   arg1, base_addr);
     }
@@ -1818,7 +1818,7 @@ typecmp (bool staticp, bool varargs, int nargs,
 	return i + 1;
 
       tt1 = check_typedef (t1[i].type ());
-      tt2 = check_typedef (value_type (t2[i]));
+      tt2 = check_typedef (t2[i]->type ());
 
       if (TYPE_IS_REFERENCE (tt1)
 	  /* We should be doing hairy argument matching, as below.  */
@@ -1856,7 +1856,7 @@ typecmp (bool staticp, bool varargs, int nargs,
       /* We should be doing much hairier argument matching (see
 	 section 13.2 of the ARM), but as a quick kludge, just check
 	 for the same type code.  */
-      if (t1[i].type ()->code () != value_type (t2[i])->code ())
+      if (t1[i].type ()->code () != t2[i]->type ()->code ())
 	return i + 1;
     }
   if (varargs || i == t2.size ())
@@ -2104,7 +2104,7 @@ struct_field_searcher::search (struct value *arg1, LONGEST offset,
 	      v2 = value_at_lazy (basetype, base_addr);
 	      if (target_read_memory (base_addr, 
 				      value_contents_raw (v2).data (),
-				      value_type (v2)->length ()) != 0)
+				      v2->type ()->length ()) != 0)
 		error (_("virtual baseclass botch"));
 	    }
 	  else
@@ -2162,7 +2162,7 @@ search_struct_field (const char *name, struct value *arg1,
 	    {
 	      gdb_assert (!candidate.path.empty ());
 
-	      struct type *field_type = value_type (candidate.field_value);
+	      struct type *field_type = candidate.field_value->type ();
 	      struct type *struct_type = candidate.path.back ();
 
 	      std::string path;
@@ -2351,7 +2351,7 @@ value_struct_elt (struct value **argp,
 
   *argp = coerce_array (*argp);
 
-  t = check_typedef (value_type (*argp));
+  t = check_typedef ((*argp)->type ());
 
   /* Follow pointers until we get to a non-pointer.  */
 
@@ -2359,9 +2359,9 @@ value_struct_elt (struct value **argp,
     {
       *argp = value_ind (*argp);
       /* Don't coerce fn pointer to fn and then back again!  */
-      if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
+      if (check_typedef ((*argp)->type ())->code () != TYPE_CODE_FUNC)
 	*argp = coerce_array (*argp);
-      t = check_typedef (value_type (*argp));
+      t = check_typedef ((*argp)->type ());
     }
 
   if (t->code () != TYPE_CODE_STRUCT
@@ -2449,14 +2449,14 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype,
 
   *argp = coerce_array (*argp);
 
-  t = check_typedef (value_type (*argp));
+  t = check_typedef ((*argp)->type ());
 
   while (t->is_pointer_or_reference ())
     {
       *argp = value_ind (*argp);
-      if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
+      if (check_typedef ((*argp)->type ())->code () != TYPE_CODE_FUNC)
 	*argp = coerce_array (*argp);
-      t = check_typedef (value_type (*argp));
+      t = check_typedef ((*argp)->type ());
     }
 
   if (t->code () != TYPE_CODE_STRUCT
@@ -2601,16 +2601,16 @@ value_find_oload_method_list (struct value **argp, const char *method,
 {
   struct type *t;
 
-  t = check_typedef (value_type (*argp));
+  t = check_typedef ((*argp)->type ());
 
   /* Code snarfed from value_struct_elt.  */
   while (t->is_pointer_or_reference ())
     {
       *argp = value_ind (*argp);
       /* Don't coerce fn pointer to fn and then back again!  */
-      if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
+      if (check_typedef ((*argp)->type ())->code () != TYPE_CODE_FUNC)
 	*argp = coerce_array (*argp);
-      t = check_typedef (value_type (*argp));
+      t = check_typedef ((*argp)->type ());
     }
 
   if (t->code () != TYPE_CODE_STRUCT
@@ -2641,7 +2641,7 @@ incomplete_type_hint (gdb::array_view<value *> args)
   std::string incomplete_arg_names;
   for (const struct value *arg : args)
     {
-      struct type *t = value_type (arg);
+      struct type *t = arg->type ();
       while (t->code () == TYPE_CODE_PTR)
 	t = t->target_type ();
       if (t->is_stub ())
@@ -2650,7 +2650,7 @@ incomplete_type_hint (gdb::array_view<value *> args)
 	  if (incomplete_types > 0)
 	    incomplete_arg_names += ", ";
 
-	  current_language->print_type (value_type (arg), "", &buffer,
+	  current_language->print_type (arg->type (), "", &buffer,
 				       -1, 0, &type_print_raw_options);
 
 	  incomplete_types++;
@@ -2726,7 +2726,7 @@ find_overload_match (gdb::array_view<value *> args,
 		     const enum noside noside)
 {
   struct value *obj = (objp ? *objp : NULL);
-  struct type *obj_type = obj ? value_type (obj) : NULL;
+  struct type *obj_type = obj ? obj->type () : NULL;
   /* Index of best overloaded function.  */
   int func_oload_champ = -1;
   int method_oload_champ = -1;
@@ -2765,16 +2765,16 @@ find_overload_match (gdb::array_view<value *> args,
 
       /* OBJ may be a pointer value rather than the object itself.  */
       obj = coerce_ref (obj);
-      while (check_typedef (value_type (obj))->code () == TYPE_CODE_PTR)
+      while (check_typedef (obj->type ())->code () == TYPE_CODE_PTR)
 	obj = coerce_ref (value_ind (obj));
-      obj_type_name = value_type (obj)->name ();
+      obj_type_name = obj->type ()->name ();
 
       /* First check whether this is a data member, e.g. a pointer to
 	 a function.  */
-      if (check_typedef (value_type (obj))->code () == TYPE_CODE_STRUCT)
+      if (check_typedef (obj->type ())->code () == TYPE_CODE_STRUCT)
 	{
 	  *valp = search_struct_field (name, obj,
-				       check_typedef (value_type (obj)), 0);
+				       check_typedef (obj->type ()), 0);
 	  if (*valp)
 	    {
 	      *staticp = 1;
@@ -3038,7 +3038,7 @@ find_overload_match (gdb::array_view<value *> args,
 
   if (objp)
     {
-      struct type *temp_type = check_typedef (value_type (temp));
+      struct type *temp_type = check_typedef (temp->type ());
       struct type *objtype = check_typedef (obj_type);
 
       if (temp_type->code () != TYPE_CODE_PTR
@@ -3158,7 +3158,7 @@ find_oload_champ_namespace_loop (gdb::array_view<value *> args,
       arg_types = (struct type **)
 	alloca (args.size () * (sizeof (struct type *)));
       for (ix = 0; ix < args.size (); ix++)
-	arg_types[ix] = value_type (args[ix]);
+	arg_types[ix] = args[ix]->type ();
       add_symbol_overload_list_adl ({arg_types, args.size ()}, func_name,
 				    &new_oload_syms);
     }
@@ -3614,7 +3614,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 		  struct type *type, *tmp;
 
 		  ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
-		  type = check_typedef (value_type (ptr));
+		  type = check_typedef (ptr->type ());
 		  gdb_assert (type != NULL
 			      && type->code () == TYPE_CODE_MEMBERPTR);
 		  tmp = lookup_pointer_type (TYPE_SELF_TYPE (type));
@@ -3631,7 +3631,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 			mem_offset += boff;
 		      else
 			{
-			  struct type *p = check_typedef (value_type (this_v));
+			  struct type *p = check_typedef (this_v->type ());
 			  p = check_typedef (p->target_type ());
 			  if (get_baseclass_offset (p, curtype, this_v,
 						    &boff, &isvirt))
@@ -3741,7 +3741,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 		{
 		  result = allocate_value
 		    (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
-		  cplus_make_method_ptr (value_type (result),
+		  cplus_make_method_ptr (result->type (),
 					 value_contents_writeable (result).data (),
 					 TYPE_FN_FIELD_VOFFSET (f, j), 1);
 		}
@@ -3766,7 +3766,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 	      else
 		{
 		  result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
-		  cplus_make_method_ptr (value_type (result),
+		  cplus_make_method_ptr (result->type (),
 					 value_contents_writeable (result).data (),
 					 value_address (v), 0);
 		}
@@ -3863,7 +3863,7 @@ value_rtti_indirect_type (struct value *v, int *full,
   struct value *target = NULL;
   struct type *type, *real_type, *target_type;
 
-  type = value_type (v);
+  type = v->type ();
   type = check_typedef (type);
   if (TYPE_IS_REFERENCE (type))
     target = coerce_ref (v);
@@ -3894,7 +3894,7 @@ value_rtti_indirect_type (struct value *v, int *full,
   if (real_type)
     {
       /* Copy qualifiers to the referenced object.  */
-      target_type = value_type (target);
+      target_type = target->type ();
       real_type = make_cv_type (TYPE_CONST (target_type),
 				TYPE_VOLATILE (target_type), real_type, NULL);
       if (TYPE_IS_REFERENCE (type))
@@ -3981,7 +3981,7 @@ value_full_object (struct value *argp,
      value_rtti_type used for its computation.  */
   new_val = value_at_lazy (real_type, value_address (argp) - top +
 			   (using_enc ? 0 : value_embedded_offset (argp)));
-  deprecated_set_value_type (new_val, value_type (argp));
+  deprecated_set_value_type (new_val, argp->type ());
   set_value_embedded_offset (new_val, (using_enc
 				       ? top + value_embedded_offset (argp)
 				       : top));
@@ -4045,7 +4045,7 @@ value_slice (struct value *array, int lowbound, int length)
   struct value *slice;
   struct type *array_type;
 
-  array_type = check_typedef (value_type (array));
+  array_type = check_typedef (array->type ());
   if (array_type->code () != TYPE_CODE_ARRAY
       && array_type->code () != TYPE_CODE_STRING)
     error (_("cannot take slice of non-array"));
@@ -4125,7 +4125,7 @@ value_literal_complex (struct value *arg1,
 struct value *
 value_real_part (struct value *value)
 {
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
   struct type *ttype = type->target_type ();
 
   gdb_assert (type->code () == TYPE_CODE_COMPLEX);
@@ -4137,7 +4137,7 @@ value_real_part (struct value *value)
 struct value *
 value_imaginary_part (struct value *value)
 {
-  struct type *type = check_typedef (value_type (value));
+  struct type *type = check_typedef (value->type ());
   struct type *ttype = type->target_type ();
 
   gdb_assert (type->code () == TYPE_CODE_COMPLEX);
@@ -4152,9 +4152,9 @@ cast_into_complex (struct type *type, struct value *val)
 {
   struct type *real_type = type->target_type ();
 
-  if (value_type (val)->code () == TYPE_CODE_COMPLEX)
+  if (val->type ()->code () == TYPE_CODE_COMPLEX)
     {
-      struct type *val_real_type = value_type (val)->target_type ();
+      struct type *val_real_type = val->type ()->target_type ();
       struct value *re_val = allocate_value (val_real_type);
       struct value *im_val = allocate_value (val_real_type);
       int len = val_real_type->length ();
@@ -4166,8 +4166,8 @@ cast_into_complex (struct type *type, struct value *val)
 
       return value_literal_complex (re_val, im_val, type);
     }
-  else if (value_type (val)->code () == TYPE_CODE_FLT
-	   || value_type (val)->code () == TYPE_CODE_INT)
+  else if (val->type ()->code () == TYPE_CODE_FLT
+	   || val->type ()->code () == TYPE_CODE_INT)
     return value_literal_complex (val, 
 				  value_zero (real_type, not_lval), 
 				  type);
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 04f83f5194a..3899d915981 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -476,7 +476,7 @@ generic_val_print_array (struct value *val,
 			 const struct
 			     generic_val_print_decorations *decorations)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   struct type *unresolved_elttype = type->target_type ();
   struct type *elttype = check_typedef (unresolved_elttype);
 
@@ -511,7 +511,7 @@ generic_value_print_ptr (struct value *val, struct ui_file *stream,
     value_print_scalar_formatted (val, options, 0, stream);
   else
     {
-      struct type *type = check_typedef (value_type (val));
+      struct type *type = check_typedef (val->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);
@@ -770,7 +770,7 @@ generic_value_print_bool
   else
     {
       const gdb_byte *valaddr = value_contents_for_printing (value).data ();
-      struct type *type = check_typedef (value_type (value));
+      struct type *type = check_typedef (value->type ());
       LONGEST val = unpack_long (type, valaddr);
       if (val == 0)
 	gdb_puts (decorations->false_name, stream);
@@ -810,7 +810,7 @@ generic_value_print_char (struct value *value, struct ui_file *stream,
     }
   else
     {
-      struct type *unresolved_type = value_type (value);
+      struct type *unresolved_type = value->type ();
       struct type *type = check_typedef (unresolved_type);
       const gdb_byte *valaddr = value_contents_for_printing (value).data ();
 
@@ -848,7 +848,7 @@ generic_val_print_fixed_point (struct value *val, struct ui_file *stream,
     value_print_scalar_formatted (val, options, 0, stream);
   else
     {
-      struct type *type = value_type (val);
+      struct type *type = val->type ();
 
       const gdb_byte *valaddr = value_contents_for_printing (val).data ();
       gdb_mpf f;
@@ -895,7 +895,7 @@ generic_value_print_memberptr
     {
       /* Member pointers are essentially specific to C++, and so if we
 	 encounter one, we should print it according to C++ rules.  */
-      struct type *type = check_typedef (value_type (val));
+      struct type *type = check_typedef (val->type ());
       const gdb_byte *valaddr = value_contents_for_printing (val).data ();
       cp_print_class_member (valaddr, type, stream, "&");
     }
@@ -910,7 +910,7 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
 		     const struct value_print_options *options,
 		     const struct generic_val_print_decorations *decorations)
 {
-  struct type *type = value_type (val);
+  struct type *type = val->type ();
 
   type = check_typedef (type);
 
@@ -1047,7 +1047,7 @@ common_val_print (struct value *value, struct ui_file *stream, int recurse,
     value_fetch_lazy (value);
 
   struct value_print_options local_opts = *options;
-  struct type *type = value_type (value);
+  struct type *type = value->type ();
   struct type *real_type = check_typedef (type);
 
   if (local_opts.prettyformat == Val_prettyformat_default)
@@ -1134,7 +1134,7 @@ value_check_printable (struct value *val, struct ui_file *stream,
 
   if (value_entirely_optimized_out (val))
     {
-      if (options->summary && !val_print_scalar_type_p (value_type (val)))
+      if (options->summary && !val_print_scalar_type_p (val->type ()))
 	gdb_printf (stream, "...");
       else
 	val_print_optimized_out (val, stream);
@@ -1143,14 +1143,14 @@ value_check_printable (struct value *val, struct ui_file *stream,
 
   if (value_entirely_unavailable (val))
     {
-      if (options->summary && !val_print_scalar_type_p (value_type (val)))
+      if (options->summary && !val_print_scalar_type_p (val->type ()))
 	gdb_printf (stream, "...");
       else
 	val_print_unavailable (stream);
       return 0;
     }
 
-  if (value_type (val)->code () == TYPE_CODE_INTERNAL_FUNCTION)
+  if (val->type ()->code () == TYPE_CODE_INTERNAL_FUNCTION)
     {
       fprintf_styled (stream, metadata_style.style (),
 		      _("<internal function %s>"),
@@ -1158,13 +1158,13 @@ value_check_printable (struct value *val, struct ui_file *stream,
       return 0;
     }
 
-  if (type_not_associated (value_type (val)))
+  if (type_not_associated (val->type ()))
     {
       val_print_not_associated (stream);
       return 0;
     }
 
-  if (type_not_allocated (value_type (val)))
+  if (type_not_allocated (val->type ()))
     {
       val_print_not_allocated (stream);
       return 0;
@@ -1282,7 +1282,7 @@ value_print_scalar_formatted (struct value *val,
 			      int size,
 			      struct ui_file *stream)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   gdb_assert (val != NULL);
 
@@ -1955,7 +1955,7 @@ value_print_array_elements (struct value *val, struct ui_file *stream,
   unsigned int reps;
   LONGEST low_bound, high_bound;
 
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   elttype = type->target_type ();
   unsigned bit_stride = type->bit_stride ();
diff --git a/gdb/value.c b/gdb/value.c
index 7ba46e20e7b..e2e641386a3 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -165,7 +165,7 @@ value::~value ()
 struct gdbarch *
 get_value_arch (const struct value *value)
 {
-  return value_type (value)->arch ();
+  return value->type ()->arch ();
 }
 
 int
@@ -894,11 +894,6 @@ allocate_optimized_out_value (struct type *type)
 
 /* Accessor methods.  */
 
-struct type *
-value_type (const struct value *value)
-{
-  return value->m_type;
-}
 void
 deprecated_set_value_type (struct value *value, struct type *type)
 {
@@ -960,7 +955,7 @@ value_contents_raw (struct value *value)
 
   allocate_value_contents (value);
 
-  ULONGEST length = value_type (value)->length ();
+  ULONGEST length = value->type ()->length ();
   return gdb::make_array_view
     (value->m_contents.get () + value->m_embedded_offset * unit_size, length);
 }
@@ -993,7 +988,7 @@ value_actual_type (struct value *value, int resolve_simple_types,
 
   if (real_type_found)
     *real_type_found = 0;
-  result = value_type (value);
+  result = value->type ();
   if (opts.objectprint)
     {
       /* If result's target type is TYPE_CODE_STRUCT, proceed to
@@ -1197,7 +1192,7 @@ value_contents_copy_raw_bitwise (struct value *dst, LONGEST dst_bit_offset,
   copy_bitwise (dst_contents.data (), dst_bit_offset,
 		src_contents.data (), src_bit_offset,
 		bit_length,
-		type_byte_order (value_type (src)) == BFD_ENDIAN_BIG);
+		type_byte_order (src->type ()) == BFD_ENDIAN_BIG);
 
   /* Copy the meta-data.  */
   value_ranges_copy_adjusted (dst, dst_bit_offset,
@@ -1399,10 +1394,10 @@ value_address (const struct value *value)
     return 0;
   if (value->m_parent != NULL)
     return value_address (value->m_parent.get ()) + value->m_offset;
-  if (NULL != TYPE_DATA_LOCATION (value_type (value)))
+  if (NULL != TYPE_DATA_LOCATION (value->type ()))
     {
-      gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value_type (value)));
-      return TYPE_DATA_LOCATION_ADDR (value_type (value));
+      gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value->type ()));
+      return TYPE_DATA_LOCATION_ADDR (value->type ());
     }
 
   return value->m_location.address + value->m_offset;
@@ -1600,7 +1595,7 @@ value_copy (const value *arg)
 struct value *
 make_cv_value (int cnst, int voltl, struct value *v)
 {
-  struct type *val_type = value_type (v);
+  struct type *val_type = v->type ();
   struct type *m_enclosing_type = value_enclosing_type (v);
   struct value *cv_val = value_copy (v);
 
@@ -1638,7 +1633,7 @@ value_force_lval (struct value *v, CORE_ADDR addr)
 {
   gdb_assert (VALUE_LVAL (v) == not_lval);
 
-  write_memory (addr, value_contents_raw (v).data (), value_type (v)->length ());
+  write_memory (addr, value_contents_raw (v).data (), v->type ()->length ());
   v->m_lval = lval_memory;
   v->m_location.address = addr;
 }
@@ -1667,14 +1662,14 @@ set_value_component_location (struct value *component,
 
   /* If the WHOLE value has a dynamically resolved location property then
      update the address of the COMPONENT.  */
-  type = value_type (whole);
+  type = whole->type ();
   if (NULL != TYPE_DATA_LOCATION (type)
       && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
     set_value_address (component, TYPE_DATA_LOCATION_ADDR (type));
 
   /* Similarly, if the COMPONENT value has a dynamically resolved location
      property then update its address.  */
-  type = value_type (component);
+  type = component->type ();
   if (NULL != TYPE_DATA_LOCATION (type)
       && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
     {
@@ -2132,7 +2127,7 @@ get_internalvar_integer (struct internalvar *var, LONGEST *result)
 
   if (var->kind == INTERNALVAR_VALUE)
     {
-      struct type *type = check_typedef (value_type (var->u.value));
+      struct type *type = check_typedef (var->u.value->type ());
 
       if (type->code () == TYPE_CODE_INT)
 	{
@@ -2176,11 +2171,11 @@ set_internalvar_component (struct internalvar *var,
       unit_size = gdbarch_addressable_memory_unit_size (arch);
 
       if (bitsize)
-	modify_field (value_type (var->u.value), addr + offset,
+	modify_field (var->u.value->type (), addr + offset,
 		      value_as_long (newval), bitpos, bitsize);
       else
 	memcpy (addr + offset * unit_size, value_contents (newval).data (),
-		value_type (newval)->length ());
+		newval->type ()->length ());
       break;
 
     default:
@@ -2199,7 +2194,7 @@ set_internalvar (struct internalvar *var, struct value *val)
     error (_("Cannot overwrite convenience function %s"), var->name);
 
   /* Prepare new contents.  */
-  switch (check_typedef (value_type (val))->code ())
+  switch (check_typedef (val->type ())->code ())
     {
     case TYPE_CODE_VOID:
       new_kind = INTERNALVAR_VOID;
@@ -2236,7 +2231,7 @@ set_internalvar (struct internalvar *var, struct value *val)
 	 when accessing the value.
 	 If we keep it, we would still refer to the origin value.
 	 Remove the location property in case it exist.  */
-      value_type (new_data.value)->remove_dyn_prop (DYN_PROP_DATA_LOCATION);
+      new_data.value->type ()->remove_dyn_prop (DYN_PROP_DATA_LOCATION);
 
       break;
     }
@@ -2554,7 +2549,7 @@ value_from_xmethod (xmethod_worker_up &&worker)
 struct type *
 result_type_of_xmethod (struct value *method, gdb::array_view<value *> argv)
 {
-  gdb_assert (value_type (method)->code () == TYPE_CODE_XMETHOD
+  gdb_assert (method->type ()->code () == TYPE_CODE_XMETHOD
 	      && method->m_lval == lval_xcallable && !argv.empty ());
 
   return method->m_location.xm_worker->get_result_type (argv[0], argv.slice (1));
@@ -2565,7 +2560,7 @@ result_type_of_xmethod (struct value *method, gdb::array_view<value *> argv)
 struct value *
 call_xmethod (struct value *method, gdb::array_view<value *> argv)
 {
-  gdb_assert (value_type (method)->code () == TYPE_CODE_XMETHOD
+  gdb_assert (method->type ()->code () == TYPE_CODE_XMETHOD
 	      && method->m_lval == lval_xcallable && !argv.empty ());
 
   return method->m_location.xm_worker->invoke (argv[0], argv.slice (1));
@@ -2583,7 +2578,7 @@ value_as_long (struct value *val)
      in disassemble_command).  It also dereferences references, which
      I suspect is the most logical thing to do.  */
   val = coerce_array (val);
-  return unpack_long (value_type (val), value_contents (val).data ());
+  return unpack_long (val->type (), value_contents (val).data ());
 }
 
 /* Extract a value as a C pointer.  Does not deallocate the value.
@@ -2592,7 +2587,7 @@ value_as_long (struct value *val)
 CORE_ADDR
 value_as_address (struct value *val)
 {
-  struct gdbarch *gdbarch = value_type (val)->arch ();
+  struct gdbarch *gdbarch = val->type ()->arch ();
 
   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
      whether we want this to be true eventually.  */
@@ -2621,7 +2616,7 @@ value_as_address (struct value *val)
      cannot be modified.
 
      Upon entry to this function, if VAL is a value of type `function'
-     (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
+     (that is, TYPE_CODE (val->type ()) == TYPE_CODE_FUNC), then
      value_address (val) is the address of the function.  This is what
      you'll get if you evaluate an expression like `main'.  The call
      to COERCE_ARRAY below actually does all the usual unary
@@ -2640,8 +2635,8 @@ value_as_address (struct value *val)
 
      The following shortcut avoids this whole mess.  If VAL is a
      function, just return its address directly.  */
-  if (value_type (val)->code () == TYPE_CODE_FUNC
-      || value_type (val)->code () == TYPE_CODE_METHOD)
+  if (val->type ()->code () == TYPE_CODE_FUNC
+      || val->type ()->code () == TYPE_CODE_METHOD)
     return value_address (val);
 
   val = coerce_array (val);
@@ -2683,12 +2678,12 @@ value_as_address (struct value *val)
      converted to pointers; usually, the ABI doesn't either, but
      ABI-specific code is a more reasonable place to handle it.  */
 
-  if (!value_type (val)->is_pointer_or_reference ()
+  if (!val->type ()->is_pointer_or_reference ()
       && gdbarch_integer_to_address_p (gdbarch))
-    return gdbarch_integer_to_address (gdbarch, value_type (val),
+    return gdbarch_integer_to_address (gdbarch, val->type (),
 				       value_contents (val).data ());
 
-  return unpack_long (value_type (val), value_contents (val).data ());
+  return unpack_long (val->type (), value_contents (val).data ());
 #endif
 }
 
@@ -2808,7 +2803,7 @@ unpack_pointer (struct type *type, const gdb_byte *valaddr)
 bool
 is_floating_value (struct value *val)
 {
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   if (is_floating_type (type))
     {
@@ -3017,7 +3012,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
 struct value *
 value_field (struct value *arg1, int fieldno)
 {
-  return value_primitive_field (arg1, 0, fieldno, value_type (arg1));
+  return value_primitive_field (arg1, 0, fieldno, arg1->type ());
 }
 
 /* Return a non-virtual function as a value.
@@ -3067,7 +3062,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
 
   if (arg1p)
     {
-      if (type != value_type (*arg1p))
+      if (type != (*arg1p)->type ())
 	*arg1p = value_ind (value_cast (lookup_pointer_type (type),
 					value_addr (*arg1p)));
 
@@ -3193,7 +3188,7 @@ unpack_value_bitfield (struct value *dest_val,
   enum bfd_endian byte_order;
   int src_bit_offset;
   int dst_bit_offset;
-  struct type *field_type = value_type (dest_val);
+  struct type *field_type = dest_val->type ();
 
   byte_order = type_byte_order (field_type);
 
@@ -3456,7 +3451,7 @@ value_from_host_double (struct type *type, double d)
   struct value *value = allocate_value (type);
   gdb_assert (type->code () == TYPE_CODE_FLT);
   target_float_from_host_double (value_contents_raw (value).data (),
-				 value_type (value), d);
+				 value->type (), d);
   return value;
 }
 
@@ -3647,7 +3642,7 @@ coerce_ref_if_computed (const struct value *arg)
 {
   const struct lval_funcs *funcs;
 
-  if (!TYPE_IS_REFERENCE (check_typedef (value_type (arg))))
+  if (!TYPE_IS_REFERENCE (check_typedef (arg->type ())))
     return NULL;
 
   if (value_lval_const (arg) != lval_computed)
@@ -3690,7 +3685,7 @@ readjust_indirect_value_type (struct value *value, struct type *enc_type,
 struct value *
 coerce_ref (struct value *arg)
 {
-  struct type *value_type_arg_tmp = check_typedef (value_type (arg));
+  struct type *value_type_arg_tmp = check_typedef (arg->type ());
   struct value *retval;
   struct type *enc_type;
 
@@ -3704,9 +3699,9 @@ coerce_ref (struct value *arg)
   enc_type = check_typedef (value_enclosing_type (arg));
   enc_type = enc_type->target_type ();
 
-  CORE_ADDR addr = unpack_pointer (value_type (arg), value_contents (arg).data ());
+  CORE_ADDR addr = unpack_pointer (arg->type (), value_contents (arg).data ());
   retval = value_at_lazy (enc_type, addr);
-  enc_type = value_type (retval);
+  enc_type = retval->type ();
   return readjust_indirect_value_type (retval, enc_type, value_type_arg_tmp,
 				       arg, addr);
 }
@@ -3717,7 +3712,7 @@ coerce_array (struct value *arg)
   struct type *type;
 
   arg = coerce_ref (arg);
-  type = check_typedef (value_type (arg));
+  type = check_typedef (arg->type ());
 
   switch (type->code ())
     {
@@ -3828,7 +3823,7 @@ value_fetch_lazy_register (struct value *val)
 {
   frame_info_ptr next_frame;
   int regnum;
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
   struct value *new_val = val, *mark = value_mark ();
 
   /* Offsets are not supported here; lazy register values must
@@ -3988,7 +3983,7 @@ isvoid_internal_fn (struct gdbarch *gdbarch,
   if (argc != 1)
     error (_("You must provide one argument for $_isvoid."));
 
-  ret = value_type (argv[0])->code () == TYPE_CODE_VOID;
+  ret = argv[0]->type ()->code () == TYPE_CODE_VOID;
 
   return value_from_longest (builtin_type (gdbarch)->builtin_int, ret);
 }
@@ -4005,7 +4000,7 @@ creal_internal_fn (struct gdbarch *gdbarch,
     error (_("You must provide one argument for $_creal."));
 
   value *cval = argv[0];
-  type *ctype = check_typedef (value_type (cval));
+  type *ctype = check_typedef (cval->type ());
   if (ctype->code () != TYPE_CODE_COMPLEX)
     error (_("expected a complex number"));
   return value_real_part (cval);
@@ -4024,7 +4019,7 @@ cimag_internal_fn (struct gdbarch *gdbarch,
     error (_("You must provide one argument for $_cimag."));
 
   value *cval = argv[0];
-  type *ctype = check_typedef (value_type (cval));
+  type *ctype = check_typedef (cval->type ());
   if (ctype->code () != TYPE_CODE_COMPLEX)
     error (_("expected a complex number"));
   return value_imaginary_part (cval);
diff --git a/gdb/value.h b/gdb/value.h
index ea549a8cb81..f4a488c9263 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -159,6 +159,11 @@ struct value
 
   DISABLE_COPY_AND_ASSIGN (value);
 
+  /* Type of the value.  */
+  struct type *type () const
+  { return m_type; }
+
+
   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */
   enum lval_type m_lval = not_lval;
@@ -325,10 +330,6 @@ struct value
   std::vector<range> m_optimized_out;
 };
 
-/* Type of the value.  */
-
-extern struct type *value_type (const struct value *);
-
 /* Return the gdbarch associated with the value. */
 
 extern struct gdbarch *get_value_arch (const struct value *value);
diff --git a/gdb/varobj.c b/gdb/varobj.c
index eb47ecada3e..fb846fd65c7 100644
--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -377,7 +377,7 @@ varobj_create (const char *objname,
 	     right type.  */
 	  struct value *type_only_value = evaluate_type (var->root->exp.get ());
 
-	  var->type = value_type (type_only_value);
+	  var->type = type_only_value->type ();
 	}
 
       if (value != NULL)
@@ -1370,7 +1370,7 @@ install_new_value (struct varobj *var, struct value *value, bool initial)
     }
   var->print_value = print_value;
 
-  gdb_assert (var->value == nullptr || value_type (var->value.get ()));
+  gdb_assert (var->value == nullptr || var->value.get ()->type ());
 
   return changed;
 }
@@ -1550,7 +1550,7 @@ varobj_update (struct varobj **varp, bool is_explicit)
 	  if (update_type_if_necessary (v, newobj))
 	    r.type_changed = true;
 	  if (newobj)
-	    new_type = value_type (newobj);
+	    new_type = newobj->type ();
 	  else
 	    new_type = v->root->lang_ops->type_of_child (v->parent, v->index);
 
@@ -1886,7 +1886,7 @@ varobj_get_value_type (const struct varobj *var)
   struct type *type;
 
   if (var->value != nullptr)
-    type = value_type (var->value.get ());
+    type = var->value.get ()->type ();
   else
     type = var->type;
 
@@ -2098,7 +2098,7 @@ value_of_root (struct varobj **var_handle, bool *type_changed)
 	/* For root varobj-s, a NULL value indicates a scoping issue.
 	   So, nothing to do in terms of checking for mutations.  */
       }
-    else if (varobj_value_has_mutated (var, value, value_type (value)))
+    else if (varobj_value_has_mutated (var, value, value->type ()))
       {
 	/* The type has mutated, so the children are no longer valid.
 	   Just delete them, and tell our caller that the type has
@@ -2229,7 +2229,7 @@ varobj_value_get_print_value (struct value *value,
 
 			  thevalue = std::string (s.get ());
 			  len = thevalue.size ();
-			  gdbarch = value_type (value)->arch ();
+			  gdbarch = value->type ()->arch ();
 			  type = builtin_type (gdbarch)->builtin_char;
 
 			  if (!string_print)
diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c
index 00c700422a1..af21aa159f4 100644
--- a/gdb/windows-tdep.c
+++ b/gdb/windows-tdep.c
@@ -400,7 +400,7 @@ static void
 tlb_value_read (struct value *val)
 {
   CORE_ADDR tlb;
-  struct type *type = check_typedef (value_type (val));
+  struct type *type = check_typedef (val->type ());
 
   if (!target_get_tib_address (inferior_ptid, &tlb))
     error (_("Unable to read tlb"));
diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
index 8476fecf3a7..c3d175adff6 100644
--- a/gdb/xtensa-tdep.c
+++ b/gdb/xtensa-tdep.c
@@ -1712,7 +1712,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
       for (int i = 0; i < nargs; i++)
 	{
 	  struct value *arg = args[i];
-	  struct type *arg_type = check_typedef (value_type (arg));
+	  struct type *arg_type = check_typedef (arg->type ());
 	  gdb_printf (gdb_stdlog, "%2d: %s %3s ", i,
 		      host_address_to_string (arg),
 		      pulongest (arg_type->length ()));
@@ -1748,7 +1748,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
     {
       struct argument_info *info = &arg_info[i];
       struct value *arg = args[i];
-      struct type *arg_type = check_typedef (value_type (arg));
+      struct type *arg_type = check_typedef (arg->type ());
 
       switch (arg_type->code ())
 	{
