From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 17021 invoked by alias); 19 Jan 2004 22:43:48 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 16991 invoked from network); 19 Jan 2004 22:43:47 -0000 Received: from unknown (HELO coconut.kealia.com) (209.3.10.89) by sources.redhat.com with SMTP; 19 Jan 2004 22:43:47 -0000 Received: from coconut.kealia.com (localhost.localdomain [127.0.0.1]) by coconut.kealia.com (8.12.8/8.12.8) with ESMTP id i0JMh60t022298; Mon, 19 Jan 2004 14:43:06 -0800 Received: (from carlton@localhost) by coconut.kealia.com (8.12.8/8.12.8/Submit) id i0JMh4cb022296; Mon, 19 Jan 2004 14:43:04 -0800 X-Authentication-Warning: coconut.kealia.com: carlton set sender to carlton@kealia.com using -f To: gdb-patches@sources.redhat.com Cc: Elena Zannoni , Jim Blandy , Daniel Jacobowitz , Michael Elizabeth Chastain Subject: [rfa] set processing_current_prefix properly (PR gdb/1520) From: David Carlton Date: Mon, 19 Jan 2004 22:43:00 -0000 Message-ID: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-SW-Source: 2004-01/txt/msg00530.txt.bz2 This is a fix for PR gdb/1520, a namespace problem with GCC 3.4. The problem was that, if we have this situation: namespace N { void foo() { } } then the compiler I had been using generated dies as following in its DWARF 2 output: 1: DW_TAG_namespace: 2: DW_TAG_subprogram: // Definition of N::foo whereas GCC head does: 1: DW_TAG_namespace: 2: DW_TAG_subprogram: // Declaration for N::foo 3: DW_TAG_subprogram: DW_AT_specification: reference to die #2 // Definition of N::foo. So I've added code to notice if a die representing a function's definition has a specification located elsewhere; if so, it looks at that specification to discover the current enclosing class/namespace. (Probably there are other places where we need to do this; hopefully, after a bit more experience, we'll find a less ad-hoc way of handling this issue.) It also fixes an inconsistency in my last patch - I had tried to maintain the invariant that processing_current_prefix was always non-NULL (i.e. was an actual string, albeit possibly an empty one), but I was using determine_prefix in ways that violated that invariant. Tested on i686-pc-linux-gnu, DWARF 2, with GCC 3.2, GCC 3.2 + DW_TAG_namespace patch, GCC 2.95.3, and GCC head. No regressions; fixes lots of FAILs in gdb.cp/namespace.exp with GCC head. (From now on, I'll probably stop testing with my patched GCC 3.2 and switch to using a GCC snapshot generating DW_TAG_namespace, so I don't miss problems like this.) Okay to commit? David Carlton carlton@kealia.com 2004-01-19 David Carlton Patch for PR c++/1520: * dwarf2read.c (read_func_scope): Set processing_current_prefix properly if we have a specification die. (possibly_determine_prefix): Rename from determine_prefix. (determine_prefix): Like the old determine_prefix, but never returns NULL. Index: dwarf2read.c =================================================================== RCS file: /cvs/src/src/gdb/dwarf2read.c,v retrieving revision 1.122 diff -u -p -r1.122 dwarf2read.c --- dwarf2read.c 17 Jan 2004 05:35:47 -0000 1.122 +++ dwarf2read.c 19 Jan 2004 20:20:13 -0000 @@ -774,6 +774,8 @@ static void read_type_die (struct die_in static char *determine_prefix (struct die_info *die); +static char *possibly_determine_prefix (struct die_info *die); + static char *typename_concat (const char *prefix, const char *suffix); static char *class_name (struct die_info *die); @@ -2180,6 +2182,8 @@ read_func_scope (struct die_info *die, s struct die_info *child_die; struct attribute *attr; char *name; + const char *previous_prefix = processing_current_prefix; + struct cleanup *back_to = NULL; name = dwarf2_linkage_name (die); @@ -2188,6 +2192,18 @@ read_func_scope (struct die_info *die, s if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu)) return; + if (cu_language == language_cplus) + { + struct die_info *spec_die = die_specification (die); + + if (spec_die != NULL) + { + char *specification_prefix = determine_prefix (spec_die); + processing_current_prefix = specification_prefix; + back_to = make_cleanup (xfree, specification_prefix); + } + } + lowpc += baseaddr; highpc += baseaddr; @@ -2238,6 +2254,10 @@ read_func_scope (struct die_info *die, s symbols go in the file symbol list. */ if (outermost_context_p ()) list_in_scope = &file_symbols; + + processing_current_prefix = previous_prefix; + if (back_to != NULL) + do_cleanups (back_to); } /* Process all the DIES contained within a lexical block scope. Start @@ -5942,12 +5962,23 @@ read_type_die (struct die_info *die, str do_cleanups (back_to); } +/* Return the name of the namespace/class that DIE is defined within, + or "" if we can't tell. The caller should xfree the result. */ + +static char * +determine_prefix (struct die_info *die) +{ + char *prefix = possibly_determine_prefix (die); + + return prefix ? prefix : xstrdup (""); +} + /* Return the name of the namespace/class that DIE is defined within, or NULL if we can't tell. The caller should xfree the result. */ static char * -determine_prefix (struct die_info *die) +possibly_determine_prefix (struct die_info *die) { struct die_info *parent; @@ -5962,7 +5993,7 @@ determine_prefix (struct die_info *die) } else { - char *parent_prefix = determine_prefix (parent); + char *parent_prefix = possibly_determine_prefix (parent); char *retval; switch (parent->tag) {