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

	* value.h (value_embedded_offset): Delete.
	(value_embedded_offset): Declare.
	* value.c (value_embedded_offset): Define.
	* valops.c, p-valprint.c, mi/mi-main.c, hpacc-abi.c: Update.
	* gnu-v3-abi.c, eval.c, c-valprint.c, cp-valprint.c: Update.
	* cp-abi.h: Update.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b2920e8ca77a3e931a38719808081802218292e5..6eaeb47d8d4a1df3fc69637838decb25d512afa3 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,12 @@
 2005-02-07  Andrew Cagney  <cagney@gnu.org>
 
+       * value.h (value_embedded_offset): Delete.
+       (value_embedded_offset): Declare.
+       * value.c (value_embedded_offset): Define.
+       * valops.c, p-valprint.c, mi/mi-main.c, hpacc-abi.c: Update.
+       * gnu-v3-abi.c, eval.c, c-valprint.c, cp-valprint.c: Update.
+       * cp-abi.h: Update.
+
        * value.h (VALUE_LAZY): Delete
        (set_value_lazy): Declare.
        * value.c (set_value_lazy): Define.

diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 64f0f42537964bfa40cc8a8b89a01c07ac4ce1d1..a18ef0ff685af564464d32fcd1ad9b441b0ebb73 100644 (file)
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -598,7 +598,7 @@ c_value_print (struct value *val, struct ui_file *stream, int format,
     }
 
   return val_print (type, value_contents_all (val),
-                   VALUE_EMBEDDED_OFFSET (val),
+                   value_embedded_offset (val),
                    VALUE_ADDRESS (val) + value_offset (val),
                    stream, format, 1, 0, pretty);
 }

diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h
index cf21a2f4cde8bbe400b1ba2436f71321e43562a3..cce41f0c372afedd7280373bd3abce76405a4135 100644 (file)
--- a/gdb/cp-abi.h
+++ b/gdb/cp-abi.h
@@ -123,7 +123,7 @@ extern struct value *value_virtual_fn_field (struct value **valuep,
        of the complete object to the start of the embedded subobject
        VALUE represents.  In other words, the enclosing object starts
        at VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) +
-       VALUE_EMBEDDED_OFFSET (VALUE) + *TOP
+       value_embedded_offset (VALUE) + *TOP
      - If *USING_ENC is non-zero, then *TOP is the offset from the
        address of the complete object to the enclosing object stored
        in VALUE.  In other words, the enclosing object starts at

diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index 8624e25b69deeaf9b8ccdb9cac1e9de7b9071b68..42a07fc4dbbc49288b731f77729cb7b92ae89d14 100644 (file)
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -665,12 +665,12 @@ cp_print_static_field (struct type *type,
 
       CHECK_TYPEDEF (type);
       cp_print_value_fields (type, type, value_contents_all (val),
-                            VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
+                            value_embedded_offset (val), VALUE_ADDRESS (val),
                             stream, format, recurse, pretty, NULL, 1);
       return;
     }
   val_print (type, value_contents_all (val), 
-            VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
+            value_embedded_offset (val), VALUE_ADDRESS (val),
             stream, format, 0, recurse, pretty);
 }
 

diff --git a/gdb/eval.c b/gdb/eval.c
index 0bcfdf6b9468af716b283f175a26c8d4845f7ae6..79a8ffd329ec4533ae63d1f56cb7c82f023aa7af 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1148,7 +1148,7 @@ evaluate_subexp_standard (struct type *expect_type,
                 reflect any ``this'' changes.  */
              arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
                                         VALUE_ADDRESS (temp) + value_offset (temp)
-                                        + VALUE_EMBEDDED_OFFSET (temp));
+                                        + value_embedded_offset (temp));
              argvec[1] = arg2; /* the ``this'' pointer */
            }
 

diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 12eea1b6189fc514153859cdfb7d01f8f7ba371b..f03ecbab5734362872c0729ad97183030079de9f 100644 (file)
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -232,7 +232,7 @@ gnuv3_rtti_type (struct value *value,
   vtable_symbol
     = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
                                    + value_offset (vtable)
-                                   + VALUE_EMBEDDED_OFFSET (vtable));
+                                   + value_embedded_offset (vtable));
   if (! vtable_symbol)
     return NULL;
   
