2005-02-07 Andrew Cagney <cagney@gnu.org>
[deliverable/binutils-gdb.git] / gdb / valops.c
index 575c9a335ea362ec976ef75c14fbe717d4408e8a..502cfa647cdfe9e858a9d71a5f24e3ffc6ffa7c8 100644 (file)
@@ -1,6 +1,7 @@
 /* Perform non-arithmetic operations on values, for GDB.
+
    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
-   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -207,13 +208,13 @@ value_cast (struct type *type, struct value *arg2)
 
   int convert_to_boolean = 0;
 
-  if (VALUE_TYPE (arg2) == type)
+  if (value_type (arg2) == type)
     return arg2;
 
   CHECK_TYPEDEF (type);
   code1 = TYPE_CODE (type);
-  COERCE_REF (arg2);
-  type2 = check_typedef (VALUE_TYPE (arg2));
+  arg2 = coerce_ref (arg2);
+  type2 = check_typedef (value_type (arg2));
 
   /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
      is treated like a cast to (TYPE [N])OBJECT,
@@ -239,8 +240,8 @@ value_cast (struct type *type, struct value *arg2)
                                          TYPE_TARGET_TYPE (range_type),
                                          low_bound,
                                          new_length + low_bound - 1);
-         VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
-                                                element_type, range_type);
+         arg2->type = create_array_type ((struct type *) NULL,
+                                         element_type, range_type);
          return arg2;
        }
     }
@@ -252,8 +253,7 @@ value_cast (struct type *type, struct value *arg2)
   if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
     arg2 = value_coerce_function (arg2);
 
-  type2 = check_typedef (VALUE_TYPE (arg2));
-  COERCE_VARYING_ARRAY (arg2, type2);
+  type2 = check_typedef (value_type (arg2));
   code2 = TYPE_CODE (type2);
 
   if (code1 == TYPE_CODE_COMPLEX)
@@ -282,7 +282,7 @@ value_cast (struct type *type, struct value *arg2)
                                         arg2, 0, type2, 1);
       if (v)
        {
-         VALUE_TYPE (v) = type;
+         v->type = type;
          return v;
        }
     }
@@ -306,7 +306,7 @@ value_cast (struct type *type, struct value *arg2)
            case TYPE_CODE_MEMBER:
              retvalp = value_from_longest (type, value_as_long (arg2));
              /* force evaluation */
-             ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
+             ptr = (unsigned int *) value_contents (retvalp);
              *ptr &= ~0x20000000;      /* zap 29th bit to remove bias */
              return retvalp;
 
@@ -326,7 +326,7 @@ 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),
+        longest = extract_unsigned_integer (value_contents (arg2),
                                             TYPE_LENGTH (type2));
       else
         longest = value_as_long (arg2);
@@ -380,7 +380,7 @@ value_cast (struct type *type, struct value *arg2)
                  if (v)
                    {
                      v = value_addr (v);
-                     VALUE_TYPE (v) = type;
+                     v->type = type;
                      return v;
                    }
                }
@@ -397,24 +397,21 @@ value_cast (struct type *type, struct value *arg2)
                    {
                       CORE_ADDR addr2 = value_as_address (arg2);
                       addr2 -= (VALUE_ADDRESS (v)
-                                + VALUE_OFFSET (v)
-                                + VALUE_EMBEDDED_OFFSET (v));
+                                + value_offset (v)
+                                + value_embedded_offset (v));
                       return value_from_pointer (type, addr2);
                    }
                }
            }
          /* No superclass found, just fall through to change ptr type.  */
        }
-      VALUE_TYPE (arg2) = type;
+      arg2->type = type;
       arg2 = value_change_enclosing_type (arg2, type);
       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) + VALUE_OFFSET (arg2),
