gdb: add type::length / type::set_length

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

Change-Id: Id1090244f15c9856969b9be5006aefe8d8897ca4

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 95fb37b49f49583c87dae66ab23d41f8f1f10753..93425660053039b97bd7835533a2d1ca4accd6c5 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -2165,7 +2165,7 @@ ada_type_of_array (struct value *arr, int bounds)
                  int array_bitsize =
                        (hi - lo + 1) * TYPE_FIELD_BITSIZE (elt_type, 0);
 
-                 TYPE_LENGTH (array_type) = (array_bitsize + 7) / 8;
+                 array_type->set_length ((array_bitsize + 7) / 8);
                }
            }
        }
@@ -2392,12 +2392,14 @@ constrained_packed_array_type (struct type *type, long *elt_bits)
       || !get_discrete_bounds (index_type, &low_bound, &high_bound))
     low_bound = high_bound = 0;
   if (high_bound < low_bound)
-    *elt_bits = TYPE_LENGTH (new_type) = 0;
+    {
+      *elt_bits = 0;
+      new_type->set_length (0);
+    }
   else
     {
       *elt_bits *= (high_bound - low_bound + 1);
-      TYPE_LENGTH (new_type) =
-       (*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
+      new_type->set_length ((*elt_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
     }
 
   new_type->set_is_fixed_instance (true);
@@ -2471,8 +2473,8 @@ recursively_update_array_bitsize (struct type *type)
       LONGEST elt_bitsize = elt_len * TYPE_FIELD_BITSIZE (elt_type, 0);
       TYPE_FIELD_BITSIZE (type, 0) = elt_bitsize;
 
-      TYPE_LENGTH (type) = ((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
-                           / HOST_CHAR_BIT);
+      type->set_length (((our_len * elt_bitsize + HOST_CHAR_BIT - 1)
+                        / HOST_CHAR_BIT));
     }
 
   return our_len;
@@ -7826,7 +7828,7 @@ empty_record (struct type *templ)
   type->set_code (TYPE_CODE_STRUCT);
   INIT_NONE_SPECIFIC (type);
   type->set_name ("<empty>");
-  TYPE_LENGTH (type) = 0;
+  type->set_length (0);
   return type;
 }
 
@@ -7996,8 +7998,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
       if (off + fld_bit_len > bit_len)
        bit_len = off + fld_bit_len;
       off += fld_bit_len;
-      TYPE_LENGTH (rtype) =
-       align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+      rtype->set_length (align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT);
     }
 
   /* We handle the variant part, if any, at the end because of certain
@@ -8042,8 +8043,9 @@ ada_template_to_fixed_record_type_1 (struct type *type,
            TARGET_CHAR_BIT;
          if (off + fld_bit_len > bit_len)
            bit_len = off + fld_bit_len;
-         TYPE_LENGTH (rtype) =
-           align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+
+         rtype->set_length
+           (align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT);
        }
     }
 
@@ -8063,10 +8065,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
                 pulongest (TYPE_LENGTH (type)));
     }
   else
-    {
-      TYPE_LENGTH (rtype) = align_up (TYPE_LENGTH (rtype),
-                                     TYPE_LENGTH (type));
-    }
+    rtype->set_length (align_up (TYPE_LENGTH (rtype), TYPE_LENGTH (type)));
 
   value_free_to_mark (mark);
   return rtype;
@@ -8148,7 +8147,7 @@ template_to_static_fixed_type (struct type *type0)
 
              type->set_name (ada_type_name (type0));
              type->set_is_fixed_instance (true);
-             TYPE_LENGTH (type) = 0;
+             type->set_length (0);
            }
          type->field (f).set_type (new_type);
          type->field (f).set_name (type0->field (f).name ());
@@ -8199,7 +8198,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
 
   rtype->set_name (ada_type_name (type));
   rtype->set_is_fixed_instance (true);
-  TYPE_LENGTH (rtype) = TYPE_LENGTH (type);
+  rtype->set_length (TYPE_LENGTH (type));
 
   branch_type = to_fixed_variant_branch_type
     (type->field (variant_field).type (),
@@ -8222,9 +8221,11 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
       rtype->field (variant_field).set_type (branch_type);
       rtype->field (variant_field).set_name ("S");
       TYPE_FIELD_BITSIZE (rtype, variant_field) = 0;
-      TYPE_LENGTH (rtype) += TYPE_LENGTH (branch_type);
+      rtype->set_length (TYPE_LENGTH (rtype) + TYPE_LENGTH (branch_type));
     }
-  TYPE_LENGTH (rtype) -= TYPE_LENGTH (type->field (variant_field).type ());
+
+  rtype->set_length (TYPE_LENGTH (rtype)
+                    - TYPE_LENGTH (type->field (variant_field).type ()));
 
   value_free_to_mark (mark);
   return rtype;
@@ -8532,9 +8533,9 @@ to_fixed_array_type (struct type *type0, struct value *dval,
       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
 
       TYPE_FIELD_BITSIZE (result, 0) = TYPE_FIELD_BITSIZE (type0, 0);
-      TYPE_LENGTH (result) = len * elt_bitsize / HOST_CHAR_BIT;
+      result->set_length (len * elt_bitsize / HOST_CHAR_BIT);
       if (TYPE_LENGTH (result) * HOST_CHAR_BIT < len * elt_bitsize)
-       TYPE_LENGTH (result)++;
+       result->set_length (TYPE_LENGTH (result) + 1);
     }
 
   result->set_is_fixed_instance (true);
@@ -8630,7 +8631,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
            if (xvz_found && TYPE_LENGTH (fixed_record_type) != size)
              {
                fixed_record_type = copy_type (fixed_record_type);
-               TYPE_LENGTH (fixed_record_type) = size;
+               fixed_record_type->set_length (size);
 
                /* The FIXED_RECORD_TYPE may have be a stub.  We have
                   observed this when the debugging info is STABS, and
@@ -11528,7 +11529,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
       /* create_static_range_type alters the resulting type's length
         to match the size of the base_type, which is not what we want.
         Set it back to the original range type's length.  */
-      TYPE_LENGTH (type) = TYPE_LENGTH (raw_type);
+      type->set_length (TYPE_LENGTH (raw_type));
       type->set_name (name);
       return type;
     }

