? eliminate-vars.patch Index: ada-valprint.c =================================================================== RCS file: /cvs/src/src/gdb/ada-valprint.c,v retrieving revision 1.91 diff -u -r1.91 ada-valprint.c --- ada-valprint.c 18 Apr 2012 06:46:46 -0000 1.91 +++ ada-valprint.c 24 Sep 2012 09:16:35 -0000 @@ -730,9 +730,8 @@ 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; } Index: alpha-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/alpha-tdep.c,v retrieving revision 1.211 diff -u -r1.211 alpha-tdep.c --- alpha-tdep.c 16 May 2012 14:35:02 -0000 1.211 +++ alpha-tdep.c 24 Sep 2012 09:16:35 -0000 @@ -475,14 +475,13 @@ { 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ /* 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); Index: amd64-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/amd64-tdep.c,v retrieving revision 1.109 diff -u -r1.109 amd64-tdep.c --- amd64-tdep.c 4 Jul 2012 20:46:20 -0000 1.109 +++ amd64-tdep.c 24 Sep 2012 09:16:36 -0000 @@ -446,12 +446,10 @@ 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 @@ /* 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 @@ { 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 @@ 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 Index: ax-gdb.c =================================================================== RCS file: /cvs/src/src/gdb/ax-gdb.c,v retrieving revision 1.105 diff -u -r1.105 ax-gdb.c --- ax-gdb.c 19 Jul 2012 15:38:16 -0000 1.105 +++ ax-gdb.c 24 Sep 2012 09:16:37 -0000 @@ -367,9 +367,7 @@ { case axs_lvalue_memory: { - int length = TYPE_LENGTH (check_typedef (value.type)); - - ax_const_l (ax, length); + ax_const_l (ax, TYPE_LENGTH (check_typedef (value.type))); ax_simple (ax, aop_trace); } break; @@ -425,8 +423,6 @@ case axs_lvalue_memory: { - int length = TYPE_LENGTH (check_typedef (value->type)); - if (string_trace) ax_simple (ax, aop_dup); @@ -435,7 +431,7 @@ "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 (check_typedef (value->type))); ax_simple (ax, aop_trace); if (string_trace) Index: bfin-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/bfin-tdep.c,v retrieving revision 1.10 diff -u -r1.10 bfin-tdep.c --- bfin-tdep.c 16 May 2012 14:35:03 -0000 1.10 +++ bfin-tdep.c 24 Sep 2012 09:16:37 -0000 @@ -513,9 +513,8 @@ 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 @@ { 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); Index: breakpoint.c =================================================================== RCS file: /cvs/src/src/gdb/breakpoint.c,v retrieving revision 1.704 diff -u -r1.704 breakpoint.c --- breakpoint.c 17 Sep 2012 07:03:14 -0000 1.704 +++ breakpoint.c 24 Sep 2012 09:16:40 -0000 @@ -1844,11 +1844,10 @@ && 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 @@ loc->pspace = frame_pspace; loc->address = addr; - loc->length = len; + loc->length = TYPE_LENGTH (value_type (v)); loc->watchpoint_type = type; } } Index: findcmd.c =================================================================== RCS file: /cvs/src/src/gdb/findcmd.c,v retrieving revision 1.19 diff -u -r1.19 findcmd.c --- findcmd.c 6 Jul 2012 15:51:39 -0000 1.19 +++ findcmd.c 24 Sep 2012 09:16:40 -0000 @@ -169,19 +169,19 @@ 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 @@ } 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 == ',') Index: findvar.c =================================================================== RCS file: /cvs/src/src/gdb/findvar.c,v retrieving revision 1.146 diff -u -r1.146 findvar.c --- findvar.c 21 Sep 2012 17:17:19 -0000 1.146 +++ findvar.c 24 Sep 2012 09:16:40 -0000 @@ -446,7 +446,6 @@ 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 @@ 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 @@ 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 @@ 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; Index: h8300-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/h8300-tdep.c,v retrieving revision 1.135 diff -u -r1.135 h8300-tdep.c --- h8300-tdep.c 19 Sep 2012 11:09:15 -0000 1.135 +++ h8300-tdep.c 24 Sep 2012 09:16:40 -0000 @@ -785,16 +785,15 @@ { 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 @@ { 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 @@ { 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, Index: i386-darwin-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/i386-darwin-tdep.c,v retrieving revision 1.12 diff -u -r1.12 i386-darwin-tdep.c --- i386-darwin-tdep.c 2 Apr 2012 13:15:48 -0000 1.12 +++ i386-darwin-tdep.c 24 Sep 2012 09:16:40 -0000 @@ -196,13 +196,12 @@ } 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 @@ 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); } } Index: infcall.c =================================================================== RCS file: /cvs/src/src/gdb/infcall.c,v retrieving revision 1.160 diff -u -r1.160 infcall.c --- infcall.c 16 Aug 2012 07:36:20 -0000 1.160 +++ infcall.c 24 Sep 2012 09:16:40 -0000 @@ -708,13 +708,11 @@ 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 @@ 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); } Index: lm32-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/lm32-tdep.c,v retrieving revision 1.12 diff -u -r1.12 lm32-tdep.c --- lm32-tdep.c 18 May 2012 21:02:48 -0000 1.12 +++ lm32-tdep.c 24 Sep 2012 09:16:40 -0000 @@ -261,7 +261,6 @@ 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 @@ /* 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 @@ 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; } } Index: m68hc11-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/m68hc11-tdep.c,v retrieving revision 1.139 diff -u -r1.139 m68hc11-tdep.c --- m68hc11-tdep.c 19 Sep 2012 11:09:16 -0000 1.139 +++ m68hc11-tdep.c 24 Sep 2012 09:16:41 -0000 @@ -1174,7 +1174,6 @@ int first_stack_argnum; struct type *type; char *val; - int len; char buf[2]; first_stack_argnum = 0; @@ -1185,19 +1184,18 @@ 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 @@ 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 @@ 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 @@ 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); Index: mep-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/mep-tdep.c,v retrieving revision 1.35 diff -u -r1.35 mep-tdep.c --- mep-tdep.c 16 May 2012 14:35:06 -0000 1.35 +++ mep-tdep.c 24 Sep 2012 09:16:41 -0000 @@ -2337,11 +2337,10 @@ 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); Index: printcmd.c =================================================================== RCS file: /cvs/src/src/gdb/printcmd.c,v retrieving revision 1.212 diff -u -r1.212 printcmd.c --- printcmd.c 14 Sep 2012 07:00:42 -0000 1.212 +++ printcmd.c 24 Sep 2012 09:16:41 -0000 @@ -346,13 +346,12 @@ { 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; Index: s390-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/s390-tdep.c,v retrieving revision 1.207 diff -u -r1.207 s390-tdep.c --- s390-tdep.c 17 Sep 2012 08:52:18 -0000 1.207 +++ s390-tdep.c 24 Sep 2012 09:16:42 -0000 @@ -376,9 +376,11 @@ 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; Index: stack.c =================================================================== RCS file: /cvs/src/src/gdb/stack.c,v retrieving revision 1.256 diff -u -r1.256 stack.c --- stack.c 19 Jul 2012 15:33:25 -0000 1.256 +++ stack.c 24 Sep 2012 09:16:42 -0000 @@ -354,14 +354,15 @@ 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 @@ TRY_CATCH (except, RETURN_MASK_ERROR) { - unsigned len_deref; + struct type *t; val_deref = coerce_ref (val); if (value_lazy (val_deref)) value_fetch_lazy (val_deref); - len_deref = TYPE_LENGTH (value_type (val_deref)); + t = value_type (val_deref); entryval_deref = coerce_ref (entryval); if (value_lazy (entryval_deref)) @@ -389,7 +390,7 @@ if (val != val_deref && value_available_contents_eq (val_deref, 0, entryval_deref, 0, - len_deref)) + TYPE_LENGTH (t))) val_equal = 1; } Index: tracepoint.c =================================================================== RCS file: /cvs/src/src/gdb/tracepoint.c,v retrieving revision 1.266 diff -u -r1.266 tracepoint.c --- tracepoint.c 18 Sep 2012 12:09:26 -0000 1.266 +++ tracepoint.c 24 Sep 2012 09:16:43 -0000 @@ -1456,7 +1456,7 @@ } else { - unsigned long addr, len; + unsigned long addr; struct cleanup *old_chain = NULL; struct cleanup *old_chain1 = NULL; @@ -1486,8 +1486,9 @@ /* 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); + check_typedef (exp->elts[1].type); + add_memrange (collect, memrange_absolute, addr, + TYPE_LENGTH (exp->elts[1].type)); break; case OP_VAR_VALUE: Index: valops.c =================================================================== RCS file: /cvs/src/src/gdb/valops.c,v retrieving revision 1.302 diff -u -r1.302 valops.c --- valops.c 14 Sep 2012 00:54:58 -0000 1.302 +++ valops.c 24 Sep 2012 09:16:44 -0000 @@ -994,7 +994,6 @@ 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_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) { Index: value.c =================================================================== RCS file: /cvs/src/src/gdb/value.c,v retrieving revision 1.161 diff -u -r1.161 value.c --- value.c 13 Aug 2012 14:30:58 -0000 1.161 +++ value.c 24 Sep 2012 09:16:44 -0000 @@ -1033,15 +1033,14 @@ { 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