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

Elena Zannoni
2001-12-07T14:52:38Z

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 ----