GDB (xrefs)

/tmp/gdb-8.1/gdb/d-namespace.c
Go to the documentation of this file.
1 /* Helper routines for D support in GDB.
2
3 Copyright (C) 2014-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "block.h"
23 #include "language.h"
24 #include "namespace.h"
25 #include "d-lang.h"
26 #include "gdb_obstack.h"
27
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. */
33
34 /* The character in NAME indexed by the return value is guaranteed to
35 always be either '.' or '\0'. */
36
37 static unsigned int
38 d_find_first_component (const char *name)
39 {
40 unsigned int index = 0;
41
42 for (;; ++index)
43 {
44 if (name[index] == '.' || name[index] == '\0')
45 return index;
46 }
47 }
48
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. */
53
54 static unsigned int
55 d_entire_prefix_len (const char *name)
56 {
57 unsigned int current_len = d_find_first_component (name);
58 unsigned int previous_len = 0;
59
60 while (name[current_len] != '\0')
61 {
62 gdb_assert (name[current_len] == '.');
63 previous_len = current_len;
64 /* Skip the '.' */
65 current_len++;
66 current_len += d_find_first_component (name + current_len);
67 }
68
69 return previous_len;
70 }
71
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. */
75
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)
80 {
81 struct block_symbol sym;
82
83 sym = lookup_symbol_in_static_block (name, block, domain);
84 if (sym.symbol != NULL)
85 return sym;
86
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)
90 {
91 struct gdbarch *gdbarch;
92
93 if (block == NULL)
94 gdbarch = target_gdbarch ();
95 else
96 gdbarch = block_gdbarch (block);
97 sym.symbol
98 = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
99 sym.block = NULL;
100 if (sym.symbol != NULL)
101 return sym;
102 }
103
104 sym = lookup_global_symbol (name, block, domain);
105
106 if (sym.symbol != NULL)
107 return sym;
108
109 if (search)
110 {
111 std::string classname, nested;
112 unsigned int prefix_len;
113 struct block_symbol class_sym;
114
115 /* A simple lookup failed. Check if the symbol was defined in
116 a base class. */
117
118 /* Find the name of the class and the name of the method,
119 variable, etc. */
120 prefix_len = d_entire_prefix_len (name);
121
122 /* If no prefix was found, search "this". */
123 if (prefix_len == 0)
124 {
125 struct type *type;
126 struct block_symbol lang_this;
127
128 lang_this = lookup_language_this (language_def (language_d), block);
129 if (lang_this.symbol == NULL)
130 return null_block_symbol;
131
132 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
133 classname = TYPE_NAME (type);
134 nested = name;
135 }
136 else
137 {
138 /* The class name is everything up to and including PREFIX_LEN. */
139 classname = std::string (name, prefix_len);
140
141 /* The rest of the name is everything else past the initial scope
142 operator. */
143 nested = std::string (name + prefix_len + 1);
144 }
145
146 /* Lookup a class named CLASSNAME. If none is found, there is nothing
147 more that can be done. */
148 class_sym = lookup_global_symbol (classname.c_str (), block, domain);
149 if (class_sym.symbol == NULL)
150 return null_block_symbol;
151
152 /* Look for a symbol named NESTED in this class. */
153 sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
154 nested.c_str (), block);
155 }
156
157 return sym;
158 }
159
160 /* Look up NAME in the D module MODULE. Other arguments are as in
161 d_lookup_symbol_nonlocal. If SEARCH is non-zero, search through
162 base classes for a matching symbol. */
163
164 static struct block_symbol
165 d_lookup_symbol_in_module (const char *module, const char *name,
166 const struct block *block,
167 const domain_enum domain, int search)
168 {
169 char *concatenated_name = NULL;
170
171 if (module[0] != '\0')
172 {
173 concatenated_name
174 = (char *) alloca (strlen (module) + strlen (name) + 2);
175 strcpy (concatenated_name, module);
176 strcat (concatenated_name, ".");
177 strcat (concatenated_name, name);
178 name = concatenated_name;
179 }
180
181 return d_lookup_symbol (NULL, name, block, domain, search);
182 }
183
184 /* Lookup NAME at module scope. SCOPE is the module that the current
185 function is defined within; only consider modules whose length is at
186 least SCOPE_LEN. Other arguments are as in d_lookup_symbol_nonlocal.
187
188 For example, if we're within a function A.B.f and looking for a
189 symbol x, this will get called with NAME = "x", SCOPE = "A.B", and
190 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
191 but with SCOPE_LEN = 1. And then it calls itself with NAME and
192 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
193 "A.B.x"; if it doesn't find it, then the second call looks for "A.x",
194 and if that call fails, then the first call looks for "x". */
195
196 static struct block_symbol
197 lookup_module_scope (const struct language_defn *langdef,
198 const char *name, const struct block *block,
199 const domain_enum domain, const char *scope,
200 int scope_len)
201 {
202 char *module;
203
204 if (scope[scope_len] != '\0')
205 {
206 /* Recursively search for names in child modules first. */
207
208 struct block_symbol sym;
209 int new_scope_len = scope_len;
210
211 /* If the current scope is followed by ".", skip past that. */
212 if (new_scope_len != 0)
213 {
214 gdb_assert (scope[new_scope_len] == '.');
215 new_scope_len++;
216 }
217 new_scope_len += d_find_first_component (scope + new_scope_len);
218 sym = lookup_module_scope (langdef, name, block, domain,
219 scope, new_scope_len);
220 if (sym.symbol != NULL)
221 return sym;
222 }
223
224 /* Okay, we didn't find a match in our children, so look for the
225 name in the current module.
226
227 If we there is no scope and we know we have a bare symbol, then short
228 circuit everything and call d_lookup_symbol directly.
229 This isn't an optimization, rather it allows us to pass LANGDEF which
230 is needed for primitive type lookup. */
231
232 if (scope_len == 0 && strchr (name, '.') == NULL)
233 return d_lookup_symbol (langdef, name, block, domain, 1);
234
235 module = (char *) alloca (scope_len + 1);
236 strncpy (module, scope, scope_len);
237 module[scope_len] = '\0';
238 return d_lookup_symbol_in_module (module, name,
239 block, domain, 1);
240 }
241
242 /* Search through the base classes of PARENT_TYPE for a symbol named
243 NAME in block BLOCK. */
244
245 static struct block_symbol
246 find_symbol_in_baseclass (struct type *parent_type, const char *name,
247 const struct block *block)
248 {
249 struct block_symbol sym;
250 int i;
251
252 sym.symbol = NULL;
253 sym.block = NULL;
254
255 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
256 {
257 struct type *base_type = TYPE_BASECLASS (parent_type, i);
258 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
259
260 if (base_name == NULL)
261 continue;
262
263 /* Search this particular base class. */
264 sym = d_lookup_symbol_in_module (base_name, name, block,
265 VAR_DOMAIN, 0);
266 if (sym.symbol != NULL)
267 break;
268
269 /* Now search all static file-level symbols. We have to do this for
270 things like typedefs in the class. First search in this symtab,
271 what we want is possibly there. */
272 std::string concatenated_name = std::string (base_name) + "." + name;
273 sym = lookup_symbol_in_static_block (concatenated_name.c_str (), block,
274 VAR_DOMAIN);
275 if (sym.symbol != NULL)
276 break;
277
278 /* Nope. We now have to search all static blocks in all objfiles,
279 even if block != NULL, because there's no guarantees as to which
280 symtab the symbol we want is in. */
281 sym = lookup_static_symbol (concatenated_name.c_str (), VAR_DOMAIN);
282 if (sym.symbol != NULL)
283 break;
284
285 /* If this class has base classes, search them next. */
286 base_type = check_typedef (base_type);
287 if (TYPE_N_BASECLASSES (base_type) > 0)
288 {
289 sym = find_symbol_in_baseclass (base_type, name, block);
290 if (sym.symbol != NULL)
291 break;
292 }
293 }
294
295 return sym;
296 }
297
298 /* Look up a symbol named NESTED_NAME that is nested inside the D
299 class or module given by PARENT_TYPE, from within the context
300 given by BLOCK. Return NULL if there is no such nested type. */
301
302 struct block_symbol
303 d_lookup_nested_symbol (struct type *parent_type,
304 const char *nested_name,
305 const struct block *block)
306 {
307 /* type_name_no_tag_required provides better error reporting using the
308 original type. */
309 struct type *saved_parent_type = parent_type;
310
311 parent_type = check_typedef (parent_type);
312
313 switch (TYPE_CODE (parent_type))
314 {
315 case TYPE_CODE_STRUCT:
316 case TYPE_CODE_UNION:
317 case TYPE_CODE_ENUM:
318 case TYPE_CODE_MODULE:
319 {
320 int size;
321 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
322 struct block_symbol sym
323 = d_lookup_symbol_in_module (parent_name, nested_name,
324 block, VAR_DOMAIN, 0);
325 char *concatenated_name;
326
327 if (sym.symbol != NULL)
328 return sym;
329
330 /* Now search all static file-level symbols. We have to do this
331 for things like typedefs in the class. We do not try to
332 guess any imported module as even the fully specified
333 module search is already not D compliant and more assumptions
334 could make it too magic. */
335 size = strlen (parent_name) + strlen (nested_name) + 2;
336 concatenated_name = (char *) alloca (size);
337
338 xsnprintf (concatenated_name, size, "%s.%s",
339 parent_name, nested_name);
340
341 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
342 if (sym.symbol != NULL)
343 return sym;
344
345 /* If no matching symbols were found, try searching any
346 base classes. */
347 return find_symbol_in_baseclass (parent_type, nested_name, block);
348 }
349
350 case TYPE_CODE_FUNC:
351 case TYPE_CODE_METHOD:
352 return null_block_symbol;
353
354 default:
355 gdb_assert_not_reached ("called with non-aggregate type.");
356 }
357 }
358
359 /* Search for NAME by applying all import statements belonging to
360 BLOCK which are applicable in SCOPE. */
361
362 static struct block_symbol
363 d_lookup_symbol_imports (const char *scope, const char *name,
364 const struct block *block,
365 const domain_enum domain)
366 {
367 struct using_direct *current;
368 struct block_symbol sym;
369
370 /* First, try to find the symbol in the given module. */
371 sym = d_lookup_symbol_in_module (scope, name, block, domain, 1);
372
373 if (sym.symbol != NULL)
374 return sym;
375
376 /* Go through the using directives. If any of them add new names to
377 the module we're searching in, see if we can find a match by
378 applying them. */
379
380 for (current = block_using (block);
381 current != NULL;
382 current = current->next)
383 {
384 const char **excludep;
385
386 /* If the import destination is the current scope then search it. */
387 if (!current->searched && strcmp (scope, current->import_dest) == 0)
388 {
389 /* Mark this import as searched so that the recursive call
390 does not search it again. */
391 scoped_restore restore_searched
392 = make_scoped_restore (&current->searched, 1);
393
394 /* If there is an import of a single declaration, compare the
395 imported declaration (after optional renaming by its alias)
396 with the sought out name. If there is a match pass
397 current->import_src as MODULE to direct the search towards
398 the imported module. */
399 if (current->declaration
400 && strcmp (name, current->alias
401 ? current->alias : current->declaration) == 0)
402 sym = d_lookup_symbol_in_module (current->import_src,
403 current->declaration,
404 block, domain, 1);
405
406 /* If a symbol was found or this import statement was an import
407 declaration, the search of this import is complete. */
408 if (sym.symbol != NULL || current->declaration)
409 {
410 if (sym.symbol != NULL)
411 return sym;
412
413 continue;
414 }
415
416 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
417 for (excludep = current->excludes; *excludep; excludep++)
418 if (strcmp (name, *excludep) == 0)
419 break;
420 if (*excludep)
421 continue;
422
423 /* If the import statement is creating an alias. */
424 if (current->alias != NULL)
425 {
426 if (strcmp (name, current->alias) == 0)
427 {
428 /* If the alias matches the sought name. Pass
429 current->import_src as the NAME to direct the
430 search towards the aliased module. */
431 sym = lookup_module_scope (NULL, current->import_src, block,
432 domain, scope, 0);
433 }
434 else
435 {
436 /* If the alias matches the first component of the
437 sought name, pass current->import_src as MODULE
438 to direct the search, skipping over the aliased
439 component in NAME. */
440 int name_scope = d_find_first_component (name);
441
442 if (name[name_scope] != '\0'
443 && strncmp (name, current->alias, name_scope) == 0)
444 {
445 /* Skip the '.' */
446 name_scope++;
447 sym = d_lookup_symbol_in_module (current->import_src,
448 name + name_scope,
449 block, domain, 1);
450 }
451 }
452 }
453 else
454 {
455 /* If this import statement creates no alias, pass
456 current->import_src as MODULE to direct the search
457 towards the imported module. */
458 sym = d_lookup_symbol_in_module (current->import_src,
459 name, block, domain, 1);
460 }
461
462 if (sym.symbol != NULL)
463 return sym;
464 }
465 }
466
467 return null_block_symbol;
468 }
469
470 /* Searches for NAME in the current module, and by applying relevant
471 import statements belonging to BLOCK and its parents. SCOPE is the
472 module scope of the context in which the search is being evaluated. */
473
474 static struct block_symbol
475 d_lookup_symbol_module (const char *scope, const char *name,
476 const struct block *block,
477 const domain_enum domain)
478 {
479 struct block_symbol sym;
480
481 /* First, try to find the symbol in the given module. */
482 sym = d_lookup_symbol_in_module (scope, name,
483 block, domain, 1);
484 if (sym.symbol != NULL)
485 return sym;
486
487 /* Search for name in modules imported to this and parent
488 blocks. */
489 while (block != NULL)
490 {
491 sym = d_lookup_symbol_imports (scope, name, block, domain);
492
493 if (sym.symbol != NULL)
494 return sym;
495
496 block = BLOCK_SUPERBLOCK (block);
497 }
498
499 return null_block_symbol;
500 }
501
502 /* The D-specific version of name lookup for static and global names
503 This makes sure that names get looked for in all modules that are
504 in scope. NAME is the natural name of the symbol that we're looking
505 looking for, BLOCK is the block that we're searching within, DOMAIN
506 says what kind of symbols we're looking for, and if SYMTAB is non-NULL,
507 we should store the symtab where we found the symbol in it. */
508
509 struct block_symbol
510 d_lookup_symbol_nonlocal (const struct language_defn *langdef,
511 const char *name,
512 const struct block *block,
513 const domain_enum domain)
514 {
515 struct block_symbol sym;
516 const char *scope = block_scope (block);
517
518 sym = lookup_module_scope (langdef, name, block, domain, scope, 0);
519 if (sym.symbol != NULL)
520 return sym;
521
522 return d_lookup_symbol_module (scope, name, block, domain);
523 }
524
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
language_lookup_primitive_type_as_symbol
struct symbol * language_lookup_primitive_type_as_symbol(const struct language_defn *la, struct gdbarch *gdbarch, const char *name)
Definition: language.c:1099
d_entire_prefix_len
static unsigned int d_entire_prefix_len(const char *name)
Definition: d-namespace.c:55
gdb_obstack.h
using_direct::import_dest
const char * import_dest
Definition: namespace.h:93
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
d_find_first_component
static unsigned int d_find_first_component(const char *name)
Definition: d-namespace.c:38
using_direct::alias
const char * alias
Definition: namespace.h:95
d_lookup_symbol_module
static struct block_symbol d_lookup_symbol_module(const char *scope, const char *name, const struct block *block, const domain_enum domain)
Definition: d-namespace.c:475
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
using_direct::import_src
const char * import_src
Definition: namespace.h:92
type_name_no_tag_or_error
const char * type_name_no_tag_or_error(struct type *type)
Definition: gdbtypes.c:1485
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
domain_enum
enum domain_enum_tag domain_enum
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
null_block_symbol
const struct block_symbol null_block_symbol
Definition: symtab.c:96
defs.h
d_lookup_symbol_nonlocal
struct block_symbol d_lookup_symbol_nonlocal(const struct language_defn *langdef, const char *name, const struct block *block, const domain_enum domain)
Definition: d-namespace.c:510
language_defn
Definition: language.h:132
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
symtab.h
name
const char *const name
Definition: aarch64-tdep.c:76
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
using_direct::excludes
const char * excludes[1]
Definition: namespace.h:106
block_symbol::block
const struct block * block
Definition: symtab.h:1140
d_lookup_symbol_imports
static struct block_symbol d_lookup_symbol_imports(const char *scope, const char *name, const struct block *block, const domain_enum domain)
Definition: d-namespace.c:363
namespace.h
block_symbol
Definition: symtab.h:1133
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
TYPE_CODE_UNION
Definition: gdbtypes.h:107
block_using
struct using_direct * block_using(const struct block *block)
Definition: block.c:324
scoped_restore_base
Definition: scoped_restore.h:24
type
Definition: gdbtypes.h:749
language.h
using_direct::searched
int searched
Definition: namespace.h:102
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
using_direct
Definition: namespace.h:90
type
static const char * type
Definition: language.c:113
TYPE_BASECLASS
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1330
lookup_global_symbol
struct block_symbol lookup_global_symbol(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2651
find_symbol_in_baseclass
static struct block_symbol find_symbol_in_baseclass(struct type *parent_type, const char *name, const struct block *block)
Definition: d-namespace.c:246
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
language_d
Definition: defs.h:210
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
using_direct::next
struct using_direct * next
Definition: namespace.h:98
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
TYPE_BASECLASS_NAME
#define TYPE_BASECLASS_NAME(thistype, index)
Definition: gdbtypes.h:1332
d-lang.h
d_lookup_symbol_in_module
static struct block_symbol d_lookup_symbol_in_module(const char *module, const char *name, const struct block *block, const domain_enum domain, int search)
Definition: d-namespace.c:165
block_gdbarch
struct gdbarch * block_gdbarch(const struct block *block)
Definition: block.c:60
lookup_static_symbol
struct block_symbol lookup_static_symbol(const char *name, const domain_enum domain)
Definition: symtab.c:2574
VAR_DOMAIN
Definition: symtab.h:739
lookup_language_this
struct block_symbol lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1915
TYPE_CODE_MODULE
Definition: gdbtypes.h:175
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
lookup_symbol_in_static_block
struct block_symbol lookup_symbol_in_static_block(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2487
lookup_module_scope
static struct block_symbol lookup_module_scope(const struct language_defn *langdef, const char *name, const struct block *block, const domain_enum domain, const char *scope, int scope_len)
Definition: d-namespace.c:197
TYPE_CODE_METHOD
Definition: gdbtypes.h:141
using_direct::declaration
const char * declaration
Definition: namespace.h:96
d_lookup_symbol
static struct block_symbol d_lookup_symbol(const struct language_defn *langdef, const char *name, const struct block *block, const domain_enum domain, int search)
Definition: d-namespace.c:77
size
size_t size
Definition: go32-nat.c:242
block_scope
const char * block_scope(const struct block *block)
Definition: block.c:295
block.h
d_lookup_nested_symbol
struct block_symbol d_lookup_nested_symbol(struct type *parent_type, const char *nested_name, const struct block *block)
Definition: d-namespace.c:303