Automatic date update in version.in

[binutils.git] / gdb / ada-lang.c

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index f097ad4b6f77bf45063ceecbb95a75be486e3c5b..5054bdb2957210226630b9869e180d2fb03dc96a 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -334,7 +334,7 @@ struct ada_inferior_data
 };
 
 /* Our key to this module's inferior data.  */
 };
 
 /* Our key to this module's inferior data.  */

-static const struct inferior_key<ada_inferior_data> ada_inferior_data;
+static const registry<inferior>::key<ada_inferior_data> ada_inferior_data;

 
 /* Return our inferior data for the given inferior (INF).
 
 
 /* Return our inferior data for the given inferior (INF).
 


@@ -376,7 +376,8 @@ struct ada_pspace_data
 };
 
 /* Key to our per-program-space data.  */
 };
 
 /* Key to our per-program-space data.  */

-static const struct program_space_key<ada_pspace_data> ada_pspace_data_handle;
+static const registry<program_space>::key<ada_pspace_data>
+  ada_pspace_data_handle;

 
 /* Return this module's data for the given program space (PSPACE).
    If not is found, add a zero'ed one now.
 
 /* Return this module's data for the given program space (PSPACE).
    If not is found, add a zero'ed one now.


@@ -428,7 +429,7 @@ static struct type *
 ada_typedef_target_type (struct type *type)
 {
   while (type->code () == TYPE_CODE_TYPEDEF)
 ada_typedef_target_type (struct type *type)
 {
   while (type->code () == TYPE_CODE_TYPEDEF)

-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();

   return type;
 }
 
   return type;
 }
 


@@ -559,12 +560,12 @@ 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
       else if (value_lazy (val)
               /* Be careful not to make a lazy not_lval value.  */
               || (VALUE_LVAL (val) != not_lval

-                  && TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val))))
+                  && type->length () > value_type (val)->length ()))

        result = allocate_value_lazy (type);
       else
        {
          result = allocate_value (type);
        result = allocate_value_lazy (type);
       else
        {
          result = allocate_value (type);

-         value_contents_copy (result, 0, val, 0, TYPE_LENGTH (type));
+         value_contents_copy (result, 0, val, 0, type->length ());

        }
       set_value_component_location (result, val);
       set_value_bitsize (result, value_bitsize (val));
        }
       set_value_component_location (result, val);
       set_value_bitsize (result, value_bitsize (val));


@@ -645,9 +646,9 @@ static LONGEST
 max_of_type (struct type *t)
 {
   if (t->is_unsigned ())
 max_of_type (struct type *t)
 {
   if (t->is_unsigned ())

-    return (LONGEST) umax_of_size (TYPE_LENGTH (t));
+    return (LONGEST) umax_of_size (t->length ());

   else
   else

-    return max_of_size (TYPE_LENGTH (t));
+    return max_of_size (t->length ());

 }
 
 /* Minimum value of integral type T, as a signed quantity.  */
 }
 
 /* Minimum value of integral type T, as a signed quantity.  */


@@ -657,7 +658,7 @@ min_of_type (struct type *t)
   if (t->is_unsigned ())
     return 0;
   else
   if (t->is_unsigned ())
     return 0;
   else

-    return min_of_size (TYPE_LENGTH (t));
+    return min_of_size (t->length ());

 }
 
 /* The largest value in the domain of TYPE, a discrete type, as an integer.  */
 }
 
 /* The largest value in the domain of TYPE, a discrete type, as an integer.  */


@@ -738,9 +739,9 @@ get_base_type (struct type *type)
 {
   while (type != NULL && type->code () == TYPE_CODE_RANGE)
     {
 {
   while (type != NULL && type->code () == TYPE_CODE_RANGE)
     {

-      if (type == TYPE_TARGET_TYPE (type) || TYPE_TARGET_TYPE (type) == NULL)
+      if (type == type->target_type () || type->target_type () == NULL)

        return type;
        return type;

-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();

     }
   return type;
 }
     }
   return type;
 }


@@ -819,7 +820,7 @@ ada_main_name (void)
 
   if (msym.minsym != NULL)
     {
 
   if (msym.minsym != NULL)
     {

-      CORE_ADDR main_program_name_addr = BMSYMBOL_VALUE_ADDRESS (msym);
+      CORE_ADDR main_program_name_addr = msym.value_address ();

       if (main_program_name_addr == 0)
        error (_("Invalid address for Ada main program name."));
 
       if (main_program_name_addr == 0)
        error (_("Invalid address for Ada main program name."));
 


@@ -1145,12 +1146,14 @@ ada_fold_name (gdb::string_view name, bool throw_on_error = false)
   return fold_storage.c_str ();
 }
 
   return fold_storage.c_str ();
 }
 

-/* The "encoded" form of DECODED, according to GNAT conventions.  */
+/* The "encoded" form of DECODED, according to GNAT conventions.  If
+   FOLD is true (the default), case-fold any ordinary symbol.  Symbols
+   with <...> quoting are not folded in any case.  */

 
 std::string
 
 std::string

-ada_encode (const char *decoded)
+ada_encode (const char *decoded, bool fold)

 {
 {

-  if (decoded[0] != '<')
+  if (fold && decoded[0] != '<')

     decoded = ada_fold_name (decoded);
   return ada_encode_1 (decoded, true);
 }
     decoded = ada_fold_name (decoded);
   return ada_encode_1 (decoded, true);
 }


@@ -1304,7 +1307,7 @@ convert_from_hex_encoded (std::string &out, const char *str, int n)
 /* See ada-lang.h.  */
 
 std::string
 /* See ada-lang.h.  */
 
 std::string

-ada_decode (const char *encoded, bool wrap)
+ada_decode (const char *encoded, bool wrap, bool operators)

 {
   int i;
   int len0;
 {
   int i;
   int len0;


@@ -1323,6 +1326,11 @@ ada_decode (const char *encoded, bool wrap)
      if we see this prefix.  */
   if (startswith (encoded, "_ada_"))
     encoded += 5;
      if we see this prefix.  */
   if (startswith (encoded, "_ada_"))
     encoded += 5;

+  /* The "___ghost_" prefix is used for ghost entities.  Normally
+     these aren't preserved but when they are, it's useful to see
+     them.  */
+  if (startswith (encoded, "___ghost_"))
+    encoded += 9;

 
   /* If the name starts with '_', then it is not a properly encoded
      name, so do not attempt to decode it.  Similarly, if the name
 
   /* If the name starts with '_', then it is not a properly encoded
      name, so do not attempt to decode it.  Similarly, if the name


@@ -1394,7 +1402,7 @@ ada_decode (const char *encoded, bool wrap)
   while (i < len0)
     {
       /* Is this a symbol function?  */
   while (i < len0)
     {
       /* Is this a symbol function?  */

-      if (at_start_name && encoded[i] == 'O')
+      if (operators && at_start_name && encoded[i] == 'O')

        {
          int k;
 
        {
          int k;
 


@@ -1553,9 +1561,12 @@ ada_decode (const char *encoded, bool wrap)
   /* Decoded names should never contain any uppercase character.
      Double-check this, and abort the decoding if we find one.  */
 
   /* Decoded names should never contain any uppercase character.
      Double-check this, and abort the decoding if we find one.  */
 

-  for (i = 0; i < decoded.length(); ++i)
-    if (isupper (decoded[i]) || decoded[i] == ' ')
-      goto Suppress;
+  if (operators)
+    {
+      for (i = 0; i < decoded.length(); ++i)
+       if (isupper (decoded[i]) || decoded[i] == ' ')
+         goto Suppress;
+    }

 
   /* If the compiler added a suffix, append it now.  */
   if (suffix >= 0)
 
   /* If the compiler added a suffix, append it now.  */
   if (suffix >= 0)


@@ -1703,7 +1714,7 @@ desc_base_type (struct type *type)
   if (type != NULL
       && (type->code () == TYPE_CODE_PTR
          || type->code () == TYPE_CODE_REF))
   if (type != NULL
       && (type->code () == TYPE_CODE_PTR
          || type->code () == TYPE_CODE_REF))

-    return ada_check_typedef (TYPE_TARGET_TYPE (type));
+    return ada_check_typedef (type->target_type ());

   else
     return type;
 }
   else
     return type;
 }


@@ -1791,7 +1802,7 @@ desc_bounds_type (struct type *type)
     {
       r = lookup_struct_elt_type (type, "P_BOUNDS", 1);
       if (r != NULL)
     {
       r = lookup_struct_elt_type (type, "P_BOUNDS", 1);
       if (r != NULL)

-       return ada_check_typedef (TYPE_TARGET_TYPE (ada_check_typedef (r)));
+       return ada_check_typedef (ada_check_typedef (r)->target_type ());

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -1823,7 +1834,7 @@ desc_bounds (struct value *arr)
 
       return
        value_from_longest (lookup_pointer_type (bounds_type),
 
       return
        value_from_longest (lookup_pointer_type (bounds_type),

-                           addr - TYPE_LENGTH (bounds_type));
+                           addr - bounds_type->length ());

     }
 
   else if (is_thick_pntr (type))
     }
 
   else if (is_thick_pntr (type))


@@ -1835,7 +1846,7 @@ desc_bounds (struct value *arr)
       if (p_bounds_type
          && p_bounds_type->code () == TYPE_CODE_PTR)
        {
       if (p_bounds_type
          && p_bounds_type->code () == TYPE_CODE_PTR)
        {

-         struct type *target_type = TYPE_TARGET_TYPE (p_bounds_type);
+         struct type *target_type = p_bounds_type->target_type ();

 
          if (target_type->is_stub ())
            p_bounds = value_cast (lookup_pointer_type
 
          if (target_type->is_stub ())
            p_bounds = value_cast (lookup_pointer_type


@@ -1871,7 +1882,7 @@ fat_pntr_bounds_bitsize (struct type *type)
   if (TYPE_FIELD_BITSIZE (type, 1) > 0)
     return TYPE_FIELD_BITSIZE (type, 1);
   else
   if (TYPE_FIELD_BITSIZE (type, 1) > 0)
     return TYPE_FIELD_BITSIZE (type, 1);
   else

-    return 8 * TYPE_LENGTH (ada_check_typedef (type->field (1).type ()));
+    return 8 * ada_check_typedef (type->field (1).type ())->length ();

 }
 
 /* If TYPE is the type of an array descriptor (fat or thin pointer) or a
 }
 
 /* If TYPE is the type of an array descriptor (fat or thin pointer) or a


@@ -1893,7 +1904,7 @@ desc_data_target_type (struct type *type)
 
       if (data_type
          && ada_check_typedef (data_type)->code () == TYPE_CODE_PTR)
 
       if (data_type
          && ada_check_typedef (data_type)->code () == TYPE_CODE_PTR)

-       return ada_check_typedef (TYPE_TARGET_TYPE (data_type));
+       return ada_check_typedef (data_type->target_type ());

     }
 
   return NULL;
     }
 
   return NULL;


@@ -1937,7 +1948,7 @@ fat_pntr_data_bitsize (struct type *type)
   if (TYPE_FIELD_BITSIZE (type, 0) > 0)
     return TYPE_FIELD_BITSIZE (type, 0);
   else
   if (TYPE_FIELD_BITSIZE (type, 0) > 0)
     return TYPE_FIELD_BITSIZE (type, 0);
   else

-    return TARGET_CHAR_BIT * TYPE_LENGTH (type->field (0).type ());
+    return TARGET_CHAR_BIT * type->field (0).type ()->length ();

 }
 
 /* If BOUNDS is an array-bounds structure (or pointer to one), return
 }
 
 /* If BOUNDS is an array-bounds structure (or pointer to one), return


@@ -1976,7 +1987,7 @@ desc_bound_bitsize (struct type *type, int i, int which)
   if (TYPE_FIELD_BITSIZE (type, 2 * i + which - 2) > 0)
     return TYPE_FIELD_BITSIZE (type, 2 * i + which - 2);
   else
   if (TYPE_FIELD_BITSIZE (type, 2 * i + which - 2) > 0)
     return TYPE_FIELD_BITSIZE (type, 2 * i + which - 2);
   else

-    return 8 * TYPE_LENGTH (type->field (2 * i + which - 2).type ());
+    return 8 * type->field (2 * i + which - 2).type ()->length ();

 }
 
 /* If TYPE is the type of an array-bounds structure, the type of its
 }
 
 /* If TYPE is the type of an array-bounds structure, the type of its


@@ -2033,7 +2044,7 @@ ada_is_array_type (struct type *type)
   while (type != NULL
         && (type->code () == TYPE_CODE_PTR
             || type->code () == TYPE_CODE_REF))
   while (type != NULL
         && (type->code () == TYPE_CODE_PTR
             || type->code () == TYPE_CODE_REF))

-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();

   return ada_is_direct_array_type (type);
 }
 
   return ada_is_direct_array_type (type);
 }
 


@@ -2047,7 +2058,7 @@ ada_is_simple_array_type (struct type *type)
   type = ada_check_typedef (type);
   return (type->code () == TYPE_CODE_ARRAY
          || (type->code () == TYPE_CODE_PTR
   type = ada_check_typedef (type);
   return (type->code () == TYPE_CODE_ARRAY
          || (type->code () == TYPE_CODE_PTR

-             && (ada_check_typedef (TYPE_TARGET_TYPE (type))->code ()
+             && (ada_check_typedef (type->target_type ())->code ()

                  == TYPE_CODE_ARRAY)));
 }
 
                  == TYPE_CODE_ARRAY)));
 }
 


@@ -2156,7 +2167,7 @@ ada_type_of_array (struct value *arr, int bounds)
                  int array_bitsize =
                        (hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
 
                  int array_bitsize =
                        (hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
 

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

                }
            }
        }
                }
            }
        }


@@ -2268,7 +2279,7 @@ ada_is_unconstrained_packed_array_type (struct type *type)
       type = desc_base_type (type);
       /* The structure's first field is a pointer to an array, so this
         fetches the array type.  */
       type = desc_base_type (type);
       /* The structure's first field is a pointer to an array, so this
         fetches the array type.  */

-      type = TYPE_TARGET_TYPE (type->field (0).type ());
+      type = type->field (0).type ()->target_type ();

       if (type->code () == TYPE_CODE_TYPEDEF)
        type = ada_typedef_target_type (type);
       /* Now we can see if the array elements are packed.  */
       if (type->code () == TYPE_CODE_TYPEDEF)
        type = ada_typedef_target_type (type);
       /* Now we can see if the array elements are packed.  */


@@ -2318,7 +2329,7 @@ decode_packed_array_bitsize (struct type *type)
       gdb_assert (is_thick_pntr (type));
       /* The structure's first field is a pointer to an array, so this
         fetches the array type.  */
       gdb_assert (is_thick_pntr (type));
       /* The structure's first field is a pointer to an array, so this
         fetches the array type.  */

-      type = TYPE_TARGET_TYPE (type->field (0).type ());
+      type = type->field (0).type ()->target_type ();

       /* Now we can see if the array elements are packed.  */
       return TYPE_FIELD_BITSIZE (type, 0);
     }
       /* Now we can see if the array elements are packed.  */
       return TYPE_FIELD_BITSIZE (type, 0);
     }


@@ -2372,7 +2383,7 @@ constrained_packed_array_type (struct type *type, long *elt_bits)
 
   new_type = alloc_type_copy (type);
   new_elt_type =
 
   new_type = alloc_type_copy (type);
   new_elt_type =

-    constrained_packed_array_type (ada_check_typedef (TYPE_TARGET_TYPE (type)),
+    constrained_packed_array_type (ada_check_typedef (type->target_type ()),

                                   elt_bits);
   create_array_type (new_type, new_elt_type, index_type);
   TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;
                                   elt_bits);
   create_array_type (new_type, new_elt_type, index_type);
   TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;


@@ -2383,12 +2394,14 @@ constrained_packed_array_type (struct type *type, long *elt_bits)
       || !get_discrete_bounds (index_type, &low_bound, &high_bound))
     low_bound = high_bound = 0;
   if (high_bound < low_bound)
       || !get_discrete_bounds (index_type, &low_bound, &high_bound))
     low_bound = high_bound = 0;
   if (high_bound < low_bound)

-    *elt_bits = TYPE_LENGTH (new_type) = 0;
+    {
+      *elt_bits = 0;
+      new_type->set_length (0);
+    }

   else
     {
       *elt_bits *= (high_bound - low_bound + 1);
   else
     {
       *elt_bits *= (high_bound - low_bound + 1);

-      TYPE_LENGTH (new_type) =
-       (*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
+      new_type->set_length ((*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);

     }
 
   new_type->set_is_fixed_instance (true);
     }
 
   new_type->set_is_fixed_instance (true);


@@ -2455,15 +2468,15 @@ recursively_update_array_bitsize (struct type *type)
     return 0;
   LONGEST our_len = high - low + 1;
 
     return 0;
   LONGEST our_len = high - low + 1;
 

-  struct type *elt_type = TYPE_TARGET_TYPE (type);
+  struct type *elt_type = type->target_type ();

   if (elt_type->code () == TYPE_CODE_ARRAY)
     {
       LONGEST elt_len = recursively_update_array_bitsize (elt_type);
       LONGEST elt_bitsize = elt_len * TYPE_FIELD_BITSIZE (elt_type, 0);
       TYPE_FIELD_BITSIZE (type, 0) = elt_bitsize;
 
   if (elt_type->code () == TYPE_CODE_ARRAY)
     {
       LONGEST elt_len = recursively_update_array_bitsize (elt_type);
       LONGEST elt_bitsize = elt_len * TYPE_FIELD_BITSIZE (elt_type, 0);
       TYPE_FIELD_BITSIZE (type, 0) = elt_bitsize;
 

-      TYPE_LENGTH (type) = ((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
-                           / HOST_CHAR_BIT);
+      type->set_length (((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
+                        / HOST_CHAR_BIT));

     }
 
   return our_len;
     }
 
   return our_len;


@@ -2506,7 +2519,7 @@ decode_constrained_packed_array (struct value *arr)
   const gdb_byte *valaddr = value_contents_for_printing (arr).data ();
   CORE_ADDR address = value_address (arr);
   gdb::array_view<const gdb_byte> view
   const gdb_byte *valaddr = value_contents_for_printing (arr).data ();
   CORE_ADDR address = value_address (arr);
   gdb::array_view<const gdb_byte> view

-    = gdb::make_array_view (valaddr, TYPE_LENGTH (type));
+    = gdb::make_array_view (valaddr, type->length ());

   type = resolve_dynamic_type (type, view, address);
   recursively_update_array_bitsize (type);
 
   type = resolve_dynamic_type (type, view, address);
   recursively_update_array_bitsize (type);
 


@@ -2527,7 +2540,7 @@ decode_constrained_packed_array (struct value *arr)
          bit_size += 1;
          mod >>= 1;
        }
          bit_size += 1;
          mod >>= 1;
        }

-      bit_pos = HOST_CHAR_BIT * TYPE_LENGTH (value_type (arr)) - bit_size;
+      bit_pos = HOST_CHAR_BIT * value_type (arr)->length () - bit_size;

       arr = ada_value_primitive_packed_val (arr, NULL,
                                            bit_pos / HOST_CHAR_BIT,
                                            bit_pos % HOST_CHAR_BIT,
       arr = ada_value_primitive_packed_val (arr, NULL,
                                            bit_pos / HOST_CHAR_BIT,
                                            bit_pos % HOST_CHAR_BIT,


@@ -2579,7 +2592,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind)
                         (long) idx);
          bits = TYPE_FIELD_BITSIZE (elt_type, 0);
          elt_total_bit_offset += (idx - lowerbound) * bits;
                         (long) idx);
          bits = TYPE_FIELD_BITSIZE (elt_type, 0);
          elt_total_bit_offset += (idx - lowerbound) * bits;

-         elt_type = ada_check_typedef (TYPE_TARGET_TYPE (elt_type));
+         elt_type = ada_check_typedef (elt_type->target_type ());

        }
     }
   elt_off = elt_total_bit_offset / HOST_CHAR_BIT;
        }
     }
   elt_off = elt_total_bit_offset / HOST_CHAR_BIT;