@@ -265,7 +265,7 @@ gnuv3_rtti_type (struct value *value,
     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 
   if (full_p)
-    *full_p = (- offset_to_top == VALUE_EMBEDDED_OFFSET (value)
+    *full_p = (- offset_to_top == value_embedded_offset (value)
                && (TYPE_LENGTH (value_enclosing_type (value))
                    >= TYPE_LENGTH (run_time_type)));
   if (top_p)

diff --git a/gdb/hpacc-abi.c b/gdb/hpacc-abi.c
index ff1d29db1b841a4ed701db710995d0e9b569e62d..9f86c1532dbd6f96358678d4909b37d7bec92e3f 100644 (file)
--- a/gdb/hpacc-abi.c
+++ b/gdb/hpacc-abi.c
@@ -104,7 +104,7 @@ hpacc_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
   /* pai: FIXME -- 32x64 possible problem? */
   /* First word (4 bytes) in object layout is the vtable pointer */
   coreptr = *(CORE_ADDR *) (value_contents (argp));    /* pai: (temp)  */
-  /* + offset + VALUE_EMBEDDED_OFFSET (argp)); */
+  /* + offset + value_embedded_offset (argp)); */
 
   if (!coreptr)
     error
@@ -223,7 +223,7 @@ hpacc_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
                             + value_offset (v)
                             + (using_enclosing
                                ? 0
-                               : VALUE_EMBEDDED_OFFSET (v)));
+                               : value_embedded_offset (v)));
   if (coreptr == 0)
     /* return silently -- maybe called on gdb-generated value */
     return NULL;
@@ -278,7 +278,7 @@ hpacc_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
        ||
        /* Or we checked on the embedded object and top offset was the
           same as the embedded offset */
-       ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
+       ((top_offset == value_embedded_offset (v)) &&
         !using_enclosing &&
         TYPE_LENGTH (value_enclosing_type (v)) == TYPE_LENGTH (rtti_type))))
 

diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 8afd2624f5ea56ad49d159bbe5f68e1df7be2cfc..cbfd2fed445b4c6be30cb1637f6524e78740a513 100644 (file)
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -680,7 +680,7 @@ mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
 
   /* Print the result of the expression evaluation. */
   val_print (value_type (val), value_contents (val),
-            VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
+            value_embedded_offset (val), VALUE_ADDRESS (val),
             stb->stream, 0, 0, 0, 0);
 
   ui_out_field_stream (uiout, "value", stb);

diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index f3a949676a9434ef64e317e54c097effd0314bb1..5291e4eb55d427b590eb520db4b666515823e21c 100644 (file)
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -565,7 +565,7 @@ pascal_value_print (struct value *val, struct ui_file *stream, int format,
          fprintf_filtered (stream, ") ");
        }
     }
-  return val_print (type, value_contents (val), VALUE_EMBEDDED_OFFSET (val),
+  return val_print (type, value_contents (val), value_embedded_offset (val),
                    VALUE_ADDRESS (val) + value_offset (val),
                    stream, format, 1, 0, pretty);
 }

diff --git a/gdb/valops.c b/gdb/valops.c
index 8aa44133299b4aa517a26ea07cb25cd595eb5131..502cfa647cdfe9e858a9d71a5f24e3ffc6ffa7c8 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -398,7 +398,7 @@ 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_embedded_offset (v));
                       return value_from_pointer (type, addr2);
                    }
                }
@@ -544,7 +544,7 @@ value_assign (struct value *toval, struct value *fromval)
       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);
+      set_value_embedded_offset (val, value_embedded_offset (fromval));
       VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
       return val;
 
@@ -732,7 +732,7 @@ value_assign (struct value *toval, struct value *fromval)
          TYPE_LENGTH (type));
   val->type = type;
   val = value_change_enclosing_type (val, value_enclosing_type (fromval));
-  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
+  set_value_embedded_offset (val, value_embedded_offset (fromval));
   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 
   return val;
@@ -868,13 +868,13 @@ value_addr (struct value *arg1)
   arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
                             (VALUE_ADDRESS (arg1)
                              + value_offset (arg1)
-                             + VALUE_EMBEDDED_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)));
   /* ... and also the relative position of the subobject in the full object */
-  VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
+  VALUE_POINTED_TO_OFFSET (arg2) = value_embedded_offset (arg1);
   return arg2;
 }
 
@@ -914,7 +914,7 @@ value_ind (struct value *arg1)
       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);
