*** empty log message ***

[binutils-gdb.git] / gdb / value.c

diff --git a/gdb/value.c b/gdb/value.c
index 589e03b14964df01e5387c090316b9c819067f0b..ec33403fbe334fa25a21485af4a31d534e06718b 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2,7 +2,7 @@
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
    1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-   2009 Free Software Foundation, Inc.
+   2009, 2010 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -254,7 +254,14 @@ struct value *
 allocate_value_lazy (struct type *type)
 {
   struct value *val;
-  struct type *atype = check_typedef (type);
+
+  /* Call check_typedef on our type to make sure that, if TYPE
+     is a TYPE_CODE_TYPEDEF, its length is set to the length
+     of the target type instead of zero.  However, we do not
+     replace the typedef type by the target type, because we want
+     to keep the typedef in order to be able to set the VAL's type
+     description correctly.  */
+  check_typedef (type);
 
   val = (struct value *) xzalloc (sizeof (struct value));
   val->contents = NULL;
@@ -297,6 +304,7 @@ struct value *
 allocate_value (struct type *type)
 {
   struct value *val = allocate_value_lazy (type);
+
   allocate_value_contents (val);
   val->lazy = 0;
   return val;
@@ -313,6 +321,7 @@ allocate_repeat_value (struct type *type, int count)
      done with it.  */
   struct type *array_type
     = lookup_array_range_type (type, low_bound, count + low_bound - 1);
+
   return allocate_value (array_type);
 }
 
@@ -322,6 +331,7 @@ allocate_computed_value (struct type *type,
                          void *closure)
 {
   struct value *v = allocate_value (type);
+
   VALUE_LVAL (v) = lval_computed;
   v->location.computed.funcs = funcs;
   v->location.computed.closure = closure;
@@ -810,7 +820,8 @@ record_latest_value (struct value *val)
   if (i == 0)
     {
       struct value_history_chunk *new
-      = (struct value_history_chunk *)
+       = (struct value_history_chunk *)
+
       xmalloc (sizeof (struct value_history_chunk));
       memset (new->values, 0, sizeof new->values);
       new->next = value_history_chain;
@@ -887,6 +898,7 @@ show_values (char *num_exp, int from_tty)
   for (i = num; i < num + 10 && i <= value_history_count; i++)
     {
       struct value_print_options opts;
+
       val = access_value_history (i);
       printf_filtered (("$%d = "), i);
       get_user_print_options (&opts);
@@ -1047,6 +1059,7 @@ struct internalvar *
 create_internalvar (const char *name)
 {
   struct internalvar *var;
+
   var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
   var->name = concat (name, (char *)NULL);
   var->kind = INTERNALVAR_VOID;
@@ -1064,6 +1077,7 @@ struct internalvar *
 create_internalvar_type_lazy (char *name, internalvar_make_value fun)
 {
   struct internalvar *var = create_internalvar (name);
+
   var->kind = INTERNALVAR_MAKE_VALUE;
   var->u.make_value = fun;
   return var;
@@ -1347,6 +1361,7 @@ create_internal_function (const char *name,
                          internal_function_fn handler, void *cookie)
 {
   struct internal_function *ifn = XNEW (struct internal_function);
+
   ifn->name = xstrdup (name);
   ifn->handler = handler;
   ifn->cookie = cookie;
@@ -1474,7 +1489,6 @@ preserve_values (struct objfile *objfile)
   htab_t copied_types;
   struct value_history_chunk *cur;
   struct internalvar *var;
-  struct value *val;
   int i;
 
   /* Create the hash table.  We allocate on the objfile's obstack, since
@@ -1806,24 +1820,28 @@ value_static_field (struct type *type, int fieldno)
 
   if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR)
     {
-      retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
-                        TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
+      retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
+                             TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
     }
   else
     {
       char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
+      /*TYPE_FIELD_NAME (type, fieldno);*/
       struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+
       if (sym == NULL)
        {
-         /* With some compilers, e.g. HP aCC, static data members are reported
-            as non-debuggable symbols */
-         struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL);
+         /* With some compilers, e.g. HP aCC, static data members are
+            reported as non-debuggable symbols */
+         struct minimal_symbol *msym = lookup_minimal_symbol (phys_name,
+                                                              NULL, NULL);
+
          if (!msym)
            return NULL;
          else
            {
-             retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
-                                SYMBOL_VALUE_ADDRESS (msym));
+             retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
+                                     SYMBOL_VALUE_ADDRESS (msym));
            }
        }
       else
@@ -1874,6 +1892,14 @@ value_primitive_field (struct value *arg1, int offset,
   CHECK_TYPEDEF (arg_type);
   type = TYPE_FIELD_TYPE (arg_type, fieldno);
 
+  /* Call check_typedef on our type to make sure that, if TYPE
+     is a TYPE_CODE_TYPEDEF, its length is set to the length
+     of the target type instead of zero.  However, we do not
+     replace the typedef type by the target type, because we want
+     to keep the typedef in order to be able to print the type
+     description correctly.  */
+  check_typedef (type);
+
   /* Handle packed fields */
 
   if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
@@ -2185,7 +2211,6 @@ value_from_longest (struct type *type, LONGEST num)
   struct value *val = allocate_value (type);
 
   pack_long (value_contents_raw (val), type, num);
-
   return val;
 }
 
@@ -2196,6 +2221,7 @@ struct value *
 value_from_pointer (struct type *type, CORE_ADDR addr)
 {
   struct value *val = allocate_value (type);
+
   store_typed_address (value_contents_raw (val), check_typedef (type), addr);
   return val;
 }
@@ -2211,6 +2237,7 @@ value_from_contents_and_address (struct type *type,
                                 CORE_ADDR address)
 {
   struct value *v = allocate_value (type);
+
   if (valaddr == NULL)
     set_value_lazy (v, 1);
   else
@@ -2226,7 +2253,6 @@ value_from_double (struct type *type, DOUBLEST num)
   struct value *val = allocate_value (type);
   struct type *base_type = check_typedef (type);
   enum type_code code = TYPE_CODE (base_type);
-  int len = TYPE_LENGTH (base_type);
 
   if (code == TYPE_CODE_FLT)
     {
@@ -2244,7 +2270,6 @@ value_from_decfloat (struct type *type, const gdb_byte *dec)
   struct value *val = allocate_value (type);
 
   memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type));
-
   return val;
 }
 
@@ -2252,6 +2277,7 @@ struct value *
 coerce_ref (struct value *arg)
 {
   struct type *value_type_arg_tmp = check_typedef (value_type (arg));
+
   if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF)
     arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
                         unpack_pointer (value_type (arg),