Merge GDB 7.5.1

gdb/valops.c

 /* Perform non-arithmetic operations on values, for GDB.
 
    Copyright (C) 1986-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 283 matching lines @@
           addr2 -= value_address (v) + value_embedded_offset (v);
           return value_at (type, addr2);
         }
     }
 
   return NULL;
 }
 
 /* Cast one pointer or reference type to another.  Both TYPE and
    the type of ARG2 should be pointer types, or else both should be
-   reference types.  Returns the new pointer or reference.  */
+   reference types.  If SUBCLASS_CHECK is non-zero, this will force a
+   check to see whether TYPE is a superclass of ARG2's type.  If
+   SUBCLASS_CHECK is zero, then the subclass check is done only when
+   ARG2 is itself non-zero.  Returns the new pointer or reference.  */
 
 struct value *
-value_cast_pointers (struct type *type, struct value *arg2)
+value_cast_pointers (struct type *type, struct value *arg2,
+                     int subclass_check)
 {
   struct type *type1 = check_typedef (type);
   struct type *type2 = check_typedef (value_type (arg2));
   struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
   struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
 
   if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
       && TYPE_CODE (t2) == TYPE_CODE_STRUCT
-      && !value_logical_not (arg2))
+      && (subclass_check || !value_logical_not (arg2)))
     {
       struct value *v2;
 
       if (TYPE_CODE (type2) == TYPE_CODE_REF)
         v2 = coerce_ref (arg2);
       else
         v2 = value_ind (arg2);
       gdb_assert (TYPE_CODE (check_typedef (value_type (v2)))
                   == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
       v2 = value_cast_structs (t1, v2);
@@ skipping 234 matching lines @@
         {
           /* Duplicate the contents of arg2 into the destination vector.  */
           memcpy (value_contents_writeable (val) + (i * TYPE_LENGTH (eltype)),
                   value_contents_all (arg2), TYPE_LENGTH (eltype));
         }
       return val;
     }
   else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
     {
       if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
-        return value_cast_pointers (type, arg2);
+        return value_cast_pointers (type, arg2, 0);
 
       arg2 = value_copy (arg2);
       deprecated_set_value_type (arg2, type);
       set_value_enclosing_type (arg2, type);
       set_value_pointed_to_offset (arg2, 0);    /* pai: chk_val */
       return arg2;
     }
   else if (VALUE_LVAL (arg2) == lval_memory)
     return value_at_lazy (type, value_address (arg2));
   else if (code1 == TYPE_CODE_VOID)
@@ skipping 706 matching lines @@
                           value_bitpos (toval), value_bitsize (toval));
             dest_buffer = buffer;
           }
         else
           {
             changed_addr = value_address (toval);
             changed_len = TYPE_LENGTH (type);
             dest_buffer = value_contents (fromval);
           }
 
-        write_memory (changed_addr, dest_buffer, changed_len);
-        observer_notify_memory_changed (changed_addr, changed_len,
-                                        dest_buffer);
+        write_memory_with_notification (changed_addr, dest_buffer, changed_len);
       }
       break;
 
     case lval_register:
       {
         struct frame_info *frame;
         struct gdbarch *gdbarch;
         int value_reg;
 
         /* Figure out which frame this is in currently.  */
@@ skipping 454 matching lines @@
         /* For functions, go through find_function_addr, which knows
            how to handle function descriptors.  */
         arg2 = value_at_lazy (enc_type, 
                               find_function_addr (arg1, NULL));
       else
         /* Retrieve the enclosing object pointed to.  */
         arg2 = value_at_lazy (enc_type, 
                               (value_as_address (arg1)
                                - value_pointed_to_offset (arg1)));
 
-      /* Re-adjust type.  */
-      deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
-      /* Add embedding info.  */
-      set_value_enclosing_type (arg2, enc_type);
-      set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
-
-      /* We may be pointing to an object of some derived type.  */
-      arg2 = value_full_object (arg2, NULL, 0, 0, 0);
-      return arg2;
+      return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
     }
 
   error (_("Attempt to take contents of a non-pointer value."));
   return 0;                     /* For lint -- never reached.  */
 }
 
 
 /* Create a value for an array by allocating space in GDB, copying the
    data into that space, and then setting up an array value.
 
@@ skipping 180 matching lines @@
         continue;
       /* Array to pointer is a `trivial conversion' according to the
          ARM.  */
 
       /* We should be doing much hairier argument matching (see
          section 13.2 of the ARM), but as a quick kludge, just check
          for the same type code.  */
       if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
         return i + 1;
     }