@@ -2779,7 +2792,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
                                is_big_endian, has_negatives (type),
                                is_scalar);
       type = resolve_dynamic_type (type, staging, 0);
                                is_big_endian, has_negatives (type),
                                is_scalar);
       type = resolve_dynamic_type (type, staging, 0);

-      if (TYPE_LENGTH (type) < (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT)
+      if (type->length () < (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT)

        {
          /* This happens when the length of the object is dynamic,
             and is actually smaller than the space reserved for it.
        {
          /* This happens when the length of the object is dynamic,
             and is actually smaller than the space reserved for it.


@@ -2788,7 +2801,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
             normally equal to the maximum size of its element.
             But, in reality, each element only actually spans a portion
             of that stride.  */
             normally equal to the maximum size of its element.
             But, in reality, each element only actually spans a portion
             of that stride.  */

-         bit_size = TYPE_LENGTH (type) * HOST_CHAR_BIT;
+         bit_size = type->length () * HOST_CHAR_BIT;

        }
     }
 
        }
     }
 


@@ -2837,11 +2850,11 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
 
   if (bit_size == 0)
     {
 
   if (bit_size == 0)
     {

-      memset (unpacked, 0, TYPE_LENGTH (type));
+      memset (unpacked, 0, type->length ());

       return v;
     }
 
       return v;
     }
 

-  if (staging.size () == TYPE_LENGTH (type))
+  if (staging.size () == type->length ())

     {
       /* Small short-cut: If we've unpacked the data into a buffer
         of the same size as TYPE's length, then we can reuse that,
     {
       /* Small short-cut: If we've unpacked the data into a buffer
         of the same size as TYPE's length, then we can reuse that,


@@ -2850,7 +2863,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
     }
   else
     ada_unpack_from_contents (src, bit_offset, bit_size,
     }
   else
     ada_unpack_from_contents (src, bit_offset, bit_size,

-                             unpacked, TYPE_LENGTH (type),
+                             unpacked, type->length (),

                              is_big_endian, has_negatives (type), is_scalar);
 
   return v;
                              is_big_endian, has_negatives (type), is_scalar);
 
   return v;


@@ -2896,7 +2909,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
       read_memory (to_addr, buffer, len);
       from_size = value_bitsize (fromval);
       if (from_size == 0)
       read_memory (to_addr, buffer, len);
       from_size = value_bitsize (fromval);
       if (from_size == 0)

-       from_size = TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT;
+       from_size = value_type (fromval)->length () * TARGET_CHAR_BIT;

 
       const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
       ULONGEST from_offset = 0;
 
       const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
       ULONGEST from_offset = 0;


@@ -2910,7 +2923,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
       val = value_copy (toval);
       memcpy (value_contents_raw (val).data (),
              value_contents (fromval).data (),
       val = value_copy (toval);
       memcpy (value_contents_raw (val).data (),
              value_contents (fromval).data (),

-             TYPE_LENGTH (type));
+             type->length ());

       deprecated_set_value_type (val, type);
 
       return val;
       deprecated_set_value_type (val, type);
 
       return val;


@@ -2944,7 +2957,7 @@ value_assign_to_component (struct value *container, struct value *component,
   val = value_cast (value_type (component), val);
 
   if (value_bitsize (component) == 0)
   val = value_cast (value_type (component), val);
 
   if (value_bitsize (component) == 0)

-    bits = TARGET_CHAR_BIT * TYPE_LENGTH (value_type (component));
+    bits = TARGET_CHAR_BIT * value_type (component)->length ();

   else
     bits = value_bitsize (component);
 
   else
     bits = value_bitsize (component);
 


@@ -2954,7 +2967,7 @@ value_assign_to_component (struct value *container, struct value *component,
 
       if (is_scalar_type (check_typedef (value_type (component))))
        src_offset
 
       if (is_scalar_type (check_typedef (value_type (component))))
        src_offset

-         = TYPE_LENGTH (value_type (component)) * TARGET_CHAR_BIT - bits;
+         = value_type (component)->length () * TARGET_CHAR_BIT - bits;

       else
        src_offset = 0;
       copy_bitwise ((value_contents_writeable (container).data ()
       else
        src_offset = 0;
       copy_bitwise ((value_contents_writeable (container).data ()


@@ -2998,7 +3011,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind)
 
   for (k = 0; k < arity; k += 1)
     {
 
   for (k = 0; k < arity; k += 1)
     {

-      struct type *saved_elt_type = TYPE_TARGET_TYPE (elt_type);
+      struct type *saved_elt_type = elt_type->target_type ();

 
       if (elt_type->code () != TYPE_CODE_ARRAY)
        error (_("too many subscripts (%d expected)"), k);
 
       if (elt_type->code () != TYPE_CODE_ARRAY)
        error (_("too many subscripts (%d expected)"), k);


@@ -3059,11 +3072,11 @@ ada_value_ptr_subscript (struct value *arr, int arity, struct value **ind)
 
       if (type->code () != TYPE_CODE_ARRAY)
        error (_("too many subscripts (%d expected)"), k);
 
       if (type->code () != TYPE_CODE_ARRAY)
        error (_("too many subscripts (%d expected)"), k);

-      arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+      arr = value_cast (lookup_pointer_type (type->target_type ()),

                        value_copy (arr));
       get_discrete_bounds (type->index_type (), &lwb, &upb);
       arr = value_ptradd (arr, pos_atr (ind[k]) - lwb);
                        value_copy (arr));
       get_discrete_bounds (type->index_type (), &lwb, &upb);
       arr = value_ptradd (arr, pos_atr (ind[k]) - lwb);

-      type = TYPE_TARGET_TYPE (type);
+      type = type->target_type ();

     }
 
   return value_ind (arr);
     }
 
   return value_ind (arr);


@@ -3078,11 +3091,11 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
                          int low, int high)
 {
   struct type *type0 = ada_check_typedef (type);
                          int low, int high)
 {
   struct type *type0 = ada_check_typedef (type);

-  struct type *base_index_type = TYPE_TARGET_TYPE (type0->index_type ());
+  struct type *base_index_type = type0->index_type ()->target_type ();

   struct type *index_type
     = create_static_range_type (NULL, base_index_type, low, high);
   struct type *slice_type = create_array_type_with_stride
   struct type *index_type
     = create_static_range_type (NULL, base_index_type, low, high);
   struct type *slice_type = create_array_type_with_stride

-                             (NULL, TYPE_TARGET_TYPE (type0), index_type,
+                             (NULL, type0->target_type (), index_type,

                               type0->dyn_prop (DYN_PROP_BYTE_STRIDE),
                               TYPE_FIELD_BITSIZE (type0, 0));
   int base_low =  ada_discrete_type_low_bound (type0->index_type ());
                               type0->dyn_prop (DYN_PROP_BYTE_STRIDE),
                               TYPE_FIELD_BITSIZE (type0, 0));
   int base_low =  ada_discrete_type_low_bound (type0->index_type ());


@@ -3101,7 +3114,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
 
   ULONGEST stride = TYPE_FIELD_BITSIZE (slice_type, 0) / 8;
   if (stride == 0)
 
   ULONGEST stride = TYPE_FIELD_BITSIZE (slice_type, 0) / 8;
   if (stride == 0)

-    stride = TYPE_LENGTH (TYPE_TARGET_TYPE (type0));
+    stride = type0->target_type ()->length ();

 
   base = value_as_address (array_ptr) + (*low_pos - *base_low_pos) * stride;
   return value_at_lazy (slice_type, base);
 
   base = value_as_address (array_ptr) + (*low_pos - *base_low_pos) * stride;
   return value_at_lazy (slice_type, base);


@@ -3112,11 +3125,11 @@ static struct value *
 ada_value_slice (struct value *array, int low, int high)
 {
   struct type *type = ada_check_typedef (value_type (array));
 ada_value_slice (struct value *array, int low, int high)
 {
   struct type *type = ada_check_typedef (value_type (array));

-  struct type *base_index_type = TYPE_TARGET_TYPE (type->index_type ());
+  struct type *base_index_type = type->index_type ()->target_type ();

   struct type *index_type
     = create_static_range_type (NULL, type->index_type (), low, high);
   struct type *slice_type = create_array_type_with_stride
   struct type *index_type
     = create_static_range_type (NULL, type->index_type (), low, high);
   struct type *slice_type = create_array_type_with_stride

-                             (NULL, TYPE_TARGET_TYPE (type), index_type,
+                             (NULL, type->target_type (), index_type,

                               type->dyn_prop (DYN_PROP_BYTE_STRIDE),
                               TYPE_FIELD_BITSIZE (type, 0));
   gdb::optional<LONGEST> low_pos, high_pos;
                               type->dyn_prop (DYN_PROP_BYTE_STRIDE),
                               TYPE_FIELD_BITSIZE (type, 0));
   gdb::optional<LONGEST> low_pos, high_pos;


@@ -3158,7 +3171,7 @@ ada_array_arity (struct type *type)
     while (type->code () == TYPE_CODE_ARRAY)
       {
        arity += 1;
     while (type->code () == TYPE_CODE_ARRAY)
       {
        arity += 1;

-       type = ada_check_typedef (TYPE_TARGET_TYPE (type));
+       type = ada_check_typedef (type->target_type ());

       }
 
   return arity;
       }
 
   return arity;


@@ -3190,7 +3203,7 @@ ada_array_element_type (struct type *type, int nindices)
        k = nindices;
       while (k > 0 && p_array_type != NULL)
        {
        k = nindices;
       while (k > 0 && p_array_type != NULL)
        {

-         p_array_type = ada_check_typedef (TYPE_TARGET_TYPE (p_array_type));
+         p_array_type = ada_check_typedef (p_array_type->target_type ());

          k -= 1;
        }
       return p_array_type;
          k -= 1;
        }
       return p_array_type;


@@ -3199,7 +3212,13 @@ ada_array_element_type (struct type *type, int nindices)
     {
       while (nindices != 0 && type->code () == TYPE_CODE_ARRAY)
        {
     {
       while (nindices != 0 && type->code () == TYPE_CODE_ARRAY)
        {

-         type = TYPE_TARGET_TYPE (type);
+         type = type->target_type ();
+         /* A multi-dimensional array is represented using a sequence
+            of array types.  If one of these types has a name, then
+            it is not another dimension of the outer array, but
+            rather the element type of the outermost array.  */
+         if (type->name () != nullptr)
+           break;

          nindices -= 1;
        }
       return type;
          nindices -= 1;
        }
       return type;


@@ -3227,9 +3246,9 @@ ada_index_type (struct type *type, int n, const char *name)
       for (i = 1; i < n; i += 1)
        {
          type = ada_check_typedef (type);
       for (i = 1; i < n; i += 1)
        {
          type = ada_check_typedef (type);

-         type = TYPE_TARGET_TYPE (type);
+         type = type->target_type ();

        }
        }

-      result_type = TYPE_TARGET_TYPE (ada_check_typedef (type)->index_type ());
+      result_type = ada_check_typedef (type)->index_type ()->target_type ();

       /* FIXME: The stabs type r(0,0);bound;bound in an array type
         has a target type of TYPE_CODE_UNDEF.  We compensate here, but
         perhaps stabsread.c would make more sense.  */
       /* FIXME: The stabs type r(0,0);bound;bound in an array type
         has a target type of TYPE_CODE_UNDEF.  We compensate here, but
         perhaps stabsread.c would make more sense.  */


@@ -3267,7 +3286,7 @@ ada_array_bound_from_type (struct type *arr_type, int n, int which)
     return (LONGEST) - which;
 
   if (arr_type->code () == TYPE_CODE_PTR)
     return (LONGEST) - which;
 
   if (arr_type->code () == TYPE_CODE_PTR)

-    type = TYPE_TARGET_TYPE (arr_type);
+    type = arr_type->target_type ();

   else
     type = arr_type;
 
   else
     type = arr_type;
 


@@ -3292,7 +3311,7 @@ ada_array_bound_from_type (struct type *arr_type, int n, int which)
       struct type *elt_type = check_typedef (type);
 
       for (i = 1; i < n; i++)
       struct type *elt_type = check_typedef (type);
 
       for (i = 1; i < n; i++)

-       elt_type = check_typedef (TYPE_TARGET_TYPE (elt_type));
+       elt_type = check_typedef (elt_type->target_type ());

 
       index_type = elt_type->index_type ();
     }
 
       index_type = elt_type->index_type ();
     }


