Turn value_bitsize into method

This changes value_bitsize to be a method of value.  Much of this patch
was written by script.

Approved-By: Simon Marchi <simon.marchi@efficios.com>

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index c5b5b14163b6f19663c9e6af196ff85f94b4065a..9cbbbb06db359407a6995027bb73a0bb6b224311 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -568,7 +568,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
          value_contents_copy (result, 0, val, 0, type->length ());
        }
       set_value_component_location (result, val);
-      set_value_bitsize (result, value_bitsize (val));
+      result->set_bitsize (val->bitsize ());
       set_value_bitpos (result, value_bitpos (val));
       if (VALUE_LVAL (result) == lval_memory)
        set_value_address (result, value_address (val));
@@ -2832,7 +2832,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
 
       set_value_component_location (v, obj);
       set_value_bitpos (v, bit_offset + value_bitpos (obj));
-      set_value_bitsize (v, bit_size);
+      v->set_bitsize (bit_size);
       if (value_bitpos (v) >= HOST_CHAR_BIT)
        {
          ++new_offset;
@@ -2845,7 +2845,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
       set_value_parent (v, obj);
     }
   else
-    set_value_bitsize (v, bit_size);
+    v->set_bitsize (bit_size);
   unpacked = value_contents_writeable (v).data ();
 
   if (bit_size == 0)
