gdb: remove TYPE_FIELD_BITSIZE

Replace with type::field + field::bitsize.

Change-Id: I2a24755a33683e4a2775a6d2a7b7a9ae7362e43a
Approved-By: Tom Tromey <tom@tromey.com>

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index f995ddc83ccd97ca00b1e2abaf8ae3ed0bcdb206..77140333ea5a169b1f1fc3ee326c7c8a5124c786 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -1881,8 +1881,8 @@ fat_pntr_bounds_bitsize (struct type *type)
 {
   type = desc_base_type (type);
 
-  if (TYPE_FIELD_BITSIZE (type, 1) > 0)
-    return TYPE_FIELD_BITSIZE (type, 1);
+  if (type->field (1).bitsize () > 0)
+    return type->field (1).bitsize ();
   else
     return 8 * ada_check_typedef (type->field (1).type ())->length ();
 }
@@ -1947,8 +1947,8 @@ fat_pntr_data_bitsize (struct type *type)
 {
   type = desc_base_type (type);
 
-  if (TYPE_FIELD_BITSIZE (type, 0) > 0)
-    return TYPE_FIELD_BITSIZE (type, 0);
+  if (type->field (0).bitsize () > 0)
+    return type->field (0).bitsize ();
   else
     return TARGET_CHAR_BIT * type->field (0).type ()->length ();
 }
@@ -1986,8 +1986,8 @@ desc_bound_bitsize (struct type *type, int i, int which)
 {
   type = desc_base_type (type);
 
-  if (TYPE_FIELD_BITSIZE (type, 2 * i + which - 2) > 0)
-    return TYPE_FIELD_BITSIZE (type, 2 * i + which - 2);
+  if (type->field (2 * i + which - 2).bitsize () > 0)
+    return type->field (2 * i + which - 2).bitsize ();
   else
     return 8 * type->field (2 * i + which - 2).type ()->length ();
 }
@@ -2151,7 +2151,7 @@ ada_type_of_array (struct value *arr, int bounds)
              if (lo < hi)
                {
                  int array_bitsize =
-                       (hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
+                       (hi - lo + 1) * elt_type->field (0).bitsize ();
 
                  elt_type->set_length ((array_bitsize + 7) / 8);
                }
@@ -2269,7 +2269,7 @@ ada_is_unconstrained_packed_array_type (struct type *type)
       if (type->code () == TYPE_CODE_TYPEDEF)
        type = ada_typedef_target_type (type);
       /* Now we can see if the array elements are packed.  */
-      return TYPE_FIELD_BITSIZE (type, 0) > 0;
+      return type->field (0).bitsize () > 0;
     }
 
   return 0;
@@ -2283,7 +2283,7 @@ ada_is_any_packed_array_type (struct type *type)
 {
   return (ada_is_constrained_packed_array_type (type)
          || (type->code () == TYPE_CODE_ARRAY
-             && TYPE_FIELD_BITSIZE (type, 0) % 8 != 0));
+             && type->field (0).bitsize () % 8 != 0));
 }
 
 /* Given that TYPE encodes a packed array type (constrained or unconstrained),
@@ -2317,7 +2317,7 @@ decode_packed_array_bitsize (struct type *type)
         fetches the array type.  */
       type = type->field (0).type ()->target_type ();
       /* Now we can see if the array elements are packed.  */
-      return TYPE_FIELD_BITSIZE (type, 0);
+      return type->field (0).bitsize ();
     }
 
   if (sscanf (tail + sizeof ("___XP") - 1, "%ld", &bits) != 1)
@@ -2458,7 +2458,7 @@ recursively_update_array_bitsize (struct type *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);
+      LONGEST elt_bitsize = elt_len * elt_type->field (0).bitsize ();
       type->field (0).set_bitsize (elt_bitsize);
 
       type->set_length (((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
@@ -2556,7 +2556,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind)
   for (i = 0; i < arity; i += 1)
     {
       if (elt_type->code () != TYPE_CODE_ARRAY
-         || TYPE_FIELD_BITSIZE (elt_type, 0) == 0)
+         || elt_type->field (0).bitsize () == 0)
        error
          (_("attempt to do packed indexing of "
             "something other than a packed array"));
@@ -2576,7 +2576,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind)
          if (idx < lowerbound || idx > upperbound)
            lim_warning (_("packed array index %ld out of bounds"),
                         (long) idx);
-         bits = TYPE_FIELD_BITSIZE (elt_type, 0);
+         bits = elt_type->field (0).bitsize ();
          elt_total_bit_offset += (idx - lowerbound) * bits;
          elt_type = ada_check_typedef (elt_type->target_type ());
        }
