[1/2] FYI: shrink struct value

[Tom Tromey <tromey at redhat dot com>]

I'm checking this in on the trunk.

struct value is needlessly big; but also various boolean fields are
typed inconsistently.  This shrinks the struct a little (from 152 bytes
to 136 bytes on x86-64) and turns the boolean fields into unsigned bit
fields.

This is just a minor cleanup for the next patch.

Tom

2011-12-22  Tom Tromey  <tromey@redhat.com>

	* value.c (struct value) <modifiable, lazy, optimized_out,
	initialized, stack>: Now bitfields.  Move to top.
	<reference_count>: Move earlier.

>From b288ea904f3277574bd88cbc8f5f0ad4e2dc8272 Mon Sep 17 00:00:00 2001
From: Tom Tromey <tromey@redhat.com>
Date: Wed, 23 Nov 2011 13:43:20 -0700
Subject: [PATCH 1/2] shrink struct value

---
 gdb/ChangeLog |    6 ++++
 gdb/value.c   |   73 +++++++++++++++++++++++++++++---------------------------
 2 files changed, 44 insertions(+), 35 deletions(-)

diff --git a/gdb/value.c b/gdb/value.c
index d263d0c..b0aa415 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -169,6 +169,9 @@ ranges_contain (VEC(range_s) *ranges, int offset, int length)
 
 static struct cmd_list_element *functionlist;
 
+/* Note that the fields in this structure are arranged to save a bit
+   of memory.  */
+
 struct value
 {
   /* Type of value; either not an lval, or one of the various
@@ -176,7 +179,34 @@ struct value
   enum lval_type lval;
 
   /* Is it modifiable?  Only relevant if lval != not_lval.  */
-  int modifiable;
+  unsigned int modifiable : 1;
+
+  /* If zero, contents of this value are in the contents field.  If
+     nonzero, contents are in inferior.  If the lval field is lval_memory,
+     the contents are in inferior memory at location.address plus offset.
+     The lval field may also be lval_register.
+
+     WARNING: This field is used by the code which handles watchpoints
+     (see breakpoint.c) to decide whether a particular value can be
+     watched by hardware watchpoints.  If the lazy flag is set for
+     some member of a value chain, it is assumed that this member of
+     the chain doesn't need to be watched as part of watching the
+     value itself.  This is how GDB avoids watching the entire struct
+     or array when the user wants to watch a single struct member or
+     array element.  If you ever change the way lazy flag is set and
+     reset, be sure to consider this use as well!  */
+  unsigned int lazy : 1;
+
+  /* If nonzero, this is the value of a variable which does not
+     actually exist in the program.  */
+  unsigned int optimized_out : 1;
+
+  /* If value is a variable, is it initialized or not.  */
+  unsigned int initialized : 1;
+
+  /* If value is from the stack.  If this is set, read_stack will be
+     used instead of read_memory to enable extra caching.  */
+  unsigned int stack : 1;
 
   /* Location of value (if lval).  */
   union
@@ -217,6 +247,13 @@ struct value
      gdbarch_bits_big_endian=1 targets, it is the position of the MSB.  */
   int bitpos;
 
+  /* The number of references to this value.  When a value is created,
+     the value chain holds a reference, so REFERENCE_COUNT is 1.  If
+     release_value is called, this value is removed from the chain but
+     the caller of release_value now has a reference to this value.
+     The caller must arrange for a call to value_free later.  */
+  int reference_count;
+
   /* Only used for bitfields; the containing value.  This allows a
      single read from the target when displaying multiple
      bitfields.  */
@@ -282,33 +319,6 @@ struct value
   /* Register number if the value is from a register.  */
   short regnum;
 
-  /* If zero, contents of this value are in the contents field.  If
-     nonzero, contents are in inferior.  If the lval field is lval_memory,
-     the contents are in inferior memory at location.address plus offset.
-     The lval field may also be lval_register.
-
-     WARNING: This field is used by the code which handles watchpoints
-     (see breakpoint.c) to decide whether a particular value can be
-     watched by hardware watchpoints.  If the lazy flag is set for
-     some member of a value chain, it is assumed that this member of
-     the chain doesn't need to be watched as part of watching the
-     value itself.  This is how GDB avoids watching the entire struct
-     or array when the user wants to watch a single struct member or
-     array element.  If you ever change the way lazy flag is set and
-     reset, be sure to consider this use as well!  */
-  char lazy;
-
-  /* If nonzero, this is the value of a variable which does not
-     actually exist in the program.  */
-  char optimized_out;
-
-  /* If value is a variable, is it initialized or not.  */
-  int initialized;
-
-  /* If value is from the stack.  If this is set, read_stack will be
-     used instead of read_memory to enable extra caching.  */
-  int stack;
-
   /* Actual contents of the value.  Target byte-order.  NULL or not
      valid if lazy is nonzero.  */
   gdb_byte *contents;
@@ -317,13 +327,6 @@ struct value
      rather than available, since the common and default case is for a
      value to be available.  This is filled in at value read time.  */
   VEC(range_s) *unavailable;
-
-  /* The number of references to this value.  When a value is created,
-     the value chain holds a reference, so REFERENCE_COUNT is 1.  If
-     release_value is called, this value is removed from the chain but
-     the caller of release_value now has a reference to this value.
-     The caller must arrange for a call to value_free later.  */
-  int reference_count;
 };
 
 int
-- 
1.7.6.4