X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fcp-valprint.c;h=3cece925938a1638f9458606b9c21085ada60e56;hb=ba543ca5afafed5bda2db52e8f424f20ff605173;hp=abcc4fc4f5ffac7c13a73cc7decc2549cef242f4;hpb=ecd75fc8eed3bde86036141228074a20e55dcfc9;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c
index abcc4fc4f5..3cece92593 100644
--- a/gdb/cp-valprint.c
+++ b/gdb/cp-valprint.c
@@ -1,6 +1,6 @@
 /* Support for printing C++ values for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2018 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -27,16 +27,15 @@
 #include "gdbcmd.h"
 #include "demangle.h"
 #include "annotate.h"
-#include <string.h>
 #include "c-lang.h"
 #include "target.h"
 #include "cp-abi.h"
 #include "valprint.h"
 #include "cp-support.h"
 #include "language.h"
-#include "python/python.h"
-#include "exceptions.h"
+#include "extension.h"
 #include "typeprint.h"
+#include "byte-vector.h"
 
 /* Controls printing of vtbl's.  */
 static void
@@ -75,22 +74,20 @@ static struct obstack dont_print_vb_obstack;
 static struct obstack dont_print_statmem_obstack;
 static struct obstack dont_print_stat_array_obstack;
 
-extern void _initialize_cp_valprint (void);
-
 static void cp_print_static_field (struct type *, struct value *,
 				   struct ui_file *, int,
 				   const struct value_print_options *);
 
 static void cp_print_value (struct type *, struct type *,
-			    const gdb_byte *, int,
+			    LONGEST,
 			    CORE_ADDR, struct ui_file *,
-			    int, const struct value *,
+			    int, struct value *,
 			    const struct value_print_options *,
 			    struct type **);
 
 
 /* GCC versions after 2.4.5 use this.  */
-const char vtbl_ptr_name[] = "__vtbl_ptr_type";
+extern const char vtbl_ptr_name[] = "__vtbl_ptr_type";
 
 /* Return truth value for assertion that TYPE is of the type
    "pointer to virtual function".  */
@@ -98,9 +95,9 @@ const char vtbl_ptr_name[] = "__vtbl_ptr_type";
 int
 cp_is_vtbl_ptr_type (struct type *type)
 {
-  const char *typename = type_name_no_tag (type);
+  const char *type_name = TYPE_NAME (type);
 
-  return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
+  return (type_name != NULL && !strcmp (type_name, vtbl_ptr_name));
 }
 
 /* Return truth value for the assertion that TYPE is of the type
@@ -156,9 +153,9 @@ cp_is_vtbl_member (struct type *type)
 
 void
 cp_print_value_fields (struct type *type, struct type *real_type,
-		       const gdb_byte *valaddr, int offset,
+		       LONGEST offset,
 		       CORE_ADDR address, struct ui_file *stream,
-		       int recurse, const struct value *val,
+		       int recurse, struct value *val,
 		       const struct value_print_options *options,
 		       struct type **dont_print_vb,
 		       int dont_print_statmem)
@@ -167,7 +164,7 @@ cp_print_value_fields (struct type *type, struct type *real_type,
   int fields_seen = 0;
   static int last_set_recurse = -1;
 
-  CHECK_TYPEDEF (type);
+  type = check_typedef (type);
   
   if (recurse == 0)
     {
@@ -196,7 +193,7 @@ cp_print_value_fields (struct type *type, struct type *real_type,
      duplicates of virtual baseclasses.  */
 
   if (n_baseclasses > 0)