diff --git a/gdb/coffread.c b/gdb/coffread.c
index 27afa11738d9e32c40af56de4ebcebb1d31ae43d..801978978e9751a96e5f1b5b96ba5fe22762ec94 100644 (file)
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1472,7 +1472,7 @@ patch_type (struct type *type, struct type *real_type)
   struct type *real_target = real_type->target_type ();
   int field_size = real_target->num_fields () * sizeof (struct field);
 
-  TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
+  target->set_length (real_target->length ());
   target->set_num_fields (real_target->num_fields ());
 
   field *fields = (struct field *) TYPE_ALLOC (target, field_size);
@@ -1887,7 +1887,7 @@ decode_base_type (struct coff_symbol *cs,
          type->set_code (TYPE_CODE_STRUCT);
          type->set_name (NULL);
          INIT_CPLUS_SPECIFIC (type);
-         TYPE_LENGTH (type) = 0;
+         type->set_length (0);
          type->set_fields (nullptr);
          type->set_num_fields (0);
        }
@@ -1907,7 +1907,7 @@ decode_base_type (struct coff_symbol *cs,
          type = coff_alloc_type (cs->c_symnum);
          type->set_name (NULL);
          INIT_CPLUS_SPECIFIC (type);
-         TYPE_LENGTH (type) = 0;
+         type->set_length (0);
          type->set_fields (nullptr);
          type->set_num_fields (0);
        }
@@ -1928,7 +1928,7 @@ decode_base_type (struct coff_symbol *cs,
          type = coff_alloc_type (cs->c_symnum);
          type->set_code (TYPE_CODE_ENUM);
          type->set_name (NULL);
-         TYPE_LENGTH (type) = 0;
+         type->set_length (0);
          type->set_fields (nullptr);
          type->set_num_fields (0);
        }
