* fork-child.c (fork_inferior): Only reset the thread list if this

[deliverable/binutils-gdb.git] / gdb / valops.c

diff --git a/gdb/valops.c b/gdb/valops.c
index c9fae8dc4e2c8152cc56e1259793aa7297dc27ca..a5bef37b338dfd5939747402fdec348892e7b8bb 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -2,7 +2,7 @@
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-   2008 Free Software Foundation, Inc.
+   2008, 2009 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -727,6 +727,8 @@ value_fetch_lazy (struct value *val)
         watchpoints from trying to watch the saved frame pointer.  */
       value_free_to_mark (mark);
     }
+  else if (VALUE_LVAL (val) == lval_computed)
+    value_computed_funcs (val)->read (val);
   else
     internal_error (__FILE__, __LINE__, "Unexpected lazy value type.");
 
@@ -895,7 +897,15 @@ value_assign (struct value *toval, struct value *fromval)
        observer_notify_target_changed (&current_target);
        break;
       }
-      
+
+    case lval_computed:
+      {
+       struct lval_funcs *funcs = value_computed_funcs (toval);
+
+       funcs->write (toval, fromval);
+      }
+      break;
+
     default:
       error (_("Left operand of assignment is not an lvalue."));
     }
@@ -988,11 +998,13 @@ struct value *
 value_of_variable (struct symbol *var, struct block *b)
 {
   struct value *val;
-  struct frame_info *frame = NULL;
+  struct frame_info *frame;
 
-  if (!b)
-    frame = NULL;              /* Use selected frame.  */
-  else if (symbol_read_needs_frame (var))
+  if (!symbol_read_needs_frame (var))
+    frame = NULL;
+  else if (!b)
+    frame = get_selected_frame (_("No frame selected."));
+  else
     {
       frame = block_innermost_frame (b);
       if (!frame)
@@ -1013,6 +1025,54 @@ value_of_variable (struct symbol *var, struct block *b)
   return val;
 }
 
+struct value *
+address_of_variable (struct symbol *var, struct block *b)
+{
+  struct type *type = SYMBOL_TYPE (var);
+  struct value *val;
+
+  /* Evaluate it first; if the result is a memory address, we're fine.
+     Lazy evaluation pays off here. */
+
+  val = value_of_variable (var, b);
+
+  if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
+      || TYPE_CODE (type) == TYPE_CODE_FUNC)
+    {
+      CORE_ADDR addr = VALUE_ADDRESS (val);
+      return value_from_pointer (lookup_pointer_type (type), addr);
+    }
+
+  /* Not a memory address; check what the problem was.  */
+  switch (VALUE_LVAL (val))
+    {
+    case lval_register:
+      {
+       struct frame_info *frame;
+       const char *regname;
+
+       frame = frame_find_by_id (VALUE_FRAME_ID (val));
+       gdb_assert (frame);
+
+       regname = gdbarch_register_name (get_frame_arch (frame),
+                                        VALUE_REGNUM (val));
+       gdb_assert (regname && *regname);
+
+       error (_("Address requested for identifier "
+                "\"%s\" which is in register $%s"),
+              SYMBOL_PRINT_NAME (var), regname);
+       break;
+      }
+
+    default:
+      error (_("Can't take address of \"%s\" which isn't an lvalue."),
+            SYMBOL_PRINT_NAME (var));
+      break;
+    }
+
+  return val;
+}
+
 /* Return one if VAL does not live in target memory, but should in order
    to operate on it.  Otherwise return zero.  */
 
@@ -1292,6 +1352,24 @@ value_array (int lowbound, int highbound, struct value **elemvec)
   return val;
 }
 
+struct value *
+value_typed_string (char *ptr, int len, struct type *char_type)
+{
+  struct value *val;
+  int lowbound = current_language->string_lower_bound;
+  int highbound = len / TYPE_LENGTH (char_type);
+  struct type *rangetype = create_range_type ((struct type *) NULL,
+                                             builtin_type_int32,
+                                             lowbound, 
+                                             highbound + lowbound - 1);
+  struct type *stringtype
+    = create_array_type ((struct type *) NULL, char_type, rangetype);
+
+  val = allocate_value (stringtype);
+  memcpy (value_contents_raw (val), ptr, len);
+  return val;
+}
+
 /* Create a value for a string constant by allocating space in the
    inferior, copying the data into that space, and returning the
    address with type TYPE_CODE_STRING.  PTR points to the string
@@ -1575,8 +1653,7 @@ search_struct_field (char *name, struct value *arg1, int offset,
                          value_contents_raw (arg1) + boffset,
                          TYPE_LENGTH (basetype));
                }
-             VALUE_LVAL (v2) = VALUE_LVAL (arg1);
-             VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
+             set_value_component_location (v2, arg1);
              VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
              set_value_offset (v2, value_offset (arg1) + boffset);
            }
@@ -2124,9 +2201,11 @@ find_overload_match (struct type **arg_types, int nargs,
 
   if (objp)
     {
-      if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR
-         && (TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR
-             || TYPE_CODE (value_type (*objp)) == TYPE_CODE_REF))
+      struct type *temp_type = check_typedef (value_type (temp));
+      struct type *obj_type = check_typedef (value_type (*objp));
+      if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
+         && (TYPE_CODE (obj_type) == TYPE_CODE_PTR
+             || TYPE_CODE (obj_type) == TYPE_CODE_REF))
        {
          temp = value_addr (temp);
        }
@@ -2984,12 +3063,7 @@ value_slice (struct value *array, int lowbound, int length)
                  TYPE_LENGTH (slice_type));
        }
 
-      if (VALUE_LVAL (array) == lval_internalvar)
-       VALUE_LVAL (slice) = lval_internalvar_component;
-      else
-       VALUE_LVAL (slice) = VALUE_LVAL (array);
-
-      VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
+      set_value_component_location (slice, array);
       VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
       set_value_offset (slice, value_offset (array) + offset);
     }