Remove some unused variables

[deliverable/binutils-gdb.git] / gdb / symtab.c

diff --git a/gdb/symtab.c b/gdb/symtab.c
index eb4e30d4556371553fb2ec4e034572e99750e0b0..996d52199fcc8367ca74c70a3fdffdf7aea8bd7b 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -729,7 +729,6 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
 {
   char *demangled = NULL;
   int i;
-  int recognized;
 
   if (gsymbol->language == language_unknown)
     gsymbol->language = language_auto;
@@ -2964,6 +2963,45 @@ find_pc_compunit_symtab (CORE_ADDR pc)
 {
   return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc));
 }
+
+/* See symtab.h.  */
+
+struct symbol *
+find_symbol_at_address (CORE_ADDR address)
+{
+  struct objfile *objfile;
+
+  ALL_OBJFILES (objfile)
+  {
+    if (objfile->sf == NULL
+       || objfile->sf->qf->find_compunit_symtab_by_address == NULL)
+      continue;
+
+    struct compunit_symtab *symtab
+      = objfile->sf->qf->find_compunit_symtab_by_address (objfile, address);
+    if (symtab != NULL)
+      {
+       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (symtab);
+
+       for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
+         {
+           struct block *b = BLOCKVECTOR_BLOCK (bv, i);
+           struct block_iterator iter;
+           struct symbol *sym;
+
+           ALL_BLOCK_SYMBOLS (b, iter, sym)
+           {
+             if (SYMBOL_CLASS (sym) == LOC_STATIC
+                 && SYMBOL_VALUE_ADDRESS (sym) == address)
+               return sym;
+           }
+         }
+      }
+  }
+
+  return NULL;
+}
+
 \f
 
 /* Find the source file and line number for a given PC value and SECTION.
@@ -3888,14 +3926,14 @@ skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
 symbol *
 find_function_alias_target (bound_minimal_symbol msymbol)
 {
-  if (!msymbol_is_text (msymbol.minsym))
+  CORE_ADDR func_addr;
+  if (!msymbol_is_function (msymbol.objfile, msymbol.minsym, &func_addr))
     return NULL;
 
-  CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
-  symbol *sym = find_pc_function (addr);
+  symbol *sym = find_pc_function (func_addr);
   if (sym != NULL
       && SYMBOL_CLASS (sym) == LOC_BLOCK
-      && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == addr)
+      && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == func_addr)
     return sym;
 
   return NULL;
@@ -4244,7 +4282,6 @@ search_symbols (const char *regexp, enum search_domain kind,
          and <TYPENAME> or <OPERATOR>.  */
       const char *opend;
       const char *opname = operator_chars (regexp, &opend);
-      int errcode;
 
       if (*opname)
        {
@@ -4659,7 +4696,7 @@ compare_symbol_name (const char *symbol_name, language symbol_language,
   symbol_name_matcher_ftype *name_match
     = language_get_symbol_name_matcher (lang, lookup_name);
 
-  return name_match (symbol_name, lookup_name, &match_res.match);
+  return name_match (symbol_name, lookup_name, &match_res);
 }
 
 /*  See symtab.h.  */
@@ -4712,7 +4749,14 @@ completion_list_add_name (completion_tracker &tracker,
 
     gdb::unique_xmalloc_ptr<char> completion (newobj);
 
-    tracker.add_completion (std::move (completion));
+    /* Here we pass the match-for-lcd object to add_completion.  Some
+       languages match the user text against substrings of symbol
+       names in some cases.  E.g., in C++, "b push_ba" completes to
+       "std::vector::push_back", "std::string::push_back", etc., and
+       in this case we want the completion lowest common denominator
+       to be "push_back" instead of "std::".  */
+    tracker.add_completion (std::move (completion),
+                           &match_res.match_for_lcd);
   }
 }
 
@@ -4877,11 +4921,44 @@ completion_list_add_fields (completion_tracker &tracker,
     }
 }
 
+/* See symtab.h.  */
+
+bool
+symbol_is_function_or_method (symbol *sym)
+{
+  switch (TYPE_CODE (SYMBOL_TYPE (sym)))
+    {
+    case TYPE_CODE_FUNC:
+    case TYPE_CODE_METHOD:
+      return true;
+    default:
+      return false;
+    }
+}
+
+/* See symtab.h.  */
+
+bool
+symbol_is_function_or_method (minimal_symbol *msymbol)
+{
+  switch (MSYMBOL_TYPE (msymbol))
+    {
+    case mst_text:
+    case mst_text_gnu_ifunc:
+    case mst_solib_trampoline:
+    case mst_file_text:
+      return true;
+    default:
+      return false;
+    }
+}
+
 /* Add matching symbols from SYMTAB to the current completion list.  */
 
 static void
 add_symtab_completions (struct compunit_symtab *cust,
                        completion_tracker &tracker,
+                       complete_symbol_mode mode,
                        const lookup_name_info &lookup_name,
                        const char *text, const char *word,
                        enum type_code code)
@@ -4900,6 +4977,9 @@ add_symtab_completions (struct compunit_symtab *cust,
       b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), i);
       ALL_BLOCK_SYMBOLS (b, iter, sym)
        {
+         if (completion_skip_symbol (mode, sym))
+           continue;
+
          if (code == TYPE_CODE_UNDEF
              || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
                  && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
@@ -4998,6 +5078,9 @@ default_collect_symbol_completion_matches_break_on
        {
          QUIT;
 
+         if (completion_skip_symbol (mode, msymbol))
+           continue;
+
          completion_list_add_msymbol (tracker, msymbol, lookup_name,
                                       sym_text, word);
 
@@ -5008,7 +5091,7 @@ default_collect_symbol_completion_matches_break_on
 
   /* Add completions for all currently loaded symbol tables.  */
   ALL_COMPUNITS (objfile, cust)
-    add_symtab_completions (cust, tracker, lookup_name,
+    add_symtab_completions (cust, tracker, mode, lookup_name,
                            sym_text, word, code);
 
   /* Look through the partial symtabs for all symbols which begin by
@@ -5019,7 +5102,7 @@ default_collect_symbol_completion_matches_break_on
                           [&] (compunit_symtab *symtab) /* expansion notify */
                             {
                               add_symtab_completions (symtab,
-                                                      tracker, lookup_name,
+                                                      tracker, mode, lookup_name,
                                                       sym_text, word, code);
                             },
                           ALL_DOMAIN);
@@ -5225,7 +5308,7 @@ collect_file_symbol_completion_matches (completion_tracker &tracker,
   iterate_over_symtabs (srcfile, [&] (symtab *s)
     {
       add_symtab_completions (SYMTAB_COMPUNIT (s),
-                             tracker, lookup_name,
+                             tracker, mode, lookup_name,
                              sym_text, word, TYPE_CODE_UNDEF);
       return false;
     });
@@ -5722,7 +5805,7 @@ allocate_template_symbol (struct objfile *objfile)
   struct template_symbol *result;
 
   result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
-  initialize_objfile_symbol_1 (&result->base);
+  initialize_objfile_symbol_1 (result);
 
   return result;
 }