Merge GDB 7.5.1

gdb/cp-support.c

 /* Helper routines for C++ support in GDB.
    Copyright (C) 2002-2005, 2007-2012 Free Software Foundation, Inc.
 
    Contributed by MontaVista Software.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
@@ skipping 16 matching lines @@
 #include "dictionary.h"
 #include "objfiles.h"
 #include "frame.h"
 #include "symtab.h"
 #include "block.h"
 #include "complaints.h"
 #include "gdbtypes.h"
 #include "exceptions.h"
 #include "expression.h"
 #include "value.h"
+#include "cp-abi.h"
 
 #include "safe-ctype.h"
 
 #include "psymtab.h"
 
 #define d_left(dc) (dc)->u.s_binary.left
 #define d_right(dc) (dc)->u.s_binary.right
 
 /* Functions related to demangled name parsing.  */
 
@@ skipping 18 matching lines @@
 
 /* The list of "maint cplus" commands.  */
 
 struct cmd_list_element *maint_cplus_cmd_list = NULL;
 
 /* The actual commands.  */
 
 static void maint_cplus_command (char *arg, int from_tty);
 static void first_component_command (char *arg, int from_tty);
 
-/* Operator validation.
-   NOTE: Multi-byte operators (usually the assignment variety
-   operator) must appear before the single byte version, i.e., "+="
-   before "+".  */
-static const char *operator_tokens[] =
-  {
-    "++", "+=", "+", "->*", "->", "--", "-=", "-", "*=", "*",
-    "/=", "/", "%=", "%", "!=", "==", "!", "&&", "<<=", "<<",
-    ">>=", ">>", "<=", "<", ">=", ">", "~", "&=", "&", "|=",
-    "||", "|", "^=", "^", "=", "()", "[]", ",", "new", "delete"
-    /* new[] and delete[] require special whitespace handling */
-  };
-
 /* A list of typedefs which should not be substituted by replace_typedefs.  */
 static const char * const ignore_typedefs[] =
   {
     "std::istream", "std::iostream", "std::ostream", "std::string"
   };
 
 static void
   replace_typedefs (struct demangle_parse_info *info,
                     struct demangle_component *ret_comp);
 
@@ skipping 423 matching lines @@
     return NULL;
 
   info = cp_demangled_name_to_comp (string, NULL);
   if (info == NULL)
     return NULL;
 
   estimated_len = strlen (string) * 2;
   ret = cp_comp_to_string (info->tree, estimated_len);
   cp_demangled_name_parse_free (info);
 
