Handle copy relocations
authorTom Tromey <tromey@adacore.com>
Tue, 25 Jun 2019 18:50:45 +0000 (12:50 -0600)
committerTom Tromey <tromey@adacore.com>
Wed, 2 Oct 2019 15:53:17 +0000 (09:53 -0600)
In ELF, if a data symbol is defined in a shared library and used by
the main program, it will be subject to a "copy relocation".  In this
scenario, the main program has a copy of the symbol in question, and a
relocation that tells ld.so to copy the data from the shared library.
Then the symbol in the main program is used to satisfy all references.

This patch changes gdb to handle this scenario.  Data symbols coming
from ELF shared libraries get a special flag that indicates that the
symbol's address may be subject to copy relocation.

I looked briefly into handling copy relocations by looking at the
actual relocations in the main program, but this seemed difficult to
do with BFD.

Note that no caching is done here.  Perhaps this could be changed if
need be; I wanted to avoid possible problems with either objfile
lifetimes and changes, or conflicts with the long-term (vapor-ware)
objfile splitting project.

gdb/ChangeLog
2019-10-02  Tom Tromey  <tromey@adacore.com>

* symmisc.c (dump_msymbols): Don't use MSYMBOL_VALUE_ADDRESS.
* ada-lang.c (lesseq_defined_than): Handle
LOC_STATIC.
* dwarf2read.c (dwarf2_per_objfile): Add can_copy
parameter.
(dwarf2_has_info): Likewise.
(new_symbol): Set maybe_copied on symbol when
appropriate.
* dwarf2read.h (dwarf2_per_objfile): Add can_copy
parameter.
<can_copy>: New member.
* elfread.c (record_minimal_symbol): Set maybe_copied
on symbol when appropriate.
(elf_symfile_read): Update call to dwarf2_has_info.
* minsyms.c (lookup_minimal_symbol_linkage): New
function.
* minsyms.h (lookup_minimal_symbol_linkage): Declare.
* symtab.c (get_symbol_address, get_msymbol_address):
New functions.
* symtab.h (get_symbol_address, get_msymbol_address):
Declare.
(SYMBOL_VALUE_ADDRESS, MSYMBOL_VALUE_ADDRESS): Handle
maybe_copied.
(struct symbol, struct minimal_symbol) <maybe_copied>:
New member.

gdb/ChangeLog
gdb/ada-lang.c
gdb/dwarf2read.c
gdb/dwarf2read.h
gdb/elfread.c
gdb/minsyms.c
gdb/minsyms.h
gdb/symfile.h
gdb/symmisc.c
gdb/symtab.c
gdb/symtab.h

index bf2811a0867b506a4d4eb65a243309e3fdf9011b..9bfb7551df2426e714c4d3533eda1b5879c1515e 100644 (file)
@@ -1,3 +1,31 @@
+2019-10-02  Tom Tromey  <tromey@adacore.com>
+
+       * symmisc.c (dump_msymbols): Don't use MSYMBOL_VALUE_ADDRESS.
+       * ada-lang.c (lesseq_defined_than): Handle
+       LOC_STATIC.
+       * dwarf2read.c (dwarf2_per_objfile): Add can_copy
+       parameter.
+       (dwarf2_has_info): Likewise.
+       (new_symbol): Set maybe_copied on symbol when
+       appropriate.
+       * dwarf2read.h (dwarf2_per_objfile): Add can_copy
+       parameter.
+       <can_copy>: New member.
+       * elfread.c (record_minimal_symbol): Set maybe_copied
+       on symbol when appropriate.
+       (elf_symfile_read): Update call to dwarf2_has_info.
+       * minsyms.c (lookup_minimal_symbol_linkage): New
+       function.
+       * minsyms.h (lookup_minimal_symbol_linkage): Declare.
+       * symtab.c (get_symbol_address, get_msymbol_address):
+       New functions.
+       * symtab.h (get_symbol_address, get_msymbol_address):
+       Declare.
+       (SYMBOL_VALUE_ADDRESS, MSYMBOL_VALUE_ADDRESS): Handle
+       maybe_copied.
+       (struct symbol, struct minimal_symbol) <maybe_copied>:
+       New member.
+
 2019-10-02  Tom Tromey  <tromey@adacore.com>
 
        * source.c (struct current_source_location): New.
