1*b725ae77Skettenis /* Helper routines for C++ support in GDB.
2*b725ae77Skettenis Copyright 2003, 2004 Free Software Foundation, Inc.
3*b725ae77Skettenis
4*b725ae77Skettenis Contributed by David Carlton and by Kealia, Inc.
5*b725ae77Skettenis
6*b725ae77Skettenis This file is part of GDB.
7*b725ae77Skettenis
8*b725ae77Skettenis This program is free software; you can redistribute it and/or modify
9*b725ae77Skettenis it under the terms of the GNU General Public License as published by
10*b725ae77Skettenis the Free Software Foundation; either version 2 of the License, or
11*b725ae77Skettenis (at your option) any later version.
12*b725ae77Skettenis
13*b725ae77Skettenis This program is distributed in the hope that it will be useful,
14*b725ae77Skettenis but WITHOUT ANY WARRANTY; without even the implied warranty of
15*b725ae77Skettenis MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16*b725ae77Skettenis GNU General Public License for more details.
17*b725ae77Skettenis
18*b725ae77Skettenis You should have received a copy of the GNU General Public License
19*b725ae77Skettenis along with this program; if not, write to the Free Software
20*b725ae77Skettenis Foundation, Inc., 59 Temple Place - Suite 330,
21*b725ae77Skettenis Boston, MA 02111-1307, USA. */
22*b725ae77Skettenis
23*b725ae77Skettenis #include "defs.h"
24*b725ae77Skettenis #include "cp-support.h"
25*b725ae77Skettenis #include "gdb_obstack.h"
26*b725ae77Skettenis #include "symtab.h"
27*b725ae77Skettenis #include "symfile.h"
28*b725ae77Skettenis #include "gdb_assert.h"
29*b725ae77Skettenis #include "block.h"
30*b725ae77Skettenis #include "objfiles.h"
31*b725ae77Skettenis #include "gdbtypes.h"
32*b725ae77Skettenis #include "dictionary.h"
33*b725ae77Skettenis #include "command.h"
34*b725ae77Skettenis #include "frame.h"
35*b725ae77Skettenis
36*b725ae77Skettenis /* When set, the file that we're processing is known to have debugging
37*b725ae77Skettenis info for C++ namespaces. */
38*b725ae77Skettenis
39*b725ae77Skettenis /* NOTE: carlton/2004-01-13: No currently released version of GCC (the
40*b725ae77Skettenis latest of which is 3.3.x at the time of this writing) produces this
41*b725ae77Skettenis debug info. GCC 3.4 should, however. */
42*b725ae77Skettenis
43*b725ae77Skettenis unsigned char processing_has_namespace_info;
44*b725ae77Skettenis
45*b725ae77Skettenis /* This contains our best guess as to the name of the current
46*b725ae77Skettenis enclosing namespace(s)/class(es), if any. For example, if we're
47*b725ae77Skettenis within the method foo() in the following code:
48*b725ae77Skettenis
49*b725ae77Skettenis namespace N {
50*b725ae77Skettenis class C {
51*b725ae77Skettenis void foo () {
52*b725ae77Skettenis }
53*b725ae77Skettenis };
54*b725ae77Skettenis }
55*b725ae77Skettenis
56*b725ae77Skettenis then processing_current_prefix should be set to "N::C". If
57*b725ae77Skettenis processing_has_namespace_info is false, then this variable might
58*b725ae77Skettenis not be reliable. */
59*b725ae77Skettenis
60*b725ae77Skettenis const char *processing_current_prefix;
61*b725ae77Skettenis
62*b725ae77Skettenis /* List of using directives that are active in the current file. */
63*b725ae77Skettenis
64*b725ae77Skettenis static struct using_direct *using_list;
65*b725ae77Skettenis
66*b725ae77Skettenis static struct using_direct *cp_add_using (const char *name,
67*b725ae77Skettenis unsigned int inner_len,
68*b725ae77Skettenis unsigned int outer_len,
69*b725ae77Skettenis struct using_direct *next);
70*b725ae77Skettenis
71*b725ae77Skettenis static struct using_direct *cp_copy_usings (struct using_direct *using,
72*b725ae77Skettenis struct obstack *obstack);
73*b725ae77Skettenis
74*b725ae77Skettenis static struct symbol *lookup_namespace_scope (const char *name,
75*b725ae77Skettenis const char *linkage_name,
76*b725ae77Skettenis const struct block *block,
77*b725ae77Skettenis const domain_enum domain,
78*b725ae77Skettenis struct symtab **symtab,
79*b725ae77Skettenis const char *scope,
80*b725ae77Skettenis int scope_len);
81*b725ae77Skettenis
82*b725ae77Skettenis static struct symbol *lookup_symbol_file (const char *name,
83*b725ae77Skettenis const char *linkage_name,
84*b725ae77Skettenis const struct block *block,
85*b725ae77Skettenis const domain_enum domain,
86*b725ae77Skettenis struct symtab **symtab,
87*b725ae77Skettenis int anonymous_namespace);
88*b725ae77Skettenis
89*b725ae77Skettenis static struct type *cp_lookup_transparent_type_loop (const char *name,
90*b725ae77Skettenis const char *scope,
91*b725ae77Skettenis int scope_len);
92*b725ae77Skettenis
93*b725ae77Skettenis static void initialize_namespace_symtab (struct objfile *objfile);
94*b725ae77Skettenis
95*b725ae77Skettenis static struct block *get_possible_namespace_block (struct objfile *objfile);
96*b725ae77Skettenis
97*b725ae77Skettenis static void free_namespace_block (struct symtab *symtab);
98*b725ae77Skettenis
99*b725ae77Skettenis static int check_possible_namespace_symbols_loop (const char *name,
100*b725ae77Skettenis int len,
101*b725ae77Skettenis struct objfile *objfile);
102*b725ae77Skettenis
103*b725ae77Skettenis static int check_one_possible_namespace_symbol (const char *name,
104*b725ae77Skettenis int len,
105*b725ae77Skettenis struct objfile *objfile);
106*b725ae77Skettenis
107*b725ae77Skettenis static
108*b725ae77Skettenis struct symbol *lookup_possible_namespace_symbol (const char *name,
109*b725ae77Skettenis struct symtab **symtab);
110*b725ae77Skettenis
111*b725ae77Skettenis static void maintenance_cplus_namespace (char *args, int from_tty);
112*b725ae77Skettenis
113*b725ae77Skettenis /* Set up support for dealing with C++ namespace info in the current
114*b725ae77Skettenis symtab. */
115*b725ae77Skettenis
cp_initialize_namespace()116*b725ae77Skettenis void cp_initialize_namespace ()
117*b725ae77Skettenis {
118*b725ae77Skettenis processing_has_namespace_info = 0;
119*b725ae77Skettenis using_list = NULL;
120*b725ae77Skettenis }
121*b725ae77Skettenis
122*b725ae77Skettenis /* Add all the using directives we've gathered to the current symtab.
123*b725ae77Skettenis STATIC_BLOCK should be the symtab's static block; OBSTACK is used
124*b725ae77Skettenis for allocation. */
125*b725ae77Skettenis
126*b725ae77Skettenis void
cp_finalize_namespace(struct block * static_block,struct obstack * obstack)127*b725ae77Skettenis cp_finalize_namespace (struct block *static_block,
128*b725ae77Skettenis struct obstack *obstack)
129*b725ae77Skettenis {
130*b725ae77Skettenis if (using_list != NULL)
131*b725ae77Skettenis {
132*b725ae77Skettenis block_set_using (static_block,
133*b725ae77Skettenis cp_copy_usings (using_list, obstack),
134*b725ae77Skettenis obstack);
135*b725ae77Skettenis using_list = NULL;
136*b725ae77Skettenis }
137*b725ae77Skettenis }
138*b725ae77Skettenis
139*b725ae77Skettenis /* Check to see if SYMBOL refers to an object contained within an
140*b725ae77Skettenis anonymous namespace; if so, add an appropriate using directive. */
141*b725ae77Skettenis
142*b725ae77Skettenis /* Optimize away strlen ("(anonymous namespace)"). */
143*b725ae77Skettenis
144*b725ae77Skettenis #define ANONYMOUS_NAMESPACE_LEN 21
145*b725ae77Skettenis
146*b725ae77Skettenis void
cp_scan_for_anonymous_namespaces(const struct symbol * symbol)147*b725ae77Skettenis cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
148*b725ae77Skettenis {
149*b725ae77Skettenis if (!processing_has_namespace_info
150*b725ae77Skettenis && SYMBOL_CPLUS_DEMANGLED_NAME (symbol) != NULL)
151*b725ae77Skettenis {
152*b725ae77Skettenis const char *name = SYMBOL_CPLUS_DEMANGLED_NAME (symbol);
153*b725ae77Skettenis unsigned int previous_component;
154*b725ae77Skettenis unsigned int next_component;
155*b725ae77Skettenis const char *len;
156*b725ae77Skettenis
157*b725ae77Skettenis /* Start with a quick-and-dirty check for mention of "(anonymous
158*b725ae77Skettenis namespace)". */
159*b725ae77Skettenis
160*b725ae77Skettenis if (!cp_is_anonymous (name))
161*b725ae77Skettenis return;
162*b725ae77Skettenis
163*b725ae77Skettenis previous_component = 0;
164*b725ae77Skettenis next_component = cp_find_first_component (name + previous_component);
165*b725ae77Skettenis
166*b725ae77Skettenis while (name[next_component] == ':')
167*b725ae77Skettenis {
168*b725ae77Skettenis if ((next_component - previous_component) == ANONYMOUS_NAMESPACE_LEN
169*b725ae77Skettenis && strncmp (name + previous_component,
170*b725ae77Skettenis "(anonymous namespace)",
171*b725ae77Skettenis ANONYMOUS_NAMESPACE_LEN) == 0)
172*b725ae77Skettenis {
173*b725ae77Skettenis /* We've found a component of the name that's an
174*b725ae77Skettenis anonymous namespace. So add symbols in it to the
175*b725ae77Skettenis namespace given by the previous component if there is
176*b725ae77Skettenis one, or to the global namespace if there isn't. */
177*b725ae77Skettenis cp_add_using_directive (name,
178*b725ae77Skettenis previous_component == 0
179*b725ae77Skettenis ? 0 : previous_component - 2,
180*b725ae77Skettenis next_component);
181*b725ae77Skettenis }
182*b725ae77Skettenis /* The "+ 2" is for the "::". */
183*b725ae77Skettenis previous_component = next_component + 2;
184*b725ae77Skettenis next_component = (previous_component
185*b725ae77Skettenis + cp_find_first_component (name
186*b725ae77Skettenis + previous_component));
187*b725ae77Skettenis }
188*b725ae77Skettenis }
189*b725ae77Skettenis }
190*b725ae77Skettenis
191*b725ae77Skettenis /* Add a using directive to using_list. NAME is the start of a string
192*b725ae77Skettenis that should contain the namespaces we want to add as initial
193*b725ae77Skettenis substrings, OUTER_LENGTH is the end of the outer namespace, and
194*b725ae77Skettenis INNER_LENGTH is the end of the inner namespace. If the using
195*b725ae77Skettenis directive in question has already been added, don't add it
196*b725ae77Skettenis twice. */
197*b725ae77Skettenis
198*b725ae77Skettenis void
cp_add_using_directive(const char * name,unsigned int outer_length,unsigned int inner_length)199*b725ae77Skettenis cp_add_using_directive (const char *name, unsigned int outer_length,
200*b725ae77Skettenis unsigned int inner_length)
201*b725ae77Skettenis {
202*b725ae77Skettenis struct using_direct *current;
203*b725ae77Skettenis struct using_direct *new;
204*b725ae77Skettenis
205*b725ae77Skettenis /* Has it already been added? */
206*b725ae77Skettenis
207*b725ae77Skettenis for (current = using_list; current != NULL; current = current->next)
208*b725ae77Skettenis {
209*b725ae77Skettenis if ((strncmp (current->inner, name, inner_length) == 0)
210*b725ae77Skettenis && (strlen (current->inner) == inner_length)
211*b725ae77Skettenis && (strlen (current->outer) == outer_length))
212*b725ae77Skettenis return;
213*b725ae77Skettenis }
214*b725ae77Skettenis
215*b725ae77Skettenis using_list = cp_add_using (name, inner_length, outer_length,
216*b725ae77Skettenis using_list);
217*b725ae77Skettenis }
218*b725ae77Skettenis
219*b725ae77Skettenis /* Record the namespace that the function defined by SYMBOL was
220*b725ae77Skettenis defined in, if necessary. BLOCK is the associated block; use
221*b725ae77Skettenis OBSTACK for allocation. */
222*b725ae77Skettenis
223*b725ae77Skettenis void
cp_set_block_scope(const struct symbol * symbol,struct block * block,struct obstack * obstack)224*b725ae77Skettenis cp_set_block_scope (const struct symbol *symbol,
225*b725ae77Skettenis struct block *block,
226*b725ae77Skettenis struct obstack *obstack)
227*b725ae77Skettenis {
228*b725ae77Skettenis /* Make sure that the name was originally mangled: if not, there
229*b725ae77Skettenis certainly isn't any namespace information to worry about! */
230*b725ae77Skettenis
231*b725ae77Skettenis if (SYMBOL_CPLUS_DEMANGLED_NAME (symbol) != NULL)
232*b725ae77Skettenis {
233*b725ae77Skettenis if (processing_has_namespace_info)
234*b725ae77Skettenis {
235*b725ae77Skettenis block_set_scope
236*b725ae77Skettenis (block, obsavestring (processing_current_prefix,
237*b725ae77Skettenis strlen (processing_current_prefix),
238*b725ae77Skettenis obstack),
239*b725ae77Skettenis obstack);
240*b725ae77Skettenis }
241*b725ae77Skettenis else
242*b725ae77Skettenis {
243*b725ae77Skettenis /* Try to figure out the appropriate namespace from the
244*b725ae77Skettenis demangled name. */
245*b725ae77Skettenis
246*b725ae77Skettenis /* FIXME: carlton/2003-04-15: If the function in question is
247*b725ae77Skettenis a method of a class, the name will actually include the
248*b725ae77Skettenis name of the class as well. This should be harmless, but
249*b725ae77Skettenis is a little unfortunate. */
250*b725ae77Skettenis
251*b725ae77Skettenis const char *name = SYMBOL_CPLUS_DEMANGLED_NAME (symbol);
252*b725ae77Skettenis unsigned int prefix_len = cp_entire_prefix_len (name);
253*b725ae77Skettenis
254*b725ae77Skettenis block_set_scope (block,
255*b725ae77Skettenis obsavestring (name, prefix_len, obstack),
256*b725ae77Skettenis obstack);
257*b725ae77Skettenis }
258*b725ae77Skettenis }
259*b725ae77Skettenis }
260*b725ae77Skettenis
261*b725ae77Skettenis /* Test whether or not NAMESPACE looks like it mentions an anonymous
262*b725ae77Skettenis namespace; return nonzero if so. */
263*b725ae77Skettenis
264*b725ae77Skettenis int
cp_is_anonymous(const char * namespace)265*b725ae77Skettenis cp_is_anonymous (const char *namespace)
266*b725ae77Skettenis {
267*b725ae77Skettenis return (strstr (namespace, "(anonymous namespace)")
268*b725ae77Skettenis != NULL);
269*b725ae77Skettenis }
270*b725ae77Skettenis
271*b725ae77Skettenis /* Create a new struct using direct whose inner namespace is the
272*b725ae77Skettenis initial substring of NAME of leng INNER_LEN and whose outer
273*b725ae77Skettenis namespace is the initial substring of NAME of length OUTER_LENGTH.
274*b725ae77Skettenis Set its next member in the linked list to NEXT; allocate all memory
275*b725ae77Skettenis using xmalloc. It copies the strings, so NAME can be a temporary
276*b725ae77Skettenis string. */
277*b725ae77Skettenis
278*b725ae77Skettenis static struct using_direct *
cp_add_using(const char * name,unsigned int inner_len,unsigned int outer_len,struct using_direct * next)279*b725ae77Skettenis cp_add_using (const char *name,
280*b725ae77Skettenis unsigned int inner_len,
281*b725ae77Skettenis unsigned int outer_len,
282*b725ae77Skettenis struct using_direct *next)
283*b725ae77Skettenis {
284*b725ae77Skettenis struct using_direct *retval;
285*b725ae77Skettenis
286*b725ae77Skettenis gdb_assert (outer_len < inner_len);
287*b725ae77Skettenis
288*b725ae77Skettenis retval = xmalloc (sizeof (struct using_direct));
289*b725ae77Skettenis retval->inner = savestring (name, inner_len);
290*b725ae77Skettenis retval->outer = savestring (name, outer_len);
291*b725ae77Skettenis retval->next = next;
292*b725ae77Skettenis
293*b725ae77Skettenis return retval;
294*b725ae77Skettenis }
295*b725ae77Skettenis
296*b725ae77Skettenis /* Make a copy of the using directives in the list pointed to by
297*b725ae77Skettenis USING, using OBSTACK to allocate memory. Free all memory pointed
298*b725ae77Skettenis to by USING via xfree. */
299*b725ae77Skettenis
300*b725ae77Skettenis static struct using_direct *
cp_copy_usings(struct using_direct * using,struct obstack * obstack)301*b725ae77Skettenis cp_copy_usings (struct using_direct *using,
302*b725ae77Skettenis struct obstack *obstack)
303*b725ae77Skettenis {
304*b725ae77Skettenis if (using == NULL)
305*b725ae77Skettenis {
306*b725ae77Skettenis return NULL;
307*b725ae77Skettenis }
308*b725ae77Skettenis else
309*b725ae77Skettenis {
310*b725ae77Skettenis struct using_direct *retval
311*b725ae77Skettenis = obstack_alloc (obstack, sizeof (struct using_direct));
312*b725ae77Skettenis retval->inner = obsavestring (using->inner, strlen (using->inner),
313*b725ae77Skettenis obstack);
314*b725ae77Skettenis retval->outer = obsavestring (using->outer, strlen (using->outer),
315*b725ae77Skettenis obstack);
316*b725ae77Skettenis retval->next = cp_copy_usings (using->next, obstack);
317*b725ae77Skettenis
318*b725ae77Skettenis xfree (using->inner);
319*b725ae77Skettenis xfree (using->outer);
320*b725ae77Skettenis xfree (using);
321*b725ae77Skettenis
322*b725ae77Skettenis return retval;
323*b725ae77Skettenis }
324*b725ae77Skettenis }
325*b725ae77Skettenis
326*b725ae77Skettenis /* The C++-specific version of name lookup for static and global
327*b725ae77Skettenis names. This makes sure that names get looked for in all namespaces
328*b725ae77Skettenis that are in scope. NAME is the natural name of the symbol that
329*b725ae77Skettenis we're looking for, LINKAGE_NAME (which is optional) is its linkage
330*b725ae77Skettenis name, BLOCK is the block that we're searching within, DOMAIN says
331*b725ae77Skettenis what kind of symbols we're looking for, and if SYMTAB is non-NULL,
332*b725ae77Skettenis we should store the symtab where we found the symbol in it. */
333*b725ae77Skettenis
334*b725ae77Skettenis struct symbol *
cp_lookup_symbol_nonlocal(const char * name,const char * linkage_name,const struct block * block,const domain_enum domain,struct symtab ** symtab)335*b725ae77Skettenis cp_lookup_symbol_nonlocal (const char *name,
336*b725ae77Skettenis const char *linkage_name,
337*b725ae77Skettenis const struct block *block,
338*b725ae77Skettenis const domain_enum domain,
339*b725ae77Skettenis struct symtab **symtab)
340*b725ae77Skettenis {
341*b725ae77Skettenis return lookup_namespace_scope (name, linkage_name, block, domain,
342*b725ae77Skettenis symtab, block_scope (block), 0);
343*b725ae77Skettenis }
344*b725ae77Skettenis
345*b725ae77Skettenis /* Lookup NAME at namespace scope (or, in C terms, in static and
346*b725ae77Skettenis global variables). SCOPE is the namespace that the current
347*b725ae77Skettenis function is defined within; only consider namespaces whose length
348*b725ae77Skettenis is at least SCOPE_LEN. Other arguments are as in
349*b725ae77Skettenis cp_lookup_symbol_nonlocal.
350*b725ae77Skettenis
351*b725ae77Skettenis For example, if we're within a function A::B::f and looking for a
352*b725ae77Skettenis symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
353*b725ae77Skettenis SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
354*b725ae77Skettenis but with SCOPE_LEN = 1. And then it calls itself with NAME and
355*b725ae77Skettenis SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
356*b725ae77Skettenis "A::B::x"; if it doesn't find it, then the second call looks for
357*b725ae77Skettenis "A::x", and if that call fails, then the first call looks for
358*b725ae77Skettenis "x". */
359*b725ae77Skettenis
360*b725ae77Skettenis static struct symbol *
lookup_namespace_scope(const char * name,const char * linkage_name,const struct block * block,const domain_enum domain,struct symtab ** symtab,const char * scope,int scope_len)361*b725ae77Skettenis lookup_namespace_scope (const char *name,
362*b725ae77Skettenis const char *linkage_name,
363*b725ae77Skettenis const struct block *block,
364*b725ae77Skettenis const domain_enum domain,
365*b725ae77Skettenis struct symtab **symtab,
366*b725ae77Skettenis const char *scope,
367*b725ae77Skettenis int scope_len)
368*b725ae77Skettenis {
369*b725ae77Skettenis char *namespace;
370*b725ae77Skettenis
371*b725ae77Skettenis if (scope[scope_len] != '\0')
372*b725ae77Skettenis {
373*b725ae77Skettenis /* Recursively search for names in child namespaces first. */
374*b725ae77Skettenis
375*b725ae77Skettenis struct symbol *sym;
376*b725ae77Skettenis int new_scope_len = scope_len;
377*b725ae77Skettenis
378*b725ae77Skettenis /* If the current scope is followed by "::", skip past that. */
379*b725ae77Skettenis if (new_scope_len != 0)
380*b725ae77Skettenis {
381*b725ae77Skettenis gdb_assert (scope[new_scope_len] == ':');
382*b725ae77Skettenis new_scope_len += 2;
383*b725ae77Skettenis }
384*b725ae77Skettenis new_scope_len += cp_find_first_component (scope + new_scope_len);
385*b725ae77Skettenis sym = lookup_namespace_scope (name, linkage_name, block,
386*b725ae77Skettenis domain, symtab,
387*b725ae77Skettenis scope, new_scope_len);
388*b725ae77Skettenis if (sym != NULL)
389*b725ae77Skettenis return sym;
390*b725ae77Skettenis }
391*b725ae77Skettenis
392*b725ae77Skettenis /* Okay, we didn't find a match in our children, so look for the
393*b725ae77Skettenis name in the current namespace. */
394*b725ae77Skettenis
395*b725ae77Skettenis namespace = alloca (scope_len + 1);
396*b725ae77Skettenis strncpy (namespace, scope, scope_len);
397*b725ae77Skettenis namespace[scope_len] = '\0';
398*b725ae77Skettenis return cp_lookup_symbol_namespace (namespace, name, linkage_name,
399*b725ae77Skettenis block, domain, symtab);
400*b725ae77Skettenis }
401*b725ae77Skettenis
402*b725ae77Skettenis /* Look up NAME in the C++ namespace NAMESPACE, applying the using
403*b725ae77Skettenis directives that are active in BLOCK. Other arguments are as in
404*b725ae77Skettenis cp_lookup_symbol_nonlocal. */
405*b725ae77Skettenis
406*b725ae77Skettenis struct symbol *
cp_lookup_symbol_namespace(const char * namespace,const char * name,const char * linkage_name,const struct block * block,const domain_enum domain,struct symtab ** symtab)407*b725ae77Skettenis cp_lookup_symbol_namespace (const char *namespace,
408*b725ae77Skettenis const char *name,
409*b725ae77Skettenis const char *linkage_name,
410*b725ae77Skettenis const struct block *block,
411*b725ae77Skettenis const domain_enum domain,
412*b725ae77Skettenis struct symtab **symtab)
413*b725ae77Skettenis {
414*b725ae77Skettenis const struct using_direct *current;
415*b725ae77Skettenis struct symbol *sym;
416*b725ae77Skettenis
417*b725ae77Skettenis /* First, go through the using directives. If any of them add new
418*b725ae77Skettenis names to the namespace we're searching in, see if we can find a
419*b725ae77Skettenis match by applying them. */
420*b725ae77Skettenis
421*b725ae77Skettenis for (current = block_using (block);
422*b725ae77Skettenis current != NULL;
423*b725ae77Skettenis current = current->next)
424*b725ae77Skettenis {
425*b725ae77Skettenis if (strcmp (namespace, current->outer) == 0)
426*b725ae77Skettenis {
427*b725ae77Skettenis sym = cp_lookup_symbol_namespace (current->inner,
428*b725ae77Skettenis name,
429*b725ae77Skettenis linkage_name,
430*b725ae77Skettenis block,
431*b725ae77Skettenis domain,
432*b725ae77Skettenis symtab);
433*b725ae77Skettenis if (sym != NULL)
434*b725ae77Skettenis return sym;
435*b725ae77Skettenis }
436*b725ae77Skettenis }
437*b725ae77Skettenis
438*b725ae77Skettenis /* We didn't find anything by applying any of the using directives
439*b725ae77Skettenis that are still applicable; so let's see if we've got a match
440*b725ae77Skettenis using the current namespace. */
441*b725ae77Skettenis
442*b725ae77Skettenis if (namespace[0] == '\0')
443*b725ae77Skettenis {
444*b725ae77Skettenis return lookup_symbol_file (name, linkage_name, block,
445*b725ae77Skettenis domain, symtab, 0);
446*b725ae77Skettenis }
447*b725ae77Skettenis else
448*b725ae77Skettenis {
449*b725ae77Skettenis char *concatenated_name
450*b725ae77Skettenis = alloca (strlen (namespace) + 2 + strlen (name) + 1);
451*b725ae77Skettenis strcpy (concatenated_name, namespace);
452*b725ae77Skettenis strcat (concatenated_name, "::");
453*b725ae77Skettenis strcat (concatenated_name, name);
454*b725ae77Skettenis sym = lookup_symbol_file (concatenated_name, linkage_name,
455*b725ae77Skettenis block, domain, symtab,
456*b725ae77Skettenis cp_is_anonymous (namespace));
457*b725ae77Skettenis return sym;
458*b725ae77Skettenis }
459*b725ae77Skettenis }
460*b725ae77Skettenis
461*b725ae77Skettenis /* Look up NAME in BLOCK's static block and in global blocks. If
462*b725ae77Skettenis ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
463*b725ae77Skettenis within an anonymous namespace. Other arguments are as in
464*b725ae77Skettenis cp_lookup_symbol_nonlocal. */
465*b725ae77Skettenis
466*b725ae77Skettenis static struct symbol *
lookup_symbol_file(const char * name,const char * linkage_name,const struct block * block,const domain_enum domain,struct symtab ** symtab,int anonymous_namespace)467*b725ae77Skettenis lookup_symbol_file (const char *name,
468*b725ae77Skettenis const char *linkage_name,
469*b725ae77Skettenis const struct block *block,
470*b725ae77Skettenis const domain_enum domain,
471*b725ae77Skettenis struct symtab **symtab,
472*b725ae77Skettenis int anonymous_namespace)
473*b725ae77Skettenis {
474*b725ae77Skettenis struct symbol *sym = NULL;
475*b725ae77Skettenis
476*b725ae77Skettenis sym = lookup_symbol_static (name, linkage_name, block, domain, symtab);
477*b725ae77Skettenis if (sym != NULL)
478*b725ae77Skettenis return sym;
479*b725ae77Skettenis
480*b725ae77Skettenis if (anonymous_namespace)
481*b725ae77Skettenis {
482*b725ae77Skettenis /* Symbols defined in anonymous namespaces have external linkage
483*b725ae77Skettenis but should be treated as local to a single file nonetheless.
484*b725ae77Skettenis So we only search the current file's global block. */
485*b725ae77Skettenis
486*b725ae77Skettenis const struct block *global_block = block_global_block (block);
487*b725ae77Skettenis
488*b725ae77Skettenis if (global_block != NULL)
489*b725ae77Skettenis sym = lookup_symbol_aux_block (name, linkage_name, global_block,
490*b725ae77Skettenis domain, symtab);
491*b725ae77Skettenis }
492*b725ae77Skettenis else
493*b725ae77Skettenis {
494*b725ae77Skettenis sym = lookup_symbol_global (name, linkage_name, domain, symtab);
495*b725ae77Skettenis }
496*b725ae77Skettenis
497*b725ae77Skettenis if (sym != NULL)
498*b725ae77Skettenis return sym;
499*b725ae77Skettenis
500*b725ae77Skettenis /* Now call "lookup_possible_namespace_symbol". Symbols in here
501*b725ae77Skettenis claim to be associated to namespaces, but this claim might be
502*b725ae77Skettenis incorrect: the names in question might actually correspond to
503*b725ae77Skettenis classes instead of namespaces. But if they correspond to
504*b725ae77Skettenis classes, then we should have found a match for them above. So if
505*b725ae77Skettenis we find them now, they should be genuine. */
506*b725ae77Skettenis
507*b725ae77Skettenis /* FIXME: carlton/2003-06-12: This is a hack and should eventually
508*b725ae77Skettenis be deleted: see comments below. */
509*b725ae77Skettenis
510*b725ae77Skettenis if (domain == VAR_DOMAIN)
511*b725ae77Skettenis {
512*b725ae77Skettenis sym = lookup_possible_namespace_symbol (name, symtab);
513*b725ae77Skettenis if (sym != NULL)
514*b725ae77Skettenis return sym;
515*b725ae77Skettenis }
516*b725ae77Skettenis
517*b725ae77Skettenis return NULL;
518*b725ae77Skettenis }
519*b725ae77Skettenis
520*b725ae77Skettenis /* Look up a type named NESTED_NAME that is nested inside the C++
521*b725ae77Skettenis class or namespace given by PARENT_TYPE, from within the context
522*b725ae77Skettenis given by BLOCK. Return NULL if there is no such nested type. */
523*b725ae77Skettenis
524*b725ae77Skettenis struct type *
cp_lookup_nested_type(struct type * parent_type,const char * nested_name,const struct block * block)525*b725ae77Skettenis cp_lookup_nested_type (struct type *parent_type,
526*b725ae77Skettenis const char *nested_name,
527*b725ae77Skettenis const struct block *block)
528*b725ae77Skettenis {
529*b725ae77Skettenis switch (TYPE_CODE (parent_type))
530*b725ae77Skettenis {
531*b725ae77Skettenis case TYPE_CODE_STRUCT:
532*b725ae77Skettenis case TYPE_CODE_NAMESPACE:
533*b725ae77Skettenis {
534*b725ae77Skettenis /* NOTE: carlton/2003-11-10: We don't treat C++ class members
535*b725ae77Skettenis of classes like, say, data or function members. Instead,
536*b725ae77Skettenis they're just represented by symbols whose names are
537*b725ae77Skettenis qualified by the name of the surrounding class. This is
538*b725ae77Skettenis just like members of namespaces; in particular,
539*b725ae77Skettenis lookup_symbol_namespace works when looking them up. */
540*b725ae77Skettenis
541*b725ae77Skettenis const char *parent_name = TYPE_TAG_NAME (parent_type);
542*b725ae77Skettenis struct symbol *sym = cp_lookup_symbol_namespace (parent_name,
543*b725ae77Skettenis nested_name,
544*b725ae77Skettenis NULL,
545*b725ae77Skettenis block,
546*b725ae77Skettenis VAR_DOMAIN,
547*b725ae77Skettenis NULL);
548*b725ae77Skettenis if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
549*b725ae77Skettenis return NULL;
550*b725ae77Skettenis else
551*b725ae77Skettenis return SYMBOL_TYPE (sym);
552*b725ae77Skettenis }
553*b725ae77Skettenis default:
554*b725ae77Skettenis internal_error (__FILE__, __LINE__,
555*b725ae77Skettenis "cp_lookup_nested_type called on a non-aggregate type.");
556*b725ae77Skettenis }
557*b725ae77Skettenis }
558*b725ae77Skettenis
559*b725ae77Skettenis /* The C++-version of lookup_transparent_type. */
560*b725ae77Skettenis
561*b725ae77Skettenis /* FIXME: carlton/2004-01-16: The problem that this is trying to
562*b725ae77Skettenis address is that, unfortunately, sometimes NAME is wrong: it may not
563*b725ae77Skettenis include the name of namespaces enclosing the type in question.
564*b725ae77Skettenis lookup_transparent_type gets called when the the type in question
565*b725ae77Skettenis is a declaration, and we're trying to find its definition; but, for
566*b725ae77Skettenis declarations, our type name deduction mechanism doesn't work.
567*b725ae77Skettenis There's nothing we can do to fix this in general, I think, in the
568*b725ae77Skettenis absence of debug information about namespaces (I've filed PR
569*b725ae77Skettenis gdb/1511 about this); until such debug information becomes more
570*b725ae77Skettenis prevalent, one heuristic which sometimes looks is to search for the
571*b725ae77Skettenis definition in namespaces containing the current namespace.
572*b725ae77Skettenis
573*b725ae77Skettenis We should delete this functions once the appropriate debug
574*b725ae77Skettenis information becomes more widespread. (GCC 3.4 will be the first
575*b725ae77Skettenis released version of GCC with such information.) */
576*b725ae77Skettenis
577*b725ae77Skettenis struct type *
cp_lookup_transparent_type(const char * name)578*b725ae77Skettenis cp_lookup_transparent_type (const char *name)
579*b725ae77Skettenis {
580*b725ae77Skettenis /* First, try the honest way of looking up the definition. */
581*b725ae77Skettenis struct type *t = basic_lookup_transparent_type (name);
582*b725ae77Skettenis const char *scope;
583*b725ae77Skettenis
584*b725ae77Skettenis if (t != NULL)
585*b725ae77Skettenis return t;
586*b725ae77Skettenis
587*b725ae77Skettenis /* If that doesn't work and we're within a namespace, look there
588*b725ae77Skettenis instead. */
589*b725ae77Skettenis scope = block_scope (get_selected_block (0));
590*b725ae77Skettenis
591*b725ae77Skettenis if (scope[0] == '\0')
592*b725ae77Skettenis return NULL;
593*b725ae77Skettenis
594*b725ae77Skettenis return cp_lookup_transparent_type_loop (name, scope, 0);
595*b725ae77Skettenis }
596*b725ae77Skettenis
597*b725ae77Skettenis /* Lookup the the type definition associated to NAME in
598*b725ae77Skettenis namespaces/classes containing SCOPE whose name is strictly longer
599*b725ae77Skettenis than LENGTH. LENGTH must be the index of the start of a
600*b725ae77Skettenis component of SCOPE. */
601*b725ae77Skettenis
602*b725ae77Skettenis static struct type *
cp_lookup_transparent_type_loop(const char * name,const char * scope,int length)603*b725ae77Skettenis cp_lookup_transparent_type_loop (const char *name, const char *scope,
604*b725ae77Skettenis int length)
605*b725ae77Skettenis {
606*b725ae77Skettenis int scope_length = length + cp_find_first_component (scope + length);
607*b725ae77Skettenis char *full_name;
608*b725ae77Skettenis
609*b725ae77Skettenis /* If the current scope is followed by "::", look in the next
610*b725ae77Skettenis component. */
611*b725ae77Skettenis if (scope[scope_length] == ':')
612*b725ae77Skettenis {
613*b725ae77Skettenis struct type *retval
614*b725ae77Skettenis = cp_lookup_transparent_type_loop (name, scope, scope_length + 2);
615*b725ae77Skettenis if (retval != NULL)
616*b725ae77Skettenis return retval;
617*b725ae77Skettenis }
618*b725ae77Skettenis
619*b725ae77Skettenis full_name = alloca (scope_length + 2 + strlen (name) + 1);
620*b725ae77Skettenis strncpy (full_name, scope, scope_length);
621*b725ae77Skettenis strncpy (full_name + scope_length, "::", 2);
622*b725ae77Skettenis strcpy (full_name + scope_length + 2, name);
623*b725ae77Skettenis
624*b725ae77Skettenis return basic_lookup_transparent_type (full_name);
625*b725ae77Skettenis }
626*b725ae77Skettenis
627*b725ae77Skettenis /* Now come functions for dealing with symbols associated to
628*b725ae77Skettenis namespaces. (They're used to store the namespaces themselves, not
629*b725ae77Skettenis objects that live in the namespaces.) These symbols come in two
630*b725ae77Skettenis varieties: if we run into a DW_TAG_namespace DIE, then we know that
631*b725ae77Skettenis we have a namespace, so dwarf2read.c creates a symbol for it just
632*b725ae77Skettenis like normal. But, unfortunately, versions of GCC through at least
633*b725ae77Skettenis 3.3 don't generate those DIE's. Our solution is to try to guess
634*b725ae77Skettenis their existence by looking at demangled names. This might cause us
635*b725ae77Skettenis to misidentify classes as namespaces, however. So we put those
636*b725ae77Skettenis symbols in a special block (one per objfile), and we only search
637*b725ae77Skettenis that block as a last resort. */
638*b725ae77Skettenis
639*b725ae77Skettenis /* FIXME: carlton/2003-06-12: Once versions of GCC that generate
640*b725ae77Skettenis DW_TAG_namespace have been out for a year or two, we should get rid
641*b725ae77Skettenis of all of this "possible namespace" nonsense. */
642*b725ae77Skettenis
643*b725ae77Skettenis /* Allocate everything necessary for the possible namespace block
644*b725ae77Skettenis associated to OBJFILE. */
645*b725ae77Skettenis
646*b725ae77Skettenis static void
initialize_namespace_symtab(struct objfile * objfile)647*b725ae77Skettenis initialize_namespace_symtab (struct objfile *objfile)
648*b725ae77Skettenis {
649*b725ae77Skettenis struct symtab *namespace_symtab;
650*b725ae77Skettenis struct blockvector *bv;
651*b725ae77Skettenis struct block *bl;
652*b725ae77Skettenis
653*b725ae77Skettenis namespace_symtab = allocate_symtab ("<<C++-namespaces>>", objfile);
654*b725ae77Skettenis namespace_symtab->language = language_cplus;
655*b725ae77Skettenis namespace_symtab->free_code = free_nothing;
656*b725ae77Skettenis namespace_symtab->dirname = NULL;
657*b725ae77Skettenis
658*b725ae77Skettenis bv = obstack_alloc (&objfile->objfile_obstack,
659*b725ae77Skettenis sizeof (struct blockvector)
660*b725ae77Skettenis + FIRST_LOCAL_BLOCK * sizeof (struct block *));
661*b725ae77Skettenis BLOCKVECTOR_NBLOCKS (bv) = FIRST_LOCAL_BLOCK + 1;
662*b725ae77Skettenis BLOCKVECTOR (namespace_symtab) = bv;
663*b725ae77Skettenis
664*b725ae77Skettenis /* Allocate empty GLOBAL_BLOCK and STATIC_BLOCK. */
665*b725ae77Skettenis
666*b725ae77Skettenis bl = allocate_block (&objfile->objfile_obstack);
667*b725ae77Skettenis BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
668*b725ae77Skettenis NULL);
669*b725ae77Skettenis BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
670*b725ae77Skettenis bl = allocate_block (&objfile->objfile_obstack);
671*b725ae77Skettenis BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
672*b725ae77Skettenis NULL);
673*b725ae77Skettenis BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
674*b725ae77Skettenis
675*b725ae77Skettenis /* Allocate the possible namespace block; we put it where the first
676*b725ae77Skettenis local block will live, though I don't think there's any need to
677*b725ae77Skettenis pretend that it's actually a local block (e.g. by setting
678*b725ae77Skettenis BLOCK_SUPERBLOCK appropriately). We don't use the global or
679*b725ae77Skettenis static block because we don't want it searched during the normal
680*b725ae77Skettenis search of all global/static blocks in lookup_symbol: we only want
681*b725ae77Skettenis it used as a last resort. */
682*b725ae77Skettenis
683*b725ae77Skettenis /* NOTE: carlton/2003-09-11: I considered not associating the fake
684*b725ae77Skettenis symbols to a block/symtab at all. But that would cause problems
685*b725ae77Skettenis with lookup_symbol's SYMTAB argument and with block_found, so
686*b725ae77Skettenis having a symtab/block for this purpose seems like the best
687*b725ae77Skettenis solution for now. */
688*b725ae77Skettenis
689*b725ae77Skettenis bl = allocate_block (&objfile->objfile_obstack);
690*b725ae77Skettenis BLOCK_DICT (bl) = dict_create_hashed_expandable ();
691*b725ae77Skettenis BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK) = bl;
692*b725ae77Skettenis
693*b725ae77Skettenis namespace_symtab->free_func = free_namespace_block;
694*b725ae77Skettenis
695*b725ae77Skettenis objfile->cp_namespace_symtab = namespace_symtab;
696*b725ae77Skettenis }
697*b725ae77Skettenis
698*b725ae77Skettenis /* Locate the possible namespace block associated to OBJFILE,
699*b725ae77Skettenis allocating it if necessary. */
700*b725ae77Skettenis
701*b725ae77Skettenis static struct block *
get_possible_namespace_block(struct objfile * objfile)702*b725ae77Skettenis get_possible_namespace_block (struct objfile *objfile)
703*b725ae77Skettenis {
704*b725ae77Skettenis if (objfile->cp_namespace_symtab == NULL)
705*b725ae77Skettenis initialize_namespace_symtab (objfile);
706*b725ae77Skettenis
707*b725ae77Skettenis return BLOCKVECTOR_BLOCK (BLOCKVECTOR (objfile->cp_namespace_symtab),
708*b725ae77Skettenis FIRST_LOCAL_BLOCK);
709*b725ae77Skettenis }
710*b725ae77Skettenis
711*b725ae77Skettenis /* Free the dictionary associated to the possible namespace block. */
712*b725ae77Skettenis
713*b725ae77Skettenis static void
free_namespace_block(struct symtab * symtab)714*b725ae77Skettenis free_namespace_block (struct symtab *symtab)
715*b725ae77Skettenis {
716*b725ae77Skettenis struct block *possible_namespace_block;
717*b725ae77Skettenis
718*b725ae77Skettenis possible_namespace_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
719*b725ae77Skettenis FIRST_LOCAL_BLOCK);
720*b725ae77Skettenis gdb_assert (possible_namespace_block != NULL);
721*b725ae77Skettenis dict_free (BLOCK_DICT (possible_namespace_block));
722*b725ae77Skettenis }
723*b725ae77Skettenis
724*b725ae77Skettenis /* Ensure that there are symbols in the possible namespace block
725*b725ae77Skettenis associated to OBJFILE for all initial substrings of NAME that look
726*b725ae77Skettenis like namespaces or classes. NAME should end in a member variable:
727*b725ae77Skettenis it shouldn't consist solely of namespaces. */
728*b725ae77Skettenis
729*b725ae77Skettenis void
cp_check_possible_namespace_symbols(const char * name,struct objfile * objfile)730*b725ae77Skettenis cp_check_possible_namespace_symbols (const char *name, struct objfile *objfile)
731*b725ae77Skettenis {
732*b725ae77Skettenis check_possible_namespace_symbols_loop (name,
733*b725ae77Skettenis cp_find_first_component (name),
734*b725ae77Skettenis objfile);
735*b725ae77Skettenis }
736*b725ae77Skettenis
737*b725ae77Skettenis /* This is a helper loop for cp_check_possible_namespace_symbols; it
738*b725ae77Skettenis ensures that there are symbols in the possible namespace block
739*b725ae77Skettenis associated to OBJFILE for all namespaces that are initial
740*b725ae77Skettenis substrings of NAME of length at least LEN. It returns 1 if a
741*b725ae77Skettenis previous loop had already created the shortest such symbol and 0
742*b725ae77Skettenis otherwise.
743*b725ae77Skettenis
744*b725ae77Skettenis This function assumes that if there is already a symbol associated
745*b725ae77Skettenis to a substring of NAME of a given length, then there are already
746*b725ae77Skettenis symbols associated to all substrings of NAME whose length is less
747*b725ae77Skettenis than that length. So if cp_check_possible_namespace_symbols has
748*b725ae77Skettenis been called once with argument "A::B::C::member", then that will
749*b725ae77Skettenis create symbols "A", "A::B", and "A::B::C". If it is then later
750*b725ae77Skettenis called with argument "A::B::D::member", then the new call will
751*b725ae77Skettenis generate a new symbol for "A::B::D", but once it sees that "A::B"
752*b725ae77Skettenis has already been created, it doesn't bother checking to see if "A"
753*b725ae77Skettenis has also been created. */
754*b725ae77Skettenis
755*b725ae77Skettenis static int
check_possible_namespace_symbols_loop(const char * name,int len,struct objfile * objfile)756*b725ae77Skettenis check_possible_namespace_symbols_loop (const char *name, int len,
757*b725ae77Skettenis struct objfile *objfile)
758*b725ae77Skettenis {
759*b725ae77Skettenis if (name[len] == ':')
760*b725ae77Skettenis {
761*b725ae77Skettenis int done;
762*b725ae77Skettenis int next_len = len + 2;
763*b725ae77Skettenis
764*b725ae77Skettenis next_len += cp_find_first_component (name + next_len);
765*b725ae77Skettenis done = check_possible_namespace_symbols_loop (name, next_len,
766*b725ae77Skettenis objfile);
767*b725ae77Skettenis
768*b725ae77Skettenis if (!done)
769*b725ae77Skettenis done = check_one_possible_namespace_symbol (name, len, objfile);
770*b725ae77Skettenis
771*b725ae77Skettenis return done;
772*b725ae77Skettenis }
773*b725ae77Skettenis else
774*b725ae77Skettenis return 0;
775*b725ae77Skettenis }
776*b725ae77Skettenis
777*b725ae77Skettenis /* Check to see if there's already a possible namespace symbol in
778*b725ae77Skettenis OBJFILE whose name is the initial substring of NAME of length LEN.
779*b725ae77Skettenis If not, create one and return 0; otherwise, return 1. */
780*b725ae77Skettenis
781*b725ae77Skettenis static int
check_one_possible_namespace_symbol(const char * name,int len,struct objfile * objfile)782*b725ae77Skettenis check_one_possible_namespace_symbol (const char *name, int len,
783*b725ae77Skettenis struct objfile *objfile)
784*b725ae77Skettenis {
785*b725ae77Skettenis struct block *block = get_possible_namespace_block (objfile);
786*b725ae77Skettenis char *name_copy = alloca (len + 1);
787*b725ae77Skettenis struct symbol *sym;
788*b725ae77Skettenis
789*b725ae77Skettenis memcpy (name_copy, name, len);
790*b725ae77Skettenis name_copy[len] = '\0';
791*b725ae77Skettenis sym = lookup_block_symbol (block, name_copy, NULL, VAR_DOMAIN);
792*b725ae77Skettenis
793*b725ae77Skettenis if (sym == NULL)
794*b725ae77Skettenis {
795*b725ae77Skettenis struct type *type;
796*b725ae77Skettenis name_copy = obsavestring (name, len, &objfile->objfile_obstack);
797*b725ae77Skettenis
798*b725ae77Skettenis type = init_type (TYPE_CODE_NAMESPACE, 0, 0, name_copy, objfile);
799*b725ae77Skettenis
800*b725ae77Skettenis TYPE_TAG_NAME (type) = TYPE_NAME (type);
801*b725ae77Skettenis
802*b725ae77Skettenis sym = obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
803*b725ae77Skettenis memset (sym, 0, sizeof (struct symbol));
804*b725ae77Skettenis SYMBOL_LANGUAGE (sym) = language_cplus;
805*b725ae77Skettenis SYMBOL_SET_NAMES (sym, name_copy, len, objfile);
806*b725ae77Skettenis SYMBOL_CLASS (sym) = LOC_TYPEDEF;
807*b725ae77Skettenis SYMBOL_TYPE (sym) = type;
808*b725ae77Skettenis SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
809*b725ae77Skettenis
810*b725ae77Skettenis dict_add_symbol (BLOCK_DICT (block), sym);
811*b725ae77Skettenis
812*b725ae77Skettenis return 0;
813*b725ae77Skettenis }
814*b725ae77Skettenis else
815*b725ae77Skettenis return 1;
816*b725ae77Skettenis }
817*b725ae77Skettenis
818*b725ae77Skettenis /* Look for a symbol named NAME in all the possible namespace blocks.
819*b725ae77Skettenis If one is found, return it; if SYMTAB is non-NULL, set *SYMTAB to
820*b725ae77Skettenis equal the symtab where it was found. */
821*b725ae77Skettenis
822*b725ae77Skettenis static struct symbol *
lookup_possible_namespace_symbol(const char * name,struct symtab ** symtab)823*b725ae77Skettenis lookup_possible_namespace_symbol (const char *name, struct symtab **symtab)
824*b725ae77Skettenis {
825*b725ae77Skettenis struct objfile *objfile;
826*b725ae77Skettenis
827*b725ae77Skettenis ALL_OBJFILES (objfile)
828*b725ae77Skettenis {
829*b725ae77Skettenis struct symbol *sym;
830*b725ae77Skettenis
831*b725ae77Skettenis sym = lookup_block_symbol (get_possible_namespace_block (objfile),
832*b725ae77Skettenis name, NULL, VAR_DOMAIN);
833*b725ae77Skettenis
834*b725ae77Skettenis if (sym != NULL)
835*b725ae77Skettenis {
836*b725ae77Skettenis if (symtab != NULL)
837*b725ae77Skettenis *symtab = objfile->cp_namespace_symtab;
838*b725ae77Skettenis
839*b725ae77Skettenis return sym;
840*b725ae77Skettenis }
841*b725ae77Skettenis }
842*b725ae77Skettenis
843*b725ae77Skettenis return NULL;
844*b725ae77Skettenis }
845*b725ae77Skettenis
846*b725ae77Skettenis /* Print out all the possible namespace symbols. */
847*b725ae77Skettenis
848*b725ae77Skettenis static void
maintenance_cplus_namespace(char * args,int from_tty)849*b725ae77Skettenis maintenance_cplus_namespace (char *args, int from_tty)
850*b725ae77Skettenis {
851*b725ae77Skettenis struct objfile *objfile;
852*b725ae77Skettenis printf_unfiltered ("Possible namespaces:\n");
853*b725ae77Skettenis ALL_OBJFILES (objfile)
854*b725ae77Skettenis {
855*b725ae77Skettenis struct dict_iterator iter;
856*b725ae77Skettenis struct symbol *sym;
857*b725ae77Skettenis
858*b725ae77Skettenis ALL_BLOCK_SYMBOLS (get_possible_namespace_block (objfile), iter, sym)
859*b725ae77Skettenis {
860*b725ae77Skettenis printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
861*b725ae77Skettenis }
862*b725ae77Skettenis }
863*b725ae77Skettenis }
864*b725ae77Skettenis
865*b725ae77Skettenis void
_initialize_cp_namespace(void)866*b725ae77Skettenis _initialize_cp_namespace (void)
867*b725ae77Skettenis {
868*b725ae77Skettenis add_cmd ("namespace", class_maintenance, maintenance_cplus_namespace,
869*b725ae77Skettenis "Print the list of possible C++ namespaces.",
870*b725ae77Skettenis &maint_cplus_cmd_list);
871*b725ae77Skettenis }
872