@@ -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. */
@@ -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 ();
}
}
}
@@ -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;
@@ -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;
@@ -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;
@@ -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
@@ -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");
@@ -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)
@@ -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);
@@ -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 ());
@@ -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);
@@ -2378,7 +2378,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)
@@ -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));
@@ -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) \
@@ -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");
}
@@ -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");
}
@@ -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);
@@ -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)
@@ -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;
@@ -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)
@@ -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);