index 48a400daa7d8cb0757f2745d00120200802a7dfb..f7f972a9bc961f6bb9a8c5cfda52d1e8e5e1c5e1 100644 (file)
@@ -4724,6 +4724,15 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
     case LOC_CONST:
       return SYMBOL_VALUE (sym0) == SYMBOL_VALUE (sym1)
         && equiv_types (SYMBOL_TYPE (sym0), SYMBOL_TYPE (sym1));
+
+    case LOC_STATIC:
+      {
+        const char *name0 = SYMBOL_LINKAGE_NAME (sym0);
+        const char *name1 = SYMBOL_LINKAGE_NAME (sym1);
+        return (strcmp (name0, name1) == 0
+                && SYMBOL_VALUE_ADDRESS (sym0) == SYMBOL_VALUE_ADDRESS (sym1));
+      }
+
     default:
       return 0;
     }
index f10f384f628d95ed912cdf3af5d90a1a0911e6e2..feac40ff95c17609f80dfceb1ca3c2b539811e1f 100644 (file)
@@ -2138,8 +2138,10 @@ attr_value_as_address (struct attribute *attr)
 /* See declaration.  */
 
 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
-                                       const dwarf2_debug_sections *names)
-  : objfile (objfile_)
+                                       const dwarf2_debug_sections *names,
+                                       bool can_copy_)
+  : objfile (objfile_),
+    can_copy (can_copy_)
 {
   if (names == NULL)
     names = &dwarf2_elf_names;
@@ -2214,11 +2216,14 @@ private:
 /* Try to locate the sections we need for DWARF 2 debugging
    information and return true if we have enough to do something.
    NAMES points to the dwarf2 section names, or is NULL if the standard
-   ELF names are used.  */
+   ELF names are used.  CAN_COPY is true for formats where symbol
+   interposition is possible and so symbol values must follow copy
+   relocation rules.  */
 
 int
 dwarf2_has_info (struct objfile *objfile,
-                 const struct dwarf2_debug_sections *names)
+                 const struct dwarf2_debug_sections *names,
+                bool can_copy)
 {
   if (objfile->flags & OBJF_READNEVER)
     return 0;
@@ -2228,7 +2233,8 @@ dwarf2_has_info (struct objfile *objfile,
 
   if (dwarf2_per_objfile == NULL)
     dwarf2_per_objfile = dwarf2_objfile_data_key.emplace (objfile, objfile,
-                                                         names);
+                                                         names,
+                                                         can_copy);
 
   return (!dwarf2_per_objfile->info.is_virtual
          && dwarf2_per_objfile->info.s.section != NULL
@@ -21715,19 +21721,21 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
                }
              else if (attr2 && (DW_UNSND (attr2) != 0))
                {
-                 /* Workaround gfortran PR debug/40040 - it uses
-                    DW_AT_location for variables in -fPIC libraries which may
-                    get overriden by other libraries/executable and get
-                    a different address.  Resolve it by the minimal symbol
-                    which may come from inferior's executable using copy
-                    relocation.  Make this workaround only for gfortran as for
-                    other compilers GDB cannot guess the minimal symbol
-                    Fortran mangling kind.  */
-                 if (cu->language == language_fortran && die->parent
-                     && die->parent->tag == DW_TAG_module
-                     && cu->producer
-                     && startswith (cu->producer, "GNU Fortran"))
-                   SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
+                 if (SYMBOL_CLASS (sym) == LOC_STATIC
+                     && (objfile->flags & OBJF_MAINLINE) == 0
+                     && dwarf2_per_objfile->can_copy)
+                   {
+                     /* A global static variable might be subject to
+                        copy relocation.  We first check for a local
+                        minsym, though, because maybe the symbol was
+                        marked hidden, in which case this would not
+                        apply.  */
+                     bound_minimal_symbol found
+                       = (lookup_minimal_symbol_linkage
+                          (SYMBOL_LINKAGE_NAME (sym), objfile));
+                     if (found.minsym != nullptr)
+                       sym->maybe_copied = 1;
+                   }
 
                  /* A variable with DW_AT_external is never static,
                     but it may be block-scoped.  */
index aee8742a79ce7f4d43a439e9e074efe5070c688e..a737168b62953fc3c899d2c69cd55d85bd872015 100644 (file)
@@ -106,9 +106,12 @@ struct dwarf2_per_objfile
 {
   /* Construct a dwarf2_per_objfile for OBJFILE.  NAMES points to the
      dwarf2 section names, or is NULL if the standard ELF names are
-     used.  */
+     used.  CAN_COPY is true for formats where symbol
+     interposition is possible and so symbol values must follow copy
+     relocation rules.  */
   dwarf2_per_objfile (struct objfile *objfile,
-                     const dwarf2_debug_sections *names);
+                     const dwarf2_debug_sections *names,
+                     bool can_copy);
 
   ~dwarf2_per_objfile ();
 
@@ -208,6 +211,9 @@ public:
      original data was compressed using 'dwz -m'.  */
   std::unique_ptr<struct dwz_file> dwz_file;
 
+  /* Whether copy relocations are supported by this object format.  */
+  bool can_copy;
+
   /* A flag indicating whether this objfile has a section loaded at a
      VMA of 0.  */
   bool has_section_at_zero = false;
index a3d17e54a2f1eb3482d08f9e88a3e8beed37630b..d2a7bcf8aa6130caa89dae074ddda85bd5f92fd1 100644 (file)
@@ -203,10 +203,16 @@ record_minimal_symbol (minimal_symbol_reader &reader,
       || ms_type == mst_text_gnu_ifunc)
     address = gdbarch_addr_bits_remove (gdbarch, address);
 
-  return reader.record_full (name, name_len, copy_name, address,
-                            ms_type,
-                            gdb_bfd_section_index (objfile->obfd,
-                                                   bfd_section));
+  struct minimal_symbol *result
+    = reader.record_full (name, name_len, copy_name, address,
+                         ms_type,
+                         gdb_bfd_section_index (objfile->obfd,
+                                                bfd_section));
+  if ((objfile->flags & OBJF_MAINLINE) == 0
+      && (ms_type == mst_data || ms_type == mst_bss))
+    result->maybe_copied = 1;
+
+  return result;
 }
 
 /* Read the symbol table of an ELF file.
@@ -1239,7 +1245,7 @@ elf_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
                                bfd_section_size (str_sect));
     }
 
-  if (dwarf2_has_info (objfile, NULL))
+  if (dwarf2_has_info (objfile, NULL, true))
     {
       dw_index_kind index_kind;
 
index 83f5d895779e5c86b236e8584a1ddf34f47bccd4..c41e5c3200121d167051cf8a2e75dd9dc1a8c1dd 100644 (file)
@@ -519,6 +519,29 @@ iterate_over_minimal_symbols
 
 /* See minsyms.h.  */
 
+bound_minimal_symbol
+lookup_minimal_symbol_linkage (const char *name, struct objfile *objf)
+{
+  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
+
+  for (objfile *objfile : objf->separate_debug_objfiles ())
+    {
+      for (minimal_symbol *msymbol = objfile->per_bfd->msymbol_hash[hash];
+          msymbol != NULL;
+          msymbol = msymbol->hash_next)
+       {
+         if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0
+             && (MSYMBOL_TYPE (msymbol) == mst_data
+                 || MSYMBOL_TYPE (msymbol) == mst_bss))
+           return {msymbol, objfile};
+       }
+    }
+
+  return {};
+}
+
+/* See minsyms.h.  */
+
 struct bound_minimal_symbol
 lookup_minimal_symbol_text (const char *name, struct objfile *objf)
 {
index ce4b83d54480dd5ce98152844bb824d931e5ff8f..0a19f0b096231ea055d5537c6c75fa41d843d6fc 100644 (file)
@@ -205,6 +205,17 @@ struct bound_minimal_symbol lookup_bound_minimal_symbol (const char *);
 struct bound_minimal_symbol lookup_minimal_symbol_text (const char *,
                                                        struct objfile *);
 
+/* Look through the minimal symbols in OBJF (and its separate debug
+   objfiles) for a global (not file-local) minsym whose linkage name
+   is NAME.  This is somewhat similar to lookup_minimal_symbol_text,
+   only data symbols (not text symbols) are considered, and a non-NULL
+   objfile is not accepted.  Returns a bound minimal symbol that
+   matches, or an "empty" bound minimal symbol otherwise.  */
+
+extern struct bound_minimal_symbol lookup_minimal_symbol_linkage
+  (const char *name, struct objfile *objf)
+  ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
+
 /* Look through all the current minimal symbol tables and find the
    first minimal symbol that matches NAME and PC.  If OBJF is non-NULL,
    limit the search to that objfile.  Returns a pointer to the minimal
index 642a5e223a32576fc2445415a5fb7bdf526d54e7..cb5bed9d85c455d72bff9cb203ad9a90690ce2c2 100644 (file)
@@ -585,7 +585,8 @@ struct dwarf2_debug_sections {
 };
 
 extern int dwarf2_has_info (struct objfile *,
-                            const struct dwarf2_debug_sections *);
+                            const struct dwarf2_debug_sections *,
+                           bool = false);
 
 /* Dwarf2 sections that can be accessed by dwarf2_get_section_info.  */
 enum dwarf2_section_enum {
index 4699fd09206e06c4ce569a3c40d84f86635043a6..c91ad5e5f455502886b6bf19b0b1395f3274b25a 100644 (file)
@@ -236,9 +236,13 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
          break;
        }
       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
-      fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
-                                                               msymbol)),
-                     outfile);
+
+      /* Use the relocated address as shown in the symbol here -- do
+        not try to respect copy relocations.  */
+      CORE_ADDR addr = (msymbol->value.address
+                       + ANOFFSET (objfile->section_offsets,
+                                   msymbol->section));
+      fputs_filtered (paddress (gdbarch, addr), outfile);
       fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
       if (section)
        {
index 7b4444c7d38cadfc9950adac586dad4c094c14ce..8a551f1575a31579b030e6ac927bf6eb78e99346 100644 (file)
@@ -6261,6 +6261,50 @@ symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
   symbol->owner.symtab = symtab;
 }
 
