Re: [RFA] Allow casting of object pointers for method calls

[Elena Zannoni <ezannoni at cygnus dot com>]

Michael Elizabeth Chastain writes:
 > Hi Elena,

Ok, Michael, thanks. I'll commit it myself now to avoid any possible
assignment problem.  But I woudn't think there is one, because you
weren't the author.

Thanks for doing this!
Elena


 > 
 > > Michael, have you tested 5.1 + patch with older gcc? Any problems?
 > > If not I'll commit it right away.
 > 
 > It proofreads good and it tests good, like a patch should.
 > 
 > I hand-applied the patch to the 5.1 line.  The process of hand application
 > was good for proofreading.
 > 
 > I believe that my work in translating the patch from mainline to 5.1
 > branch is trivial and obvious.  This might be important because I don't
 > have an FSF assignment in place yet (the FSF has just sent me paperwork).
 > Andrew, is this an issue?
 > 
 > The patch touches only dwarf-2 support and only for the attribute form
 > DW_FORM_strp, plus it removes some support for the unsupported case
 > HOST_CHAR_BITS != 8.  The HOST_CHAR_BITS parts were in the original
 > patch in response to a comment from Andrew.
 > 
 > I tested the 5.1 line with 8 configurations:
 > 
 >   gcc 2.95.3, gcc 3.0.2, gcc HEAD, gcc gcc-3_0-branch
 >   -gstabs+, -gdwarf-2
 > 
 > The tables are here:
 > 
 >   http://www.shout.net/~mec/public_html/sunday/2001-12-06/index.html
 > 
 > The new gdb fixes the problem with gcc HEAD dwarf-2 and the results are
 > similar to the gcc 3.0.2 dwarf-2 and gcc gcc-3_0-branch dwarf2.  There
 > are no significant regressions with the other 7 tested configurations.
 > There are insignificant result transitions in gdb.c++/annota2.exp
 > and gdb.base/interrupt.exp.
 > 
 > I recomend this patch for commitment on the 5.1 branch.
 > 
 > Michael C
 > 
 > ===
 > 
 > 2001-11-12  Jakub Jelinek  <jakub@redhat.com>
 > 
 > 	* dwarf2read.c (dwarf_str_buffer): New.
 > 	(struct dwarf2_pinfo): Add dwarf_str_buffer and dwarf_str_size.
 > 	(DWARF_STR_BUFFER, DWARF_STR_SIZE): Define.
 > 	(dwarf2_has_info): Clear dwarf_str_offset.
 > 	(dwarf2_build_psymtabs): Read .debug_str section if present.
 > 	(dwarf2_build_psymtabs_hard): Save DWARF_STR_BUFFER and
 > 	DWARF_STR_SIZE.
 > 	(psymtab_to_symtab_1): Restore DWARF_STR_BUFFER and DWARF_STR_SIZE.
 > 	(read_attribute): Handle DW_FORM_strp.
 > 	(read_n_bytes, read_string): Remove HOST_CHAR_BIT != 8
 > 	handling code.
 > 	(read_indirect_string): New.
 > 	(dump_die): Handle DW_FORM_strp.
 > 
 > Index: dwarf2read.c
 > ===================================================================
 > RCS file: /cvs/src/src/gdb/dwarf2read.c,v
 > retrieving revision 1.29
 > diff -c -3 -r1.29 dwarf2read.c
 > *** dwarf2read.c	2001/07/05 16:45:48	1.29
 > --- dwarf2read.c	2001/12/07 11:01:20
 > ***************
 > *** 43,48 ****
 > --- 43,49 ----
 >   #include "bcache.h"
 >   #include <fcntl.h>
 >   #include "gdb_string.h"
 > + #include "gdb_assert.h"
 >   #include <sys/types.h>
 >   
 >   #ifndef DWARF2_REG_TO_REGNUM
 > ***************
 > *** 302,307 ****
 > --- 303,309 ----
 >   static char *dwarf_info_buffer;
 >   static char *dwarf_abbrev_buffer;
 >   static char *dwarf_line_buffer;
 > + static char *dwarf_str_buffer;
 >   
 >   /* A zeroed version of a partial die for initialization purposes.  */
 >   static struct partial_die_info zeroed_partial_die;
 > ***************
 > *** 383,388 ****
 > --- 385,398 ----
 >       /* Pointer to start of dwarf line buffer for the objfile.  */
 >   
 >       char *dwarf_line_buffer;
 > + 
 > +     /* Pointer to start of dwarf string buffer for the objfile.  */
 > + 
 > +     char *dwarf_str_buffer;
 > + 
 > +     /* Size of dwarf string section for the objfile.  */
 > + 
 > +     unsigned int dwarf_str_size;
 >     };
 >   
 >   #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
 > ***************
 > *** 391,396 ****
 > --- 401,408 ----
 >   #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
 >   #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
 >   #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
 > + #define DWARF_STR_BUFFER(p)  (PST_PRIVATE(p)->dwarf_str_buffer)
 > + #define DWARF_STR_SIZE(p)    (PST_PRIVATE(p)->dwarf_str_size)
 >   
 >   /* Maintain an array of referenced fundamental types for the current
 >      compilation unit being read.  For DWARF version 1, we have to construct
 > ***************
 > *** 619,624 ****
 > --- 631,639 ----
 >   
 >   static char *read_string (bfd *, char *, unsigned int *);
 >   
 > + static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *,
 > +                                    unsigned int *);
 > + 
 >   static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *);
 >   
 >   static long read_signed_leb128 (bfd *, char *, unsigned int *);
 > ***************
 > *** 791,796 ****
 > --- 806,812 ----
 >   dwarf2_has_info (bfd *abfd)
 >   {
 >     dwarf_info_offset = dwarf_abbrev_offset = dwarf_line_offset = 0;
 > +   dwarf_str_offset = 0;
 >     bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
 >     if (dwarf_info_offset && dwarf_abbrev_offset)
 >       {
 > ***************
 > *** 869,874 ****
 > --- 885,897 ----
 >   					   dwarf_line_offset,
 >   					   dwarf_line_size);
 >   
 > +   if (dwarf_str_offset)
 > +     dwarf_str_buffer = dwarf2_read_section (objfile,
 > +                                         dwarf_str_offset,
 > +                                         dwarf_str_size);
 > +   else
 > +     dwarf_str_buffer = NULL;
 > + 
 >     if (mainline || objfile->global_psymbols.size == 0 ||
 >         objfile->static_psymbols.size == 0)
 >       {
 > ***************
 > *** 1045,1050 ****
 > --- 1068,1075 ----
 >         DWARF_ABBREV_BUFFER (pst) = dwarf_abbrev_buffer;
 >         DWARF_ABBREV_SIZE (pst) = dwarf_abbrev_size;
 >         DWARF_LINE_BUFFER (pst) = dwarf_line_buffer;
 > +       DWARF_STR_BUFFER (pst) = dwarf_str_buffer;
 > +       DWARF_STR_SIZE (pst) = dwarf_str_size;
 >         baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 >   
 >         /* Store the function that reads in the rest of the symbol table */
 > ***************
 > *** 1344,1349 ****
 > --- 1369,1376 ----
 >     dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER (pst);
 >     dwarf_abbrev_size = DWARF_ABBREV_SIZE (pst);
 >     dwarf_line_buffer = DWARF_LINE_BUFFER (pst);
 > +   dwarf_str_buffer = DWARF_STR_BUFFER (pst);
 > +   dwarf_str_size = DWARF_STR_SIZE (pst);
 >     baseaddr = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile));
 >     cu_header_offset = offset;
 >     info_ptr = dwarf_info_buffer + offset;
 > ***************
 > *** 3358,3363 ****
 > --- 3385,3395 ----
 >         DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
 >         info_ptr += bytes_read;
 >         break;
 > +     case DW_FORM_strp:
 > +       DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
 > + 	                                       &bytes_read);
 > +       info_ptr += bytes_read;
 > +       break;
 >       case DW_FORM_block:
 >         blk = dwarf_alloc_block ();
 >         blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 > ***************
 > *** 3410,3416 ****
 >         DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 >         info_ptr += bytes_read;
 >         break;
 > -     case DW_FORM_strp:
 >       case DW_FORM_indirect:
 >       default:
 >         error ("Dwarf Error: Cannot handle %s in DWARF reader.",
 > --- 3442,3447 ----
 > ***************
 > *** 3597,3628 ****
 >   static char *
 >   read_n_bytes (bfd *abfd, char *buf, unsigned int size)
 >   {
 > !   /* If the size of a host char is 8 bits, we can return a pointer
 > !      to the buffer, otherwise we have to copy the data to a buffer
 > !      allocated on the temporary obstack.  */
 > ! #if HOST_CHAR_BIT == 8
 >     return buf;
 > - #else
 > -   char *ret;
 > -   unsigned int i;
 > - 
 > -   ret = obstack_alloc (&dwarf2_tmp_obstack, size);
 > -   for (i = 0; i < size; ++i)
 > -     {
 > -       ret[i] = bfd_get_8 (abfd, (bfd_byte *) buf);
 > -       buf++;
 > -     }
 > -   return ret;
 > - #endif
 >   }
 >   
 >   static char *
 >   read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
 >   {
 > !   /* If the size of a host char is 8 bits, we can return a pointer
 > !      to the string, otherwise we have to copy the string to a buffer
 > !      allocated on the temporary obstack.  */
 > ! #if HOST_CHAR_BIT == 8
 >     if (*buf == '\0')
 >       {
 >         *bytes_read_ptr = 1;
 > --- 3628,3643 ----
 >   static char *
 >   read_n_bytes (bfd *abfd, char *buf, unsigned int size)
 >   {
 > !   /* Require host char == 8 bits.  Other parts of GDB already do this (findvar.c).  */
 > !   gdb_assert (HOST_CHAR_BIT == 8);
 >     return buf;
 >   }
 >   
 >   static char *
 >   read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
 >   {
 > !   /* Require host char == 8 bits.  Other parts of GDB already do this (findvar.c).  */
 > !   gdb_assert (HOST_CHAR_BIT == 8);
 >     if (*buf == '\0')
 >       {
 >         *bytes_read_ptr = 1;
 > ***************
 > *** 3630,3654 ****
 >       }
 >     *bytes_read_ptr = strlen (buf) + 1;
 >     return buf;
 > ! #else
 > !   int byte;
 > !   unsigned int i = 0;
 >   
 > !   while ((byte = bfd_get_8 (abfd, (bfd_byte *) buf)) != 0)
 >       {
 > !       obstack_1grow (&dwarf2_tmp_obstack, byte);
 > !       i++;
 > !       buf++;
 >       }
 > !   if (i == 0)
 >       {
 > !       *bytes_read_ptr = 1;
 >         return NULL;
 >       }
 > !   obstack_1grow (&dwarf2_tmp_obstack, '\0');
 > !   *bytes_read_ptr = i + 1;
 > !   return obstack_finish (&dwarf2_tmp_obstack);
 > ! #endif
 >   }
 >   
 >   static unsigned long
 > --- 3645,3675 ----
 >       }
 >     *bytes_read_ptr = strlen (buf) + 1;
 >     return buf;
 > ! }
 >   
 > ! static char *
 > ! read_indirect_string (bfd *abfd, char *buf,
 > !                       const struct comp_unit_head *cu_header,
 > ! 		      unsigned int *bytes_read_ptr)
 > ! {
 > !   LONGEST str_offset = read_offset (abfd, buf, cu_header,
 > !                                     (int *) bytes_read_ptr);
 > !   if (dwarf_str_buffer == NULL)
 >       {
 > !       error ("DW_FORM_strp used without .debug_str section");
 > !       return NULL;
 >       }
 > ! 
 > !   if (str_offset >= dwarf_str_size)
 >       {
 > !       error ("DW_FORM_strp pointing outside of .debug_str section");
 >         return NULL;
 >       }
 > ! 
 > !   gdb_assert (HOST_CHAR_BIT == 8);
 > !   if (dwarf_str_buffer[str_offset] == '\0')
 > !     return NULL;
 > !   return dwarf_str_buffer + str_offset;
 >   }
 >   
 >   static unsigned long
 > ***************
 > *** 5552,5557 ****
 > --- 5573,5579 ----
 >   	  fprintf (stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
 >   	  break;
 >   	case DW_FORM_string:
 > + 	case DW_FORM_strp:
 >   	  fprintf (stderr, "string: \"%s\"",
 >   		   DW_STRING (&die->attrs[i])
 >   		   ? DW_STRING (&die->attrs[i]) : "");
 > ***************
 > *** 5562,5569 ****
 >   	  else
 >   	    fprintf (stderr, "flag: FALSE");
 >   	  break;
 > - 	case DW_FORM_strp:	/* we do not support separate string
 > - 				   section yet */
 >   	case DW_FORM_indirect:	/* we do not handle indirect yet */
 >   	default:
 >   	  fprintf (stderr, "unsupported attribute form: %d.",
 > --- 5584,5589 ----