* jit.c (jit_event_handler): Use paddress to print target addresses.
[deliverable/binutils-gdb.git] / gdb / valops.c
index 38722a4404e29d625361ae6b8130a9c1864c03cf..5e5c4edeb30bfdcca4194df09f719b29693e6191 100644 (file)
@@ -422,17 +422,18 @@ value_cast (struct type *type, struct value *arg2)
     return value_from_double (type, value_as_double (arg2));
   else if (code1 == TYPE_CODE_DECFLOAT && scalar)
     {
+      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
       int dec_len = TYPE_LENGTH (type);
       gdb_byte dec[16];
 
       if (code2 == TYPE_CODE_FLT)
-       decimal_from_floating (arg2, dec, dec_len);
+       decimal_from_floating (arg2, dec, dec_len, byte_order);
       else if (code2 == TYPE_CODE_DECFLOAT)
        decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
-                        dec, dec_len);
+                        byte_order, dec, dec_len, byte_order);
       else
        /* The only option left is an integral type.  */
-       decimal_from_integral (arg2, dec, dec_len);
+       decimal_from_integral (arg2, dec, dec_len, byte_order);
 
       return value_from_decfloat (type, dec);
     }
@@ -450,8 +451,9 @@ value_cast (struct type *type, struct value *arg2)
          sees a cast as a simple reinterpretation of the pointer's
          bits.  */
       if (code2 == TYPE_CODE_PTR)
-        longest = extract_unsigned_integer (value_contents (arg2),
-                                            TYPE_LENGTH (type2));
+        longest = extract_unsigned_integer
+                   (value_contents (arg2), TYPE_LENGTH (type2),
+                    gdbarch_byte_order (get_type_arch (type2)));
       else
         longest = value_as_long (arg2);
       return value_from_longest (type, convert_to_boolean ?
@@ -541,8 +543,9 @@ value_one (struct type *type, enum lval_type lv)
 
   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
     {
+      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
       gdb_byte v[16];
-      decimal_from_string (v, TYPE_LENGTH (type), "1");
+      decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1");
       val = value_from_decfloat (type, v);
     }
   else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
@@ -629,7 +632,25 @@ value_fetch_lazy (struct value *val)
 {
   gdb_assert (value_lazy (val));
   allocate_value_contents (val);
-  if (VALUE_LVAL (val) == lval_memory)
+  if (value_bitsize (val))
+    {
+      /* To read a lazy bitfield, read the entire enclosing value.  This
+        prevents reading the same block of (possibly volatile) memory once
+         per bitfield.  It would be even better to read only the containing
+         word, but we have no way to record that just specific bits of a
+         value have been fetched.  */
+      struct type *type = check_typedef (value_type (val));
+      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
+      struct value *parent = value_parent (val);
+      LONGEST offset = value_offset (val);
+      LONGEST num = unpack_bits_as_long (value_type (val),
+                                        value_contents (parent) + offset,
+                                        value_bitpos (val),
+                                        value_bitsize (val));
+      int length = TYPE_LENGTH (type);
+      store_signed_integer (value_contents_raw (val), length, 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)));
@@ -702,8 +723,9 @@ value_fetch_lazy (struct value *val)
                fprintf_unfiltered (gdb_stdlog, " register=%d",
                                    VALUE_REGNUM (new_val));
              else if (VALUE_LVAL (new_val) == lval_memory)
-               fprintf_unfiltered (gdb_stdlog, " address=0x%s",
-                                   paddr_nz (value_address (new_val)));
+               fprintf_unfiltered (gdb_stdlog, " address=%s",
+                                   paddress (gdbarch,
+                                             value_address (new_val)));
              else
                fprintf_unfiltered (gdb_stdlog, " computed");
 
@@ -796,13 +818,20 @@ value_assign (struct value *toval, struct value *fromval)
 
        if (value_bitsize (toval))
          {
-           /* We assume that the argument to read_memory is in units
-              of host chars.  FIXME: Is that correct?  */
            changed_len = (value_bitpos (toval)
                           + value_bitsize (toval)
                           + HOST_CHAR_BIT - 1)
              / HOST_CHAR_BIT;
 
+           /* If we can read-modify-write exactly the size of the
+              containing type (e.g. short or int) then do so.  This
+              is safer for volatile bitfields mapped to hardware
+              registers.  */
+           if (changed_len < TYPE_LENGTH (type)
+               && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)
+               && ((LONGEST) value_address (toval) % TYPE_LENGTH (type)) == 0)
+             changed_len = TYPE_LENGTH (type);
+
            if (changed_len > (int) sizeof (LONGEST))
              error (_("Can't handle bitfields which don't fit in a %d bit word."),
                     (int) sizeof (LONGEST) * HOST_CHAR_BIT);
This page took 0.025528 seconds and 4 git commands to generate.