+/* See symtab.h.  */
+
+CORE_ADDR
+get_symbol_address (const struct symbol *sym)
+{
+  gdb_assert (sym->maybe_copied);
+  gdb_assert (SYMBOL_CLASS (sym) == LOC_STATIC);
+
+  const char *linkage_name = SYMBOL_LINKAGE_NAME (sym);
+
+  for (objfile *objfile : current_program_space->objfiles ())
+    {
+      bound_minimal_symbol minsym
+       = lookup_minimal_symbol_linkage (linkage_name, objfile);
+      if (minsym.minsym != nullptr)
+       return BMSYMBOL_VALUE_ADDRESS (minsym);
+    }
+  return sym->ginfo.value.address;
+}
+
+/* See symtab.h.  */
+
+CORE_ADDR
+get_msymbol_address (struct objfile *objf, const struct minimal_symbol *minsym)
+{
+  gdb_assert (minsym->maybe_copied);
+  gdb_assert ((objf->flags & OBJF_MAINLINE) == 0);
+
+  const char *linkage_name = MSYMBOL_LINKAGE_NAME (minsym);
+
+  for (objfile *objfile : current_program_space->objfiles ())
+    {
+      if ((objfile->flags & OBJF_MAINLINE) != 0)
+       {
+         bound_minimal_symbol found
+           = lookup_minimal_symbol_linkage (linkage_name, objfile);
+         if (found.minsym != nullptr)
+           return BMSYMBOL_VALUE_ADDRESS (found);
+       }
+    }
+  return (minsym->value.address
+         + ANOFFSET (objf->section_offsets, minsym->section));
+}
+
 \f
 
 void