@@ -1996,7 +1996,7 @@ coff_read_struct_type (int index, int length, int lastsym,
   type = coff_alloc_type (index);
   type->set_code (TYPE_CODE_STRUCT);
   INIT_CPLUS_SPECIFIC (type);
-  TYPE_LENGTH (type) = length;
+  type->set_length (length);
 
   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
     {
@@ -2124,9 +2124,9 @@ coff_read_enum_type (int index, int length, int lastsym,
   /* Now fill in the fields of the type-structure.  */
 
   if (length > 0)
-    TYPE_LENGTH (type) = length;
+    type->set_length (length);
   else /* Assume ints.  */
-    TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
+    type->set_length (gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT);
   type->set_code (TYPE_CODE_ENUM);
   type->set_num_fields (nsyms);
   type->set_fields

diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index 07bbb9b262e0410e5e388d7b8c7645452137ca91..86bc57b5353ad336a605673d2402838ec93fd11b 100644 (file)
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -729,7 +729,7 @@ test_print_fields (gdbarch *arch)
   type *uint8_type = builtin_type (arch)->builtin_uint8;
   type *bool_type = builtin_type (arch)->builtin_bool;
   type *the_struct = arch_composite_type (arch, NULL, TYPE_CODE_STRUCT);
-  TYPE_LENGTH (the_struct) = 4;
+  the_struct->set_length (4);
 
   /* Value:  1110 1001
      Fields: C-BB B-A- */

diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index 561534f9ebe61c20d4451380fb1f9fa305d04a7d..890cb91aca7a4191f25be62646a19dfa289d6228 100644 (file)
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -641,7 +641,7 @@ read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
   else
     type->set_code (TYPE_CODE_STRUCT);
 
-  TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+  type->set_length (ctf_type_size (fp, tid));
   set_type_align (type, ctf_type_align (fp, tid));
 
   return set_tid_type (ccp->of, tid, type);
@@ -747,7 +747,7 @@ read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
     type->set_name (name);
 
   type->set_code (TYPE_CODE_ENUM);
-  TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+  type->set_length (ctf_type_size (fp, tid));
   /* Set the underlying type based on its ctf_type_size bits.  */
   type->set_target_type (objfile_int_type (of, TYPE_LENGTH (type), false));
   set_type_align (type, ctf_type_align (fp, tid));
@@ -834,11 +834,11 @@ read_array_type (struct ctf_context *ccp, ctf_id_t tid)
   if (ar.ctr_nelems <= 1)      /* Check if undefined upper bound.  */
     {
       range_type->bounds ()->high.set_undefined ();
-      TYPE_LENGTH (type) = 0;
+      type->set_length (0);
       type->set_target_is_stub (true);
     }
   else
-    TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+    type->set_length (ctf_type_size (fp, tid));
 
   set_type_align (type, ctf_type_align (fp, tid));
 
@@ -988,7 +988,7 @@ read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
   else
     type->set_code (TYPE_CODE_STRUCT);
 
-  TYPE_LENGTH (type) = 0;
+  type->set_length (0);
   type->set_is_stub (true);
 
   return set_tid_type (of, tid, type);

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index d358297acef5af669a69b1a9b691378f2f336dfb..ef988d7d14c0d28cd7b0f21cee3795a67b9857a0 100644 (file)
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -8191,7 +8191,7 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
 
          /* In Rust, each element should have the size of the
             enclosing enum.  */
-         TYPE_LENGTH (type->field (i).type ()) = TYPE_LENGTH (type);
+         type->field (i).type ()->set_length (TYPE_LENGTH (type));
 
          /* Remove the discriminant field, if it exists.  */
          struct type *sub_type = type->field (i).type ();
@@ -14640,19 +14640,18 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
   if (attr != nullptr)
     {
       if (attr->form_is_constant ())
-       TYPE_LENGTH (type) = attr->constant_value (0);
+       type->set_length (attr->constant_value (0));
       else
        {
          struct dynamic_prop prop;
          if (attr_to_dynamic_prop (attr, die, cu, &prop, cu->addr_type ()))
            type->add_dyn_prop (DYN_PROP_BYTE_SIZE, prop);
-         TYPE_LENGTH (type) = 0;
+
+         type->set_length (0);
        }
     }
   else
-    {
-      TYPE_LENGTH (type) = 0;
-    }
+    type->set_length (0);
 
   maybe_set_alignment (cu, die, type);
 
@@ -15200,13 +15199,9 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr)
-    {
-      TYPE_LENGTH (type) = attr->constant_value (0);
-    }
+    type->set_length (attr->constant_value (0));
   else
-    {
-      TYPE_LENGTH (type) = 0;
-    }
+    type->set_length (0);
 
   maybe_set_alignment (cu, die, type);
 
@@ -15233,7 +15228,7 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
       type->set_is_unsigned (underlying_type->is_unsigned ());
 
       if (TYPE_LENGTH (type) == 0)
-       TYPE_LENGTH (type) = TYPE_LENGTH (underlying_type);
+       type->set_length (TYPE_LENGTH (underlying_type));
 
       if (TYPE_RAW_ALIGN (type) == 0
          && TYPE_RAW_ALIGN (underlying_type) != 0)
@@ -15530,7 +15525,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
   int last_fieldno = range_fields.size () - 1;
   int bounds_size = (bounds->field (last_fieldno).loc_bitpos () / 8
                     + TYPE_LENGTH (bounds->field (last_fieldno).type ()));
-  TYPE_LENGTH (bounds) = align_up (bounds_size, max_align);
+  bounds->set_length (align_up (bounds_size, max_align));
 
   /* Rewrite the existing array type in place.  Specifically, we
      remove any dynamic properties we might have read, and we replace
@@ -15564,8 +15559,8 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
   result->field (1).set_loc_bitpos (8 * bounds_offset);
 
   result->set_name (type->name ());
-  TYPE_LENGTH (result) = (TYPE_LENGTH (result->field (0).type ())
-                         + TYPE_LENGTH (result->field (1).type ()));
+  result->set_length (TYPE_LENGTH (result->field (0).type ())
+                     + TYPE_LENGTH (result->field (1).type ()));
 
   return result;
 }
@@ -15706,7 +15701,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
   if (attr != nullptr && attr->form_is_unsigned ())
     {
       if (attr->as_unsigned () >= TYPE_LENGTH (type))
-       TYPE_LENGTH (type) = attr->as_unsigned ();
+       type->set_length (attr->as_unsigned ());
       else
        complaint (_("DW_AT_byte_size for array type smaller "
                     "than the total size of elements"));
@@ -15792,7 +15787,7 @@ read_set_type (struct die_info *die, struct dwarf2_cu *cu)
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr && attr->form_is_unsigned ())
-    TYPE_LENGTH (set_type) = attr->as_unsigned ();
+    set_type->set_length (attr->as_unsigned ());
 
   maybe_set_alignment (cu, die, set_type);
 
@@ -16194,7 +16189,7 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
        }
     }
 
-  TYPE_LENGTH (type) = byte_size;
+  type->set_length (byte_size);
   set_type_align (type, alignment);
   return set_die_type (die, type, cu);
 }
@@ -16257,13 +16252,10 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
   type = lookup_reference_type (target_type, refcode);
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr)
-    {
-      TYPE_LENGTH (type) = attr->constant_value (cu_header->addr_size);
-    }
+    type->set_length (attr->constant_value (cu_header->addr_size));
   else
-    {
-      TYPE_LENGTH (type) = cu_header->addr_size;
-    }
+    type->set_length (cu_header->addr_size);
+
   maybe_set_alignment (cu, die, type);
   return set_die_type (die, type, cu);
 }
@@ -17692,7 +17684,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr != nullptr)
-    TYPE_LENGTH (range_type) = attr->constant_value (0);
+    range_type->set_length (attr->constant_value (0));
 
   maybe_set_alignment (cu, die, range_type);
 

diff --git a/gdb/eval.c b/gdb/eval.c
index ddbdd95b39cf0a10b06f90f3edc33866825ad39e..a6e295d78cd23726612131b4a19e208e4884a98f 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -482,7 +482,7 @@ fake_method::fake_method (type_instance_flags flags,
   struct type *type = &m_type;
 
   TYPE_MAIN_TYPE (type) = &m_main_type;
-  TYPE_LENGTH (type) = 1;
+  type->set_length (1);
   type->set_code (TYPE_CODE_METHOD);
   TYPE_CHAIN (type) = type;
   type->set_instance_flags (flags);

diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 544657d585011f830b922650d0a87e87c3f47d7f..2dda1b8c67ca840e4bc5c1b094a6e28c87ebfd80 100644 (file)
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -91,10 +91,8 @@ f77_get_dynamic_length_of_aggregate (struct type *type)
   upper_bound = f77_get_upperbound (type);
 
   /* Patch in a valid length value.  */
-
-  TYPE_LENGTH (type) =
-    (upper_bound - lower_bound + 1)
-    * TYPE_LENGTH (check_typedef (type->target_type ()));
+  type->set_length ((upper_bound - lower_bound + 1)
+                   * TYPE_LENGTH (check_typedef (type->target_type ())));
 }
 
 /* Per-dimension statistics.  */

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 71a8bd193b6f01197161b16a511c8ea0d735e392..a306c1a4e846c992beb8f62c305302b567405dab 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -376,7 +376,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
 
   /* FIXME!  Assumes the machine has only one representation for pointers!  */
 
-  TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT;
+  ntype->set_length (gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT);
   ntype->set_code (TYPE_CODE_PTR);
 
   /* Mark pointers as unsigned.  The target converts between pointers
@@ -388,7 +388,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
   chain = TYPE_CHAIN (ntype);
   while (chain != ntype)
     {
-      TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
+      chain->set_length (TYPE_LENGTH (ntype));
       chain = TYPE_CHAIN (chain);
     }
 
@@ -459,7 +459,7 @@ make_reference_type (struct type *type, struct type **typeptr,
      references, and that it matches the (only) representation for
      pointers!  */
 
-  TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT;
+  ntype->set_length (gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT);
   ntype->set_code (refcode);
 
   *reftype = ntype;
@@ -468,7 +468,7 @@ make_reference_type (struct type *type, struct type **typeptr,
   chain = TYPE_CHAIN (ntype);
   while (chain != ntype)
     {
-      TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
+      chain->set_length (TYPE_LENGTH (ntype));
       chain = TYPE_CHAIN (chain);
     }
 
@@ -524,7 +524,7 @@ make_function_type (struct type *type, struct type **typeptr)
 
   ntype->set_target_type (type);
 
-  TYPE_LENGTH (ntype) = 1;
+  ntype->set_length (1);
   ntype->set_code (TYPE_CODE_FUNC);
 
   INIT_FUNC_SPECIFIC (ntype);
@@ -671,7 +671,7 @@ make_qualified_type (struct type *type, type_instance_flags new_flags,
   ntype->set_instance_flags (new_flags);
 
   /* Set length of new type to that of the original type.  */
-  TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+  ntype->set_length (TYPE_LENGTH (type));
 
   return ntype;
 }
@@ -824,7 +824,7 @@ replace_type (struct type *ntype, struct type *type)
         call replace_type().  */
       gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
 
-      TYPE_LENGTH (chain) = TYPE_LENGTH (type);
+      chain->set_length (TYPE_LENGTH (type));
       chain = TYPE_CHAIN (chain);
     }
   while (ntype != chain);
@@ -874,7 +874,7 @@ allocate_stub_method (struct type *type)
 
   mtype = alloc_type_copy (type);
   mtype->set_code (TYPE_CODE_METHOD);
-  TYPE_LENGTH (mtype) = 1;
+  mtype->set_length (1);
   mtype->set_is_stub (true);
   mtype->set_target_type (type);
   /* TYPE_SELF_TYPE (mtype) = unknown yet */
@@ -945,7 +945,7 @@ create_range_type (struct type *result_type, struct type *index_type,
   if (index_type->is_stub ())
     result_type->set_target_is_stub (true);
   else
-    TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
+    result_type->set_length (TYPE_LENGTH (check_typedef (index_type)));
 
   range_bounds *bounds
     = (struct range_bounds *) TYPE_ZALLOC (result_type, sizeof (range_bounds));
@@ -1297,7 +1297,7 @@ update_static_array_size (struct type *type)
         empty arrays with the high_bound being smaller than the low_bound.
         In such cases, the array length should be zero.  */
       if (high_bound < low_bound)
-       TYPE_LENGTH (type) = 0;
+       type->set_length (0);
       else if (stride != 0)
        {
          /* Ensure that the type length is always positive, even in the
@@ -1307,12 +1307,11 @@ update_static_array_size (struct type *type)
             special, it's still just a single element array) so do
             consider that case when touching this code.  */
          LONGEST element_count = std::abs (high_bound - low_bound + 1);
-         TYPE_LENGTH (type)
-           = ((std::abs (stride) * element_count) + 7) / 8;
+         type->set_length (((std::abs (stride) * element_count) + 7) / 8);
        }
       else
-       TYPE_LENGTH (type) =
-         TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
+       type->set_length (TYPE_LENGTH (element_type)
+                         * (high_bound - low_bound + 1));
 
       /* If this array's element is itself an array with a bit stride,
         then we want to update this array's bit stride to reflect the
@@ -1397,7 +1396,7 @@ create_array_type_with_stride (struct type *result_type,
         to trust TYPE_LENGTH in this case, setting the size to zero
         allows us to avoid allocating objects of random sizes in case
         we accidently do.  */
-      TYPE_LENGTH (result_type) = 0;
+      result_type->set_length (0);
     }
 
   /* TYPE_TARGET_STUB will take care of zero length arrays.  */
@@ -1492,8 +1491,8 @@ create_set_type (struct type *result_type, struct type *domain_type)
        low_bound = high_bound = 0;
 
       bit_length = high_bound - low_bound + 1;
-      TYPE_LENGTH (result_type)
-       = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+      result_type->set_length ((bit_length + TARGET_CHAR_BIT - 1)
+                              / TARGET_CHAR_BIT);
       if (low_bound >= 0)
        result_type->set_is_unsigned (true);
     }
