FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
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
This commit is contained in:
Simon Marchi 2022-07-30 12:01:12 -04:00
parent 27710edb4e
commit b6cdbc9a81
14 changed files with 119 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

47
gdb/ada-lang.c
View file

@ -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;
}

14
gdb/coffread.c
View file

@ -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

2
gdb/cp-valprint.c
View file

@ -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- */

10
gdb/ctfread.c
View file

@ -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);

44
gdb/dwarf2/read.c
View file

@ -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);

2
gdb/eval.c
View file

@ -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);

6
gdb/f-valprint.c
View file

@ -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. */

71
gdb/gdbtypes.c
View file

@ -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);
}
}
}

16
gdb/gdbtypes.h
View file

@ -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. */

4
gdb/mdebugread.c
View file

@ -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)

2
gdb/opencl-lang.c
View file

@ -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)); \

5
gdb/rust-lang.c
View file

@ -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;
}

10
gdb/stabsread.c
View file

@ -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);

2
gdb/target-descriptions.c
View file

@ -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)