index e9024a0a7397d70259e343dd456f10b8133c1028..dc65409dd24cd8ae561525fd1d72a8f82b3ecdd1 100644 (file)
@@ -454,6 +454,14 @@ extern const char *symbol_get_demangled_name
 
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
 
+/* Return the address of SYM.  The MAYBE_COPIED flag must be set on
+   SYM.  If SYM appears in the main program's minimal symbols, then
+   that minsym's address is returned; otherwise, SYM's address is
+   returned.  This should generally only be used via the
+   SYMBOL_VALUE_ADDRESS macro.  */
+
+extern CORE_ADDR get_symbol_address (const struct symbol *sym);
+
 /* Note that all the following SYMBOL_* macros are used with the
    SYMBOL argument being either a partial symbol or
    a full symbol.  Both types have a ginfo field.  In particular
@@ -463,7 +471,9 @@ extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
    field only, instead of the SYMBOL parameter.  */
 
 #define SYMBOL_VALUE(symbol)           (symbol)->ginfo.value.ivalue
-#define SYMBOL_VALUE_ADDRESS(symbol)   ((symbol)->ginfo.value.address + 0)
+#define SYMBOL_VALUE_ADDRESS(symbol)                         \
+  (((symbol)->maybe_copied) ? get_symbol_address (symbol)     \
+   : ((symbol)->ginfo.value.address))
 #define SET_SYMBOL_VALUE_ADDRESS(symbol, new_value)    \
   ((symbol)->ginfo.value.address = (new_value))
 #define SYMBOL_VALUE_BYTES(symbol)     (symbol)->ginfo.value.bytes