+  if (ret == NULL)
+    {
+      warning (_("internal error: string \"%s\" failed to be canonicalized"),
+               string);
+      return NULL;
+    }
+
   if (strcmp (string, ret) == 0)
     {
       xfree (ret);
       return NULL;
     }
 
   return ret;
 }
 
 /* Convert a mangled name to a demangle_component tree.  *MEMORY is
@@ skipping 597 matching lines @@
   return sym_return_val;
 }
 
 /* Add all symbols with a name matching NAME in BLOCK to the overload
    list.  */
 
 static void
 make_symbol_overload_list_block (const char *name,
                                  const struct block *block)
 {
-  struct dict_iterator iter;
+  struct block_iterator iter;
   struct symbol *sym;
 
-  const struct dictionary *dict = BLOCK_DICT (block);
-
-  for (sym = dict_iter_name_first (dict, name, &iter);
+  for (sym = block_iter_name_first (block, name, &iter);
        sym != NULL;
-       sym = dict_iter_name_next (name, &iter))
+       sym = block_iter_name_next (name, &iter))
     overload_list_add_symbol (sym, name);
 }
 
 /* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
 
 static void
 make_symbol_overload_list_namespace (const char *func_name,
                                      const char *namespace)
 {
   const char *name;
@@ skipping 25 matching lines @@
 }
 
 /* Search the namespace of the given type and namespace of and public
    base types.  */
 
 static void
 make_symbol_overload_list_adl_namespace (struct type *type,
                                          const char *func_name)
 {
   char *namespace;
-  char *type_name;
+  const char *type_name;
   int i, prefix_len;
 
   while (TYPE_CODE (type) == TYPE_CODE_PTR
          || TYPE_CODE (type) == TYPE_CODE_REF
          || TYPE_CODE (type) == TYPE_CODE_ARRAY
          || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
     {
       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
         type = check_typedef(type);
       else
@@ skipping 108 matching lines @@
   make_symbol_overload_list_namespace (func_name, namespace);
 }
 
 /* This does the bulk of the work of finding overloaded symbols.
    FUNC_NAME is the name of the overloaded function we're looking for
    (possibly including namespace info).  */
 
 static void
 make_symbol_overload_list_qualified (const char *func_name)
 {
-  struct symbol *sym;
   struct symtab *s;
   struct objfile *objfile;
   const struct block *b, *surrounding_static_block = 0;
-  struct dict_iterator iter;
-  const struct dictionary *dict;
 
   /* Look through the partial symtabs for all symbols which begin by
      matching FUNC_NAME.  Make sure we read that symbol table in.  */
 
   ALL_OBJFILES (objfile)
   {
     if (objfile->sf)
       objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
   }
 
@@ skipping 98 matching lines @@
   prefix = alloca (len + 1);
 
   memcpy (prefix, arg, len);
   prefix[len] = '\0';
 
   printf_unfiltered ("%s\n", prefix);
 }
 
 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
 
-#define SKIP_SPACE(P)                           \
-  do                                            \
-  {                                             \
-    while (*(P) == ' ' || *(P) == '\t')         \
-      ++(P);                                    \
-  }                                             \
-  while (0)
 
-/* Returns the length of the operator name or 0 if INPUT does not
-   point to a valid C++ operator.  INPUT should start with
-   "operator".  */
-int
-cp_validate_operator (const char *input)
+/* Implement "info vtbl".  */
+
+static void
+info_vtbl_command (char *arg, int from_tty)
 {
-  int i;
-  char *copy;
-  const char *p;
-  struct expression *expr;
-  struct value *val;
-  struct gdb_exception except;
+  struct value *value;
 
-  p = input;
-
-  if (strncmp (p, "operator", 8) == 0)
-    {
-      int valid = 0;
-
-      p += 8;
-      SKIP_SPACE (p);
-      for (i = 0;
-           i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
-           ++i)
-        {
-          int length = strlen (operator_tokens[i]);
-
-          /* By using strncmp here, we MUST have operator_tokens
-             ordered!  See additional notes where operator_tokens is
-             defined above.  */
-          if (strncmp (p, operator_tokens[i], length) == 0)
-            {
-              const char *op = p;
-
-              valid = 1;
-              p += length;
-
-              if (strncmp (op, "new", 3) == 0
-                  || strncmp (op, "delete", 6) == 0)
-                {
-
-                  /* Special case: new[] and delete[].  We must be
-                     careful to swallow whitespace before/in "[]".  */
-                  SKIP_SPACE (p);
-
-                  if (*p == '[')
-                    {
-                      ++p;
-                      SKIP_SPACE (p);
-                      if (*p == ']')
-                        ++p;
-                      else
-                        valid = 0;
-                    }
-                }
-
-              if (valid)
-                return (p - input);
-            }
-        }
-
-      /* Check input for a conversion operator.  */
-
-      /* Skip past base typename.  */
-      while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
-        ++p;
-      SKIP_SPACE (p);
-
-      /* Add modifiers '*' / '&'.  */
-      while (*p == '*' || *p == '&')
-        {
-          ++p;
-          SKIP_SPACE (p);
-        }
-
-      /* Check for valid type.  [Remember: input starts with 
-         "operator".]  */
-      copy = savestring (input + 8, p - input - 8);
-      expr = NULL;
-      val = NULL;
-      TRY_CATCH (except, RETURN_MASK_ALL)
-        {
-          expr = parse_expression (copy);
-          val = evaluate_type (expr);
-        }
-
-      xfree (copy);
-      if (expr)
-        xfree (expr);
-
-      if (val != NULL && value_type (val) != NULL)
-        return (p - input);
-    }
-
-  return 0;
+  value = parse_and_eval (arg);
+  cplus_print_vtable (value);
 }
 
 void
 _initialize_cp_support (void)
 {
   add_prefix_cmd ("cplus", class_maintenance,
                   maint_cplus_command,
                   _("C++ maintenance commands."),
                   &maint_cplus_cmd_list,
                   "maintenance cplus ",
                   0, &maintenancelist);
   add_alias_cmd ("cp", "cplus",
                  class_maintenance, 1,
                  &maintenancelist);
 
   add_cmd ("first_component",
            class_maintenance,
            first_component_command,
            _("Print the first class/namespace component of NAME."),
            &maint_cplus_cmd_list);
+
+  add_info ("vtbl", info_vtbl_command,
+            _("Show the virtual function table for a C++ object.\n\
+Usage: info vtbl EXPRESSION\n\
+Evaluate EXPRESSION and display the virtual function table for the\n\
+resulting object."));
 }