@@ -3361,7 +3380,7 @@ ada_array_length (struct value *arr, int n)
     {
       struct type *base_type;
       if (index_type->code () == TYPE_CODE_RANGE)
     {
       struct type *base_type;
       if (index_type->code () == TYPE_CODE_RANGE)

-       base_type = TYPE_TARGET_TYPE (index_type);
+       base_type = index_type->target_type ();

       else
        base_type = index_type;
 
       else
        base_type = index_type;
 


@@ -3381,7 +3400,7 @@ empty_array (struct type *arr_type, int low, int high)
   struct type *arr_type0 = ada_check_typedef (arr_type);
   struct type *index_type
     = create_static_range_type
   struct type *arr_type0 = ada_check_typedef (arr_type);
   struct type *index_type
     = create_static_range_type

-       (NULL, TYPE_TARGET_TYPE (arr_type0->index_type ()), low,
+       (NULL, arr_type0->index_type ()->target_type (), low,

         high < low ? low - 1 : high);
   struct type *elt_type = ada_array_element_type (arr_type0, 1);
 
         high < low ? low - 1 : high);
   struct type *elt_type = ada_array_element_type (arr_type0, 1);
 


@@ -3485,7 +3504,7 @@ ada_print_symbol_signature (struct ui_file *stream, struct symbol *sym,
 {
   struct type *type = sym->type ();
 
 {
   struct type *type = sym->type ();
 

-  fprintf_filtered (stream, "%s", sym->print_name ());
+  gdb_printf (stream, "%s", sym->print_name ());

   if (!print_signatures
       || type == NULL
       || type->code () != TYPE_CODE_FUNC)
   if (!print_signatures
       || type == NULL
       || type->code () != TYPE_CODE_FUNC)


@@ -3495,21 +3514,21 @@ ada_print_symbol_signature (struct ui_file *stream, struct symbol *sym,
     {
       int i;
 
     {
       int i;
 

-      fprintf_filtered (stream, " (");
+      gdb_printf (stream, " (");

       for (i = 0; i < type->num_fields (); ++i)
        {
          if (i > 0)
       for (i = 0; i < type->num_fields (); ++i)
        {
          if (i > 0)

-           fprintf_filtered (stream, "; ");
+           gdb_printf (stream, "; ");

          ada_print_type (type->field (i).type (), NULL, stream, -1, 0,
                          flags);
        }
          ada_print_type (type->field (i).type (), NULL, stream, -1, 0,
                          flags);
        }

-      fprintf_filtered (stream, ")");
+      gdb_printf (stream, ")");

     }
     }

-  if (TYPE_TARGET_TYPE (type) != NULL
-      && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+  if (type->target_type () != NULL
+      && type->target_type ()->code () != TYPE_CODE_VOID)

     {
     {

-      fprintf_filtered (stream, " return ");
-      ada_print_type (TYPE_TARGET_TYPE (type), NULL, stream, -1, 0, flags);
+      gdb_printf (stream, " return ");
+      ada_print_type (type->target_type (), NULL, stream, -1, 0, flags);

     }
 }
 
     }
 }
 


@@ -3634,9 +3653,9 @@ See set/show multiple-symbol."));
   if (select_mode == multiple_symbols_all && max_results > 1)
     return nsyms;
 
   if (select_mode == multiple_symbols_all && max_results > 1)
     return nsyms;
 

-  printf_filtered (_("[0] cancel\n"));
+  gdb_printf (_("[0] cancel\n"));

   if (max_results > 1)
   if (max_results > 1)

-    printf_filtered (_("[1] all\n"));
+    gdb_printf (_("[1] all\n"));

 
   sort_choices (syms, nsyms);
 
 
   sort_choices (syms, nsyms);
 


@@ -3650,14 +3669,14 @@ See set/show multiple-symbol."));
          struct symtab_and_line sal =
            find_function_start_sal (syms[i].symbol, 1);
 
          struct symtab_and_line sal =
            find_function_start_sal (syms[i].symbol, 1);
 

-         printf_filtered ("[%d] ", i + first_choice);
+         gdb_printf ("[%d] ", i + first_choice);

          ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
                                      &type_print_raw_options);
          if (sal.symtab == NULL)
          ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
                                      &type_print_raw_options);
          if (sal.symtab == NULL)

-           printf_filtered (_(" at %p[<no source file available>%p]:%d\n"),
-                            metadata_style.style ().ptr (), nullptr, sal.line);
+           gdb_printf (_(" at %p[<no source file available>%p]:%d\n"),
+                       metadata_style.style ().ptr (), nullptr, sal.line);

          else
          else

-           printf_filtered
+           gdb_printf

              (_(" at %ps:%d\n"),
               styled_string (file_name_style.style (),
                              symtab_to_filename_for_display (sal.symtab)),
              (_(" at %ps:%d\n"),
               styled_string (file_name_style.style (),
                              symtab_to_filename_for_display (sal.symtab)),


@@ -3673,41 +3692,41 @@ See set/show multiple-symbol."));
          struct symtab *symtab = NULL;
 
          if (syms[i].symbol->is_objfile_owned ())
          struct symtab *symtab = NULL;
 
          if (syms[i].symbol->is_objfile_owned ())

-           symtab = symbol_symtab (syms[i].symbol);
+           symtab = syms[i].symbol->symtab ();

 
          if (syms[i].symbol->line () != 0 && symtab != NULL)
            {
 
          if (syms[i].symbol->line () != 0 && symtab != NULL)
            {

-             printf_filtered ("[%d] ", i + first_choice);
+             gdb_printf ("[%d] ", i + first_choice);

              ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
                                          &type_print_raw_options);
              ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
                                          &type_print_raw_options);

-             printf_filtered (_(" at %s:%d\n"),
-                              symtab_to_filename_for_display (symtab),
-                              syms[i].symbol->line ());
+             gdb_printf (_(" at %s:%d\n"),
+                         symtab_to_filename_for_display (symtab),
+                         syms[i].symbol->line ());

            }
          else if (is_enumeral
                   && syms[i].symbol->type ()->name () != NULL)
            {
            }
          else if (is_enumeral
                   && syms[i].symbol->type ()->name () != NULL)
            {

-             printf_filtered (("[%d] "), i + first_choice);
+             gdb_printf (("[%d] "), i + first_choice);

              ada_print_type (syms[i].symbol->type (), NULL,
                              gdb_stdout, -1, 0, &type_print_raw_options);
              ada_print_type (syms[i].symbol->type (), NULL,
                              gdb_stdout, -1, 0, &type_print_raw_options);

-             printf_filtered (_("'(%s) (enumeral)\n"),
-                              syms[i].symbol->print_name ());
+             gdb_printf (_("'(%s) (enumeral)\n"),
+                         syms[i].symbol->print_name ());

            }
          else
            {
            }
          else
            {

-             printf_filtered ("[%d] ", i + first_choice);
+             gdb_printf ("[%d] ", i + first_choice);

              ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
                                          &type_print_raw_options);
 
              if (symtab != NULL)
              ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
                                          &type_print_raw_options);
 
              if (symtab != NULL)

-               printf_filtered (is_enumeral
-                                ? _(" in %s (enumeral)\n")
-                                : _(" at %s:?\n"),
-                                symtab_to_filename_for_display (symtab));
+               gdb_printf (is_enumeral
+                           ? _(" in %s (enumeral)\n")
+                           : _(" at %s:?\n"),
+                           symtab_to_filename_for_display (symtab));

              else
              else

-               printf_filtered (is_enumeral
-                                ? _(" (enumeral)\n")
-                                : _(" at ?\n"));
+               gdb_printf (is_enumeral
+                           ? _(" (enumeral)\n")
+                           : _(" at ?\n"));

            }
        }
     }
            }
        }
     }


@@ -3846,7 +3865,7 @@ ada_resolve_variable (struct symbol *sym, const struct block *block,
       candidates.end (),
       [] (block_symbol &bsym)
       {
       candidates.end (),
       [] (block_symbol &bsym)
       {

-       return bsym.symbol->artificial;
+       return bsym.symbol->is_artificial ();

       }),
      candidates.end ());
 
       }),
      candidates.end ());
 


@@ -3870,7 +3889,7 @@ ada_resolve_variable (struct symbol *sym, const struct block *block,
     }
   else
     {
     }
   else
     {

-      printf_filtered (_("Multiple matches for %s\n"), sym->print_name ());
+      gdb_printf (_("Multiple matches for %s\n"), sym->print_name ());

       user_select_syms (candidates.data (), candidates.size (), 1);
       i = 0;
     }
       user_select_syms (candidates.data (), candidates.size (), 1);
       i = 0;
     }


@@ -3890,9 +3909,9 @@ ada_type_match (struct type *ftype, struct type *atype)
   atype = ada_check_typedef (atype);
 
   if (ftype->code () == TYPE_CODE_REF)
   atype = ada_check_typedef (atype);
 
   if (ftype->code () == TYPE_CODE_REF)

-    ftype = TYPE_TARGET_TYPE (ftype);
+    ftype = ftype->target_type ();

   if (atype->code () == TYPE_CODE_REF)
   if (atype->code () == TYPE_CODE_REF)

-    atype = TYPE_TARGET_TYPE (atype);
+    atype = atype->target_type ();

 
   switch (ftype->code ())
     {
 
   switch (ftype->code ())
     {


@@ -3901,11 +3920,11 @@ ada_type_match (struct type *ftype, struct type *atype)
     case TYPE_CODE_PTR:
       if (atype->code () != TYPE_CODE_PTR)
        return 0;
     case TYPE_CODE_PTR:
       if (atype->code () != TYPE_CODE_PTR)
        return 0;

-      atype = TYPE_TARGET_TYPE (atype);
+      atype = atype->target_type ();

       /* This can only happen if the actual argument is 'null'.  */
       /* This can only happen if the actual argument is 'null'.  */

-      if (atype->code () == TYPE_CODE_INT && TYPE_LENGTH (atype) == 0)
+      if (atype->code () == TYPE_CODE_INT && atype->length () == 0)

        return 1;
        return 1;

-      return ada_type_match (TYPE_TARGET_TYPE (ftype), atype);
+      return ada_type_match (ftype->target_type (), atype);

     case TYPE_CODE_INT:
     case TYPE_CODE_ENUM:
     case TYPE_CODE_RANGE:
     case TYPE_CODE_INT:
     case TYPE_CODE_ENUM:
     case TYPE_CODE_RANGE:


@@ -3987,7 +4006,7 @@ return_match (struct type *func_type, struct type *context_type)
     return 1;
 
   if (func_type->code () == TYPE_CODE_FUNC)
     return 1;
 
   if (func_type->code () == TYPE_CODE_FUNC)

-    return_type = get_base_type (TYPE_TARGET_TYPE (func_type));
+    return_type = get_base_type (func_type->target_type ());

   else
     return_type = get_base_type (func_type);
   if (return_type == NULL)
   else
     return_type = get_base_type (func_type);
   if (return_type == NULL)


@@ -4053,7 +4072,7 @@ ada_resolve_function (std::vector<struct block_symbol> &syms,
     return -1;
   else if (m > 1 && !parse_completion)
     {
     return -1;
   else if (m > 1 && !parse_completion)
     {

-      printf_filtered (_("Multiple matches for %s\n"), name);
+      gdb_printf (_("Multiple matches for %s\n"), name);

       user_select_syms (syms.data (), m, 1);
       return 0;
     }
       user_select_syms (syms.data (), m, 1);
       return 0;
     }


@@ -4079,8 +4098,8 @@ numeric_type_p (struct type *type)
        case TYPE_CODE_FIXED_POINT:
          return 1;
        case TYPE_CODE_RANGE:
        case TYPE_CODE_FIXED_POINT:
          return 1;
        case TYPE_CODE_RANGE:

-         return (type == TYPE_TARGET_TYPE (type)
-                 || numeric_type_p (TYPE_TARGET_TYPE (type)));
+         return (type == type->target_type ()
+                 || numeric_type_p (type->target_type ()));

        default:
          return 0;
        }
        default:
          return 0;
        }


@@ -4101,8 +4120,8 @@ integer_type_p (struct type *type)
        case TYPE_CODE_INT:
          return 1;
        case TYPE_CODE_RANGE:
        case TYPE_CODE_INT:
          return 1;
        case TYPE_CODE_RANGE:

-         return (type == TYPE_TARGET_TYPE (type)
-                 || integer_type_p (TYPE_TARGET_TYPE (type)));
+         return (type == type->target_type ()
+                 || integer_type_p (type->target_type ()));

        default:
          return 0;
        }
        default:
          return 0;
        }


@@ -4132,7 +4151,9 @@ scalar_type_p (struct type *type)
     }
 }
 
     }
 }
 

-/* True iff TYPE is discrete (INT, RANGE, ENUM).  */
+/* True iff TYPE is discrete, as defined in the Ada Reference Manual.
+   This essentially means one of (INT, RANGE, ENUM) -- but note that
+   "enum" includes character and boolean as well.  */

 
 static int
 discrete_type_p (struct type *type)
 
 static int
 discrete_type_p (struct type *type)


@@ -4147,6 +4168,7 @@ discrete_type_p (struct type *type)
        case TYPE_CODE_RANGE:
        case TYPE_CODE_ENUM:
        case TYPE_CODE_BOOL:
        case TYPE_CODE_RANGE:
        case TYPE_CODE_ENUM:
        case TYPE_CODE_BOOL:

+       case TYPE_CODE_CHAR:

          return 1;
        default:
          return 0;
          return 1;
        default:
          return 0;


@@ -4329,7 +4351,7 @@ ensure_lval (struct value *val)
   if (VALUE_LVAL (val) == not_lval
       || VALUE_LVAL (val) == lval_internalvar)
     {
   if (VALUE_LVAL (val) == not_lval
       || VALUE_LVAL (val) == lval_internalvar)
     {

-      int len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
+      int len = ada_check_typedef (value_type (val))->length ();

       const CORE_ADDR addr =
        value_as_long (value_allocate_space_in_inferior (len));
 
       const CORE_ADDR addr =
        value_as_long (value_allocate_space_in_inferior (len));
 


@@ -4364,7 +4386,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
   t1 = t = ada_check_typedef (value_type (arg));
   if (t->code () == TYPE_CODE_REF)
     {
   t1 = t = ada_check_typedef (value_type (arg));
   if (t->code () == TYPE_CODE_REF)
     {

-      t1 = TYPE_TARGET_TYPE (t);
+      t1 = t->target_type ();

       if (t1 == NULL)
        goto BadValue;
       t1 = ada_check_typedef (t1);
       if (t1 == NULL)
        goto BadValue;
       t1 = ada_check_typedef (t1);


@@ -4377,7 +4399,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
 
   while (t->code () == TYPE_CODE_PTR)
     {
 
   while (t->code () == TYPE_CODE_PTR)
     {

-      t1 = TYPE_TARGET_TYPE (t);
+      t1 = t->target_type ();

       if (t1 == NULL)
        goto BadValue;
       t1 = ada_check_typedef (t1);
       if (t1 == NULL)
        goto BadValue;
       t1 = ada_check_typedef (t1);


@@ -4414,7 +4436,7 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
 
       if (ada_is_tagged_type (t1, 0)
          || (t1->code () == TYPE_CODE_REF
 
       if (ada_is_tagged_type (t1, 0)
          || (t1->code () == TYPE_CODE_REF

-             && ada_is_tagged_type (TYPE_TARGET_TYPE (t1), 0)))
+             && ada_is_tagged_type (t1->target_type (), 0)))

        {
          /* We first try to find the searched field in the current type.
             If not found then let's look in the fixed type.  */
        {
          /* We first try to find the searched field in the current type.
             If not found then let's look in the fixed type.  */


@@ -4482,10 +4504,10 @@ ada_convert_actual (struct value *actual, struct type *formal_type0)
   struct type *formal_type = ada_check_typedef (formal_type0);
   struct type *formal_target =
     formal_type->code () == TYPE_CODE_PTR
   struct type *formal_type = ada_check_typedef (formal_type0);
   struct type *formal_target =
     formal_type->code () == TYPE_CODE_PTR

-    ? ada_check_typedef (TYPE_TARGET_TYPE (formal_type)) : formal_type;
+    ? ada_check_typedef (formal_type->target_type ()) : formal_type;

   struct type *actual_target =
     actual_type->code () == TYPE_CODE_PTR
   struct type *actual_target =
     actual_type->code () == TYPE_CODE_PTR

-    ? ada_check_typedef (TYPE_TARGET_TYPE (actual_type)) : actual_type;
+    ? ada_check_typedef (actual_type->target_type ()) : actual_type;

 
   if (ada_is_array_descriptor_type (formal_target)
       && actual_target->code () == TYPE_CODE_ARRAY)
 
   if (ada_is_array_descriptor_type (formal_target)
       && actual_target->code () == TYPE_CODE_ARRAY)


@@ -4539,7 +4561,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0)
 static CORE_ADDR
 value_pointer (struct value *value, struct type *type)
 {
 static CORE_ADDR
 value_pointer (struct value *value, struct type *type)
 {

-  unsigned len = TYPE_LENGTH (type);
+  unsigned len = type->length ();

   gdb_byte *buf = (gdb_byte *) alloca (len);
   CORE_ADDR addr;
 
   gdb_byte *buf = (gdb_byte *) alloca (len);
   CORE_ADDR addr;
 


@@ -4703,12 +4725,13 @@ cache_symbol (const char *name, domain_enum domain, struct symbol *sym,
      for that symbol depends on the context.  To determine whether
      the symbol is local or not, we check the block where we found it
      against the global and static blocks of its associated symtab.  */
      for that symbol depends on the context.  To determine whether
      the symbol is local or not, we check the block where we found it
      against the global and static blocks of its associated symtab.  */

-  if (sym
-      && BLOCKVECTOR_BLOCK (symbol_symtab (sym)->blockvector (),
-                           GLOBAL_BLOCK) != block
-      && BLOCKVECTOR_BLOCK (symbol_symtab (sym)->blockvector (),
-                           STATIC_BLOCK) != block)
-    return;
+  if (sym != nullptr)
+    {
+      const blockvector &bv = *sym->symtab ()->compunit ()->blockvector ();
+
+      if (bv.global_block () != block && bv.static_block () != block)
+       return;
+    }

 
   h = msymbol_hash (name) % HASH_SIZE;
   e = XOBNEW (&sym_cache->cache_space, cache_entry);
 
   h = msymbol_hash (name) % HASH_SIZE;
   e = XOBNEW (&sym_cache->cache_space, cache_entry);


@@ -4820,7 +4843,7 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
                  && startswith (name1 + len0, "___XV")));
       }
     case LOC_CONST:
                  && startswith (name1 + len0, "___XV")));
       }
     case LOC_CONST:

-      return SYMBOL_VALUE (sym0) == SYMBOL_VALUE (sym1)
+      return sym0->value_longest () == sym1->value_longest ()

        && equiv_types (sym0->type (), sym1->type ());
 
     case LOC_STATIC:
        && equiv_types (sym0->type (), sym1->type ());
 
     case LOC_STATIC:


@@ -4828,7 +4851,7 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
        const char *name0 = sym0->linkage_name ();
        const char *name1 = sym1->linkage_name ();
        return (strcmp (name0, name1) == 0
        const char *name0 = sym0->linkage_name ();
        const char *name1 = sym1->linkage_name ();
        return (strcmp (name0, name1) == 0

-               && SYMBOL_VALUE_ADDRESS (sym0) == SYMBOL_VALUE_ADDRESS (sym1));
+               && sym0->value_address () == sym1->value_address ());

       }
 
     default:
       }
 
     default:


@@ -4878,7 +4901,7 @@ add_defn_to_vec (std::vector<struct block_symbol> &result,
    global symbols are searched.  */
 
 struct bound_minimal_symbol
    global symbols are searched.  */
 
 struct bound_minimal_symbol

-ada_lookup_simple_minsym (const char *name)
+ada_lookup_simple_minsym (const char *name, struct objfile *objfile)

 {
   struct bound_minimal_symbol result;
 
 {
   struct bound_minimal_symbol result;
 


@@ -4888,19 +4911,23 @@ ada_lookup_simple_minsym (const char *name)
   symbol_name_matcher_ftype *match_name
     = ada_get_symbol_name_matcher (lookup_name);
 
   symbol_name_matcher_ftype *match_name
     = ada_get_symbol_name_matcher (lookup_name);
 

-  for (objfile *objfile : current_program_space->objfiles ())
-    {
-      for (minimal_symbol *msymbol : objfile->msymbols ())
-       {
-         if (match_name (msymbol->linkage_name (), lookup_name, NULL)
-             && MSYMBOL_TYPE (msymbol) != mst_solib_trampoline)
-           {
-             result.minsym = msymbol;
-             result.objfile = objfile;
-             break;
-           }
-       }
-    }
+  gdbarch_iterate_over_objfiles_in_search_order
+    (objfile != NULL ? objfile->arch () : target_gdbarch (),
+     [&result, lookup_name, match_name] (struct objfile *obj)
+       {
+        for (minimal_symbol *msymbol : obj->msymbols ())
+          {
+            if (match_name (msymbol->linkage_name (), lookup_name, nullptr)
+                && msymbol->type () != mst_solib_trampoline)
+              {
+                result.minsym = msymbol;
+                result.objfile = obj;
+                return 1;
+              }
+          }
+
+        return 0;
+       }, objfile);

 
   return result;
 }
 
   return result;
 }


@@ -4998,7 +5025,7 @@ symbols_are_identical_enums (const std::vector<struct block_symbol> &syms)
 
   /* Quick check: They should all have the same value.  */
   for (i = 1; i < syms.size (); i++)
 
   /* Quick check: They should all have the same value.  */
   for (i = 1; i < syms.size (); i++)

-    if (SYMBOL_VALUE (syms[i].symbol) != SYMBOL_VALUE (syms[0].symbol))
+    if (syms[i].symbol->value_longest () != syms[0].symbol->value_longest ())

       return 0;
 
   /* Quick check: They should all have the same number of enumerals.  */
       return 0;
 
   /* Quick check: They should all have the same number of enumerals.  */


@@ -5072,8 +5099,8 @@ remove_extra_symbols (std::vector<struct block_symbol> *syms)
                             (*syms)[j].symbol->linkage_name ()) == 0
                  && ((*syms)[i].symbol->aclass ()
                      == (*syms)[j].symbol->aclass ())
                             (*syms)[j].symbol->linkage_name ()) == 0
                  && ((*syms)[i].symbol->aclass ()
                      == (*syms)[j].symbol->aclass ())

-                 && SYMBOL_VALUE_ADDRESS ((*syms)[i].symbol)
-                 == SYMBOL_VALUE_ADDRESS ((*syms)[j].symbol))
+                 && (*syms)[i].symbol->value_address ()
+                 == (*syms)[j].symbol->value_address ())

                remove_p = 1;
            }
        }
                remove_p = 1;
            }
        }


