From 744a80590447619c1c58d7d6a6e780ae6bd29777 Mon Sep 17 00:00:00 2001 From: Siddhesh Poyarekar Date: Tue, 25 Sep 2012 12:48:53 +0000 Subject: [PATCH] * 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. --- gdb/ChangeLog | 33 +++++++++++++++++++++++++++++++++ gdb/ada-valprint.c | 3 +-- gdb/alpha-tdep.c | 14 ++++++-------- gdb/amd64-tdep.c | 11 ++++------- gdb/ax-gdb.c | 13 +++++++------ gdb/bfin-tdep.c | 6 ++---- gdb/breakpoint.c | 5 ++--- gdb/findcmd.c | 10 +++++----- gdb/findvar.c | 8 +++----- gdb/h8300-tdep.c | 19 ++++++++----------- gdb/i386-darwin-tdep.c | 11 +++++------ gdb/infcall.c | 6 ++---- gdb/lm32-tdep.c | 7 +++---- gdb/m68hc11-tdep.c | 18 +++++++----------- gdb/mep-tdep.c | 3 +-- gdb/printcmd.c | 7 +++---- gdb/s390-tdep.c | 6 ++++-- gdb/stack.c | 11 ++++++----- gdb/tracepoint.c | 8 +++++--- gdb/valops.c | 12 ++++++------ gdb/value.c | 7 +++---- 21 files changed, 116 insertions(+), 102 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 83c3171acf8..19d3602e43e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,36 @@ +2012-09-25 Siddhesh Poyarekar + + * 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 * symtab.c (skip_prologue_sal): Fix typo in comment. diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c index 95ec7ecdb5c..ca30e42c5d7 100644 --- a/gdb/ada-valprint.c +++ b/gdb/ada-valprint.c @@ -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; } diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c index 5d3affa86d1..e5b75d2471a 100644 --- a/gdb/alpha-tdep.c +++ b/gdb/alpha-tdep.c @@ -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); diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c index 54249265a71..8c5b6cc5079 100644 --- a/gdb/amd64-tdep.c +++ b/gdb/amd64-tdep.c @@ -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 diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index f2c5155b788..9cb8fe9a873 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -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) diff --git a/gdb/bfin-tdep.c b/gdb/bfin-tdep.c index fb2ead05212..4eb5763c0f2 100644 --- a/gdb/bfin-tdep.c +++ b/gdb/bfin-tdep.c @@ -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); diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index b841bcddae9..cbd21c4477c 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -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; } } diff --git a/gdb/findcmd.c b/gdb/findcmd.c index 68184aa27e9..116e0b0107b 100644 --- a/gdb/findcmd.c +++ b/gdb/findcmd.c @@ -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 == ',') diff --git a/gdb/findvar.c b/gdb/findvar.c index ec9dde7810d..d0051455109 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -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; diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c index bcb769e4246..4e98a8f7128 100644 --- a/gdb/h8300-tdep.c +++ b/gdb/h8300-tdep.c @@ -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, diff --git a/gdb/i386-darwin-tdep.c b/gdb/i386-darwin-tdep.c index c353154bf0b..e46d1bbc82d 100644 --- a/gdb/i386-darwin-tdep.c +++ b/gdb/i386-darwin-tdep.c @@ -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); } } diff --git a/gdb/infcall.c b/gdb/infcall.c index 1b927484671..2fa1daa88ef 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -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); } diff --git a/gdb/lm32-tdep.c b/gdb/lm32-tdep.c index 57d73b5aedc..725ce5bf0e2 100644 --- a/gdb/lm32-tdep.c +++ b/gdb/lm32-tdep.c @@ -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; } } diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c index cd324596ca0..ff4cb99895b 100644 --- a/gdb/m68hc11-tdep.c +++ b/gdb/m68hc11-tdep.c @@ -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); diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c index 960500c167e..c73d38f9fea 100644 --- a/gdb/mep-tdep.c +++ b/gdb/mep-tdep.c @@ -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); diff --git a/gdb/printcmd.c b/gdb/printcmd.c index 38c7b0ee67d..7a669f125e0 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -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; diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c index ed067406553..6cd6fd48351 100644 --- a/gdb/s390-tdep.c +++ b/gdb/s390-tdep.c @@ -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; diff --git a/gdb/stack.c b/gdb/stack.c index 51747ead38e..2c03f42ca97 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -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; } diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index bdd6f50fc44..cce8d002363 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -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: diff --git a/gdb/valops.c b/gdb/valops.c index 3a5ac0fe8b0..75995ac9f6b 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -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) { diff --git a/gdb/value.c b/gdb/value.c index ae44ebab313..3feb1ca5518 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -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 -- 2.30.2