-                           VALUE_BFD_SECTION (arg2));
-    }
+    return value_at_lazy (type, VALUE_ADDRESS (arg2) + value_offset (arg2));
   else if (code1 == TYPE_CODE_VOID)
     {
       return value_zero (builtin_type_void, not_lval);
@@ -432,8 +429,6 @@ struct value *
 value_zero (struct type *type, enum lval_type lv)
 {
   struct value *val = allocate_value (type);
-
-  memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
   VALUE_LVAL (val) = lv;
 
   return val;
@@ -445,14 +440,14 @@ value_zero (struct type *type, enum lval_type lv)
    if we can be 'lazy' and defer the fetch, perhaps indefinately, call
    value_at_lazy instead.  value_at_lazy simply records the address of
    the data and sets the lazy-evaluation-required flag.  The lazy flag
-   is tested in the VALUE_CONTENTS macro, which is used if and when
+   is tested in the value_contents macro, which is used if and when
    the contents are actually required.
 
    Note: value_at does *NOT* handle embedded offsets; perform such
    adjustments before or after calling it. */
 
 struct value *
-value_at (struct type *type, CORE_ADDR addr, asection *sect)
+value_at (struct type *type, CORE_ADDR addr)
 {
   struct value *val;
 
@@ -461,11 +456,10 @@ value_at (struct type *type, CORE_ADDR addr, asection *sect)
 
   val = allocate_value (type);
 
-  read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
+  read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
 
   VALUE_LVAL (val) = lval_memory;
   VALUE_ADDRESS (val) = addr;
-  VALUE_BFD_SECTION (val) = sect;
 
   return val;
 }
@@ -473,7 +467,7 @@ value_at (struct type *type, CORE_ADDR addr, asection *sect)
 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
 
 struct value *
-value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
+value_at_lazy (struct type *type, CORE_ADDR addr)
 {
   struct value *val;
 
@@ -484,35 +478,35 @@ value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
 
   VALUE_LVAL (val) = lval_memory;
   VALUE_ADDRESS (val) = addr;
-  VALUE_LAZY (val) = 1;
-  VALUE_BFD_SECTION (val) = sect;
+  set_value_lazy (val, 1);
 
   return val;
 }
 
-/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
-   if the current data for a variable needs to be loaded into
-   VALUE_CONTENTS(VAL).  Fetches the data from the user's process, and
-   clears the lazy flag to indicate that the data in the buffer is valid.
+/* Called only from the value_contents and value_contents_all()
+   macros, if the current data for a variable needs to be loaded into
+   value_contents(VAL).  Fetches the data from the user's process, and
+   clears the lazy flag to indicate that the data in the buffer is
+   valid.
 
    If the value is zero-length, we avoid calling read_memory, which would
    abort.  We mark the value as fetched anyway -- all 0 bytes of it.
 
-   This function returns a value because it is used in the VALUE_CONTENTS
+   This function returns a value because it is used in the value_contents
    macro as part of an expression, where a void would not work.  The
    value is ignored.  */
 
 int
 value_fetch_lazy (struct value *val)
 {
-  CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
-  int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
+  CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
+  int length = TYPE_LENGTH (value_enclosing_type (val));
 
-  struct type *type = VALUE_TYPE (val);
+  struct type *type = value_type (val);
   if (length)
-    read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
+    read_memory (addr, value_contents_all_raw (val), length);
 
-  VALUE_LAZY (val) = 0;
+  set_value_lazy (val, 0);
   return 0;
 }
 
@@ -530,13 +524,13 @@ value_assign (struct value *toval, struct value *fromval)
   if (!toval->modifiable)
     error ("Left operand of assignment is not a modifiable lvalue.");
 
-  COERCE_REF (toval);
+  toval = coerce_ref (toval);
 
-  type = VALUE_TYPE (toval);
+  type = value_type (toval);
   if (VALUE_LVAL (toval) != lval_internalvar)
     fromval = value_cast (type, fromval);
   else
-    COERCE_ARRAY (fromval);
+    fromval = coerce_array (fromval);
   CHECK_TYPEDEF (type);
 
   /* Since modifying a register can trash the frame chain, and modifying memory
@@ -549,32 +543,32 @@ value_assign (struct value *toval, struct value *fromval)
     case lval_internalvar:
       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
       val = value_copy (VALUE_INTERNALVAR (toval)->value);
-      val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
-      VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
+      val = value_change_enclosing_type (val, value_enclosing_type (fromval));
+      set_value_embedded_offset (val, value_embedded_offset (fromval));
       VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
       return val;
 
     case lval_internalvar_component:
       set_internalvar_component (VALUE_INTERNALVAR (toval),
-                                VALUE_OFFSET (toval),
-                                VALUE_BITPOS (toval),
-                                VALUE_BITSIZE (toval),
+                                value_offset (toval),
+                                value_bitpos (toval),
+                                value_bitsize (toval),
                                 fromval);
       break;
 
     case lval_memory:
       {
-       char *dest_buffer;
+       const bfd_byte *dest_buffer;
        CORE_ADDR changed_addr;
        int changed_len;
         char buffer[sizeof (LONGEST)];
 
-       if (VALUE_BITSIZE (toval))
+       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)
+           changed_len = (value_bitpos (toval)
+                          + value_bitsize (toval)
                           + HOST_CHAR_BIT - 1)
              / HOST_CHAR_BIT;
 
@@ -582,18 +576,18 @@ value_assign (struct value *toval, struct value *fromval)
              error ("Can't handle bitfields which don't fit in a %d bit word.",
                     (int) sizeof (LONGEST) * HOST_CHAR_BIT);
 
-           read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+           read_memory (VALUE_ADDRESS (toval) + value_offset (toval),
                         buffer, changed_len);
            modify_field (buffer, value_as_long (fromval),
-                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
-           changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+                         value_bitpos (toval), value_bitsize (toval));
+           changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
            dest_buffer = buffer;
          }
        else
          {
-           changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+           changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
            changed_len = TYPE_LENGTH (type);
-           dest_buffer = VALUE_CONTENTS (fromval);
+           dest_buffer = value_contents (fromval);
          }
 
        write_memory (changed_addr, dest_buffer, changed_len);
@@ -602,34 +596,25 @@ value_assign (struct value *toval, struct value *fromval)
       }
       break;
 
-    case lval_reg_frame_relative:
     case lval_register:
       {
        struct frame_info *frame;
        int value_reg;
 
        /* Figure out which frame this is in currently.  */
-       if (VALUE_LVAL (toval) == lval_register)
-         {
-           frame = get_current_frame ();
-           value_reg = VALUE_REGNO (toval);
-         }
-       else
-         {
-           frame = frame_find_by_id (VALUE_FRAME_ID (toval));
-           value_reg = VALUE_FRAME_REGNUM (toval);
-         }
+       frame = frame_find_by_id (VALUE_FRAME_ID (toval));
+       value_reg = VALUE_REGNUM (toval);
 
        if (!frame)
          error ("Value being assigned to is no longer active.");
        
-       if (VALUE_LVAL (toval) == lval_reg_frame_relative
-           && CONVERT_REGISTER_P (VALUE_FRAME_REGNUM (toval), type))
+       if (VALUE_LVAL (toval) == lval_register
+           && CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
          {
            /* If TOVAL is a special machine register requiring
               conversion of program values to a special raw format.  */
-           VALUE_TO_REGISTER (frame, VALUE_FRAME_REGNUM (toval),
-                              type, VALUE_CONTENTS (fromval));
+           VALUE_TO_REGISTER (frame, VALUE_REGNUM (toval),
+                              type, value_contents (fromval));
          }
        else
          {
@@ -649,14 +634,14 @@ value_assign (struct value *toval, struct value *fromval)
            {
              int offset;
              for (reg_offset = value_reg, offset = 0;
-                  offset + register_size (current_gdbarch, reg_offset) <= VALUE_OFFSET (toval);
+                  offset + register_size (current_gdbarch, reg_offset) <= value_offset (toval);
                   reg_offset++);
-             byte_offset = VALUE_OFFSET (toval) - offset;
+             byte_offset = value_offset (toval) - offset;
            }
 
            /* Compute the number of register aligned values that need
               to be copied.  */
-           if (VALUE_BITSIZE (toval))
+           if (value_bitsize (toval))
              amount_to_copy = byte_offset + 1;
            else
              amount_to_copy = byte_offset + TYPE_LENGTH (type);
@@ -671,12 +656,12 @@ value_assign (struct value *toval, struct value *fromval)
              frame_register_read (frame, regno, buffer + amount_copied);
            
            /* Modify what needs to be modified.  */
-           if (VALUE_BITSIZE (toval))
+           if (value_bitsize (toval))
              modify_field (buffer + byte_offset,
                            value_as_long (fromval),
-                           VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+                           value_bitpos (toval), value_bitsize (toval));
            else
-             memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
+             memcpy (buffer + byte_offset, value_contents (fromval),
                      TYPE_LENGTH (type));
 
            /* Copy it out.  */
@@ -705,7 +690,6 @@ value_assign (struct value *toval, struct value *fromval)
     {
     case lval_memory:
     case lval_register:
-    case lval_reg_frame_relative:
 
       reinit_frame_cache ();
 
@@ -730,11 +714,11 @@ value_assign (struct value *toval, struct value *fromval)
   
   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
      If the field is signed, and is negative, then sign extend. */
-  if ((VALUE_BITSIZE (toval) > 0)
-      && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
+  if ((value_bitsize (toval) > 0)
+      && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
     {
       LONGEST fieldval = value_as_long (fromval);
-      LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
+      LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
 
       fieldval &= valmask;
       if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
@@ -744,11 +728,11 @@ value_assign (struct value *toval, struct value *fromval)
     }
 
   val = value_copy (toval);
-  memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
+  memcpy (value_contents_raw (val), value_contents (fromval),
          TYPE_LENGTH (type));
-  VALUE_TYPE (val) = type;
-  val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
-  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
+  val->type = type;
+  val = value_change_enclosing_type (val, value_enclosing_type (fromval));
+  set_value_embedded_offset (val, value_embedded_offset (fromval));
   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 
   return val;
@@ -766,13 +750,13 @@ value_repeat (struct value *arg1, int count)
   if (count < 1)
     error ("Invalid number %d of repetitions.", count);
 
-  val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
+  val = allocate_repeat_value (value_enclosing_type (arg1), count);
 
-  read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
-              VALUE_CONTENTS_ALL_RAW (val),
-              TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
+  read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1),
+              value_contents_all_raw (val),
+              TYPE_LENGTH (value_enclosing_type (val)));
   VALUE_LVAL (val) = lval_memory;
-  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
+  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1);
 
   return val;
 }
@@ -832,13 +816,13 @@ value_of_variable (struct symbol *var, struct block *b)
 struct value *
 value_coerce_array (struct value *arg1)
 {
-  struct type *type = check_typedef (VALUE_TYPE (arg1));
+  struct type *type = check_typedef (value_type (arg1));
 
   if (VALUE_LVAL (arg1) != lval_memory)
     error ("Attempt to take address of value not located in memory.");
 
   return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
-                            (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
+                            (VALUE_ADDRESS (arg1) + value_offset (arg1)));
 }
 
 /* Given a value which is a function, return a value which is a pointer
@@ -852,9 +836,8 @@ value_coerce_function (struct value *arg1)
   if (VALUE_LVAL (arg1) != lval_memory)
     error ("Attempt to take address of value not located in memory.");
 
-  retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
-                              (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
-  VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
+  retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
+                              (VALUE_ADDRESS (arg1) + value_offset (arg1)));
   return retval;
 }
 
@@ -865,14 +848,14 @@ value_addr (struct value *arg1)
 {
   struct value *arg2;
 
-  struct type *type = check_typedef (VALUE_TYPE (arg1));
+  struct type *type = check_typedef (value_type (arg1));
   if (TYPE_CODE (type) == TYPE_CODE_REF)
     {
       /* Copy the value, but change the type from (T&) to (T*).
          We keep the same location information, which is efficient,
          and allows &(&X) to get the location containing the reference. */
       arg2 = value_copy (arg1);
-      VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+      arg2->type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
       return arg2;
     }
   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
@@ -882,17 +865,16 @@ value_addr (struct value *arg1)
     error ("Attempt to take address of value not located in memory.");
 
   /* Get target memory address */
-  arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
+  arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
                             (VALUE_ADDRESS (arg1)
-                             + VALUE_OFFSET (arg1)
-                             + VALUE_EMBEDDED_OFFSET (arg1)));
+                             + value_offset (arg1)
+                             + value_embedded_offset (arg1)));
 
   /* This may be a pointer to a base subobject; so remember the
      full derived object's type ... */
