Use unrelocated_addr in minimal symbols

This changes minimal symbols to use unrelocated_addr.  I believe this
detected a latent bug in add_pe_forwarded_sym.

diff --git a/gdb/coff-pe-read.c b/gdb/coff-pe-read.c
index 2b89e8a3542980fc8f8d12b327f8f31ecbf97e35..07cd216b4b215de7c9df9d65af94250b333d7b0e 100644 (file)
--- a/gdb/coff-pe-read.c
+++ b/gdb/coff-pe-read.c
@@ -127,7 +127,8 @@ add_pe_exported_sym (minimal_symbol_reader &reader,
                     const char *dll_name, struct objfile *objfile)
 {
   /* Add the stored offset to get the loaded address of the symbol.  */
-  CORE_ADDR vma = func_rva + section_data->vma_offset;
+  unrelocated_addr vma = unrelocated_addr (func_rva
+                                          + section_data->vma_offset);
 
   /* Generate a (hopefully unique) qualified name using the first part
      of the dll name, e.g. KERNEL32!AddAtomA.  This matches the style
@@ -174,7 +175,6 @@ add_pe_forwarded_sym (minimal_symbol_reader &reader,
                      const char *forward_func_name, int ordinal,
                      const char *dll_name, struct objfile *objfile)
 {
-  CORE_ADDR vma, baseaddr;
   struct bound_minimal_symbol msymbol;
   enum minimal_symbol_type msymtype;
   int forward_dll_name_len = strlen (forward_dll_name);
@@ -210,7 +210,7 @@ add_pe_forwarded_sym (minimal_symbol_reader &reader,
                              " \"%s\" in dll \"%s\", pointing to \"%s\"\n"),
                sym_name, dll_name, forward_qualified_name.c_str ());
 
-  vma = msymbol.value_address ();
+  unrelocated_addr vma = msymbol.minsym->value_raw_address ();
   msymtype = msymbol.minsym->type ();
   section = msymbol.minsym->section_index ();
 
@@ -232,14 +232,11 @@ add_pe_forwarded_sym (minimal_symbol_reader &reader,
      really be relocated properly, but nevertheless we make a stab at
      it, choosing an approach consistent with the history of this
      code.  */
-  baseaddr = objfile->text_section_offset ();
 
-  reader.record_with_info (qualified_name.c_str (), vma - baseaddr, msymtype,
-                          section);
+  reader.record_with_info (qualified_name.c_str (), vma, msymtype, section);
 
   /* Enter the plain name as well, which might not be unique.  */
-  reader.record_with_info (bare_name.c_str(), vma - baseaddr, msymtype,
-                          section);
+  reader.record_with_info (bare_name.c_str(), vma, msymtype, section);
 
   return 1;
 }

