Index: gdb-6.5/gdb/dwarf2read.c

===================================================================

--- gdb-6.5.orig/gdb/dwarf2read.c	2006-07-11 02:47:11.000000000 -0300

+++ gdb-6.5/gdb/dwarf2read.c	2006-07-11 02:56:58.000000000 -0300

@@ -1208,7 +1208,7 @@ dwarf2_build_psymtabs (struct objfile *o

   else

     dwarf2_per_objfile->loc_buffer = NULL;

-  if (mainline

+  if ((mainline == 1)

       || (objfile->global_psymbols.size == 0

 	  && objfile->static_psymbols.size == 0))

     {

Index: gdb-6.5/gdb/auxv.c

===================================================================

--- gdb-6.5.orig/gdb/auxv.c	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/auxv.c	2006-07-11 02:47:11.000000000 -0300

@@ -119,7 +119,7 @@ target_auxv_read (struct target_ops *ops

    Return 1 if an entry was read into *TYPEP and *VALP.  */

 int

 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,

-		   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)

+		   gdb_byte *endptr, ULONGEST *typep, CORE_ADDR *valp)

 {

   const int sizeof_auxv_field = TYPE_LENGTH (builtin_type_void_data_ptr);

   gdb_byte *ptr = *readptr;

@@ -144,9 +144,10 @@ target_auxv_parse (struct target_ops *op

    an error getting the information.  On success, return 1 after

    storing the entry's value field in *VALP.  */

 int

-target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)

+target_auxv_search (struct target_ops *ops, ULONGEST match, CORE_ADDR *valp)

 {

-  CORE_ADDR type, val;

+  CORE_ADDR val;

+  ULONGEST at_type;

   gdb_byte *data;

   int n = target_auxv_read (ops, &data);

   gdb_byte *ptr = data;

@@ -156,10 +157,10 @@ target_auxv_search (struct target_ops *o

     return n;

   while (1)

-    switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))

+    switch (target_auxv_parse (ops, &ptr, data + n, &at_type, &val))

       {

       case 1:			/* Here's an entry, check it.  */

-	if (type == match)

+	if (at_type == match)

 	  {

 	    xfree (data);

 	    *valp = val;

@@ -182,7 +183,8 @@ target_auxv_search (struct target_ops *o

 int

 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)

 {

-  CORE_ADDR type, val;

+  CORE_ADDR val;

+  ULONGEST at_type;

   gdb_byte *data;

   int len = target_auxv_read (ops, &data);

   gdb_byte *ptr = data;

@@ -191,14 +193,14 @@ fprint_target_auxv (struct ui_file *file

   if (len <= 0)

     return len;

-  while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)

+  while (target_auxv_parse (ops, &ptr, data + len, &at_type, &val) > 0)

     {

       extern int addressprint;

       const char *name = "???";

       const char *description = "";

       enum { dec, hex, str } flavor = hex;

-      switch (type)

+      switch (at_type)

 	{

 #define TAG(tag, text, kind) \

 	case tag: name = #tag; description = text; flavor = kind; break

@@ -249,7 +251,7 @@ fprint_target_auxv (struct ui_file *file

 	}

       fprintf_filtered (file, "%-4s %-20s %-30s ",

-			paddr_d (type), name, description);

+			paddr_d (at_type), name, description);

       switch (flavor)

 	{

 	case dec:

Index: gdb-6.5/gdb/auxv.h

===================================================================

--- gdb-6.5.orig/gdb/auxv.h	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/auxv.h	2006-07-11 02:47:11.000000000 -0300

@@ -43,14 +43,14 @@ extern LONGEST target_auxv_read (struct 

    Return 1 if an entry was read into *TYPEP and *VALP.  */

 extern int target_auxv_parse (struct target_ops *ops,

 			      gdb_byte **readptr, gdb_byte *endptr,

-			      CORE_ADDR *typep, CORE_ADDR *valp);

+			      ULONGEST *typep, CORE_ADDR *valp);

 /* Extract the auxiliary vector entry with a_type matching MATCH.

    Return zero if no such entry was found, or -1 if there was

    an error getting the information.  On success, return 1 after

    storing the entry's value field in *VALP.  */

 extern int target_auxv_search (struct target_ops *ops,

-			       CORE_ADDR match, CORE_ADDR *valp);

+			       ULONGEST match, CORE_ADDR *valp);

 /* Print the contents of the target's AUXV on the specified file. */

 extern int fprint_target_auxv (struct ui_file *file, struct target_ops *ops);

Index: gdb-6.5/gdb/breakpoint.h

===================================================================

--- gdb-6.5.orig/gdb/breakpoint.h	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/breakpoint.h	2006-07-11 02:47:11.000000000 -0300

@@ -159,6 +159,7 @@ enum enable_state

 			   automatically enabled and reset when the call 

 			   "lands" (either completes, or stops at another 

 			   eventpoint). */

+    bp_startup_disabled,

     bp_permanent	/* There is a breakpoint instruction hard-wired into

 			   the target's code.  Don't try to write another

 			   breakpoint instruction on top of it, or restore

@@ -807,8 +808,12 @@ extern void remove_thread_event_breakpoi

 extern void disable_breakpoints_in_shlibs (int silent);

+extern void disable_breakpoints_at_startup (int silent);

+

 extern void re_enable_breakpoints_in_shlibs (void);

+void re_enable_breakpoints_at_startup (void);

+

 extern void create_solib_load_event_breakpoint (char *, int, char *, char *);

 extern void create_solib_unload_event_breakpoint (char *, int,

Index: gdb-6.5/gdb/symfile-mem.c

===================================================================

--- gdb-6.5.orig/gdb/symfile-mem.c	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/symfile-mem.c	2006-07-11 02:56:55.000000000 -0300

@@ -110,7 +110,7 @@ symbol_file_add_from_memory (struct bfd 

       }

   objf = symbol_file_add_from_bfd (nbfd, from_tty,

-                                   sai, 0, OBJF_SHARED);

+                                   sai, 2, OBJF_SHARED);

   /* This might change our ideas about frames already looked at.  */

   reinit_frame_cache ();

Index: gdb-6.5/gdb/infrun.c

===================================================================

--- gdb-6.5.orig/gdb/infrun.c	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/infrun.c	2006-07-11 02:56:58.000000000 -0300

@@ -2230,6 +2230,11 @@ process_event_stop_test:

 	     code segments in shared libraries might be mapped in now. */

 	  re_enable_breakpoints_in_shlibs ();

+	  /* For PIE executables, we dont really know where the

+	     breakpoints are going to be until we start up the

+	     inferior.  */

+          re_enable_breakpoints_at_startup ();

+

 	  /* If requested, stop when the dynamic linker notifies

 	     gdb of events.  This allows the user to get control

 	     and place breakpoints in initializer routines for

Index: gdb-6.5/gdb/objfiles.c

===================================================================

--- gdb-6.5.orig/gdb/objfiles.c	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/objfiles.c	2006-07-11 02:47:11.000000000 -0300

@@ -47,6 +47,9 @@

 #include "dictionary.h"

 #include "source.h"

+#include "auxv.h"

+#include "elf/common.h"

+

 /* Prototypes for local functions */

 static void objfile_alloc_data (struct objfile *objfile);

@@ -258,7 +261,19 @@ init_entry_point_info (struct objfile *o

 CORE_ADDR

 entry_point_address (void)

 {

-  return symfile_objfile ? symfile_objfile->ei.entry_point : 0;

+  int ret;

+  CORE_ADDR entry_addr;

+

+  /* Find the address of the entry point of the program from the

+     auxv vector.  */

+  ret = target_auxv_search (&current_target, AT_ENTRY, &entry_addr);

+  if (ret == 1)

+     return entry_addr;                                                                              

+  /*if (ret == 0 || ret == -1)*/

+  else

+    {

+      return symfile_objfile ? symfile_objfile->ei.entry_point : 0;

+    }

 }

 /* Create the terminating entry of OBJFILE's minimal symbol table.

Index: gdb-6.5/gdb/solib-svr4.c

===================================================================

--- gdb-6.5.orig/gdb/solib-svr4.c	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/solib-svr4.c	2006-07-11 02:47:11.000000000 -0300

@@ -34,6 +34,8 @@

 #include "gdbcore.h"

 #include "target.h"

 #include "inferior.h"

+#include "auxv.h"

+#include "command.h"

 #include "gdb_assert.h"

@@ -254,7 +256,9 @@ static CORE_ADDR breakpoint_addr;	/* Add

 /* Local function prototypes */

+#if 0

 static int match_main (char *);

+#endif

 static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword);

@@ -376,22 +380,79 @@ elf_locate_base (void)

 {

   struct bfd_section *dyninfo_sect;

   int dyninfo_sect_size;

-  CORE_ADDR dyninfo_addr;

+  CORE_ADDR dyninfo_addr, relocated_dyninfo_addr, entry_addr;

   gdb_byte *buf;

   gdb_byte *bufend;

   int arch_size;

+  int ret;

+

+  /* Find the address of the entry point of the program from the

+     auxv vector.  */

+  ret = target_auxv_search (&current_target, AT_ENTRY, &entry_addr);

+

+  if (ret == 0 || ret == -1)

+    {

+      /* No auxv info, maybe an older kernel. Fake our way through.  */

+      entry_addr = bfd_get_start_address (exec_bfd); 

+

+      if (debug_solib)

+	fprintf_unfiltered (gdb_stdlog,

+			    "elf_locate_base: program entry address not found. Using bfd's 0x%s for %s\n",

+			    paddr_nz (entry_addr), exec_bfd->filename);

+    }

+  else

+    {

+      if (debug_solib)

+	fprintf_unfiltered (gdb_stdlog,

+			    "elf_locate_base: found program entry address 0x%s for %s\n",

+			    paddr_nz (entry_addr), exec_bfd->filename);

+    }

   /* Find the start address of the .dynamic section.  */

   dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");

   if (dyninfo_sect == NULL)

-    return 0;

+    { 

+      if (debug_solib)

+	fprintf_unfiltered (gdb_stdlog,

+			    "elf_locate_base: .dynamic section not found in %s -- return now\n",

+			    exec_bfd->filename);

+      return 0;

+    }

+  else

+    { 

+      if (debug_solib)

+	fprintf_unfiltered (gdb_stdlog,

+			    "elf_locate_base: .dynamic section found in %s\n",

+			    exec_bfd->filename);

+    }

+

   dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);

+  if (debug_solib)

+    fprintf_unfiltered (gdb_stdlog,

+			"elf_locate_base: unrelocated .dynamic addr 0x%s\n",

+			paddr_nz (dyninfo_addr));

+

+  relocated_dyninfo_addr = dyninfo_addr

+    + entry_addr - bfd_get_start_address(exec_bfd);

+  if (debug_solib) 

+    fprintf_unfiltered (gdb_stdlog, 

+			"elf_locate_base: relocated .dyn addr 0x%s for %s\n",

+			paddr_nz(relocated_dyninfo_addr), exec_bfd->filename);

   /* Read in .dynamic section, silently ignore errors.  */

   dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);

   buf = alloca (dyninfo_sect_size);

-  if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))

-    return 0;

+  if (debug_solib) 

+    fprintf_unfiltered (gdb_stdlog, 

+                        "elf_locate_base: read in .dynamic section\n");

+  if (target_read_memory (relocated_dyninfo_addr, buf, dyninfo_sect_size))

+    { 

+      if (debug_solib)

+	fprintf_unfiltered (gdb_stdlog,

+			    "elf_locate_base: couldn't read .dynamic section at 0x%s -- return now\n",

+			    paddr_nz (relocated_dyninfo_addr));

+      return 0;

+    }

   /* Find the DT_DEBUG entry in the the .dynamic section.

      For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has

@@ -418,6 +479,10 @@ elf_locate_base (void)

 	    {

 	      dyn_ptr = bfd_h_get_32 (exec_bfd, 

 				      (bfd_byte *) x_dynp->d_un.d_ptr);

+              if (debug_solib)

+                fprintf_unfiltered (gdb_stdlog,

+				    "elf_locate_base: DT_DEBUG entry has value 0x%s -- return now\n",

+				    paddr_nz (dyn_ptr));

 	      return dyn_ptr;

 	    }

 	  else if (dyn_tag == DT_MIPS_RLD_MAP)

@@ -543,6 +608,10 @@ solib_svr4_r_map (void)

 {

   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

+  if (debug_solib)

+    fprintf_unfiltered (gdb_stdlog, 

+                        "solib_svr4_r_map: read at 0x%s\n",

+                        paddr_nz (debug_base + lmo->r_map_offset));

   return read_memory_typed_address (debug_base + lmo->r_map_offset,

 				    builtin_type_void_data_ptr);

 }

@@ -669,6 +738,11 @@ svr4_current_sos (void)

   struct so_list **link_ptr = &head;

   CORE_ADDR ldsomap = 0;

+  if (debug_solib)

+    fprintf_unfiltered (gdb_stdlog, 

+                        "svr4_current_sos: exec_bfd %s\n",

+                        exec_bfd->filename);

+

   /* Make sure we've looked up the inferior's dynamic linker's base

      structure.  */

   if (! debug_base)

@@ -678,11 +752,21 @@ svr4_current_sos (void)

       /* If we can't find the dynamic linker's base structure, this

 	 must not be a dynamically linked executable.  Hmm.  */

       if (! debug_base)

-	return 0;

+	{

+	  if (debug_solib)

+	    fprintf_unfiltered (gdb_stdlog, 

+				"svr4_current_sos: no DT_DEBUG found in %s -- return now\n",

+				exec_bfd->filename);

+	  return 0;

+	}

     }

   /* Walk the inferior's link map list, and build our list of

      `struct so_list' nodes.  */

+  if (debug_solib)

+    fprintf_unfiltered (gdb_stdlog, 

+                        "svr4_current_sos: walk link map in %s\n",

+                        exec_bfd->filename);

   lm = solib_svr4_r_map ();

   while (lm)

     {

@@ -697,23 +781,103 @@ svr4_current_sos (void)

       new->lm_info->lm = xzalloc (lmo->link_map_size);

       make_cleanup (xfree, new->lm_info->lm);

+      if (debug_solib)

+        fprintf_unfiltered (gdb_stdlog, 

+                            "svr4_current_sos: read lm at 0x%s\n", paddr_nz(lm));

       read_memory (lm, new->lm_info->lm, lmo->link_map_size);

       lm = LM_NEXT (new);

+      if (debug_solib)

+        fprintf_unfiltered (gdb_stdlog,

+                            "svr4_current_sos: is first link entry? %d\n",

+                            IGNORE_FIRST_LINK_MAP_ENTRY (new));

+

       /* For SVR4 versions, the first entry in the link map is for the

          inferior executable, so we must ignore it.  For some versions of

          SVR4, it has no name.  For others (Solaris 2.3 for example), it

          does have a name, so we can no longer use a missing name to

          decide when to ignore it. */

       if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap == 0)

-	free_so (new);

+	{

+          /* It is the first link map entry, i.e. it is the main executable.  */

+

+	  if (bfd_get_start_address (exec_bfd) == entry_point_address ())

+	    {

+              /* Non-pie case, main executable has not been relocated.  */

+	      free_so (new);

+	    }

+	  else

+	    {

+              /* Pie case, main executable has been relocated.  */

+	      struct so_list *gdb_solib;

+

+	      if (debug_solib)

+		fprintf_unfiltered (gdb_stdlog,

+				    "svr4_current_sos: Processing first link map entry\n");

+	      strncpy (new->so_name, exec_bfd->filename,

+		       SO_NAME_MAX_PATH_SIZE - 1);

+	      new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';

+	      strcpy (new->so_original_name, new->so_name);

+	      /*new->main = 1;*/

+	      new->main_relocated = 0;

+            

+	      if (debug_solib)

+		{ 

+		  fprintf_unfiltered (gdb_stdlog,

+				      "svr4_current_sos: Processing nameless DSO\n");

+		  fprintf_unfiltered (gdb_stdlog,

+				      "svr4_current_sos: adding name %s\n",

+				      new->so_name);

+		}

+

+	      for (gdb_solib = master_so_list ();

+                   gdb_solib;

+                   gdb_solib = gdb_solib->next)

+		{

+		  if (debug_solib)

+		    fprintf_unfiltered (gdb_stdlog,

+					"svr4_current_sos: compare gdb %s and new %s\n",

+					gdb_solib->so_name, new->so_name);

+		  if (strcmp (gdb_solib->so_name, new->so_name) == 0)

+		    if (gdb_solib->main_relocated)

+		      { 

+			if (debug_solib)

+			  fprintf_unfiltered (gdb_stdlog,

+					      "svr4_current_sos: found main relocated\n");

+			break;

+		      }

+		}

+

+	      if ((gdb_solib && !gdb_solib->main_relocated) || (!gdb_solib))

+		{

+		  add_to_target_sections (0 /*from_tty*/, &current_target, new);

+		  new->main = 1;

+		}

+

+	      /* We need this in the list of shared libs we return because

+		 solib_add_stub will loop through it and add the symbol file.  */

+	      new->next = 0;

+	      *link_ptr = new;

+	      link_ptr = &new->next; 

+	    }

+	} /* End of IGNORE_FIRST_LINK_MAP_ENTRY  */

       else

 	{

+          /* This is not the first link map entry, i.e. is not the main

+             executable.  Note however that it could be the DSO supplied on

+             certain systems (i.e. Linux 2.6) containing information about

+             the vsyscall page.  We must ignore such entry. This entry is 

+             nameless (just like the one for the main executable, sigh).  */

+

 	  int errcode;

 	  char *buffer;

 	  /* Extract this shared object's name.  */

+	  if (debug_solib)

+	    fprintf_unfiltered (gdb_stdlog, 

+                                "svr4_current_sos: read LM_NAME\n");

+

 	  target_read_string (LM_NAME (new), &buffer,

 			      SO_NAME_MAX_PATH_SIZE - 1, &errcode);

 	  if (errcode != 0)

@@ -721,22 +885,37 @@ svr4_current_sos (void)

 		     safe_strerror (errcode));

 	  else

 	    {

-	      strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);

-	      new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';

-	      xfree (buffer);

-	      strcpy (new->so_original_name, new->so_name);

-	    }

-

-	  /* If this entry has no name, or its name matches the name

-	     for the main executable, don't include it in the list.  */

-	  if (! new->so_name[0]

-	      || match_main (new->so_name))

-	    free_so (new);

-	  else

-	    {

-	      new->next = 0;

-	      *link_ptr = new;

-	      link_ptr = &new->next;

+              if (debug_solib)

+                fprintf_unfiltered (gdb_stdlog, 

+                                    "svr4_current_sos: LM_NAME is <%s>\n",

+                                    buffer);

+              /* The name could be empty, in which case it is the

+                 system supplied DSO.  */

+              if (strcmp (buffer, "") == 0)

+		{

+                 xfree (buffer);

+                 free_so (new);

+		}

+              else

+                {

+		  strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);

+		  new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';

+		  xfree (buffer);

+		  strcpy (new->so_original_name, new->so_name);

+		  if (debug_solib)

+		    {

+		      fprintf_unfiltered (gdb_stdlog, 

+					  "svr4_current_sos: Processing DSO: %s\n",

+					  new->so_name);

+		      fprintf_unfiltered (gdb_stdlog,

+					  "svr4_current_sos: first link entry %d\n",

+					  IGNORE_FIRST_LINK_MAP_ENTRY (new));

+		    }

+

+		  new->next = 0;

+		  *link_ptr = new;

+		  link_ptr = &new->next;

+		}

 	    }

 	}

