Change regcache list to be an hash map

[deliverable/binutils-gdb.git] / gdb / ada-valprint.c

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index e11e47ee59eae35626d4fa8a99a1139bbbce2d3d..61893d5cad3fe2dbfcef0582101e51a03de8b911 100644 (file)
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -71,7 +71,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type,
   if (low_bound > high_bound)
     return 0;
 
-  index_type = TYPE_INDEX_TYPE (type);
+  index_type = type->index_type ();
 
   while (index_type->code () == TYPE_CODE_RANGE)
     {
@@ -92,8 +92,9 @@ print_optional_low_bound (struct ui_file *stream, struct type *type,
        return 0;
       break;
     case TYPE_CODE_ENUM:
-      if (low_bound == TYPE_FIELD_ENUMVAL (index_type, 0))
+      if (low_bound == 0)
        return 0;
+      low_bound = TYPE_FIELD_ENUMVAL (index_type, low_bound);
       break;
     case TYPE_CODE_UNDEF:
       index_type = NULL;
@@ -130,51 +131,28 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
   LONGEST low = 0;
 
   elttype = TYPE_TARGET_TYPE (type);
-  index_type = TYPE_INDEX_TYPE (type);
+  index_type = type->index_type ();
 
   {
     LONGEST high;
-    struct type *base_index_type;
 
     if (get_discrete_bounds (index_type, &low, &high) < 0)
       len = 1;
-    else
-      len = high - low + 1;
-
-    if (index_type->code () == TYPE_CODE_RANGE)
-        base_index_type = TYPE_TARGET_TYPE (index_type);
-      else
-        base_index_type = index_type;
-
-    if (base_index_type->code () == TYPE_CODE_ENUM)
+    else if (low > high)
       {
-        LONGEST low_pos, high_pos;
-
-        /* Non-contiguous enumerations types can by used as index types
-           so the array length is computed from the positions of the
-           first and last literal in the enumeration type, and not from
-           the values of these literals.  */
-
-        if (!discrete_position (base_index_type, low, &low_pos)
-          || !discrete_position (base_index_type, high, &high_pos))
-          {
-            warning (_("unable to get positions in array, use bounds instead"));
-            low_pos = low;
-            high_pos = high;
-          }
-
         /* The array length should normally be HIGH_POS - LOW_POS + 1.
            But in Ada we allow LOW_POS to be greater than HIGH_POS for
            empty arrays.  In that situation, the array length is just zero,
            not negative!  */
-
-        if (low_pos > high_pos)
-          len = 0;
-        else
-          len = high_pos - low_pos + 1;
+       len = 0;
       }
+    else
+      len = high - low + 1;
   }
 
+  if (index_type->code () == TYPE_CODE_RANGE)
+    index_type = TYPE_TARGET_TYPE (index_type);
+
   i = 0;
   annotate_array_section_begin (i, elttype);
 
@@ -400,7 +378,7 @@ ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
     {
 
     case TYPE_CODE_ENUM:
-      len = TYPE_NFIELDS (type);
+      len = type->num_fields ();
       for (i = 0; i < len; i++)
        {
          if (TYPE_FIELD_ENUMVAL (type, i) == val)
@@ -564,7 +542,7 @@ print_variant_part (struct value *value, int field_num,
                    const struct language_defn *language)
 {
   struct type *type = value_type (value);
-  struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
+  struct type *var_type = type->field (field_num).type ();
   int which = ada_which_variant_applies (var_type, outer_value);
 
   if (which < 0)
@@ -600,7 +578,7 @@ print_field_values (struct value *value, struct value *outer_value,
   int i, len;
 
   struct type *type = value_type (value);
-  len = TYPE_NFIELDS (type);
+  len = type->num_fields ();
 
   for (i = 0; i < len; i += 1)
     {
@@ -639,7 +617,7 @@ print_field_values (struct value *value, struct value *outer_value,
          wrap_here (n_spaces (2 + 2 * recurse));
        }
 
-      annotate_field_begin (TYPE_FIELD_TYPE (type, i));
+      annotate_field_begin (type->field (i).type ());
       fprintf_filtered (stream, "%.*s",
                        ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
                        TYPE_FIELD_NAME (type, i));
@@ -663,12 +641,12 @@ print_field_values (struct value *value, struct value *outer_value,
              int bit_size = TYPE_FIELD_BITSIZE (type, i);
              struct value_print_options opts;
 
-             adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
+             adjust_type_signedness (type->field (i).type ());
              v = ada_value_primitive_packed_val
                    (value, nullptr,
                     bit_pos / HOST_CHAR_BIT,
                     bit_pos % HOST_CHAR_BIT,
-                    bit_size, TYPE_FIELD_TYPE (type, i));
+                    bit_size, type->field (i).type ());
              opts = *options;
              opts.deref_ref = 0;
              common_val_print (v, stream, recurse + 1, &opts, language);
@@ -776,10 +754,10 @@ ada_value_print_ptr (struct value *val,
   struct type *type = ada_check_typedef (value_type (val));
   if (ada_is_tag_type (type))
     {
-      const char *name = ada_tag_name (val);
+      gdb::unique_xmalloc_ptr<char> name = ada_tag_name (val);
 
       if (name != NULL)
-       fprintf_filtered (stream, " (%s)", name);
+       fprintf_filtered (stream, " (%s)", name.get ());
     }
 }
 
@@ -886,7 +864,7 @@ ada_val_print_enum (struct value *value, struct ui_file *stream, int recurse,
   const gdb_byte *valaddr = value_contents_for_printing (value);
   int offset_aligned = ada_aligned_value_addr (type, valaddr) - valaddr;
 
-  len = TYPE_NFIELDS (type);
+  len = type->num_fields ();
   val = unpack_long (type, valaddr + offset_aligned);
   for (i = 0; i < len; i++)
     {