2015-08-14 02:34:15 +08:00
|
|
|
/* Helper routines for D support in GDB.
|
|
|
|
|
2016-01-01 12:33:14 +08:00
|
|
|
Copyright (C) 2014-2016 Free Software Foundation, Inc.
|
2015-08-14 02:34:15 +08:00
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "symtab.h"
|
|
|
|
#include "block.h"
|
|
|
|
#include "language.h"
|
|
|
|
#include "namespace.h"
|
|
|
|
#include "d-lang.h"
|
|
|
|
#include "gdb_obstack.h"
|
|
|
|
|
|
|
|
/* This returns the length of first component of NAME, which should be
|
|
|
|
the demangled name of a D variable/function/method/etc.
|
|
|
|
Specifically, it returns the index of the first dot forming the
|
|
|
|
boundary of the first component: so, given 'A.foo' or 'A.B.foo'
|
|
|
|
it returns the 1, and given 'foo', it returns 0. */
|
|
|
|
|
|
|
|
/* The character in NAME indexed by the return value is guaranteed to
|
|
|
|
always be either '.' or '\0'. */
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
d_find_first_component (const char *name)
|
|
|
|
{
|
|
|
|
unsigned int index = 0;
|
|
|
|
|
|
|
|
for (;; ++index)
|
|
|
|
{
|
|
|
|
if (name[index] == '.' || name[index] == '\0')
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If NAME is the fully-qualified name of a D function/variable/method,
|
|
|
|
this returns the length of its entire prefix: all of the modules and
|
|
|
|
classes that make up its name. Given 'A.foo', it returns 1, given
|
|
|
|
'A.B.foo', it returns 4, given 'foo', it returns 0. */
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
d_entire_prefix_len (const char *name)
|
|
|
|
{
|
|
|
|
unsigned int current_len = d_find_first_component (name);
|
|
|
|
unsigned int previous_len = 0;
|
|
|
|
|
|
|
|
while (name[current_len] != '\0')
|
|
|
|
{
|
|
|
|
gdb_assert (name[current_len] == '.');
|
|
|
|
previous_len = current_len;
|
|
|
|
/* Skip the '.' */
|
|
|
|
current_len++;
|
|
|
|
current_len += d_find_first_component (name + current_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
return previous_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up NAME in BLOCK's static block and in global blocks.
|
|
|
|
If SEARCH is non-zero, search through base classes for a matching
|
|
|
|
symbol. Other arguments are as in d_lookup_symbol_nonlocal. */
|
|
|
|
|
|
|
|
static struct block_symbol
|
2015-09-26 15:08:12 +08:00
|
|
|
d_lookup_symbol (const struct language_defn *langdef,
|
|
|
|
const char *name, const struct block *block,
|
2015-08-14 02:34:15 +08:00
|
|
|
const domain_enum domain, int search)
|
|
|
|
{
|
|
|
|
struct block_symbol sym;
|
|
|
|
|
|
|
|
sym = lookup_symbol_in_static_block (name, block, domain);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
2015-09-26 15:08:12 +08:00
|
|
|
/* If we didn't find a definition for a builtin type in the static block,
|
|
|
|
such as "ucent" which is a specialist type, search for it now. */
|
|
|
|
if (langdef != NULL && domain == VAR_DOMAIN)
|
|
|
|
{
|
|
|
|
struct gdbarch *gdbarch;
|
|
|
|
|
|
|
|
if (block == NULL)
|
|
|
|
gdbarch = target_gdbarch ();
|
|
|
|
else
|
|
|
|
gdbarch = block_gdbarch (block);
|
|
|
|
sym.symbol
|
|
|
|
= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
|
|
|
|
sym.block = NULL;
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
|
2015-08-14 02:34:15 +08:00
|
|
|
sym = lookup_global_symbol (name, block, domain);
|
|
|
|
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
if (search)
|
|
|
|
{
|
|
|
|
char *classname, *nested;
|
|
|
|
unsigned int prefix_len;
|
|
|
|
struct cleanup *cleanup;
|
|
|
|
struct block_symbol class_sym;
|
|
|
|
|
|
|
|
/* A simple lookup failed. Check if the symbol was defined in
|
|
|
|
a base class. */
|
|
|
|
|
|
|
|
cleanup = make_cleanup (null_cleanup, NULL);
|
|
|
|
|
|
|
|
/* Find the name of the class and the name of the method,
|
|
|
|
variable, etc. */
|
|
|
|
prefix_len = d_entire_prefix_len (name);
|
|
|
|
|
|
|
|
/* If no prefix was found, search "this". */
|
|
|
|
if (prefix_len == 0)
|
|
|
|
{
|
|
|
|
struct type *type;
|
|
|
|
struct block_symbol lang_this;
|
|
|
|
|
|
|
|
lang_this = lookup_language_this (language_def (language_d), block);
|
|
|
|
if (lang_this.symbol == NULL)
|
|
|
|
{
|
|
|
|
do_cleanups (cleanup);
|
2015-11-17 21:12:23 +08:00
|
|
|
return null_block_symbol;
|
2015-08-14 02:34:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
|
|
|
|
classname = xstrdup (TYPE_NAME (type));
|
|
|
|
nested = xstrdup (name);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* The class name is everything up to and including PREFIX_LEN. */
|
|
|
|
classname = savestring (name, prefix_len);
|
|
|
|
|
|
|
|
/* The rest of the name is everything else past the initial scope
|
|
|
|
operator. */
|
|
|
|
nested = xstrdup (name + prefix_len + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add cleanups to free memory for these strings. */
|
|
|
|
make_cleanup (xfree, classname);
|
|
|
|
make_cleanup (xfree, nested);
|
|
|
|
|
|
|
|
/* Lookup a class named CLASSNAME. If none is found, there is nothing
|
|
|
|
more that can be done. */
|
|
|
|
class_sym = lookup_global_symbol (classname, block, domain);
|
|
|
|
if (class_sym.symbol == NULL)
|
|
|
|
{
|
|
|
|
do_cleanups (cleanup);
|
2015-11-17 21:12:23 +08:00
|
|
|
return null_block_symbol;
|
2015-08-14 02:34:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Look for a symbol named NESTED in this class. */
|
|
|
|
sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
|
|
|
|
nested, block);
|
|
|
|
do_cleanups (cleanup);
|
|
|
|
}
|
|
|
|
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up NAME in the D module MODULE. Other arguments are as in
|
|
|
|
d_lookup_symbol_nonlocal. If SEARCH is non-zero, search through
|
|
|
|
base classes for a matching symbol. */
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
char *concatenated_name = NULL;
|
|
|
|
|
|
|
|
if (module[0] != '\0')
|
|
|
|
{
|
2015-09-26 02:08:06 +08:00
|
|
|
concatenated_name
|
|
|
|
= (char *) alloca (strlen (module) + strlen (name) + 2);
|
2015-08-14 02:34:15 +08:00
|
|
|
strcpy (concatenated_name, module);
|
|
|
|
strcat (concatenated_name, ".");
|
|
|
|
strcat (concatenated_name, name);
|
|
|
|
name = concatenated_name;
|
|
|
|
}
|
|
|
|
|
2015-09-26 15:08:12 +08:00
|
|
|
return d_lookup_symbol (NULL, name, block, domain, search);
|
2015-08-14 02:34:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Lookup NAME at module scope. SCOPE is the module that the current
|
|
|
|
function is defined within; only consider modules whose length is at
|
|
|
|
least SCOPE_LEN. Other arguments are as in d_lookup_symbol_nonlocal.
|
|
|
|
|
|
|
|
For example, if we're within a function A.B.f and looking for a
|
|
|
|
symbol x, this will get called with NAME = "x", SCOPE = "A.B", and
|
|
|
|
SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
|
|
|
|
but with SCOPE_LEN = 1. And then it calls itself with NAME and
|
|
|
|
SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
|
|
|
|
"A.B.x"; if it doesn't find it, then the second call looks for "A.x",
|
|
|
|
and if that call fails, then the first call looks for "x". */
|
|
|
|
|
|
|
|
static struct block_symbol
|
2015-09-26 15:08:12 +08:00
|
|
|
lookup_module_scope (const struct language_defn *langdef,
|
|
|
|
const char *name, const struct block *block,
|
2015-08-14 02:34:15 +08:00
|
|
|
const domain_enum domain, const char *scope,
|
|
|
|
int scope_len)
|
|
|
|
{
|
|
|
|
char *module;
|
|
|
|
|
|
|
|
if (scope[scope_len] != '\0')
|
|
|
|
{
|
|
|
|
/* Recursively search for names in child modules first. */
|
|
|
|
|
|
|
|
struct block_symbol sym;
|
|
|
|
int new_scope_len = scope_len;
|
|
|
|
|
|
|
|
/* If the current scope is followed by ".", skip past that. */
|
|
|
|
if (new_scope_len != 0)
|
|
|
|
{
|
|
|
|
gdb_assert (scope[new_scope_len] == '.');
|
|
|
|
new_scope_len++;
|
|
|
|
}
|
|
|
|
new_scope_len += d_find_first_component (scope + new_scope_len);
|
2015-09-26 15:08:12 +08:00
|
|
|
sym = lookup_module_scope (langdef, name, block, domain,
|
2015-08-14 02:34:15 +08:00
|
|
|
scope, new_scope_len);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Okay, we didn't find a match in our children, so look for the
|
2015-09-26 15:08:12 +08:00
|
|
|
name in the current module.
|
|
|
|
|
|
|
|
If we there is no scope and we know we have a bare symbol, then short
|
|
|
|
circuit everything and call d_lookup_symbol directly.
|
|
|
|
This isn't an optimization, rather it allows us to pass LANGDEF which
|
|
|
|
is needed for primitive type lookup. */
|
|
|
|
|
|
|
|
if (scope_len == 0 && strchr (name, '.') == NULL)
|
|
|
|
return d_lookup_symbol (langdef, name, block, domain, 1);
|
2015-08-14 02:34:15 +08:00
|
|
|
|
2015-09-26 02:08:06 +08:00
|
|
|
module = (char *) alloca (scope_len + 1);
|
2015-08-14 02:34:15 +08:00
|
|
|
strncpy (module, scope, scope_len);
|
|
|
|
module[scope_len] = '\0';
|
|
|
|
return d_lookup_symbol_in_module (module, name,
|
|
|
|
block, domain, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search through the base classes of PARENT_TYPE for a symbol named
|
|
|
|
NAME in block BLOCK. */
|
|
|
|
|
|
|
|
static struct block_symbol
|
|
|
|
find_symbol_in_baseclass (struct type *parent_type, const char *name,
|
|
|
|
const struct block *block)
|
|
|
|
{
|
|
|
|
char *concatenated_name = NULL;
|
|
|
|
struct block_symbol sym;
|
|
|
|
struct cleanup *cleanup;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
sym.symbol = NULL;
|
|
|
|
sym.block = NULL;
|
|
|
|
cleanup = make_cleanup (free_current_contents, &concatenated_name);
|
|
|
|
|
|
|
|
for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
struct type *base_type = TYPE_BASECLASS (parent_type, i);
|
|
|
|
const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
|
|
|
|
|
|
|
|
if (base_name == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Search this particular base class. */
|
|
|
|
sym = d_lookup_symbol_in_module (base_name, name, block,
|
|
|
|
VAR_DOMAIN, 0);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Now search all static file-level symbols. We have to do this for
|
|
|
|
things like typedefs in the class. First search in this symtab,
|
|
|
|
what we want is possibly there. */
|
|
|
|
len = strlen (base_name) + strlen (name) + 2;
|
2015-09-26 02:08:06 +08:00
|
|
|
concatenated_name = (char *) xrealloc (concatenated_name, len);
|
2015-08-14 02:34:15 +08:00
|
|
|
xsnprintf (concatenated_name, len, "%s.%s", base_name, name);
|
|
|
|
sym = lookup_symbol_in_static_block (concatenated_name, block,
|
|
|
|
VAR_DOMAIN);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Nope. We now have to search all static blocks in all objfiles,
|
|
|
|
even if block != NULL, because there's no guarantees as to which
|
|
|
|
symtab the symbol we want is in. */
|
|
|
|
sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* If this class has base classes, search them next. */
|
|
|
|
base_type = check_typedef (base_type);
|
|
|
|
if (TYPE_N_BASECLASSES (base_type) > 0)
|
|
|
|
{
|
|
|
|
sym = find_symbol_in_baseclass (base_type, name, block);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
do_cleanups (cleanup);
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up a symbol named NESTED_NAME that is nested inside the D
|
|
|
|
class or module given by PARENT_TYPE, from within the context
|
|
|
|
given by BLOCK. Return NULL if there is no such nested type. */
|
|
|
|
|
|
|
|
struct block_symbol
|
|
|
|
d_lookup_nested_symbol (struct type *parent_type,
|
|
|
|
const char *nested_name,
|
|
|
|
const struct block *block)
|
|
|
|
{
|
|
|
|
/* type_name_no_tag_required provides better error reporting using the
|
|
|
|
original type. */
|
|
|
|
struct type *saved_parent_type = parent_type;
|
|
|
|
|
|
|
|
parent_type = check_typedef (parent_type);
|
|
|
|
|
|
|
|
switch (TYPE_CODE (parent_type))
|
|
|
|
{
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
case TYPE_CODE_UNION:
|
2015-08-18 03:45:42 +08:00
|
|
|
case TYPE_CODE_ENUM:
|
2015-08-14 02:34:15 +08:00
|
|
|
case TYPE_CODE_MODULE:
|
|
|
|
{
|
|
|
|
int size;
|
|
|
|
const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
|
|
|
|
struct block_symbol sym
|
|
|
|
= d_lookup_symbol_in_module (parent_name, nested_name,
|
|
|
|
block, VAR_DOMAIN, 0);
|
|
|
|
char *concatenated_name;
|
|
|
|
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
/* Now search all static file-level symbols. We have to do this
|
|
|
|
for things like typedefs in the class. We do not try to
|
|
|
|
guess any imported module as even the fully specified
|
|
|
|
module search is already not D compliant and more assumptions
|
|
|
|
could make it too magic. */
|
|
|
|
size = strlen (parent_name) + strlen (nested_name) + 2;
|
2015-09-26 02:08:06 +08:00
|
|
|
concatenated_name = (char *) alloca (size);
|
2015-08-14 02:34:15 +08:00
|
|
|
|
|
|
|
xsnprintf (concatenated_name, size, "%s.%s",
|
|
|
|
parent_name, nested_name);
|
|
|
|
|
|
|
|
sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
/* If no matching symbols were found, try searching any
|
|
|
|
base classes. */
|
|
|
|
return find_symbol_in_baseclass (parent_type, nested_name, block);
|
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_CODE_FUNC:
|
|
|
|
case TYPE_CODE_METHOD:
|
2015-11-17 21:12:23 +08:00
|
|
|
return null_block_symbol;
|
2015-08-14 02:34:15 +08:00
|
|
|
|
|
|
|
default:
|
|
|
|
gdb_assert_not_reached ("called with non-aggregate type.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Used for cleanups to reset the "searched" flag incase
|
|
|
|
of an error. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
reset_directive_searched (void *data)
|
|
|
|
{
|
Add some more casts (1/2)
Note: I needed to split this patch in two, otherwise it's too big for
the mailing list.
This patch adds explicit casts to situations where a void pointer is
assigned to a pointer to the "real" type. Building in C++ mode requires
those assignments to use an explicit cast. This includes, for example:
- callback arguments (cleanups, comparison functions, ...)
- data attached to some object (objfile, program space, etc) in the form
of a void pointer
- "user data" passed to some function
This patch comes from the commit "(mostly) auto-generated patch to insert
casts needed for C++", taken from Pedro's C++ branch.
Only files built on x86 with --enable-targets=all are modified, so the
native files for other arches will need to be dealt with separately.
I built-tested this with --enable-targets=all and reg-tested. To my
surprise, a test case (selftest.exp) had to be adjusted.
Here's the ChangeLog entry. Again, this was relatively quick to make
despite the length, thanks to David Malcom's script, although I don't
believe it's very useful information in that particular case...
gdb/ChangeLog:
* aarch64-tdep.c (aarch64_make_prologue_cache): Add cast(s).
(aarch64_make_stub_cache): Likewise.
(value_of_aarch64_user_reg): Likewise.
* ada-lang.c (ada_inferior_data_cleanup): Likewise.
(get_ada_inferior_data): Likewise.
(get_ada_pspace_data): Likewise.
(ada_pspace_data_cleanup): Likewise.
(ada_complete_symbol_matcher): Likewise.
(ada_exc_search_name_matches): Likewise.
* ada-tasks.c (get_ada_tasks_pspace_data): Likewise.
(get_ada_tasks_inferior_data): Likewise.
* addrmap.c (addrmap_mutable_foreach_worker): Likewise.
(splay_obstack_alloc): Likewise.
(splay_obstack_free): Likewise.
* alpha-linux-tdep.c (alpha_linux_supply_gregset): Likewise.
(alpha_linux_collect_gregset): Likewise.
(alpha_linux_supply_fpregset): Likewise.
(alpha_linux_collect_fpregset): Likewise.
* alpha-mdebug-tdep.c (alpha_mdebug_frame_unwind_cache): Likewise.
* alpha-tdep.c (alpha_lds): Likewise.
(alpha_sts): Likewise.
(alpha_sigtramp_frame_unwind_cache): Likewise.
(alpha_heuristic_frame_unwind_cache): Likewise.
(alpha_supply_int_regs): Likewise.
(alpha_fill_int_regs): Likewise.
(alpha_supply_fp_regs): Likewise.
(alpha_fill_fp_regs): Likewise.
* alphanbsd-tdep.c (alphanbsd_supply_fpregset): Likewise.
(alphanbsd_aout_supply_gregset): Likewise.
(alphanbsd_supply_gregset): Likewise.
* amd64-linux-tdep.c (amd64_linux_init_abi): Likewise.
(amd64_x32_linux_init_abi): Likewise.
* amd64-nat.c (amd64_supply_native_gregset): Likewise.
(amd64_collect_native_gregset): Likewise.
* amd64-tdep.c (amd64_frame_cache): Likewise.
(amd64_sigtramp_frame_cache): Likewise.
(amd64_epilogue_frame_cache): Likewise.
(amd64_supply_fxsave): Likewise.
(amd64_supply_xsave): Likewise.
(amd64_collect_fxsave): Likewise.
(amd64_collect_xsave): Likewise.
* amd64-windows-tdep.c (amd64_windows_frame_cache): Likewise.
* amd64obsd-tdep.c (amd64obsd_trapframe_cache): Likewise.
* arm-linux-tdep.c (arm_linux_supply_gregset): Likewise.
(arm_linux_collect_gregset): Likewise.
(arm_linux_supply_nwfpe): Likewise.
(arm_linux_collect_nwfpe): Likewise.
(arm_linux_supply_vfp): Likewise.
(arm_linux_collect_vfp): Likewise.
* arm-tdep.c (arm_find_mapping_symbol): Likewise.
(arm_prologue_unwind_stop_reason): Likewise.
(arm_prologue_this_id): Likewise.
(arm_prologue_prev_register): Likewise.
(arm_exidx_data_free): Likewise.
(arm_find_exidx_entry): Likewise.
(arm_stub_this_id): Likewise.
(arm_m_exception_this_id): Likewise.
(arm_m_exception_prev_register): Likewise.
(arm_normal_frame_base): Likewise.
(gdb_print_insn_arm): Likewise.
(arm_objfile_data_free): Likewise.
(arm_record_special_symbol): Likewise.
(value_of_arm_user_reg): Likewise.
* armbsd-tdep.c (armbsd_supply_fpregset): Likewise.
(armbsd_supply_gregset): Likewise.
* auto-load.c (auto_load_pspace_data_cleanup): Likewise.
(get_auto_load_pspace_data): Likewise.
(hash_loaded_script_entry): Likewise.
(eq_loaded_script_entry): Likewise.
(clear_section_scripts): Likewise.
(collect_matching_scripts): Likewise.
* auxv.c (auxv_inferior_data_cleanup): Likewise.
(get_auxv_inferior_data): Likewise.
* avr-tdep.c (avr_frame_unwind_cache): Likewise.
* ax-general.c (do_free_agent_expr_cleanup): Likewise.
* bfd-target.c (target_bfd_xfer_partial): Likewise.
(target_bfd_xclose): Likewise.
(target_bfd_get_section_table): Likewise.
* bfin-tdep.c (bfin_frame_cache): Likewise.
* block.c (find_block_in_blockvector): Likewise.
(call_site_for_pc): Likewise.
(block_find_non_opaque_type_preferred): Likewise.
* break-catch-sig.c (signal_catchpoint_insert_location): Likewise.
(signal_catchpoint_remove_location): Likewise.
(signal_catchpoint_breakpoint_hit): Likewise.
(signal_catchpoint_print_one): Likewise.
(signal_catchpoint_print_mention): Likewise.
(signal_catchpoint_print_recreate): Likewise.
* break-catch-syscall.c (get_catch_syscall_inferior_data): Likewise.
* breakpoint.c (do_cleanup_counted_command_line): Likewise.
(bp_location_compare_addrs): Likewise.
(get_first_locp_gte_addr): Likewise.
(check_tracepoint_command): Likewise.
(do_map_commands_command): Likewise.
(get_breakpoint_objfile_data): Likewise.
(free_breakpoint_probes): Likewise.
(do_captured_breakpoint_query): Likewise.
(compare_breakpoints): Likewise.
(bp_location_compare): Likewise.
(bpstat_remove_breakpoint_callback): Likewise.
(do_delete_breakpoint_cleanup): Likewise.
* bsd-uthread.c (bsd_uthread_set_supply_uthread): Likewise.
(bsd_uthread_set_collect_uthread): Likewise.
(bsd_uthread_activate): Likewise.
(bsd_uthread_fetch_registers): Likewise.
(bsd_uthread_store_registers): Likewise.
* btrace.c (check_xml_btrace_version): Likewise.
(parse_xml_btrace_block): Likewise.
(parse_xml_btrace_pt_config_cpu): Likewise.
(parse_xml_btrace_pt_raw): Likewise.
(parse_xml_btrace_pt): Likewise.
(parse_xml_btrace_conf_bts): Likewise.
(parse_xml_btrace_conf_pt): Likewise.
(do_btrace_data_cleanup): Likewise.
* c-typeprint.c (find_typedef_for_canonicalize): Likewise.
* charset.c (cleanup_iconv): Likewise.
(do_cleanup_iterator): Likewise.
* cli-out.c (cli_uiout_dtor): Likewise.
(cli_table_begin): Likewise.
(cli_table_body): Likewise.
(cli_table_end): Likewise.
(cli_table_header): Likewise.
(cli_begin): Likewise.
(cli_end): Likewise.
(cli_field_int): Likewise.
(cli_field_skip): Likewise.
(cli_field_string): Likewise.
(cli_field_fmt): Likewise.
(cli_spaces): Likewise.
(cli_text): Likewise.
(cli_message): Likewise.
(cli_wrap_hint): Likewise.
(cli_flush): Likewise.
(cli_redirect): Likewise.
(out_field_fmt): Likewise.
(field_separator): Likewise.
(cli_out_set_stream): Likewise.
* cli/cli-cmds.c (compare_symtabs): Likewise.
* cli/cli-dump.c (call_dump_func): Likewise.
(restore_section_callback): Likewise.
* cli/cli-script.c (clear_hook_in_cleanup): Likewise.
(do_restore_user_call_depth): Likewise.
(do_free_command_lines_cleanup): Likewise.
* coff-pe-read.c (get_section_vmas): Likewise.
(pe_as16): Likewise.
(pe_as32): Likewise.
* coffread.c (coff_symfile_read): Likewise.
* common/agent.c (agent_look_up_symbols): Likewise.
* common/filestuff.c (do_close_cleanup): Likewise.
* common/format.c (free_format_pieces_cleanup): Likewise.
* common/vec.c (vec_o_reserve): Likewise.
* compile/compile-c-support.c (print_one_macro): Likewise.
* compile/compile-c-symbols.c (hash_symbol_error): Likewise.
(eq_symbol_error): Likewise.
(del_symbol_error): Likewise.
(error_symbol_once): Likewise.
(gcc_convert_symbol): Likewise.
(gcc_symbol_address): Likewise.
(hash_symname): Likewise.
(eq_symname): Likewise.
* compile/compile-c-types.c (hash_type_map_instance): Likewise.
(eq_type_map_instance): Likewise.
(insert_type): Likewise.
(convert_type): Likewise.
* compile/compile-object-load.c (munmap_listp_free_cleanup): Likewise.
(setup_sections): Likewise.
(link_hash_table_free): Likewise.
(copy_sections): Likewise.
* compile/compile-object-run.c (do_module_cleanup): Likewise.
* compile/compile.c (compile_print_value): Likewise.
(do_rmdir): Likewise.
(cleanup_compile_instance): Likewise.
(cleanup_unlink_file): Likewise.
* completer.c (free_completion_tracker): Likewise.
* corelow.c (add_to_spuid_list): Likewise.
* cp-namespace.c (reset_directive_searched): Likewise.
* cp-support.c (reset_directive_searched): Likewise.
* cris-tdep.c (cris_sigtramp_frame_unwind_cache): Likewise.
(cris_frame_unwind_cache): Likewise.
* d-lang.c (builtin_d_type): Likewise.
* d-namespace.c (reset_directive_searched): Likewise.
* dbxread.c (dbx_free_symfile_info): Likewise.
(do_free_bincl_list_cleanup): Likewise.
* disasm.c (hash_dis_line_entry): Likewise.
(eq_dis_line_entry): Likewise.
(dis_asm_print_address): Likewise.
(fprintf_disasm): Likewise.
(do_ui_file_delete): Likewise.
* doublest.c (convert_floatformat_to_doublest): Likewise.
* dummy-frame.c (pop_dummy_frame_bpt): Likewise.
(dummy_frame_prev_register): Likewise.
(dummy_frame_this_id): Likewise.
* dwarf2-frame-tailcall.c (cache_hash): Likewise.
(cache_eq): Likewise.
(cache_find): Likewise.
(tailcall_frame_this_id): Likewise.
(dwarf2_tailcall_prev_register_first): Likewise.
(tailcall_frame_prev_register): Likewise.
(tailcall_frame_dealloc_cache): Likewise.
(tailcall_frame_prev_arch): Likewise.
* dwarf2-frame.c (dwarf2_frame_state_free): Likewise.
(dwarf2_frame_set_init_reg): Likewise.
(dwarf2_frame_init_reg): Likewise.
(dwarf2_frame_set_signal_frame_p): Likewise.
(dwarf2_frame_signal_frame_p): Likewise.
(dwarf2_frame_set_adjust_regnum): Likewise.
(dwarf2_frame_adjust_regnum): Likewise.
(clear_pointer_cleanup): Likewise.
(dwarf2_frame_cache): Likewise.
(find_cie): Likewise.
(dwarf2_frame_find_fde): Likewise.
* dwarf2expr.c (dwarf_expr_address_type): Likewise.
(free_dwarf_expr_context_cleanup): Likewise.
* dwarf2loc.c (locexpr_find_frame_base_location): Likewise.
(locexpr_get_frame_base): Likewise.
(loclist_find_frame_base_location): Likewise.
(loclist_get_frame_base): Likewise.
(dwarf_expr_dwarf_call): Likewise.
(dwarf_expr_get_base_type): Likewise.
(dwarf_expr_push_dwarf_reg_entry_value): Likewise.
(dwarf_expr_get_obj_addr): Likewise.
(entry_data_value_coerce_ref): Likewise.
(entry_data_value_copy_closure): Likewise.
(entry_data_value_free_closure): Likewise.
(get_frame_address_in_block_wrapper): Likewise.
(dwarf2_evaluate_property): Likewise.
(dwarf2_compile_property_to_c): Likewise.
(needs_frame_read_addr_from_reg): Likewise.
(needs_frame_get_reg_value): Likewise.
(needs_frame_frame_base): Likewise.
(needs_frame_frame_cfa): Likewise.
(needs_frame_tls_address): Likewise.
(needs_frame_dwarf_call): Likewise.
(needs_dwarf_reg_entry_value): Likewise.
(get_ax_pc): Likewise.
(locexpr_read_variable): Likewise.
(locexpr_read_variable_at_entry): Likewise.
(locexpr_read_needs_frame): Likewise.
(locexpr_describe_location): Likewise.
(locexpr_tracepoint_var_ref): Likewise.
(locexpr_generate_c_location): Likewise.
(loclist_read_variable): Likewise.
(loclist_read_variable_at_entry): Likewise.
(loclist_describe_location): Likewise.
(loclist_tracepoint_var_ref): Likewise.
(loclist_generate_c_location): Likewise.
* dwarf2read.c (line_header_hash_voidp): Likewise.
(line_header_eq_voidp): Likewise.
(dwarf2_has_info): Likewise.
(dwarf2_get_section_info): Likewise.
(locate_dwz_sections): Likewise.
(hash_file_name_entry): Likewise.
(eq_file_name_entry): Likewise.
(delete_file_name_entry): Likewise.
(dw2_setup): Likewise.
(dw2_get_file_names_reader): Likewise.
(dw2_find_pc_sect_compunit_symtab): Likewise.
(hash_signatured_type): Likewise.
(eq_signatured_type): Likewise.
(add_signatured_type_cu_to_table): Likewise.
(create_debug_types_hash_table): Likewise.
(lookup_dwo_signatured_type): Likewise.
(lookup_dwp_signatured_type): Likewise.
(lookup_signatured_type): Likewise.
(hash_type_unit_group): Likewise.
(eq_type_unit_group): Likewise.
(get_type_unit_group): Likewise.
(process_psymtab_comp_unit_reader): Likewise.
(sort_tu_by_abbrev_offset): Likewise.
(process_skeletonless_type_unit): Likewise.
(psymtabs_addrmap_cleanup): Likewise.
(dwarf2_read_symtab): Likewise.
(psymtab_to_symtab_1): Likewise.
(die_hash): Likewise.
(die_eq): Likewise.
(load_full_comp_unit_reader): Likewise.
(reset_die_in_process): Likewise.
(free_cu_line_header): Likewise.
(handle_DW_AT_stmt_list): Likewise.
(hash_dwo_file): Likewise.
(eq_dwo_file): Likewise.
(hash_dwo_unit): Likewise.
(eq_dwo_unit): Likewise.
(create_dwo_cu_reader): Likewise.
(create_dwo_unit_in_dwp_v1): Likewise.
(create_dwo_unit_in_dwp_v2): Likewise.
(lookup_dwo_unit_in_dwp): Likewise.
(dwarf2_locate_dwo_sections): Likewise.
(dwarf2_locate_common_dwp_sections): Likewise.
(dwarf2_locate_v2_dwp_sections): Likewise.
(hash_dwp_loaded_cutus): Likewise.
(eq_dwp_loaded_cutus): Likewise.
(lookup_dwo_cutu): Likewise.
(abbrev_table_free_cleanup): Likewise.
(dwarf2_free_abbrev_table): Likewise.
(find_partial_die_in_comp_unit): Likewise.
(free_line_header_voidp): Likewise.
(follow_die_offset): Likewise.
(follow_die_sig_1): Likewise.
(free_heap_comp_unit): Likewise.
(free_stack_comp_unit): Likewise.
(dwarf2_free_objfile): Likewise.
(per_cu_offset_and_type_hash): Likewise.
(per_cu_offset_and_type_eq): Likewise.
(get_die_type_at_offset): Likewise.
(partial_die_hash): Likewise.
(partial_die_eq): Likewise.
(dwarf2_per_objfile_free): Likewise.
(hash_strtab_entry): Likewise.
(eq_strtab_entry): Likewise.
(add_string): Likewise.
(hash_symtab_entry): Likewise.
(eq_symtab_entry): Likewise.
(delete_symtab_entry): Likewise.
(cleanup_mapped_symtab): Likewise.
(add_indices_to_cpool): Likewise.
(hash_psymtab_cu_index): Likewise.
(eq_psymtab_cu_index): Likewise.
(add_address_entry_worker): Likewise.
(unlink_if_set): Likewise.
(write_one_signatured_type): Likewise.
(save_gdb_index_command): Likewise.
* elfread.c (elf_symtab_read): Likewise.
(elf_gnu_ifunc_cache_hash): Likewise.
(elf_gnu_ifunc_cache_eq): Likewise.
(elf_gnu_ifunc_record_cache): Likewise.
(elf_gnu_ifunc_resolve_by_cache): Likewise.
(elf_get_probes): Likewise.
(probe_key_free): Likewise.
* f-lang.c (builtin_f_type): Likewise.
* frame-base.c (frame_base_append_sniffer): Likewise.
(frame_base_set_default): Likewise.
(frame_base_find_by_frame): Likewise.
* frame-unwind.c (frame_unwind_prepend_unwinder): Likewise.
(frame_unwind_append_unwinder): Likewise.
(frame_unwind_find_by_frame): Likewise.
* frame.c (frame_addr_hash): Likewise.
(frame_addr_hash_eq): Likewise.
(frame_stash_find): Likewise.
(do_frame_register_read): Likewise.
(unwind_to_current_frame): Likewise.
(frame_cleanup_after_sniffer): Likewise.
* frv-linux-tdep.c (frv_linux_sigtramp_frame_cache): Likewise.
* frv-tdep.c (frv_frame_unwind_cache): Likewise.
* ft32-tdep.c (ft32_frame_cache): Likewise.
* gcore.c (do_bfd_delete_cleanup): Likewise.
(gcore_create_callback): Likewise.
* gdb_bfd.c (hash_bfd): Likewise.
(eq_bfd): Likewise.
(gdb_bfd_open): Likewise.
(free_one_bfd_section): Likewise.
(gdb_bfd_ref): Likewise.
(gdb_bfd_unref): Likewise.
(get_section_descriptor): Likewise.
(gdb_bfd_map_section): Likewise.
(gdb_bfd_crc): Likewise.
(gdb_bfd_mark_parent): Likewise.
(gdb_bfd_record_inclusion): Likewise.
(gdb_bfd_requires_relocations): Likewise.
(print_one_bfd): Likewise.
* gdbtypes.c (type_pair_hash): Likewise.
(type_pair_eq): Likewise.
(builtin_type): Likewise.
(objfile_type): Likewise.
* gnu-v3-abi.c (vtable_ptrdiff_type): Likewise.
(vtable_address_point_offset): Likewise.
(gnuv3_get_vtable): Likewise.
(hash_value_and_voffset): Likewise.
(eq_value_and_voffset): Likewise.
(compare_value_and_voffset): Likewise.
(compute_vtable_size): Likewise.
(gnuv3_get_typeid_type): Likewise.
* go-lang.c (builtin_go_type): Likewise.
* guile/scm-block.c (bkscm_hash_block_smob): Likewise.
(bkscm_eq_block_smob): Likewise.
(bkscm_objfile_block_map): Likewise.
(bkscm_del_objfile_blocks): Likewise.
* guile/scm-breakpoint.c (bpscm_build_bp_list): Likewise.
* guile/scm-disasm.c (gdbscm_disasm_read_memory_worker): Likewise.
(gdbscm_disasm_print_address): Likewise.
* guile/scm-frame.c (frscm_hash_frame_smob): Likewise.
(frscm_eq_frame_smob): Likewise.
(frscm_inferior_frame_map): Likewise.
(frscm_del_inferior_frames): Likewise.
* guile/scm-gsmob.c (gdbscm_add_objfile_ref): Likewise.
* guile/scm-objfile.c (ofscm_handle_objfile_deleted): Likewise.
(ofscm_objfile_smob_from_objfile): Likewise.
* guile/scm-ports.c (ioscm_write): Likewise.
(ioscm_file_port_delete): Likewise.
(ioscm_file_port_rewind): Likewise.
(ioscm_file_port_put): Likewise.
(ioscm_file_port_write): Likewise.
* guile/scm-progspace.c (psscm_handle_pspace_deleted): Likewise.
(psscm_pspace_smob_from_pspace): Likewise.
* guile/scm-safe-call.c (scscm_recording_pre_unwind_handler): Likewise.
(scscm_recording_unwind_handler): Likewise.
(gdbscm_with_catch): Likewise.
(scscm_call_0_body): Likewise.
(scscm_call_1_body): Likewise.
(scscm_call_2_body): Likewise.
(scscm_call_3_body): Likewise.
(scscm_call_4_body): Likewise.
(scscm_apply_1_body): Likewise.
(scscm_eval_scheme_string): Likewise.
(gdbscm_safe_eval_string): Likewise.
(scscm_source_scheme_script): Likewise.
(gdbscm_safe_source_script): Likewise.
* guile/scm-string.c (gdbscm_call_scm_to_stringn): Likewise.
(gdbscm_call_scm_from_stringn): Likewise.
* guile/scm-symbol.c (syscm_hash_symbol_smob): Likewise.
(syscm_eq_symbol_smob): Likewise.
(syscm_get_symbol_map): Likewise.
(syscm_del_objfile_symbols): Likewise.
* guile/scm-symtab.c (stscm_hash_symtab_smob): Likewise.
(stscm_eq_symtab_smob): Likewise.
(stscm_objfile_symtab_map): Likewise.
(stscm_del_objfile_symtabs): Likewise.
* guile/scm-type.c (tyscm_hash_type_smob): Likewise.
(tyscm_eq_type_smob): Likewise.
(tyscm_type_map): Likewise.
(tyscm_copy_type_recursive): Likewise.
(save_objfile_types): Likewise.
* guile/scm-utils.c (extract_arg): Likewise.
* h8300-tdep.c (h8300_frame_cache): Likewise.
* hppa-linux-tdep.c (hppa_linux_sigtramp_frame_unwind_cache): Likewise.
* hppa-tdep.c (compare_unwind_entries): Likewise.
(find_unwind_entry): Likewise.
(hppa_frame_cache): Likewise.
(hppa_stub_frame_unwind_cache): Likewise.
* hppanbsd-tdep.c (hppanbsd_supply_gregset): Likewise.
* hppaobsd-tdep.c (hppaobsd_supply_gregset): Likewise.
(hppaobsd_supply_fpregset): Likewise.
* i386-cygwin-tdep.c (core_process_module_section): Likewise.
* i386-linux-tdep.c (i386_linux_init_abi): Likewise.
* i386-tdep.c (i386_frame_cache): Likewise.
(i386_epilogue_frame_cache): Likewise.
(i386_sigtramp_frame_cache): Likewise.
(i386_supply_gregset): Likewise.
(i386_collect_gregset): Likewise.
(i386_gdbarch_init): Likewise.
* i386obsd-tdep.c (i386obsd_aout_supply_regset): Likewise.
(i386obsd_trapframe_cache): Likewise.
* i387-tdep.c (i387_supply_fsave): Likewise.
(i387_collect_fsave): Likewise.
(i387_supply_fxsave): Likewise.
(i387_collect_fxsave): Likewise.
(i387_supply_xsave): Likewise.
(i387_collect_xsave): Likewise.
* ia64-tdep.c (ia64_frame_cache): Likewise.
(ia64_sigtramp_frame_cache): Likewise.
* infcmd.c (attach_command_continuation): Likewise.
(attach_command_continuation_free_args): Likewise.
* inferior.c (restore_inferior): Likewise.
(delete_thread_of_inferior): Likewise.
* inflow.c (inflow_inferior_data_cleanup): Likewise.
(get_inflow_inferior_data): Likewise.
(inflow_inferior_exit): Likewise.
* infrun.c (displaced_step_clear_cleanup): Likewise.
(restore_current_uiout_cleanup): Likewise.
(release_stop_context_cleanup): Likewise.
(do_restore_infcall_suspend_state_cleanup): Likewise.
(do_restore_infcall_control_state_cleanup): Likewise.
(restore_inferior_ptid): Likewise.
* inline-frame.c (block_starting_point_at): Likewise.
* iq2000-tdep.c (iq2000_frame_cache): Likewise.
* jit.c (get_jit_objfile_data): Likewise.
(get_jit_program_space_data): Likewise.
(jit_object_close_impl): Likewise.
(jit_find_objf_with_entry_addr): Likewise.
(jit_breakpoint_deleted): Likewise.
(jit_unwind_reg_set_impl): Likewise.
(jit_unwind_reg_get_impl): Likewise.
(jit_dealloc_cache): Likewise.
(jit_frame_sniffer): Likewise.
(jit_frame_prev_register): Likewise.
(jit_prepend_unwinder): Likewise.
(jit_inferior_exit_hook): Likewise.
(free_objfile_data): Likewise.
* jv-lang.c (jv_per_objfile_free): Likewise.
(get_dynamics_objfile): Likewise.
(get_java_class_symtab): Likewise.
(builtin_java_type): Likewise.
* language.c (language_string_char_type): Likewise.
(language_bool_type): Likewise.
(language_lookup_primitive_type): Likewise.
(language_lookup_primitive_type_as_symbol): Likewise.
* linespec.c (hash_address_entry): Likewise.
(eq_address_entry): Likewise.
(iterate_inline_only): Likewise.
(iterate_name_matcher): Likewise.
(decode_line_2_compare_items): Likewise.
(collect_one_symbol): Likewise.
(compare_symbols): Likewise.
(compare_msymbols): Likewise.
(add_symtabs_to_list): Likewise.
(collect_symbols): Likewise.
(compare_msyms): Likewise.
(add_minsym): Likewise.
(cleanup_linespec_result): Likewise.
* linux-fork.c (inferior_call_waitpid_cleanup): Likewise.
* linux-nat.c (delete_lwp_cleanup): Likewise.
(count_events_callback): Likewise.
(select_event_lwp_callback): Likewise.
(resume_stopped_resumed_lwps): Likewise.
* linux-tdep.c (get_linux_gdbarch_data): Likewise.
(invalidate_linux_cache_inf): Likewise.
(get_linux_inferior_data): Likewise.
(linux_find_memory_regions_thunk): Likewise.
(linux_make_mappings_callback): Likewise.
(linux_corefile_thread_callback): Likewise.
(find_mapping_size): Likewise.
* linux-thread-db.c (find_new_threads_callback): Likewise.
* lm32-tdep.c (lm32_frame_cache): Likewise.
* m2-lang.c (builtin_m2_type): Likewise.
* m32c-tdep.c (m32c_analyze_frame_prologue): Likewise.
* m32r-linux-tdep.c (m32r_linux_sigtramp_frame_cache): Likewise.
(m32r_linux_supply_gregset): Likewise.
(m32r_linux_collect_gregset): Likewise.
* m32r-tdep.c (m32r_frame_unwind_cache): Likewise.
* m68hc11-tdep.c (m68hc11_frame_unwind_cache): Likewise.
* m68k-tdep.c (m68k_frame_cache): Likewise.
* m68kbsd-tdep.c (m68kbsd_supply_fpregset): Likewise.
(m68kbsd_supply_gregset): Likewise.
* m68klinux-tdep.c (m68k_linux_sigtramp_frame_cache): Likewise.
* m88k-tdep.c (m88k_frame_cache): Likewise.
(m88k_supply_gregset): Likewise.
gdb/gdbserver/ChangeLog:
* dll.c (match_dll): Add cast(s).
(unloaded_dll): Likewise.
* linux-low.c (second_thread_of_pid_p): Likewise.
(delete_lwp_callback): Likewise.
(count_events_callback): Likewise.
(select_event_lwp_callback): Likewise.
(linux_set_resume_request): Likewise.
* server.c (accumulate_file_name_length): Likewise.
(emit_dll_description): Likewise.
(handle_qxfer_threads_worker): Likewise.
(visit_actioned_threads): Likewise.
* thread-db.c (any_thread_of): Likewise.
* tracepoint.c (same_process_p): Likewise.
(match_blocktype): Likewise.
(build_traceframe_info_xml): Likewise.
gdb/testsuite/ChangeLog:
* gdb.gdb/selftest.exp (do_steps_and_nexts): Adjust expected
source line.
2015-09-26 02:08:07 +08:00
|
|
|
struct using_direct *direct = (struct using_direct *) data;
|
2015-08-14 02:34:15 +08:00
|
|
|
direct->searched = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search for NAME by applying all import statements belonging to
|
|
|
|
BLOCK which are applicable in SCOPE.
|
|
|
|
|
|
|
|
If SEARCH_PARENTS the search will include imports which are
|
|
|
|
applicable in parents of SCOPE.
|
|
|
|
Example:
|
|
|
|
|
|
|
|
module A;
|
|
|
|
import X;
|
|
|
|
void B() {
|
|
|
|
import Y;
|
|
|
|
}
|
|
|
|
|
|
|
|
If SCOPE is "A.B" and SEARCH_PARENTS is true, the imports of
|
|
|
|
modules X and Y will be considered. If SEARCH_PARENTS is false
|
|
|
|
only the import of Y is considered. */
|
|
|
|
|
|
|
|
static struct block_symbol
|
|
|
|
d_lookup_symbol_imports (const char *scope, const char *name,
|
|
|
|
const struct block *block,
|
|
|
|
const domain_enum domain,
|
|
|
|
const int search_parents)
|
|
|
|
{
|
|
|
|
struct using_direct *current;
|
|
|
|
struct block_symbol sym;
|
|
|
|
int directive_match;
|
|
|
|
struct cleanup *searched_cleanup;
|
|
|
|
|
|
|
|
/* First, try to find the symbol in the given module. */
|
|
|
|
sym = d_lookup_symbol_in_module (scope, name, block, domain, 1);
|
|
|
|
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
/* Go through the using directives. If any of them add new names to
|
|
|
|
the module we're searching in, see if we can find a match by
|
|
|
|
applying them. */
|
|
|
|
|
|
|
|
for (current = block_using (block);
|
|
|
|
current != NULL;
|
|
|
|
current = current->next)
|
|
|
|
{
|
|
|
|
const char **excludep;
|
|
|
|
int len = strlen (current->import_dest);
|
|
|
|
|
|
|
|
directive_match = (search_parents
|
|
|
|
? (strncmp (scope, current->import_dest, len) == 0
|
|
|
|
&& (len == 0
|
|
|
|
|| scope[len] == '.'
|
|
|
|
|| scope[len] == '\0'))
|
|
|
|
: strcmp (scope, current->import_dest) == 0);
|
|
|
|
|
|
|
|
/* If the import destination is the current scope or one of its
|
|
|
|
ancestors then it is applicable. */
|
|
|
|
if (directive_match && !current->searched)
|
|
|
|
{
|
|
|
|
/* Mark this import as searched so that the recursive call
|
|
|
|
does not search it again. */
|
|
|
|
current->searched = 1;
|
|
|
|
searched_cleanup = make_cleanup (reset_directive_searched,
|
|
|
|
current);
|
|
|
|
|
|
|
|
/* If there is an import of a single declaration, compare the
|
|
|
|
imported declaration (after optional renaming by its alias)
|
|
|
|
with the sought out name. If there is a match pass
|
|
|
|
current->import_src as MODULE to direct the search towards
|
|
|
|
the imported module. */
|
|
|
|
if (current->declaration
|
|
|
|
&& strcmp (name, current->alias
|
|
|
|
? current->alias : current->declaration) == 0)
|
|
|
|
sym = d_lookup_symbol_in_module (current->import_src,
|
|
|
|
current->declaration,
|
|
|
|
block, domain, 1);
|
|
|
|
|
|
|
|
/* If a symbol was found or this import statement was an import
|
|
|
|
declaration, the search of this import is complete. */
|
|
|
|
if (sym.symbol != NULL || current->declaration)
|
|
|
|
{
|
|
|
|
current->searched = 0;
|
|
|
|
discard_cleanups (searched_cleanup);
|
|
|
|
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do not follow CURRENT if NAME matches its EXCLUDES. */
|
|
|
|
for (excludep = current->excludes; *excludep; excludep++)
|
|
|
|
if (strcmp (name, *excludep) == 0)
|
|
|
|
break;
|
|
|
|
if (*excludep)
|
|
|
|
{
|
|
|
|
discard_cleanups (searched_cleanup);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the import statement is creating an alias. */
|
|
|
|
if (current->alias != NULL)
|
|
|
|
{
|
|
|
|
if (strcmp (name, current->alias) == 0)
|
|
|
|
{
|
|
|
|
/* If the alias matches the sought name. Pass
|
|
|
|
current->import_src as the NAME to direct the
|
|
|
|
search towards the aliased module. */
|
2015-09-26 15:08:12 +08:00
|
|
|
sym = lookup_module_scope (NULL, current->import_src, block,
|
2015-08-14 02:34:15 +08:00
|
|
|
domain, scope, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* If the alias matches the first component of the
|
|
|
|
sought name, pass current->import_src as MODULE
|
|
|
|
to direct the search, skipping over the aliased
|
|
|
|
component in NAME. */
|
|
|
|
int name_scope = d_find_first_component (name);
|
|
|
|
|
|
|
|
if (name[name_scope] != '\0'
|
|
|
|
&& strncmp (name, current->alias, name_scope) == 0)
|
|
|
|
{
|
|
|
|
/* Skip the '.' */
|
|
|
|
name_scope++;
|
|
|
|
sym = d_lookup_symbol_imports (current->import_src,
|
|
|
|
name + name_scope,
|
|
|
|
block, domain, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* If this import statement creates no alias, pass
|
|
|
|
current->import_src as MODULE to direct the search
|
|
|
|
towards the imported module. */
|
|
|
|
sym = d_lookup_symbol_imports (current->import_src,
|
|
|
|
name, block, domain, 0);
|
|
|
|
}
|
|
|
|
current->searched = 0;
|
|
|
|
discard_cleanups (searched_cleanup);
|
|
|
|
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-17 21:12:23 +08:00
|
|
|
return null_block_symbol;
|
2015-08-14 02:34:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Searches for NAME in the current module, and by applying relevant
|
|
|
|
import statements belonging to BLOCK and its parents. SCOPE is the
|
|
|
|
module scope of the context in which the search is being evaluated. */
|
|
|
|
|
|
|
|
static struct block_symbol
|
|
|
|
d_lookup_symbol_module (const char *scope, const char *name,
|
|
|
|
const struct block *block,
|
|
|
|
const domain_enum domain)
|
|
|
|
{
|
|
|
|
struct block_symbol sym;
|
|
|
|
|
|
|
|
/* First, try to find the symbol in the given module. */
|
|
|
|
sym = d_lookup_symbol_in_module (scope, name,
|
|
|
|
block, domain, 1);
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
/* Search for name in modules imported to this and parent
|
|
|
|
blocks. */
|
|
|
|
while (block != NULL)
|
|
|
|
{
|
|
|
|
sym = d_lookup_symbol_imports (scope, name, block, domain, 1);
|
|
|
|
|
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
block = BLOCK_SUPERBLOCK (block);
|
|
|
|
}
|
|
|
|
|
2015-11-17 21:12:23 +08:00
|
|
|
return null_block_symbol;
|
2015-08-14 02:34:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The D-specific version of name lookup for static and global names
|
|
|
|
This makes sure that names get looked for in all modules that are
|
|
|
|
in scope. NAME is the natural name of the symbol that we're looking
|
|
|
|
looking for, BLOCK is the block that we're searching within, DOMAIN
|
|
|
|
says what kind of symbols we're looking for, and if SYMTAB is non-NULL,
|
|
|
|
we should store the symtab where we found the symbol in it. */
|
|
|
|
|
|
|
|
struct block_symbol
|
|
|
|
d_lookup_symbol_nonlocal (const struct language_defn *langdef,
|
|
|
|
const char *name,
|
|
|
|
const struct block *block,
|
|
|
|
const domain_enum domain)
|
|
|
|
{
|
|
|
|
struct block_symbol sym;
|
|
|
|
const char *scope = block_scope (block);
|
|
|
|
|
2015-09-26 15:08:12 +08:00
|
|
|
sym = lookup_module_scope (langdef, name, block, domain, scope, 0);
|
2015-08-14 02:34:15 +08:00
|
|
|
if (sym.symbol != NULL)
|
|
|
|
return sym;
|
|
|
|
|
|
|
|
return d_lookup_symbol_module (scope, name, block, domain);
|
|
|
|
}
|
|
|
|
|