@@ -5323,10 +5350,10 @@ ada_add_local_symbols (std::vector<struct block_symbol> &result,
       /* If we found a non-function match, assume that's the one.  We
         only check this when finding a function boundary, so that we
         can accumulate all results from intervening blocks first.  */
       /* If we found a non-function match, assume that's the one.  We
         only check this when finding a function boundary, so that we
         can accumulate all results from intervening blocks first.  */

-      if (BLOCK_FUNCTION (block) != nullptr && is_nonfunction (result))
+      if (block->function () != nullptr && is_nonfunction (result))

        return;
 
        return;
 

-      block = BLOCK_SUPERBLOCK (block);
+      block = block->superblock ();

     }
 }
 
     }
 }
 


@@ -5555,7 +5582,7 @@ map_matching_symbols (struct objfile *objfile,
   for (compunit_symtab *symtab : objfile->compunits ())
     {
       const struct block *block
   for (compunit_symtab *symtab : objfile->compunits ())
     {
       const struct block *block

-       = BLOCKVECTOR_BLOCK (symtab->blockvector (), block_kind);
+       = symtab->blockvector ()->block (block_kind);

       if (!iterate_over_symbols_terminated (block, lookup_name,
                                            domain, data))
        break;
       if (!iterate_over_symbols_terminated (block, lookup_name,
                                            domain, data))
        break;


@@ -5584,7 +5611,7 @@ add_nonlocal_symbols (std::vector<struct block_symbol> &result,
       for (compunit_symtab *cu : objfile->compunits ())
        {
          const struct block *global_block
       for (compunit_symtab *cu : objfile->compunits ())
        {
          const struct block *global_block

-           = BLOCKVECTOR_BLOCK (cu->blockvector (), GLOBAL_BLOCK);
+           = cu->blockvector ()->global_block ();

 
          if (ada_add_block_renamings (result, global_block, lookup_name,
                                       domain))
 
          if (ada_add_block_renamings (result, global_block, lookup_name,
                                       domain))


@@ -6016,6 +6043,9 @@ wild_match (const char *name, const char *patn)
   const char *p;
   const char *name0 = name;
 
   const char *p;
   const char *name0 = name;
 

+  if (startswith (name, "___ghost_"))
+    name += 9;
+

   while (1)
     {
       const char *match = name;
   while (1)
     {
       const char *match = name;


@@ -6239,7 +6269,7 @@ ada_is_dispatch_table_ptr_type (struct type *type)
   if (type->code () != TYPE_CODE_PTR)
     return 0;
 
   if (type->code () != TYPE_CODE_PTR)
     return 0;
 

-  name = TYPE_TARGET_TYPE (type)->name ();
+  name = type->target_type ()->name ();

   if (name == NULL)
     return 0;
 
   if (name == NULL)
     return 0;
 


@@ -6287,6 +6317,18 @@ ada_is_ignored_field (struct type *type, int field_num)
        should not be ignored either.  */
     if (name[0] == '_' && !startswith (name, "_parent"))
       return 1;
        should not be ignored either.  */
     if (name[0] == '_' && !startswith (name, "_parent"))
       return 1;

+
+    /* The compiler doesn't document this, but sometimes it emits
+       a field whose name starts with a capital letter, like 'V148s'.
+       These aren't marked as artificial in any way, but we know they
+       should be ignored.  However, wrapper fields should not be
+       ignored.  */
+    if (name[0] == 'S' || name[0] == 'R' || name[0] == 'O')
+      {
+       /* Wrapper field.  */
+      }
+    else if (isupper (name[0]))
+      return 1;

   }
 
   /* If this is the dispatch table of a tagged type or an interface tag,
   }
 
   /* If this is the dispatch table of a tagged type or an interface tag,


@@ -6320,7 +6362,7 @@ ada_is_tag_type (struct type *type)
     return 0;
   else
     {
     return 0;
   else
     {

-      const char *name = ada_type_name (TYPE_TARGET_TYPE (type));
+      const char *name = ada_type_name (type->target_type ());

 
       return (name != NULL
              && strcmp (name, "ada__tags__dispatch_table") == 0);
 
       return (name != NULL
              && strcmp (name, "ada__tags__dispatch_table") == 0);


@@ -6366,7 +6408,7 @@ value_tag_from_contents_and_address (struct type *type,
 
   gdb::array_view<const gdb_byte> contents;
   if (valaddr != nullptr)
 
   gdb::array_view<const gdb_byte> contents;
   if (valaddr != nullptr)

-    contents = gdb::make_array_view (valaddr, TYPE_LENGTH (type));
+    contents = gdb::make_array_view (valaddr, type->length ());

   struct type *resolved_type = resolve_dynamic_type (type, contents, address);
   if (find_struct_field ("_tag", resolved_type, 0, &tag_type, &tag_byte_offset,
                         NULL, NULL, NULL))
   struct type *resolved_type = resolve_dynamic_type (type, contents, address);
   if (find_struct_field ("_tag", resolved_type, 0, &tag_type, &tag_byte_offset,
                         NULL, NULL, NULL))


@@ -6422,9 +6464,10 @@ ada_tag_value_at_base_address (struct value *obj)
   if (is_ada95_tag (tag))
     return obj;
 
   if (is_ada95_tag (tag))
     return obj;
 

-  ptr_type = language_lookup_primitive_type
-    (language_def (language_ada), target_gdbarch(), "storage_offset");
-  ptr_type = lookup_pointer_type (ptr_type);
+  struct type *offset_type
+    = language_lookup_primitive_type (language_def (language_ada),
+                                     target_gdbarch(), "storage_offset");
+  ptr_type = lookup_pointer_type (offset_type);

   val = value_cast (ptr_type, tag);
   if (!val)
     return obj;
   val = value_cast (ptr_type, tag);
   if (!val)
     return obj;


@@ -6456,16 +6499,29 @@ ada_tag_value_at_base_address (struct value *obj)
   if (offset_to_top == -1)
     return obj;
 
   if (offset_to_top == -1)
     return obj;
 

-  /* OFFSET_TO_TOP used to be a positive value to be subtracted
-     from the base address.  This was however incompatible with
-     C++ dispatch table: C++ uses a *negative* value to *add*
-     to the base address.  Ada's convention has therefore been
-     changed in GNAT 19.0w 20171023: since then, C++ and Ada
-     use the same convention.  Here, we support both cases by
-     checking the sign of OFFSET_TO_TOP.  */
+  /* Storage_Offset'Last is used to indicate that a dynamic offset to
+     top is used.  In this situation the offset is stored just after
+     the tag, in the object itself.  */
+  ULONGEST last = (((ULONGEST) 1) << (8 * offset_type->length () - 1)) - 1;
+  if (offset_to_top == last)
+    {
+      struct value *tem = value_addr (tag);
+      tem = value_ptradd (tem, 1);
+      tem = value_cast (ptr_type, tem);
+      offset_to_top = value_as_long (value_ind (tem));
+    }

 
   if (offset_to_top > 0)
 
   if (offset_to_top > 0)

-    offset_to_top = -offset_to_top;
+    {
+      /* OFFSET_TO_TOP used to be a positive value to be subtracted
+        from the base address.  This was however incompatible with
+        C++ dispatch table: C++ uses a *negative* value to *add*
+        to the base address.  Ada's convention has therefore been
+        changed in GNAT 19.0w 20171023: since then, C++ and Ada
+        use the same convention.  Here, we support both cases by
+        checking the sign of OFFSET_TO_TOP.  */
+      offset_to_top = -offset_to_top;
+    }

 
   base_address = value_address (obj) + offset_to_top;
   tag = value_tag_from_contents_and_address (obj_type, NULL, base_address);
 
   base_address = value_address (obj) + offset_to_top;
   tag = value_tag_from_contents_and_address (obj_type, NULL, base_address);


@@ -6620,7 +6676,7 @@ ada_parent_type (struct type *type)
 
        /* If the _parent field is a pointer, then dereference it.  */
        if (parent_type->code () == TYPE_CODE_PTR)
 
        /* If the _parent field is a pointer, then dereference it.  */
        if (parent_type->code () == TYPE_CODE_PTR)

-         parent_type = TYPE_TARGET_TYPE (parent_type);
+         parent_type = parent_type->target_type ();

        /* If there is a parallel XVS type, get the actual base type.  */
        parent_type = ada_get_base_type (parent_type);
 
        /* If there is a parallel XVS type, get the actual base type.  */
        parent_type = ada_get_base_type (parent_type);
 


@@ -6688,7 +6744,7 @@ ada_is_variant_part (struct type *type, int field_num)
 
   return (field_type->code () == TYPE_CODE_UNION
          || (is_dynamic_field (type, field_num)
 
   return (field_type->code () == TYPE_CODE_UNION
          || (is_dynamic_field (type, field_num)

-             && (TYPE_TARGET_TYPE (field_type)->code ()
+             && (field_type->target_type ()->code ()

                  == TYPE_CODE_UNION)));
 }
 
                  == TYPE_CODE_UNION)));
 }
 


@@ -6731,7 +6787,7 @@ ada_variant_discrim_name (struct type *type0)
   const char *discrim_start;
 
   if (type0->code () == TYPE_CODE_PTR)
   const char *discrim_start;
 
   if (type0->code () == TYPE_CODE_PTR)

-    type = TYPE_TARGET_TYPE (type0);
+    type = type0->target_type ();

   else
     type = type0;
 
   else
     type = type0;
 


@@ -7276,7 +7332,7 @@ ada_lookup_struct_elt_type (struct type *type, const char *name, int refok,
        type = ada_check_typedef (type);
        if (type->code () != TYPE_CODE_PTR && type->code () != TYPE_CODE_REF)
          break;
        type = ada_check_typedef (type);
        if (type->code () != TYPE_CODE_PTR && type->code () != TYPE_CODE_REF)
          break;

-       type = TYPE_TARGET_TYPE (type);
+       type = type->target_type ();

       }
 
   if (type == NULL
       }
 
   if (type == NULL


@@ -7781,7 +7837,7 @@ empty_record (struct type *templ)
   type->set_code (TYPE_CODE_STRUCT);
   INIT_NONE_SPECIFIC (type);
   type->set_name ("<empty>");
   type->set_code (TYPE_CODE_STRUCT);
   INIT_NONE_SPECIFIC (type);
   type->set_name ("<empty>");

-  TYPE_LENGTH (type) = 0;
+  type->set_length (0);

   return type;
 }
 
   return type;
 }
 


@@ -7808,7 +7864,6 @@ ada_template_to_fixed_record_type_1 (struct type *type,
                                     CORE_ADDR address, struct value *dval0,
                                     int keep_dynamic_fields)
 {
                                     CORE_ADDR address, struct value *dval0,
                                     int keep_dynamic_fields)
 {

-  struct value *mark = value_mark ();

   struct value *dval;
   struct type *rtype;
   int nfields, bit_len;
   struct value *dval;
   struct type *rtype;
   int nfields, bit_len;


@@ -7817,6 +7872,8 @@ ada_template_to_fixed_record_type_1 (struct type *type,
   int fld_bit_len;
   int f;
 
   int fld_bit_len;
   int f;
 

+  scoped_value_mark mark;
+

   /* Compute the number of fields in this record type that are going
      to be processed: unless keep_dynamic_fields, this includes only
      fields whose position and length are static will be processed.  */
   /* Compute the number of fields in this record type that are going
      to be processed: unless keep_dynamic_fields, this includes only
      fields whose position and length are static will be processed.  */


@@ -7860,8 +7917,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
        {
          const gdb_byte *field_valaddr = valaddr;
          CORE_ADDR field_address = address;
        {
          const gdb_byte *field_valaddr = valaddr;
          CORE_ADDR field_address = address;

-         struct type *field_type =
-           TYPE_TARGET_TYPE (type->field (f).type ());
+         struct type *field_type = type->field (f).type ()->target_type ();

 
          if (dval0 == NULL)
            {
 
          if (dval0 == NULL)
            {


@@ -7914,8 +7970,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
             an overflow should not happen in practice.  So rather than
             adding overflow recovery code to this already complex code,
             we just assume that it's not going to happen.  */
             an overflow should not happen in practice.  So rather than
             adding overflow recovery code to this already complex code,
             we just assume that it's not going to happen.  */

-         fld_bit_len =
-           TYPE_LENGTH (rtype->field (f).type ()) * TARGET_CHAR_BIT;
+         fld_bit_len = rtype->field (f).type ()->length () * TARGET_CHAR_BIT;

        }
       else
        {
        }
       else
        {


@@ -7946,14 +8001,13 @@ ada_template_to_fixed_record_type_1 (struct type *type,
                field_type = ada_typedef_target_type (field_type);
 
              fld_bit_len =
                field_type = ada_typedef_target_type (field_type);
 
              fld_bit_len =

-               TYPE_LENGTH (ada_check_typedef (field_type)) * TARGET_CHAR_BIT;
+               ada_check_typedef (field_type)->length () * TARGET_CHAR_BIT;

            }
        }
       if (off + fld_bit_len > bit_len)
        bit_len = off + fld_bit_len;
       off += fld_bit_len;
            }
        }
       if (off + fld_bit_len > bit_len)
        bit_len = off + fld_bit_len;
       off += fld_bit_len;

-      TYPE_LENGTH (rtype) =
-       align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+      rtype->set_length (align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT);

     }
 
   /* We handle the variant part, if any, at the end because of certain
     }
 
   /* We handle the variant part, if any, at the end because of certain


@@ -7994,12 +8048,12 @@ ada_template_to_fixed_record_type_1 (struct type *type,
          rtype->field (variant_field).set_type (branch_type);
          rtype->field (variant_field).set_name ("S");
          fld_bit_len =
          rtype->field (variant_field).set_type (branch_type);
          rtype->field (variant_field).set_name ("S");
          fld_bit_len =

-           TYPE_LENGTH (rtype->field (variant_field).type ()) *
-           TARGET_CHAR_BIT;
+           rtype->field (variant_field).type ()->length () * TARGET_CHAR_BIT;

          if (off + fld_bit_len > bit_len)
            bit_len = off + fld_bit_len;
          if (off + fld_bit_len > bit_len)
            bit_len = off + fld_bit_len;

-         TYPE_LENGTH (rtype) =
-           align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+
+         rtype->set_length
+           (align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT);

        }
     }
 
        }
     }
 


@@ -8009,22 +8063,18 @@ ada_template_to_fixed_record_type_1 (struct type *type,
      probably in the debug info.  In that case, we don't round up the size
      of the resulting type.  If this record is not part of another structure,
      the current RTYPE length might be good enough for our purposes.  */
      probably in the debug info.  In that case, we don't round up the size
      of the resulting type.  If this record is not part of another structure,
      the current RTYPE length might be good enough for our purposes.  */

-  if (TYPE_LENGTH (type) <= 0)
+  if (type->length () <= 0)

     {
       if (rtype->name ())
        warning (_("Invalid type size for `%s' detected: %s."),
     {
       if (rtype->name ())
        warning (_("Invalid type size for `%s' detected: %s."),

-                rtype->name (), pulongest (TYPE_LENGTH (type)));
+                rtype->name (), pulongest (type->length ()));

       else
        warning (_("Invalid type size for <unnamed> detected: %s."),
       else
        warning (_("Invalid type size for <unnamed> detected: %s."),

-                pulongest (TYPE_LENGTH (type)));
+                pulongest (type->length ()));

     }
   else
     }
   else

-    {
-      TYPE_LENGTH (rtype) = align_up (TYPE_LENGTH (rtype),
-                                     TYPE_LENGTH (type));
-    }
+    rtype->set_length (align_up (rtype->length (), type->length ()));

 
 

-  value_free_to_mark (mark);

   return rtype;
 }
 
   return rtype;
 }
 


@@ -8045,7 +8095,7 @@ template_to_fixed_record_type (struct type *type, const gdb_byte *valaddr,
    no runtime values.  Useless for use in values, but that's OK,
    since the results are used only for type determinations.   Works on both
    structs and unions.  Representation note: to save space, we memorize
    no runtime values.  Useless for use in values, but that's OK,
    since the results are used only for type determinations.   Works on both
    structs and unions.  Representation note: to save space, we memorize

-   the result of this function in the TYPE_TARGET_TYPE of the
+   the result of this function in the type::target_type of the

    template type.  */
 
 static struct type *
    template type.  */
 
 static struct type *


@@ -8060,8 +8110,8 @@ template_to_static_fixed_type (struct type *type0)
     return type0;
 
   /* Likewise if we already have computed the static approximation.  */
     return type0;
 
   /* Likewise if we already have computed the static approximation.  */

-  if (TYPE_TARGET_TYPE (type0) != NULL)
-    return TYPE_TARGET_TYPE (type0);
+  if (type0->target_type () != NULL)
+    return type0->target_type ();

 
   /* Don't clone TYPE0 until we are sure we are going to need a copy.  */
   type = type0;
 
   /* Don't clone TYPE0 until we are sure we are going to need a copy.  */
   type = type0;


@@ -8069,7 +8119,7 @@ template_to_static_fixed_type (struct type *type0)
 
   /* Whether or not we cloned TYPE0, cache the result so that we don't do
      recompute all over next time.  */
 
   /* Whether or not we cloned TYPE0, cache the result so that we don't do
      recompute all over next time.  */

-  TYPE_TARGET_TYPE (type0) = type;
+  type0->set_target_type (type);

 
   for (f = 0; f < nfields; f += 1)
     {
 
   for (f = 0; f < nfields; f += 1)
     {


@@ -8079,7 +8129,7 @@ template_to_static_fixed_type (struct type *type0)
       if (is_dynamic_field (type0, f))
        {
          field_type = ada_check_typedef (field_type);
       if (is_dynamic_field (type0, f))
        {
          field_type = ada_check_typedef (field_type);

-         new_type = to_static_fixed_type (TYPE_TARGET_TYPE (field_type));
+         new_type = to_static_fixed_type (field_type->target_type ());

        }
       else
        new_type = static_unwrap_type (field_type);
        }
       else
        new_type = static_unwrap_type (field_type);


@@ -8089,7 +8139,8 @@ template_to_static_fixed_type (struct type *type0)
          /* Clone TYPE0 only the first time we get a new field type.  */
          if (type == type0)
            {
          /* Clone TYPE0 only the first time we get a new field type.  */
          if (type == type0)
            {

-             TYPE_TARGET_TYPE (type0) = type = alloc_type_copy (type0);
+             type = alloc_type_copy (type0);
+             type0->set_target_type (type);

              type->set_code (type0->code ());
              INIT_NONE_SPECIFIC (type);
              type->set_num_fields (nfields);
              type->set_code (type0->code ());
              INIT_NONE_SPECIFIC (type);
              type->set_num_fields (nfields);


@@ -8103,7 +8154,7 @@ template_to_static_fixed_type (struct type *type0)
 
              type->set_name (ada_type_name (type0));
              type->set_is_fixed_instance (true);
 
              type->set_name (ada_type_name (type0));
              type->set_is_fixed_instance (true);

-             TYPE_LENGTH (type) = 0;
+             type->set_length (0);

            }
          type->field (f).set_type (new_type);
          type->field (f).set_name (type0->field (f).name ());
            }
          type->field (f).set_type (new_type);
          type->field (f).set_name (type0->field (f).name ());


@@ -8124,7 +8175,6 @@ static struct type *
 to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
                                   CORE_ADDR address, struct value *dval0)
 {
 to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
                                   CORE_ADDR address, struct value *dval0)
 {

-  struct value *mark = value_mark ();

   struct value *dval;
   struct type *rtype;
   struct type *branch_type;
   struct value *dval;
   struct type *rtype;
   struct type *branch_type;


@@ -8134,6 +8184,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
   if (variant_field == -1)
     return type;
 
   if (variant_field == -1)
     return type;
 

+  scoped_value_mark mark;

   if (dval0 == NULL)
     {
       dval = value_from_contents_and_address (type, valaddr, address);
   if (dval0 == NULL)
     {
       dval = value_from_contents_and_address (type, valaddr, address);


@@ -8154,7 +8205,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
 
   rtype->set_name (ada_type_name (type));
   rtype->set_is_fixed_instance (true);
 
   rtype->set_name (ada_type_name (type));
   rtype->set_is_fixed_instance (true);

-  TYPE_LENGTH (rtype) = TYPE_LENGTH (type);
+  rtype->set_length (type->length ());

 
   branch_type = to_fixed_variant_branch_type
     (type->field (variant_field).type (),
 
   branch_type = to_fixed_variant_branch_type
     (type->field (variant_field).type (),


@@ -8177,11 +8228,12 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
       rtype->field (variant_field).set_type (branch_type);
       rtype->field (variant_field).set_name ("S");
       TYPE_FIELD_BITSIZE (rtype, variant_field) = 0;
       rtype->field (variant_field).set_type (branch_type);
       rtype->field (variant_field).set_name ("S");
       TYPE_FIELD_BITSIZE (rtype, variant_field) = 0;

-      TYPE_LENGTH (rtype) += TYPE_LENGTH (branch_type);
+      rtype->set_length (rtype->length () + branch_type->length ());

     }
     }

-  TYPE_LENGTH (rtype) -= TYPE_LENGTH (type->field (variant_field).type ());

 
 

-  value_free_to_mark (mark);
+  rtype->set_length (rtype->length ()
+                    - type->field (variant_field).type ()->length ());
+

   return rtype;
 }
 
   return rtype;
 }
 


@@ -8248,7 +8300,7 @@ to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr,
   struct type *var_type;
 
   if (var_type0->code () == TYPE_CODE_PTR)
   struct type *var_type;
 
   if (var_type0->code () == TYPE_CODE_PTR)

-    var_type = TYPE_TARGET_TYPE (var_type0);
+    var_type = var_type0->target_type ();

   else
     var_type = var_type0;
 
   else
     var_type = var_type0;
 


@@ -8265,8 +8317,7 @@ to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr,
     return empty_record (var_type);
   else if (is_dynamic_field (var_type, which))
     return to_fixed_record_type
     return empty_record (var_type);
   else if (is_dynamic_field (var_type, which))
     return to_fixed_record_type

-      (TYPE_TARGET_TYPE (var_type->field (which).type ()),
-       valaddr, address, dval);
+      (var_type->field (which).type ()->target_type(), valaddr, address, dval);

   else if (variant_field_index (var_type->field (which).type ()) >= 0)
     return
       to_fixed_record_type
   else if (variant_field_index (var_type->field (which).type ()) >= 0)
     return
       to_fixed_record_type


@@ -8341,7 +8392,7 @@ ada_is_redundant_index_type_desc (struct type *array_type,
       if (!ada_is_redundant_range_encoding (this_layer->index_type (),
                                            desc_type->field (i).type ()))
        return 0;
       if (!ada_is_redundant_range_encoding (this_layer->index_type (),
                                            desc_type->field (i).type ()))
        return 0;

-      this_layer = check_typedef (TYPE_TARGET_TYPE (this_layer));
+      this_layer = check_typedef (this_layer->target_type ());

     }
 
   return 1;
     }
 
   return 1;


@@ -8414,7 +8465,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 
   if (index_type_desc == NULL)
     {
 
   if (index_type_desc == NULL)
     {

-      struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0));
+      struct type *elt_type0 = ada_check_typedef (type0->target_type ());

 
       /* NOTE: elt_type---the fixed version of elt_type0---should never
         depend on the contents of the array in properly constructed
 
       /* NOTE: elt_type---the fixed version of elt_type0---should never
         depend on the contents of the array in properly constructed


@@ -8445,7 +8496,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 
       elt_type0 = type0;
       for (i = index_type_desc->num_fields (); i > 0; i -= 1)
 
       elt_type0 = type0;
       for (i = index_type_desc->num_fields (); i > 0; i -= 1)

-       elt_type0 = TYPE_TARGET_TYPE (elt_type0);
+       elt_type0 = elt_type0->target_type ();

 
       /* NOTE: result---the fixed version of elt_type0---should never
         depend on the contents of the array in properly constructed
 
       /* NOTE: result---the fixed version of elt_type0---should never
         depend on the contents of the array in properly constructed


@@ -8469,7 +8520,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
 
          result = create_array_type (alloc_type_copy (elt_type0),
                                      result, range_type);
 
          result = create_array_type (alloc_type_copy (elt_type0),
                                      result, range_type);

-         elt_type0 = TYPE_TARGET_TYPE (elt_type0);
+         elt_type0 = elt_type0->target_type ();

        }
     }
 
        }
     }
 


@@ -8484,13 +8535,13 @@ to_fixed_array_type (struct type *type0, struct value *dval,
         type was a regular (non-packed) array type.  As a result, the
         bitsize of the array elements needs to be set again, and the array
         length needs to be recomputed based on that bitsize.  */
         type was a regular (non-packed) array type.  As a result, the
         bitsize of the array elements needs to be set again, and the array
         length needs to be recomputed based on that bitsize.  */

-      int len = TYPE_LENGTH (result) / TYPE_LENGTH (TYPE_TARGET_TYPE (result));
+      int len = result->length () / result->target_type ()->length ();

       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
 
       TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
 
       TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);

-      TYPE_LENGTH (result) = len * elt_bitsize / HOST_CHAR_BIT;
-      if (TYPE_LENGTH (result) * HOST_CHAR_BIT < len * elt_bitsize)
-       TYPE_LENGTH (result)++;
+      result->set_length (len * elt_bitsize / HOST_CHAR_BIT);
+      if (result->length () * HOST_CHAR_BIT < len * elt_bitsize)
+       result->set_length (result->length () + 1);

     }
 
   result->set_is_fixed_instance (true);
     }
 
   result->set_is_fixed_instance (true);


@@ -8583,10 +8634,10 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
                             xvz_name, except.what ());
              }
 
                             xvz_name, except.what ());
              }
 

