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

* ada-valprint.c (ada_val_print_1): Eliminate single-use

Browse source 
variable LEN.
	* alpha-tdep.c (alpha_extract_return_value): Use TYPE_LENGTH
	directly.
	(alpha_store_return_value): Likewise.
	* amd64-tdep.c (amd64_classify_aggregate): Likewise.
	(amd64_push_arguments): Likewise.
	* ax-gdb.c (gen_trace_static_fields): Likewise.
	(gen_traced_pop): Likewise.
	* bfin-tdep.c (bfin_push_dummy_call): Likewise.
	* breakpoint.c (update_watchpoint): Likewise.
	* findcmd.c (parse_find_args): Use local variable for type
	instead of length.
	* findvar.c (default_read_var_value): Use TYPE_LENGTH directly.
	* h8300-tdep.c (h8300h_extract_return_value): Likewise.
	(h8300_store_return_value): Likewise.
	* i386-darwin-tdep.c (i386_darwin_push_dummy_call): Likewise.
	Use i386_darwin_arg_type_alignment directly.
	* infcall.c (call_function_by_hand): Use TYPE_LENGTH directly.
	* lm32-tdep.c (lm32_push_dummy_call): Likewise.
	* m68hc11-tdep.c (m68hc11_push_dummy_call): Likewise.
	(m68hc11_extract_return_value): Likewise.
	* mep-tdep.c (mep_push_dummy_call): Likewise.
	* printcmd.c (float_type_from_length): Likewise.
	* s390-tdep.c (s390_value_from_register): Likewise.
	* stack.c (read_frame_arg): Likewise.
	* tracepoint.c (encode_actions_1): Likewise.
	* valops.c (value_fetch_lazy): Use local variable for type
	instead of length.  Use TYPE_LENGTH directly.
	* value.c (value_contents_equal): Use TYPE_LENGTH directly.
This commit is contained in:
Siddhesh Poyarekar 2012-09-25 12:48:53 +00:00
parent a4b411d69d
commit 744a805904
21 changed files with 116 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
gdb/ChangeLog
View file

@ -1,3 +1,36 @@
2012-09-25 Siddhesh Poyarekar <siddhesh@redhat.com>
* ada-valprint.c (ada_val_print_1): Eliminate single-use
variable LEN.
* alpha-tdep.c (alpha_extract_return_value): Use TYPE_LENGTH
directly.
(alpha_store_return_value): Likewise.
* amd64-tdep.c (amd64_classify_aggregate): Likewise.
(amd64_push_arguments): Likewise.
* ax-gdb.c (gen_trace_static_fields): Likewise.
(gen_traced_pop): Likewise.
* bfin-tdep.c (bfin_push_dummy_call): Likewise.
* breakpoint.c (update_watchpoint): Likewise.
* findcmd.c (parse_find_args): Use local variable for type
instead of length.
* findvar.c (default_read_var_value): Use TYPE_LENGTH directly.
* h8300-tdep.c (h8300h_extract_return_value): Likewise.
(h8300_store_return_value): Likewise.
* i386-darwin-tdep.c (i386_darwin_push_dummy_call): Likewise.
Use i386_darwin_arg_type_alignment directly.
* infcall.c (call_function_by_hand): Use TYPE_LENGTH directly.
* lm32-tdep.c (lm32_push_dummy_call): Likewise.
* m68hc11-tdep.c (m68hc11_push_dummy_call): Likewise.
(m68hc11_extract_return_value): Likewise.
* mep-tdep.c (mep_push_dummy_call): Likewise.
* printcmd.c (float_type_from_length): Likewise.
* s390-tdep.c (s390_value_from_register): Likewise.
* stack.c (read_frame_arg): Likewise.
* tracepoint.c (encode_actions_1): Likewise.
* valops.c (value_fetch_lazy): Use local variable for type
instead of length. Use TYPE_LENGTH directly.
* value.c (value_contents_equal): Use TYPE_LENGTH directly.
2012-09-25 Joel Brobecker <brobecker@adacore.com>
* symtab.c (skip_prologue_sal): Fix typo in comment.

3
gdb/ada-valprint.c
View file

