}
}
+/* 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 (get_dyn_prop (DYN_PROP_BYTE_STRIDE, type) == 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)
+ 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;
- 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;
if (prop != nullptr && prop->kind != PROP_TYPE)
return 1;
+ if (TYPE_HAS_DYNAMIC_LENGTH (type))
+ return 1;
+
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
{
int i;
+ bool is_cplus = HAVE_CPLUS_STRUCT (type);
+
for (i = 0; i < TYPE_NFIELDS (type); ++i)
- if (!field_is_static (&TYPE_FIELD (type, i))
- && is_dynamic_type_internal (TYPE_FIELD_TYPE (type, i), 0))
+ {
+ /* Static fields can be ignored here. */
+ if (field_is_static (&TYPE_FIELD (type, i)))
+ continue;
+ /* If the field has dynamic type, then so does TYPE. */
+ if (is_dynamic_type_internal (TYPE_FIELD_TYPE (type, i), 0))
+ return 1;
+ /* If the field is at a fixed offset, then it is not
+ dynamic. */
+ if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_DWARF_BLOCK)
+ continue;
+ /* Do not consider C++ virtual base types to be dynamic
+ due to the field's offset being dynamic; these are
+ handled via other means. */
+ if (is_cplus && BASETYPE_VIA_VIRTUAL (type, i))
+ continue;
return 1;
+ }
}
break;
}
if (field_is_static (&TYPE_FIELD (resolved_type, i)))
continue;
+ if (TYPE_FIELD_LOC_KIND (resolved_type, i) == FIELD_LOC_KIND_DWARF_BLOCK)
+ {
+ struct dwarf2_property_baton baton;
+ baton.property_type
+ = lookup_pointer_type (TYPE_FIELD_TYPE (resolved_type, i));
+ baton.locexpr = *TYPE_FIELD_DWARF_BLOCK (resolved_type, i);
+
+ struct dynamic_prop prop;
+ prop.kind = PROP_LOCEXPR;
+ prop.data.baton = &baton;
+
+ CORE_ADDR addr;
+ if (dwarf2_evaluate_property (&prop, nullptr, addr_stack, &addr,
+ true))
+ SET_FIELD_BITPOS (TYPE_FIELD (resolved_type, i),
+ TARGET_CHAR_BIT * (addr - addr_stack->addr));
+ }
+
/* As we know this field is not a static field, the field's
field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
this is the case, but only trigger a simple error rather
int top_level)
{
struct type *real_type = check_typedef (type);
- struct type *resolved_type = type;
+ struct type *resolved_type = nullptr;
struct dynamic_prop *prop;
CORE_ADDR value;
if (!is_dynamic_type_internal (real_type, top_level))
return type;
+ gdb::optional<CORE_ADDR> type_length;
+ prop = TYPE_DYNAMIC_LENGTH (type);
+ if (prop != NULL
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ type_length = value;
+
if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
{
resolved_type = copy_type (type);
}
}
+ if (resolved_type == nullptr)
+ return type;
+
+ if (type_length.has_value ())
+ {
+ TYPE_LENGTH (resolved_type) = *type_length;
+ remove_dyn_prop (DYN_PROP_BYTE_SIZE, resolved_type);
+ }
+
/* Resolve data_location attribute. */
prop = TYPE_DATA_LOCATION (resolved_type);
if (prop != NULL
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");
projects / deliverable / binutils-gdb.git / blobdiff