-  arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
+  arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
   /* ... and also the relative position of the subobject in the full object */
-  VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
-  VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
+  VALUE_POINTED_TO_OFFSET (arg2) = value_embedded_offset (arg1);
   return arg2;
 }
 
@@ -904,9 +886,9 @@ value_ind (struct value *arg1)
   struct type *base_type;
   struct value *arg2;
 
-  COERCE_ARRAY (arg1);
+  arg1 = coerce_array (arg1);
 
-  base_type = check_typedef (VALUE_TYPE (arg1));
+  base_type = check_typedef (value_type (arg1));
 
   if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
     error ("not implemented: member types in value_ind");
@@ -917,24 +899,22 @@ value_ind (struct value *arg1)
      BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
   if (TYPE_CODE (base_type) == TYPE_CODE_INT)
     return value_at_lazy (builtin_type_int,
-                         (CORE_ADDR) value_as_long (arg1),
-                         VALUE_BFD_SECTION (arg1));
+                         (CORE_ADDR) value_as_long (arg1));
   else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
     {
       struct type *enc_type;
       /* We may be pointing to something embedded in a larger object */
       /* Get the real type of the enclosing object */
-      enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
+      enc_type = check_typedef (value_enclosing_type (arg1));
       enc_type = TYPE_TARGET_TYPE (enc_type);
       /* Retrieve the enclosing object pointed to */
-      arg2 = value_at_lazy (enc_type,
-                  value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
-                           VALUE_BFD_SECTION (arg1));
+      arg2 = value_at_lazy (enc_type, (value_as_address (arg1)
+                                      - VALUE_POINTED_TO_OFFSET (arg1)));
       /* Re-adjust type */
-      VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
+      arg2->type = TYPE_TARGET_TYPE (base_type);
       /* Add embedding info */
       arg2 = value_change_enclosing_type (arg2, enc_type);
-      VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
+      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);
@@ -1022,10 +1002,10 @@ value_array (int lowbound, int highbound, struct value **elemvec)
     {
       error ("bad array bounds (%d, %d)", lowbound, highbound);
     }