@@ -2878,7 +2878,7 @@ static struct value *
 ada_value_assign (struct value *toval, struct value *fromval)
 {
   struct type *type = toval->type ();
-  int bits = value_bitsize (toval);
+  int bits = toval->bitsize ();
 
   toval = ada_coerce_ref (toval);
   fromval = ada_coerce_ref (fromval);
@@ -2907,7 +2907,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
        fromval = value_cast (type, fromval);
 
       read_memory (to_addr, buffer, len);
-      from_size = value_bitsize (fromval);
+      from_size = fromval->bitsize ();
       if (from_size == 0)
        from_size = fromval->type ()->length () * TARGET_CHAR_BIT;
 
@@ -2956,10 +2956,10 @@ value_assign_to_component (struct value *container, struct value *component,
 
   val = value_cast (component->type (), val);
 
-  if (value_bitsize (component) == 0)
+  if (component->bitsize () == 0)
     bits = TARGET_CHAR_BIT * component->type ()->length ();
   else
-    bits = value_bitsize (component);
+    bits = component->bitsize ();
 
   if (type_byte_order (container->type ()) == BFD_ENDIAN_BIG)
     {

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index eaaef94f59e8c433f74e8aa73be72dd5006035d0..7245e8b5b4324d89e169375b9150bc43a8d6e1d5 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -2092,12 +2092,12 @@ update_watchpoint (struct watchpoint *b, bool reparse)
                  struct bp_location *loc, **tmp;
                  int bitpos = 0, bitsize = 0;
 
-                 if (value_bitsize (v) != 0)
+                 if (v->bitsize () != 0)
                    {
                      /* Extract the bit parameters out from the bitfield
                         sub-expression.  */
                      bitpos = value_bitpos (v);
-                     bitsize = value_bitsize (v);
+                     bitsize = v->bitsize ();
                    }
                  else if (v == result && b->val_bitsize != 0)
                    {
@@ -10199,7 +10199,7 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   if (val_as_value != NULL && just_location)
     {
       saved_bitpos = value_bitpos (val_as_value);
-      saved_bitsize = value_bitsize (val_as_value);
+      saved_bitsize = val_as_value->bitsize ();
     }
 
   value_ref_ptr val;

diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index 7310295db4d39f0ee00f84efab7481db6373a233..cbc20509cbe024d46e6b75e0f7e03068b872ce0f 100644 (file)
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -169,7 +169,7 @@ rw_pieced_value (value *v, value *from, bool check_optimized)
     }
 
   ULONGEST bits_to_skip = 8 * value_offset (v);
-  if (value_bitsize (v))
+  if (v->bitsize ())
     {
       bits_to_skip += (8 * value_offset (value_parent (v))
                       + value_bitpos (v));
@@ -179,10 +179,10 @@ rw_pieced_value (value *v, value *from, bool check_optimized)
        {
          /* Use the least significant bits of FROM.  */
          max_offset = 8 * from->type ()->length ();
-         offset = max_offset - value_bitsize (v);
+         offset = max_offset - v->bitsize ();
        }
       else
-       max_offset = value_bitsize (v);
+       max_offset = v->bitsize ();
     }
   else
     max_offset = 8 * v->type ()->length ();
@@ -467,7 +467,7 @@ check_pieced_synthetic_pointer (const value *value, LONGEST bit_offset,
   int i;
 
   bit_offset += 8 * value_offset (value);
-  if (value_bitsize (value))
+  if (value->bitsize ())
     bit_offset += value_bitpos (value);
 
   for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
@@ -513,7 +513,7 @@ indirect_pieced_value (value *value)
 
   int bit_length = 8 * type->length ();
   LONGEST bit_offset = 8 * value_offset (value);
-  if (value_bitsize (value))
+  if (value->bitsize ())
     bit_offset += value_bitpos (value);
 
   for (i = 0; i < c->pieces.size () && bit_length > 0; i++)

diff --git a/gdb/valops.c b/gdb/valops.c
index ae876b795d0aa1c293defd41c8f33080f035488a..2ad19eaf8c7718ab50de90eebd183b1bc0876316 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -1126,8 +1126,8 @@ value_assign (struct value *toval, struct value *fromval)
        /* Are we dealing with a bitfield?
 
           It is important to mention that `value_parent (toval)' is
-          non-NULL iff `value_bitsize (toval)' is non-zero.  */
-       if (value_bitsize (toval))
+          non-NULL iff `toval->bitsize ()' is non-zero.  */
+       if (toval->bitsize ())
          {
            /* VALUE_INTERNALVAR below refers to the parent value, while
               the offset is relative to this parent value.  */
@@ -1138,7 +1138,7 @@ value_assign (struct value *toval, struct value *fromval)
        set_internalvar_component (VALUE_INTERNALVAR (toval),
                                   offset,
                                   value_bitpos (toval),
-                                  value_bitsize (toval),
+                                  toval->bitsize (),
                                   fromval);
       }
       break;
@@ -1150,13 +1150,13 @@ value_assign (struct value *toval, struct value *fromval)
        int changed_len;
        gdb_byte buffer[sizeof (LONGEST)];
 
-       if (value_bitsize (toval))
+       if (toval->bitsize ())
          {
            struct value *parent = value_parent (toval);
 
            changed_addr = value_address (parent) + value_offset (toval);
            changed_len = (value_bitpos (toval)
-                          + value_bitsize (toval)
+                          + toval->bitsize ()
                           + HOST_CHAR_BIT - 1)
              / HOST_CHAR_BIT;
 
@@ -1176,7 +1176,7 @@ value_assign (struct value *toval, struct value *fromval)
 
            read_memory (changed_addr, buffer, changed_len);
            modify_field (type, buffer, value_as_long (fromval),
-                         value_bitpos (toval), value_bitsize (toval));
+                         value_bitpos (toval), toval->bitsize ());
            dest_buffer = buffer;
          }
        else
@@ -1213,7 +1213,7 @@ value_assign (struct value *toval, struct value *fromval)
 
        gdbarch = get_frame_arch (frame);
 
-       if (value_bitsize (toval))
+       if (toval->bitsize ())
          {
            struct value *parent = value_parent (toval);
            LONGEST offset = value_offset (parent) + value_offset (toval);
@@ -1222,7 +1222,7 @@ value_assign (struct value *toval, struct value *fromval)
            int optim, unavail;
 
            changed_len = (value_bitpos (toval)
-                          + value_bitsize (toval)
+                          + toval->bitsize ()
                           + HOST_CHAR_BIT - 1)
                          / HOST_CHAR_BIT;
 
@@ -1244,7 +1244,7 @@ value_assign (struct value *toval, struct value *fromval)
              }
 
            modify_field (type, buffer, value_as_long (fromval),
-                         value_bitpos (toval), value_bitsize (toval));
+                         value_bitpos (toval), toval->bitsize ());
 
            put_frame_register_bytes (frame, value_reg, offset,
                                      {buffer, changed_len});
@@ -1325,11 +1325,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 ((toval->bitsize () > 0)
+      && (toval->bitsize () < 8 * (int) sizeof (LONGEST)))
     {
       LONGEST fieldval = value_as_long (fromval);
-      LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
+      LONGEST valmask = (((ULONGEST) 1) << toval->bitsize ()) - 1;
 
       fieldval &= valmask;
       if (!type->is_unsigned () 

diff --git a/gdb/value.c b/gdb/value.c
index 8eb3cb203791df3a7c25d1e897cd3102a087c32a..2cdbd7eb93c249ab537e9ff7f371af5bb8a6647a 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1046,17 +1046,6 @@ set_value_bitpos (struct value *value, LONGEST bit)
   value->m_bitpos = bit;
 }
 
-LONGEST
-value_bitsize (const struct value *value)
-{
-  return value->m_bitsize;
-}
-void
-set_value_bitsize (struct value *value, LONGEST bit)
-{
-  value->m_bitsize = bit;
-}
-
 struct value *
 value_parent (const struct value *value)
 {
@@ -3940,7 +3929,7 @@ value_initialized (const struct value *val)
 static void
 value_fetch_lazy_bitfield (struct value *val)
 {
-  gdb_assert (value_bitsize (val) != 0);
+  gdb_assert (val->bitsize () != 0);
 
   /* To read a lazy bitfield, read the entire enclosing value.  This
      prevents reading the same block of (possibly volatile) memory once
@@ -3952,7 +3941,7 @@ value_fetch_lazy_bitfield (struct value *val)
   if (value_lazy (parent))
     value_fetch_lazy (parent);
 
-  unpack_value_bitfield (val, value_bitpos (val), value_bitsize (val),
+  unpack_value_bitfield (val, value_bitpos (val), val->bitsize (),
                         value_contents_for_printing (parent).data (),
                         value_offset (val), parent);
 }
@@ -4126,7 +4115,7 @@ value_fetch_lazy (struct value *val)
     {
       /* Nothing.  */
     }
-  else if (value_bitsize (val))
+  else if (val->bitsize ())
     value_fetch_lazy_bitfield (val);
   else if (VALUE_LVAL (val) == lval_memory)
     value_fetch_lazy_memory (val);

diff --git a/gdb/value.h b/gdb/value.h
index 66297e455b94339a07ecedb929db6b17aa320391..c18e28e4f7d0b417bc0ee3adaaf2a7eb45045032 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -173,6 +173,13 @@ struct value
   /* Return the gdbarch associated with the value. */
   struct gdbarch *arch () const;
 
+  /* Only used for bitfields; number of bits contained in them.  */
+  LONGEST bitsize () const
+  { return m_bitsize; }
+
+  void set_bitsize (LONGEST bit)
+  { m_bitsize = bit; }
+
 
   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */
@@ -351,11 +358,6 @@ struct value
   ULONGEST m_limited_length = 0;
 };
 
-/* Only used for bitfields; number of bits contained in them.  */
-
-extern LONGEST value_bitsize (const struct value *);
-extern void set_value_bitsize (struct value *, LONGEST bit);
-
 /* Only used for bitfields; position of start of field.  For
    little-endian targets, it is the position of the LSB.  For
    big-endian targets, it is the position of the MSB.  */