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

Michael Elizabeth Chastain
2001-12-07T11:22:04Z

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