@@ -1504,7 +1504,7 @@ search_struct_method (char *name, struct value **arg1p,
              int skip;
              find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
                                    value_contents_all (*arg1p),
-                                   offset + VALUE_EMBEDDED_OFFSET (*arg1p),
+                                   offset + value_embedded_offset (*arg1p),
                                    &base_offset, &skip);
              if (skip >= 0)
                error ("Virtual base class offset not found in vtable");
@@ -1738,7 +1738,7 @@ find_method_list (struct value **argp, char *method, int offset,
              int skip;
              find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
                                    value_contents_all (*argp),
-                                   offset + VALUE_EMBEDDED_OFFSET (*argp),
+                                   offset + value_embedded_offset (*argp),
                                    &base_offset, &skip);
              if (skip >= 0)
                error ("Virtual base class offset not found in vtable");
@@ -2624,9 +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)));
+                          (using_enc ? 0 : value_embedded_offset (argp)));
   new_val->type = value_type (argp);
-  VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
+  set_value_embedded_offset (new_val, (using_enc
+                                      ? top + value_embedded_offset (argp)
+                                      : top));
   return new_val;
 }
 

diff --git a/gdb/value.c b/gdb/value.c
index 0006a40eedbec492cb61766785e540bbdfbf9259..11cc4bc20c06b77500e313e668fcd038dd148276 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -97,7 +97,7 @@ allocate_value (struct type *type)
   VALUE_REGNUM (val) = -1;
   val->lazy = 0;
   val->optimized_out = 0;
-  VALUE_EMBEDDED_OFFSET (val) = 0;
+  val->embedded_offset = 0;
   VALUE_POINTED_TO_OFFSET (val) = 0;
   val->modifiable = 1;
   return val;
@@ -210,6 +210,18 @@ set_value_optimized_out (struct value *value, int val)
 {
   value->optimized_out = val;
 }
+
+int
+value_embedded_offset (struct value *value)
+{
+  return value->embedded_offset;
+}
+
+void
+set_value_embedded_offset (struct value *value, int val)
+{
+  value->embedded_offset = val;
+}
 \f
 /* Return a mark in the value chain.  All values allocated after the
    mark is obtained (except for those released) are subject to being freed
@@ -315,7 +327,7 @@ value_copy (struct value *arg)
   VALUE_REGNUM (val) = VALUE_REGNUM (arg);
   val->lazy = arg->lazy;
   val->optimized_out = arg->optimized_out;
-  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (arg);
+  val->embedded_offset = value_embedded_offset (arg);
   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (arg);
   val->modifiable = arg->modifiable;
   if (!value_lazy (val))
@@ -1005,10 +1017,8 @@ value_primitive_field (struct value *arg1, int offset,
        memcpy (value_contents_all_raw (v), value_contents_all_raw (arg1),
                TYPE_LENGTH (value_enclosing_type (arg1)));
       v->offset = value_offset (arg1);
-      VALUE_EMBEDDED_OFFSET (v)
-       = offset +
-       VALUE_EMBEDDED_OFFSET (arg1) +
-       TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+      v->embedded_offset = (offset + value_embedded_offset (arg1)
+                           + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8);
     }
   else
     {
@@ -1022,7 +1032,7 @@ value_primitive_field (struct value *arg1, int offset,
                value_contents_raw (arg1) + offset,
                TYPE_LENGTH (type));
       v->offset = (value_offset (arg1) + offset
-                  + VALUE_EMBEDDED_OFFSET (arg1));
+                  + value_embedded_offset (arg1));
     }
   VALUE_LVAL (v) = VALUE_LVAL (arg1);
   if (VALUE_LVAL (arg1) == lval_internalvar)

diff --git a/gdb/value.h b/gdb/value.h
index ae17cd2c907afa047cfc5f0c9061568aee30bbce..914bc64875f67c6ae3c7a2587ce05c9087ff553e 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -215,7 +215,8 @@ extern int value_fetch_lazy (struct value *val);
 #define VALUE_REGNUM(val) (val)->regnum
 extern int value_optimized_out (struct value *value);
 extern void set_value_optimized_out (struct value *value, int val);
-#define VALUE_EMBEDDED_OFFSET(val) ((val)->embedded_offset)
+extern int value_embedded_offset (struct value *value);
+extern void set_value_embedded_offset (struct value *value, int val);
 #define VALUE_POINTED_TO_OFFSET(val) ((val)->pointed_to_offset)
 
 /* Convert a REF to the object referenced.  */