*** empty log message ***

[deliverable/binutils-gdb.git] / gdb / solib-svr4.c

diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 3f98a1eb4338b2faefee568d5d89550b22c885a5..78311086a3d52ce86d996be67f2dbc120fe8dcd1 100644 (file)
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -197,7 +197,7 @@ bfd_lookup_symbol (bfd *abfd, char *symname)
   if (storage_needed > 0)
     {
       symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, (PTR) symbol_table);
+      back_to = make_cleanup (xfree, symbol_table);
       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 
       for (i = 0; i < number_of_symbols; i++)
@@ -224,7 +224,7 @@ bfd_lookup_symbol (bfd *abfd, char *symname)
   if (storage_needed > 0)
     {
       symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, (PTR) symbol_table);
+      back_to = make_cleanup (xfree, symbol_table);
       number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
 
       for (i = 0; i < number_of_symbols; i++)
@@ -446,15 +446,16 @@ elf_locate_base (void)
          else if (dyn_tag == DT_MIPS_RLD_MAP)
            {
              char *pbuf;
+             int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT;
 
-             pbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
+             pbuf = alloca (pbuf_size);
              /* DT_MIPS_RLD_MAP contains a pointer to the address
                 of the dynamic link structure.  */
              dyn_ptr = bfd_h_get_32 (exec_bfd, 
                                      (bfd_byte *) x_dynp->d_un.d_ptr);
-             if (target_read_memory (dyn_ptr, pbuf, sizeof (pbuf)))
+             if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
                return 0;
-             return extract_unsigned_integer (pbuf, sizeof (pbuf));
+             return extract_unsigned_integer (pbuf, pbuf_size);
            }
        }
     }
@@ -477,6 +478,20 @@ elf_locate_base (void)
                                      (bfd_byte *) x_dynp->d_un.d_ptr);
              return dyn_ptr;
            }
+         else if (dyn_tag == DT_MIPS_RLD_MAP)
+           {
+             char *pbuf;
+             int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT;
+
+             pbuf = alloca (pbuf_size);
+             /* DT_MIPS_RLD_MAP contains a pointer to the address
+                of the dynamic link structure.  */
+             dyn_ptr = bfd_h_get_64 (exec_bfd, 
+                                     (bfd_byte *) x_dynp->d_un.d_ptr);
+             if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
+               return 0;
+             return extract_unsigned_integer (pbuf, pbuf_size);
+           }
        }
     }
 
@@ -762,6 +777,77 @@ svr4_current_sos (void)
   return head;
 }
 
+/* Get the address of the link_map for a given OBJFILE.  Loop through
+   the link maps, and return the address of the one corresponding to
+   the given objfile.  Note that this function takes into account that
+   objfile can be the main executable, not just a shared library.  The
+   main executable has always an empty name field in the linkmap.  */
+
+CORE_ADDR
+svr4_fetch_objfile_link_map (struct objfile *objfile)
+{
+  CORE_ADDR lm;
+
+  if ((debug_base = locate_base ()) == 0)
+    return 0;   /* failed somehow... */
+
+  /* Position ourselves on the first link map.  */
+  lm = first_link_map_member ();  
+  while (lm)
+    {
+      /* Get info on the layout of the r_debug and link_map structures. */
+      struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
+      int errcode;
+      char *buffer;
+      struct lm_info objfile_lm_info;
+      struct cleanup *old_chain;
+      CORE_ADDR name_address;
+      char *l_name_buf = xmalloc (lmo->l_name_size);
+      old_chain = make_cleanup (xfree, l_name_buf);
+
+      /* Set up the buffer to contain the portion of the link_map
+         structure that gdb cares about.  Note that this is not the
+         whole link_map structure.  */
+      objfile_lm_info.lm = xmalloc (lmo->link_map_size);
+      make_cleanup (xfree, objfile_lm_info.lm);
+      memset (objfile_lm_info.lm, 0, lmo->link_map_size);
+
+      /* Read the link map into our internal structure.  */
+      read_memory (lm, objfile_lm_info.lm, lmo->link_map_size);
+
+      /* Read address of name from target memory to GDB.  */
+      read_memory (lm + lmo->l_name_offset, l_name_buf, lmo->l_name_size);
+
+      /* Extract this object's name.  */
+      name_address = extract_address (l_name_buf,
+                                     lmo->l_name_size);
+      target_read_string (name_address, &buffer,
+                         SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+      make_cleanup (xfree, buffer);
+      if (errcode != 0)
+       {
+         warning ("svr4_fetch_objfile_link_map: Can't read pathname for load map: %s\n",
+                  safe_strerror (errcode));
+       }
+      else
+       {
+         /* Is this the linkmap for the file we want?  */
+         /* If the file is not a shared library and has no name,
+            we are sure it is the main executable, so we return that.  */
+         if ((buffer && strcmp (buffer, objfile->name) == 0)
+              || (!(objfile->flags & OBJF_SHARED) && (strcmp (buffer, "") == 0)))
+           {
+             do_cleanups (old_chain);
+             return lm;
+           }
+       }
+      /* Not the file we wanted, continue checking.  */
+      lm = extract_address (objfile_lm_info.lm + lmo->l_next_offset,
+                           lmo->l_next_size);
+      do_cleanups (old_chain);
+    }
+  return 0;
+}
 
 /* On some systems, the only way to recognize the link map entry for
    the main executable file is by looking at its name.  Return