/* Helper routines for C++ support in GDB.
- Copyright (C) 2003-2004, 2007-2012 Free Software Foundation, Inc.
+ Copyright (C) 2003-2014 Free Software Foundation, Inc.
Contributed by David Carlton and by Kealia, Inc.
#include "gdb_obstack.h"
#include "symtab.h"
#include "symfile.h"
-#include "gdb_assert.h"
#include "block.h"
#include "objfiles.h"
#include "gdbtypes.h"
anonymous namespace. So add symbols in it to the
namespace given by the previous component if there is
one, or to the global namespace if there isn't. */
- cp_add_using_directive (dest, src, NULL, NULL, NULL,
+ cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
&objfile->objfile_obstack);
}
/* The "+ 2" is for the "::". */
in the current scope. If ALIAS is NULL then the namespace is known
by its original name. DECLARATION is the name if the imported
varable if this is a declaration import (Eg. using A::x), otherwise
- it is NULL. EXCLUDES is a list of names not to import from an imported
- module or NULL. The arguments are copied into newly allocated memory so
- they can be temporaries. For EXCLUDES the VEC pointers are copied but the
+ it is NULL. EXCLUDES is a list of names not to import from an
+ imported module or NULL. If COPY_NAMES is non-zero, then the
+ arguments are copied into newly allocated memory so they can be
+ temporaries. For EXCLUDES the VEC pointers are copied but the
pointed to characters are not copied. */
void
const char *alias,
const char *declaration,
VEC (const_char_ptr) *excludes,
+ int copy_names,
struct obstack *obstack)
{
struct using_direct *current;
* sizeof (*new->excludes))));
memset (new, 0, sizeof (*new));
- new->import_src = obsavestring (src, strlen (src), obstack);
- new->import_dest = obsavestring (dest, strlen (dest), obstack);
+ if (copy_names)
+ {
+ new->import_src = obstack_copy0 (obstack, src, strlen (src));
+ new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
+ }
+ else
+ {
+ new->import_src = src;
+ new->import_dest = dest;
+ }
- if (alias != NULL)
- new->alias = obsavestring (alias, strlen (alias), obstack);
+ if (alias != NULL && copy_names)
+ new->alias = obstack_copy0 (obstack, alias, strlen (alias));
+ else
+ new->alias = alias;
- if (declaration != NULL)
- new->declaration = obsavestring (declaration, strlen (declaration),
- obstack);
+ if (declaration != NULL && copy_names)
+ new->declaration = obstack_copy0 (obstack,
+ declaration, strlen (declaration));
+ else
+ new->declaration = declaration;
memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
using_directives = new;
}
-/* Record the namespace that the function defined by SYMBOL was
- defined in, if necessary. BLOCK is the associated block; use
- OBSTACK for allocation. */
-
-void
-cp_set_block_scope (const struct symbol *symbol,
- struct block *block,
- struct obstack *obstack,
- const char *processing_current_prefix,
- int processing_has_namespace_info)
-{
- if (processing_has_namespace_info)
- {
- block_set_scope
- (block, obsavestring (processing_current_prefix,
- strlen (processing_current_prefix),
- obstack),
- obstack);
- }
- else if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
- {
- /* Try to figure out the appropriate namespace from the
- demangled name. */
-
- /* FIXME: carlton/2003-04-15: If the function in question is
- a method of a class, the name will actually include the
- name of the class as well. This should be harmless, but
- is a little unfortunate. */
-
- const char *name = SYMBOL_DEMANGLED_NAME (symbol);
- unsigned int prefix_len = cp_entire_prefix_len (name);
-
- block_set_scope (block,
- obsavestring (name, prefix_len, obstack),
- obstack);
- }
-}
-
/* Test whether or not NAMESPACE looks like it mentions an anonymous
namespace; return nonzero if so. */
if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
{
- int i;
- struct cplus_specific *cps
- = function->ginfo.language_specific.cplus_specific;
-
/* Search the function's template parameters. */
if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
{
char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
struct cleanup *cleanups = make_cleanup (xfree, name_copy);
const struct language_defn *lang = language_def (language_cplus);
- struct gdbarch *arch = SYMBOL_SYMTAB (function)->objfile->gdbarch;
+ struct gdbarch *arch
+ = get_objfile_arch (SYMBOL_SYMTAB (function)->objfile);
const struct block *parent = BLOCK_SUPERBLOCK (block);
while (1)
TYPE_N_TEMPLATE_ARGUMENTS (context),
TYPE_TEMPLATE_ARGUMENTS (context));
if (result != NULL)
- return result;
+ {
+ do_cleanups (cleanups);
+ return result;
+ }
}
do_cleanups (cleanups);
}
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
+ /* If TYPE_NAME is NULL, abandon trying to find this symbol.
+ This can happen for lambda functions compiled with clang++,
+ which outputs no name for the container class. */
+ if (TYPE_NAME (type) == NULL)
+ return NULL;
klass = xstrdup (TYPE_NAME (type));
nested = xstrdup (name);
}
return sym;
}
+/* Search through the base classes of PARENT_TYPE for a base class
+ named NAME and return its type. If not found, return NULL. */
+
+struct type *
+find_type_baseclass_by_name (struct type *parent_type, const char *name)
+{
+ int i;
+
+ CHECK_TYPEDEF (parent_type);
+ for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
+ {
+ struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
+ const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
+
+ if (base_name == NULL)
+ continue;
+
+ if (streq (base_name, name))
+ return type;
+
+ type = find_type_baseclass_by_name (type, name);
+ if (type != NULL)
+ return type;
+ }
+
+ return NULL;
+}
+
/* Search through the base classes of PARENT_TYPE for a symbol named
NAME in block BLOCK. */
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 = cp_lookup_symbol_namespace (base_name, name, block, VAR_DOMAIN);
+ sym = cp_lookup_symbol_in_namespace (base_name, name, block,
+ VAR_DOMAIN, 0);
if (sym != 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) + 2 + strlen (name) + 1;
concatenated_name = xrealloc (concatenated_name, len);
xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
sym = lookup_symbol_static (concatenated_name, block, VAR_DOMAIN);
+ if (sym != NULL)
+ break;
- /* If there is currently no BLOCK, e.g., the inferior hasn't yet
- been started, then try searching all STATIC_BLOCK symbols in
- all objfiles. */
- if (block == NULL)
- {
- sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
- if (sym != 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_aux (concatenated_name, VAR_DOMAIN);
+ if (sym != NULL)
+ break;
/* If this class has base classes, search them next. */
- if (TYPE_N_BASECLASSES (TYPE_BASECLASS (parent_type, i)) > 0)
+ CHECK_TYPEDEF (base_type);
+ if (TYPE_N_BASECLASSES (base_type) > 0)
{
- sym = find_symbol_in_baseclass (TYPE_BASECLASS (parent_type, i),
- name, block);
+ sym = find_symbol_in_baseclass (base_type, name, block);
if (sym != NULL)
break;
}
case TYPE_CODE_STRUCT:
case TYPE_CODE_NAMESPACE:
case TYPE_CODE_UNION:
+ case TYPE_CODE_ENUM:
+ /* NOTE: Handle modules here as well, because Fortran is re-using the C++
+ specific code to lookup nested symbols in modules, by calling the
+ function pointer la_lookup_symbol_nonlocal, which ends up here. */
+ case TYPE_CODE_MODULE:
{
/* NOTE: carlton/2003-11-10: We don't treat C++ class members
of classes like, say, data or function members. Instead,
if (sym != NULL)
return sym;
- /* Now search all static file-level symbols. Not strictly
- correct, but more useful than an error. We do not try to
+ /* 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 namespace as even the fully specified
namespace search is already not C++ compliant and more
assumptions could make it too magic. */
base classes. */
return find_symbol_in_baseclass (parent_type, nested_name, block);
}
+
+ case TYPE_CODE_FUNC:
+ case TYPE_CODE_METHOD:
+ return NULL;
+
default:
internal_error (__FILE__, __LINE__,
_("cp_lookup_nested_symbol called "