@@ -750,6 +929,11 @@ svr4_current_sos (void)

       discard_cleanups (old_chain);

     }

+  if (debug_solib)

+    fprintf_unfiltered (gdb_stdlog, 

+                        "svr4_current_sos: ENDS %s\n",

+                        exec_bfd->filename);

+

   return head;

 }

@@ -826,7 +1010,7 @@ svr4_fetch_objfile_link_map (struct objf

 /* On some systems, the only way to recognize the link map entry for

    the main executable file is by looking at its name.  Return

    non-zero iff SONAME matches one of the known main executable names.  */

-

+#if 0

 static int

 match_main (char *soname)

 {

@@ -840,6 +1024,7 @@ match_main (char *soname)

   return (0);

 }

+#endif

 /* Return 1 if PC lies in the dynamic symbol resolution code of the

    SVR4 run time loader.  */

@@ -939,6 +1124,11 @@ enable_break (void)

   /* Find the .interp section; if not found, warn the user and drop

      into the old breakpoint at symbol code.  */

   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");

+

+  if (debug_solib)

+     fprintf_unfiltered (gdb_stdlog,

+                         "enable_break: search for .interp in %s\n",

+                         exec_bfd->filename);

   if (interp_sect)

     {

       unsigned int interp_sect_size;

@@ -972,6 +1162,9 @@ enable_break (void)

       if (tmp_fd >= 0)

 	tmp_bfd = bfd_fopen (tmp_pathname, gnutarget, FOPEN_RB, tmp_fd);

+      if (debug_solib)

+         fprintf_unfiltered (gdb_stdlog,

+                            "enable_break: opening %s\n", tmp_pathname);

       if (tmp_bfd == NULL)

 	goto bkpt_at_symbol;

@@ -1052,6 +1245,9 @@ enable_break (void)

       if (sym_addr != 0)

 	{

 	  create_solib_event_breakpoint (load_addr + sym_addr);

+          if (debug_solib)

+            fprintf_unfiltered (gdb_stdlog,

+                               "enable_break: solib bp set\n");

 	  return 1;

 	}

@@ -1311,6 +1507,8 @@ svr4_solib_create_inferior_hook (void)

   while (stop_signal != TARGET_SIGNAL_TRAP);

   stop_soon = NO_STOP_QUIETLY;

 #endif /* defined(_SCO_DS) */

+ 

+   disable_breakpoints_at_startup (1); 

 }

 static void

@@ -1493,6 +1691,75 @@ svr4_lp64_fetch_link_map_offsets (void)

   return lmp;

 }

