Merge GDB 7.5.1

gdb/elfread.c

 /* Read ELF (Executable and Linking Format) object files for GDB.
 
    Copyright (C) 1991-2012 Free Software Foundation, Inc.
 
    Written by Fred Fish at Cygnus Support.
 
    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
@@ skipping 18 matching lines @@
 #include "symtab.h"
 #include "symfile.h"
 #include "objfiles.h"
 #include "buildsym.h"
 #include "stabsread.h"
 #include "gdb-stabs.h"
 #include "complaints.h"
 #include "demangle.h"
 #include "psympriv.h"
 #include "filenames.h"
+#include "probe.h"
+#include "arch-utils.h"
 #include "gdbtypes.h"
 #include "value.h"
 #include "infcall.h"
 #include "gdbthread.h"
 #include "regcache.h"
+#include "bcache.h"
 
 extern void _initialize_elfread (void);
 
 /* Forward declarations.  */
 static const struct sym_fns elf_sym_fns_gdb_index;
 static const struct sym_fns elf_sym_fns_lazy_psyms;
 
 /* The struct elfinfo is available only during ELF symbol table and
    psymtab reading.  It is destroyed at the completion of psymtab-reading.
    It's local to elf_symfile_read.  */
 
 struct elfinfo
   {
     asection *stabsect;         /* Section pointer for .stab section */
     asection *stabindexsect;    /* Section pointer for .stab.index section */
     asection *mdebugsect;       /* Section pointer for .mdebug section */
   };
 
+/* Per-objfile data for probe info.  */
+
+static const struct objfile_data *probe_key = NULL;
+
 static void free_elfinfo (void *);
 
 /* Minimal symbols located at the GOT entries for .plt - that is the real
    pointer where the given entry will jump to.  It gets updated by the real
    function address during lazy ld.so resolving in the inferior.  These
    minimal symbols are indexed for <tab>-completion.  */
 
 #define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
 
 /* Locate the segments in ABFD.  */