-    cp_print_value (type, real_type, valaddr, 
+    cp_print_value (type, real_type,
 		    offset, address, stream,
 		    recurse + 1, val, options,
 		    dont_print_vb);
@@ -208,8 +205,8 @@ cp_print_value_fields (struct type *type, struct type *real_type,
     fprintf_filtered (stream, "<No data fields>");
   else
     {
-      int statmem_obstack_initial_size = 0;
-      int stat_array_obstack_initial_size = 0;
+      size_t statmem_obstack_initial_size = 0;
+      size_t stat_array_obstack_initial_size = 0;
       struct type *vptr_basetype = NULL;
       int vptr_fieldno;
 
@@ -230,6 +227,8 @@ cp_print_value_fields (struct type *type, struct type *real_type,
       vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
       for (i = n_baseclasses; i < len; i++)
 	{
+	  const gdb_byte *valaddr = value_contents_for_printing (val);
+
 	  /* If requested, skip printing of static fields.  */
 	  if (!options->static_field_print
 	      && field_is_static (&TYPE_FIELD (type, i)))
@@ -244,7 +243,7 @@ cp_print_value_fields (struct type *type, struct type *real_type,
 		  fprintf_filtered (stream, "\n");
 		  print_spaces_filtered (2 + 2 * recurse, stream);
 		  fputs_filtered ("members of ", stream);
-		  fputs_filtered (type_name_no_tag (type), stream);
+		  fputs_filtered (TYPE_NAME (type), stream);
 		  fputs_filtered (": ", stream);
 		}
 	    }
@@ -294,12 +293,6 @@ cp_print_value_fields (struct type *type, struct type *real_type,
 		{
 		  fputs_filtered (_("<synthetic pointer>"), stream);
 		}
-	      else if (!value_bits_valid (val,
-					  TYPE_FIELD_BITPOS (type, i),
-					  TYPE_FIELD_BITSIZE (type, i)))
-		{
-		  val_print_optimized_out (val, stream);
-		}
 	      else
 		{
 		  struct value_print_options opts = *options;
@@ -321,18 +314,21 @@ cp_print_value_fields (struct type *type, struct type *real_type,
 		}
 	      else if (field_is_static (&TYPE_FIELD (type, i)))
 		{
-		  volatile struct gdb_exception ex;
 		  struct value *v = NULL;
 
-		  TRY_CATCH (ex, RETURN_MASK_ERROR)
+		  TRY
 		    {
 		      v = value_static_field (type, i);
 		    }
 
-		  if (ex.reason < 0)
-		    fprintf_filtered (stream,
-				      _("<error reading variable: %s>"),
-				      ex.message);
+		  CATCH (ex, RETURN_MASK_ERROR)
+		    {
+		      fprintf_filtered (stream,
+					_("<error reading variable: %s>"),
+					ex.message);
+		    }
+		  END_CATCH
+
 		  cp_print_static_field (TYPE_FIELD_TYPE (type, i),
 					 v, stream, recurse + 1,
 					 options);
@@ -358,7 +354,6 @@ cp_print_value_fields (struct type *type, struct type *real_type,
 
 		  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,
@@ -370,30 +365,26 @@ cp_print_value_fields (struct type *type, struct type *real_type,
 
       if (dont_print_statmem == 0)
 	{
-	  int obstack_final_size =
+	  size_t obstack_final_size =
            obstack_object_size (&dont_print_statmem_obstack);
 
 	  if (obstack_final_size > statmem_obstack_initial_size)
 	    {
 	      /* In effect, a pop of the printed-statics stack.  */
-
-	      void *free_to_ptr =
-		obstack_next_free (&dont_print_statmem_obstack) -
-		(obstack_final_size - statmem_obstack_initial_size);
-
-	      obstack_free (&dont_print_statmem_obstack,
-			    free_to_ptr);
+	      size_t shrink_bytes
+		= statmem_obstack_initial_size - obstack_final_size;
+	      obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
 	    }
 
 	  if (last_set_recurse != recurse)
 	    {
-	      int obstack_final_size =
+	      obstack_final_size =
 		obstack_object_size (&dont_print_stat_array_obstack);
 	      
 	      if (obstack_final_size > stat_array_obstack_initial_size)
 		{
 		  void *free_to_ptr =
-		    obstack_next_free (&dont_print_stat_array_obstack)
+		    (char *) obstack_next_free (&dont_print_stat_array_obstack)
 		    - (obstack_final_size
 		       - stat_array_obstack_initial_size);
 
@@ -422,10 +413,10 @@ cp_print_value_fields (struct type *type, struct type *real_type,
 
 void
 cp_print_value_fields_rtti (struct type *type,
-			    const gdb_byte *valaddr, int offset,
+			    const gdb_byte *valaddr, LONGEST offset,
 			    CORE_ADDR address,
 			    struct ui_file *stream, int recurse,
-			    const struct value *val,
+			    struct value *val,
 			    const struct value_print_options *options,
 			    struct type **dont_print_vb, 
 			    int dont_print_statmem)
@@ -434,15 +425,18 @@ cp_print_value_fields_rtti (struct type *type,
 
   /* We require all bits to be valid in order to attempt a
      conversion.  */
-  if (value_bits_valid (val, TARGET_CHAR_BIT * offset,
-			TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+  if (!value_bits_any_optimized_out (val,
+				     TARGET_CHAR_BIT * offset,
+				     TARGET_CHAR_BIT * TYPE_LENGTH (type)))
     {
       struct value *value;
-      int full, top, using_enc;
+      int full, using_enc;
+      LONGEST top;
 
       /* Ugh, we have to convert back to a value here.  */
       value = value_from_contents_and_address (type, valaddr + offset,
 					       address + offset);
+      type = value_type (value);
       /* We don't actually care about most of the result here -- just
 	 the type.  We already have the correct offset, due to how
 	 val_print was initially called.  */
@@ -452,7 +446,7 @@ cp_print_value_fields_rtti (struct type *type,
   if (!real_type)
     real_type = type;
 
-  cp_print_value_fields (type, real_type, valaddr, offset,
+  cp_print_value_fields (type, real_type, offset,
 			 address, stream, recurse, val, options,
 			 dont_print_vb, dont_print_statmem);
 }
@@ -462,9 +456,9 @@ cp_print_value_fields_rtti (struct type *type,
 
 static void
 cp_print_value (struct type *type, struct type *real_type,
-		const gdb_byte *valaddr, int offset,
+		LONGEST offset,
 		CORE_ADDR address, struct ui_file *stream,
-		int recurse, const struct value *val,
+		int recurse, struct value *val,
 		const struct value_print_options *options,
 		struct type **dont_print_vb)
 {
@@ -472,8 +466,9 @@ cp_print_value (struct type *type, struct type *real_type,
     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
   struct obstack tmp_obstack = dont_print_vb_obstack;
   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
-  int thisoffset;
+  LONGEST thisoffset;
   struct type *thistype;
+  const gdb_byte *valaddr = value_contents_for_printing (val);
 
   if (dont_print_vb == 0)
     {
@@ -486,13 +481,11 @@ cp_print_value (struct type *type, struct type *real_type,
 
   for (i = 0; i < n_baseclasses; i++)
     {
-      int boffset = 0;
-      int skip;
+      LONGEST boffset = 0;
+      int skip = 0;
       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
       const char *basename = TYPE_NAME (baseclass);
-      const gdb_byte *base_valaddr = NULL;
-      const struct value *base_val = NULL;
-      volatile struct gdb_exception ex;
+      struct value *base_val = NULL;
 
       if (BASETYPE_VIA_VIRTUAL (type, i))
 	{
@@ -512,18 +505,21 @@ cp_print_value (struct type *type, struct type *real_type,
       thisoffset = offset;
       thistype = real_type;
 
-      TRY_CATCH (ex, RETURN_MASK_ERROR)
+      TRY
 	{
 	  boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 	}
-      if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
-	skip = -1;
-      else if (ex.reason < 0)
-	skip = 1;
-      else
- 	{
-	  skip = 0;
+      CATCH (ex, RETURN_MASK_ERROR)
+	{
+	  if (ex.error == NOT_AVAILABLE_ERROR)
+	    skip = -1;
+	  else
+	    skip = 1;
+	}
+      END_CATCH
 
+      if (skip == 0)
+	{
 	  if (BASETYPE_VIA_VIRTUAL (type, i))
 	    {
 	      /* The virtual base class pointer might have been
@@ -533,33 +529,26 @@ cp_print_value (struct type *type, struct type *real_type,
 	      if ((boffset + offset) < 0
 		  || (boffset + offset) >= TYPE_LENGTH (real_type))
 		{
-		  gdb_byte *buf;
-		  struct cleanup *back_to;
-
-		  buf = xmalloc (TYPE_LENGTH (baseclass));
-		  back_to = make_cleanup (xfree, buf);
+		  gdb::byte_vector buf (TYPE_LENGTH (baseclass));
 
-		  if (target_read_memory (address + boffset, buf,
+		  if (target_read_memory (address + boffset, buf.data (),
 					  TYPE_LENGTH (baseclass)) != 0)
 		    skip = 1;
 		  base_val = value_from_contents_and_address (baseclass,
-							      buf,
+							      buf.data (),
 							      address + boffset);
+		  baseclass = value_type (base_val);
 		  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;
 	      base_val = val;
 	    }
 	}
@@ -584,19 +573,19 @@ cp_print_value (struct type *type, struct type *real_type,
 	{
 	  int result = 0;
 
-	  /* Attempt to run the Python pretty-printers on the
+	  /* Attempt to run an extension language pretty-printer on the
 	     baseclass if possible.  */
 	  if (!options->raw)
-	    result = apply_val_pretty_printer (baseclass, base_valaddr,
-					       thisoffset + boffset,
-					       value_address (base_val),
-					       stream, recurse, base_val,
-					       options, current_language);
+	    result
+	      = apply_ext_lang_val_pretty_printer (baseclass,
+						   thisoffset + boffset,
+						   value_address (base_val),
+						   stream, recurse,
+						   base_val, options,
+						   current_language);
 
-
-	  	  
 	  if (!result)
-	    cp_print_value_fields (baseclass, thistype, base_valaddr,
+	    cp_print_value_fields (baseclass, thistype,
 				   thisoffset + boffset,
 				   value_address (base_val),
 				   stream, recurse, base_val, options,
@@ -644,7 +633,8 @@ cp_print_static_field (struct type *type,
       return;
     }
 
-  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+  struct type *real_type = check_typedef (type);
+  if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
     {
       CORE_ADDR *first_dont_print;
       CORE_ADDR addr;
@@ -669,16 +659,14 @@ cp_print_static_field (struct type *type,
       addr = value_address (val);
       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 		    sizeof (CORE_ADDR));
-      CHECK_TYPEDEF (type);
       cp_print_value_fields (type, value_enclosing_type (val),
-			     value_contents_for_printing (val),
 			     value_embedded_offset (val), addr,
 			     stream, recurse, val,
 			     options, NULL, 1);
       return;
     }
 
-  if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+  if (TYPE_CODE (real_type) == TYPE_CODE_ARRAY)
     {
       struct type **first_dont_print;
       int i;
@@ -707,34 +695,33 @@ cp_print_static_field (struct type *type,
 
   opts = *options;
   opts.deref_ref = 0;
-  val_print (type, value_contents_for_printing (val), 
+  val_print (type,
 	     value_embedded_offset (val),
 	     value_address (val),
 	     stream, recurse, val,
 	     &opts, current_language);
 }
 
-
-/* Find the field in *DOMAIN, or its non-virtual base classes, with
-   bit offset OFFSET.  Set *DOMAIN to the containing type and *FIELDNO
+/* Find the field in *SELF, or its non-virtual base classes, with
+   bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
    to the containing field number.  If OFFSET is not exactly at the
-   start of some field, set *DOMAIN to NULL.  */
+   start of some field, set *SELF to NULL.  */
 
 static void
-cp_find_class_member (struct type **domain_p, int *fieldno,
+cp_find_class_member (struct type **self_p, int *fieldno,
 		      LONGEST offset)
 {
-  struct type *domain;
+  struct type *self;
   unsigned int i;
   unsigned len;
 
-  *domain_p = check_typedef (*domain_p);
-  domain = *domain_p;
-  len = TYPE_NFIELDS (domain);
+  *self_p = check_typedef (*self_p);
+  self = *self_p;
+  len = TYPE_NFIELDS (self);
 
-  for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
+  for (i = TYPE_N_BASECLASSES (self); i < len; i++)
     {
-      LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
+      LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 
       QUIT;
       if (offset == bitpos)
@@ -744,32 +731,32 @@ cp_find_class_member (struct type **domain_p, int *fieldno,
 	}
     }
 
-  for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
+  for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
     {
-      LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
-      LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
+      LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
+      LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
 
       if (offset >= bitpos && offset < bitpos + bitsize)
 	{
-	  *domain_p = TYPE_FIELD_TYPE (domain, i);
-	  cp_find_class_member (domain_p, fieldno, offset - bitpos);
+	  *self_p = TYPE_FIELD_TYPE (self, i);
+	  cp_find_class_member (self_p, fieldno, offset - bitpos);
 	  return;
 	}
     }
 
-  *domain_p = NULL;
+  *self_p = NULL;
 }
 
 void
 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
-		       struct ui_file *stream, char *prefix)
+		       struct ui_file *stream, const char *prefix)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 
-  /* VAL is a byte offset into the structure type DOMAIN.
+  /* VAL is a byte offset into the structure type SELF_TYPE.
      Find the name of the field for that offset and
      print it.  */
-  struct type *domain = TYPE_DOMAIN_TYPE (type);
+  struct type *self_type = TYPE_SELF_TYPE (type);
   LONGEST val;
   int fieldno;
 
@@ -793,20 +780,20 @@ cp_print_class_member (const gdb_byte *valaddr, struct type *type,
       return;
     }
 
-  cp_find_class_member (&domain, &fieldno, val << 3);
+  cp_find_class_member (&self_type, &fieldno, val << 3);
 
-  if (domain != NULL)
+  if (self_type != NULL)
     {
       const char *name;
 
       fputs_filtered (prefix, stream);
-      name = type_name_no_tag (domain);
+      name = TYPE_NAME (self_type);
       if (name)
 	fputs_filtered (name, stream);
       else
-	c_type_print_base (domain, stream, 0, 0, &type_print_raw_options);
+	c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
       fprintf_filtered (stream, "::");
-      fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
+      fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
     }
   else
     fprintf_filtered (stream, "%ld", (long) val);