inf-ptrace: Return an IGNORE event if waitpid() fails.

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

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 9357b5b11ed17ccfecf4f6883ab38fa190836c04..1a39372aad02be4c0cc8f19a9ef24ae04ab46095 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1229,7 +1229,7 @@ eq_symbol_entry (const struct symbol_cache_slot *slot,
   else
     {
       slot_name = slot->value.found.symbol->search_name ();
-      slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol);
+      slot_domain = slot->value.found.symbol->domain ();
     }
 
   /* NULL names match.  */
@@ -1582,7 +1582,7 @@ symbol_cache_dump (const struct symbol_cache *cache)
                printf_filtered ("  [%4u] = %s, %s %s\n", i,
                                 host_address_to_string (context),
                                 found->print_name (),
-                                domain_name (SYMBOL_DOMAIN (found)));
+                                domain_name (found->domain ()));
                break;
              }
            }
@@ -1789,7 +1789,7 @@ fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
   if (!sym)
     return NULL;
 
-  if (!SYMBOL_OBJFILE_OWNED (sym))
+  if (!sym->is_objfile_owned ())
     return sym;
 
   /* We either have an OBJFILE, or we can get at it from the sym's
@@ -2130,7 +2130,7 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
 
       if (result.symbol)
        {
-         struct type *t = result.symbol->type;
+         struct type *t = result.symbol->type ();
 
          /* I'm not really sure that type of this can ever
             be typedefed; just be safe.  */
@@ -2329,7 +2329,7 @@ lookup_symbol_in_objfile_symtabs (struct objfile *objfile,
          break;
        }
       if (symbol_matches_domain (result.symbol->language (),
-                                SYMBOL_DOMAIN (result.symbol), domain))
+                                result.symbol->domain (), domain))
        {
          struct symbol *better
            = better_symbol (other.symbol, result.symbol, domain);
@@ -2806,8 +2806,8 @@ basic_lookup_transparent_type_quick (struct objfile *objfile,
                           block_find_non_opaque_type, NULL);
   if (sym == NULL)
     error_in_psymtab_expansion (block_index, name, cust);
-  gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
-  return SYMBOL_TYPE (sym);
+  gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+  return sym->type ();
 }
 
 /* Subroutine of basic_lookup_transparent_type to simplify it.
@@ -2831,8 +2831,8 @@ basic_lookup_transparent_type_1 (struct objfile *objfile,
                               block_find_non_opaque_type, NULL);
       if (sym != NULL)
        {
-         gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
-         return SYMBOL_TYPE (sym);
+         gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+         return sym->type ();
        }
     }
 
@@ -2906,7 +2906,7 @@ iterate_over_symbols (const struct block *block,
 
   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
     {
-      if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain))
+      if (symbol_matches_domain (sym->language (), sym->domain (), domain))
        {
          struct block_symbol block_sym = {sym, block};
 
@@ -3987,9 +3987,9 @@ skip_prologue_sal (struct symtab_and_line *sal)
       b = BLOCK_SUPERBLOCK (b);
     }
   if (function_block != NULL
-      && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
+      && BLOCK_FUNCTION (function_block)->line () != 0)
     {
-      sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
+      sal->line = BLOCK_FUNCTION (function_block)->line ();
       sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
     }
 }
@@ -4657,7 +4657,7 @@ treg_matches_sym_type_name (const compiled_regex &treg,
                          sym->natural_name ());
     }
 
-  sym_type = SYMBOL_TYPE (sym);
+  sym_type = sym->type ();
   if (sym_type == NULL)
     return false;
 
@@ -4836,7 +4836,7 @@ global_symbol_searcher::add_matching_symbols
                              members.  We only want to skip enums
                              here.  */
                           && !(sym->aclass () == LOC_CONST
-                               && (SYMBOL_TYPE (sym)->code ()
+                               && (sym->type ()->code ()
                                    == TYPE_CODE_ENUM))
                           && (!treg.has_value ()
                               || treg_matches_sym_type_name (*treg, sym)))