-           if (xvz_found && TYPE_LENGTH (fixed_record_type) != size)
+           if (xvz_found && fixed_record_type->length () != size)

              {
                fixed_record_type = copy_type (fixed_record_type);
              {
                fixed_record_type = copy_type (fixed_record_type);

-               TYPE_LENGTH (fixed_record_type) = size;
+               fixed_record_type->set_length (size);

 
                /* The FIXED_RECORD_TYPE may have be a stub.  We have
                   observed this when the debugging info is STABS, and
 
                /* The FIXED_RECORD_TYPE may have be a stub.  We have
                   observed this when the debugging info is STABS, and


@@ -8895,7 +8946,7 @@ val_atr (struct type *type, LONGEST val)
 {
   gdb_assert (discrete_type_p (type));
   if (type->code () == TYPE_CODE_RANGE)
 {
   gdb_assert (discrete_type_p (type));
   if (type->code () == TYPE_CODE_RANGE)

-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();

   if (type->code () == TYPE_CODE_ENUM)
     {
       if (val < 0 || val >= type->num_fields ())
   if (type->code () == TYPE_CODE_ENUM)
     {
       if (val < 0 || val >= type->num_fields ())


@@ -9042,7 +9093,7 @@ ada_get_base_type (struct type *raw_type)
     }
 
   /* The field in our XVS type is a reference to the base type.  */
     }
 
   /* The field in our XVS type is a reference to the base type.  */

-  return TYPE_TARGET_TYPE (real_type_namer->field (0).type ());
+  return real_type_namer->field (0).type ()->target_type ();

 }
 
 /* The type of value designated by TYPE, with all aligners removed.  */
 }
 
 /* The type of value designated by TYPE, with all aligners removed.  */


@@ -9226,7 +9277,7 @@ ada_same_array_size_p (struct type *t1, struct type *t2)
 static struct value *
 ada_promote_array_of_integrals (struct type *type, struct value *val)
 {
 static struct value *
 ada_promote_array_of_integrals (struct type *type, struct value *val)
 {

-  struct type *elt_type = TYPE_TARGET_TYPE (type);
+  struct type *elt_type = type->target_type ();

   LONGEST lo, hi;
   LONGEST i;
 
   LONGEST lo, hi;
   LONGEST i;
 


@@ -9234,11 +9285,11 @@ ada_promote_array_of_integrals (struct type *type, struct value *val)
      that the size of val's elements is smaller than the size
      of type's element.  */
   gdb_assert (type->code () == TYPE_CODE_ARRAY);
      that the size of val's elements is smaller than the size
      of type's element.  */
   gdb_assert (type->code () == TYPE_CODE_ARRAY);

-  gdb_assert (is_integral_type (TYPE_TARGET_TYPE (type)));
+  gdb_assert (is_integral_type (type->target_type ()));

   gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);
   gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);

-  gdb_assert (is_integral_type (TYPE_TARGET_TYPE (value_type (val))));
-  gdb_assert (TYPE_LENGTH (TYPE_TARGET_TYPE (type))
-             > TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (val))));
+  gdb_assert (is_integral_type (value_type (val)->target_type ()));
+  gdb_assert (type->target_type ()->length ()
+             > value_type (val)->target_type ()->length ());

 
   if (!get_array_bounds (type, &lo, &hi))
     error (_("unable to determine array bounds"));
 
   if (!get_array_bounds (type, &lo, &hi))
     error (_("unable to determine array bounds"));


@@ -9250,7 +9301,7 @@ ada_promote_array_of_integrals (struct type *type, struct value *val)
   for (i = 0; i < hi - lo + 1; i++)
     {
       struct value *elt = value_cast (elt_type, value_subscript (val, lo + i));
   for (i = 0; i < hi - lo + 1; i++)
     {
       struct value *elt = value_cast (elt_type, value_subscript (val, lo + i));

-      int elt_len = TYPE_LENGTH (elt_type);
+      int elt_len = elt_type->length ();

 
       copy (value_contents_all (elt), res_contents.slice (elt_len * i, elt_len));
     }
 
       copy (value_contents_all (elt), res_contents.slice (elt_len * i, elt_len));
     }


@@ -9285,18 +9336,16 @@ coerce_for_assign (struct type *type, struct value *val)
       if (!ada_same_array_size_p (type, type2))
        error (_("cannot assign arrays of different length"));
 
       if (!ada_same_array_size_p (type, type2))
        error (_("cannot assign arrays of different length"));
 

-      if (is_integral_type (TYPE_TARGET_TYPE (type))
-         && is_integral_type (TYPE_TARGET_TYPE (type2))
-         && TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
-              < TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
+      if (is_integral_type (type->target_type ())
+         && is_integral_type (type2->target_type ())
+         && type2->target_type ()->length () < type->target_type ()->length ())

        {
          /* Allow implicit promotion of the array elements to
             a wider type.  */
          return ada_promote_array_of_integrals (type, val);
        }
 
        {
          /* Allow implicit promotion of the array elements to
             a wider type.  */
          return ada_promote_array_of_integrals (type, val);
        }
 

-      if (TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
-         != TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
+      if (type2->target_type ()->length () != type->target_type ()->length ())

        error (_("Incompatible types in assignment"));
       deprecated_set_value_type (val, type);
     }
        error (_("Incompatible types in assignment"));
       deprecated_set_value_type (val, type);
     }


@@ -9369,7 +9418,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 (),
 
   val = allocate_value (type1);
   store_unsigned_integer (value_contents_raw (val).data (),

-                         TYPE_LENGTH (value_type (val)),
+                         value_type (val)->length (),

                          type_byte_order (type1), v);
   return val;
 }
                          type_byte_order (type1), v);
   return val;
 }


@@ -9399,10 +9448,10 @@ ada_value_equal (struct value *arg1, struct value *arg2)
       /* FIXME: The following works only for types whose
         representations use all bits (no padding or undefined bits)
         and do not have user-defined equality.  */
       /* FIXME: The following works only for types whose
         representations use all bits (no padding or undefined bits)
         and do not have user-defined equality.  */

-      return (TYPE_LENGTH (arg1_type) == TYPE_LENGTH (arg2_type)
+      return (arg1_type->length () == arg2_type->length ()

              && memcmp (value_contents (arg1).data (),
                         value_contents (arg2).data (),
              && memcmp (value_contents (arg1).data (),
                         value_contents (arg2).data (),

-                        TYPE_LENGTH (arg1_type)) == 0);
+                        arg1_type->length ()) == 0);

     }
   return value_equal (arg1, arg2);
 }
     }
   return value_equal (arg1, arg2);
 }


@@ -9466,7 +9515,7 @@ ada_aggregate_component::uses_objfile (struct objfile *objfile)
 void
 ada_aggregate_component::dump (ui_file *stream, int depth)
 {
 void
 ada_aggregate_component::dump (ui_file *stream, int depth)
 {

-  fprintf_filtered (stream, _("%*sAggregate\n"), depth, "");
+  gdb_printf (stream, _("%*sAggregate\n"), depth, "");

   for (const auto &item : m_components)
     item->dump (stream, depth + 1);
 }
   for (const auto &item : m_components)
     item->dump (stream, depth + 1);
 }


@@ -9533,8 +9582,8 @@ ada_positional_component::uses_objfile (struct objfile *objfile)
 void
 ada_positional_component::dump (ui_file *stream, int depth)
 {
 void
 ada_positional_component::dump (ui_file *stream, int depth)
 {

-  fprintf_filtered (stream, _("%*sPositional, index = %d\n"),
-                   depth, "", m_index);
+  gdb_printf (stream, _("%*sPositional, index = %d\n"),
+             depth, "", m_index);

   m_op->dump (stream, depth + 1);
 }
 
   m_op->dump (stream, depth + 1);
 }
 


