diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index c5b5b14163b..9cbbbb06db3 100644
--- 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 3c099d185f3..edb685fc4d0 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -2084,12 +2084,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)
 		    {
@@ -10170,7 +10170,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 7310295db4d..cbc20509cbe 100644
--- 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 2d1db3cef83..cbc995295ed 100644
--- 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 96db14c99cc..963350a487c 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -916,17 +916,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)
 {
@@ -3776,7 +3765,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
@@ -3788,7 +3777,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);
 }
@@ -3949,7 +3938,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 31ec0b5c202..fed4d804f55 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -172,6 +172,13 @@ struct value
   /* Return the gdbarch associated with the value. */
   struct gdbarch *get_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.  */
@@ -339,11 +346,6 @@ struct value
   std::vector<range> m_optimized_out;
 };
 
-/* 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.  */