+void

+info_linkmap_command (char *cmd, int from_tty)

+{

+  CORE_ADDR lm;

+                                                                                

+  /* Make sure we've looked up the inferior's dynamic linker's base

+     structure.  */

+  if (! debug_base)

+    {

+      debug_base = locate_base ();

+                                                                                

+      /* If we can't find the dynamic linker's base structure, this

+         must not be a dynamically linked executable.  Hmm.  */

+      if (! debug_base)

+        {

+          if (debug_solib)

+            fprintf_unfiltered (gdb_stdlog,

+                                "svr4_print_linkmap: no DT_DEBUG found in %s -- return now\n",

+                                exec_bfd->filename);

+          return;

+        }

+    }

+                                                                                

+  /* Walk the inferior's link map list, and print the info.  */

+ 

+  lm = solib_svr4_r_map ();

+  while (lm)

+    {

+      int errcode;

+      char *buffer;

+      CORE_ADDR load_addr;

+

+      struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

+      struct so_list *new

+        = (struct so_list *) xmalloc (sizeof (struct so_list));

+      struct cleanup *old_chain = make_cleanup (xfree, new);

+

+      memset (new, 0, sizeof (*new));

+

+      new->lm_info = xmalloc (sizeof (struct lm_info));

+      make_cleanup (xfree, new->lm_info);

+

+      new->lm_info->lm = xmalloc (lmo->link_map_size);

+      make_cleanup (xfree, new->lm_info->lm);

+      memset (new->lm_info->lm, 0, lmo->link_map_size);

+

+      if (debug_solib)

+        fprintf_unfiltered (gdb_stdlog,

+                            "svr4_print_linkmap: read lm at 0x%s\n", paddr_nz(lm));

+      read_memory (lm, new->lm_info->lm, lmo->link_map_size);

+

+      lm = LM_NEXT (new);

+

+      /* Load address.  */

+      load_addr = LM_ADDR_CHECK (new, NULL);

+      /* Shared object's name.  */

+      target_read_string (LM_NAME (new), &buffer,

+			  SO_NAME_MAX_PATH_SIZE - 1, &errcode);

+      make_cleanup (xfree, buffer);

+      if (errcode != 0)

+	{

+	  warning ("svr4_print_linkmap: Can't read pathname for load map: %s\n",

+		   safe_strerror (errcode));

+	}

+      fprintf_filtered (gdb_stdout, "%-8s %-30s\n", paddr(load_addr), buffer);

+      do_cleanups (old_chain);

+    }

+}                                                                                

