Merge GDB 7.5.1

gdb/symtab.c

 /* Symbol table lookup for the GNU debugger, GDB.
 
    Copyright (C) 1986-2004, 2007-2012 Free Software Foundation, Inc.
 
    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.
@@ skipping 15 matching lines @@
 #include "value.h"
 #include "symfile.h"
 #include "objfiles.h"
 #include "gdbcmd.h"
 #include "call-cmds.h"
 #include "gdb_regex.h"
 #include "expression.h"
 #include "language.h"
 #include "demangle.h"
 #include "inferior.h"
-#include "linespec.h"
 #include "source.h"
 #include "filenames.h"          /* for FILENAME_CMP */
 #include "objc-lang.h"
 #include "d-lang.h"
 #include "ada-lang.h"
+#include "go-lang.h"
 #include "p-lang.h"
 #include "addrmap.h"
 
 #include "hashtab.h"
 
 #include "gdb_obstack.h"
 #include "block.h"
 #include "dictionary.h"
 
 #include <sys/types.h>
 #include <fcntl.h>
 #include "gdb_string.h"
 #include "gdb_stat.h"
 #include <ctype.h>
 #include "cp-abi.h"
 #include "cp-support.h"
 #include "observer.h"
 #include "gdb_assert.h"
 #include "solist.h"
 #include "macrotab.h"
 #include "macroscope.h"
 
 #include "psymtab.h"
 
 /* Prototypes for local functions */
 
-static void completion_list_add_name (char *, char *, int, char *, char *);
-
 static void rbreak_command (char *, int);
 
 static void types_info (char *, int);
 
 static void functions_info (char *, int);
 
 static void variables_info (char *, int);
 
 static void sources_info (char *, int);
 
-static void output_source_filename (const char *, int *);
-
 static int find_line_common (struct linetable *, int, int *, int);
 
 static struct symbol *lookup_symbol_aux (const char *name,
                                          const struct block *block,
                                          const domain_enum domain,
                                          enum language language,
                                          int *is_a_field_of_this);
 
 static
 struct symbol *lookup_symbol_aux_local (const char *name,
@@ skipping 11 matching lines @@
                                         int block_index,
                                         const char *name,
                                         const domain_enum domain);
 
 static void print_msymbol_info (struct minimal_symbol *);
 
 void _initialize_symtab (void);
 
 /* */
 
+/* When non-zero, print debugging messages related to symtab creation.  */
+int symtab_create_debug = 0;
+
 /* Non-zero if a file may be known by two different basenames.
    This is the uncommon case, and significantly slows down gdb.
    Default set to "off" to not slow down the common case.  */
 int basenames_may_differ = 0;
 
 /* Allow the user to configure the debugger behavior with respect
    to multiple-choice menus when more than one symbol matches during
    a symbol lookup.  */
 
 const char multiple_symbols_ask[] = "ask";
 const char multiple_symbols_all[] = "all";
 const char multiple_symbols_cancel[] = "cancel";
-static const char *multiple_symbols_modes[] =
+static const char *const multiple_symbols_modes[] =
 {
   multiple_symbols_ask,
   multiple_symbols_all,
   multiple_symbols_cancel,
   NULL
 };
 static const char *multiple_symbols_mode = multiple_symbols_all;
 
 /* Read-only accessor to AUTO_SELECT_MODE.  */
 
 const char *
 multiple_symbols_select_mode (void)
 {
   return multiple_symbols_mode;
 }
 
 /* Block in which the most recently searched-for symbol was found.
    Might be better to make this a parameter to lookup_symbol and
    value_of_this.  */
 
 const struct block *block_found;
 