@@ -2992,7 +2992,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind)
 
   elt_type = ada_check_typedef (elt->type ());
   if (elt_type->code () == TYPE_CODE_ARRAY
-      && TYPE_FIELD_BITSIZE (elt_type, 0) > 0)
+      && elt_type->field (0).bitsize () > 0)
     return value_subscript_packed (elt, arity, ind);
 
   for (k = 0; k < arity; k += 1)
@@ -3049,7 +3049,7 @@ ada_value_ptr_subscript (struct value *arr, int arity, struct value **ind)
     = check_typedef (array_ind->enclosing_type ());
 
   if (type->code () == TYPE_CODE_ARRAY
-      && TYPE_FIELD_BITSIZE (type, 0) > 0)
+      && type->field (0).bitsize () > 0)
     return value_subscript_packed (array_ind, arity, ind);
 
   for (k = 0; k < arity; k += 1)
@@ -3084,7 +3084,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
   struct type *slice_type = create_array_type_with_stride
                              (alloc, type0->target_type (), index_type,
                               type0->dyn_prop (DYN_PROP_BYTE_STRIDE),
-                              TYPE_FIELD_BITSIZE (type0, 0));
+                              type0->field (0).bitsize ());
   int base_low =  ada_discrete_type_low_bound (type0->index_type ());
   gdb::optional<LONGEST> base_low_pos, low_pos;
   CORE_ADDR base;
@@ -3099,7 +3099,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
       base_low_pos = base_low;
     }
 
-  ULONGEST stride = TYPE_FIELD_BITSIZE (slice_type, 0) / 8;
+  ULONGEST stride = slice_type->field (0).bitsize () / 8;
   if (stride == 0)
     stride = type0->target_type ()->length ();
 
@@ -3119,7 +3119,7 @@ ada_value_slice (struct value *array, int low, int high)
   struct type *slice_type = create_array_type_with_stride
                              (alloc, type->target_type (), index_type,
                               type->dyn_prop (DYN_PROP_BYTE_STRIDE),
-                              TYPE_FIELD_BITSIZE (type, 0));
+                              type->field (0).bitsize ());
   gdb::optional<LONGEST> low_pos, high_pos;
 
 
@@ -6886,10 +6886,10 @@ ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
   /* Handle packed fields.  It might be that the field is not packed
      relative to its containing structure, but the structure itself is
      packed; in this case we must take the bit-field path.  */