@ -730,9 +730,8 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
if (ada_is_fixed_point_type (type))
{
LONGEST v = unpack_long (type, valaddr + offset_aligned);
int len = TYPE_LENGTH (type);
fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
fprintf_filtered (stream, TYPE_LENGTH (type) < 4 ? "%.11g" : "%.17g",
(double) ada_fixed_to_float (type, v));
return;
}

14
gdb/alpha-tdep.c
View file

@ -475,14 +475,13 @@ alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int length = TYPE_LENGTH (valtype);
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
ULONGEST l;
switch (TYPE_CODE (valtype))
{
case TYPE_CODE_FLT:
switch (length)
switch (TYPE_LENGTH (valtype))
{
case 4:
regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, raw_buffer);
@ -505,7 +504,7 @@ alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
break;
case TYPE_CODE_COMPLEX:
switch (length)
switch (TYPE_LENGTH (valtype))
{
case 8:
/* ??? This isn't correct wrt the ABI, but it's what GCC does. */
@ -531,7 +530,7 @@ alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
default:
/* Assume everything else degenerates to an integer. */
regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
store_unsigned_integer (valbuf, length, byte_order, l);
store_unsigned_integer (valbuf, TYPE_LENGTH (valtype), byte_order, l);
break;
}
}
@ -544,14 +543,13 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache,
const gdb_byte *valbuf)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int length = TYPE_LENGTH (valtype);
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
ULONGEST l;
switch (TYPE_CODE (valtype))
{
case TYPE_CODE_FLT:
switch (length)
switch (TYPE_LENGTH (valtype))
{
case 4:
alpha_lds (gdbarch, raw_buffer, valbuf);
@ -575,7 +573,7 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache,
break;
case TYPE_CODE_COMPLEX:
switch (length)
switch (TYPE_LENGTH (valtype))
{
case 8:
/* ??? This isn't correct wrt the ABI, but it's what GCC does. */
@ -603,7 +601,7 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache,
/* Assume everything else degenerates to an integer. */
/* 32-bit values must be sign-extended to 64 bits
even if the base data type is unsigned. */
if (length == 4)
if (TYPE_LENGTH (valtype) == 4)
valtype = builtin_type (gdbarch)->builtin_int32;
l = unpack_long (valtype, valbuf);
regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l);

11
gdb/amd64-tdep.c
View file

@ -446,12 +446,10 @@ amd64_non_pod_p (struct type *type)
static void
amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
{
int len = TYPE_LENGTH (type);
/* 1. If the size of an object is larger than two eightbytes, or in
C++, is a non-POD structure or union type, or contains
unaligned fields, it has class memory. */
if (len > 16 || amd64_non_pod_p (type))
if (TYPE_LENGTH (type) > 16 || amd64_non_pod_p (type))
{
class[0] = class[1] = AMD64_MEMORY;
return;
@ -471,7 +469,7 @@ amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
/* All fields in an array have the same type. */
amd64_classify (subtype, class);
if (len > 8 && class[1] == AMD64_NO_CLASS)
if (TYPE_LENGTH (type) > 8 && class[1] == AMD64_NO_CLASS)
class[1] = class[0];
}
else
@ -839,10 +837,9 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
{
struct type *type = value_type (stack_args[i]);
const gdb_byte *valbuf = value_contents (stack_args[i]);
int len = TYPE_LENGTH (type);
CORE_ADDR arg_addr = sp + element * 8;
write_memory (arg_addr, valbuf, len);
write_memory (arg_addr, valbuf, TYPE_LENGTH (type));
if (arg_addr_regno[i] >= 0)
{
/* We also need to store the address of that argument in
@ -853,7 +850,7 @@ amd64_push_arguments (struct regcache *regcache, int nargs,
store_unsigned_integer (buf, 8, byte_order, arg_addr);
regcache_cooked_write (regcache, arg_addr_regno[i], buf);
}
element += ((len + 7) / 8);
element += ((TYPE_LENGTH (type) + 7) / 8);
}
/* The psABI says that "For calls that may call functions that use

13
gdb/ax-gdb.c
View file

@ -367,9 +367,9 @@ gen_trace_static_fields (struct gdbarch *gdbarch,
{
case axs_lvalue_memory:
{
int length = TYPE_LENGTH (check_typedef (value.type));
ax_const_l (ax, length);
/* Initialize the TYPE_LENGTH if it is a typedef. */
check_typedef (value.type);
ax_const_l (ax, TYPE_LENGTH (value.type));
ax_simple (ax, aop_trace);
}
break;
@ -425,17 +425,18 @@ gen_traced_pop (struct gdbarch *gdbarch,
case axs_lvalue_memory:
{
int length = TYPE_LENGTH (check_typedef (value->type));
if (string_trace)
ax_simple (ax, aop_dup);
/* Initialize the TYPE_LENGTH if it is a typedef. */
check_typedef (value->type);
/* There's no point in trying to use a trace_quick bytecode
here, since "trace_quick SIZE pop" is three bytes, whereas
"const8 SIZE trace" is also three bytes, does the same
thing, and the simplest code which generates that will also
work correctly for objects with large sizes. */
ax_const_l (ax, length);
ax_const_l (ax, TYPE_LENGTH (value->type));
ax_simple (ax, aop_trace);
if (string_trace)

6
gdb/bfin-tdep.c
View file

@ -513,9 +513,8 @@ bfin_push_dummy_call (struct gdbarch *gdbarch,
for (i = nargs - 1; i >= 0; i--)
{
struct type *value_type = value_enclosing_type (args[i]);
int len = TYPE_LENGTH (value_type);
total_len += (len + 3) & ~3;
total_len += (TYPE_LENGTH (value_type) + 3) & ~3;
}
/* At least twelve bytes of stack space must be allocated for the function's
@ -531,8 +530,7 @@ bfin_push_dummy_call (struct gdbarch *gdbarch,
{
struct type *value_type = value_enclosing_type (args[i]);
struct type *arg_type = check_typedef (value_type);
int len = TYPE_LENGTH (value_type);
int container_len = (len + 3) & ~3;
int container_len = (TYPE_LENGTH (value_type) + 3) & ~3;
sp -= container_len;
write_memory (sp, value_contents_writeable (args[i]), container_len);

5
gdb/breakpoint.c
View file

@ -1844,11 +1844,10 @@ update_watchpoint (struct watchpoint *b, int reparse)
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
CORE_ADDR addr;
int len, type;
int type;
struct bp_location *loc, **tmp;
addr = value_address (v);
len = TYPE_LENGTH (value_type (v));
type = hw_write;
if (b->base.type == bp_read_watchpoint)
type = hw_read;
@ -1863,7 +1862,7 @@ update_watchpoint (struct watchpoint *b, int reparse)
loc->pspace = frame_pspace;
loc->address = addr;
loc->length = len;
loc->length = TYPE_LENGTH (value_type (v));
loc->watchpoint_type = type;
}
}

10
gdb/findcmd.c
View file

@ -169,19 +169,19 @@ parse_find_args (char *args, ULONGEST *max_countp,
while (*s != '\0')
{
LONGEST x;
int val_bytes;
struct type *t;
ULONGEST pattern_buf_size_need;
while (isspace (*s))
++s;
v = parse_to_comma_and_eval (&s);
val_bytes = TYPE_LENGTH (value_type (v));
t = value_type (v);
/* Keep it simple and assume size == 'g' when watching for when we
need to grow the pattern buf. */
pattern_buf_size_need = (pattern_buf_end - pattern_buf
+ max (val_bytes, sizeof (int64_t)));
+ max (TYPE_LENGTH (t), sizeof (int64_t)));
if (pattern_buf_size_need > pattern_buf_size)
{
size_t current_offset = pattern_buf_end - pattern_buf;
@ -215,8 +215,8 @@ parse_find_args (char *args, ULONGEST *max_countp,
}
else
{
memcpy (pattern_buf_end, value_contents (v), val_bytes);
pattern_buf_end += val_bytes;
memcpy (pattern_buf_end, value_contents (v), TYPE_LENGTH (t));
pattern_buf_end += TYPE_LENGTH (t);
}
if (*s == ',')

8
gdb/findvar.c
View file

@ -446,7 +446,6 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
struct value *v;
struct type *type = SYMBOL_TYPE (var);
CORE_ADDR addr;
int len;
/* Call check_typedef on our type to make sure that, if TYPE is
a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
@ -455,8 +454,6 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
set the returned value type description correctly. */
check_typedef (type);
len = TYPE_LENGTH (type);
if (symbol_read_needs_frame (var))
gdb_assert (frame);
@ -465,7 +462,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
case LOC_CONST:
/* Put the constant back in target format. */
v = allocate_value (type);
store_signed_integer (value_contents_raw (v), len,
store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
gdbarch_byte_order (get_type_arch (type)),
(LONGEST) SYMBOL_VALUE (var));
VALUE_LVAL (v) = not_lval;
@ -490,7 +487,8 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
case LOC_CONST_BYTES:
v = allocate_value (type);
memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
TYPE_LENGTH (type));
VALUE_LVAL (v) = not_lval;
return v;

19
gdb/h8300-tdep.c
View file

@ -785,16 +785,15 @@ h8300h_extract_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int len = TYPE_LENGTH (type);
ULONGEST c;
switch (len)
switch (TYPE_LENGTH (type))
{
case 1:
case 2:
case 4:
regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
store_unsigned_integer (valbuf, len, byte_order, c);
store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
break;
case 8: /* long long is now 8 bytes. */
if (TYPE_CODE (type) == TYPE_CODE_INT)
@ -852,18 +851,17 @@ h8300_store_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int len = TYPE_LENGTH (type);
ULONGEST val;
switch (len)
switch (TYPE_LENGTH (type))
{
case 1:
case 2: /* short... */
val = extract_unsigned_integer (valbuf, len, byte_order);
val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
break;
case 4: /* long, float */
val = extract_unsigned_integer (valbuf, len, byte_order);
val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
(val >> 16) & 0xffff);
regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff);
@ -882,19 +880,18 @@ h8300h_store_return_value (struct type *type, struct regcache *regcache,
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int len = TYPE_LENGTH (type);
ULONGEST val;
switch (len)
switch (TYPE_LENGTH (type))
{
case 1:
case 2:
case 4: /* long, float */
val = extract_unsigned_integer (valbuf, len, byte_order);
val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
break;
case 8:
val = extract_unsigned_integer (valbuf, len, byte_order);
val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
(val >> 32) & 0xffffffff);
regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM,

11
gdb/i386-darwin-tdep.c
View file

@ -196,13 +196,12 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
}
else
{
int len = TYPE_LENGTH (arg_type);
int align = i386_darwin_arg_type_alignment (arg_type);
args_space = align_up (args_space, align);
args_space = align_up (args_space,
i386_darwin_arg_type_alignment (arg_type));
if (write_pass)
write_memory (sp + args_space,
value_contents_all (args[i]), len);
value_contents_all (args[i]),
TYPE_LENGTH (arg_type));
/* The System V ABI says that:
@ -211,7 +210,7 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
depending on the size of the argument."
This makes sure the stack stays word-aligned. */
args_space += align_up (len, 4);
args_space += align_up (TYPE_LENGTH (arg_type), 4);
}
}

6
gdb/infcall.c
View file

@ -708,13 +708,11 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
if (struct_return || hidden_first_param_p)
{
int len = TYPE_LENGTH (values_type);
if (gdbarch_inner_than (gdbarch, 1, 2))
{
/* Stack grows downward. Align STRUCT_ADDR and SP after
making space for the return value. */
sp -= len;
sp -= TYPE_LENGTH (values_type);
if (gdbarch_frame_align_p (gdbarch))
sp = gdbarch_frame_align (gdbarch, sp);
struct_addr = sp;
@ -726,7 +724,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
if (gdbarch_frame_align_p (gdbarch))
sp = gdbarch_frame_align (gdbarch, sp);
struct_addr = sp;
sp += len;
sp += TYPE_LENGTH (values_type);
if (gdbarch_frame_align_p (gdbarch))
sp = gdbarch_frame_align (gdbarch, sp);
}

7
gdb/lm32-tdep.c
View file

@ -261,7 +261,6 @@ lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct value *arg = args[i];
struct type *arg_type = check_typedef (value_type (arg));
gdb_byte *contents;
int len;
ULONGEST val;
/* Promote small integer types to int. */
@ -283,8 +282,8 @@ lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* FIXME: Handle structures. */
contents = (gdb_byte *) value_contents (arg);
len = TYPE_LENGTH (arg_type);
val = extract_unsigned_integer (contents, len, byte_order);
val = extract_unsigned_integer (contents, TYPE_LENGTH (arg_type),
byte_order);
/* First num_arg_regs parameters are passed by registers,
and the rest are passed on the stack. */
@ -292,7 +291,7 @@ lm32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
regcache_cooked_write_unsigned (regcache, first_arg_reg + i, val);
else
{
write_memory (sp, (void *) &val, len);
write_memory (sp, (void *) &val, TYPE_LENGTH (arg_type));
sp -= 4;
}
}

18
gdb/m68hc11-tdep.c
View file

@ -1174,7 +1174,6 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int first_stack_argnum;
struct type *type;
char *val;
int len;
char buf[2];
first_stack_argnum = 0;
@ -1185,19 +1184,18 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
else if (nargs > 0)
{
type = value_type (args[0]);
len = TYPE_LENGTH (type);
/* First argument is passed in D and X registers. */
if (len <= 4)
if (TYPE_LENGTH (type) <= 4)
{
ULONGEST v;
v = extract_unsigned_integer (value_contents (args[0]),
len, byte_order);
TYPE_LENGTH (type), byte_order);
first_stack_argnum = 1;
regcache_cooked_write_unsigned (regcache, HARD_D_REGNUM, v);
if (len > 2)
if (TYPE_LENGTH (type) > 2)
{
v >>= 16;
regcache_cooked_write_unsigned (regcache, HARD_X_REGNUM, v);
@ -1208,9 +1206,8 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (argnum = nargs - 1; argnum >= first_stack_argnum; argnum--)
{
type = value_type (args[argnum]);
len = TYPE_LENGTH (type);
if (len & 1)
if (TYPE_LENGTH (type) & 1)
{
static char zero = 0;
@ -1218,8 +1215,8 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
write_memory (sp, &zero, 1);
}
val = (char*) value_contents (args[argnum]);
sp -= len;
write_memory (sp, val, len);
sp -= TYPE_LENGTH (type);
write_memory (sp, val, TYPE_LENGTH (type));
}
/* Store return address. */
@ -1291,11 +1288,10 @@ static void
m68hc11_extract_return_value (struct type *type, struct regcache *regcache,
void *valbuf)
{
int len = TYPE_LENGTH (type);
char buf[M68HC11_REG_SIZE];
regcache_raw_read (regcache, HARD_D_REGNUM, buf);
switch (len)
switch (TYPE_LENGTH (type))
{
case 1:
memcpy (valbuf, buf + 1, 1);

3
gdb/mep-tdep.c
View file

@ -2337,11 +2337,10 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
for (i = 0; i < argc; i++)
{
unsigned arg_size = TYPE_LENGTH (value_type (argv[i]));
ULONGEST value;
/* Arguments that fit in a GPR get expanded to fill the GPR. */
if (arg_size <= MEP_GPR_SIZE)
if (TYPE_LENGTH (value_type (argv[i])) <= MEP_GPR_SIZE)
value = extract_unsigned_integer (value_contents (argv[i]),
TYPE_LENGTH (value_type (argv[i])),
byte_order);

7
gdb/printcmd.c
View file

@ -346,13 +346,12 @@ float_type_from_length (struct type *type)
{
struct gdbarch *gdbarch = get_type_arch (type);
const struct builtin_type *builtin = builtin_type (gdbarch);
unsigned int len = TYPE_LENGTH (type);
if (len == TYPE_LENGTH (builtin->builtin_float))
if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float))
type = builtin->builtin_float;
else if (len == TYPE_LENGTH (builtin->builtin_double))
else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double))
type = builtin->builtin_double;
else if (len == TYPE_LENGTH (builtin->builtin_long_double))
else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double))
type = builtin->builtin_long_double;
return type;

6
gdb/s390-tdep.c
View file

@ -376,9 +376,11 @@ s390_value_from_register (struct type *type, int regnum,
struct frame_info *frame)
{
struct value *value = default_value_from_register (type, regnum, frame);
int len = TYPE_LENGTH (check_typedef (type));
if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM && len < 8)
check_typedef (type);
if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
&& TYPE_LENGTH (type) < 8)
set_value_offset (value, 0);
return value;

11
gdb/stack.c
View file

@ -354,14 +354,15 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
{
unsigned len = TYPE_LENGTH (value_type (val));
struct type *type = value_type (val);
if (!value_optimized_out (val) && value_lazy (val))
value_fetch_lazy (val);
if (!value_optimized_out (val) && value_lazy (entryval))
value_fetch_lazy (entryval);
if (!value_optimized_out (val)
&& value_available_contents_eq (val, 0, entryval, 0, len))
&& value_available_contents_eq (val, 0, entryval, 0,
TYPE_LENGTH (type)))
{
/* Initialize it just to avoid a GCC false warning. */
struct value *val_deref = NULL, *entryval_deref;
@ -373,12 +374,12 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
TRY_CATCH (except, RETURN_MASK_ERROR)
{
unsigned len_deref;
struct type *type_deref;
val_deref = coerce_ref (val);
if (value_lazy (val_deref))
value_fetch_lazy (val_deref);
len_deref = TYPE_LENGTH (value_type (val_deref));
type_deref = value_type (val_deref);
entryval_deref = coerce_ref (entryval);
if (value_lazy (entryval_deref))
@ -389,7 +390,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
if (val != val_deref
&& value_available_contents_eq (val_deref, 0,
entryval_deref, 0,
len_deref))
TYPE_LENGTH (type_deref)))
val_equal = 1;
}

8
gdb/tracepoint.c
View file

@ -1456,7 +1456,7 @@ encode_actions_1 (struct command_line *action,
}
else
{
unsigned long addr, len;
unsigned long addr;
struct cleanup *old_chain = NULL;
struct cleanup *old_chain1 = NULL;
@ -1486,8 +1486,10 @@ encode_actions_1 (struct command_line *action,
/* Safe because we know it's a simple expression. */
tempval = evaluate_expression (exp);
addr = value_address (tempval);
len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
add_memrange (collect, memrange_absolute, addr, len);
/* Initialize the TYPE_LENGTH if it is a typedef. */
check_typedef (exp->elts[1].type);
add_memrange (collect, memrange_absolute, addr,
TYPE_LENGTH (exp->elts[1].type));
break;
case OP_VAR_VALUE:

12
gdb/valops.c
View file

@ -994,7 +994,6 @@ value_fetch_lazy (struct value *val)
struct value *parent = value_parent (val);
LONGEST offset = value_offset (val);
LONGEST num;
int length = TYPE_LENGTH (type);
if (!value_bits_valid (val,
TARGET_CHAR_BIT * offset + value_bitpos (val),
@ -1008,19 +1007,20 @@ value_fetch_lazy (struct value *val)
value_bitsize (val), parent, &num))
mark_value_bytes_unavailable (val,
value_embedded_offset (val),
length);
TYPE_LENGTH (type));
else
store_signed_integer (value_contents_raw (val), length,
store_signed_integer (value_contents_raw (val), TYPE_LENGTH (type),
byte_order, num);
}
else if (VALUE_LVAL (val) == lval_memory)
{
CORE_ADDR addr = value_address (val);
int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
struct type *type = check_typedef (value_enclosing_type (val));
if (length)
if (TYPE_LENGTH (type))
read_value_memory (val, 0, value_stack (val),
addr, value_contents_all_raw (val), length);
addr, value_contents_all_raw (val),
TYPE_LENGTH (type));
}
else if (VALUE_LVAL (val) == lval_register)
{

7
gdb/value.c
View file

@ -1033,15 +1033,14 @@ value_contents_equal (struct value *val1, struct value *val2)
{
struct type *type1;
struct type *type2;
int len;
type1 = check_typedef (value_type (val1));
type2 = check_typedef (value_type (val2));
len = TYPE_LENGTH (type1);
if (len != TYPE_LENGTH (type2))
if (TYPE_LENGTH (type1) != TYPE_LENGTH (type2))
return 0;
return (memcmp (value_contents (val1), value_contents (val2), len) == 0);
return (memcmp (value_contents (val1), value_contents (val2),
TYPE_LENGTH (type1)) == 0);
}
int