@@ skipping 62 matching lines @@
          If we haven't, we will not relocate this section by any
          offsets we apply to the segments.  As an exception, do not
          warn about SHT_NOBITS sections; in normal ELF execution
          environments, SHT_NOBITS means zero-initialized and belongs
          in a segment, but in no-OS environments some tools (e.g. ARM
          RealView) use SHT_NOBITS for uninitialized data.  Since it is
          uninitialized, it doesn't need a program header.  Such
          binaries are not relocatable.  */
       if (bfd_get_section_size (sect) > 0 && j == num_segments
           && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
-        warning (_("Loadable segment \"%s\" outside of ELF segments"),
+        warning (_("Loadable section \"%s\" outside of ELF segments"),
                  bfd_section_name (abfd, sect));
     }
 
   return data;
 }
 
 /* We are called once per section from elf_symfile_read.  We
    need to examine each section we are passed, check to see
    if it is something we are interested in processing, and
    if so, stash away some access information for the section.
@@ skipping 76 matching lines @@
   CORE_ADDR symaddr;
   CORE_ADDR offset;
   enum minimal_symbol_type ms_type;
   /* If sectinfo is nonNULL, it contains section info that should end up
      filed in the objfile.  */
   struct stab_section_info *sectinfo = NULL;
   /* If filesym is nonzero, it points to a file symbol, but we haven't
      seen any section info for it yet.  */
   asymbol *filesym = 0;
   /* Name of filesym.  This is either a constant string or is saved on
-     the objfile's obstack.  */
-  char *filesymname = "";
+     the objfile's filename cache.  */
+  const char *filesymname = "";
   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
   int stripped = (bfd_get_symcount (objfile->obfd) == 0);
 
   for (i = 0; i < number_of_symbols; i++)
     {
       sym = symbol_table[i];
       if (sym->name == NULL || *sym->name == '\0')
         {
           /* Skip names that don't exist (shouldn't happen), or names
              that are null strings (may happen).  */
           continue;
         }
 
       /* Skip "special" symbols, e.g. ARM mapping symbols.  These are
          symbols which do not correspond to objects in the symbol table,
          but have some other target-specific meaning.  */
       if (bfd_is_target_special_symbol (objfile->obfd, sym))
         {
           if (gdbarch_record_special_symbol_p (gdbarch))
             gdbarch_record_special_symbol (gdbarch, objfile, sym);
           continue;
         }
 
       offset = ANOFFSET (objfile->section_offsets, sym->section->index);
       if (type == ST_DYNAMIC
-          && sym->section == &bfd_und_section
+          && sym->section == bfd_und_section_ptr
           && (sym->flags & BSF_FUNCTION))
         {
           struct minimal_symbol *msym;
           bfd *abfd = objfile->obfd;
           asection *sect;
 
           /* Symbol is a reference to a function defined in
              a shared library.
              If its value is non zero then it is usually the address
              of the corresponding entry in the procedure linkage table,
@@ skipping 15 matching lines @@
                 continue;
 
               if (symaddr >= bfd_get_section_vma (abfd, sect)
                   && symaddr < bfd_get_section_vma (abfd, sect)
                                + bfd_get_section_size (sect))
                 break;
             }
           if (!sect)
             continue;
 
+          /* On ia64-hpux, we have discovered that the system linker
+             adds undefined symbols with nonzero addresses that cannot
+             be right (their address points inside the code of another
+             function in the .text section).  This creates problems
+             when trying to determine which symbol corresponds to
+             a given address.
+
+             We try to detect those buggy symbols by checking which
+             section we think they correspond to.  Normally, PLT symbols
+             are stored inside their own section, and the typical name
+             for that section is ".plt".  So, if there is a ".plt"
+             section, and yet the section name of our symbol does not
+             start with ".plt", we ignore that symbol.  */
+          if (strncmp (sect->name, ".plt", 4) != 0
+              && bfd_get_section_by_name (abfd, ".plt") != NULL)
+            continue;
+
           symaddr += ANOFFSET (objfile->section_offsets, sect->index);
 
           msym = record_minimal_symbol
             (sym->name, strlen (sym->name), copy_names,
              symaddr, mst_solib_trampoline, sect, objfile);
           if (msym != NULL)
             msym->filename = filesymname;
           continue;
         }
 
       /* If it is a nonstripped executable, do not enter dynamic
          symbols, as the dynamic symbol table is usually a subset
          of the main symbol table.  */
       if (type == ST_DYNAMIC && !stripped)
         continue;
       if (sym->flags & BSF_FILE)
         {
           /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
              Chain any old one onto the objfile; remember new sym.  */
           if (sectinfo != NULL)
             {
               sectinfo->next = dbx->stab_section_info;
               dbx->stab_section_info = sectinfo;
               sectinfo = NULL;
             }
           filesym = sym;
-          filesymname =
-            obsavestring ((char *) filesym->name, strlen (filesym->name),
-                          &objfile->objfile_obstack);
+          filesymname = bcache (filesym->name, strlen (filesym->name) + 1,
+                                objfile->filename_cache);
         }
       else if (sym->flags & BSF_SECTION_SYM)
         continue;
       else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
         {
           struct minimal_symbol *msym;
 
           /* Select global/local/weak symbols.  Note that bfd puts abs
              symbols in their own section, so all symbols we are
              interested in will have a section.  */
           /* Bfd symbols are section relative.  */
           symaddr = sym->value + sym->section->vma;
           /* Relocate all non-absolute and non-TLS symbols by the
              section offset.  */
-          if (sym->section != &bfd_abs_section
+          if (sym->section != bfd_abs_section_ptr
               && !(sym->section->flags & SEC_THREAD_LOCAL))
             {
               symaddr += offset;
             }
           /* For non-absolute symbols, use the type of the section
              they are relative to, to intuit text/data.  Bfd provides
              no way of figuring this out for absolute symbols.  */
-          if (sym->section == &bfd_abs_section)
+          if (sym->section == bfd_abs_section_ptr)
             {
               /* This is a hack to get the minimal symbol type
                  right for Irix 5, which has absolute addresses
                  with special section indices for dynamic symbols.
 
                  NOTE: uweigand-20071112: Synthetic symbols do not
                  have an ELF-private part, so do not touch those.  */
               unsigned int shndx = type == ST_SYNTHETIC ? 0 :
                 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
 
@@ skipping 121 matching lines @@
                         }
                       if (sectinfo->sections[special_local_sect] != 0)
                         complaint (&symfile_complaints,
                                    _("duplicated elf/stab section "
                                      "information for %s"),
                                    sectinfo->filename);
                       /* BFD symbols are section relative.  */
                       symaddr = sym->value + sym->section->vma;
                       /* Relocate non-absolute symbols by the
                          section offset.  */
-                      if (sym->section != &bfd_abs_section)
+                      if (sym->section != bfd_abs_section_ptr)
                         symaddr += offset;
                       sectinfo->sections[special_local_sect] = symaddr;
                       /* The special local symbols don't go in the
                          minimal symbol table, so ignore this one.  */
                       continue;
                     }
                   /* Not a special stabs-in-elf symbol, do regular
                      symbol processing.  */
                   if (sym->section->flags & SEC_LOAD)
                     {
@@ skipping 56 matching lines @@
                 {
                   struct minimal_symbol *mtramp;
 
                   mtramp = record_minimal_symbol (sym->name, len - 4, 1,
                                                   symaddr,
                                                   mst_solib_trampoline,
                                                   sym->section, objfile);
                   if (mtramp)
                     {
                       MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
+                      mtramp->created_by_gdb = 1;
                       mtramp->filename = filesymname;
                       gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
                     }
                 }
             }
         }
     }
 }
 
 /* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
    for later look ups of which function to call when user requests
    a STT_GNU_IFUNC function.  As the STT_GNU_IFUNC type is found at the target
    library defining `function' we cannot yet know while reading OBJFILE which
    of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
    DYN_SYMBOL_TABLE is no longer easily available for OBJFILE.  */
 
 static void
 elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table)
 {
   bfd *obfd = objfile->obfd;
   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
   asection *plt, *relplt, *got_plt;
-  unsigned u;
   int plt_elf_idx;
   bfd_size_type reloc_count, reloc;
   char *string_buffer = NULL;
   size_t string_buffer_size = 0;
   struct cleanup *back_to;
   struct gdbarch *gdbarch = objfile->gdbarch;
   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
   size_t ptr_size = TYPE_LENGTH (ptr_type);
 
   if (objfile->separate_debug_objfile_backlink)
@@ skipping 18 matching lines @@
     return;
 
   if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE))
     return;
 
   back_to = make_cleanup (free_current_contents, &string_buffer);
 
   reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
   for (reloc = 0; reloc < reloc_count; reloc++)
     {
-      const char *name, *name_got_plt;
+      const char *name;
       struct minimal_symbol *msym;
       CORE_ADDR address;
       const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
       size_t name_len;
 
       name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr);
       name_len = strlen (name);
       address = relplt->relocation[reloc].address;
 
       /* Does the pointer reside in the .got.plt section?  */