-  typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
+  typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
   for (idx = 1; idx < nelem; idx++)
     {
-      if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
+      if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
        {
          error ("array elements must all be the same size");
        }
@@ -1034,18 +1014,17 @@ value_array (int lowbound, int highbound, struct value **elemvec)
   rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
                                 lowbound, highbound);
   arraytype = create_array_type ((struct type *) NULL,
-                             VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
+                             value_enclosing_type (elemvec[0]), rangetype);
 
   if (!current_language->c_style_arrays)
     {
       val = allocate_value (arraytype);
       for (idx = 0; idx < nelem; idx++)
        {
-         memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
-                 VALUE_CONTENTS_ALL (elemvec[idx]),
+         memcpy (value_contents_all_raw (val) + (idx * typelength),
+                 value_contents_all (elemvec[idx]),
                  typelength);
        }
-      VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
       return val;
     }
 
@@ -1057,13 +1036,14 @@ value_array (int lowbound, int highbound, struct value **elemvec)
   addr = allocate_space_in_inferior (nelem * typelength);
   for (idx = 0; idx < nelem; idx++)
     {
-      write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
+      write_memory (addr + (idx * typelength),
+                   value_contents_all (elemvec[idx]),
                    typelength);
     }
 
   /* Create the array type and set up an array value to be evaluated lazily. */
 