@@ -9568,7 +9617,7 @@ ada_discrete_range_association::uses_objfile (struct objfile *objfile)
 void
 ada_discrete_range_association::dump (ui_file *stream, int depth)
 {
 void
 ada_discrete_range_association::dump (ui_file *stream, int depth)
 {

-  fprintf_filtered (stream, _("%*sDiscrete range:\n"), depth, "");
+  gdb_printf (stream, _("%*sDiscrete range:\n"), depth, "");

   m_low->dump (stream, depth + 1);
   m_high->dump (stream, depth + 1);
 }
   m_low->dump (stream, depth + 1);
   m_high->dump (stream, depth + 1);
 }


@@ -9604,7 +9653,7 @@ ada_name_association::uses_objfile (struct objfile *objfile)
 void
 ada_name_association::dump (ui_file *stream, int depth)
 {
 void
 ada_name_association::dump (ui_file *stream, int depth)
 {

-  fprintf_filtered (stream, _("%*sName:\n"), depth, "");
+  gdb_printf (stream, _("%*sName:\n"), depth, "");

   m_val->dump (stream, depth + 1);
 }
 
   m_val->dump (stream, depth + 1);
 }
 


@@ -9662,7 +9711,7 @@ ada_choices_component::uses_objfile (struct objfile *objfile)
 void
 ada_choices_component::dump (ui_file *stream, int depth)
 {
 void
 ada_choices_component::dump (ui_file *stream, int depth)
 {

-  fprintf_filtered (stream, _("%*sChoices:\n"), depth, "");
+  gdb_printf (stream, _("%*sChoices:\n"), depth, "");

   m_op->dump (stream, depth + 1);
   for (const auto &item : m_assocs)
     item->dump (stream, depth + 1);
   m_op->dump (stream, depth + 1);
   for (const auto &item : m_assocs)
     item->dump (stream, depth + 1);


@@ -9691,7 +9740,7 @@ ada_others_component::uses_objfile (struct objfile *objfile)
 void
 ada_others_component::dump (ui_file *stream, int depth)
 {
 void
 ada_others_component::dump (ui_file *stream, int depth)
 {

-  fprintf_filtered (stream, _("%*sOthers:\n"), depth, "");
+  gdb_printf (stream, _("%*sOthers:\n"), depth, "");

   m_op->dump (stream, depth + 1);
 }
 
   m_op->dump (stream, depth + 1);
 }
 


@@ -10147,13 +10196,13 @@ ada_atr_size (struct type *expect_type,
      the user is really asking for the size of the actual object,
      not the size of the pointer.  */
   if (type->code () == TYPE_CODE_REF)
      the user is really asking for the size of the actual object,
      not the size of the pointer.  */
   if (type->code () == TYPE_CODE_REF)

-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();

 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     return value_zero (builtin_type (exp->gdbarch)->builtin_int, not_lval);
   else
     return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     return value_zero (builtin_type (exp->gdbarch)->builtin_int, not_lval);
   else
     return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,

-                              TARGET_CHAR_BIT * TYPE_LENGTH (type));
+                              TARGET_CHAR_BIT * type->length ());

 }
 
 /* A helper function for UNOP_ABS.  */
 }
 
 /* A helper function for UNOP_ABS.  */


@@ -10232,9 +10281,9 @@ ada_ternop_slice (struct expression *exp,
   /* If this is a reference to an aligner type, then remove all
      the aligners.  */
   if (value_type (array)->code () == TYPE_CODE_REF
   /* If this is a reference to an aligner type, then remove all
      the aligners.  */
   if (value_type (array)->code () == TYPE_CODE_REF

-      && ada_is_aligner_type (TYPE_TARGET_TYPE (value_type (array))))
-    TYPE_TARGET_TYPE (value_type (array)) =
-      ada_aligned_type (TYPE_TARGET_TYPE (value_type (array)));
+      && ada_is_aligner_type (value_type (array)->target_type ()))
+    value_type (array)->set_target_type
+      (ada_aligned_type (value_type (array)->target_type ()));

 
   if (ada_is_any_packed_array_type (value_type (array)))
     error (_("cannot slice a packed array"));
 
   if (ada_is_any_packed_array_type (value_type (array)))
     error (_("cannot slice a packed array"));


@@ -10257,7 +10306,7 @@ ada_ternop_slice (struct expression *exp,
   /* If we have more than one level of pointer indirection,
      dereference the value until we get only one level.  */
   while (value_type (array)->code () == TYPE_CODE_PTR
   /* If we have more than one level of pointer indirection,
      dereference the value until we get only one level.  */
   while (value_type (array)->code () == TYPE_CODE_PTR

-        && (TYPE_TARGET_TYPE (value_type (array))->code ()
+        && (value_type (array)->target_type ()->code ()

             == TYPE_CODE_PTR))
     array = value_ind (array);
 
             == TYPE_CODE_PTR))
     array = value_ind (array);
 


@@ -10274,11 +10323,11 @@ ada_ternop_slice (struct expression *exp,
       struct type *type0 = ada_check_typedef (value_type (array));
 
       if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)
       struct type *type0 = ada_check_typedef (value_type (array));
 
       if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)

-       return empty_array (TYPE_TARGET_TYPE (type0), low_bound, high_bound);
+       return empty_array (type0->target_type (), low_bound, high_bound);

       else
        {
          struct type *arr_type0 =
       else
        {
          struct type *arr_type0 =

-           to_fixed_array_type (TYPE_TARGET_TYPE (type0), NULL, 1);
+           to_fixed_array_type (type0->target_type (), NULL, 1);

 
          return ada_value_slice_from_ptr (array, arr_type0,
                                           longest_to_int (low_bound),
 
          return ada_value_slice_from_ptr (array, arr_type0,
                                           longest_to_int (low_bound),


@@ -10552,6 +10601,17 @@ convert_char_literal (struct type *type, LONGEST val)
   return val;
 }
 
   return val;
 }
 

+value *
+ada_char_operation::evaluate (struct type *expect_type,
+                             struct expression *exp,
+                             enum noside noside)
+{
+  value *result = long_const_operation::evaluate (expect_type, exp, noside);
+  if (expect_type != nullptr)
+    result = ada_value_cast (expect_type, result);
+  return result;
+}
+

 /* See ada-exp.h.  */
 
 operation_up
 /* See ada-exp.h.  */
 
 operation_up


@@ -10572,7 +10632,7 @@ ada_char_operation::replace (operation_up &&owner,
        = convert_char_literal (context_type, std::get<1> (m_storage));
     }
 
        = convert_char_literal (context_type, std::get<1> (m_storage));
     }
 

-  return make_operation<ada_wrapped_operation> (std::move (result));
+  return result;

 }
 
 value *
 }
 
 value *