@@ -1614,7 +1613,7 @@ smash_to_memberptr_type (struct type *type, struct type *self_type,
   set_type_self_type (type, self_type);
   /* Assume that a data member pointer is the same size as a normal
      pointer.  */
-  TYPE_LENGTH (type) = gdbarch_ptr_bit (to_type->arch ()) / TARGET_CHAR_BIT;
+  type->set_length (gdbarch_ptr_bit (to_type->arch ()) / TARGET_CHAR_BIT);
 }
 
 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
@@ -1630,7 +1629,7 @@ smash_to_methodptr_type (struct type *type, struct type *to_type)
   type->set_code (TYPE_CODE_METHODPTR);
   type->set_target_type (to_type);
   set_type_self_type (type, TYPE_SELF_TYPE (to_type));
-  TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
+  type->set_length (cplus_method_ptr_size (to_type));
 }
 
 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
@@ -1651,9 +1650,12 @@ smash_to_method_type (struct type *type, struct type *self_type,
   set_type_self_type (type, self_type);
   type->set_fields (args);
   type->set_num_fields (nargs);
+
   if (varargs)
     type->set_has_varargs (true);
-  TYPE_LENGTH (type) = 1;      /* In practice, this is never needed.  */
+
+  /* In practice, this is never needed.  */
+  type->set_length (1);
 }
 
 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
