Add bootstrap-asan.mk
[deliverable/binutils-gdb.git] / gdb / varobj.c
index aaea23861d8aa937832ee9a308a216aaccd4988f..130f438f2d7a90f8e1d2eb66b888faa927c4d003 100644 (file)
@@ -49,7 +49,7 @@ typedef int PyObject;
 
 /* Non-zero if we want to see trace of varobj level stuff.  */
 
-int varobjdebug = 0;
+unsigned int varobjdebug = 0;
 static void
 show_varobjdebug (struct ui_file *file, int from_tty,
                  struct cmd_list_element *c, const char *value)
@@ -84,7 +84,7 @@ struct varobj_root
   struct expression *exp;
 
   /* Block for which this expression is valid.  */
-  struct block *valid_block;
+  const struct block *valid_block;
 
   /* The frame for this expression.  This field is set iff valid_block is
      not NULL.  */
@@ -270,6 +270,9 @@ static void cppush (struct cpstack **pstack, char *name);
 
 static char *cppop (struct cpstack **pstack);
 
+static int update_type_if_necessary (struct varobj *var,
+                                    struct value *new_value);
+
 static int install_new_value (struct varobj *var, struct value *value, 
                              int initial);
 
@@ -306,6 +309,8 @@ static struct varobj *varobj_add_child (struct varobj *var,
 
 #endif /* HAVE_PYTHON */
 
+static int default_value_is_changeable_p (struct varobj *var);
+
 /* C implementation */
 
 static int c_number_of_children (struct varobj *var);
@@ -384,6 +389,8 @@ static struct type *ada_type_of_child (struct varobj *parent, int index);
 static char *ada_value_of_variable (struct varobj *var,
                                    enum varobj_display_formats format);
 
+static int ada_value_is_changeable_p (struct varobj *var);
+
 static int ada_value_has_mutated (struct varobj *var, struct value *new_val,
                                  struct type *new_type);
 
@@ -421,6 +428,16 @@ struct language_specific
   char *(*value_of_variable) (struct varobj * var,
                              enum varobj_display_formats format);
 
+  /* Return non-zero if changes in value of VAR must be detected and
+     reported by -var-update.  Return zero if -var-update should never
+     report changes of such values.  This makes sense for structures
+     (since the changes in children values will be reported separately),
+     or for artifical objects (like 'public' pseudo-field in C++).
+
+     Return value of 0 means that gdb need not call value_fetch_lazy
+     for the value of this variable object.  */
+  int (*value_is_changeable_p) (struct varobj *var);
+
   /* Return nonzero if the type of VAR has mutated.
 
      VAR's value is still the varobj's previous value, while NEW_VALUE
@@ -450,6 +467,7 @@ static struct language_specific languages[vlang_end] = {
    c_value_of_child,
    c_type_of_child,
    c_value_of_variable,
+   default_value_is_changeable_p,
    NULL /* value_has_mutated */}
   ,
   /* C */
@@ -463,6 +481,7 @@ static struct language_specific languages[vlang_end] = {
    c_value_of_child,
    c_type_of_child,
    c_value_of_variable,
+   default_value_is_changeable_p,
    NULL /* value_has_mutated */}
   ,
   /* C++ */
@@ -476,6 +495,7 @@ static struct language_specific languages[vlang_end] = {
    cplus_value_of_child,
    cplus_type_of_child,
    cplus_value_of_variable,
+   default_value_is_changeable_p,
    NULL /* value_has_mutated */}
   ,
   /* Java */
@@ -489,6 +509,7 @@ static struct language_specific languages[vlang_end] = {
    java_value_of_child,
    java_type_of_child,
    java_value_of_variable,
+   default_value_is_changeable_p,
    NULL /* value_has_mutated */},
   /* Ada */
   {
@@ -501,6 +522,7 @@ static struct language_specific languages[vlang_end] = {
    ada_value_of_child,
    ada_type_of_child,
    ada_value_of_variable,
+   ada_value_is_changeable_p,
    ada_value_has_mutated}
 };
 
