}
}
+/* If the array TYPE has static bounds calculate and update its
+ size, then return true. Otherwise return false and leave TYPE
+ unchanged. */
+
+static bool
+update_static_array_size (struct type *type)
+{
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
+
+ struct type *range_type = TYPE_INDEX_TYPE (type);
+
+ if (type->dyn_prop (DYN_PROP_BYTE_STRIDE) == nullptr
+ && has_static_range (TYPE_RANGE_DATA (range_type))
+ && (!type_not_associated (type)
+ && !type_not_allocated (type)))
+ {
+ LONGEST low_bound, high_bound;
+ int stride;
+ struct type *element_type;
+
+ /* If the array itself doesn't provide a stride value then take
+ whatever stride the range provides. Don't update BIT_STRIDE as
+ we don't want to place the stride value from the range into this
+ arrays bit size field. */
+ stride = TYPE_FIELD_BITSIZE (type, 0);
+ if (stride == 0)
+ stride = TYPE_BIT_STRIDE (range_type);
+
+ if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
+ low_bound = high_bound = 0;
+ element_type = check_typedef (TYPE_TARGET_TYPE (type));
+ /* Be careful when setting the array length. Ada arrays can be
+ 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;
+ else if (stride != 0)
+ {
+ /* Ensure that the type length is always positive, even in the
+ case where (for example in Fortran) we have a negative
+ stride. It is possible to have a single element array with a
+ negative stride in Fortran (this doesn't mean anything
+ 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;
+ }
+ else
+ TYPE_LENGTH (type) =
+ TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
+
+ return true;
+ }
+
+ return false;
+}
+
/* Create an array type using either a blank type supplied in
RESULT_TYPE, or creating a new type, inheriting the objfile from
RANGE_TYPE.
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type;
- if (byte_stride_prop == NULL
- && has_static_range (TYPE_RANGE_DATA (range_type))
- && (!type_not_associated (result_type)
- && !type_not_allocated (result_type)))
- {
- LONGEST low_bound, high_bound;
- int stride;
- /* If the array itself doesn't provide a stride value then take
- whatever stride the range provides. Don't update BIT_STRIDE as
- we don't want to place the stride value from the range into this
- arrays bit size field. */
- stride = bit_stride;
- if (stride == 0)
- stride = TYPE_BIT_STRIDE (range_type);
+ TYPE_NFIELDS (result_type) = 1;
+ TYPE_FIELDS (result_type) =
+ (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
+ TYPE_INDEX_TYPE (result_type) = range_type;
+ if (byte_stride_prop != NULL)
+ result_type->add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop);
+ else if (bit_stride > 0)
+ TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
- if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
- low_bound = high_bound = 0;
- element_type = check_typedef (element_type);
- /* Be careful when setting the array length. Ada arrays can be
- 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 (result_type) = 0;
- else if (stride != 0)
- {
- /* Ensure that the type length is always positive, even in the
- case where (for example in Fortran) we have a negative
- stride. It is possible to have a single element array with a
- negative stride in Fortran (this doesn't mean anything
- 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 (result_type)
- = ((std::abs (stride) * element_count) + 7) / 8;
- }
- else
- TYPE_LENGTH (result_type) =
- TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
- }
- else
+ if (!update_static_array_size (result_type))
{
/* This type is dynamic and its length needs to be computed
on demand. In the meantime, avoid leaving the TYPE_LENGTH
TYPE_LENGTH (result_type) = 0;
}
- TYPE_NFIELDS (result_type) = 1;
- TYPE_FIELDS (result_type) =
- (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
- TYPE_INDEX_TYPE (result_type) = range_type;
- if (byte_stride_prop != NULL)
- add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop, result_type);
- else if (bit_stride > 0)
- TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
-
/* TYPE_TARGET_STUB will take care of zero length arrays. */
if (TYPE_LENGTH (result_type) == 0)
TYPE_TARGET_STUB (result_type) = 1;
static int
array_type_has_dynamic_stride (struct type *type)
{
- struct dynamic_prop *prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
+ struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
return (prop != NULL && prop->kind != PROP_CONST);
}
if (TYPE_ALLOCATED_PROP (type))
return 1;
- struct dynamic_prop *prop = get_dyn_prop (DYN_PROP_VARIANT_PARTS, type);
+ struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
if (prop != nullptr && prop->kind != PROP_TYPE)
return 1;
else
elt_type = TYPE_TARGET_TYPE (type);
- prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
+ prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
if (prop != NULL)
{
if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
- remove_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
+ type->remove_dyn_prop (DYN_PROP_BYTE_STRIDE);
bit_stride = (unsigned int) (value * 8);
}
else
resolved_type = copy_type (type);
- struct dynamic_prop *variant_prop = get_dyn_prop (DYN_PROP_VARIANT_PARTS,
- resolved_type);
+ dynamic_prop *variant_prop = resolved_type->dyn_prop (DYN_PROP_VARIANT_PARTS);
if (variant_prop != nullptr && variant_prop->kind == PROP_VARIANT_PARTS)
{
compute_variant_fields (type, resolved_type, addr_stack,
if (type_length.has_value ())
{
TYPE_LENGTH (resolved_type) = *type_length;
- remove_dyn_prop (DYN_PROP_BYTE_SIZE, resolved_type);
+ resolved_type->remove_dyn_prop (DYN_PROP_BYTE_SIZE);
}
/* Resolve data_location attribute. */
/* See gdbtypes.h */
-struct dynamic_prop *
-get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type)
+dynamic_prop *
+type::dyn_prop (dynamic_prop_node_kind prop_kind) const
{
- struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type);
+ dynamic_prop_list *node = this->main_type->dyn_prop_list;
while (node != NULL)
{
/* See gdbtypes.h */
void
-add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop,
- struct type *type)
+type::add_dyn_prop (dynamic_prop_node_kind prop_kind, dynamic_prop prop)
{
struct dynamic_prop_list *temp;
- gdb_assert (TYPE_OBJFILE_OWNED (type));
+ gdb_assert (TYPE_OBJFILE_OWNED (this));
- temp = XOBNEW (&TYPE_OBJFILE (type)->objfile_obstack,
+ temp = XOBNEW (&TYPE_OBJFILE (this)->objfile_obstack,
struct dynamic_prop_list);
temp->prop_kind = prop_kind;
temp->prop = prop;
- temp->next = TYPE_DYN_PROP_LIST (type);
+ temp->next = this->main_type->dyn_prop_list;
- TYPE_DYN_PROP_LIST (type) = temp;
+ this->main_type->dyn_prop_list = temp;
}
-/* Remove dynamic property from TYPE in case it exists. */
+/* See gdbtypes.h. */
void
-remove_dyn_prop (enum dynamic_prop_node_kind prop_kind,
- struct type *type)
+type::remove_dyn_prop (dynamic_prop_node_kind kind)
{
struct dynamic_prop_list *prev_node, *curr_node;
- curr_node = TYPE_DYN_PROP_LIST (type);
+ curr_node = this->main_type->dyn_prop_list;
prev_node = NULL;
while (NULL != curr_node)
{
- if (curr_node->prop_kind == prop_kind)
+ if (curr_node->prop_kind == kind)
{
/* Update the linked list but don't free anything.
The property was allocated on objstack and it is not known
if we are on top of it. Nevertheless, everything is released
when the complete objstack is freed. */
if (NULL == prev_node)
- TYPE_DYN_PROP_LIST (type) = curr_node->next;
+ this->main_type->dyn_prop_list = curr_node->next;
else
prev_node->next = curr_node->next;
TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
TYPE_TARGET_STUB (type) = 0;
}
+ else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ && update_static_array_size (type))
+ TYPE_TARGET_STUB (type) = 0;
}
type = make_qualified_type (type, instance_flags, NULL);
{
puts_filtered (" TYPE_PROTOTYPED");
}
- if (TYPE_INCOMPLETE (type))
- {
- puts_filtered (" TYPE_INCOMPLETE");
- }
if (TYPE_VARARGS (type))
{
puts_filtered (" TYPE_VARARGS");
*TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
}
- if (TYPE_DYN_PROP_LIST (type) != NULL)
- TYPE_DYN_PROP_LIST (new_type)
+ if (type->main_type->dyn_prop_list != NULL)
+ new_type->main_type->dyn_prop_list
= copy_dynamic_prop_list (&objfile->objfile_obstack,
- TYPE_DYN_PROP_LIST (type));
+ type->main_type->dyn_prop_list);
/* Copy pointers to other types. */
TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
sizeof (struct main_type));
- if (TYPE_DYN_PROP_LIST (type) != NULL)
- TYPE_DYN_PROP_LIST (new_type)
+ if (type->main_type->dyn_prop_list != NULL)
+ new_type->main_type->dyn_prop_list
= copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
- TYPE_DYN_PROP_LIST (type));
+ type->main_type->dyn_prop_list);
return new_type;
}