-  val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
+  val = value_at_lazy (arraytype, addr);
   return (val);
 }
 
@@ -1090,7 +1070,7 @@ value_string (char *ptr, int len)
   if (current_language->c_style_arrays == 0)
     {
       val = allocate_value (stringtype);
-      memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
+      memcpy (value_contents_raw (val), ptr, len);
       return val;
     }
 
@@ -1101,7 +1081,7 @@ value_string (char *ptr, int len)
   addr = allocate_space_in_inferior (len);
   write_memory (addr, ptr, len);
 
-  val = value_at_lazy (stringtype, addr, NULL);
+  val = value_at_lazy (stringtype, addr);
   return (val);
 }
 
@@ -1114,7 +1094,7 @@ value_bitstring (char *ptr, int len)
   struct type *type = create_set_type ((struct type *) NULL, domain_type);
   TYPE_CODE (type) = TYPE_CODE_BITSTRING;
   val = allocate_value (type);
-  memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
+  memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
   return val;
 }
 \f
@@ -1157,7 +1137,7 @@ typecmp (int staticp, int varargs, int nargs,
        return i + 1;
 
       tt1 = check_typedef (t1[i].type);
-      tt2 = check_typedef (VALUE_TYPE (t2[i]));
+      tt2 = check_typedef (value_type (t2[i]));
 
       if (TYPE_CODE (tt1) == TYPE_CODE_REF
       /* We should be doing hairy argument matching, as below.  */
@@ -1194,7 +1174,7 @@ typecmp (int staticp, int varargs, int nargs,
       /* 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])))
+      if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
        return i + 1;
     }
   if (varargs || t2[i] == NULL)
@@ -1302,9 +1282,9 @@ search_struct_field (char *name, struct value *arg1, int offset,
          struct value *v2 = allocate_value (basetype);
 
          boffset = baseclass_offset (type, i,
-                                     VALUE_CONTENTS (arg1) + offset,
+                                     value_contents (arg1) + offset,
                                      VALUE_ADDRESS (arg1)
-                                     + VALUE_OFFSET (arg1) + offset);
+                                     + value_offset (arg1) + offset);
          if (boffset == -1)
            error ("virtual baseclass botch");
 
@@ -1317,8 +1297,8 @@ search_struct_field (char *name, struct value *arg1, int offset,
            {
              CORE_ADDR base_addr;
 
-             base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
-             if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
+             base_addr = VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
+             if (target_read_memory (base_addr, value_contents_raw (v2),
                                      TYPE_LENGTH (basetype)) != 0)
                error ("virtual baseclass botch");
              VALUE_LVAL (v2) = lval_memory;
@@ -1328,12 +1308,13 @@ search_struct_field (char *name, struct value *arg1, int offset,
            {
              VALUE_LVAL (v2) = VALUE_LVAL (arg1);
              VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
-             VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
-             if (VALUE_LAZY (arg1))
-               VALUE_LAZY (v2) = 1;
+             VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
+             v2->offset = value_offset (arg1) + boffset;
+             if (value_lazy (arg1))
+               set_value_lazy (v2, 1);
              else
-               memcpy (VALUE_CONTENTS_RAW (v2),
-                       VALUE_CONTENTS_RAW (arg1) + boffset,
+               memcpy (value_contents_raw (v2),
+                       value_contents_raw (arg1) + boffset,
                        TYPE_LENGTH (basetype));
            }
 
@@ -1374,8 +1355,9 @@ search_struct_field (char *name, struct value *arg1, int offset,
  * conventions.  */
 
 void
-find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
-                     int offset, int *boffset_p, int *skip_p)
+find_rt_vbase_offset (struct type *type, struct type *basetype,
+                     const bfd_byte *valaddr, int offset, int *boffset_p,
+                     int *skip_p)
 {
   int boffset;                 /* offset of virtual base */
   int index;                   /* displacement to use in virtual table */
@@ -1435,7 +1417,7 @@ find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
      & use long type */
 
   /* epstein : FIXME -- added param for overlay section. May not be correct */
-  vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
+  vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START));
   boffset = value_as_long (vp);
   *skip_p = -1;
   *boffset_p = boffset;
@@ -1521,8 +1503,8 @@ search_struct_method (char *name, struct value **arg1p,
                 according to HP/Taligent runtime spec.  */
              int skip;
              find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
-                                   VALUE_CONTENTS_ALL (*arg1p),
-                                   offset + VALUE_EMBEDDED_OFFSET (*arg1p),
+                                   value_contents_all (*arg1p),
+                                   offset + value_embedded_offset (*arg1p),
                                    &base_offset, &skip);
              if (skip >= 0)
                error ("Virtual base class offset not found in vtable");
@@ -1530,7 +1512,7 @@ search_struct_method (char *name, struct value **arg1p,
          else
            {
              struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
-             char *base_valaddr;
+             const bfd_byte *base_valaddr;
 
              /* The virtual base class pointer might have been clobbered by the
                 user program. Make sure that it still points to a valid memory
@@ -1538,20 +1520,20 @@ search_struct_method (char *name, struct value **arg1p,
 
              if (offset < 0 || offset >= TYPE_LENGTH (type))
                {
-                 base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
+                 bfd_byte *tmp = alloca (TYPE_LENGTH (baseclass));
                  if (target_read_memory (VALUE_ADDRESS (*arg1p)
-                                         + VALUE_OFFSET (*arg1p) + offset,
-                                         base_valaddr,
-                                         TYPE_LENGTH (baseclass)) != 0)
+                                         + value_offset (*arg1p) + offset,
+                                         tmp, TYPE_LENGTH (baseclass)) != 0)
                    error ("virtual baseclass botch");
+                 base_valaddr = tmp;
                }
              else
-               base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
+               base_valaddr = value_contents (*arg1p) + offset;
 
              base_offset =
                baseclass_offset (type, i, base_valaddr,
                                  VALUE_ADDRESS (*arg1p)
-                                 + VALUE_OFFSET (*arg1p) + offset);
+                                 + value_offset (*arg1p) + offset);
              if (base_offset == -1)
                error ("virtual baseclass botch");
            }
@@ -1600,9 +1582,9 @@ value_struct_elt (struct value **argp, struct value **args,
   struct type *t;
   struct value *v;
 
-  COERCE_ARRAY (*argp);
+  *argp = coerce_array (*argp);
 
-  t = check_typedef (VALUE_TYPE (*argp));
+  t = check_typedef (value_type (*argp));
 
   /* Follow pointers until we get to a non-pointer.  */
 
@@ -1610,9 +1592,9 @@ value_struct_elt (struct value **argp, struct value **args,
     {
       *argp = value_ind (*argp);
       /* Don't coerce fn pointer to fn and then back again!  */
-      if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
-       COERCE_ARRAY (*argp);
-      t = check_typedef (VALUE_TYPE (*argp));
+      if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
+       *argp = coerce_array (*argp);
+      t = check_typedef (value_type (*argp));
     }
 
   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
@@ -1755,8 +1737,8 @@ find_method_list (struct value **argp, char *method, int offset,
               * according to HP/Taligent runtime spec.  */
              int skip;
              find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
-                                   VALUE_CONTENTS_ALL (*argp),
-                                   offset + VALUE_EMBEDDED_OFFSET (*argp),
+                                   value_contents_all (*argp),
+                                   offset + value_embedded_offset (*argp),
                                    &base_offset, &skip);
              if (skip >= 0)
                error ("Virtual base class offset not found in vtable");
@@ -1764,10 +1746,10 @@ find_method_list (struct value **argp, char *method, int offset,
          else
            {
              /* probably g++ runtime model */
-             base_offset = VALUE_OFFSET (*argp) + offset;
+             base_offset = value_offset (*argp) + offset;
              base_offset =
                baseclass_offset (type, i,
-                                 VALUE_CONTENTS (*argp) + base_offset,
+                                 value_contents (*argp) + base_offset,
                                  VALUE_ADDRESS (*argp) + base_offset);
              if (base_offset == -1)
                error ("virtual baseclass botch");
@@ -1802,16 +1784,16 @@ value_find_oload_method_list (struct value **argp, char *method, int offset,
 {
   struct type *t;
 
-  t = check_typedef (VALUE_TYPE (*argp));
+  t = check_typedef (value_type (*argp));
 
   /* code snarfed from value_struct_elt */
   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
     {
       *argp = value_ind (*argp);
       /* Don't coerce fn pointer to fn and then back again!  */
-      if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
-       COERCE_ARRAY (*argp);
-      t = check_typedef (VALUE_TYPE (*argp));
+      if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
+       *argp = coerce_array (*argp);
+      t = check_typedef (value_type (*argp));
     }
 
   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
@@ -1880,12 +1862,12 @@ find_overload_match (struct type **arg_types, int nargs, char *name, int method,
   /* Get the list of overloaded methods or functions */
   if (method)
     {
-      obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
+      obj_type_name = TYPE_NAME (value_type (obj));
       /* Hack: evaluate_subexp_standard often passes in a pointer
          value rather than the object itself, so try again */
       if ((!obj_type_name || !*obj_type_name) &&
-         (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
-       obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
+         (TYPE_CODE (value_type (obj)) == TYPE_CODE_PTR))
+       obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj)));
 
       fns_ptr = value_find_oload_method_list (&temp, name, 0,
                                              &num_fns,
@@ -1972,8 +1954,8 @@ find_overload_match (struct type **arg_types, int nargs, char *name, int method,
 
   if (objp)
     {
-      if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
-         && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
+      if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR
+         && TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR)
        {
          temp = value_addr (temp);
        }
@@ -2331,9 +2313,9 @@ check_field (struct value *arg1, const char *name)
 {
   struct type *t;
 
-  COERCE_ARRAY (arg1);
+  arg1 = coerce_array (arg1);
 
-  t = VALUE_TYPE (arg1);
+  t = value_type (arg1);
 
   /* Follow pointers until we get to a non-pointer.  */
 
@@ -2618,7 +2600,7 @@ value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
     real_type = value_rtti_type (argp, &full, &top, &using_enc);
 
   /* If no RTTI data, or if object is already complete, do nothing */
-  if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
+  if (!real_type || real_type == value_enclosing_type (argp))
     return argp;
 
   /* If we have the full object, but for some reason the enclosing
@@ -2642,10 +2624,11 @@ value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
      adjusting for the embedded offset of argp if that's what value_rtti_type
      used for its computation. */
   new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
-                          (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
-                          VALUE_BFD_SECTION (argp));
-  VALUE_TYPE (new_val) = VALUE_TYPE (argp);
-  VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
+                          (using_enc ? 0 : value_embedded_offset (argp)));
+  new_val->type = value_type (argp);
+  set_value_embedded_offset (new_val, (using_enc
+                                      ? top + value_embedded_offset (argp)
+                                      : top));
   return new_val;
 }
 
@@ -2730,8 +2713,7 @@ value_slice (struct value *array, int lowbound, int length)
   LONGEST lowerbound, upperbound;
   struct value *slice;
   struct type *array_type;
-  array_type = check_typedef (VALUE_TYPE (array));
-  COERCE_VARYING_ARRAY (array, array_type);
+  array_type = check_typedef (value_type (array));
   if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
       && TYPE_CODE (array_type) != TYPE_CODE_STRING
       && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
@@ -2756,7 +2738,7 @@ value_slice (struct value *array, int lowbound, int length)
       for (i = 0; i < length; i++)
        {
          int element = value_bit_index (array_type,
-                                        VALUE_CONTENTS (array),
+                                        value_contents (array),
                                         lowbound + i);
          if (element < 0)
            error ("internal error accessing bitstring");
@@ -2765,7 +2747,7 @@ value_slice (struct value *array, int lowbound, int length)
              int j = i % TARGET_CHAR_BIT;
              if (BITS_BIG_ENDIAN)
                j = TARGET_CHAR_BIT - 1 - j;
-             VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
+             value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
            }
        }
       /* We should set the address, bitssize, and bitspos, so the clice
@@ -2781,17 +2763,19 @@ value_slice (struct value *array, int lowbound, int length)
                                      slice_range_type);
       TYPE_CODE (slice_type) = TYPE_CODE (array_type);
       slice = allocate_value (slice_type);
-      if (VALUE_LAZY (array))
-       VALUE_LAZY (slice) = 1;
+      if (value_lazy (array))
+       set_value_lazy (slice, 1);
       else
-       memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
+       memcpy (value_contents_writeable (slice),
+               value_contents (array) + offset,
                TYPE_LENGTH (slice_type));
       if (VALUE_LVAL (array) == lval_internalvar)
        VALUE_LVAL (slice) = lval_internalvar_component;
       else
        VALUE_LVAL (slice) = VALUE_LVAL (array);
       VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
-      VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
+      VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
+      slice->offset = value_offset (array) + offset;
     }
   return slice;
 }
@@ -2812,10 +2796,10 @@ value_literal_complex (struct value *arg1, struct value *arg2, struct type *type
   arg1 = value_cast (real_type, arg1);
   arg2 = value_cast (real_type, arg2);
 
-  memcpy (VALUE_CONTENTS_RAW (val),
-         VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
-  memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
-         VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
+  memcpy (value_contents_raw (val),
+         value_contents (arg1), TYPE_LENGTH (real_type));
+  memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
+         value_contents (arg2), TYPE_LENGTH (real_type));
   return val;
 }
 
@@ -2825,22 +2809,22 @@ static struct value *
 cast_into_complex (struct type *type, struct value *val)
 {
   struct type *real_type = TYPE_TARGET_TYPE (type);
-  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
+  if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
     {
-      struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
+      struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
       struct value *re_val = allocate_value (val_real_type);
       struct value *im_val = allocate_value (val_real_type);
 
-      memcpy (VALUE_CONTENTS_RAW (re_val),
-             VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
-      memcpy (VALUE_CONTENTS_RAW (im_val),
-             VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
+      memcpy (value_contents_raw (re_val),
+             value_contents (val), TYPE_LENGTH (val_real_type));
+      memcpy (value_contents_raw (im_val),
+             value_contents (val) + TYPE_LENGTH (val_real_type),
              TYPE_LENGTH (val_real_type));
 
       return value_literal_complex (re_val, im_val, type);
     }
-  else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
-          || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
+  else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
+          || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
     return value_literal_complex (val, value_zero (real_type, not_lval), type);
   else
     error ("cannot cast non-number to complex");
This page took 0.040462 seconds and 4 git commands to generate.