@@ -602,6 +624,7 @@ varobj_create (char *objname,
       enum varobj_languages lang;
       struct value *value = NULL;
       volatile struct gdb_exception except;
+      CORE_ADDR pc;
 
       /* Parse and evaluate the expression, filling in as much of the
          variable's data as possible.  */
@@ -628,9 +651,13 @@ varobj_create (char *objname,
       if (type == USE_SELECTED_FRAME)
        var->root->floating = 1;
 
+      pc = 0;
       block = NULL;
       if (fi != NULL)
-       block = get_frame_block (fi, 0);
+       {
+         block = get_frame_block (fi, 0);
+         pc = get_frame_pc (fi);
+       }
 
       p = expression;
       innermost_block = NULL;
@@ -638,7 +665,7 @@ varobj_create (char *objname,
          return a sensible error.  */
       TRY_CATCH (except, RETURN_MASK_ERROR)
        {
-         var->root->exp = parse_exp_1 (&p, block, 0);
+         var->root->exp = parse_exp_1 (&p, pc, block, 0);
        }
 
       if (except.reason < 0)
@@ -648,7 +675,9 @@ varobj_create (char *objname,
        }
 
       /* Don't allow variables to be created for types.  */
-      if (var->root->exp->elts[0].opcode == OP_TYPE)
+      if (var->root->exp->elts[0].opcode == OP_TYPE
+         || var->root->exp->elts[0].opcode == OP_TYPEOF
+         || var->root->exp->elts[0].opcode == OP_DECLTYPE)
        {
          do_cleanups (old_chain);
          fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
@@ -697,15 +726,21 @@ varobj_create (char *objname,
 
          var->type = value_type (type_only_value);
        }
-      else 
-       var->type = value_type (value);
+       else
+         {
+           int real_type_found = 0;
 
-      install_new_value (var, value, 1 /* Initial assignment */);
+           var->type = value_actual_type (value, 0, &real_type_found);
+           if (real_type_found)
+             value = value_cast (var->type, value);
+         }
 
       /* Set language info */
       lang = variable_language (var);
       var->root->lang = &languages[lang];
 
+      install_new_value (var, value, 1 /* Initial assignment */);
+
       /* Set ourselves as our root.  */
       var->root->rootvar = var;
 
@@ -986,6 +1021,7 @@ restrict_range (VEC (varobj_p) *children, int *from, int *to)
 static void
 install_dynamic_child (struct varobj *var,
                       VEC (varobj_p) **changed,
+                      VEC (varobj_p) **type_changed,
                       VEC (varobj_p) **new,
                       VEC (varobj_p) **unchanged,
                       int *cchanged,
@@ -1008,12 +1044,18 @@ install_dynamic_child (struct varobj *var,
     {
       varobj_p existing = VEC_index (varobj_p, var->children, index);
 
+      int type_updated = update_type_if_necessary (existing, value);
+      if (type_updated)
+       {
+         if (type_changed)
+           VEC_safe_push (varobj_p, *type_changed, existing);
+       }
       if (install_new_value (existing, value, 0))
        {
-         if (changed)
+         if (!type_updated && changed)
            VEC_safe_push (varobj_p, *changed, existing);
        }
-      else if (unchanged)
+      else if (!type_updated && unchanged)
        VEC_safe_push (varobj_p, *unchanged, existing);
     }
 }
@@ -1036,6 +1078,7 @@ dynamic_varobj_has_child_method (struct varobj *var)
 static int
 update_dynamic_varobj_children (struct varobj *var,
                                VEC (varobj_p) **changed,
+                               VEC (varobj_p) **type_changed,
                                VEC (varobj_p) **new,
                                VEC (varobj_p) **unchanged,
                                int *cchanged,
@@ -1071,9 +1114,6 @@ update_dynamic_varobj_children (struct varobj *var,
 
       make_cleanup_py_decref (children);
 
-      if (!PyIter_Check (children))
-       error (_("Returned value is not iterable"));
-
       Py_XDECREF (var->child_iter);
       var->child_iter = PyObject_GetIter (children);
       if (!var->child_iter)
@@ -1171,6 +1211,7 @@ update_dynamic_varobj_children (struct varobj *var,
          if (v == NULL)
            gdbpy_print_stack ();
          install_dynamic_child (var, can_mention ? changed : NULL,
+                                can_mention ? type_changed : NULL,
                                 can_mention ? new : NULL,
                                 can_mention ? unchanged : NULL,
                                 can_mention ? cchanged : NULL, i, name, v);
@@ -1226,7 +1267,7 @@ varobj_get_num_children (struct varobj *var)
 
          /* If we have a dynamic varobj, don't report -1 children.
             So, try to fetch some children first.  */
-         update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
+         update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
                                          0, 0, 0);
        }
       else
@@ -1252,8 +1293,8 @@ varobj_list_children (struct varobj *var, int *from, int *to)
       /* This, in theory, can result in the number of children changing without
         frontend noticing.  But well, calling -var-list-children on the same
         varobj twice is not something a sane frontend would do.  */
-      update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
-                                     0, 0, *to);
+      update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
+                                     &children_changed, 0, 0, *to);
       restrict_range (var->children, from, to);
       return var->children;
     }
@@ -1434,7 +1475,7 @@ varobj_set_value (struct varobj *var, char *expression)
   gdb_assert (varobj_editable_p (var));
 
   input_radix = 10;            /* ALWAYS reset to decimal temporarily.  */
-  exp = parse_exp_1 (&s, 0, 0);
+  exp = parse_exp_1 (&s, 0, 0, 0);
   TRY_CATCH (except, RETURN_MASK_ERROR)
     {
       value = evaluate_expression (exp);
@@ -1600,6 +1641,43 @@ install_new_value_visualizer (struct varobj *var)
 #endif
 }
 
+/* When using RTTI to determine variable type it may be changed in runtime when
+   the variable value is changed.  This function checks whether type of varobj
+   VAR will change when a new value NEW_VALUE is assigned and if it is so
+   updates the type of VAR.  */
+
+static int
+update_type_if_necessary (struct varobj *var, struct value *new_value)
+{
+  if (new_value)
+    {
+      struct value_print_options opts;
+
+      get_user_print_options (&opts);
+      if (opts.objectprint)
+       {
+         struct type *new_type;
+         char *curr_type_str, *new_type_str;
+
+         new_type = value_actual_type (new_value, 0, 0);
+         new_type_str = type_to_string (new_type);
+         curr_type_str = varobj_get_type (var);
+         if (strcmp (curr_type_str, new_type_str) != 0)
+           {
+             var->type = new_type;
+
+             /* This information may be not valid for a new type.  */
+             varobj_delete (var, NULL, 1);
+             VEC_free (varobj_p, var->children);
+             var->num_children = -1;
+             return 1;
+           }
+       }
+    }
+
+  return 0;
+}
+
 /* Assign a new value to a variable object.  If INITIAL is non-zero,
    this is the first assignement after the variable object was just
    created, or changed type.  In that case, just assign the value 
@@ -1929,8 +2007,9 @@ varobj_update (struct varobj **varp, int explicit)
         value_of_root variable dispose of the varobj if the type
         has changed.  */
       new = value_of_root (varp, &type_changed);
+      if (update_type_if_necessary(*varp, new))
+         type_changed = 1;
       r.varobj = *varp;
-
       r.type_changed = type_changed;
       if (install_new_value ((*varp), new, type_changed))
        r.changed = 1;
@@ -1971,6 +2050,8 @@ varobj_update (struct varobj **varp, int explicit)
          struct type *new_type;
 
          new = value_of_child (v->parent, v->index);
+         if (update_type_if_necessary(v, new))
+           r.type_changed = 1;
          if (new)
            new_type = value_type (new);
          else
@@ -2000,7 +2081,8 @@ varobj_update (struct varobj **varp, int explicit)
         invoked.  */
       if (v->pretty_printer)
        {
-         VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
+         VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0;
+         VEC (varobj_p) *new = 0;
          int i, children_changed = 0;
 
          if (v->frozen)
@@ -2018,7 +2100,7 @@ varobj_update (struct varobj **varp, int explicit)
                 it.  */
              if (!varobj_has_more (v, 0))
                {
-                 update_dynamic_varobj_children (v, NULL, NULL, NULL,
+                 update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
                                                  &dummy, 0, 0, 0);
                  if (varobj_has_more (v, 0))
                    r.changed = 1;
@@ -2032,8 +2114,8 @@ varobj_update (struct varobj **varp, int explicit)
 
          /* If update_dynamic_varobj_children returns 0, then we have
             a non-conforming pretty-printer, so we skip it.  */
-         if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
-                                             &children_changed, 1,
+         if (update_dynamic_varobj_children (v, &changed, &type_changed, &new,
+                                             &unchanged, &children_changed, 1,
                                              v->from, v->to))
            {
              if (children_changed || new)
@@ -2045,6 +2127,18 @@ varobj_update (struct varobj **varp, int explicit)
                 popped from the work stack first, and so will be
                 added to result first.  This does not affect
                 correctness, just "nicer".  */
+             for (i = VEC_length (varobj_p, type_changed) - 1; i >= 0; --i)
+               {
+                 varobj_p tmp = VEC_index (varobj_p, type_changed, i);
+                 varobj_update_result r = {0};
+
+                 /* Type may change only if value was changed.  */
+                 r.varobj = tmp;
+                 r.changed = 1;
+                 r.type_changed = 1;
+                 r.value_installed = 1;
+                 VEC_safe_push (varobj_update_result, stack, &r);
+               }
              for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
                {
                  varobj_p tmp = VEC_index (varobj_p, changed, i);
@@ -2071,9 +2165,10 @@ varobj_update (struct varobj **varp, int explicit)
              if (r.changed || r.children_changed)
                VEC_safe_push (varobj_update_result, result, &r);
 
-             /* Free CHANGED and UNCHANGED, but not NEW, because NEW
-                has been put into the result vector.  */
+             /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
+                because NEW has been put into the result vector.  */
              VEC_free (varobj_p, changed);
+             VEC_free (varobj_p, type_changed);
              VEC_free (varobj_p, unchanged);
 
              continue;
@@ -2348,7 +2443,7 @@ create_child_with_value (struct varobj *parent, int index, const char *name,
   if (value != NULL)
     /* If the child had no evaluation errors, var->value
        will be non-NULL and contain a valid type.  */
-    child->type = value_type (value);
+    child->type = value_actual_type (value, 0, NULL);
   else
     /* Otherwise, we must compute the type.  */
     child->type = (*child->root->lang->type_of_child) (child->parent, 
@@ -2905,62 +3000,12 @@ varobj_editable_p (struct varobj *var)
     }
 }
 
-/* Return non-zero if changes in value of VAR
-   must be detected and reported by -var-update.
-   Return zero is -var-update should never report
-   changes of such values.  This makes sense for structures
-   (since the changes in children values will be reported separately),
-   or for artifical objects (like 'public' pseudo-field in C++).
+/* Call VAR's value_is_changeable_p language-specific callback.  */
 
-   Return value of 0 means that gdb need not call value_fetch_lazy
-   for the value of this variable object.  */
 static int
 varobj_value_is_changeable_p (struct varobj *var)
 {
-  int r;
-  struct type *type;
-
-  if (CPLUS_FAKE_CHILD (var))
-    return 0;
-
-  /* FIXME: This, and the check above, show that this routine
-     should be language-specific.  */
-  if (variable_language (var) == vlang_ada)
-    {
-      struct type *type = var->value ? value_type (var->value) : var->type;
-
-      if (ada_is_array_descriptor_type (type)
-         && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
-       {
-         /* This is in reality a pointer to an unconstrained array.
-            its value is changeable.  */
-         return 1;
-       }
-
-      if (ada_is_string_type (type))
-       {
-         /* We display the contents of the string in the array's
-            "value" field.  The contents can change, so consider
-            that the array is changeable.  */
-         return 1;
-       }
-    }
-
-  type = get_value_type (var);
-
-  switch (TYPE_CODE (type))
-    {
-    case TYPE_CODE_STRUCT:
-    case TYPE_CODE_UNION:
-    case TYPE_CODE_ARRAY:
-      r = 0;
-      break;
-
-    default:
-      r = 1;
-    }
-
-  return r;
+  return var->root->lang->value_is_changeable_p (var);
 }
 
 /* Return 1 if that varobj is floating, that is is always evaluated in the
@@ -2979,6 +3024,10 @@ varobj_floating_p (struct varobj *var)
    to all types and dereferencing pointers to
    structures.
 
+   If LOOKUP_ACTUAL_TYPE is set the enclosing type of the
+   value will be fetched and if it differs from static type
+   the value will be casted to it.
+
    Both TYPE and *TYPE should be non-null.  VALUE
    can be null if we want to only translate type.
    *VALUE can be null as well -- if the parent
@@ -2990,7 +3039,8 @@ varobj_floating_p (struct varobj *var)
 static void
 adjust_value_for_child_access (struct value **value,
                                  struct type **type,
-                                 int *was_ptr)
+                                 int *was_ptr,
+                                 int lookup_actual_type)
 {
   gdb_assert (type && *type);
 
@@ -3035,9 +3085,53 @@ adjust_value_for_child_access (struct value **value,
   /* The 'get_target_type' function calls check_typedef on
      result, so we can immediately check type code.  No
      need to call check_typedef here.  */
+
+  /* Access a real type of the value (if necessary and possible).  */
+  if (value && *value && lookup_actual_type)
+    {
+      struct type *enclosing_type;
+      int real_type_found = 0;
+
+      enclosing_type = value_actual_type (*value, 1, &real_type_found);
+      if (real_type_found)
+        {
+          *type = enclosing_type;
+          *value = value_cast (enclosing_type, *value);
+        }
+    }
+}
+
+/* Implement the "value_is_changeable_p" varobj callback for most
+   languages.  */
+
+static int
+default_value_is_changeable_p (struct varobj *var)
+{
+  int r;
+  struct type *type;
+
+  if (CPLUS_FAKE_CHILD (var))
+    return 0;
+
+  type = get_value_type (var);
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_ARRAY:
+      r = 0;
+      break;
+
+    default:
+      r = 1;
+    }
+
+  return r;
 }
 
 /* C */
+
 static int
 c_number_of_children (struct varobj *var)
 {
@@ -3045,7 +3139,7 @@ c_number_of_children (struct varobj *var)
   int children = 0;
   struct type *target;
 
-  adjust_value_for_child_access (NULL, &type, NULL);
+  adjust_value_for_child_access (NULL, &type, NULL, 0);
   target = get_target_type (type);
 
   switch (TYPE_CODE (type))
@@ -3161,7 +3255,7 @@ c_describe_child (struct varobj *parent, int index,
       *cfull_expression = NULL;
       parent_expression = varobj_get_path_expr (get_path_expr_parent (parent));
     }
-  adjust_value_for_child_access (&value, &type, &was_ptr);
+  adjust_value_for_child_access (&value, &type, &was_ptr, 0);
       
   switch (TYPE_CODE (type))
     {
@@ -3457,16 +3551,29 @@ c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
 static int
 cplus_number_of_children (struct varobj *var)
 {
+  struct value *value = NULL;
   struct type *type;
   int children, dont_know;
+  int lookup_actual_type = 0;
+  struct value_print_options opts;
 
   dont_know = 1;
   children = 0;
 
+  get_user_print_options (&opts);
+
   if (!CPLUS_FAKE_CHILD (var))
     {
       type = get_value_type (var);
-      adjust_value_for_child_access (NULL, &type, NULL);
+
+      /* It is necessary to access a real type (via RTTI).  */
+      if (opts.objectprint)
+        {
+          value = var->value;
+          lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
+                               || TYPE_CODE (var->type) == TYPE_CODE_PTR);
+        }
+      adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
 
       if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
          ((TYPE_CODE (type)) == TYPE_CODE_UNION))
@@ -3493,7 +3600,17 @@ cplus_number_of_children (struct varobj *var)
       int kids[3];
 
       type = get_value_type (var->parent);
-      adjust_value_for_child_access (NULL, &type, NULL);
+
+      /* It is necessary to access a real type (via RTTI).  */
+      if (opts.objectprint)
+        {
+         struct varobj *parent = var->parent;
+
+         value = parent->value;
+         lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
+                               || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
+        }
+      adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
 
       cplus_class_num_children (type, kids);
       if (strcmp (var->name, "public") == 0)
@@ -3575,7 +3692,10 @@ cplus_describe_child (struct varobj *parent, int index,
   struct value *value;
   struct type *type;
   int was_ptr;
+  int lookup_actual_type = 0;
   char *parent_expression = NULL;
+  struct varobj *var;
+  struct value_print_options opts;
 
   if (cname)
     *cname = NULL;
@@ -3586,24 +3706,18 @@ cplus_describe_child (struct varobj *parent, int index,
   if (cfull_expression)
     *cfull_expression = NULL;
 
-  if (CPLUS_FAKE_CHILD (parent))
-    {
-      value = parent->parent->value;
-      type = get_value_type (parent->parent);
-      if (cfull_expression)
-       parent_expression
-         = varobj_get_path_expr (get_path_expr_parent (parent->parent));
-    }
-  else
-    {
-      value = parent->value;
-      type = get_value_type (parent);
-      if (cfull_expression)
-       parent_expression
-         = varobj_get_path_expr (get_path_expr_parent (parent));
-    }
+  get_user_print_options (&opts);
 
-  adjust_value_for_child_access (&value, &type, &was_ptr);
+  var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
+  if (opts.objectprint)
+    lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
+                         || TYPE_CODE (var->type) == TYPE_CODE_PTR);
+  value = var->value;
+  type = get_value_type (var);
+  if (cfull_expression)
+    parent_expression = varobj_get_path_expr (get_path_expr_parent (var));
+
+  adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
 
   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
       || TYPE_CODE (type) == TYPE_CODE_UNION)
@@ -3967,6 +4081,32 @@ ada_value_of_variable (struct varobj *var, enum varobj_display_formats format)
   return ada_varobj_get_value_of_variable (var->value, var->type, &opts);
 }
 
+/* Implement the "value_is_changeable_p" routine for Ada.  */
+
+static int
+ada_value_is_changeable_p (struct varobj *var)
+{
+  struct type *type = var->value ? value_type (var->value) : var->type;
+
+  if (ada_is_array_descriptor_type (type)
+      && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+    {
+      /* This is in reality a pointer to an unconstrained array.
+        its value is changeable.  */
+      return 1;
+    }
+
+  if (ada_is_string_type (type))
+    {
+      /* We display the contents of the string in the array's
+        "value" field.  The contents can change, so consider
+        that the array is changeable.  */
+      return 1;
+    }
+
+  return default_value_is_changeable_p (var);
+}
+
 /* Implement the "value_has_mutated" routine for Ada.  */
 
 static int
@@ -4033,28 +4173,27 @@ _initialize_varobj (void)
   varobj_table = xmalloc (sizeof_table);
   memset (varobj_table, 0, sizeof_table);
 
-  add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
-                           &varobjdebug,
-                           _("Set varobj debugging."),
-                           _("Show varobj debugging."),
-                           _("When non-zero, varobj debugging is enabled."),
-                           NULL, show_varobjdebug,
-                           &setlist, &showlist);
+  add_setshow_zuinteger_cmd ("debugvarobj", class_maintenance,
+                            &varobjdebug,
+                            _("Set varobj debugging."),
+                            _("Show varobj debugging."),
+                            _("When non-zero, varobj debugging is enabled."),
+                            NULL, show_varobjdebug,
+                            &setlist, &showlist);
 }
 
 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
-   defined on globals.  It is a helper for varobj_invalidate.  */
+   defined on globals.  It is a helper for varobj_invalidate.
+
+   This function is called after changing the symbol file, in this case the
+   pointers to "struct type" stored by the varobj are no longer valid.  All
+   varobj must be either re-evaluated, or marked as invalid here.  */
 
 static void
 varobj_invalidate_iter (struct varobj *var, void *unused)
 {
-  /* Floating varobjs are reparsed on each stop, so we don't care if the
-     presently parsed expression refers to something that's gone.  */
-  if (var->root->floating)
-    return;
-
-  /* global var must be re-evaluated.  */     
-  if (var->root->valid_block == NULL)
+  /* global and floating var must be re-evaluated.  */
+  if (var->root->floating || var->root->valid_block == NULL)
     {
       struct varobj *tmp_var;
 
This page took 0.042783 seconds and 4 git commands to generate.