diff --git a/gdb/coffread.c b/gdb/coffread.c
index 8e88aaca2ad645a5c5d8e2e56362a1fa88d2ce17..ff4d4ae53138e235b0b4bbf5b66a3a1cd4ee18d3 100644 (file)
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -445,7 +445,7 @@ is_import_fixup_symbol (struct coff_symbol *cs,
 
 static struct minimal_symbol *
 record_minimal_symbol (minimal_symbol_reader &reader,
-                      struct coff_symbol *cs, CORE_ADDR address,
+                      struct coff_symbol *cs, unrelocated_addr address,
                       enum minimal_symbol_type type, int section, 
                       struct objfile *objfile)
 {
@@ -880,8 +880,9 @@ coff_symtab_read (minimal_symbol_reader &reader,
          tmpaddr = cs->c_value;
          /* Don't record unresolved symbols.  */
          if (!(cs->c_secnum <= 0 && cs->c_value == 0))
-           record_minimal_symbol (reader, cs, tmpaddr, mst_text,
-                                  section, objfile);
+           record_minimal_symbol (reader, cs,
+                                  unrelocated_addr (tmpaddr),
+                                  mst_text, section, objfile);
 
          fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
          fcn_start_addr = tmpaddr;
@@ -1041,8 +1042,9 @@ coff_symtab_read (minimal_symbol_reader &reader,
                  ms_type = mst_unknown;
              }
 
-           msym = record_minimal_symbol (reader, cs, tmpaddr, ms_type,
-                                         sec, objfile);
+           msym = record_minimal_symbol (reader, cs,
+                                         unrelocated_addr (tmpaddr),
+                                         ms_type, sec, objfile);
            if (msym)
              gdbarch_coff_make_msymbol_special (gdbarch,
                                                 cs->c_sclass, msym);

diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 677e91d7725f970de34665109bafb68a008b57d9..9df9320bc7bf1bfd53bfe44f1e8da3d02207cc09 100644 (file)
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -157,7 +157,7 @@ static unsigned char processing_acc_compilation;
    need to make guesses based on the symbols (which *are* relocated to
    reflect the address it will be loaded at).  */
 
-static CORE_ADDR lowest_text_address;
+static unrelocated_addr lowest_text_address;
 
 /* Non-zero if there is any line number info in the objfile.  Prevents
    dbx_end_psymtab from discarding an otherwise empty psymtab.  */
@@ -286,7 +286,7 @@ static void dbx_symfile_read (struct objfile *, symfile_add_flags);
 static void dbx_symfile_finish (struct objfile *);
 
 static void record_minimal_symbol (minimal_symbol_reader &,
-                                  const char *, CORE_ADDR, int,
+                                  const char *, unrelocated_addr, int,
                                   struct objfile *);
 
 static void add_new_header_file (const char *, int);
@@ -428,7 +428,7 @@ explicit_lookup_type (int real_filenum, int index)
 \f
 static void
 record_minimal_symbol (minimal_symbol_reader &reader,
-                      const char *name, CORE_ADDR address, int type,
+                      const char *name, unrelocated_addr address, int type,
                       struct objfile *objfile)
 {
   enum minimal_symbol_type ms_type;
@@ -1009,7 +1009,7 @@ read_dbx_symtab (minimal_symbol_reader &reader,
 
   set_last_source_file (NULL);
 
-  lowest_text_address = (CORE_ADDR) -1;
+  lowest_text_address = (unrelocated_addr) -1;
 
   symfile_bfd = objfile->obfd.get ();  /* For next_text_symbol.  */
   abfd = objfile->obfd.get ();
@@ -1103,7 +1103,8 @@ read_dbx_symtab (minimal_symbol_reader &reader,
          record_it:
          namestring = set_namestring (objfile, &nlist);
 
-         record_minimal_symbol (reader, namestring, nlist.n_value,
+         record_minimal_symbol (reader, namestring,
+                                unrelocated_addr (nlist.n_value),
                                 nlist.n_type, objfile);        /* Always */
          continue;
 
@@ -1680,7 +1681,8 @@ read_dbx_symtab (minimal_symbol_reader &reader,
                                          pst ? pst->filename : NULL,
                                          objfile);
                  if (minsym.minsym != NULL)
-                   nlist.n_value = minsym.minsym->value_raw_address ();
+                   nlist.n_value
+                     = CORE_ADDR (minsym.minsym->value_raw_address ());
                }
              if (pst && textlow_not_set
                  && gdbarch_sofun_address_maybe_missing (gdbarch))
@@ -1738,7 +1740,8 @@ read_dbx_symtab (minimal_symbol_reader &reader,
                                          pst ? pst->filename : NULL,
                                          objfile);
                  if (minsym.minsym != NULL)
-                   nlist.n_value = minsym.minsym->value_raw_address ();
+                   nlist.n_value
+                     = CORE_ADDR (minsym.minsym->value_raw_address ());
                }
              if (pst && textlow_not_set
                  && gdbarch_sofun_address_maybe_missing (gdbarch))
@@ -1945,10 +1948,11 @@ read_dbx_symtab (minimal_symbol_reader &reader,
       /* Don't set high text address of PST lower than it already
         is.  */
       unrelocated_addr text_end
-       = unrelocated_addr ((lowest_text_address == (CORE_ADDR) -1
-                            ? text_addr
-                            : lowest_text_address)
-                           + text_size);
+       = (unrelocated_addr
+          (lowest_text_address == (unrelocated_addr) -1
+           ? text_addr
+           : CORE_ADDR (lowest_text_address)
+           + text_size));
 
       dbx_end_psymtab (objfile, partial_symtabs,
                       pst, psymtab_include_list, includes_used,
@@ -2054,7 +2058,7 @@ dbx_end_psymtab (struct objfile *objfile, psymtab_storage *partial_symtabs,
 
       if (minsym.minsym)
        pst->set_text_high
-         (unrelocated_addr (minsym.minsym->value_raw_address ()
+         (unrelocated_addr (CORE_ADDR (minsym.minsym->value_raw_address ())
                             + minsym.minsym->size ()));
 
       last_function_name = NULL;

diff --git a/gdb/elfread.c b/gdb/elfread.c
index b414da9ed2184eef709def4839ac9333dac766f5..5577149204431751c37c0abf9fd3b86706ef606b 100644 (file)
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -199,7 +199,7 @@ elf_locate_sections (asection *sectp, struct elfinfo *ei)
 static struct minimal_symbol *
 record_minimal_symbol (minimal_symbol_reader &reader,
                       gdb::string_view name, bool copy_name,
-                      CORE_ADDR address,
+                      unrelocated_addr address,
                       enum minimal_symbol_type ms_type,
                       asection *bfd_section, struct objfile *objfile)
 {
@@ -207,7 +207,9 @@ record_minimal_symbol (minimal_symbol_reader &reader,
 
   if (ms_type == mst_text || ms_type == mst_file_text
       || ms_type == mst_text_gnu_ifunc)
-    address = gdbarch_addr_bits_remove (gdbarch, address);
+    address
+      = unrelocated_addr (gdbarch_addr_bits_remove (gdbarch,
+                                                   CORE_ADDR (address)));
 
   /* We only setup section information for allocatable sections.  Usually
      we'd only expect to find msymbols for allocatable sections, but if the
@@ -338,7 +340,8 @@ elf_symtab_read (minimal_symbol_reader &reader,
 
          msym = record_minimal_symbol
            (reader, sym->name, copy_names,
-            symaddr, mst_solib_trampoline, sect, objfile);
+            unrelocated_addr (symaddr),
+            mst_solib_trampoline, sect, objfile);
          if (msym != NULL)
            {
              msym->filename = filesymname;
@@ -477,7 +480,7 @@ elf_symtab_read (minimal_symbol_reader &reader,
              continue; /* Skip this symbol.  */
            }
          msym = record_minimal_symbol
-           (reader, sym->name, copy_names, symaddr,
+           (reader, sym->name, copy_names, unrelocated_addr (symaddr),
             ms_type, sym->section, objfile);
 
          if (msym)
@@ -509,8 +512,8 @@ elf_symtab_read (minimal_symbol_reader &reader,
                  && (elf_sym->version & VERSYM_HIDDEN) == 0)
                record_minimal_symbol (reader,
                                       gdb::string_view (sym->name, len),
-                                      true, symaddr, ms_type, sym->section,
-                                      objfile);
+                                      true, unrelocated_addr (symaddr),
+                                      ms_type, sym->section, objfile);
              else if (is_plt)
                {
                  /* For @plt symbols, also record a trampoline to the
@@ -523,7 +526,8 @@ elf_symtab_read (minimal_symbol_reader &reader,
 
                      mtramp = record_minimal_symbol
                        (reader, gdb::string_view (sym->name, len), true,
-                        symaddr, mst_solib_trampoline, sym->section, objfile);
+                        unrelocated_addr (symaddr),
+                        mst_solib_trampoline, sym->section, objfile);
                      if (mtramp)
                        {
                          mtramp->set_size (msym->size());
@@ -641,8 +645,8 @@ elf_rel_plt_read (minimal_symbol_reader &reader,
       string_buffer.append (got_suffix, got_suffix + got_suffix_len);
 
       msym = record_minimal_symbol (reader, string_buffer,
-                                   true, address, mst_slot_got_plt,
-                                   msym_section, objfile);
+                                   true, unrelocated_addr (address),
+                                   mst_slot_got_plt, msym_section, objfile);
       if (msym)
        msym->set_size (ptr_size);
     }

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 60b5ca3faf3a51a3a2536c59832600035aa7514c..97cc9ba76608bd31fce4cbff506f44afa9b2ffcd 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -754,9 +754,9 @@ language_defn::read_var_value (struct symbol *var,
           a TLS variable. */
        if (obj_section == NULL
            || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
-          addr = bmsym.minsym->value_raw_address ();
+         addr = CORE_ADDR (bmsym.minsym->value_raw_address ());
        else
-          addr = bmsym.value_address ();
+         addr = bmsym.value_address ();
        if (overlay_debugging)
          addr = symbol_overlayed_address (addr, obj_section);
        /* Determine address of TLS variable. */

diff --git a/gdb/machoread.c b/gdb/machoread.c
index e8cae810788b57905428ea1aacc39fb854abdbf4..9735de80d57232a7ce9ae4bdf7bd849051393536 100644 (file)
--- a/gdb/machoread.c
+++ b/gdb/machoread.c
@@ -98,11 +98,11 @@ macho_symtab_add_minsym (minimal_symbol_reader &reader,
 
   if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
     {
-      CORE_ADDR symaddr;
+      unrelocated_addr symaddr;
       enum minimal_symbol_type ms_type;
 
       /* Bfd symbols are section relative.  */
-      symaddr = sym->value + sym->section->vma;
+      symaddr = unrelocated_addr (sym->value + sym->section->vma);
 
       if (sym->section == bfd_abs_section_ptr)
        ms_type = mst_abs;

diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index e041558764613584212f8b252a1f59301bed417b..8faf482b09cd713c834a9b1c10beda4c7a09d8e2 100644 (file)
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -2235,7 +2235,7 @@ function_outside_compilation_unit_complaint (const char *arg1)
 
 static void
 record_minimal_symbol (minimal_symbol_reader &reader,
-                      const char *name, const CORE_ADDR address,
+                      const char *name, const unrelocated_addr address,
                       enum minimal_symbol_type ms_type, int storage_class,
                       struct objfile *objfile)
 {
@@ -2461,7 +2461,7 @@ parse_partial_symbols (minimal_symbol_reader &reader,
   for (; ext_in < ext_in_end; ext_in++)
     {
       enum minimal_symbol_type ms_type = mst_text;
-      CORE_ADDR svalue = ext_in->asym.value;
+      unrelocated_addr svalue = unrelocated_addr (ext_in->asym.value);
 
       /* The Irix 5 native tools seem to sometimes generate bogus
         external symbols.  */
@@ -2701,7 +2701,8 @@ parse_partial_symbols (minimal_symbol_reader &reader,
                      if (sh.st == stStaticProc)
                        {
                          namestring = debug_info->ss + fh->issBase + sh.iss;
-                         record_minimal_symbol (reader, namestring, sh.value,
+                         record_minimal_symbol (reader, namestring,
+                                                unrelocated_addr (sh.value),
                                                 mst_file_text, sh.sc,
                                                 objfile);
                        }
@@ -2747,7 +2748,8 @@ parse_partial_symbols (minimal_symbol_reader &reader,
                        case scPData:
                        case scXData:
                          namestring = debug_info->ss + fh->issBase + sh.iss;
-                         record_minimal_symbol (reader, namestring, sh.value,
+                         record_minimal_symbol (reader, namestring,
+                                                unrelocated_addr (sh.value),
                                                 mst_file_data, sh.sc,
                                                 objfile);
                          break;
@@ -2756,7 +2758,8 @@ parse_partial_symbols (minimal_symbol_reader &reader,
                          /* FIXME!  Shouldn't this use cases for bss, 
                             then have the default be abs?  */
                          namestring = debug_info->ss + fh->issBase + sh.iss;
-                         record_minimal_symbol (reader, namestring, sh.value,
+                         record_minimal_symbol (reader, namestring,
+                                                unrelocated_addr (sh.value),
                                                 mst_file_bss, sh.sc,
                                                 objfile);
                          break;
@@ -3369,7 +3372,7 @@ parse_partial_symbols (minimal_symbol_reader &reader,
            {
              char *sym_name;
              enum address_class theclass;
-             CORE_ADDR minsym_value;
+             unrelocated_addr minsym_value;
              short section = -1;
 
              (*swap_sym_in) (cur_bfd,
@@ -3396,7 +3399,7 @@ parse_partial_symbols (minimal_symbol_reader &reader,
 
              sym_name = debug_info->ss + fh->issBase + sh.iss;
 
-             minsym_value = sh.value;
+             minsym_value = unrelocated_addr (sh.value);
 
              switch (sh.sc)
                {

diff --git a/gdb/minsyms.c b/gdb/minsyms.c
index 02e36cc6dd2bf7c9410ed0441cd4c744154fbe8a..67bd4903a3e5b4b11bc710dea1680dcd6d18c093 100644 (file)
--- a/gdb/minsyms.c
+++ b/gdb/minsyms.c
@@ -672,19 +672,20 @@ lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name,
 
 /* A helper function that makes *PC section-relative.  This searches
    the sections of OBJFILE and if *PC is in a section, it subtracts
-   the section offset and returns true.  Otherwise it returns
-   false.  */
+   the section offset, stores the result into UNREL_ADDR, and returns
+   true.  Otherwise it returns false.  */
 
 static int
-frob_address (struct objfile *objfile, CORE_ADDR *pc)
+frob_address (struct objfile *objfile, CORE_ADDR pc,
+             unrelocated_addr *unrel_addr)
 {
   struct obj_section *iter;
 
   ALL_OBJFILE_OSECTIONS (objfile, iter)
     {
-      if (*pc >= iter->addr () && *pc < iter->endaddr ())
+      if (pc >= iter->addr () && pc < iter->endaddr ())
        {
-         *pc -= iter->offset ();
+         *unrel_addr = unrelocated_addr (pc - iter->offset ());
          return 1;
        }
     }
@@ -793,15 +794,16 @@ lookup_minimal_symbol_by_pc_section (CORE_ADDR pc_in, struct obj_section *sectio
 
             Warning: this code is trickier than it would appear at first.  */
 
-         if (frob_address (objfile, &pc)
-             && pc >= msymbol[lo].value_raw_address ())
+         unrelocated_addr unrel_pc;
+         if (frob_address (objfile, pc, &unrel_pc)
+             && unrel_pc >= msymbol[lo].value_raw_address ())
            {
-             while (msymbol[hi].value_raw_address () > pc)
+             while (msymbol[hi].value_raw_address () > unrel_pc)
                {
                  /* pc is still strictly less than highest address.  */
                  /* Note "new" will always be >= lo.  */
                  newobj = (lo + hi) / 2;
-                 if ((msymbol[newobj].value_raw_address () >= pc)
+                 if ((msymbol[newobj].value_raw_address () >= unrel_pc)
                      || (lo == newobj))
                    {
                      hi = newobj;
@@ -894,10 +896,8 @@ lookup_minimal_symbol_by_pc_section (CORE_ADDR pc_in, struct obj_section *sectio
                     the cancellable variants, but both have sizes.  */
                  if (hi > 0
                      && msymbol[hi].size () != 0
-                     && pc >= (msymbol[hi].value_raw_address ()
-                               + msymbol[hi].size ())
-                     && pc < (msymbol[hi - 1].value_raw_address ()
-                              + msymbol[hi - 1].size ()))
+                     && unrel_pc >= msymbol[hi].value_raw_end_address ()
+                     && unrel_pc < msymbol[hi - 1].value_raw_end_address ())
                    {
                      hi--;
                      continue;
@@ -926,8 +926,7 @@ lookup_minimal_symbol_by_pc_section (CORE_ADDR pc_in, struct obj_section *sectio
 
              if (hi >= 0
                  && msymbol[hi].size () != 0
-                 && pc >= (msymbol[hi].value_raw_address ()
-                           + msymbol[hi].size ()))
+                 && unrel_pc >= msymbol[hi].value_raw_end_address ())
                {
                  if (best_zero_sized != -1)
                    hi = best_zero_sized;
@@ -1092,7 +1091,7 @@ minimal_symbol_reader::~minimal_symbol_reader ()
 /* See minsyms.h.  */
 
 void
-minimal_symbol_reader::record (const char *name, CORE_ADDR address,
+minimal_symbol_reader::record (const char *name, unrelocated_addr address,
                               enum minimal_symbol_type ms_type)
 {
   int section;
@@ -1152,7 +1151,7 @@ mst_str (minimal_symbol_type t)
 
 struct minimal_symbol *
 minimal_symbol_reader::record_full (gdb::string_view name,
-                                   bool copy_name, CORE_ADDR address,
+                                   bool copy_name, unrelocated_addr address,
                                    enum minimal_symbol_type ms_type,
                                    int section)
 {
@@ -1178,8 +1177,9 @@ minimal_symbol_reader::record_full (gdb::string_view name,
     return (NULL);
 
   symtab_create_debug_printf_v ("recording minsym:  %-21s  %18s  %4d  %.*s",
-                               mst_str (ms_type), hex_string (address), section,
-                               (int) name.size (), name.data ());
+                               mst_str (ms_type),
+                               hex_string (LONGEST (address)),
+                               section, (int) name.size (), name.data ());
 
   if (m_msym_bunch_index == BUNCH_SIZE)
     {
@@ -1198,7 +1198,7 @@ minimal_symbol_reader::record_full (gdb::string_view name,
   else
     msymbol->m_name = name.data ();
 
-  msymbol->set_value_address (address);
+  msymbol->set_unrelocated_address (address);
   msymbol->set_section_index (section);
 
   msymbol->set_type (ms_type);

diff --git a/gdb/minsyms.h b/gdb/minsyms.h
index e9081495eb1f5d874478261a4691ccd22bad13dc..59c276f01f3d836a17f2370935a092c61fd9f13b 100644 (file)
--- a/gdb/minsyms.h
+++ b/gdb/minsyms.h
@@ -120,7 +120,7 @@ class minimal_symbol_reader
 
   struct minimal_symbol *record_full (gdb::string_view name,
                                      bool copy_name,
-                                     CORE_ADDR address,
+                                     unrelocated_addr address,
                                      enum minimal_symbol_type ms_type,
                                      int section);
 
@@ -131,7 +131,7 @@ class minimal_symbol_reader
 
      This variant does not return the new symbol.  */
 
-  void record (const char *name, CORE_ADDR address,
+  void record (const char *name, unrelocated_addr address,
               enum minimal_symbol_type ms_type);
 
   /* Like record_full, but:
@@ -140,7 +140,7 @@ class minimal_symbol_reader
 
      This variant does not return the new symbol.  */
 
-  void record_with_info (const char *name, CORE_ADDR address,
+  void record_with_info (const char *name, unrelocated_addr address,
                         enum minimal_symbol_type ms_type,
                         int section)
   {

diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 52799b926d3ad360c9bd042bddc92693273ff71d..b86bf61f4d15b2edbb244b91f3c56172f94d61d1 100644 (file)
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -436,12 +436,14 @@ mips_elf_make_msymbol_special (asymbol * sym, struct minimal_symbol *msym)
   if (ELF_ST_IS_MICROMIPS (st_other))
     {
       SET_MSYMBOL_TARGET_FLAG_MICROMIPS (msym);
-      msym->set_value_address (msym->value_raw_address () | 1);
+      CORE_ADDR fixed = CORE_ADDR (msym->value_raw_address ()) | 1;
+      msym->set_unrelocated_address (unrelocated_addr (fixed));
     }
   else if (ELF_ST_IS_MIPS16 (st_other))
     {
       SET_MSYMBOL_TARGET_FLAG_MIPS16 (msym);
-      msym->set_value_address (msym->value_raw_address () | 1);
+      CORE_ADDR fixed = CORE_ADDR (msym->value_raw_address ()) | 1;
+      msym->set_unrelocated_address (unrelocated_addr (fixed));
     }
 }
 

diff --git a/gdb/mipsread.c b/gdb/mipsread.c
index 5c2c88e81c28d5512375e50707fede2c9c1439cb..efff2841974edd1c429b85596a0d4d36a311177f 100644 (file)
--- a/gdb/mipsread.c
+++ b/gdb/mipsread.c
@@ -358,7 +358,7 @@ read_alphacoff_dynamic_symtab (minimal_symbol_reader &reader,
            }
        }
 
-      reader.record (name, sym_value, ms_type);
+      reader.record (name, unrelocated_addr (sym_value), ms_type);
     }
 }
 

diff --git a/gdb/parse.c b/gdb/parse.c
index 24db3ca57d9f3701cbd14e199ccd476fca518d98..4bce63c58f70b3c6048f5f19065ecdea88411d77 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -115,7 +115,7 @@ find_minsym_type_and_address (minimal_symbol *msymbol,
     {
       /* Addresses of TLS symbols are really offsets into a
         per-objfile/per-thread storage block.  */
-      addr = bound_msym.minsym->value_raw_address ();
+      addr = CORE_ADDR (bound_msym.minsym->value_raw_address ());
     }
   else if (msymbol_is_function (objfile, msymbol, &addr))
     {

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index ae59a14aeb15fa0acb8466f88d93c13334eddc0f..d4b3cce696fc54702f62e060c20c73e68871adf8 100644 (file)
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1824,7 +1824,7 @@ info_address_command (const char *exp, int from_tty)
            if (section
                && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
              {
-               load_addr = msym.minsym->value_raw_address ();
+               load_addr = CORE_ADDR (msym.minsym->value_raw_address ());
                gdb_printf (_("a thread-local variable at offset %s "
                              "in the thread-local storage for `%s'"),
                            paddress (gdbarch, load_addr),

diff --git a/gdb/solib.c b/gdb/solib.c
index 54f1723debfe0cb7960d89b8df01a34138c0fe4a..b6af8a15582948152fd1bd971d17d71bcb2f3401 100644 (file)
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -1515,7 +1515,7 @@ gdb_bfd_lookup_symbol_from_symtab
 
                  msym.set_value_address (symaddr);
                  gdbarch_elf_make_msymbol_special (gdbarch, sym, &msym);
-                 symaddr = msym.value_raw_address ();
+                 symaddr = CORE_ADDR (msym.value_raw_address ());
                }
 
              /* BFD symbols are section relative.  */

diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index a09b541f1b39ef3ca52bbfd4120959ce99e2c3fc..2483d317f325a53d21c03394ef081108c8805006 100644 (file)
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -201,7 +201,7 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 
       /* Use the relocated address as shown in the symbol here -- do
         not try to respect copy relocations.  */
-      CORE_ADDR addr = (msymbol->value_raw_address ()
+      CORE_ADDR addr = (CORE_ADDR (msymbol->value_raw_address ())
                        + objfile->section_offsets[msymbol->section_index ()]);
       gdb_puts (paddress (gdbarch, addr), outfile);
       gdb_printf (outfile, " %s", msymbol->linkage_name ());

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 8ab1f58affec61995dceffe5c0b6d2e616afd271..ac6535fe9834fe7ec060c274c64625280d2a352e 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -424,7 +424,7 @@ minimal_symbol::value_address (objfile *objfile) const
   if (this->maybe_copied)
     return get_msymbol_address (objfile, this);
   else
-    return (this->value_raw_address ()
+    return (CORE_ADDR (this->value_raw_address ())
            + objfile->section_offsets[this->section_index ()]);
 }
 

diff --git a/gdb/symtab.h b/gdb/symtab.h
index d1ace398fe2dd8655fb4deca9d152064ebab6018..826489c9cbc6fb0d52e0596b71bbc4f0f8e66afd 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -754,10 +754,21 @@ struct minimal_symbol : public general_symbol_info
      offsets from OBJFILE.  */
   CORE_ADDR value_address (objfile *objfile) const;
 
+  /* It does not make sense to call this for minimal symbols, as they
+     are stored unrelocated.  */
+  CORE_ADDR value_address () const = delete;
+
   /* The unrelocated address of the minimal symbol.  */
-  CORE_ADDR value_raw_address () const
+  unrelocated_addr value_raw_address () const
   {
-    return m_value.address;
+    return m_value.unrel_addr;
+  }
+
+  /* The unrelocated address just after the end of the the minimal
+     symbol.  */
+  unrelocated_addr value_raw_end_address () const
+  {
+    return unrelocated_addr (CORE_ADDR (value_raw_address ()) + size ());
   }
 
   /* Return this minimal symbol's type.  */

diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c
index cbd427f870937c43ddbd1de6890ace4947dc06f8..2a27bc3e8046fa488eca6daa2939d38fb47727eb 100644 (file)
--- a/gdb/xcoffread.c
+++ b/gdb/xcoffread.c
@@ -840,7 +840,7 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset,
 
 static void
 record_minimal_symbol (minimal_symbol_reader &reader,
-                      const char *name, CORE_ADDR address,
+                      const char *name, unrelocated_addr address,
                       enum minimal_symbol_type ms_type,
                       int n_scnum,
                       struct objfile *objfile)
@@ -2055,7 +2055,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
   unsigned int ssymnum;
 
   const char *last_csect_name = NULL; /* Last seen csect's name and value.  */
-  CORE_ADDR last_csect_val = 0;
+  unrelocated_addr last_csect_val = unrelocated_addr (0);
   int last_csect_sec = 0;
   int misc_func_recorded = 0;  /* true if any misc. function.  */
   int textlow_not_set = 1;
@@ -2168,7 +2168,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
                                       || namestring[0] == '@'))
                      {
                        last_csect_name = namestring;
-                       last_csect_val = symbol.n_value;
+                       last_csect_val = unrelocated_addr (symbol.n_value);
                        last_csect_sec = symbol.n_scnum;
                      }
                    if (pst != NULL)
@@ -2193,7 +2193,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
                       table, except for section symbols.  */
                    if (*namestring != '.')
                      record_minimal_symbol
-                       (reader, namestring, symbol.n_value,
+                       (reader, namestring, unrelocated_addr (symbol.n_value),
                         sclass == C_HIDEXT ? mst_file_data : mst_data,
                         symbol.n_scnum, objfile);
                    break;
@@ -2231,7 +2231,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
                        main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
 
                    record_minimal_symbol
-                     (reader, namestring, symbol.n_value,
+                     (reader, namestring, unrelocated_addr (symbol.n_value),
                       sclass == C_HIDEXT ? mst_file_text : mst_text,
                       symbol.n_scnum, objfile);
                    misc_func_recorded = 1;
@@ -2246,7 +2246,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
                       symbols, we will choose mst_text over
                       mst_solib_trampoline.  */
                    record_minimal_symbol
-                     (reader, namestring, symbol.n_value,
+                     (reader, namestring, unrelocated_addr (symbol.n_value),
                       mst_solib_trampoline, symbol.n_scnum, objfile);
                    misc_func_recorded = 1;
                    break;
@@ -2268,7 +2268,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
                       XMC_BS might be possible too.  */
                    if (*namestring != '.')
                      record_minimal_symbol
-                       (reader, namestring, symbol.n_value,
+                       (reader, namestring, unrelocated_addr (symbol.n_value),
                         sclass == C_HIDEXT ? mst_file_data : mst_data,
                         symbol.n_scnum, objfile);
                    break;
@@ -2284,7 +2284,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
                       table, except for section symbols.  */
                    if (*namestring != '.')
                      record_minimal_symbol
-                       (reader, namestring, symbol.n_value,
+                       (reader, namestring, unrelocated_addr (symbol.n_value),
                         sclass == C_HIDEXT ? mst_file_bss : mst_bss,
                         symbol.n_scnum, objfile);
                    break;