@@ -4847,10 +4847,10 @@ global_symbol_searcher::add_matching_symbols
                                                                 sym)))
                          || (kind == TYPES_DOMAIN
                              && sym->aclass () == LOC_TYPEDEF
-                             && SYMBOL_DOMAIN (sym) != MODULE_DOMAIN)
+                             && sym->domain () != MODULE_DOMAIN)
                          || (kind == MODULES_DOMAIN
-                             && SYMBOL_DOMAIN (sym) == MODULE_DOMAIN
-                             && SYMBOL_LINE (sym) != 0))))
+                             && sym->domain () == MODULE_DOMAIN
+                             && sym->line () != 0))))
                {
                  if (result_set->size () < m_max_search_results)
                    {
@@ -5030,7 +5030,7 @@ symbol_to_info_string (struct symbol *sym, int block,
 
   /* Typedef that is not a C++ class.  */
   if (kind == TYPES_DOMAIN
-      && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
+      && sym->domain () != STRUCT_DOMAIN)
     {
       string_file tmp_stream;
 
@@ -5042,20 +5042,20 @@ symbol_to_info_string (struct symbol *sym, int block,
         For the struct printing case below, things are worse, we force
         printing of the ";" in this function, which is going to be wrong
         for languages that don't require a ";" between statements.  */
-      if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_TYPEDEF)
-       typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);
+      if (sym->type ()->code () == TYPE_CODE_TYPEDEF)
+       typedef_print (sym->type (), sym, &tmp_stream);
       else
-       type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
+       type_print (sym->type (), "", &tmp_stream, -1);
       str += tmp_stream.string ();
     }
   /* variable, func, or typedef-that-is-c++-class.  */
   else if (kind < TYPES_DOMAIN
           || (kind == TYPES_DOMAIN
-              && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
+              && sym->domain () == STRUCT_DOMAIN))
     {
       string_file tmp_stream;
 
-      type_print (SYMBOL_TYPE (sym),
+      type_print (sym->type (),
                  (sym->aclass () == LOC_TYPEDEF
                   ? "" : sym->print_name ()),
                  &tmp_stream, 0);
@@ -5098,8 +5098,8 @@ print_symbol_info (enum search_domain kind,
                                          s_filename));
        }
 
-      if (SYMBOL_LINE (sym) != 0)
-       printf_filtered ("%d:\t", SYMBOL_LINE (sym));
+      if (sym->line () != 0)
+       printf_filtered ("%d:\t", sym->line ());
       else
        puts_filtered ("\t");
     }
@@ -5525,7 +5525,7 @@ completion_list_add_symbol (completion_tracker &tracker,
      the msymbol name and removes the msymbol name from the completion
      tracker.  */
   if (sym->language () == language_cplus
-      && SYMBOL_DOMAIN (sym) == VAR_DOMAIN
+      && sym->domain () == VAR_DOMAIN
       && sym->aclass () == LOC_BLOCK)
     {
       /* The call to canonicalize returns the empty string if the input
@@ -5673,7 +5673,7 @@ completion_list_add_fields (completion_tracker &tracker,
 {
   if (sym->aclass () == LOC_TYPEDEF)
     {
-      struct type *t = SYMBOL_TYPE (sym);
+      struct type *t = sym->type ();
       enum type_code c = t->code ();
       int j;
 
@@ -5691,7 +5691,7 @@ completion_list_add_fields (completion_tracker &tracker,
 bool
 symbol_is_function_or_method (symbol *sym)
 {
-  switch (SYMBOL_TYPE (sym)->code ())
+  switch (sym->type ()->code ())
     {
     case TYPE_CODE_FUNC:
     case TYPE_CODE_METHOD:
@@ -5788,8 +5788,8 @@ add_symtab_completions (struct compunit_symtab *cust,
            continue;
 
          if (code == TYPE_CODE_UNDEF
-             || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
-                 && SYMBOL_TYPE (sym)->code () == code))
+             || (sym->domain () == STRUCT_DOMAIN
+                 && sym->type ()->code () == code))
            completion_list_add_symbol (tracker, sym,
                                        lookup_name,
                                        text, word);
@@ -5941,8 +5941,8 @@ default_collect_symbol_completion_matches_break_on
                completion_list_add_fields (tracker, sym, lookup_name,
                                            sym_text, word);
              }
-           else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
-                    && SYMBOL_TYPE (sym)->code () == code)
+           else if (sym->domain () == STRUCT_DOMAIN
+                    && sym->type ()->code () == code)
              completion_list_add_symbol (tracker, sym, lookup_name,
                                          sym_text, word);
          }
@@ -6534,7 +6534,7 @@ initialize_ordinary_address_classes (void)
 struct objfile *
 symbol_objfile (const struct symbol *symbol)
 {
-  gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
+  gdb_assert (symbol->is_objfile_owned ());
   return symbol->owner.symtab->objfile ();
 }
 
@@ -6543,7 +6543,7 @@ symbol_objfile (const struct symbol *symbol)
 struct gdbarch *
 symbol_arch (const struct symbol *symbol)
 {
-  if (!SYMBOL_OBJFILE_OWNED (symbol))
+  if (!symbol->is_objfile_owned ())
     return symbol->owner.arch;
   return symbol->owner.symtab->objfile ()->arch ();
 }
@@ -6553,7 +6553,7 @@ symbol_arch (const struct symbol *symbol)
 struct symtab *
 symbol_symtab (const struct symbol *symbol)
 {
-  gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
+  gdb_assert (symbol->is_objfile_owned ());
   return symbol->owner.symtab;
 }
 
@@ -6562,7 +6562,7 @@ symbol_symtab (const struct symbol *symbol)
 void
 symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
 {
-  gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
+  gdb_assert (symbol->is_objfile_owned ());
   symbol->owner.symtab = symtab;
 }