Merge GDB 7.5.1

gdb/cp-valprint.c

 /* Support for printing C++ values for GDB, the GNU debugger.
 
    Copyright (C) 1986, 1988-1989, 1991-1997, 2000-2003, 2005-2012 Free
    Software Foundation, Inc.
 
    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 80 matching lines @@
 
 /* GCC versions after 2.4.5 use this.  */
 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
 
 /* Return truth value for assertion that TYPE is of the type
    "pointer to virtual function".  */
 
 int
 cp_is_vtbl_ptr_type (struct type *type)
 {
-  char *typename = type_name_no_tag (type);
+  const char *typename = type_name_no_tag (type);
 
   return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
 }
 
 /* Return truth value for the assertion that TYPE is of the type
    "pointer to virtual function table".  */
 
 int
 cp_is_vtbl_member (struct type *type)
 {
@@ skipping 239 matching lines @@
                     fprintf_filtered (stream,
                                       _("<error reading variable: %s>"),
                                       ex.message);
                   else if (v == NULL)
                     val_print_optimized_out (stream);
                   else
                     cp_print_static_field (TYPE_FIELD_TYPE (type, i),
                                            v, stream, recurse + 1,
                                            options);
                 }
+              else if (i == TYPE_VPTR_FIELDNO (type))
+                {
+                  int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
+                  struct type *i_type = TYPE_FIELD_TYPE (type, i);
+
+                  if (valprint_check_validity (stream, i_type, i_offset, val))
+                    {
+                      CORE_ADDR addr;
+                      
+                      addr = extract_typed_address (valaddr + i_offset, i_type);
+                      print_function_pointer_address (options,
+                                                      get_type_arch (type),
+                                                      addr, stream);
+                    }
+                }
               else
                 {
                   struct value_print_options opts = *options;
 
                   opts.deref_ref = 0;
                   val_print (TYPE_FIELD_TYPE (type, i),
                              valaddr, 
                              offset + TYPE_FIELD_BITPOS (type, i) / 8,
                              address,
                              stream, recurse + 1, val, &opts,
@@ skipping 117 matching lines @@
          returns.  */
       /* Bump up the high-water mark.  Now alpha is omega.  */
       obstack_finish (&dont_print_vb_obstack);
     }
 
   for (i = 0; i < n_baseclasses; i++)
     {
       int boffset = 0;
       int skip;
       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
-      char *basename = TYPE_NAME (baseclass);
+      const char *basename = TYPE_NAME (baseclass);
       const gdb_byte *base_valaddr = NULL;
       const struct value *base_val = NULL;
       volatile struct gdb_exception ex;
 
       if (BASETYPE_VIA_VIRTUAL (type, i))
         {
           struct type **first_dont_print
             = (struct type **) obstack_base (&dont_print_vb_obstack);
 
           int j = (struct type **)
@@ skipping 23 matching lines @@
 
           if (BASETYPE_VIA_VIRTUAL (type, i))
             {
               /* The virtual base class pointer might have been
                  clobbered by the user program. Make sure that it
                  still points to a valid memory location.  */
 
               if ((boffset + offset) < 0
                   || (boffset + offset) >= TYPE_LENGTH (real_type))
                 {
-                  /* FIXME (alloca): unsafe if baseclass is really
-                     really large.  */
-                  gdb_byte *buf = alloca (TYPE_LENGTH (baseclass));
+                  gdb_byte *buf;
+                  struct cleanup *back_to;
+
+                  buf = xmalloc (TYPE_LENGTH (baseclass));
+                  back_to = make_cleanup (xfree, buf);
 
                   if (target_read_memory (address + boffset, buf,
                                           TYPE_LENGTH (baseclass)) != 0)
                     skip = 1;
                   base_val = value_from_contents_and_address (baseclass,
                                                               buf,
                                                               address + boffset);
                   thisoffset = 0;
                   boffset = 0;
                   thistype = baseclass;
                   base_valaddr = value_contents_for_printing_const (base_val);
+                  do_cleanups (back_to);
                 }
               else
                 {
                   base_valaddr = valaddr;
                   base_val = val;
                 }
             }
           else
             {
               base_valaddr = valaddr;
@@ skipping 221 matching lines @@
   if (val == -1)
     {
       fprintf_filtered (stream, "NULL");
       return;
     }
 
   cp_find_class_member (&domain, &fieldno, val << 3);
 
   if (domain != NULL)
     {
-      char *name;
+      const char *name;
 
       fputs_filtered (prefix, stream);
       name = type_name_no_tag (domain);
       if (name)
         fputs_filtered (name, stream);
       else
         c_type_print_base (domain, stream, 0, 0);
       fprintf_filtered (stream, "::");
       fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
     }
@@ skipping 29 matching lines @@
                            show_objectprint,
                            &setprintlist, &showprintlist);
 
   obstack_begin (&dont_print_stat_array_obstack,
                  32 * sizeof (struct type *));
   obstack_begin (&dont_print_statmem_obstack,
                  32 * sizeof (CORE_ADDR));
   obstack_begin (&dont_print_vb_obstack,
                  32 * sizeof (struct type *));
 }