@@ -10611,7 +10671,7 @@ ada_string_operation::evaluate (struct type *expect_type,
 
   const std::string &str = std::get<0> (m_storage);
   const char *encoding;
 
   const std::string &str = std::get<0> (m_storage);
   const char *encoding;

-  switch (TYPE_LENGTH (char_type))
+  switch (char_type->length ())

     {
     case 1:
       {
     {
     case 1:
       {


@@ -10642,7 +10702,7 @@ ada_string_operation::evaluate (struct type *expect_type,
 
     default:
       error (_("unexpected character type size %s"),
 
     default:
       error (_("unexpected character type size %s"),

-            pulongest (TYPE_LENGTH (char_type)));
+            pulongest (char_type->length ()));

     }
 
   auto_obstack converted;
     }
 
   auto_obstack converted;


@@ -10654,7 +10714,7 @@ ada_string_operation::evaluate (struct type *expect_type,
   struct type *stringtype
     = lookup_array_range_type (char_type, 1,
                               obstack_object_size (&converted)
   struct type *stringtype
     = lookup_array_range_type (char_type, 1,
                               obstack_object_size (&converted)

-                              / TYPE_LENGTH (char_type));
+                              / char_type->length ());

   struct value *val = allocate_value (stringtype);
   memcpy (value_contents_raw (val).data (),
          obstack_base (&converted),
   struct value *val = allocate_value (stringtype);
   memcpy (value_contents_raw (val).data (),
          obstack_base (&converted),


@@ -10662,6 +10722,51 @@ ada_string_operation::evaluate (struct type *expect_type,
   return val;
 }
 
   return val;
 }
 

+value *
+ada_concat_operation::evaluate (struct type *expect_type,
+                               struct expression *exp,
+                               enum noside noside)
+{
+  /* If one side is a literal, evaluate the other side first so that
+     the expected type can be set properly.  */
+  const operation_up &lhs_expr = std::get<0> (m_storage);
+  const operation_up &rhs_expr = std::get<1> (m_storage);
+
+  value *lhs, *rhs;
+  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);
+    }
+  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 *elt_type = nullptr;
+      if (rhs_type->code () == TYPE_CODE_ARRAY)
+       elt_type = rhs_type->target_type ();
+      lhs = lhs_expr->evaluate (elt_type, exp, noside);
+    }
+  else if (dynamic_cast<ada_string_operation *> (rhs_expr.get ()) != nullptr)
+    {
+      lhs = lhs_expr->evaluate (nullptr, exp, noside);
+      rhs = rhs_expr->evaluate (value_type (lhs), 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 *elt_type = nullptr;
+      if (lhs_type->code () == TYPE_CODE_ARRAY)
+       elt_type = lhs_type->target_type ();
+      rhs = rhs_expr->evaluate (elt_type, exp, noside);
+    }
+  else
+    return concat_operation::evaluate (expect_type, exp, noside);
+
+  return value_concat (lhs, rhs);
+}
+

 value *
 ada_qual_operation::evaluate (struct type *expect_type,
                              struct expression *exp,
 value *
 ada_qual_operation::evaluate (struct type *expect_type,
                              struct expression *exp,


@@ -10710,7 +10815,7 @@ ada_binop_addsub_operation::evaluate (struct type *expect_type,
      a reference type, find its underlying type.  */
   struct type *type = value_type (arg1);
   while (type->code () == TYPE_CODE_REF)
      a reference type, find its underlying type.  */
   struct type *type = value_type (arg1);
   while (type->code () == TYPE_CODE_REF)

-    type = TYPE_TARGET_TYPE (type);
+    type = type->target_type ();

   binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
   arg1 = value_binop (arg1, arg2, std::get<0> (m_storage));
   /* We need to special-case the result with a range.
   binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
   arg1 = value_binop (arg1, arg2, std::get<0> (m_storage));
   /* We need to special-case the result with a range.


@@ -10813,7 +10918,7 @@ ada_var_value_operation::evaluate (struct type *expect_type,
         a reference should mostly be transparent to the user.  */
       if (ada_is_tagged_type (type, 0)
          || (type->code () == TYPE_CODE_REF
         a reference should mostly be transparent to the user.  */
       if (ada_is_tagged_type (type, 0)
          || (type->code () == TYPE_CODE_REF

-             && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0)))
+             && ada_is_tagged_type (type->target_type (), 0)))

        {
          /* Tagged types are a little special in the fact that the real
             type is dynamic and can only be determined by inspecting the
        {
          /* Tagged types are a little special in the fact that the real
             type is dynamic and can only be determined by inspecting the


@@ -10943,7 +11048,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 
          if ((type->code () == TYPE_CODE_REF
               || type->code () == TYPE_CODE_PTR)
 
          if ((type->code () == TYPE_CODE_REF
               || type->code () == TYPE_CODE_PTR)

-             && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0))
+             && ada_is_tagged_type (type->target_type (), 0))

            {
              arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp,
                                                        EVAL_NORMAL);
            {
              arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp,
                                                        EVAL_NORMAL);


@@ -10953,7 +11058,7 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
            {
              type = to_static_fixed_type
                (ada_aligned_type
            {
              type = to_static_fixed_type
                (ada_aligned_type

-                (ada_check_typedef (TYPE_TARGET_TYPE (type))));
+                (ada_check_typedef (type->target_type ())));

            }
          return value_zero (type, lval_memory);
        }
            }
          return value_zero (type, lval_memory);
        }


@@ -11090,17 +11195,17 @@ ada_funcall_operation::evaluate (struct type *expect_type,
 
   if (type->code () == TYPE_CODE_PTR)
     {
 
   if (type->code () == TYPE_CODE_PTR)
     {

-      switch (ada_check_typedef (TYPE_TARGET_TYPE (type))->code ())
+      switch (ada_check_typedef (type->target_type ())->code ())

        {
        case TYPE_CODE_FUNC:
        {
        case TYPE_CODE_FUNC:

-         type = ada_check_typedef (TYPE_TARGET_TYPE (type));
+         type = ada_check_typedef (type->target_type ());

          break;
        case TYPE_CODE_ARRAY:
          break;
        case TYPE_CODE_STRUCT:
          if (noside != EVAL_AVOID_SIDE_EFFECTS)
            callee = ada_value_ind (callee);
          break;
        case TYPE_CODE_ARRAY:
          break;
        case TYPE_CODE_STRUCT:
          if (noside != EVAL_AVOID_SIDE_EFFECTS)
            callee = ada_value_ind (callee);

-         type = ada_check_typedef (TYPE_TARGET_TYPE (type));
+         type = ada_check_typedef (type->target_type ());

          break;
        default:
          error (_("cannot subscript or call something of type `%s'"),
          break;
        default:
          error (_("cannot subscript or call something of type `%s'"),


@@ -11114,9 +11219,9 @@ ada_funcall_operation::evaluate (struct type *expect_type,
     case TYPE_CODE_FUNC:
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
     case TYPE_CODE_FUNC:
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {

-         if (TYPE_TARGET_TYPE (type) == NULL)
+         if (type->target_type () == NULL)

            error_call_unknown_return_type (NULL);
            error_call_unknown_return_type (NULL);

-         return allocate_value (TYPE_TARGET_TYPE (type));
+         return allocate_value (type->target_type ());

        }
       return call_function_by_hand (callee, NULL, argvec);
     case TYPE_CODE_INTERNAL_FUNCTION:
        }
       return call_function_by_hand (callee, NULL, argvec);
     case TYPE_CODE_INTERNAL_FUNCTION:


@@ -11163,7 +11268,7 @@ ada_funcall_operation::evaluate (struct type *expect_type,
     case TYPE_CODE_PTR:     /* Pointer to array */
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
     case TYPE_CODE_PTR:     /* Pointer to array */
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {

-         type = to_fixed_array_type (TYPE_TARGET_TYPE (type), NULL, 1);
+         type = to_fixed_array_type (type->target_type (), NULL, 1);

          type = ada_array_element_type (type, nargs);
          if (type == NULL)
            error (_("element type of array unknown"));
          type = ada_array_element_type (type, nargs);
          if (type == NULL)
            error (_("element type of array unknown"));


@@ -11357,7 +11462,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
   gdb_assert (raw_type->name () != NULL);
 
   if (raw_type->code () == TYPE_CODE_RANGE)
   gdb_assert (raw_type->name () != NULL);
 
   if (raw_type->code () == TYPE_CODE_RANGE)

-    base_type = TYPE_TARGET_TYPE (raw_type);
+    base_type = raw_type->target_type ();

   else
     base_type = raw_type;
 
   else
     base_type = raw_type;
 


@@ -11428,7 +11533,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
       /* create_static_range_type alters the resulting type's length
         to match the size of the base_type, which is not what we want.
         Set it back to the original range type's length.  */
       /* create_static_range_type alters the resulting type's length
         to match the size of the base_type, which is not what we want.
         Set it back to the original range type's length.  */

-      TYPE_LENGTH (type) = TYPE_LENGTH (raw_type);
+      type->set_length (raw_type->length ());

       type->set_name (name);
       return type;
     }
       type->set_name (name);
       return type;
     }


@@ -11628,7 +11733,7 @@ ada_has_this_exception_support (const struct exception_support_info *einfo)
       struct bound_minimal_symbol msym
        = lookup_minimal_symbol (einfo->catch_exception_sym, NULL, NULL);
 
       struct bound_minimal_symbol msym
        = lookup_minimal_symbol (einfo->catch_exception_sym, NULL, NULL);
 

-      if (msym.minsym && MSYMBOL_TYPE (msym.minsym) != mst_solib_trampoline)
+      if (msym.minsym && msym.minsym->type () != mst_solib_trampoline)

        error (_("Your Ada runtime appears to be missing some debugging "
                 "information.\nCannot insert Ada exception catchpoint "
                 "in this configuration."));
        error (_("Your Ada runtime appears to be missing some debugging "
                 "information.\nCannot insert Ada exception catchpoint "
                 "in this configuration."));


@@ -11651,7 +11756,7 @@ ada_has_this_exception_support (const struct exception_support_info *einfo)
       struct bound_minimal_symbol msym
        = lookup_minimal_symbol (einfo->catch_handlers_sym, NULL, NULL);
 
       struct bound_minimal_symbol msym
        = lookup_minimal_symbol (einfo->catch_handlers_sym, NULL, NULL);
 

-      if (msym.minsym && MSYMBOL_TYPE (msym.minsym) != mst_solib_trampoline)
+      if (msym.minsym && msym.minsym->type () != mst_solib_trampoline)

        error (_("Your Ada runtime appears to be missing some debugging "
                 "information.\nCannot insert Ada exception catchpoint "
                 "in this configuration."));
        error (_("Your Ada runtime appears to be missing some debugging "
                 "information.\nCannot insert Ada exception catchpoint "
                 "in this configuration."));


@@ -11740,7 +11845,7 @@ ada_exception_support_info_sniffer (void)
    to most users.  */
 
 static int
    to most users.  */
 
 static int

-is_known_support_routine (struct frame_info *frame)
+is_known_support_routine (frame_info_ptr frame)

 {
   enum language func_lang;
   int i;
 {
   enum language func_lang;
   int i;


@@ -11773,8 +11878,8 @@ is_known_support_routine (struct frame_info *frame)
       re_comp (known_runtime_file_name_patterns[i]);
       if (re_exec (lbasename (sal.symtab->filename)))
        return 1;
       re_comp (known_runtime_file_name_patterns[i]);
       if (re_exec (lbasename (sal.symtab->filename)))
        return 1;

-      if (sal.symtab->objfile () != NULL
-         && re_exec (objfile_name (sal.symtab->objfile ())))
+      if (sal.symtab->compunit ()->objfile () != NULL
+         && re_exec (objfile_name (sal.symtab->compunit ()->objfile ())))

        return 1;
     }
 
        return 1;
     }
 


@@ -11799,7 +11904,7 @@ is_known_support_routine (struct frame_info *frame)
    part of the Ada run-time, starting from FI and moving upward.  */
 
 void
    part of the Ada run-time, starting from FI and moving upward.  */
 
 void

-ada_find_printable_frame (struct frame_info *fi)
+ada_find_printable_frame (frame_info_ptr fi)

 {
   for (; fi != NULL; fi = get_prev_frame (fi))
     {
 {
   for (; fi != NULL; fi = get_prev_frame (fi))
     {


@@ -11833,7 +11938,7 @@ static CORE_ADDR
 ada_unhandled_exception_name_addr_from_raise (void)
 {
   int frame_level;
 ada_unhandled_exception_name_addr_from_raise (void)
 {
   int frame_level;

-  struct frame_info *fi;
+  frame_info_ptr fi;

   struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
 
   /* To determine the name of this exception, we need to select
   struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
 
   /* To determine the name of this exception, we need to select


@@ -11876,8 +11981,7 @@ ada_unhandled_exception_name_addr_from_raise (void)
    Return zero if the address could not be computed, or if not relevant.  */
 
 static CORE_ADDR
    Return zero if the address could not be computed, or if not relevant.  */
 
 static CORE_ADDR

-ada_exception_name_addr_1 (enum ada_exception_catchpoint_kind ex,
-                          struct breakpoint *b)
+ada_exception_name_addr_1 (enum ada_exception_catchpoint_kind ex)

 {
   struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
 
 {
   struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
 


@@ -11901,7 +12005,7 @@ ada_exception_name_addr_1 (enum ada_exception_catchpoint_kind ex,
        break;
 
       default:
        break;
 
       default:

-       internal_error (__FILE__, __LINE__, _("unexpected catchpoint type"));
+       internal_error (_("unexpected catchpoint type"));

        break;
     }
 
        break;
     }
 


@@ -11934,7 +12038,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_val = ada_coerce_to_simple_array (e_msg_val);
   gdb_assert (e_msg_val != NULL);

-  e_msg_len = TYPE_LENGTH (value_type (e_msg_val));
+  e_msg_len = value_type (e_msg_val)->length ();

 
   /* If the message string is empty, then treat it as if there was
      no exception message.  */
 
   /* If the message string is empty, then treat it as if there was
      no exception message.  */


@@ -11975,14 +12079,13 @@ ada_exception_message (void)
    and zero is returned.  */
 
 static CORE_ADDR
    and zero is returned.  */
 
 static CORE_ADDR

-ada_exception_name_addr (enum ada_exception_catchpoint_kind ex,
-                        struct breakpoint *b)
+ada_exception_name_addr (enum ada_exception_catchpoint_kind ex)

 {
   CORE_ADDR result = 0;
 
   try
     {
 {
   CORE_ADDR result = 0;
 
   try
     {

-      result = ada_exception_name_addr_1 (ex, b);
+      result = ada_exception_name_addr_1 (ex);

     }
 
   catch (const gdb_exception_error &e)
     }
 
   catch (const gdb_exception_error &e)


@@ -12011,13 +12114,74 @@ static std::string ada_exception_catchpoint_cond_string
    exception, in order to be able to re-set the condition expression
    when symbols change.  */
 
    exception, in order to be able to re-set the condition expression
    when symbols change.  */
 

+/* An instance of this type is used to represent an Ada catchpoint.  */
+
+struct ada_catchpoint : public code_breakpoint
+{
+  ada_catchpoint (struct gdbarch *gdbarch_,
+                 enum ada_exception_catchpoint_kind kind,
+                 struct symtab_and_line sal,
+                 const char *addr_string_,
+                 bool tempflag,
+                 bool enabled,
+                 bool from_tty)
+    : code_breakpoint (gdbarch_, bp_catchpoint),
+      m_kind (kind)
+  {
+    add_location (sal);
+
+    /* Unlike most code_breakpoint types, Ada catchpoints are
+       pspace-specific.  */
+    gdb_assert (sal.pspace != nullptr);
+    this->pspace = sal.pspace;
+
+    if (from_tty)
+      {
+       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
+       if (!loc_gdbarch)
+         loc_gdbarch = gdbarch;
+
+       describe_other_breakpoints (loc_gdbarch,
+                                   sal.pspace, sal.pc, sal.section, -1);
+       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
+          version for exception catchpoints, because two catchpoints
+          used for different exception names will use the same address.
+          In this case, a "breakpoint ... also set at..." warning is
+          unproductive.  Besides, the warning phrasing is also a bit
+          inappropriate, we should use the word catchpoint, and tell
+          the user what type of catchpoint it is.  The above is good
+          enough for now, though.  */
+      }
+
+    enable_state = enabled ? bp_enabled : bp_disabled;
+    disposition = tempflag ? disp_del : disp_donttouch;
+    locspec = string_to_location_spec (&addr_string_,
+                                      language_def (language_ada));
+    language = language_ada;
+  }
+
+  struct bp_location *allocate_location () override;
+  void re_set () override;
+  void check_status (struct bpstat *bs) override;
+  enum print_stop_action print_it (const bpstat *bs) const override;
+  bool print_one (bp_location **) const override;
+  void print_mention () const override;
+  void print_recreate (struct ui_file *fp) const override;
+
+  /* The name of the specific exception the user specified.  */
+  std::string excep_string;
+
+  /* What kind of catchpoint this is.  */
+  enum ada_exception_catchpoint_kind m_kind;
+};
+

 /* An instance of this type is used to represent an Ada catchpoint
    breakpoint location.  */
 
 class ada_catchpoint_location : public bp_location
 {
 public:
 /* An instance of this type is used to represent an Ada catchpoint
    breakpoint location.  */
 
 class ada_catchpoint_location : public bp_location
 {
 public:

-  ada_catchpoint_location (breakpoint *owner)
+  explicit ada_catchpoint_location (ada_catchpoint *owner)

     : bp_location (owner, bp_loc_software_breakpoint)
   {}
 
     : bp_location (owner, bp_loc_software_breakpoint)
   {}
 


@@ -12027,22 +12191,6 @@ public:
   expression_up excep_cond_expr;
 };
 
   expression_up excep_cond_expr;
 };
 

-/* An instance of this type is used to represent an Ada catchpoint.  */
-
-struct ada_catchpoint : public breakpoint
-{
-  explicit ada_catchpoint (enum ada_exception_catchpoint_kind kind)
-    : m_kind (kind)
-  {
-  }
-
-  /* The name of the specific exception the user specified.  */
-  std::string excep_string;
-
-  /* What kind of catchpoint this is.  */
-  enum ada_exception_catchpoint_kind m_kind;
-};
-

 /* Parse the exception condition string in the context of each of the
    catchpoint's locations, and store them for later evaluation.  */
 
 /* Parse the exception condition string in the context of each of the
    catchpoint's locations, and store them for later evaluation.  */
 


@@ -12094,30 +12242,28 @@ create_excep_cond_exprs (struct ada_catchpoint *c,
     }
 }
 
     }
 }
 

-/* Implement the ALLOCATE_LOCATION method in the breakpoint_ops
-   structure for all exception catchpoint kinds.  */
+/* Implement the ALLOCATE_LOCATION method in the structure for all
+   exception catchpoint kinds.  */

 
 

-static struct bp_location *
-allocate_location_exception (struct breakpoint *self)
+struct bp_location *
+ada_catchpoint::allocate_location ()

 {
 {

-  return new ada_catchpoint_location (self);
+  return new ada_catchpoint_location (this);

 }
 
 }
 

-/* Implement the RE_SET method in the breakpoint_ops structure for all
-   exception catchpoint kinds.  */
+/* Implement the RE_SET method in the structure for all exception
+   catchpoint kinds.  */

 
 

-static void
-re_set_exception (struct breakpoint *b)
+void
+ada_catchpoint::re_set ()

 {
 {

-  struct ada_catchpoint *c = (struct ada_catchpoint *) b;
-

   /* Call the base class's method.  This updates the catchpoint's
      locations.  */
   /* Call the base class's method.  This updates the catchpoint's
      locations.  */

-  bkpt_breakpoint_ops.re_set (b);
+  this->code_breakpoint::re_set ();

 
   /* Reparse the exception conditional expressions.  One for each
      location.  */
 
   /* Reparse the exception conditional expressions.  One for each
      location.  */

-  create_excep_cond_exprs (c, c->m_kind);
+  create_excep_cond_exprs (this, m_kind);

 }
 
 /* Returns true if we should stop for this breakpoint hit.  If the
 }
 
 /* Returns true if we should stop for this breakpoint hit.  If the


@@ -12170,11 +12316,8 @@ should_stop_exception (const struct bp_location *bl)
   stop = true;
   try
     {
   stop = true;
   try
     {

-      struct value *mark;
-
-      mark = value_mark ();
+      scoped_value_mark mark;

       stop = value_true (evaluate_expression (ada_loc->excep_cond_expr.get ()));
       stop = value_true (evaluate_expression (ada_loc->excep_cond_expr.get ()));

-      value_free_to_mark (mark);

     }
   catch (const gdb_exception &ex)
     {
     }
   catch (const gdb_exception &ex)
     {


@@ -12185,36 +12328,35 @@ should_stop_exception (const struct bp_location *bl)
   return stop;
 }
 
   return stop;
 }
 

-/* Implement the CHECK_STATUS method in the breakpoint_ops structure
-   for all exception catchpoint kinds.  */
+/* Implement the CHECK_STATUS method in the structure for all
+   exception catchpoint kinds.  */

 
 

-static void
-check_status_exception (bpstat *bs)
+void
+ada_catchpoint::check_status (bpstat *bs)

 {
   bs->stop = should_stop_exception (bs->bp_location_at.get ());
 }
 
 {
   bs->stop = should_stop_exception (bs->bp_location_at.get ());
 }
 

-/* Implement the PRINT_IT method in the breakpoint_ops structure
-   for all exception catchpoint kinds.  */
+/* Implement the PRINT_IT method in the structure for all exception
+   catchpoint kinds.  */

 
 

-static enum print_stop_action
-print_it_exception (bpstat *bs)
+enum print_stop_action
+ada_catchpoint::print_it (const bpstat *bs) const

 {
   struct ui_out *uiout = current_uiout;
 {
   struct ui_out *uiout = current_uiout;

-  struct breakpoint *b = bs->breakpoint_at;

 
 

-  annotate_catchpoint (b->number);
+  annotate_catchpoint (number);

 
   if (uiout->is_mi_like_p ())
     {
       uiout->field_string ("reason",
                           async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
 
   if (uiout->is_mi_like_p ())
     {
       uiout->field_string ("reason",
                           async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));

-      uiout->field_string ("disp", bpdisp_text (b->disposition));
+      uiout->field_string ("disp", bpdisp_text (disposition));

     }
 
     }
 

-  uiout->text (b->disposition == disp_del
+  uiout->text (disposition == disp_del

               ? "\nTemporary catchpoint " : "\nCatchpoint ");
               ? "\nTemporary catchpoint " : "\nCatchpoint ");

-  uiout->field_signed ("bkptno", b->number);
+  print_num_locno (bs, uiout);

   uiout->text (", ");
 
   /* ada_exception_name_addr relies on the selected frame being the
   uiout->text (", ");
 
   /* ada_exception_name_addr relies on the selected frame being the


@@ -12224,14 +12366,13 @@ print_it_exception (bpstat *bs)
      ada_find_printable_frame).  */
   select_frame (get_current_frame ());
 
      ada_find_printable_frame).  */
   select_frame (get_current_frame ());
 

-  struct ada_catchpoint *c = (struct ada_catchpoint *) b;
-  switch (c->m_kind)
+  switch (m_kind)

     {
       case ada_catch_exception:
       case ada_catch_exception_unhandled:
       case ada_catch_handlers:
        {
     {
       case ada_catch_exception:
       case ada_catch_exception_unhandled:
       case ada_catch_handlers:
        {

-         const CORE_ADDR addr = ada_exception_name_addr (c->m_kind, b);
+         const CORE_ADDR addr = ada_exception_name_addr (m_kind);

          char exception_name[256];
 
          if (addr != 0)
          char exception_name[256];
 
          if (addr != 0)


@@ -12255,7 +12396,7 @@ print_it_exception (bpstat *bs)
             it clearer to the user which kind of catchpoint just got
             hit.  We used ui_out_text to make sure that this extra
             info does not pollute the exception name in the MI case.  */
             it clearer to the user which kind of catchpoint just got
             hit.  We used ui_out_text to make sure that this extra
             info does not pollute the exception name in the MI case.  */

-         if (c->m_kind == ada_catch_exception_unhandled)
+         if (m_kind == ada_catch_exception_unhandled)

            uiout->text ("unhandled ");
          uiout->field_string ("exception-name", exception_name);
        }
            uiout->text ("unhandled ");
          uiout->field_string ("exception-name", exception_name);
        }


@@ -12284,14 +12425,13 @@ print_it_exception (bpstat *bs)
   return PRINT_SRC_AND_LOC;
 }
 
   return PRINT_SRC_AND_LOC;
 }
 

-/* Implement the PRINT_ONE method in the breakpoint_ops structure
-   for all exception catchpoint kinds.  */
+/* Implement the PRINT_ONE method in the structure for all exception
+   catchpoint kinds.  */

 
 

-static void
-print_one_exception (struct breakpoint *b, struct bp_location **last_loc)
+bool
+ada_catchpoint::print_one (bp_location **last_loc) const

 { 
   struct ui_out *uiout = current_uiout;
 { 
   struct ui_out *uiout = current_uiout;

-  struct ada_catchpoint *c = (struct ada_catchpoint *) b;

   struct value_print_options opts;
 
   get_user_print_options (&opts);
   struct value_print_options opts;
 
   get_user_print_options (&opts);


@@ -12300,13 +12440,13 @@ print_one_exception (struct breakpoint *b, struct bp_location **last_loc)
     uiout->field_skip ("addr");
 
   annotate_field (5);
     uiout->field_skip ("addr");
 
   annotate_field (5);

-  switch (c->m_kind)
+  switch (m_kind)

     {
       case ada_catch_exception:
     {
       case ada_catch_exception:

-       if (!c->excep_string.empty ())
+       if (!excep_string.empty ())

          {
            std::string msg = string_printf (_("`%s' Ada exception"),
          {
            std::string msg = string_printf (_("`%s' Ada exception"),

-                                            c->excep_string.c_str ());
+                                            excep_string.c_str ());

 
            uiout->field_string ("what", msg);
          }
 
            uiout->field_string ("what", msg);
          }


@@ -12320,11 +12460,11 @@ print_one_exception (struct breakpoint *b, struct bp_location **last_loc)
        break;
       
       case ada_catch_handlers:
        break;
       
       case ada_catch_handlers:

-       if (!c->excep_string.empty ())
+       if (!excep_string.empty ())

          {
            uiout->field_fmt ("what",
                              _("`%s' Ada exception handlers"),
          {
            uiout->field_fmt ("what",
                              _("`%s' Ada exception handlers"),

-                             c->excep_string.c_str ());
+                             excep_string.c_str ());

          }
        else
          uiout->field_string ("what", "all Ada exceptions handlers");
          }
        else
          uiout->field_string ("what", "all Ada exceptions handlers");


@@ -12335,32 +12475,33 @@ print_one_exception (struct breakpoint *b, struct bp_location **last_loc)
        break;
 
       default:
        break;
 
       default:

-       internal_error (__FILE__, __LINE__, _("unexpected catchpoint type"));
+       internal_error (_("unexpected catchpoint type"));

        break;
     }
        break;
     }

+
+  return true;

 }
 
 /* Implement the PRINT_MENTION method in the breakpoint_ops structure
    for all exception catchpoint kinds.  */
 
 }
 
 /* Implement the PRINT_MENTION method in the breakpoint_ops structure
    for all exception catchpoint kinds.  */
 

-static void
-print_mention_exception (struct breakpoint *b)
+void
+ada_catchpoint::print_mention () const

 {
 {

-  struct ada_catchpoint *c = (struct ada_catchpoint *) b;

   struct ui_out *uiout = current_uiout;
 
   struct ui_out *uiout = current_uiout;
 

-  uiout->text (b->disposition == disp_del ? _("Temporary catchpoint ")
+  uiout->text (disposition == disp_del ? _("Temporary catchpoint ")

                                                 : _("Catchpoint "));
                                                 : _("Catchpoint "));

-  uiout->field_signed ("bkptno", b->number);
+  uiout->field_signed ("bkptno", number);

   uiout->text (": ");
 
   uiout->text (": ");
 

-  switch (c->m_kind)
+  switch (m_kind)

     {
       case ada_catch_exception:
     {
       case ada_catch_exception:

-       if (!c->excep_string.empty ())
+       if (!excep_string.empty ())

          {
            std::string info = string_printf (_("`%s' Ada exception"),
          {
            std::string info = string_printf (_("`%s' Ada exception"),

-                                             c->excep_string.c_str ());
+                                             excep_string.c_str ());

            uiout->text (info);
          }
        else
            uiout->text (info);
          }
        else


@@ -12372,11 +12513,11 @@ print_mention_exception (struct breakpoint *b)
        break;
 
       case ada_catch_handlers:
        break;
 
       case ada_catch_handlers:

-       if (!c->excep_string.empty ())
+       if (!excep_string.empty ())

          {
            std::string info
              = string_printf (_("`%s' Ada exception handlers"),
          {
            std::string info
              = string_printf (_("`%s' Ada exception handlers"),

-                              c->excep_string.c_str ());
+                              excep_string.c_str ());

            uiout->text (info);
          }
        else
            uiout->text (info);
          }
        else


@@ -12388,54 +12529,49 @@ print_mention_exception (struct breakpoint *b)
        break;
 
       default:
        break;
 
       default:

-       internal_error (__FILE__, __LINE__, _("unexpected catchpoint type"));
+       internal_error (_("unexpected catchpoint type"));

        break;
     }
 }
 
        break;
     }
 }
 

-/* Implement the PRINT_RECREATE method in the breakpoint_ops structure
-   for all exception catchpoint kinds.  */
+/* Implement the PRINT_RECREATE method in the structure for all
+   exception catchpoint kinds.  */

 
 

-static void
-print_recreate_exception (struct breakpoint *b, struct ui_file *fp)
+void
+ada_catchpoint::print_recreate (struct ui_file *fp) const

 {
 {

-  struct ada_catchpoint *c = (struct ada_catchpoint *) b;
-
-  switch (c->m_kind)
+  switch (m_kind)

     {
       case ada_catch_exception:
     {
       case ada_catch_exception:

-       fprintf_filtered (fp, "catch exception");
-       if (!c->excep_string.empty ())
-         fprintf_filtered (fp, " %s", c->excep_string.c_str ());
+       gdb_printf (fp, "catch exception");
+       if (!excep_string.empty ())
+         gdb_printf (fp, " %s", excep_string.c_str ());

        break;
 
       case ada_catch_exception_unhandled:
        break;
 
       case ada_catch_exception_unhandled:

-       fprintf_filtered (fp, "catch exception unhandled");
+       gdb_printf (fp, "catch exception unhandled");

        break;
 
       case ada_catch_handlers:
        break;
 
       case ada_catch_handlers:

-       fprintf_filtered (fp, "catch handlers");
+       gdb_printf (fp, "catch handlers");

        break;
 
       case ada_catch_assert:
        break;
 
       case ada_catch_assert:

-       fprintf_filtered (fp, "catch assert");
+       gdb_printf (fp, "catch assert");

        break;
 
       default:
        break;
 
       default:

-       internal_error (__FILE__, __LINE__, _("unexpected catchpoint type"));
+       internal_error (_("unexpected catchpoint type"));

     }
     }

-  print_recreate_thread (b, fp);
+  print_recreate_thread (fp);

 }
 
 }
 

-/* Virtual table for breakpoint type.  */
-static struct breakpoint_ops catch_exception_breakpoint_ops;
-

 /* See ada-lang.h.  */
 
 bool
 is_ada_exception_catchpoint (breakpoint *bp)
 {
 /* See ada-lang.h.  */
 
 bool
 is_ada_exception_catchpoint (breakpoint *bp)
 {

-  return bp->ops == &catch_exception_breakpoint_ops;
+  return dynamic_cast<ada_catchpoint *> (bp) != nullptr;

 }
 
 /* Split the arguments specified in a "catch exception" command.  
 }
 
 /* Split the arguments specified in a "catch exception" command.  


@@ -12540,8 +12676,7 @@ ada_exception_sym_name (enum ada_exception_catchpoint_kind ex)
        return (data->exception_info->catch_handlers_sym);
        break;
       default:
        return (data->exception_info->catch_handlers_sym);
        break;
       default:

-       internal_error (__FILE__, __LINE__,
-                       _("unexpected catchpoint kind (%d)"), ex);
+       internal_error (_("unexpected catchpoint kind (%d)"), ex);

     }
 }
 
     }
 }
 


@@ -12615,7 +12750,7 @@ ada_exception_catchpoint_cond_string (const char *excep_string,
 
 static struct symtab_and_line
 ada_exception_sal (enum ada_exception_catchpoint_kind ex,
 
 static struct symtab_and_line
 ada_exception_sal (enum ada_exception_catchpoint_kind ex,

-                  std::string *addr_string, const struct breakpoint_ops **ops)
+                  std::string *addr_string)

 {
   const char *sym_name;
   struct symbol *sym;
 {
   const char *sym_name;
   struct symbol *sym;


@@ -12637,9 +12772,6 @@ ada_exception_sal (enum ada_exception_catchpoint_kind ex,
   /* Set ADDR_STRING.  */
   *addr_string = sym_name;
 
   /* Set ADDR_STRING.  */
   *addr_string = sym_name;
 

-  /* Set OPS.  */
-  *ops = &catch_exception_breakpoint_ops;
-

   return find_function_start_sal (sym, 1);
 }
 
   return find_function_start_sal (sym, 1);
 }
 


@@ -12668,12 +12800,11 @@ create_ada_exception_catchpoint (struct gdbarch *gdbarch,
                                 int from_tty)
 {
   std::string addr_string;
                                 int from_tty)
 {
   std::string addr_string;

-  const struct breakpoint_ops *ops = NULL;
-  struct symtab_and_line sal = ada_exception_sal (ex_kind, &addr_string, &ops);
+  struct symtab_and_line sal = ada_exception_sal (ex_kind, &addr_string);

 
 

-  std::unique_ptr<ada_catchpoint> c (new ada_catchpoint (ex_kind));
-  init_ada_exception_breakpoint (c.get (), gdbarch, sal, addr_string.c_str (),
-                                ops, tempflag, disabled, from_tty);
+  std::unique_ptr<ada_catchpoint> c
+    (new ada_catchpoint (gdbarch, ex_kind, sal, addr_string.c_str (),
+                        tempflag, disabled, from_tty));

   c->excep_string = excep_string;
   create_excep_cond_exprs (c.get (), ex_kind);
   if (!cond_string.empty ())
   c->excep_string = excep_string;
   create_excep_cond_exprs (c.get (), ex_kind);
   if (!cond_string.empty ())


@@ -12892,15 +13023,29 @@ ada_add_standard_exceptions (compiled_regex *preg,
     {
       if (preg == NULL || preg->exec (name, 0, NULL, 0) == 0)
        {
     {
       if (preg == NULL || preg->exec (name, 0, NULL, 0) == 0)
        {

-         struct bound_minimal_symbol msymbol
-           = ada_lookup_simple_minsym (name);
+         symbol_name_match_type match_type = name_match_type_from_name (name);
+         lookup_name_info lookup_name (name, match_type);

 
 

-         if (msymbol.minsym != NULL)
-           {
-             struct ada_exc_info info
-               = {name, BMSYMBOL_VALUE_ADDRESS (msymbol)};
+         symbol_name_matcher_ftype *match_name
+           = ada_get_symbol_name_matcher (lookup_name);

 
 

-             exceptions->push_back (info);
+         /* Iterate over all objfiles irrespective of scope or linker
+            namespaces so we get all exceptions anywhere in the
+            progspace.  */
+         for (objfile *objfile : current_program_space->objfiles ())
+           {
+             for (minimal_symbol *msymbol : objfile->msymbols ())
+               {
+                 if (match_name (msymbol->linkage_name (), lookup_name,
+                                 nullptr)
+                     && msymbol->type () != mst_solib_trampoline)
+                   {
+                     ada_exc_info info
+                       = {name, msymbol->value_address (objfile)};
+
+                     exceptions->push_back (info);
+                   }
+               }

            }
        }
     }
            }
        }
     }


@@ -12918,7 +13063,7 @@ ada_add_standard_exceptions (compiled_regex *preg,
 
 static void
 ada_add_exceptions_from_frame (compiled_regex *preg,
 
 static void
 ada_add_exceptions_from_frame (compiled_regex *preg,

-                              struct frame_info *frame,
+                              frame_info_ptr frame,

                               std::vector<ada_exc_info> *exceptions)
 {
   const struct block *block = get_frame_block (frame, 0);
                               std::vector<ada_exc_info> *exceptions)
 {
   const struct block *block = get_frame_block (frame, 0);


@@ -12940,15 +13085,15 @@ ada_add_exceptions_from_frame (compiled_regex *preg,
              if (ada_is_exception_sym (sym))
                {
                  struct ada_exc_info info = {sym->print_name (),
              if (ada_is_exception_sym (sym))
                {
                  struct ada_exc_info info = {sym->print_name (),

-                                             SYMBOL_VALUE_ADDRESS (sym)};
+                                             sym->value_address ()};

 
                  exceptions->push_back (info);
                }
            }
        }
 
                  exceptions->push_back (info);
                }
            }
        }

-      if (BLOCK_FUNCTION (block) != NULL)
+      if (block->function () != NULL)

        break;
        break;

-      block = BLOCK_SUPERBLOCK (block);
+      block = block->superblock ();

     }
 }
 
     }
 }
 


@@ -12998,6 +13143,8 @@ ada_add_global_exceptions (compiled_regex *preg,
                           SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
                           VARIABLES_DOMAIN);
 
                           SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
                           VARIABLES_DOMAIN);
 

+  /* Iterate over all objfiles irrespective of scope or linker namespaces
+     so we get all exceptions anywhere in the progspace.  */

   for (objfile *objfile : current_program_space->objfiles ())
     {
       for (compunit_symtab *s : objfile->compunits ())
   for (objfile *objfile : current_program_space->objfiles ())
     {
       for (compunit_symtab *s : objfile->compunits ())


@@ -13007,7 +13154,7 @@ ada_add_global_exceptions (compiled_regex *preg,
 
          for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
            {
 
          for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
            {

-             const struct block *b = BLOCKVECTOR_BLOCK (bv, i);
+             const struct block *b = bv->block (i);

              struct block_iterator iter;
              struct symbol *sym;
 
              struct block_iterator iter;
              struct symbol *sym;
 


@@ -13016,7 +13163,7 @@ ada_add_global_exceptions (compiled_regex *preg,
                    && name_matches_regex (sym->natural_name (), preg))
                  {
                    struct ada_exc_info info
                    && name_matches_regex (sym->natural_name (), preg))
                  {
                    struct ada_exc_info info

-                     = {sym->print_name (), SYMBOL_VALUE_ADDRESS (sym)};
+                     = {sym->print_name (), sym->value_address ()};

 
                    exceptions->push_back (info);
                  }
 
                    exceptions->push_back (info);
                  }


@@ -13099,13 +13246,13 @@ info_exceptions_command (const char *regexp, int from_tty)
   std::vector<ada_exc_info> exceptions = ada_exceptions_list (regexp);
 
   if (regexp != NULL)
   std::vector<ada_exc_info> exceptions = ada_exceptions_list (regexp);
 
   if (regexp != NULL)

-    printf_filtered
+    gdb_printf

       (_("All Ada exceptions matching regular expression \"%s\":\n"), regexp);
   else
       (_("All Ada exceptions matching regular expression \"%s\":\n"), regexp);
   else

-    printf_filtered (_("All defined Ada exceptions:\n"));
+    gdb_printf (_("All defined Ada exceptions:\n"));

 
   for (const ada_exc_info &info : exceptions)
 
   for (const ada_exc_info &info : exceptions)

-    printf_filtered ("%s: %s\n", info.name, paddress (gdbarch, info.addr));
+    gdb_printf ("%s: %s\n", info.name, paddress (gdbarch, info.addr));

 }
 
 \f
 }
 
 \f


@@ -13137,6 +13284,10 @@ do_full_match (const char *symbol_search_name,
   if (startswith (symbol_search_name, "_ada_")
       && !startswith (lname, "_ada"))
     symbol_search_name += 5;
   if (startswith (symbol_search_name, "_ada_")
       && !startswith (lname, "_ada"))
     symbol_search_name += 5;

+  /* Likewise for ghost entities.  */
+  if (startswith (symbol_search_name, "___ghost_")
+      && !startswith (lname, "___ghost_"))
+    symbol_search_name += 9;

 
   int uscore_count = 0;
   while (*lname != '\0')
 
   int uscore_count = 0;
   while (*lname != '\0')


@@ -13336,14 +13487,14 @@ public:
     struct value *index_value = val_atr (index_type, index);
 
     value_print (index_value, stream, options);
     struct value *index_value = val_atr (index_type, index);
 
     value_print (index_value, stream, options);

-    fprintf_filtered (stream, " => ");
+    gdb_printf (stream, " => ");

   }
 
   /* Implement the "read_var_value" language_defn method for Ada.  */
 
   struct value *read_var_value (struct symbol *var,
                                const struct block *var_block,
   }
 
   /* Implement the "read_var_value" language_defn method for Ada.  */
 
   struct value *read_var_value (struct symbol *var,
                                const struct block *var_block,

-                               struct frame_info *frame) const override
+                               frame_info_ptr frame) const override

   {
     /* The only case where default_read_var_value is not sufficient
        is when VAR is a renaming...  */
   {
     /* The only case where default_read_var_value is not sufficient
        is when VAR is a renaming...  */


@@ -13360,9 +13511,9 @@ public:
   }
 
   /* See language.h.  */
   }
 
   /* See language.h.  */

-  virtual bool symbol_printing_suppressed (struct symbol *symbol) const override
+  bool symbol_printing_suppressed (struct symbol *symbol) const override

   {
   {

-    return symbol->artificial;
+    return symbol->is_artificial ();

   }
 
   /* See language.h.  */
   }
 
   /* See language.h.  */


@@ -13413,7 +13564,7 @@ public:
     /* Create the equivalent of the System.Storage_Elements.Storage_Offset
        type.  This is a signed integral type whose size is the same as
        the size of addresses.  */
     /* Create the equivalent of the System.Storage_Elements.Storage_Offset
        type.  This is a signed integral type whose size is the same as
        the size of addresses.  */

-    unsigned int addr_length = TYPE_LENGTH (system_addr_ptr);
+    unsigned int addr_length = system_addr_ptr->length ();

     add (arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0,
                            "storage_offset"));
 
     add (arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0,
                            "storage_offset"));
 


@@ -13566,9 +13717,9 @@ public:
     /* Search upwards from currently selected frame (so that we can
        complete on local vars.  */
 
     /* Search upwards from currently selected frame (so that we can
        complete on local vars.  */
 

-    for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
+    for (b = get_selected_block (0); b != NULL; b = b->superblock ())

       {
       {

-       if (!BLOCK_SUPERBLOCK (b))
+       if (!b->superblock ())

          surrounding_static_block = b;   /* For elmin of dups */
 
        ALL_BLOCK_SYMBOLS (b, iter, sym)
          surrounding_static_block = b;   /* For elmin of dups */
 
        ALL_BLOCK_SYMBOLS (b, iter, sym)


@@ -13591,7 +13742,7 @@ public:
        for (compunit_symtab *s : objfile->compunits ())
          {
            QUIT;
        for (compunit_symtab *s : objfile->compunits ())
          {
            QUIT;

-           b = BLOCKVECTOR_BLOCK (s->blockvector (), GLOBAL_BLOCK);
+           b = s->blockvector ()->global_block ();

            ALL_BLOCK_SYMBOLS (b, iter, sym)
              {
                if (completion_skip_symbol (mode, sym))
            ALL_BLOCK_SYMBOLS (b, iter, sym)
              {
                if (completion_skip_symbol (mode, sym))


@@ -13610,7 +13761,7 @@ public:
        for (compunit_symtab *s : objfile->compunits ())
          {
            QUIT;
        for (compunit_symtab *s : objfile->compunits ())
          {
            QUIT;

-           b = BLOCKVECTOR_BLOCK (s->blockvector (), STATIC_BLOCK);
+           b = s->blockvector ()->static_block ();

            /* Don't do this block twice.  */
            if (b == surrounding_static_block)
              continue;
            /* Don't do this block twice.  */
            if (b == surrounding_static_block)
              continue;


@@ -13633,7 +13784,7 @@ public:
   gdb::unique_xmalloc_ptr<char> watch_location_expression
        (struct type *type, CORE_ADDR addr) const override
   {
   gdb::unique_xmalloc_ptr<char> watch_location_expression
        (struct type *type, CORE_ADDR addr) const override
   {

-    type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
+    type = check_typedef (check_typedef (type)->target_type ());

     std::string name = type_to_string (type);
     return xstrprintf ("{%s} %s", name.c_str (), core_addr_to_string (addr));
   }
     std::string name = type_to_string (type);
     return xstrprintf ("{%s} %s", name.c_str (), core_addr_to_string (addr));
   }


@@ -13784,24 +13935,6 @@ static ada_language ada_language_defn;
 static struct cmd_list_element *set_ada_list;
 static struct cmd_list_element *show_ada_list;
 
 static struct cmd_list_element *set_ada_list;
 static struct cmd_list_element *show_ada_list;
 

-static void
-initialize_ada_catchpoint_ops (void)
-{
-  struct breakpoint_ops *ops;
-
-  initialize_breakpoint_ops ();
-
-  ops = &catch_exception_breakpoint_ops;
-  *ops = bkpt_breakpoint_ops;
-  ops->allocate_location = allocate_location_exception;
-  ops->re_set = re_set_exception;
-  ops->check_status = check_status_exception;
-  ops->print_it = print_it_exception;
-  ops->print_one = print_one_exception;
-  ops->print_mention = print_mention_exception;
-  ops->print_recreate = print_recreate_exception;
-}
-

 /* This module's 'new_objfile' observer.  */
 
 static void
 /* This module's 'new_objfile' observer.  */
 
 static void


@@ -13842,8 +13975,6 @@ void _initialize_ada_language ();
 void
 _initialize_ada_language ()
 {
 void
 _initialize_ada_language ()
 {

-  initialize_ada_catchpoint_ops ();
-

   add_setshow_prefix_cmd
     ("ada", no_class,
      _("Prefix command for changing Ada-specific settings."),
   add_setshow_prefix_cmd
     ("ada", no_class,
      _("Prefix command for changing Ada-specific settings."),