+

 static struct target_so_ops svr4_so_ops;

@@ -1515,4 +1782,8 @@ _initialize_svr4_solib (void)

   /* FIXME: Don't do this here.  *_gdbarch_init() should set so_ops. */

   current_target_so_ops = &svr4_so_ops;

+

+  add_info ("linkmap", info_linkmap_command,

+            "Display the inferior's linkmap.");

+

 }

Index: gdb-6.5/gdb/varobj.c

===================================================================

--- gdb-6.5.orig/gdb/varobj.c	2006-07-11 02:47:06.000000000 -0300

+++ gdb-6.5/gdb/varobj.c	2006-07-11 02:56:57.000000000 -0300

@@ -870,6 +870,62 @@ varobj_list (struct varobj ***varlist)

   return rootcount;

 }

+void

+varobj_refresh (void)

+{

+  struct varobj *var;

+  struct varobj_root *croot;

+  int mycount = rootcount;

+  char * name;

+

+  croot = rootlist;

+  while ((croot != NULL) && (mycount > 0))

+    {

+      var = croot->rootvar;

+

+      /* Get rid of the memory for the old expression.  This also

+         leaves var->root->exp == NULL, which is ok for the parsing

+         below.  */

+      free_current_contents (&var->root->exp);

+

+      value_free (var->value);

+      var->type = NULL;

+

+      name = xstrdup (var->name);

+

+      /* Reparse the expression.  Wrap the call to parse expression,

+         so we can return a sensible error. */

+      if (!gdb_parse_exp_1 (&name, var->root->valid_block, 0, &var->root->exp))

+        {

+          return;

+        }

+

+      /* We definitively need to catch errors here.

+         If evaluate_expression succeeds we got the value we wanted.

+         But if it fails, we still go on with a call to evaluate_type()  */