1 /* Helper routines for D support in GDB.
3 Copyright (C) 2014-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "namespace.h"
26 #include "gdb_obstack.h"
28 /* This returns the length of first component of NAME, which should be
29 the demangled name of a D variable/function/method/etc.
30 Specifically, it returns the index of the first dot forming the
31 boundary of the first component: so, given 'A.foo' or 'A.B.foo'
32 it returns the 1, and given 'foo', it returns 0. */
34 /* The character in NAME indexed by the return value is guaranteed to
35 always be either '.' or '\0'. */
38 d_find_first_component (const char *name)
40 unsigned int index = 0;
44 if (name[index] == '.' || name[index] == '\0')
49 /* If NAME is the fully-qualified name of a D function/variable/method,
50 this returns the length of its entire prefix: all of the modules and
51 classes that make up its name. Given 'A.foo', it returns 1, given
52 'A.B.foo', it returns 4, given 'foo', it returns 0. */
55 d_entire_prefix_len (const char *name)
57 unsigned int current_len = d_find_first_component (name);
58 unsigned int previous_len = 0;
60 while (name[current_len] != '\0')
62 gdb_assert (name[current_len] == '.');
63 previous_len = current_len;
66 current_len += d_find_first_component (name + current_len);
72 /* Look up NAME in BLOCK's static block and in global blocks.
73 If SEARCH is non-zero, search through base classes for a matching
74 symbol. Other arguments are as in d_lookup_symbol_nonlocal. */
76 static struct block_symbol
77 d_lookup_symbol (const struct language_defn *langdef,
78 const char *name, const struct block *block,
79 const domain_enum domain, int search)
81 struct block_symbol sym;
83 sym = lookup_symbol_in_static_block (name, block, domain);
84 if (sym.symbol != NULL)
87 /* If we didn't find a definition for a builtin type in the static block,
88 such as "ucent" which is a specialist type, search for it now. */
89 if (langdef != NULL && domain == VAR_DOMAIN)
91 struct gdbarch *gdbarch;
94 gdbarch = target_gdbarch ();
96 gdbarch = block_gdbarch (block);
98 = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
100 if (sym.symbol != NULL)
104 sym = lookup_global_symbol (name, block, domain);
106 if (sym.symbol != NULL)
111 char *classname, *nested;
112 unsigned int prefix_len;
113 struct cleanup *cleanup;
114 struct block_symbol class_sym;
116 /* A simple lookup failed. Check if the symbol was defined in
119 cleanup = make_cleanup (null_cleanup, NULL);
121 /* Find the name of the class and the name of the method,
123 prefix_len = d_entire_prefix_len (name);
125 /* If no prefix was found, search "this". */
129 struct block_symbol lang_this;
131 lang_this = lookup_language_this (language_def (language_d), block);
132 if (lang_this.symbol == NULL)
134 do_cleanups (cleanup);
135 return null_block_symbol;
138 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
139 classname = xstrdup (TYPE_NAME (type));
140 nested = xstrdup (name);
144 /* The class name is everything up to and including PREFIX_LEN. */
145 classname = savestring (name, prefix_len);
147 /* The rest of the name is everything else past the initial scope
149 nested = xstrdup (name + prefix_len + 1);
152 /* Add cleanups to free memory for these strings. */
153 make_cleanup (xfree, classname);
154 make_cleanup (xfree, nested);
156 /* Lookup a class named CLASSNAME. If none is found, there is nothing
157 more that can be done. */
158 class_sym = lookup_global_symbol (classname, block, domain);
159 if (class_sym.symbol == NULL)
161 do_cleanups (cleanup);
162 return null_block_symbol;
165 /* Look for a symbol named NESTED in this class. */
166 sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
168 do_cleanups (cleanup);
174 /* Look up NAME in the D module MODULE. Other arguments are as in
175 d_lookup_symbol_nonlocal. If SEARCH is non-zero, search through
176 base classes for a matching symbol. */
178 static struct block_symbol
179 d_lookup_symbol_in_module (const char *module, const char *name,
180 const struct block *block,
181 const domain_enum domain, int search)
183 char *concatenated_name = NULL;
185 if (module[0] != '\0')
188 = (char *) alloca (strlen (module) + strlen (name) + 2);
189 strcpy (concatenated_name, module);
190 strcat (concatenated_name, ".");
191 strcat (concatenated_name, name);
192 name = concatenated_name;
195 return d_lookup_symbol (NULL, name, block, domain, search);
198 /* Lookup NAME at module scope. SCOPE is the module that the current
199 function is defined within; only consider modules whose length is at
200 least SCOPE_LEN. Other arguments are as in d_lookup_symbol_nonlocal.
202 For example, if we're within a function A.B.f and looking for a
203 symbol x, this will get called with NAME = "x", SCOPE = "A.B", and
204 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
205 but with SCOPE_LEN = 1. And then it calls itself with NAME and
206 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
207 "A.B.x"; if it doesn't find it, then the second call looks for "A.x",
208 and if that call fails, then the first call looks for "x". */
210 static struct block_symbol
211 lookup_module_scope (const struct language_defn *langdef,
212 const char *name, const struct block *block,
213 const domain_enum domain, const char *scope,
218 if (scope[scope_len] != '\0')
220 /* Recursively search for names in child modules first. */
222 struct block_symbol sym;
223 int new_scope_len = scope_len;
225 /* If the current scope is followed by ".", skip past that. */
226 if (new_scope_len != 0)
228 gdb_assert (scope[new_scope_len] == '.');
231 new_scope_len += d_find_first_component (scope + new_scope_len);
232 sym = lookup_module_scope (langdef, name, block, domain,
233 scope, new_scope_len);
234 if (sym.symbol != NULL)
238 /* Okay, we didn't find a match in our children, so look for the
239 name in the current module.
241 If we there is no scope and we know we have a bare symbol, then short
242 circuit everything and call d_lookup_symbol directly.
243 This isn't an optimization, rather it allows us to pass LANGDEF which
244 is needed for primitive type lookup. */
246 if (scope_len == 0 && strchr (name, '.') == NULL)
247 return d_lookup_symbol (langdef, name, block, domain, 1);
249 module = (char *) alloca (scope_len + 1);
250 strncpy (module, scope, scope_len);
251 module[scope_len] = '\0';
252 return d_lookup_symbol_in_module (module, name,
256 /* Search through the base classes of PARENT_TYPE for a symbol named
257 NAME in block BLOCK. */
259 static struct block_symbol
260 find_symbol_in_baseclass (struct type *parent_type, const char *name,
261 const struct block *block)
263 char *concatenated_name = NULL;
264 struct block_symbol sym;
265 struct cleanup *cleanup;
270 cleanup = make_cleanup (free_current_contents, &concatenated_name);
272 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
275 struct type *base_type = TYPE_BASECLASS (parent_type, i);
276 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
278 if (base_name == NULL)
281 /* Search this particular base class. */
282 sym = d_lookup_symbol_in_module (base_name, name, block,
284 if (sym.symbol != NULL)
287 /* Now search all static file-level symbols. We have to do this for
288 things like typedefs in the class. First search in this symtab,
289 what we want is possibly there. */
290 len = strlen (base_name) + strlen (name) + 2;
291 concatenated_name = (char *) xrealloc (concatenated_name, len);
292 xsnprintf (concatenated_name, len, "%s.%s", base_name, name);
293 sym = lookup_symbol_in_static_block (concatenated_name, block,
295 if (sym.symbol != NULL)
298 /* Nope. We now have to search all static blocks in all objfiles,
299 even if block != NULL, because there's no guarantees as to which
300 symtab the symbol we want is in. */
301 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
302 if (sym.symbol != NULL)
305 /* If this class has base classes, search them next. */
306 base_type = check_typedef (base_type);
307 if (TYPE_N_BASECLASSES (base_type) > 0)
309 sym = find_symbol_in_baseclass (base_type, name, block);
310 if (sym.symbol != NULL)
315 do_cleanups (cleanup);
319 /* Look up a symbol named NESTED_NAME that is nested inside the D
320 class or module given by PARENT_TYPE, from within the context
321 given by BLOCK. Return NULL if there is no such nested type. */
324 d_lookup_nested_symbol (struct type *parent_type,
325 const char *nested_name,
326 const struct block *block)
328 /* type_name_no_tag_required provides better error reporting using the
330 struct type *saved_parent_type = parent_type;
332 parent_type = check_typedef (parent_type);
334 switch (TYPE_CODE (parent_type))
336 case TYPE_CODE_STRUCT:
337 case TYPE_CODE_UNION:
339 case TYPE_CODE_MODULE:
342 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
343 struct block_symbol sym
344 = d_lookup_symbol_in_module (parent_name, nested_name,
345 block, VAR_DOMAIN, 0);
346 char *concatenated_name;
348 if (sym.symbol != NULL)
351 /* Now search all static file-level symbols. We have to do this
352 for things like typedefs in the class. We do not try to
353 guess any imported module as even the fully specified
354 module search is already not D compliant and more assumptions
355 could make it too magic. */
356 size = strlen (parent_name) + strlen (nested_name) + 2;
357 concatenated_name = (char *) alloca (size);
359 xsnprintf (concatenated_name, size, "%s.%s",
360 parent_name, nested_name);
362 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
363 if (sym.symbol != NULL)
366 /* If no matching symbols were found, try searching any
368 return find_symbol_in_baseclass (parent_type, nested_name, block);
372 case TYPE_CODE_METHOD:
373 return null_block_symbol;
376 gdb_assert_not_reached ("called with non-aggregate type.");
380 /* Used for cleanups to reset the "searched" flag incase
384 reset_directive_searched (void *data)
386 struct using_direct *direct = (struct using_direct *) data;
387 direct->searched = 0;
390 /* Search for NAME by applying all import statements belonging to
391 BLOCK which are applicable in SCOPE. */
393 static struct block_symbol
394 d_lookup_symbol_imports (const char *scope, const char *name,
395 const struct block *block,
396 const domain_enum domain)
398 struct using_direct *current;
399 struct block_symbol sym;
400 struct cleanup *searched_cleanup;
402 /* First, try to find the symbol in the given module. */
403 sym = d_lookup_symbol_in_module (scope, name, block, domain, 1);
405 if (sym.symbol != NULL)
408 /* Go through the using directives. If any of them add new names to
409 the module we're searching in, see if we can find a match by
412 for (current = block_using (block);
414 current = current->next)
416 const char **excludep;
418 /* If the import destination is the current scope then search it. */
419 if (!current->searched && strcmp (scope, current->import_dest) == 0)
421 /* Mark this import as searched so that the recursive call
422 does not search it again. */
423 current->searched = 1;
424 searched_cleanup = make_cleanup (reset_directive_searched,
427 /* If there is an import of a single declaration, compare the
428 imported declaration (after optional renaming by its alias)
429 with the sought out name. If there is a match pass
430 current->import_src as MODULE to direct the search towards
431 the imported module. */
432 if (current->declaration
433 && strcmp (name, current->alias
434 ? current->alias : current->declaration) == 0)
435 sym = d_lookup_symbol_in_module (current->import_src,
436 current->declaration,
439 /* If a symbol was found or this import statement was an import
440 declaration, the search of this import is complete. */
441 if (sym.symbol != NULL || current->declaration)
443 current->searched = 0;
444 discard_cleanups (searched_cleanup);
446 if (sym.symbol != NULL)
452 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
453 for (excludep = current->excludes; *excludep; excludep++)
454 if (strcmp (name, *excludep) == 0)
458 discard_cleanups (searched_cleanup);
462 /* If the import statement is creating an alias. */
463 if (current->alias != NULL)
465 if (strcmp (name, current->alias) == 0)
467 /* If the alias matches the sought name. Pass
468 current->import_src as the NAME to direct the
469 search towards the aliased module. */
470 sym = lookup_module_scope (NULL, current->import_src, block,
475 /* If the alias matches the first component of the
476 sought name, pass current->import_src as MODULE
477 to direct the search, skipping over the aliased
478 component in NAME. */
479 int name_scope = d_find_first_component (name);
481 if (name[name_scope] != '\0'
482 && strncmp (name, current->alias, name_scope) == 0)
486 sym = d_lookup_symbol_imports (current->import_src,
494 /* If this import statement creates no alias, pass
495 current->import_src as MODULE to direct the search
496 towards the imported module. */
497 sym = d_lookup_symbol_imports (current->import_src,
498 name, block, domain);
500 current->searched = 0;
501 discard_cleanups (searched_cleanup);
503 if (sym.symbol != NULL)
508 return null_block_symbol;
511 /* Searches for NAME in the current module, and by applying relevant
512 import statements belonging to BLOCK and its parents. SCOPE is the
513 module scope of the context in which the search is being evaluated. */
515 static struct block_symbol
516 d_lookup_symbol_module (const char *scope, const char *name,
517 const struct block *block,
518 const domain_enum domain)
520 struct block_symbol sym;
522 /* First, try to find the symbol in the given module. */
523 sym = d_lookup_symbol_in_module (scope, name,
525 if (sym.symbol != NULL)
528 /* Search for name in modules imported to this and parent
530 while (block != NULL)
532 sym = d_lookup_symbol_imports (scope, name, block, domain);
534 if (sym.symbol != NULL)
537 block = BLOCK_SUPERBLOCK (block);
540 return null_block_symbol;
543 /* The D-specific version of name lookup for static and global names
544 This makes sure that names get looked for in all modules that are
545 in scope. NAME is the natural name of the symbol that we're looking
546 looking for, BLOCK is the block that we're searching within, DOMAIN
547 says what kind of symbols we're looking for, and if SYMTAB is non-NULL,
548 we should store the symtab where we found the symbol in it. */
551 d_lookup_symbol_nonlocal (const struct language_defn *langdef,
553 const struct block *block,
554 const domain_enum domain)
556 struct block_symbol sym;
557 const char *scope = block_scope (block);
559 sym = lookup_module_scope (langdef, name, block, domain, scope, 0);
560 if (sym.symbol != NULL)
563 return d_lookup_symbol_module (scope, name, block, domain);