@@ skipping 250 matching lines @@
 }
 
 /* Call STT_GNU_IFUNC - a function returning addresss of a real function to
    call.  PC is theSTT_GNU_IFUNC resolving function entry.  The value returned
    is the entry point of the resolved STT_GNU_IFUNC target function to call.
    */
 
 static CORE_ADDR
 elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
-  char *name_at_pc;
+  const char *name_at_pc;
   CORE_ADDR start_at_pc, address;
   struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
   struct value *function, *address_val;
 
   /* Try first any non-intrusive methods without an inferior call.  */
 
   if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL)
       && start_at_pc == pc)
     {
       if (elf_gnu_ifunc_resolve_name (name_at_pc, &address))
@@ skipping 54 matching lines @@
 
       init_sal (&sal);
       sal.pspace = current_inferior ()->pspace;
       sal.pc = prev_pc;
       sal.section = find_pc_overlay (sal.pc);
       sal.explicit_pc = 1;
       b_return = set_momentary_breakpoint (get_frame_arch (prev_frame), sal,
                                            prev_frame_id,
                                            bp_gnu_ifunc_resolver_return);
 
+      /* set_momentary_breakpoint invalidates PREV_FRAME.  */
+      prev_frame = NULL;
+
       /* Add new b_return to the ring list b->related_breakpoint.  */
       gdb_assert (b_return->related_breakpoint == b_return);
       b_return->related_breakpoint = b->related_breakpoint;
       b->related_breakpoint = b_return;
     }
 }
 
 /* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition.  */
 
 static void
 elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
 {
   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
   struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
   struct type *value_type = TYPE_TARGET_TYPE (func_func_type);
   struct regcache *regcache = get_thread_regcache (inferior_ptid);
+  struct value *func_func;
   struct value *value;
   CORE_ADDR resolved_address, resolved_pc;
   struct symtab_and_line sal;
   struct symtabs_and_lines sals, sals_end;
 
   gdb_assert (b->type == bp_gnu_ifunc_resolver_return);
 
-  value = allocate_value (value_type);
-  gdbarch_return_value (gdbarch, func_func_type, value_type, regcache,
-                        value_contents_raw (value), NULL);
-  resolved_address = value_as_address (value);
-  resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
-                                                    resolved_address,
-                                                    &current_target);
-
   while (b->related_breakpoint != b)
     {
       struct breakpoint *b_next = b->related_breakpoint;
 
       switch (b->type)
         {
         case bp_gnu_ifunc_resolver:
           break;
         case bp_gnu_ifunc_resolver_return:
           delete_breakpoint (b);
           break;
         default:
           internal_error (__FILE__, __LINE__,
                           _("handle_inferior_event: Invalid "
                             "gnu-indirect-function breakpoint type %d"),
                           (int) b->type);
         }
       b = b_next;
     }
   gdb_assert (b->type == bp_gnu_ifunc_resolver);
