read_pieced_value do big endian processing only in case of valid gdb_regnum

During armv7b testing gdb.base/store.exp test was failling with
'GDB internal error' with the following message:

Temporary breakpoint 1, wack_double (u=
../../binutils-gdb/gdb/regcache.c:177: internal-error: register_size: Assertion `regnum >= 0 && regnum < (gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch))' failed.
A problem internal to GDB has been detected,
further debugging may prove unreliable.

It turns out that compiler generated DWARF with non-existent
register numbers. The compiler issue is present in both little endian
(armv7) and big endian (armv7b) (it is separate issue). Here is
example for one of formal parameters of wack_double function:

 <2><792>: Abbrev Number: 10 (DW_TAG_formal_parameter)
    <793>   DW_AT_name        : u
    <795>   DW_AT_decl_file   : 1
    <796>   DW_AT_decl_line   : 115
    <797>   DW_AT_type        : <0x57c>
    <79b>   DW_AT_location    : 6 byte block: 6d 93 4 6c 93 4   (DW_OP_reg29 (r29); DW_OP_piece: 4; DW_OP_reg28 (r28); DW_OP_piece: 4)

In both big and little endian cases gdbarch_dwarf2_reg_to_regnum
returns -1 which is stored into gdb_regnum. But it causes severe
problem only in big endian case because in read_pieced_value and
write_pieced_value functions BFD_ENDIAN_BIG related processing
happen regardless of gdb_regnum value, for example register_size
function is called and in case of gdb_regnum=-1, it cause
'GDB internal error' and crash.

Solution is to move BFD_ENDIAN_BIG related processing under
(gdb_regnum != -1) branch of processing.

gdb/ChangeLog:

2014-11-02  Victor Kamensky  <victor.kamensky@linaro.org>

	* dwarf2loc.c (read_pieced_value): Do big endian
	processing only if gdb_regnum is not -1.
	(write_pieced_value): Ditto.

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index 71adc896e99ebf8d68b67a3cdb1b324e4e7a24b4..6e461bcdccf0ed8ef723508d0245f86d7729ffe5 100644 (file)
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -1683,21 +1683,21 @@ read_pieced_value (struct value *v)
          {
            struct gdbarch *arch = get_frame_arch (frame);
            int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
-           int reg_offset = source_offset;
-
-           if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
-               && this_size < register_size (arch, gdb_regnum))
-             {
-               /* Big-endian, and we want less than full size.  */
-               reg_offset = register_size (arch, gdb_regnum) - this_size;
-               /* We want the lower-order THIS_SIZE_BITS of the bytes
-                  we extract from the register.  */
-               source_offset_bits += 8 * this_size - this_size_bits;
-             }
 
            if (gdb_regnum != -1)
              {
                int optim, unavail;
+               int reg_offset = source_offset;
+
+               if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+                   && this_size < register_size (arch, gdb_regnum))
+                 {
+                   /* Big-endian, and we want less than full size.  */
+                   reg_offset = register_size (arch, gdb_regnum) - this_size;
+                   /* We want the lower-order THIS_SIZE_BITS of the bytes
+                      we extract from the register.  */
+                   source_offset_bits += 8 * this_size - this_size_bits;
+                }
 
                if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
                                               this_size, buffer,
@@ -1875,15 +1875,18 @@ write_pieced_value (struct value *to, struct value *from)
          {
            struct gdbarch *arch = get_frame_arch (frame);
            int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
-           int reg_offset = dest_offset;
-
-           if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
-               && this_size <= register_size (arch, gdb_regnum))
-             /* Big-endian, and we want less than full size.  */
-             reg_offset = register_size (arch, gdb_regnum) - this_size;
 
            if (gdb_regnum != -1)
              {
+               int reg_offset = dest_offset;
+
+               if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+                   && this_size <= register_size (arch, gdb_regnum))
+                 {
+                   /* Big-endian, and we want less than full size.  */
+                   reg_offset = register_size (arch, gdb_regnum) - this_size;
+                 }
+
                if (need_bitwise)
                  {
                    int optim, unavail;