-  if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0 || arg1->bitpos () != 0)
+  if (arg_type->field (fieldno).bitsize () != 0 || arg1->bitpos () != 0)
     {
       int bit_pos = arg_type->field (fieldno).loc_bitpos ();
-      int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
+      int bit_size = arg_type->field (fieldno).bitsize ();
 
       return ada_value_primitive_packed_val (arg1,
                                             arg1->contents ().data (),
@@ -7018,7 +7018,7 @@ find_struct_field (const char *name, struct type *type, int offset,
 
       else if (name != NULL && field_name_match (t_field_name, name))
        {
-         int bit_size = TYPE_FIELD_BITSIZE (type, i);
+         int bit_size = type->field (i).bitsize ();
 
          if (field_type_p != NULL)
            *field_type_p = type->field (i).type ();
@@ -7866,9 +7866,9 @@ ada_template_to_fixed_record_type_1 (struct type *type,
             would prevent us from printing this field appropriately.  */
          rtype->field (f).set_type (type->field (f).type ());
          rtype->field (f).set_name (type->field (f).name ());
-         if (TYPE_FIELD_BITSIZE (type, f) > 0)
+         if (type->field (f).bitsize () > 0)
            {
-             fld_bit_len = TYPE_FIELD_BITSIZE (type, f);
+             fld_bit_len = type->field (f).bitsize ();
              rtype->field (f).set_bitsize (fld_bit_len);
            }
          else
@@ -8409,9 +8409,9 @@ to_fixed_array_type (struct type *type0, struct value *dval,
         bitsize of the array elements needs to be set again, and the array
         length needs to be recomputed based on that bitsize.  */
       int len = result->length () / result->target_type ()->length ();
-      int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
+      int elt_bitsize = type0->field (0).bitsize ();
 
-      result->field (0).set_bitsize (TYPE_FIELD_BITSIZE (type0, 0));
+      result->field (0).set_bitsize (elt_bitsize);
       result->set_length (len * elt_bitsize / HOST_CHAR_BIT);
       if (result->length () * HOST_CHAR_BIT < len * elt_bitsize)
        result->set_length (result->length () + 1);
@@ -11111,7 +11111,7 @@ ada_funcall_operation::evaluate (struct type *expect_type,
       (desc_base_type (callee->type ())))
     callee = ada_coerce_to_simple_array (callee);
   else if (callee->type ()->code () == TYPE_CODE_ARRAY
-          && TYPE_FIELD_BITSIZE (callee->type (), 0) != 0)
+          && callee->type ()->field (0).bitsize () != 0)
     /* This is a packed array that has already been fixed, and
        therefore already coerced to a simple array.  Nothing further
        to do.  */

diff --git a/gdb/ada-typeprint.c b/gdb/ada-typeprint.c
index 3d7f61ff25a20e34e2770cb27710ae09e89ea085..3b7faee8a613f35bb4e333b0fa7891824cf556c5 100644 (file)
--- a/gdb/ada-typeprint.c
+++ b/gdb/ada-typeprint.c
@@ -383,8 +383,8 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
                gdb_printf (stream, ", ");
              print_range (arr_type->index_type (), stream,
                           0 /* bounds_preferred_p */);
-             if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
-               bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
+             if (arr_type->field (0).bitsize () > 0)
+               bitsize = arr_type->field (0).bitsize ();
              /* 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
@@ -408,8 +408,8 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
                gdb_printf (stream, ", ");
              print_range_type (range_desc_type->field (k).type (),
                                stream, 0 /* bounds_preferred_p */);
-             if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
-               bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
+             if (arr_type->field (0).bitsize () > 0)
+               bitsize = arr_type->field (0).bitsize ();
            }
        }
     }

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index dacc72d9f1bfda04fa05d279d86ee3d0e8ae0d54..9a1f3d6c9ffe13bde3ae792885e8bd219c331932 100644 (file)
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -117,7 +117,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
   unsigned int things_printed = 0;
   unsigned len;
   struct type *elttype, *index_type;
-  unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
+  unsigned long bitsize = type->field (0).bitsize ();
   LONGEST low = 0;
 
   scoped_value_mark mark;
@@ -628,7 +628,7 @@ print_field_values (struct value *value, struct value *outer_value,
            {
              struct value *v;
              int bit_pos = type->field (i).loc_bitpos ();
-             int bit_size = TYPE_FIELD_BITSIZE (type, i);
+             int bit_size = type->field (i).bitsize ();
              struct value_print_options opts;
 
              v = ada_value_primitive_packed_val
@@ -883,7 +883,7 @@ ada_value_print_array (struct value *val, struct ui_file *stream, int recurse,
 
   if (val->entirely_optimized_out ())
     val_print_optimized_out (val, stream);
-  else if (TYPE_FIELD_BITSIZE (type, 0) > 0)
+  else if (type->field (0).bitsize () > 0)
     {
       const gdb_byte *valaddr = val->contents_for_printing ().data ();
       int offset_aligned = ada_aligned_value_addr (type, valaddr) - valaddr;

diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 2c4189203cb07ef30f8e130dbec9d6696f2c87f8..affb775fb7e27a32f825b385d21ba73675f52867 100644 (file)
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -558,7 +558,7 @@ amd64_has_unaligned_fields (struct type *type)
             empty structures), and bitfields (these are handled by
             the caller).  */
          if (type->field (i).is_static ()
-             || (TYPE_FIELD_BITSIZE (type, i) == 0
+             || (type->field (i).bitsize () == 0
                  && subtype->length () == 0)
              || TYPE_FIELD_PACKED (type, i))
            continue;
@@ -594,7 +594,7 @@ amd64_classify_aggregate_field (struct type *type, int i,
 {
   struct type *subtype = check_typedef (type->field (i).type ());
   enum amd64_reg_class subclass[2];
-  int bitsize = TYPE_FIELD_BITSIZE (type, i);
+  int bitsize = type->field (i).bitsize ();
 
   if (bitsize == 0)
     bitsize = subtype->length () * 8;

diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 6d4c9d04cbc9606a99d1c0041bb82997376e2d05..fcdd304eef30ac64ee888ea8ccf424dbf5f5f79b 100644 (file)
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -9109,7 +9109,7 @@ arm_return_in_memory (struct gdbarch *gdbarch, struct type *type)
                  /* Bitfields are not addressable.  If the field bitsize is 
                     zero, then the field is not packed.  Hence it cannot be
                     a bitfield or any other packed type.  */
-                 if (TYPE_FIELD_BITSIZE (type, i) == 0)
+                 if (type->field (i).bitsize () == 0)
                    {
                      nRc = 1;
                      break;

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 55450bd29797fccddc6bf984a86e6c1fdea29620..068796aa9bcd14e9a4b97e5bdd05b70156c6e8e0 100644 (file)
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1323,7 +1323,7 @@ gen_primitive_field (struct agent_expr *ax, struct axs_value *value,
                       + type->field (fieldno).loc_bitpos ()),
                      (offset * TARGET_CHAR_BIT
                       + type->field (fieldno).loc_bitpos ()
-                      + TYPE_FIELD_BITSIZE (type, fieldno)));
+                      + type->field (fieldno).bitsize ()));
   else
     {
       gen_offset (ax, offset

diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index a23ceb0ddc4a2ddf1d95643cb38b010a7282f1ca..708250c4801dc1018dc208544a61e8a0d8fb0281 100644 (file)
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -1161,8 +1161,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream,
                 unnamed fields.  This would lead to misleading
                 results if the compiler does not put out fields
                 for such things (I don't know what it does).  */
-             gdb_printf (stream, " : %d",
-                         TYPE_FIELD_BITSIZE (type, i));
+             gdb_printf (stream, " : %d", type->field (i).bitsize ());
            }
          gdb_printf (stream, ";\n");
        }
@@ -1591,11 +1590,11 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream,
                                language, &local_flags, podata);
                gdb_printf (stream, " @%s",
                            plongest (type->field (i).loc_bitpos ()));
-               if (TYPE_FIELD_BITSIZE (type, i) > 1)
+               if (type->field (i).bitsize () > 1)
                  {
                    gdb_printf (stream, "-%s",
                                plongest (type->field (i).loc_bitpos ()
-                                         + TYPE_FIELD_BITSIZE (type, i)
+                                         + type->field (i).bitsize ()
                                          - 1));
                  }
                gdb_printf (stream, ";\n");

diff --git a/gdb/compile/compile-c-types.c b/gdb/compile/compile-c-types.c
index 4853c3f78b12f49d9e75838d6f9a3dbb83a9cfa2..274871655d058de77bd1598d4c10ca016a02e60c 100644 (file)
--- a/gdb/compile/compile-c-types.c
+++ b/gdb/compile/compile-c-types.c
@@ -106,7 +106,7 @@ convert_struct_or_union (compile_c_instance *context, struct type *type)
   for (i = 0; i < type->num_fields (); ++i)
     {
       gcc_type field_type;
-      unsigned long bitsize = TYPE_FIELD_BITSIZE (type, i);
+      unsigned long bitsize = type->field (i).bitsize ();
 
       field_type = context->convert_type (type->field (i).type ());
       if (bitsize == 0)

diff --git a/gdb/compile/compile-cplus-types.c b/gdb/compile/compile-cplus-types.c
index cea04b74d10aa96b7100f2f03f550ac6348b71da..ac27e83618b585b516275d42812fa99a0a6251f4 100644 (file)
--- a/gdb/compile/compile-cplus-types.c
+++ b/gdb/compile/compile-cplus-types.c
@@ -642,7 +642,7 @@ compile_cplus_convert_struct_or_union_members
        }
       else
        {
-         unsigned long bitsize = TYPE_FIELD_BITSIZE (type, i);
+         unsigned long bitsize = type->field (i).bitsize ();
          enum gcc_cp_symbol_kind field_flags = GCC_CP_SYMBOL_FIELD
            | get_field_access_flag (type, i);
 

diff --git a/gdb/compile/compile-object-load.c b/gdb/compile/compile-object-load.c
index 07cbbed4af913a393584ac7b70451f3b53145fe9..013b6a9a4275d4156e63b3e0b96202f716a48b0f 100644 (file)
--- a/gdb/compile/compile-object-load.c
+++ b/gdb/compile/compile-object-load.c
@@ -553,7 +553,7 @@ store_regs (struct type *regs_type, CORE_ADDR regs_base)
     {
       const char *reg_name = regs_type->field (fieldno).name ();
       ULONGEST reg_bitpos = regs_type->field (fieldno).loc_bitpos ();
-      ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
+      ULONGEST reg_bitsize = regs_type->field (fieldno).bitsize ();
       ULONGEST reg_offset;
       struct type *reg_type
        = check_typedef (regs_type->field (fieldno).type ());

diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index fd0ba5a349e96dbc364e47a26932ceded4bbbbc9..c73764eb5290c17c8f2ea4ac85069019bcb2eac3 100644 (file)
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -272,7 +272,7 @@ cp_print_value_fields (struct value *val, struct ui_file *stream,
                }
              else if (val->bits_synthetic_pointer
                       (type->field (i).loc_bitpos (),
-                       TYPE_FIELD_BITSIZE (type, i)))
+                       type->field (i).bitsize ()))
                {
                  fputs_styled (_("<synthetic pointer>"),
                                metadata_style.style (), stream);

diff --git a/gdb/eval.c b/gdb/eval.c
index 5a255ab66c9483f9dbfcb7210ab9e4b3dff3beb8..794698f85bd19ca581969634618816ccf4eaa848 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2383,7 +2383,7 @@ array_operation::evaluate_struct_tuple (struct value *struct_val,
       if (val->type () != field_type)
        val = value_cast (field_type, val);
 
-      bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
+      bitsize = struct_type->field (fieldno).bitsize ();
       bitpos = struct_type->field (fieldno).loc_bitpos ();
       addr = struct_val->contents_writeable ().data () + bitpos / 8;
       if (bitsize)

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index cd6b191ea6288c26836134694f280a933c3792a5..59ddd75ab798073ba6f845c4189ecc948f024723 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1317,12 +1317,12 @@ update_static_array_size (struct type *type)
       if (element_type->code () == TYPE_CODE_ARRAY
          && (stride != 0 || element_type->is_multi_dimensional ())
          && element_type->length () != 0
-         && TYPE_FIELD_BITSIZE (element_type, 0) != 0
+         && element_type->field (0).bitsize () != 0
          && get_array_bounds (element_type, &low_bound, &high_bound)
          && high_bound >= low_bound)
        type->field (0).set_bitsize
          ((high_bound - low_bound + 1)
-          * TYPE_FIELD_BITSIZE (element_type, 0));
+          * element_type->field (0).bitsize ());
 
       return true;
     }
@@ -2330,7 +2330,7 @@ resolve_dynamic_array_or_string_1 (struct type *type,
        }
     }
   else
-    bit_stride = TYPE_FIELD_BITSIZE (type, 0);
+    bit_stride = type->field (0).bitsize ();
 
   type_allocator alloc (type, type_allocator::SMASH);
   return create_array_type_with_stride (alloc, elt_type, range_type, NULL,
@@ -2550,7 +2550,7 @@ compute_variant_fields_inner (struct type *type,
                            + (type->field (idx).loc_bitpos ()
                               / TARGET_CHAR_BIT));
 
-         LONGEST bitsize = TYPE_FIELD_BITSIZE (type, idx);
+         LONGEST bitsize = type->field (idx).bitsize ();
          LONGEST size = bitsize / 8;
          if (size == 0)
            size = type->field (idx).type ()->length ();
@@ -2704,8 +2704,8 @@ resolve_dynamic_struct (struct type *type,
                  == FIELD_LOC_KIND_BITPOS);
 
       new_bit_length = resolved_type->field (i).loc_bitpos ();
-      if (TYPE_FIELD_BITSIZE (resolved_type, i) != 0)
-       new_bit_length += TYPE_FIELD_BITSIZE (resolved_type, i);
+      if (resolved_type->field (i).bitsize () != 0)
+       new_bit_length += resolved_type->field (i).bitsize ();
       else
        {
          struct type *real_type
@@ -5349,7 +5349,7 @@ recursive_dump_type (struct type *type, int spaces)
       else
        gdb_printf ("%*s[%d] bitpos %s bitsize %d type ", spaces + 2, "",
                    idx, plongest (type->field (idx).loc_bitpos ()),
-                   TYPE_FIELD_BITSIZE (type, idx));
+                   type->field (idx).bitsize ());
       gdb_printf ("%s name '%s' (%s)\n",
                  host_address_to_string (type->field (idx).type ()),
                  type->field (idx).name () != NULL
@@ -5543,7 +5543,7 @@ copy_type_recursive (struct type *type, htab_t copied_types)
        {
          new_type->field (i).set_is_artificial
            (type->field (i).is_artificial ());
-         new_type->field (i).set_bitsize (TYPE_FIELD_BITSIZE (type, i));
+         new_type->field (i).set_bitsize (type->field (i).bitsize ());
          if (type->field (i).type ())
            new_type->field (i).set_type
              (copy_type_recursive (type->field (i).type (), copied_types));

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 6c522a935c5bab600728f3ff61794aa5c6b95a09..d2edca51caffaac8a818ce18ba9c800dc586c9d4 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -1933,7 +1933,6 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
 
-#define TYPE_FIELD_BITSIZE(thistype, n) ((thistype)->field (n).bitsize ())
 #define TYPE_FIELD_PACKED(thistype, n) (((thistype)->field (n).bitsize ())!=0)
 
 #define TYPE_FIELD_PRIVATE_BITS(thistype) \

diff --git a/gdb/m2-typeprint.c b/gdb/m2-typeprint.c
index 2eea410bcd3c12ee6cc4da62e414e6c7d7072c56..552c1219dbfc8dac4dd03b1ef8828f66b5e4e049 100644 (file)
--- a/gdb/m2-typeprint.c
+++ b/gdb/m2-typeprint.c
@@ -577,8 +577,7 @@ m2_record_fields (struct type *type, struct ui_file *stream, int show,
                 unnamed fields.  This would lead to misleading
                 results if the compiler does not put out fields
                 for such things (I don't know what it does).  */
-             gdb_printf (stream, " : %d",
-                         TYPE_FIELD_BITSIZE (type, i));
+             gdb_printf (stream, " : %d", type->field (i).bitsize ());
            }
          gdb_printf (stream, ";\n");
        }

diff --git a/gdb/p-typeprint.c b/gdb/p-typeprint.c
index a3c2ef897d664658103e737e6f0026969138c376..356a3a8d2355ed762b5c774a4c4f82046af8d2bc 100644 (file)
--- a/gdb/p-typeprint.c
+++ b/gdb/p-typeprint.c
@@ -529,8 +529,7 @@ pascal_language::type_print_base (struct type *type, struct ui_file *stream, int
                     unnamed fields.  This would lead to misleading
                     results if the compiler does not put out fields
                     for such things (I don't know what it does).  */
-                 gdb_printf (stream, " : %d",
-                             TYPE_FIELD_BITSIZE (type, i));
+                 gdb_printf (stream, " : %d", type->field (i).bitsize ());
                }
              gdb_printf (stream, ";\n");
            }

diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index 2136a192bbc24a4fded0af423ea0adb7521a3efb..b32c0f17c6b272064eb4b6888d8aa77202a8e418 100644 (file)
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -611,7 +611,7 @@ pascal_object_print_value_fields (struct value *val, struct ui_file *stream,
                }
              else if (val->bits_synthetic_pointer
                       (type->field (i).loc_bitpos (),
-                       TYPE_FIELD_BITSIZE (type, i)))
+                       type->field (i).bitsize ()))
                {
                  fputs_styled (_("<synthetic pointer>"),
                                metadata_style.style (), stream);

diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index 9933bb378b57e42e3d3d77787c506646a5b89100..0ea30d6c6b3f4425429f8a7adc3143f381e6b629 100644 (file)
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -208,7 +208,7 @@ convert_field (struct type *type, int field)
   if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
     return NULL;
 
-  arg = gdb_py_object_from_longest (TYPE_FIELD_BITSIZE (type, field));
+  arg = gdb_py_object_from_longest (type->field (field).bitsize ());
   if (arg == NULL)
     return NULL;
   if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)

diff --git a/gdb/typeprint.c b/gdb/typeprint.c
index 01c11629a70bfaf796368eab18f642e6c7f840b8..4a282cbaaa298c9f9de1939b78afacea8c6275a1 100644 (file)
--- a/gdb/typeprint.c
+++ b/gdb/typeprint.c
@@ -153,7 +153,7 @@ print_offset_data::update (struct type *type, unsigned int field_idx,
       || offset_bitpos % TARGET_CHAR_BIT != 0)
     {
       /* We're dealing with a bitfield.  Print the bit offset.  */
-      fieldsize_bit = TYPE_FIELD_BITSIZE (type, field_idx);
+      fieldsize_bit = type->field (field_idx).bitsize ();
 
       unsigned real_bitpos = bitpos + offset_bitpos;
 

diff --git a/gdb/valprint.c b/gdb/valprint.c
index 9489662168086d4ab8e71871ce1b96b365fa42c7..b65dda15c04bd67b696bd521256a5d676ede94fd 100644 (file)
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -1244,7 +1244,7 @@ val_print_type_code_flags (struct type *type, struct value *original_value,
                 problematic place to notify the user of an internal error
                 though.  Instead just fall through and print the field as an
                 int.  */
-             && TYPE_FIELD_BITSIZE (type, field) == 1)
+             && type->field (field).bitsize () == 1)
            {
              if (val & ((ULONGEST)1 << type->field (field).loc_bitpos ()))
                gdb_printf
@@ -1254,7 +1254,7 @@ val_print_type_code_flags (struct type *type, struct value *original_value,
            }
          else
            {
-             unsigned field_len = TYPE_FIELD_BITSIZE (type, field);
+             unsigned field_len = type->field (field).bitsize ();
              ULONGEST field_val = val >> type->field (field).loc_bitpos ();
 
              if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)

diff --git a/gdb/value.c b/gdb/value.c
index 4226e793ac957b1497d3cd43bca899e7ddd55d71..1cc326256293f1c4b37d01ccb34d283e38df2e8d 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2946,7 +2946,7 @@ value::primitive_field (LONGEST offset, int fieldno, struct type *arg_type)
      description correctly.  */
   check_typedef (type);
 
-  if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
+  if (arg_type->field (fieldno).bitsize ())
     {
       /* Handle packed fields.
 
@@ -2961,7 +2961,7 @@ value::primitive_field (LONGEST offset, int fieldno, struct type *arg_type)
       LONGEST container_bitsize = type->length () * 8;
 
       v = value::allocate_lazy (type);
-      v->set_bitsize (TYPE_FIELD_BITSIZE (arg_type, fieldno));
+      v->set_bitsize (arg_type->field (fieldno).bitsize ());
       if ((bitpos % container_bitsize) + v->bitsize () <= container_bitsize
          && type->length () <= (int) sizeof (LONGEST))
        v->set_bitpos (bitpos % container_bitsize);
@@ -3180,7 +3180,7 @@ unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
                            const struct value *val, LONGEST *result)
 {
   int bitpos = type->field (fieldno).loc_bitpos ();
-  int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+  int bitsize = type->field (fieldno).bitsize ();
   struct type *field_type = type->field (fieldno).type ();
   int bit_offset;
 
@@ -3203,7 +3203,7 @@ LONGEST
 unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
 {
   int bitpos = type->field (fieldno).loc_bitpos ();
-  int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+  int bitsize = type->field (fieldno).bitsize ();
   struct type *field_type = type->field (fieldno).type ();
 
   return unpack_bits_as_long (field_type, valaddr, bitpos, bitsize);
@@ -3261,7 +3261,7 @@ value_field_bitfield (struct type *type, int fieldno,
                      LONGEST embedded_offset, const struct value *val)
 {
   int bitpos = type->field (fieldno).loc_bitpos ();
-  int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+  int bitsize = type->field (fieldno).bitsize ();
   struct value *res_val = value::allocate (type->field (fieldno).type ());
 
   val->unpack_bitfield (res_val, bitpos, bitsize, valaddr, embedded_offset);