@@ -2503,7 +2505,7 @@ resolve_dynamic_union (struct type *type,
        max_len = TYPE_LENGTH (real_type);
     }
 
-  TYPE_LENGTH (resolved_type) = max_len;
+  resolved_type->set_length (max_len);
   return resolved_type;
 }
 
@@ -2777,8 +2779,8 @@ resolve_dynamic_struct (struct type *type,
      type length of the structure.  If we adapt it, we run into problems
      when calculating the element offset for arrays of structs.  */
   if (current_language->la_language != language_fortran)
-    TYPE_LENGTH (resolved_type)
-      = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+    resolved_type->set_length ((resolved_type_bit_length + TARGET_CHAR_BIT - 1)
+                              / TARGET_CHAR_BIT);
 
   /* The Ada language uses this field as a cache for static fixed types: reset
      it as RESOLVED_TYPE must have its own static fixed type.  */
@@ -2873,7 +2875,7 @@ resolve_dynamic_type_internal (struct type *type,
 
   if (type_length.has_value ())
     {
-      TYPE_LENGTH (resolved_type) = *type_length;
+      resolved_type->set_length (*type_length);
       resolved_type->remove_dyn_prop (DYN_PROP_BYTE_SIZE);
     }
 
@@ -3146,7 +3148,7 @@ check_typedef (struct type *type)
        }
       else if (type->code () == TYPE_CODE_RANGE)
        {
-         TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
+         type->set_length (TYPE_LENGTH (target_type));
          type->set_target_is_stub (false);
        }
       else if (type->code () == TYPE_CODE_ARRAY
@@ -3157,7 +3159,7 @@ check_typedef (struct type *type)
   type = make_qualified_type (type, instance_flags, NULL);
 
   /* Cache TYPE_LENGTH for future use.  */
-  TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
+  orig_type->set_length (TYPE_LENGTH (type));
 
   return type;
 }
@@ -3430,7 +3432,7 @@ init_type (struct objfile *objfile, enum type_code code, int bit,
   type = alloc_type (objfile);
   set_type_code (type, code);
   gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
-  TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
+  type->set_length (bit / TARGET_CHAR_BIT);
   type->set_name (name);
 
   return type;
@@ -3579,7 +3581,7 @@ init_complex_type (const char *name, struct type *target_type)
 
       t = alloc_type_copy (target_type);
       set_type_code (t, TYPE_CODE_COMPLEX);
-      TYPE_LENGTH (t) = 2 * TYPE_LENGTH (target_type);
+      t->set_length (2 * TYPE_LENGTH (target_type));
       t->set_name (name);
 
       t->set_target_type (target_type);
@@ -5658,7 +5660,7 @@ copy_type_recursive (struct type *type, htab_t copied_types)
     new_type->set_name (xstrdup (type->name ()));
 
   new_type->set_instance_flags (type->instance_flags ());
-  TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
+  new_type->set_length (TYPE_LENGTH (type));
 
   /* Copy the fields.  */
   if (type->num_fields ())
@@ -5787,7 +5789,7 @@ copy_type (const struct type *type)
 {
   struct type *new_type = alloc_type_copy (type);
   new_type->set_instance_flags (type->instance_flags ());
-  TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
+  new_type->set_length (TYPE_LENGTH (type));
   memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
          sizeof (struct main_type));
   if (type->main_type->dyn_prop_list != NULL)
@@ -5816,7 +5818,7 @@ arch_type (struct gdbarch *gdbarch,
   type = alloc_type_arch (gdbarch);
   set_type_code (type, code);
   gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
-  TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
+  type->set_length (bit / TARGET_CHAR_BIT);
 
   if (name)
     type->set_name (gdbarch_obstack_strdup (gdbarch, name));
@@ -6026,11 +6028,11 @@ append_composite_type_field_aligned (struct type *t, const char *name,
   if (t->code () == TYPE_CODE_UNION)
     {
       if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
-       TYPE_LENGTH (t) = TYPE_LENGTH (field);
+       t->set_length (TYPE_LENGTH (field));
     }
   else if (t->code () == TYPE_CODE_STRUCT)
     {
-      TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
+      t->set_length (TYPE_LENGTH (t) + TYPE_LENGTH (field));
       if (t->num_fields () > 1)
        {
          f->set_loc_bitpos
@@ -6046,7 +6048,8 @@ append_composite_type_field_aligned (struct type *t, const char *name,
              if (left)
                {
                  f->set_loc_bitpos (f[0].loc_bitpos () + (alignment - left));
-                 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
+                 t->set_length
+                   (t->length () + (alignment - left) / TARGET_CHAR_BIT);
                }
            }
        }

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 6f4b2d61ca88e2f9e5e4ef5e9dbe18f452ef8c1d..6d12a489b15791542b93ad7e9fdb0f35ab08a24e 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -1045,6 +1045,16 @@ struct type
     this->main_type->name = name;
   }
 
+  ULONGEST length () const
+  {
+    return this->m_length;
+  }
+
+  void set_length (ULONGEST length)
+  {
+    this->m_length = length;
+  }
+
   /* Get the number of fields of this type.  */
   int num_fields () const
   {
@@ -1443,7 +1453,7 @@ struct type
   bool bit_size_differs_p () const
   {
     return (main_type->type_specific_field == TYPE_SPECIFIC_INT
-           && main_type->type_specific.int_stuff.bit_size != 8 * length);
+           && main_type->type_specific.int_stuff.bit_size != 8 * length ());
   }
 
   /* * Return the logical (bit) size for this integer type.  Only
@@ -1528,7 +1538,7 @@ struct type
      type_length_units function should be used in order to get the length
      expressed in target addressable memory units.  */
 
-  ULONGEST length;
+  ULONGEST m_length;
 
   /* * Core type, shared by a group of qualified types.  */
 
@@ -2105,7 +2115,7 @@ extern void allocate_gnat_aux_type (struct type *);
    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
    so you only have to call check_typedef once.  Since allocate_value
    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
-#define TYPE_LENGTH(thistype) (thistype)->length
+#define TYPE_LENGTH(thistype) ((thistype)->length ())
 
 /* * Return the alignment of the type in target addressable memory
    units, or 0 if no alignment was specified.  */

diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 673c370e1202224759a7b254e8d0e44fb95b9869..56710cf6041e8c225fa7ad8a6f8772378eec4600 100644 (file)
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -1022,7 +1022,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                                 name, (char *) NULL));
 
        t->set_code (type_code);
-       TYPE_LENGTH (t) = sh->value;
+       t->set_length (sh->value);
        t->set_num_fields (nfields);
        f = ((struct field *) TYPE_ALLOC (t, nfields * sizeof (struct field)));
        t->set_fields (f);
@@ -1043,7 +1043,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
               that too.  */
            if (TYPE_LENGTH (t) == t->num_fields ()
                || TYPE_LENGTH (t) == 0)
-             TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
+             t->set_length (gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT);
            for (ext_tsym = ext_sh + external_sym_size;
                 ;
                 ext_tsym += external_sym_size)

diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 32aa58c7211140b58d4f4c42b7638b3908e6471e..5bd3edb4adc96c81541fa80d2ddf1eb6418b996e 100644 (file)
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -899,7 +899,7 @@ public:
        tmp->set_name (OCL_STRING(TYPE ## 2));                  \
        tmp = add (init_vector_type (ELEMENT_TYPE, 3));         \
        tmp->set_name (OCL_STRING(TYPE ## 3));                  \
-       TYPE_LENGTH (tmp) = 4 * TYPE_LENGTH (ELEMENT_TYPE);     \
+       tmp->set_length (4 * TYPE_LENGTH (ELEMENT_TYPE));       \
        tmp = add (init_vector_type (ELEMENT_TYPE, 4));         \
        tmp->set_name (OCL_STRING(TYPE ## 4));                  \
        tmp = add (init_vector_type (ELEMENT_TYPE, 8));         \

diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index 36f77907a70a19cb00608c21c4b9a7a006e271ce..a48996e1b2e66d71f7b2fa817d0bdf0b79a8e77e 100644 (file)
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -989,9 +989,8 @@ rust_composite_type (struct type *original,
     }
 
   if (i > 0)
-    TYPE_LENGTH (result)
-      = (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT +
-        TYPE_LENGTH (result->field (i - 1).type ()));
+    result->set_length (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT
+                       + TYPE_LENGTH (result->field (i - 1).type ()));
   return result;
 }
 

diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 3c484cee87bde8596db563cfd66a6e65608d3a71..af34353903bce1adc97874357bd8a3f4ea0945cf 100644 (file)
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1684,7 +1684,7 @@ again:
          {
            /* It's being defined as itself.  That means it is "void".  */
            type->set_code (TYPE_CODE_VOID);
-           TYPE_LENGTH (type) = 1;
+           type->set_length (1);
          }
        else if (type_size >= 0 || is_string)
          {
@@ -2008,7 +2008,7 @@ again:
 
   /* Size specified in a type attribute overrides any other size.  */
   if (type_size != -1)
-    TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+    type->set_length ((type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT);
 
   return type;
 }
@@ -3385,7 +3385,7 @@ set_length_in_type_chain (struct type *type)
   while (ntype != type)
     {
       if (TYPE_LENGTH(ntype) == 0)
-       TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+       ntype->set_length (TYPE_LENGTH (type));
       else
        complain_about_struct_wipeout (ntype);
       ntype = TYPE_CHAIN (ntype);
@@ -3441,7 +3441,7 @@ read_struct_type (const char **pp, struct type *type, enum type_code type_code,
   {
     int nbits;
 
-    TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
+    type->set_length (read_huge_number (pp, 0, &nbits, 0));
     if (nbits != 0)
       return error_type (pp, objfile);
     set_length_in_type_chain (type);
@@ -3606,7 +3606,7 @@ read_enum_type (const char **pp, struct type *type,
 
   /* Now fill in the fields of the type-structure.  */
 
-  TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
+  type->set_length (gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT);
   set_length_in_type_chain (type);
   type->set_code (TYPE_CODE_ENUM);
   type->set_is_stub (false);

diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c
index 044b171ecd27d3ac57ab75c92dce8d8a34bd7555..20a79d5d4583e5d7c15a673b5b55a04b8376ec12 100644 (file)
--- a/gdb/target-descriptions.c
+++ b/gdb/target-descriptions.c
@@ -246,7 +246,7 @@ make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
        }
 
       if (e->size != 0)
-       TYPE_LENGTH (m_type) = e->size;
+       m_type->set_length (e->size);
     }
 
     void make_gdb_type_union (const tdesc_type_with_fields *e)