+2002-10-22 David Carlton <carlton@math.stanford.edu>
+
+ * Makefile.in (buildsym.o): Depend on $(gdb_assert_h) and
+ $(cp_support_h).
+ (cp-support.o): Fix dependencies and add $(gdb_obstack_h) and
+ $(gdb_assert_h).
+ (symtab.o): Depend on $(cp_support_h).
+ * symtab.h: Add opaque declaration for struct using_direct_node.
+ (struct block): Add member 'language_specific'.
+ (BLOCK_USING): New macro.
+ * symtab.c: #include "cp-support.h"
+ (lookup_symbol_aux): Call lookup_symbol_aux_nonlocal and
+ lookup_symbol_aux_using when appropriate.
+ (lookup_symbol_aux_nonlocal): New function.
+ (lookup_symbol_aux_using): New function.
+ (lookup_symbol_aux_using_loop): New function.
+ * symfile.h: Add opaque declaration for struct obstack.
+ Declare obsavestring to take a const char *.
+ * symfile.c (obsavestring): Make first argument a const char *.
+ * jv-lang.c (get_java_class_symtab): Initialize BLOCK_USING.
+ * dwarf2read.c: New variable current_namespace.
+ (scan_partial_symbols): Handle DW_TAG_namespace.
+ (psymtab_to_symtab_1): Initialize current_namespace.
+ (process_die): Handle DW_TAG_namespace,
+ DW_TAG_imported_declaration, DW_TAG_imported_module.
+ (read_namespace): New function.
+ (dwarf2_name): New function.
+ (dwarf2_extension): New function.
+ (dwarf_tag_name): Add DWARF 3 names.
+ (dwarf_attr_name): Ditto.
+ (dwarf_type_encoding_name): Ditto.
+ * cp-support.h: Opaque declaration for struct obstack.
+ (struct using_direct): New struct.
+ (struct using_direct_node): New struct.
+ Add declarations for cp_add_using_obstack, cp_add_using_xmalloc,
+ cp_copy_usings, cp_free_usings, cp_find_first_component.
+ * cp-support.c: #include "gdb_obstack.h", "gdb_assert.h".
+ Comment on demangled name pitfalls.
+ (cp_add_using_obstack): New function.
+ (cp_add_using_xmalloc): New function.
+ (cp_copy_usings): New function.
+ (cp_free_usings): New function.
+ (cp_find_first_component): New function.
+ * buildsym.h: Declare processing_has_namespace_info.
+ Declare add_using_directive.
+ * buildsym.c: #include "gdb_assert.h", "cp-support.h".
+ Change comment after #include "symfile.h".
+ New variable using_list.
+ (add_symbol_to_list): Scan for anonymous namespaces when
+ appropriate.
+ (scan_for_anonymous_namespaces): New function.
+ (add_using_directive): New function.
+ (start_symtab): Initialize processing_has_namespace_info,
+ using_list.
+ (end_symtab): Copy using_list into block.
+ (copy_usings_to_obstack): New function.
+ (finish_block): Set BLOCK_USING in general case and in C++
+ function case.
+
2002-10-11 David Carlton <carlton@math.stanford.edu>
* symtab.c (lookup_symbol_aux): Move chunks of code into separate
$(symfile_h) $(objfiles_h) $(gdbtypes_h) $(complaints_h) \
$(gdb_string_h) $(expression_h) $(language_h) $(bcache_h) \
$(filenames_h) $(macrotab_h) $(demangle_h) $(buildsym_h) \
- $(stabsread_h)
+ $(stabsread_h) $(gdb_assert_h) $(cp_support_h)
builtin-regs.o: builtin-regs.c $(defs_h) $(builtin_regs_h) $(gdbtypes_h) \
$(gdb_string_h) $(gdb_assert_h)
c-lang.o: c-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \
$(symtab_h) $(command_h) $(bfd_h) $(target_h) $(gdbcore_h) \
$(gdbthread_h) $(regcache_h) $(symfile_h)
cp-abi.o: cp-abi.c $(defs_h) $(value_h) $(cp_abi_h) $(gdb_string_h)
-cp-support.o: cp-support.c $(defs_h) $(cp_support_h)
+cp-support.o: cp-support.c $(defs_h) $(cp_support_h) $(gdb_string_h) \
+ $(demangle_h) $(gdb_obstack_h) $(gdb_assert_h)
cp-valprint.o: cp-valprint.c $(defs_h) $(gdb_obstack_h) $(symtab_h) \
$(gdbtypes_h) $(expression_h) $(value_h) $(command_h) $(gdbcmd_h) \
$(demangle_h) $(annotate_h) $(gdb_string_h) $(c_lang_h) $(target_h) \
$(gdbcmd_h) $(call_cmds_h) $(gdb_regex_h) $(expression_h) \
$(language_h) $(demangle_h) $(inferior_h) $(linespec_h) \
$(filenames_h) $(gdb_obstack_h) $(gdb_string_h) $(gdb_stat_h) \
- $(cp_abi_h) $(source_h)
+ $(cp_abi_h) $(source_h) $(cp_support_h)
target.o: target.c $(defs_h) $(gdb_string_h) $(target_h) $(gdbcmd_h) \
$(symtab_h) $(inferior_h) $(bfd_h) $(symfile_h) $(objfiles_h) \
$(gdb_wait_h) $(dcache_h) $(regcache_h)
#include "bfd.h"
#include "gdb_obstack.h"
#include "symtab.h"
-#include "symfile.h" /* Needed for "struct complaint" */
+#include "symfile.h" /* Needed for "struct complaint", obsavestring */
#include "objfiles.h"
#include "gdbtypes.h"
#include "complaints.h"
#include "filenames.h" /* For DOSish file names */
#include "macrotab.h"
#include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
+#include "gdb_assert.h"
+#include "cp-support.h"
/* Ask buildsym.h to define the vars it normally declares `extern'. */
#define EXTERN
/**/
otherwise empty symtab from being tossed. */
static int have_line_numbers;
+
+/* List of using directives that are active in the current file. */
+
+static struct using_direct_node *using_list;
+
\f
static int compare_line_numbers (const void *ln1p, const void *ln2p);
+
+static void scan_for_anonymous_namespaces (struct symbol *symbol);
+
+static struct using_direct_node *copy_usings_to_obstack (struct
+ using_direct_node
+ *usings,
+ struct obstack
+ *obstack);
\f
/* Initial sizes of data structures. These are realloc'd larger if
}
}
-/* Add a symbol to one of the lists of symbols. */
+/* Add a symbol to one of the lists of symbols. While we're at it, if
+ we're in the C++ case and don't have full namespace debugging info,
+ check to see if it references an anonymous namespace; if so, add an
+ appropriate using directive. */
void
add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
}
(*listhead)->symbol[(*listhead)->nsyms++] = symbol;
+
+ /* Check to see if we might need to look for a mention of anonymous
+ namespaces. */
+
+ if (SYMBOL_LANGUAGE (symbol) == language_cplus
+ && !processing_has_namespace_info
+ && SYMBOL_CPLUS_DEMANGLED_NAME (symbol) != NULL)
+ scan_for_anonymous_namespaces (symbol);
+}
+
+/* Check to see if a symbol is contained within an anonymous
+ namespace; if so, add an appropriate using directive. */
+
+/* Optimize away strlen ("(anonymous namespace)"). */
+
+#define ANONYMOUS_NAMESPACE_LEN 21
+
+static void
+scan_for_anonymous_namespaces (struct symbol *symbol)
+{
+ const char *name = SYMBOL_CPLUS_DEMANGLED_NAME (symbol);
+ const char *beginning, *end;
+
+ /* FIXME: carlton/2002-10-14: Should we do some sort of fast search
+ first to see if the substring "(anonymous namespace)" occurs in
+ name at all? */
+
+ for (beginning = name, end = cp_find_first_component (name);
+ *end == ':';
+ /* The "+ 2" is for the "::"-. */
+ beginning = end + 2, end = cp_find_first_component (beginning))
+ {
+ if ((end - beginning) == ANONYMOUS_NAMESPACE_LEN
+ && strncmp (beginning, "(anonymous namespace)",
+ ANONYMOUS_NAMESPACE_LEN) == 0)
+ /* We've found a component of the name that's an anonymous
+ namespace. So add symbols in it to the namespace given by
+ the previous component if there is one, or to the global
+ namespace if there isn't. */
+ add_using_directive (name,
+ beginning == name ? 0 : beginning - name - 2,
+ end - name);
+ }
}
/* Find a symbol named NAME on a LIST. NAME need not be
return (NULL);
}
+/* This adds a using directive to using_list. NAME is the start of a
+ string that should contain the namespaces we want to add as initial
+ substrings, OUTER_LENGTH is the end of the outer namespace, and
+ INNER_LENGTH is the end of the inner namespace. If the using
+ directive in question has already been added, don't add it
+ twice. */
+
+void
+add_using_directive (const char *name, unsigned int outer_length,
+ unsigned int inner_length)
+{
+ struct using_direct_node *current;
+ struct using_direct_node *new_node;
+ struct using_direct *new;
+
+ gdb_assert (outer_length < inner_length);
+
+ /* Has it already been added? */
+
+ for (current = using_list; current; current = current->next)
+ if (current->current->outer_length == outer_length
+ && current->current->inner_length == inner_length
+ && (strncmp (current->current->name, name, inner_length) == 0))
+ return;
+
+ using_list = cp_add_using_xmalloc (name, outer_length, inner_length,
+ using_list);
+}
+
/* At end of reading syms, or in case of quit, really free as many
`struct pending's as we can easily find. */
BLOCK_END (block) = end;
/* Superblock filled in when containing block is made */
BLOCK_SUPERBLOCK (block) = NULL;
+ BLOCK_USING (block) = NULL;
BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
}
}
}
+
+ /* If we're in the C++ case, make sure that we add 'using'
+ directives for all of the namespaces in which this function
+ lives. Also, make sure that the name was originally mangled:
+ if not, there certainly isn't any namespace information to
+ worry about! (Also, if not, the gdb_assert will fail.) */
+ if (SYMBOL_LANGUAGE (symbol) == language_cplus
+ && SYMBOL_CPLUS_DEMANGLED_NAME (symbol) != NULL)
+ {
+ const char *name = SYMBOL_CPLUS_DEMANGLED_NAME (symbol);
+ const char *next;
+
+ for (next = cp_find_first_component (name);
+ *next == ':';
+ /* The '+ 2' is to skip the '::'. */
+ next = cp_find_first_component (next + 2))
+ {
+ BLOCK_USING (block)
+ = cp_add_using_obstack (name, 0, next - name,
+ BLOCK_USING (block),
+ &objfile->symbol_obstack);
+ }
+
+ /* FIMXE: carlton/2002-10-09: Until I understand the
+ possible pitfalls of demangled names a lot better, I want
+ to make sure I'm not running into surprises. */
+ gdb_assert (*next == '\0');
+ }
}
else
{
global_symbols = NULL;
within_function = 0;
have_line_numbers = 0;
+ processing_has_namespace_info = 0;
+ using_list = NULL;
/* Context stack is initially empty. Allocate first one with room
for 10 levels; reuse it forever afterward. */
finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr,
objfile);
blockvector = make_blockvector (objfile);
+ if (using_list != NULL)
+ {
+ BLOCK_USING (BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK))
+ = copy_usings_to_obstack (using_list,
+ &objfile->symbol_obstack);
+ using_list = NULL;
+ }
}
#ifndef PROCESS_LINENUMBER_HOOK
return symtab;
}
+/* This reallocates USINGS using OBSTACK and xfree's USINGS. It
+ returns the reallocated version of USINGS. */
+
+static struct using_direct_node *
+copy_usings_to_obstack (struct using_direct_node *usings,
+ struct obstack *obstack)
+{
+ if (usings == NULL)
+ return NULL;
+ else
+ {
+ struct using_direct_node *new_node
+ = cp_add_using_obstack (usings->current->name,
+ usings->current->outer_length,
+ usings->current->inner_length,
+ copy_usings_to_obstack (usings->next,
+ obstack),
+ obstack);
+
+ xfree (usings->current);
+ xfree (usings);
+
+ return new_node;
+ }
+}
+
/* Push a context block. Args are an identifying nesting level
(checkable when you pop it), and the starting PC address of this
context. */
EXTERN unsigned char processing_hp_compilation;
+/* When set, the file that we're processing seems to have debugging
+ info for C++ namespaces, so buildsym.c shouldn't try to guess
+ namespace info itself. */
+
+EXTERN unsigned char processing_has_namespace_info;
+
/* Count symbols as they are processed, for error messages. */
EXTERN unsigned int symnum;
extern struct symbol *find_symbol_in_list (struct pending *list,
char *name, int length);
+extern void add_using_directive (const char *name, unsigned int outer_length,
+ unsigned int inner_length);
+
extern void finish_block (struct symbol *symbol,
struct pending **listhead,
struct pending_block *old_blocks,
#include "cp-support.h"
#include "gdb_string.h"
#include "demangle.h"
+#include "gdb_obstack.h"
+#include "gdb_assert.h"
+
+/* Here are some random pieces of trivia to keep in mind while trying
+ to take apart demangled names:
+
+ - Names can contain function arguments or templates, so the process
+ has to be, to some extent recursive: maybe keep track of your
+ depth based on encountering <> and ().
+
+ - Parentheses don't just have to happen at the end of a name: they
+ can occur even if the name in question isn't a function, because
+ a template argument might be a type that's a function.
+
+ - Conversely, even if you're trying to deal with a function, its
+ demangled name might not end with ')': it could be a const (or
+ volatile, I suppose) class method, in which case it ends with
+ "const".
+
+ - Parentheses are also used in anonymous namespaces: a variable
+ 'foo' in an anonymous namespace gets demangled as "(anonymous
+ namespace)::foo".
+
+ - And operator names can contain parentheses or angle brackets.
+ Fortunately, I _think_ that operator names can only occur in a
+ fairly restrictive set of locations (in particular, they have be
+ at depth 0, don't they?). */
+
+/* FIXME: carlton/2002-10-09: Do all the functions here handle all the
+ above considerations correctly? */
/* Find the last component of the demangled C++ name NAME. NAME
must be a method name including arguments, in order to correctly
xfree (demangled_name);
return ret;
}
+
+/* This allocates a new using_direct structure initialized to contain
+ NAME, OUTER_LENGTH, and INNER_LENGTH, and puts it at the beginning
+ of the linked list given by NEXT. It returns the resulting struct
+ using_direct_node. All memory is allocated using OBSTACK. */
+
+struct using_direct_node *
+cp_add_using_obstack (const char *name,
+ unsigned short outer_length,
+ unsigned short inner_length,
+ struct using_direct_node *next,
+ struct obstack *obstack)
+{
+ struct using_direct *current
+ = obstack_alloc (obstack, sizeof (struct using_direct));
+ struct using_direct_node *retval
+ = obstack_alloc (obstack, sizeof (struct using_direct_node));
+
+ gdb_assert (outer_length < inner_length);
+
+ current->name = name;
+ current->outer_length = outer_length;
+ current->inner_length = inner_length;
+ retval->current = current;
+ retval->next = next;
+
+ return retval;
+}
+
+/* Same as cp_add_using, except that it uses xmalloc instead of
+ obstacks. */
+
+struct using_direct_node *
+cp_add_using_xmalloc (const char *name,
+ unsigned short outer_length,
+ unsigned short inner_length,
+ struct using_direct_node *next)
+{
+ struct using_direct *current = xmalloc (sizeof (struct using_direct));
+ struct using_direct_node *retval
+ = xmalloc (sizeof (struct using_direct_node));
+
+ gdb_assert (outer_length < inner_length);
+
+ current->name = name;
+ current->outer_length = outer_length;
+ current->inner_length = inner_length;
+ retval->current = current;
+ retval->next = next;
+
+ return retval;
+}
+
+/* This copies the using_direct_nodes in TOCOPY, using xmalloc, and
+ sticks them onto a list ending in TAIL. (It doesn't copy the
+ using_directs, just the using_direct_nodes.) */
+
+struct using_direct_node *
+cp_copy_usings (struct using_direct_node *tocopy,
+ struct using_direct_node *tail)
+{
+ struct using_direct_node *new_node;
+
+ if (tocopy == NULL)
+ return tail;
+
+ new_node = xmalloc (sizeof (struct using_direct_node));
+ new_node->current = tocopy->current;
+ new_node->next = cp_copy_usings (tocopy->next, tail);
+
+ return new_node;
+}
+
+/* This xfree's all the using_direct_nodes in USING (but not their
+ using_directs!) */
+void
+cp_free_usings (struct using_direct_node *using)
+{
+ struct using_direct_node *next;
+
+ if (using != NULL)
+ {
+ for (next = using->next; next;
+ using = next, next = next->next)
+ xfree (using);
+
+ xfree (using);
+ }
+}
+
+
+/* This returns the first component of NAME, which should be the
+ demangled name of a C++ variable/function/method/etc.
+ Specifically, it returns a pointer to the first colon forming the
+ boundary of the first component: so, given 'A::foo' or 'A::B::foo'
+ it returns a pointer to the first :, and given 'foo', it returns a
+ pointer to the trailing '\0'. */
+
+/* Well, that's what it should do when called externally, but to make
+ the recursion easier, it also stops if it reaches an unexpected ')'
+ or '>'. */
+
+/* Let's optimize away calls to strlen("operator"). */
+
+#define LENGTH_OF_OPERATOR 8
+
+const char *
+cp_find_first_component (const char *name)
+{
+ /* Names like 'operator<<' screw up the recursion, so let's
+ special-case them. I _hope_ they can only occur at the start of
+ a component. */
+
+ if (strncmp (name, "operator", LENGTH_OF_OPERATOR) == 0)
+ {
+ name += LENGTH_OF_OPERATOR;
+ switch (*name)
+ {
+ case '<':
+ if (name[1] == '<')
+ name += 2;
+ else
+ name += 1;
+ break;
+ case '>':
+ case '-':
+ if (name[1] == '>')
+ name +=2;
+ else
+ name += 1;
+ break;
+ case '(':
+ name += 2;
+ break;
+ default:
+ name += 1;
+ break;
+ }
+ }
+
+ for (;; ++name)
+ {
+ switch (*name)
+ {
+ case '<':
+ /* Template; eat it up. The calls to cp_first_component
+ should only return (I hope!) when they reach the '>'
+ terminating the component or a '::' between two
+ components. (Hence the '+ 2'.) */
+ for (name = cp_find_first_component (name + 1);
+ *name != '>';
+ name = cp_find_first_component (name + 2))
+ gdb_assert (*name == ':');
+ break;
+ case '(':
+ /* Similar comment as to '<'. */
+ for (name = cp_find_first_component (name + 1);
+ *name != ')';
+ name = cp_find_first_component (name + 2))
+ gdb_assert (*name == ':');
+ break;
+ case '>':
+ case ')':
+ case '\0':
+ case ':':
+ return name;
+ default:
+ break;
+ }
+ }
+}
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+/* Opaque declarations. */
+
+struct obstack;
+
extern char *class_name_from_physname (const char *physname);
extern char *method_name_from_physname (const char *physname);
+
+extern const char *cp_find_first_component (const char *name);
+
+/* This is a struct to store data from "using directives" and similar
+ language constructs. NAME is a pointer to a string; its initial
+ substrings of length OUTER_LENGTH and INNER_LENGTH should both be
+ fully-qualified namespace names. (And OUTER_LENGTH should be
+ strictly less than INNER_LENGTH). The meaning is that names in the
+ inner namespace should be imported into outer.
+
+ For example, if it is used to represent the directive "using
+ namespace std;" then NAME should start with "std", INNER_LENGTH
+ should be 0, and OUTER_LENGTH should be "3". For a more
+ complicated example, if there is an anonymous namespace with a
+ named namespace A, then NAME should start with "A::(anonymous
+ namespace)", INNER_LENGTH should be 1, and OUTER_LENGTH should be
+ strlen ("A::(anonymous namespace)"). */
+
+/* FIXME: carlton/2002-10-07: That anonymous namespace example isn't
+ that great, since it really depends not only on what the
+ demangler's output is but also on the fact that the demangler's
+ output doesn't depend on the name of the file in question. Which,
+ alas, it doesn't, but should, leaving us with no way to distinguish
+ between anonymous namespaces in different files. Sigh... */
+
+struct using_direct
+{
+ const char *name;
+ unsigned short outer_length;
+ unsigned short inner_length;
+};
+
+/* This is a struct for a linked list of using_direct's. */
+
+struct using_direct_node
+{
+ struct using_direct *current;
+ struct using_direct_node *next;
+};
+
+extern struct
+using_direct_node *cp_add_using_obstack (const char *name,
+ unsigned short outer_length,
+ unsigned short inner_length,
+ struct using_direct_node *next,
+ struct obstack *obstack);
+
+extern
+struct using_direct_node *cp_add_using_xmalloc (const char *name,
+ unsigned short outer_length,
+ unsigned short inner_length,
+ struct using_direct_node
+ *next);
+
+extern
+struct using_direct_node *cp_copy_usings (struct using_direct_node *tocopy,
+ struct using_direct_node *tail);
+
+extern void cp_free_usings (struct using_direct_node *using);
in buildsym.c. */
static struct pending **list_in_scope = &file_symbols;
+/* If we're debugging C++ code, this string should contain the name of
+ the current namespace. Other people shouldn't have to copy it when
+ referring to it, so don't free its previous contents when setting
+ this to a new value. */
+
+static const char *current_namespace;
+
/* FIXME: decode_locdesc sets these variables to describe the location
to the caller. These ought to be a structure or something. If
none of the flags are set, the object lives at the address returned
static void read_common_block (struct die_info *, struct objfile *,
const struct comp_unit_head *);
+static void read_namespace (struct die_info *die, struct objfile *objfile,
+ const struct comp_unit_head *cu_header);
+
static void read_enumeration (struct die_info *, struct objfile *,
const struct comp_unit_head *);
static char *dwarf2_linkage_name (struct die_info *);
+static char *dwarf2_name (struct die_info *);
+
+static struct die_info *dwarf2_extension (struct die_info *die);
+
static char *dwarf_tag_name (unsigned int);
static char *dwarf_attr_name (unsigned int);
int nesting_level = 1;
+ /* What level do we consider to be file scope? This is normally 1,
+ but can get pushed up by DW_TAG_namespace entries. */
+
+ int file_scope_level = 1;
+
*lowpc = ((CORE_ADDR) -1);
*highpc = ((CORE_ADDR) 0);
{
*highpc = pdi.highpc;
}
- if ((pdi.is_external || nesting_level == 1)
+ if ((pdi.is_external || nesting_level == file_scope_level)
&& !pdi.is_declaration)
{
add_partial_symbol (&pdi, objfile, cu_header);
case DW_TAG_structure_type:
case DW_TAG_union_type:
case DW_TAG_enumeration_type:
- if ((pdi.is_external || nesting_level == 1)
+ if ((pdi.is_external || nesting_level == file_scope_level)
&& !pdi.is_declaration)
{
add_partial_symbol (&pdi, objfile, cu_header);
case DW_TAG_enumerator:
/* File scope enumerators are added to the partial symbol
table. */
- if (nesting_level == 2)
+ if (nesting_level == file_scope_level + 1)
add_partial_symbol (&pdi, objfile, cu_header);
break;
case DW_TAG_base_type:
/* File scope base type definitions are added to the partial
symbol table. */
- if (nesting_level == 1)
+ if (nesting_level == file_scope_level)
add_partial_symbol (&pdi, objfile, cu_header);
break;
+ case DW_TAG_namespace:
+ /* FIXME: carlton/2002-10-16: we're not yet doing
+ anything useful with this, but for now make sure that
+ these tags at least don't cause us to miss any
+ important symbols. */
+ if (pdi.has_children)
+ file_scope_level++;
default:
break;
}
}
- /* If the die has a sibling, skip to the sibling.
- Do not skip enumeration types, we want to record their
- enumerators. */
- if (pdi.sibling && pdi.tag != DW_TAG_enumeration_type)
+ /* If the die has a sibling, skip to the sibling. Do not skip
+ enumeration types, we want to record their enumerators. Do
+ not skip namespaces, we want to record symbols inside
+ them. */
+ if (pdi.sibling
+ && pdi.tag != DW_TAG_enumeration_type
+ && pdi.tag != DW_TAG_namespace)
{
info_ptr = pdi.sibling;
}
else if (pdi.has_children)
{
- /* Die has children, but the optional DW_AT_sibling attribute
- is missing. */
+ /* Die has children, but either the optional DW_AT_sibling
+ attribute is missing or we want to look at them. */
nesting_level++;
}
if (pdi.tag == 0)
{
nesting_level--;
+ /* If this is the end of a DW_TAG_namespace entry, then
+ decrease the file_scope_level, too. */
+ if (nesting_level < file_scope_level)
+ file_scope_level--;
}
}
cu_header_offset = offset;
info_ptr = dwarf_info_buffer + offset;
+ /* We're in the global namespace. */
+ current_namespace = "";
+
obstack_init (&dwarf2_tmp_obstack);
back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
break;
case DW_TAG_common_inclusion:
break;
+ case DW_TAG_namespace:
+ processing_has_namespace_info = 1;
+ read_namespace (die, objfile, cu_header);
+ break;
+ case DW_TAG_imported_declaration:
+ case DW_TAG_imported_module:
+ /* FIXME: carlton/2002-10-16: Eventually, we should use the
+ information contained in these. DW_TAG_imported_declaration
+ dies shouldn't have children; DW_TAG_imported_module dies
+ shouldn't in the C++ case, but conceivably could in the
+ Fortran case, so we'll have to replace this gdb_assert if
+ Fortran compilers start generating that info. */
+ processing_has_namespace_info = 1;
+ gdb_assert (!die->has_children);
+ break;
default:
new_symbol (die, NULL, objfile, cu_header);
break;
}
}
+/* Read a C++ namespace. */
+
+/* FIXME: carlton/2002-10-16: For now, we don't actually do anything
+ useful with the namespace data: we just process its children. */
+
+static void
+read_namespace (struct die_info *die, struct objfile *objfile,
+ const struct comp_unit_head *cu_header)
+{
+ const char *previous_namespace = current_namespace;
+ const char *name = NULL;
+ int is_anonymous;
+ struct die_info *current_die;
+
+ /* Loop through the extensions until we find a name. */
+
+ for (current_die = die; current_die != NULL;
+ current_die = dwarf2_extension (die))
+ {
+ name = dwarf2_name (die);
+ if (name != NULL)
+ break;
+ }
+
+ /* Is it an anonymous namespace? */
+
+ is_anonymous = (name == NULL);
+ if (is_anonymous)
+ name = "(anonymous namespace)";
+
+ /* Now build the name of the current namespace. */
+
+ current_namespace = obconcat (&objfile->symbol_obstack,
+ previous_namespace,
+ previous_namespace[0] == '\0' ? "" : "::",
+ name);
+
+ /* If it's an anonymous namespace that we're seeing for the first
+ time, add a using directive. */
+
+ if (is_anonymous && dwarf_attr (die, DW_AT_extension) == NULL)
+ add_using_directive (current_namespace,
+ strlen (previous_namespace),
+ strlen (current_namespace));
+
+
+ if (die->has_children)
+ {
+ struct die_info *child_die = die->next;
+
+ while (child_die && child_die->tag)
+ {
+ process_die (child_die, objfile, cu_header);
+ child_die = sibling_die (child_die);
+ }
+ }
+
+ current_namespace = previous_namespace;
+}
+
/* Extract all information from a DW_TAG_pointer_type DIE and add to
the user defined type vector. */
return NULL;
}
+/* Get name of a die, return NULL if not found. */
+
+static char *
+dwarf2_name (struct die_info *die)
+{
+ struct attribute *attr;
+
+ attr = dwarf_attr (die, DW_AT_name);
+ if (attr && DW_STRING (attr))
+ return DW_STRING (attr);
+ return NULL;
+}
+
+/* Return the die that this die in an extension of, or NULL if there
+ is none. */
+
+static struct die_info *
+dwarf2_extension (struct die_info *die)
+{
+ struct attribute *attr;
+ struct die_info *extension_die;
+ unsigned int ref;
+
+ attr = dwarf_attr (die, DW_AT_extension);
+ if (attr == NULL)
+ return NULL;
+
+ ref = dwarf2_get_ref_die_offset (attr);
+ extension_die = follow_die_ref (ref);
+ if (!extension_die)
+ {
+ error ("Dwarf Error: Cannot find referent at offset %d.", ref);
+ }
+
+ return extension_die;
+}
+
/* Convert a DIE tag into its string name. */
static char *
return "DW_TAG_variable";
case DW_TAG_volatile_type:
return "DW_TAG_volatile_type";
+ case DW_TAG_dwarf_procedure:
+ return "DW_TAG_dwarf_procedure";
+ case DW_TAG_restrict_type:
+ return "DW_TAG_restrict_type";
+ case DW_TAG_interface_type:
+ return "DW_TAG_interface_type";
+ case DW_TAG_namespace:
+ return "DW_TAG_namespace";
+ case DW_TAG_imported_module:
+ return "DW_TAG_imported_module";
+ case DW_TAG_unspecified_type:
+ return "DW_TAG_unspecified_type";
+ case DW_TAG_partial_unit:
+ return "DW_TAG_partial_unit";
+ case DW_TAG_imported_unit:
+ return "DW_TAG_imported_unit";
case DW_TAG_MIPS_loop:
return "DW_TAG_MIPS_loop";
case DW_TAG_format_label:
return "DW_AT_virtuality";
case DW_AT_vtable_elem_location:
return "DW_AT_vtable_elem_location";
-
+ case DW_AT_allocated:
+ return "DW_AT_allocated";
+ case DW_AT_associated:
+ return "DW_AT_associated";
+ case DW_AT_data_location:
+ return "DW_AT_data_location";
+ case DW_AT_stride:
+ return "DW_AT_stride";
+ case DW_AT_entry_pc:
+ return "DW_AT_entry_pc";
+ case DW_AT_use_UTF8:
+ return "DW_AT_use_UTF8";
+ case DW_AT_extension:
+ return "DW_AT_extension";
+ case DW_AT_ranges:
+ return "DW_AT_ranges";
+ case DW_AT_trampoline:
+ return "DW_AT_trampoline";
+ case DW_AT_call_column:
+ return "DW_AT_call_column";
+ case DW_AT_call_file:
+ return "DW_AT_call_file";
+ case DW_AT_call_line:
+ return "DW_AT_call_line";
#ifdef MIPS
case DW_AT_MIPS_fde:
return "DW_AT_MIPS_fde";
return "DW_ATE_unsigned";
case DW_ATE_unsigned_char:
return "DW_ATE_unsigned_char";
+ case DW_ATE_imaginary_float:
+ return "DW_ATE_imaginary_float";
default:
return "DW_ATE_<unknown>";
}
BLOCK_END (bl) = 0;
BLOCK_FUNCTION (bl) = NULL;
BLOCK_SUPERBLOCK (bl) = NULL;
+ BLOCK_USING (bl) = NULL;
BLOCK_GCC_COMPILED (bl) = 0;
BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
may be part of a larger string and we are only saving a substring. */
char *
-obsavestring (char *ptr, int size, struct obstack *obstackp)
+obsavestring (const char *ptr, int size, struct obstack *obstackp)
{
register char *p = (char *) obstack_alloc (obstackp, size + 1);
/* Open-coded memcpy--saves function call time. These strings are usually
short. FIXME: Is this really still true with a compiler that can
inline memcpy? */
{
- register char *p1 = ptr;
+ register const char *p1 = ptr;
register char *p2 = p;
- char *end = ptr + size;
+ const char *end = ptr + size;
while (p1 != end)
*p2++ = *p1++;
}
/* This file requires that you first include "bfd.h". */
+/* Opaque declarations. */
+
+struct obstack;
+
/* Partial symbols are stored in the psymbol_cache and pointers to them
are kept in a dynamically grown array that is obtained from malloc and
grown as necessary via realloc. Each objfile typically has two of these,
(and add a null character at the end in the copy).
Returns the address of the copy. */
-extern char *obsavestring (char *, int, struct obstack *);
+extern char *obsavestring (const char *, int, struct obstack *);
/* Concatenate strings S1, S2 and S3; return the new string.
Space is found in the symbol_obstack. */
#include "gdb_stat.h"
#include <ctype.h>
#include "cp-abi.h"
+#include "cp-support.h"
/* Prototype for one function in parser-defs.h,
instead of including that entire file. */
const namespace_enum namespace,
struct symtab **symtab);
+static
+struct symbol *lookup_symbol_aux_nonlocal (int block_index,
+ const char *name,
+ const char *mangled_name,
+ const namespace_enum namespace,
+ struct symtab **symtab);
+
static
struct symbol *lookup_symbol_aux_symtabs (int block_index,
const char *name,
const char *mangled_name,
const namespace_enum namespace,
struct symtab **symtab);
+
+static
+struct symbol *lookup_symbol_aux_using (const char *name,
+ const char *mangled_name,
+ const struct block *block,
+ const namespace_enum namespace,
+ struct symtab **symtab);
+
+static
+struct symbol *lookup_symbol_aux_using_loop (const char *prefix,
+ int prefix_len,
+ const char *rest,
+ struct using_direct_node *using,
+ const char *mangled_name,
+ namespace_enum namespace,
+ struct symtab **symtab);
+
static
struct symbol *lookup_symbol_aux_minsyms (const char *name,
const char *mangled_name,
of the desired name as a global, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, mangled_name,
- namespace, symtab);
- if (sym != NULL)
- return sym;
-
- sym = lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, mangled_name,
+ sym = lookup_symbol_aux_nonlocal (GLOBAL_BLOCK, name, mangled_name,
namespace, symtab);
if (sym != NULL)
return sym;
+ /* If we're in the C++ case, check to see if the symbol is defined
+ in a namespace accessible via a "using" declaration. */
+
+ /* FIXME: carlton/2002-10-10: is "is_a_field_of_this" always
+ non-NULL if we're in the C++ case? Maybe we should always do
+ this, and delete the two previous searches: this will always
+ search the global namespace, after all. */
+
+ if (is_a_field_of_this)
+ {
+ sym = lookup_symbol_aux_using (name, mangled_name, block, namespace,
+ symtab);
+ if (sym != NULL)
+ return sym;
+ }
+
#ifndef HPUXHPPA
/* Check for the possibility of the symbol being a function or a
desired name as a file-level static, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, mangled_name,
- namespace, symtab);
- if (sym != NULL)
- return sym;
-
- sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, mangled_name,
+ sym = lookup_symbol_aux_nonlocal (STATIC_BLOCK, name, mangled_name,
namespace, symtab);
if (sym != NULL)
return sym;
-
#ifdef HPUXHPPA
/* Check for the possibility of the symbol being a function or a
return NULL;
}
+/* Check to see if the symbol is defined in one of the symtabs or
+ psymtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
+ STATIC_BLOCK, depending on whether or not we want to search global
+ symbols or static symbols. */
+
+/* FIXME: carlton/2002-10-11: Should this also do some minsym
+ lookup? */
+
+static struct symbol *
+lookup_symbol_aux_nonlocal (int block_index,
+ const char *name,
+ const char *mangled_name,
+ const namespace_enum namespace,
+ struct symtab **symtab)
+{
+ struct symbol *sym;
+
+ sym = lookup_symbol_aux_symtabs (block_index, name, mangled_name,
+ namespace, symtab);
+ if (sym != NULL)
+ return sym;
+
+ return lookup_symbol_aux_psymtabs (block_index, name, mangled_name,
+ namespace, symtab);
+}
+
/* Check to see if the symbol is defined in one of the symtabs.
BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
depending on whether or not we want to search global symbols or
return NULL;
}
+/* This function gathers using directives from BLOCK and its
+ superblocks, and then searches for symbols in the global namespace
+ by trying to apply those various using directives. */
+static struct symbol *lookup_symbol_aux_using (const char *name,
+ const char *mangled_name,
+ const struct block *block,
+ const namespace_enum namespace,
+ struct symtab **symtab)
+{
+ struct using_direct_node *using = NULL;
+ struct symbol *sym;
+
+ while (block != NULL)
+ {
+ using = cp_copy_usings (BLOCK_USING (block), using);
+ block = BLOCK_SUPERBLOCK (block);
+ }
+
+ sym = lookup_symbol_aux_using_loop ("", 0, name, using, mangled_name,
+ namespace, symtab);
+ cp_free_usings (using);
+
+ return sym;
+}
+
+/* This tries to look up REST in the namespace given by the initial
+ substring of PREFIX of length PREFIX_LEN.
+
+ Basically, assume that we have using directives adding A to the
+ global namespace, adding A::inner to namespace A, and adding B to
+ the global namespace. Then, when looking up a symbol "foo", we
+ want to recurse by looking up stuff in A::foo and seeing which
+ using directives still apply. The only one that still applies
+ converts that to A::inner::foo: we _don't_ want to then look at
+ B::A::foo (let alone A::A::foo!). So we end up just looking at
+ A::foo, A::inner::foo, and B::foo. (Though if the original caller
+ to lookup_symbol had specified A::foo, we would want to look up
+ stuff in A::A::foo, A::inner::A::foo, A::inner::foo, and
+ B::A::foo). */
+
+/* FIXME: carlton/2002-10-11: There are still some places where this
+ will return false positives. For example, if you have namespaces
+ C, C::D, C::E, and C::D::E, then, from a function defined in C::D,
+ all references to variables E::var _should_ be treated as
+ C::D::E::var, but this function will also see variables in
+ C::E::var. I don't think this can be fixed without making
+ namespaces first-class objects. (Which is certainly a good idea
+ for other reasons, but it will take a little while.) */
+
+static struct symbol *
+lookup_symbol_aux_using_loop (const char *prefix,
+ int prefix_len,
+ const char *rest,
+ struct using_direct_node *using,
+ const char *mangled_name,
+ namespace_enum namespace,
+ struct symtab **symtab)
+{
+ struct using_direct_node *current;
+ struct symbol *sym;
+
+ for (current = using; current; current = current->next)
+ {
+ /* First, see if the prefix matches the start of this using
+ directive. */
+ if (prefix_len <= current->current->outer_length
+ && strncmp (prefix, current->current->name, prefix_len) == 0)
+ {
+ /* Great, it matches: now does the rest of the using
+ directive match the rest of the name? */
+
+ const char *rest_of_outer = current->current->name + prefix_len;
+ int rest_of_outer_len
+ = current->current->outer_length - prefix_len;
+ /* Should we skip some colons? Should be true unless
+ PREFIX_LEN is zero (and hence we're in the global
+ namespace) or we've finished all of outer. */
+ if (rest_of_outer_len != 0 && *rest_of_outer == ':')
+ {
+ rest_of_outer += 2;
+ rest_of_outer_len -= 2;
+ }
+ if (strncmp (rest_of_outer, rest, rest_of_outer_len) == 0)
+ {
+ /* Everything matches! Yippee! So apply the using
+ directive and recurse. */
+ const char *new_rest = rest + rest_of_outer_len;
+ if (*new_rest == ':')
+ new_rest += 2;
+
+ sym = lookup_symbol_aux_using_loop
+ (current->current->name,
+ current->current->inner_length,
+ new_rest,
+ using,
+ mangled_name,
+ namespace,
+ symtab);
+ if (sym != NULL)
+ return sym;
+ }
+ }
+ }
+
+ /* We didn't find anything by applying any of the using directives
+ that are still applicable; so let's see if we've got a match
+ using the current name. */
+
+ if (prefix_len == 0)
+ {
+ return lookup_symbol_aux_nonlocal (GLOBAL_BLOCK, rest, mangled_name,
+ namespace, symtab);
+ }
+ else
+ {
+ char *concatenated_name
+ = xmalloc (prefix_len + 2 + strlen (rest) + 1);
+ strncpy (concatenated_name, prefix, prefix_len);
+ strcpy (concatenated_name + prefix_len, "::");
+ strcpy (concatenated_name + prefix_len + 2, rest);
+ sym = lookup_symbol_aux_nonlocal (GLOBAL_BLOCK, concatenated_name,
+ mangled_name, namespace, symtab);
+
+ xfree (concatenated_name);
+ return sym;
+ }
+}
+
/* Check for the possibility of the symbol being a function or a
mangled variable that is stored in one of the minimal symbol
tables. Eventually, all global symbols might be resolved in this
/* Opaque declarations. */
struct obstack;
+struct using_direct_node;
/* Don't do this; it means that if some .o's are compiled with GNU C
and some are not (easy to do accidentally the way we configure
struct block *superblock;
+ /* Used for language-specific info. */
+
+ union
+ {
+ struct
+ {
+ /* Contains information about what using directives or other
+ similar features are added by this block. This should always
+ be NULL for global blocks: if there are using directives that
+ affect an entire file, put it in the static block. */
+
+ struct using_direct_node *using;
+ }
+ cplus_specific;
+ }
+ language_specific;
+
/* Version of GCC used to compile the function corresponding
to this block, or 0 if not compiled with GCC. When possible,
GCC should be compatible with the native compiler, or if that
#define BLOCK_END(bl) (bl)->endaddr
#define BLOCK_FUNCTION(bl) (bl)->function
#define BLOCK_SUPERBLOCK(bl) (bl)->superblock
+#define BLOCK_USING(bl) (bl)->language_specific.cplus_specific.using
#define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag
#define BLOCK_HASHTABLE(bl) (bl)->hashtable
--- /dev/null
+2002-10-22 David Carlton <carlton@math.stanford.edu>
+
+ * gdb.c++/namespace.exp: Add tests involving namespaces
+ starting from C.
+ * gdb.c++/namespace.cc: Add namespaces with names starting
+ from C and their contents.
return;
}
+namespace
+{
+ int X = 9;
+
+ namespace G
+ {
+ int Xg = 10;
+
+ namespace
+ {
+ int XgX = 11;
+ }
+ }
+}
+
+namespace H
+{
+ int h = 14;
+}
+
+namespace I = H;
+
+namespace J
+{
+ int j = 15;
+}
+
+using namespace J;
+
+namespace K
+{
+ int k = 16;
+}
+
+namespace L
+{
+ using namespace K;
+}
+
+namespace O
+{
+ int o = 18;
+}
+
+namespace P
+{
+ using namespace O;
+}
+
+namespace Q
+{
+ using namespace P;
+}
+
+namespace R
+{
+ int r1 = 19;
+ int r2 = 20;
+}
+
+using R::r1;
+
+namespace C
+{
+ int c = 1;
+ int shadow = 12;
+
+ namespace
+ {
+ int cX = 6;
+
+ namespace F
+ {
+ int cXf = 7;
+
+ namespace
+ {
+ int cXfX = 8;
+ }
+ }
+ }
+
+ namespace C
+ {
+ int cc = 2;
+ }
+
+ namespace E
+ {
+ int ce = 4;
+ }
+
+ namespace D
+ {
+ int cd = 3;
+ int shadow = 13;
+
+ namespace E
+ {
+ int cde = 5;
+ }
+
+ namespace M
+ {
+ int cdm = 17;
+ }
+
+ using namespace M;
+
+ void marker2 (void)
+ {
+ // NOTE: carlton/2002-10-11: I'm listing the expressions that I
+ // plan to have GDB try to print out, just to make sure that the
+ // compiler and I agree which ones should be legal! It's easy
+ // to screw up when testing the boundaries of namespace stuff.
+ c;
+ //cc;
+ C::cc;
+ cd;
+ E::cde;
+ shadow;
+ //E::ce;
+ cX;
+ F::cXf;
+ F::cXfX;
+ X;
+ G::Xg;
+ G::XgX;
+ I::h;
+ j;
+ L::k;
+ //k;
+ cdm;
+ Q::o;
+ //o;
+ r1;
+ //r2;
+ return;
+ }
+
+ }
+}
int main ()
{
c1 = cl.xyzq('e');
marker1();
-
-}
-
-
-
-
+ C::D::marker2 ();
+}
timeout { fail "(timeout) break BBB::Class::xyzq" }
}
+# Test to see if the appropriate namespaces are in scope when trying
+# to print out stuff from within a function defined within a
+# namespace.
+
+if ![runto "'C::D::marker2'"] then {
+ perror "couldn't run to marker2"
+ continue
+}
+
+gdb_test "print c" "\\$\[0-9\].* = 1" "print c"
+gdb_test "print cc" "No symbol \"cc\" in current context." "print cc"
+gdb_test "print 'C::cc'" "\\$\[0-9\].* = 2" "print C::cc"
+gdb_test "print cd" "\\$\[0-9\].* = 3" "print cd"
+gdb_test "print 'C::D::cd'" "\\$\[0-9\].* = 3" "print C::D::cd"
+gdb_test "print 'E::cde'" "\\$\[0-9\].* = 5" "print E::cde"
+
+# FIXME: carlton/2002-10-17: It's somewhat accidental that we
+# currently get this one right. (Delete this comment once namespace
+# scope issues have been handled correctly!)
+
+gdb_test "print shadow" "\\$\[0-9\].* = 13" "print shadow"
+
+
+# NOTE: carlton/2002-10-17: This one won't get fixed until namespaces
+# are first-class objects.
+
+setup_xfail "*-*-*"
+gdb_test "print 'E::ce'" "No symbol \"E::ce\" in current context." "print E::ce"
+
+# Some anonymous namespace tests.
+
+gdb_test "print cX" "\\$\[0-9\].* = 6" "print cX"
+gdb_test "print 'F::cXf'" "\\$\[0-9\].* = 7" "print F::cXf"
+gdb_test "print 'F::cXfX'" "\\$\[0-9\].* = 8" "print F::cXfX"
+gdb_test "print X" "\\$\[0-9\].* = 9" "print X"
+gdb_test "print 'G::Xg'" "\\$\[0-9\].* = 10" "print G::Xg"
+gdb_test "print 'G::XgX'" "\\$\[0-9\].* = 11" "print G::XgX"
+
+# Test namespace renaming.
+
+setup_xfail "*-*-*"
+gdb_test "print 'I::h'" "\\$\[0-9\].* = 14" "print I::h"
+
+# Test using directives.
+
+# NOTE: carlton/2002-10-17: Some of these are easy, but some of these
+# have unfortunate interactions with namespace scope issues. As of
+# this writing, some of these pass, but they pass for the wrong reasons.
+
+setup_xfail "*-*-*"
+gdb_test "print j" "\\$\[0-9\].* = 15" "print j"
+setup_xfail "*-*-*"
+gdb_test "print 'L::k'" "\\$\[0-9\].* = 16" "print L::k"
+setup_xfail "*-*-*"
+gdb_test "print k" "No symbol \"k\" in current context." "print k"
+setup_xfail "*-*-*"
+gdb_test "print cdm" "\\$\[0-9\].* = 17" "print cdm"
+setup_xfail "*-*-*"
+gdb_test "print 'Q::o'" "\\$\[0-9\].* = 18" "print Q::o"
+setup_xfail "*-*-*"
+gdb_test "print o" "No symbol \"o\" in current context." "print o"
+
+# Test using declarations. I should probably test these more.
+
+setup_xfail "*-*-*"
+gdb_test "print r1" "\\$\[0-9\].* = 19" "print r1"
+setup_xfail "*-*-*"
+gdb_test "print r2" "No symbol \"r2\" in current context." "print r2"
projects / thirdparty / binutils-gdb.git / commitdiff
