2001-05-07 Daniel Berlin <dan@cgsoftware.com>

	Changes by Jim Ingham:

	* values.c (value_change_enclosing_type): New function.  If the
	new enclosing type is larger than the old one, we need to allocate
	more space.
	* value.h: Add value_change_enclosing_type prototype.
	* valops.c (value_cast): Use it.
	(value_assign): Use it.
	(value_addr): Use it.
	(value_ind): Use it.
	(value_full_object): Use it.

2001-05-07  Daniel Berlin  <dan@cgsoftware.com>

	* values.c (value_static_field): Handle static fields that have a constant value.

4 files changed, 80 insertions, 9 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 76dba30..57df488 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,21 @@
+2001-05-07  Daniel Berlin  <dan@cgsoftware.com>
+
+	Changes by Jim Ingham:
+	
+	* values.c (value_change_enclosing_type): New function.  If the
+	new enclosing type is larger than the old one, we need to allocate
+	more space.
+	* value.h: Add value_change_enclosing_type prototype.
+	* valops.c (value_cast): Use it.
+	(value_assign): Use it.
+	(value_addr): Use it.
+	(value_ind): Use it.
+	(value_full_object): Use it.
+	
+2001-05-07  Daniel Berlin  <dan@cgsoftware.com>
+
+	* values.c (value_static_field): Handle static fields that have a constant value.
+
 2001-05-17  Michael Snyder  <msnyder@redhat.com>
 
 	* blockframe.c (create_new_frame): Zero all the fields via memset,
diff --git a/gdb/valops.c b/gdb/valops.c
index 0e7e7e1..7cc025d 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -365,7 +365,7 @@ value_cast (struct type *type, register value_ptr arg2)
 	  /* No superclass found, just fall through to change ptr type.  */
 	}
       VALUE_TYPE (arg2) = type;
-      VALUE_ENCLOSING_TYPE (arg2) = type;	/* pai: chk_val */
+      arg2 = value_change_enclosing_type (arg2, type);
       VALUE_POINTED_TO_OFFSET (arg2) = 0;	/* pai: chk_val */
       return arg2;
     }
@@ -609,7 +609,7 @@ value_assign (register value_ptr toval, register value_ptr fromval)
     case lval_internalvar:
       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
       val = value_copy (VALUE_INTERNALVAR (toval)->value);
-      VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
+      val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
       VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
       VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
       return val;
@@ -823,7 +823,7 @@ value_assign (register value_ptr toval, register value_ptr fromval)
   memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
 	  TYPE_LENGTH (type));
   VALUE_TYPE (val) = type;
-  VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
+  val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
   VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 
@@ -965,7 +965,7 @@ value_addr (value_ptr arg1)
 
   /* This may be a pointer to a base subobject; so remember the
      full derived object's type ... */
-  VALUE_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);
@@ -1009,7 +1009,7 @@ value_ind (value_ptr arg1)
       /* Re-adjust type */
       VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
       /* Add embedding info */
-      VALUE_ENCLOSING_TYPE (arg2) = enc_type;
+      arg2 = value_change_enclosing_type (arg2, enc_type);
       VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
 
       /* We may be pointing to an object of some derived type */
@@ -3165,7 +3165,7 @@ value_full_object (value_ptr argp, struct type *rtype, int xfull, int xtop,
      type is wrong, set it *//* pai: FIXME -- sounds iffy */
   if (full)
     {
-      VALUE_ENCLOSING_TYPE (argp) = real_type;
+      argp = value_change_enclosing_type (argp, real_type);
       return argp;
     }
 
diff --git a/gdb/value.h b/gdb/value.h
index 50abe0e..cc1d90f 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -307,6 +307,8 @@ extern value_ptr allocate_value (struct type *type);
 
 extern value_ptr allocate_repeat_value (struct type *type, int count);
 
+extern value_ptr value_change_enclosing_type (value_ptr val, struct type *new_type);
+
 extern value_ptr value_mark (void);
 
 extern void value_free_to_mark (value_ptr mark);
diff --git a/gdb/values.c b/gdb/values.c
index 8a93be9..8336233 100644
--- a/gdb/values.c
+++ b/gdb/values.c
@@ -762,14 +762,65 @@ value_static_field (struct type *type, int fieldno)
 	}
       else
 	{
-	  addr = SYMBOL_VALUE_ADDRESS (sym);
-	  sect = SYMBOL_BFD_SECTION (sym);
-	}
+ 	  /* Anything static that isn't a constant, has an address */
+ 	  if (SYMBOL_CLASS (sym) != LOC_CONST)
+ 	    {
+	      addr = SYMBOL_VALUE_ADDRESS (sym);
+	      sect = SYMBOL_BFD_SECTION (sym);
+	    }
+ 	  /* However, static const's do not, the value is already known.  */
+ 	  else
+ 	    {
+ 	      return value_from_longest (TYPE_FIELD_TYPE (type, fieldno), SYMBOL_VALUE (sym));
+ 	    }
+ 	}
       SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), addr);
     }
   return value_at (TYPE_FIELD_TYPE (type, fieldno), addr, sect);
 }
 
+/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.  
+   You have to be careful here, since the size of the data area for the value 
+   is set by the length of the enclosing type.  So if NEW_ENCL_TYPE is bigger 
+   than the old enclosing type, you have to allocate more space for the data.  
+   The return value is a pointer to the new version of this value structure. */
+
+value_ptr
+value_change_enclosing_type (value_ptr val, struct type *new_encl_type)
+{
+  if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))) 
+    {
+      VALUE_ENCLOSING_TYPE (val) = new_encl_type;
+      return val;
+    }
+  else
+    {
+      value_ptr new_val;
+      register value_ptr prev;
+      
+      new_val = (value_ptr) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type));
+      
+      /* We have to make sure this ends up in the same place in the value
+	 chain as the original copy, so it's clean-up behavior is the same. 
+	 If the value has been released, this is a waste of time, but there
+	 is no way to tell that in advance, so... */
+      
+      if (val != all_values) 
+	{
+	  for (prev = all_values; prev != NULL; prev = prev->next)
+	    {
+	      if (prev->next == val) 
+		{
+		  prev->next = new_val;
+		  break;
+		}
+	    }
+	}
+      
+      return new_val;
+    }
+}
+
 /* Given a value ARG1 (offset by OFFSET bytes)
    of a struct or union type ARG_TYPE,
    extract and return the value of one of its (non-static) fields.