+/* See whether FILENAME matches SEARCH_NAME using the rule that we
+   advertise to the user.  (The manual's description of linespecs
+   describes what we advertise).  SEARCH_LEN is the length of
+   SEARCH_NAME.  We assume that SEARCH_NAME is a relative path.
+   Returns true if they match, false otherwise.  */
+
+int
+compare_filenames_for_search (const char *filename, const char *search_name,
+                              int search_len)
+{
+  int len = strlen (filename);
+
+  if (len < search_len)
+    return 0;
+
+  /* The tail of FILENAME must match.  */
+  if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
+    return 0;
+
+  /* Either the names must completely match, or the character
+     preceding the trailing SEARCH_NAME segment of FILENAME must be a
+     directory separator.  */
+  return (len == search_len
+          || IS_DIR_SEPARATOR (filename[len - search_len - 1])
+          || (HAS_DRIVE_SPEC (filename)
+              && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
+}
+
 /* Check for a symtab of a specific name by searching some symtabs.
    This is a helper function for callbacks of iterate_over_symtabs.
 
    The return value, NAME, FULL_PATH, REAL_PATH, CALLBACK, and DATA
    are identical to the `map_symtabs_matching_filename' method of
    quick_symbol_functions.
 
    FIRST and AFTER_LAST indicate the range of symtabs to search.
    AFTER_LAST is one past the last symtab to search; NULL means to
    search until the end of the list.  */
 
 int
 iterate_over_some_symtabs (const char *name,
                            const char *full_path,
                            const char *real_path,
                            int (*callback) (struct symtab *symtab,
                                             void *data),
                            void *data,
                            struct symtab *first,
                            struct symtab *after_last)
 {
   struct symtab *s = NULL;
-  struct cleanup *cleanup;
   const char* base_name = lbasename (name);
+  int name_len = strlen (name);
+  int is_abs = IS_ABSOLUTE_PATH (name);
 
   for (s = first; s != NULL && s != after_last; s = s->next)
     {
+      /* Exact match is always ok.  */
       if (FILENAME_CMP (name, s->filename) == 0)
         {
           if (callback (s, data))
             return 1;
         }
 
+      if (!is_abs && compare_filenames_for_search (s->filename, name, name_len))
+        {
+          if (callback (s, data))
+            return 1;
+        }
+
     /* Before we invoke realpath, which can get expensive when many
        files are involved, do a quick comparison of the basenames.  */
     if (! basenames_may_differ
         && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
       continue;
 
     /* If the user gave us an absolute path, try to find the file in
        this symtab and use its absolute path.  */
 
     if (full_path != NULL)
       {
         const char *fp = symtab_to_fullname (s);
 
         if (fp != NULL && FILENAME_CMP (full_path, fp) == 0)
           {
             if (callback (s, data))
               return 1;
           }
+
+        if (fp != NULL && !is_abs && compare_filenames_for_search (fp, name,
+                                                                   name_len))
+          {
+            if (callback (s, data))
+              return 1;
+          }
       }
 
     if (real_path != NULL)
       {
         char *fullname = symtab_to_fullname (s);
 
         if (fullname != NULL)
           {
             char *rp = gdb_realpath (fullname);
 
             make_cleanup (xfree, rp);
             if (FILENAME_CMP (real_path, rp) == 0)
               {
                 if (callback (s, data))
                   return 1;
               }
+
+            if (!is_abs && compare_filenames_for_search (rp, name, name_len))
+              {
+                if (callback (s, data))
+                  return 1;
+              }
           }
       }
     }
 
-  /* Now, search for a matching tail (only if name doesn't have any dirs).  */
-
-  if (lbasename (name) == name)
-    {
-      for (s = first; s != NULL && s != after_last; s = s->next)
-        {
-          if (FILENAME_CMP (lbasename (s->filename), name) == 0)
-            {
-              if (callback (s, data))
-                return 1;
-            }
-        }
-    }
-
   return 0;
 }
 
 /* Check for a symtab of a specific name; first in symtabs, then in
    psymtabs.  *If* there is no '/' in the name, a match after a '/'
    in the symtab filename will also work.
 
    Calls CALLBACK with each symtab that is found and with the supplied
    DATA.  If CALLBACK returns true, the search stops.  */
 
@@ skipping 76 matching lines @@
 
 
 /* Mangle a GDB method stub type.  This actually reassembles the pieces of the
    full method name, which consist of the class name (from T), the unadorned
    method name from METHOD_ID, and the signature for the specific overload,
    specified by SIGNATURE_ID.  Note that this function is g++ specific.  */
 
 char *
 gdb_mangle_name (struct type *type, int method_id, int signature_id)
 {