@@ -671,6 +681,14 @@ struct minimal_symbol : public general_symbol_info
      the object file format may not carry that piece of information.  */
   unsigned int has_size : 1;
 
+  /* For data symbols only, if this is set, then the symbol might be
+     subject to copy relocation.  In this case, a minimal symbol
+     matching the symbol's linkage name is first looked for in the
+     main objfile.  If found, then that address is used; otherwise the
+     address in this symbol is used.  */
+
+  unsigned maybe_copied : 1;
+
   /* Minimal symbols with the same hash key are kept on a linked
      list.  This is the link.  */
 
@@ -690,6 +708,15 @@ struct minimal_symbol : public general_symbol_info
   bool text_p () const;
 };
 
+/* Return the address of MINSYM, which comes from OBJF.  The
+   MAYBE_COPIED flag must be set on MINSYM.  If MINSYM appears in the
+   main program's minimal symbols, then that minsym's address is
+   returned; otherwise, MINSYM's address is returned.  This should
+   generally only be used via the MSYMBOL_VALUE_ADDRESS macro.  */
+
+extern CORE_ADDR get_msymbol_address (struct objfile *objf,
+                                     const struct minimal_symbol *minsym);
+
 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2
 #define MSYMBOL_SIZE(msymbol)          ((msymbol)->size + 0)
@@ -708,8 +735,9 @@ struct minimal_symbol : public general_symbol_info
 /* The relocated address of the minimal symbol, using the section
    offsets from OBJFILE.  */
 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol)                         \
-  ((symbol)->value.address                                     \
-   + ANOFFSET ((objfile)->section_offsets, ((symbol)->section)))
+  (((symbol)->maybe_copied) ? get_msymbol_address (objfile, symbol)    \
+   : ((symbol)->value.address                                          \
+      + ANOFFSET ((objfile)->section_offsets, ((symbol)->section))))
 /* For a bound minsym, we can easily compute the address directly.  */
 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
   MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
@@ -1112,6 +1140,14 @@ struct symbol
   /* Whether this is an inlined function (class LOC_BLOCK only).  */
   unsigned is_inlined : 1;
 
+  /* For LOC_STATIC only, if this is set, then the symbol might be
+     subject to copy relocation.  In this case, a minimal symbol
+     matching the symbol's linkage name is first looked for in the
+     main objfile.  If found, then that address is used; otherwise the
+     address in this symbol is used.  */
+
+  unsigned maybe_copied : 1;
+
   /* The concrete type of this symbol.  */
 
   ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;