+  gdb_assert (b->loc->next == NULL);
+
+  func_func = allocate_value (func_func_type);
+  set_value_address (func_func, b->loc->related_address);
+
+  value = allocate_value (value_type);
+  gdbarch_return_value (gdbarch, func_func, value_type, regcache,
+                        value_contents_raw (value), NULL);
+  resolved_address = value_as_address (value);
+  resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
+                                                    resolved_address,
+                                                    &current_target);
 
   gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
   elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc);
 
   sal = find_pc_line (resolved_pc, 0);
   sals.nelts = 1;
   sals.sals = &sal;
   sals_end.nelts = 0;
 
   b->type = bp_breakpoint;
@@ skipping 54 matching lines @@
 
   xfree (found);
 
   return retval;
 }
 
 static char *
 build_id_to_debug_filename (struct build_id *build_id)
 {
   char *link, *debugdir, *retval = NULL;
+  VEC (char_ptr) *debugdir_vec;
+  struct cleanup *back_to;
+  int ix;
 
   /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
   link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
                  + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
 
   /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
      cause "/.build-id/..." lookups.  */
 
-  debugdir = debug_file_directory;
-  do
+  debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory);
+  back_to = make_cleanup_free_char_ptr_vec (debugdir_vec);
+
+  for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix)
     {
-      char *s, *debugdir_end;
+      size_t debugdir_len = strlen (debugdir);
       gdb_byte *data = build_id->data;
       size_t size = build_id->size;
+      char *s;
 
-      while (*debugdir == DIRNAME_SEPARATOR)
-        debugdir++;
-
-      debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
-      if (debugdir_end == NULL)
-        debugdir_end = &debugdir[strlen (debugdir)];
-
-      memcpy (link, debugdir, debugdir_end - debugdir);
-      s = &link[debugdir_end - debugdir];
+      memcpy (link, debugdir, debugdir_len);
+      s = &link[debugdir_len];
       s += sprintf (s, "/.build-id/");
       if (size > 0)
         {
           size--;
           s += sprintf (s, "%02x", (unsigned) *data++);
         }
       if (size > 0)
         *s++ = '/';
       while (size-- > 0)
         s += sprintf (s, "%02x", (unsigned) *data++);
       strcpy (s, ".debug");
 
       /* lrealpath() is expensive even for the usually non-existent files.  */
       if (access (link, F_OK) == 0)
         retval = lrealpath (link);
 
       if (retval != NULL && !build_id_verify (retval, build_id))
         {
           xfree (retval);
           retval = NULL;
         }
 
       if (retval != NULL)
         break;
+    }
 
-      debugdir = debugdir_end;
-    }
-  while (*debugdir != 0);
-
+  do_cleanups (back_to);
   return retval;
 }
 
 static char *
 find_separate_debug_file_by_buildid (struct objfile *objfile)
 {
   struct build_id *build_id;
 
   build_id = build_id_bfd_get (objfile->obfd);
   if (build_id != NULL)
@@ skipping 47 matching lines @@
 static void
 elf_symfile_read (struct objfile *objfile, int symfile_flags)
 {
   bfd *synth_abfd, *abfd = objfile->obfd;
   struct elfinfo ei;
   struct cleanup *back_to;
   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
   asymbol *synthsyms;
 
+  if (symtab_create_debug)
+    {
+      fprintf_unfiltered (gdb_stdlog,
+                          "Reading minimal symbols of objfile %s ...\n",
+                          objfile->name);
+    }
+
   init_minimal_symbol_collection ();
   back_to = make_cleanup_discard_minimal_symbols ();
 
   memset ((char *) &ei, 0, sizeof (ei));
 
   /* Allocate struct to keep track of the symfile.  */
   objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
     xmalloc (sizeof (struct dbx_symfile_info));
   memset ((char *) objfile->deprecated_sym_stab_info,
           0, sizeof (struct dbx_symfile_info));
@@ skipping 172 matching lines @@
         debugfile = find_separate_debug_file_by_debuglink (objfile);
 
       if (debugfile)
         {
           bfd *abfd = symfile_bfd_open (debugfile);
 
           symbol_file_add_separate (abfd, symfile_flags, objfile);
           xfree (debugfile);
         }
     }
+
+  if (symtab_create_debug)
+    fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n");
 }
 
 /* Callback to lazily read psymtabs.  */
 
 static void
 read_psyms (struct objfile *objfile)
 {
   if (dwarf2_has_info (objfile, NULL))
     dwarf2_build_psymtabs (objfile);
 }
@@ skipping 121 matching lines @@
       pst->section_offsets = (struct section_offsets *)
         obstack_alloc (&objfile->objfile_obstack,
                        SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
       for (i = 0; i < maybe->num_sections; i++)
         (pst->section_offsets)->offsets[i] = maybe->sections[i];
       return;
     }
 
   /* We were unable to find any offsets for this file.  Complain.  */
   if (dbx->stab_section_info)   /* If there *is* any info, */