2005-02-06 Andrew Cagney <cagney@gnu.org>

[deliverable/binutils-gdb.git] / gdb / s390-tdep.c

diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 71d9b37aab59c7dba33552aafd1d19abc0f105f9..b09abaec1a21182f982686525e04f2642256cf3a 100644 (file)
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -1,6 +1,7 @@
 /* Target-dependent code for GDB, the GNU debugger.
 
-   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+   Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation,
+   Inc.
 
    Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
    for IBM Deutschland Entwicklung GmbH, IBM Corporation.
@@ -2434,10 +2435,10 @@ extend_simple_arg (struct value *arg)
      register / memory word.  It's not really right to extract them as
      an integer, but it does take care of the extension.  */
   if (TYPE_UNSIGNED (type))
-    return extract_unsigned_integer (VALUE_CONTENTS (arg),
+    return extract_unsigned_integer (value_contents (arg),
                                      TYPE_LENGTH (type));
   else
-    return extract_signed_integer (VALUE_CONTENTS (arg),
+    return extract_signed_integer (value_contents (arg),
                                    TYPE_LENGTH (type));
 }
 
@@ -2518,7 +2519,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
         {
           sp -= length;
           sp = align_down (sp, alignment_of (type));
-          write_memory (sp, VALUE_CONTENTS (arg), length);
+          write_memory (sp, value_contents (arg), length);
           copy_addr[i] = sp;
         }
     }
@@ -2578,7 +2579,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                /* When we store a single-precision value in an FP register,
                   it occupies the leftmost bits.  */
                regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
-                                           0, length, VALUE_CONTENTS (arg));
+                                           0, length, value_contents (arg));
                fr += 2;
              }
            else
@@ -2586,7 +2587,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                /* When we store a single-precision value in a stack slot,
                   it occupies the rightmost bits.  */
                starg = align_up (starg + length, word_size);
-                write_memory (starg - length, VALUE_CONTENTS (arg), length);
+                write_memory (starg - length, value_contents (arg), length);
              }
          }
        else if (s390_function_arg_integer (type) && length <= word_size)
@@ -2611,9 +2612,9 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            if (gr <= 5)
              {
                regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
-                                      VALUE_CONTENTS (arg));
+                                      value_contents (arg));
                regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
-                                      VALUE_CONTENTS (arg) + word_size);
+                                      value_contents (arg) + word_size);
                gr += 2;
              }
            else
@@ -2622,7 +2623,7 @@ s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                   in it, then don't go back and use it again later.  */
                gr = 7;
 
-               write_memory (starg, VALUE_CONTENTS (arg), length);
+               write_memory (starg, value_contents (arg), length);
                starg += length;
              }
          }