[gentoo-commits] gentoo commit in src/patchsets/gdb/6.8: 50_all_gdb-pie-1.patch 50_all_gdb-pie-2.patch README.history

[Mike Frysinger (vapier)]

vapier      08/06/21 06:44:08

  Modified:             README.history
  Added:                50_all_gdb-pie-1.patch 50_all_gdb-pie-2.patch
  Log:
  add pie patches #223533

Revision  Changes    Path
1.4                  src/patchsets/gdb/6.8/README.history

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/README.history?rev=1.4&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/README.history?rev=1.4&content-type=text/plain
diff : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/README.history?r1=1.3&r2=1.4

Index: README.history
===================================================================
RCS file: /var/cvsroot/gentoo/src/patchsets/gdb/6.8/README.history,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- README.history	7 Apr 2008 23:01:58 -0000	1.3
+++ README.history	21 Jun 2008 06:44:08 -0000	1.4
@@ -1,3 +1,7 @@
+1.3		21.06.2008
+	+ 50_all_gdb-pie-1.patch
+	+ 50_all_gdb-pie-2.patch
+
 1.2		07.04.2008
 	U 10_all_gdb-6.6-duel.patch
 	U 11_all_gdb-6.6-duel-integrate.patch



1.1                  src/patchsets/gdb/6.8/50_all_gdb-pie-1.patch

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/50_all_gdb-pie-1.patch?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/50_all_gdb-pie-1.patch?rev=1.1&content-type=text/plain

Index: 50_all_gdb-pie-1.patch
===================================================================
http://bugs.gentoo.org/223533

2007-11-02  Jan Kratochvil  <jan.kratochvil@××××××.com>

	Port to GDB-6.7.1.

2007-11-02  Jan Kratochvil  <jan.kratochvil@××××××.com>

	Port to post-GDB-6.7.1 multi-PC breakpoints.

2007-11-09  Jan Kratochvil  <jan.kratochvil@××××××.com>

	* solib-svr4.c (svr4_current_sos): Fix segfault on NULL EXEC_BFD.

2008-02-24  Jan Kratochvil  <jan.kratochvil@××××××.com>

	Port to GDB-6.8pre.

2008-02-27  Jan Kratochvil  <jan.kratochvil@××××××.com>

	Port to gdb-6.7.50.20080227.

Index: gdb/dwarf2read.c
===================================================================
--- gdb/dwarf2read.c	2008-02-27 08:57:20.000000000 +0100
+++ gdb/dwarf2read.c	2008-02-27 08:57:31.000000000 +0100
@@ -1217,7 +1217,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/auxv.c
===================================================================
--- gdb/auxv.c	2008-01-16 17:27:37.000000000 +0100
+++ gdb/auxv.c	2008-02-27 08:57:31.000000000 +0100
@@ -80,7 +80,7 @@ procfs_xfer_auxv (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;
@@ -105,9 +105,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;
   LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
   gdb_byte *ptr = data;
@@ -117,10 +118,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;
@@ -143,7 +144,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;
   LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
 				   &data);
@@ -153,14 +155,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
@@ -213,7 +215,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/auxv.h
===================================================================
--- gdb/auxv.h	2008-01-01 23:53:09.000000000 +0100
+++ gdb/auxv.h	2008-02-27 08:57:31.000000000 +0100
@@ -35,14 +35,14 @@ struct target_ops;		/* Forward declarati
    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/breakpoint.h
===================================================================
--- gdb/breakpoint.h	2008-02-01 17:24:46.000000000 +0100
+++ gdb/breakpoint.h	2008-02-27 08:57:31.000000000 +0100
@@ -144,6 +144,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
@@ -823,6 +824,10 @@ extern void remove_thread_event_breakpoi
 
 extern void disable_breakpoints_in_shlibs (void);
 
+extern void disable_breakpoints_at_startup (int silent);
+
+extern void re_enable_breakpoints_at_startup (void);
+
 /* This function returns TRUE if ep is a catchpoint. */
 extern int ep_is_catchpoint (struct breakpoint *);
 
Index: gdb/symfile-mem.c
===================================================================
--- gdb/symfile-mem.c	2008-01-01 23:53:13.000000000 +0100
+++ gdb/symfile-mem.c	2008-02-27 08:57:31.000000000 +0100
@@ -108,7 +108,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/infrun.c
===================================================================
--- gdb/infrun.c	2008-02-27 08:57:20.000000000 +0100
+++ gdb/infrun.c	2008-02-27 08:57:31.000000000 +0100
@@ -2277,6 +2277,11 @@ process_event_stop_test:
 #endif
 	  target_terminal_inferior ();
 
+	  /* 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/objfiles.c
===================================================================
--- gdb/objfiles.c	2008-01-01 23:53:12.000000000 +0100
+++ gdb/objfiles.c	2008-02-27 08:57:31.000000000 +0100
@@ -49,6 +49,9 @@
 #include "source.h"
 #include "addrmap.h"
 
+#include "auxv.h"
+#include "elf/common.h"
+
 /* Prototypes for local functions */
 
 static void objfile_alloc_data (struct objfile *objfile);
@@ -260,7 +263,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/solib-svr4.c
===================================================================
--- gdb/solib-svr4.c	2008-02-27 08:57:19.000000000 +0100
+++ gdb/solib-svr4.c	2008-02-27 08:59:06.000000000 +0100
@@ -31,6 +31,8 @@
 #include "gdbcore.h"
 #include "target.h"
 #include "inferior.h"
+#include "auxv.h"
+#include "command.h"
 
 #include "gdb_assert.h"
 
@@ -246,7 +248,9 @@ static char *debug_loader_name;
 
 /* Local function prototypes */
 
+#if 0
 static int match_main (char *);
+#endif
 
 static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
 
@@ -349,10 +353,12 @@ scan_dyntag (int dyntag, bfd *abfd, CORE
   int arch_size, step, sect_size;
   long dyn_tag;
   CORE_ADDR dyn_ptr, dyn_addr;
+  CORE_ADDR entry_addr;
   gdb_byte *bufend, *bufstart, *buf;
   Elf32_External_Dyn *x_dynp_32;
   Elf64_External_Dyn *x_dynp_64;
   struct bfd_section *sect;
+  int ret;
 
   if (abfd == NULL)
     return 0;
@@ -360,19 +366,74 @@ scan_dyntag (int dyntag, bfd *abfd, CORE
   if (arch_size == -1)
    return 0;
 
+  /* The auxv vector based relocatable files reading is limited to the main
+     executable.  */
+  gdb_assert (abfd == exec_bfd || ptr == NULL);
+
+  if (ptr != NULL)
+    {
+      /* 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.  */
   sect = bfd_get_section_by_name (abfd, ".dynamic");
   if (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);
+    }
+
   dyn_addr = bfd_section_vma (abfd, sect);
+  if (debug_solib)
+    fprintf_unfiltered (gdb_stdlog,
+			"elf_locate_base: .dynamic addr 0x%s\n",
+			paddr_nz (dyn_addr));
 
   /* Read in .dynamic from the BFD.  We will get the actual value
      from memory later.  */
   sect_size = bfd_section_size (abfd, sect);
   buf = bufstart = alloca (sect_size);
+  if (debug_solib) 
+    fprintf_unfiltered (gdb_stdlog, 
+                        "elf_locate_base: read in .dynamic section\n");
   if (!bfd_get_section_contents (abfd, sect,
 				 buf, 0, sect_size))
-    return 0;
+    { 
+      if (debug_solib)
+	fprintf_unfiltered (gdb_stdlog,
+			    "elf_locate_base: couldn't read .dynamic section -- return now\n");
+      return 0;
+    }
 
   /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */
   step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
@@ -405,9 +466,43 @@ scan_dyntag (int dyntag, bfd *abfd, CORE
 	     CORE_ADDR ptr_addr;
 
 	     ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
+	     if (ptr != NULL)
+	       {
+		 if (debug_solib)
+		   fprintf_unfiltered (gdb_stdlog,
+				       "elf_locate_base: unrelocated ptr addr 0x%s\n",
+				       paddr_nz (ptr_addr));
+		 ptr_addr += entry_addr - bfd_get_start_address (exec_bfd);
+		 if (debug_solib) 
+		   fprintf_unfiltered (gdb_stdlog, 
+				       "elf_locate_base: relocated ptr addr 0x%s"
+				       " (auxv entry 0x%s, bfd start address 0x%s)"
+				       " for %s\n",
+				       paddr_nz (ptr_addr), paddr_nz (entry_addr),
+				       paddr_nz (bfd_get_start_address (exec_bfd)),
+				       exec_bfd->filename);
+	       }
 	     if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
-	       dyn_ptr = extract_typed_address (ptr_buf,
-						builtin_type_void_data_ptr);
+	       {
+		 dyn_ptr = extract_typed_address (ptr_buf,
+						  builtin_type_void_data_ptr);
+		 if (ptr != NULL)
+		   {
+		     if (debug_solib)
+		       fprintf_unfiltered (gdb_stdlog,
+					   "elf_locate_base: Tag entry has value 0x%s -- return now\n",
+					   paddr_nz (dyn_ptr));
+		   }
+	       }
+	     else
+	       {
+		 if (ptr != NULL)
+		   {
+		     if (debug_solib)
+		       fprintf_unfiltered (gdb_stdlog,
+					   "elf_locate_base: Couldn't read tag entry value -- return now\n");
+		   }
+	       }
 	     *ptr = dyn_ptr;
 	   }
 	 return 1;
@@ -544,6 +639,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);
 }
@@ -713,6 +812,11 @@ svr4_current_sos (void)
   struct so_list *head = 0;
   struct so_list **link_ptr = &head;
   CORE_ADDR ldsomap = 0;
+  const char *filename = exec_bfd ? exec_bfd->filename : "<none>";
+
+  if (debug_solib)
+    fprintf_unfiltered (gdb_stdlog, 
+                        "svr4_current_sos: exec_bfd %s\n", filename);
 
   /* Always locate the debug struct, in case it has moved.  */
   debug_base = 0;
@@ -721,10 +825,19 @@ 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 svr4_default_sos ();
+    {
+      if (debug_solib)
+	fprintf_unfiltered (gdb_stdlog, 
+			    "svr4_current_sos: no DT_DEBUG found in %s -- return now\n",
+			    filename);
+      return svr4_default_sos ();
+    }
 
   /* 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", filename);
   lm = solib_svr4_r_map ();
 
   while (lm)
@@ -740,23 +853,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);
+      if (exec_bfd != NULL && IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap == 0)
+	{
+          /* 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)
@@ -764,23 +957,35 @@ 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';
-	      strcpy (new->so_original_name, new->so_name);
-	    }
-	  xfree (buffer);
-
-	  /* 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)
+		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';
+		  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;
+		}
 	    }
+          xfree (buffer);
 	}
 
       /* On Solaris, the dynamic linker is not in the normal list of
@@ -796,6 +1001,9 @@ svr4_current_sos (void)
   if (head == NULL)
     return svr4_default_sos ();
 
+  if (debug_solib)
+    fprintf_unfiltered (gdb_stdlog, "svr4_current_sos: ENDS %s\n", filename);
+
   return head;
 }
 
@@ -875,7 +1083,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)
 {
@@ -889,6 +1097,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.  */
@@ -1040,6 +1249,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;
@@ -1074,6 +1288,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;
 
@@ -1180,6 +1397,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;
 	}
 
@@ -1440,6 +1660,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
@@ -1620,6 +1842,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);
+    }
+}                                                                                
+
 
 
 struct target_so_ops svr4_so_ops;
@@ -1678,4 +1969,7 @@ _initialize_svr4_solib (void)
   svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
   svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
   svr4_so_ops.same = svr4_same;
+
+  add_info ("linkmap", info_linkmap_command,
+	    "Display the inferior's linkmap.");
 }
Index: gdb/varobj.c
===================================================================
--- gdb/varobj.c	2008-02-04 08:49:04.000000000 +0100
+++ gdb/varobj.c	2008-02-27 08:57:31.000000000 +0100
@@ -1078,6 +1078,62 @@ install_new_value (struct varobj *var, s
   return changed;
 }
 
+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()  */
+      if (gdb_evaluate_expression (var->root->exp, &var->value))
+        {
+          /* no error */
+          release_value (var->value);
+          if (value_lazy (var->value))
+            gdb_value_fetch_lazy (var->value);
+        }
+      else
+        var->value = evaluate_type (var->root->exp);
+
+      var->type = value_type (var->value);
+
+      mycount--;
+      croot = croot->next;
+    }
+
+  if (mycount || (croot != NULL))
+    warning
+      ("varobj_refresh: assertion failed - wrong tally of root vars (%d:%d)",
+       rootcount, mycount);
+}
+
+
 /* Update the values for a variable and its children.  This is a
    two-pronged attack.  First, re-parse the value for the root's
    expression to see if it's changed.  Then go all the way
Index: gdb/solist.h
===================================================================
--- gdb/solist.h	2008-01-07 16:19:58.000000000 +0100
+++ gdb/solist.h	2008-02-27 08:57:31.000000000 +0100
@@ -61,6 +61,8 @@ struct so_list
     bfd *abfd;
     char symbols_loaded;	/* flag: symbols read in yet? */
     char from_tty;		/* flag: print msgs? */
+    char main;                  /* flag: is this the main executable? */
+    char main_relocated;        /* flag: has it been relocated yet? */
     struct objfile *objfile;	/* objfile for loaded lib */
     struct section_table *sections;
     struct section_table *sections_end;
@@ -127,9 +129,15 @@ void free_so (struct so_list *so);
 /* Return address of first so_list entry in master shared object list.  */
 struct so_list *master_so_list (void);
 
+/* Return address of first so_list entry in master shared object list.  */
+struct so_list *master_so_list (void);
+
 /* Find solib binary file and open it.  */
 extern int solib_open (char *in_pathname, char **found_pathname);
 
+/* Add the list of sections in so_list to the target to_sections.  */
+extern void add_to_target_sections (int, struct target_ops *, struct so_list *);
+
 /* FIXME: gdbarch needs to control this variable */
 extern struct target_so_ops *current_target_so_ops;
 
@@ -140,4 +148,6 @@ struct symbol *solib_global_lookup (cons
 				    const domain_enum domain,
 				    struct symtab **symtab);
 
+/* Controls the printing of debugging output.  */
+extern int debug_solib;
 #endif
Index: gdb/varobj.h
===================================================================
--- gdb/varobj.h	2008-01-30 08:17:31.000000000 +0100
+++ gdb/varobj.h	2008-02-27 08:57:31.000000000 +0100
@@ -122,4 +122,6 @@ extern void varobj_invalidate (void);
 
 extern int varobj_editable_p (struct varobj *var);
 
+extern void varobj_refresh(void);
+
 #endif /* VAROBJ_H */
Index: gdb/symfile.c
===================================================================
--- gdb/symfile.c	2008-01-29 23:47:20.000000000 +0100
+++ gdb/symfile.c	2008-02-27 08:57:31.000000000 +0100
@@ -47,6 +47,7 @@
 #include "readline/readline.h"
 #include "gdb_assert.h"
 #include "block.h"
+#include "varobj.h"
 #include "observer.h"
 #include "exec.h"
 #include "parser-defs.h"
@@ -778,7 +779,7 @@ syms_from_objfile (struct objfile *objfi
 
   /* Now either addrs or offsets is non-zero.  */
 
-  if (mainline)
+  if (mainline == 1)
     {
       /* We will modify the main symbol table, make sure that all its users
          will be cleaned up if an error occurs during symbol reading.  */
@@ -806,7 +807,7 @@ syms_from_objfile (struct objfile *objfi
 
      We no longer warn if the lowest section is not a text segment (as
      happens for the PA64 port.  */
-  if (!mainline && addrs && addrs->other[0].name)
+  if (/*!mainline &&*/ addrs && addrs->other[0].name)
     {
       asection *lower_sect;
       asection *sect;
@@ -975,17 +976,21 @@ new_symfile_objfile (struct objfile *obj
   /* If this is the main symbol file we have to clean up all users of the
      old main symbol file. Otherwise it is sufficient to fixup all the
      breakpoints that may have been redefined by this symbol file.  */
-  if (mainline)
+  if (mainline == 1)
     {
       /* OK, make it the "real" symbol file.  */
       symfile_objfile = objfile;
 
       clear_symtab_users ();
     }
-  else
+  else if (mainline == 0)
     {
       breakpoint_re_set ();
     }
+  else
+    {
+      /* Don't reset breakpoints or it will screw up PIE.  */
+    }
 
   /* We're done reading the symbol file; finish off complaints.  */
   clear_complaints (&symfile_complaints, 0, verbo);
@@ -1028,7 +1033,7 @@ symbol_file_add_with_addrs_or_offsets (b
      interactively wiping out any existing symbols.  */
 
   if ((have_full_symbols () || have_partial_symbols ())
-      && mainline
+      && (mainline == 1)
       && from_tty
       && !query ("Load new symbol table from \"%s\"? ", name))
     error (_("Not confirmed."));
@@ -1212,6 +1217,10 @@ symbol_file_clear (int from_tty)
 		    symfile_objfile->name)
 	  : !query (_("Discard symbol table? "))))
     error (_("Not confirmed."));
+#ifdef CLEAR_SOLIB
+      CLEAR_SOLIB ();
+#endif
+
     free_all_objfiles ();
 
     /* solib descriptors may have handles to objfiles.  Since their
@@ -2466,6 +2475,8 @@ reread_symbols (void)
 	      /* Discard cleanups as symbol reading was successful.  */
 	      discard_cleanups (old_cleanups);
 
+	      init_entry_point_info (objfile);
+
 	      /* If the mtime has changed between the time we set new_modtime
 	         and now, we *want* this to be out of date, so don't call stat
 	         again now.  */
@@ -2834,6 +2845,7 @@ clear_symtab_users (void)
   breakpoint_re_set ();
   set_default_breakpoint (0, 0, 0, 0);
   clear_pc_function_cache ();
+  varobj_refresh ();
   observer_notify_new_objfile (NULL);
 
   /* Clear globals which might have pointed into a removed objfile.
Index: gdb/breakpoint.c
===================================================================
--- gdb/breakpoint.c	2008-02-27 08:57:20.000000000 +0100
+++ gdb/breakpoint.c	2008-02-27 08:57:31.000000000 +0100
@@ -923,7 +923,7 @@ update_watchpoint (struct breakpoint *b,
       value_release_to_mark (mark);
 
       /* Look at each value on the value chain.  */
-      for (; v; v = next)
+      for (; v; v = value_next (v))
 	{
 	  /* If it's a memory location, and GDB actually needed
 	     its contents to evaluate the expression, then we
@@ -3882,7 +3882,8 @@ describe_other_breakpoints (CORE_ADDR pc
 	      printf_filtered (" (thread %d)", b->thread);
 	    printf_filtered ("%s%s ",
 			     ((b->enable_state == bp_disabled || 
-			       b->enable_state == bp_call_disabled) 
+			       b->enable_state == bp_call_disabled ||
+			       b->enable_state == bp_startup_disabled)
 			      ? " (disabled)"
 			      : b->enable_state == bp_permanent 
 			      ? " (permanent)"
@@ -4534,6 +4535,62 @@ disable_breakpoints_in_unloaded_shlib (s
   }
 }
 
+void
+disable_breakpoints_at_startup (int silent)
+{
+  struct breakpoint *b;
+  int disabled_startup_breaks = 0;
+
+  if (bfd_get_start_address (exec_bfd) != entry_point_address ())
+    {
+      ALL_BREAKPOINTS (b)
+	{
+	  if (((b->type == bp_breakpoint) ||
+	       (b->type == bp_hardware_breakpoint)) &&
+	      b->enable_state == bp_enabled &&
+	      !b->loc->duplicate)
+	    {
+	      b->enable_state = bp_startup_disabled;
+	      if (!silent)
+		{
+		  if (!disabled_startup_breaks)
+		    {
+		      target_terminal_ours_for_output ();
+		      warning ("Temporarily disabling breakpoints:");
+		    }
+		  disabled_startup_breaks = 1;
+		  warning ("breakpoint #%d addr 0x%s", b->number, paddr_nz(b->loc->address));
+		}
+	    }
+	}
+    }
+}
+
+/* Try to reenable any breakpoints after startup.  */
+void
+re_enable_breakpoints_at_startup (void)
+{
+  struct breakpoint *b;
+
+  if (bfd_get_start_address (exec_bfd) != entry_point_address ())
+    {
+      ALL_BREAKPOINTS (b)
+	if (b->enable_state == bp_startup_disabled)
+	  {
+	    char buf[1];
+
+	    /* Do not reenable the breakpoint if the shared library
+	       is still not mapped in.  */
+	    if (target_read_memory (b->loc->address, buf, 1) == 0)
+	      {
+		/*printf ("enabling breakpoint at 0x%s\n", paddr_nz(b->loc->address));*/
+		b->enable_state = bp_enabled;
+	      }
+	  }
+    }
+}
+
+
 static void
 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
 				    enum bptype bp_kind)
Index: gdb/solib.c
===================================================================
--- gdb/solib.c	2008-01-07 16:19:58.000000000 +0100
+++ gdb/solib.c	2008-02-27 08:57:31.000000000 +0100
@@ -79,6 +79,8 @@ set_solib_ops (struct gdbarch *gdbarch, 
 
 /* external data declarations */
 
+int debug_solib;
+
 /* FIXME: gdbarch needs to control this variable, or else every
    configuration needs to call set_solib_ops.  */
 struct target_so_ops *current_target_so_ops;
@@ -102,6 +104,8 @@ The search path for loading non-absolute
 		    value);
 }
 
+void add_to_target_sections (int, struct target_ops *, struct so_list *);
+
 /*
 
    GLOBAL FUNCTION
@@ -391,7 +395,6 @@ free_so (struct so_list *so)
   xfree (so);
 }
 
-
 /* Return address of first so_list entry in master shared object list.  */
 struct so_list *
 master_so_list (void)
@@ -399,7 +402,6 @@ master_so_list (void)
   return so_list_head;
 }
 
-
 /* A small stub to get us past the arg-passing pinhole of catch_errors.  */
 
 static int
@@ -411,15 +413,40 @@ symbol_add_stub (void *arg)
   /* Have we already loaded this shared object?  */
   ALL_OBJFILES (so->objfile)
     {
-      if (strcmp (so->objfile->name, so->so_name) == 0)
+      /* Found an already loaded shared library.  */
+      if (strcmp (so->objfile->name, so->so_name) == 0
+          && !so->main)
 	return 1;
+      /* Found an already loaded main executable.  This could happen in
+         two circumstances. 
+         First case: the main file has already been read in
+         as the first thing that gdb does at startup, and the file
+         hasn't been relocated properly yet. Therefor we need to read
+         it in with the proper section info.
+         Second case: it has been read in with the correct relocation,
+         and therefore we need to skip it.  */
+      if (strcmp (so->objfile->name, so->so_name) == 0 
+          && so->main
+          && so->main_relocated)
+        return 1;
     }
 
   sap = build_section_addr_info_from_section_table (so->sections,
                                                     so->sections_end);
 
-  so->objfile = symbol_file_add (so->so_name, so->from_tty,
-				 sap, 0, OBJF_SHARED);
+  if (so->main)
+    {
+      if (debug_solib)
+        fprintf_unfiltered (gdb_stdlog,
+			    "symbol_add_stub: adding symbols for main\n");
+      so->objfile = symbol_file_add (so->so_name, /*so->from_tty*/ 0,
+   				     sap, 1, 0);
+      so->main_relocated = 1;
+    }
+  else
+    so->objfile = symbol_file_add (so->so_name, so->from_tty,
+				   sap, 0, OBJF_SHARED);
+
   free_section_addr_info (sap);
 
   return (1);
@@ -545,6 +572,10 @@ update_solib_list (int from_tty, struct 
 	    }
 	  else
 	    {
+	      if (debug_solib)
+		fprintf_unfiltered (gdb_stdlog,
+				    "update_solib_list: compare gdb:%s and inferior:%s\n",
+				    gdb->so_original_name, i->so_original_name);
 	      if (! strcmp (gdb->so_original_name, i->so_original_name))
 		break;	      
 	    }
@@ -599,28 +630,7 @@ update_solib_list (int from_tty, struct 
       /* Fill in the rest of each of the `struct so_list' nodes.  */
       for (i = inferior; i; i = i->next)
 	{
-	  i->from_tty = from_tty;
-
-	  /* Fill in the rest of the `struct so_list' node.  */
-	  catch_errors (solib_map_sections, i,
-			"Error while mapping shared library sections:\n",
-			RETURN_MASK_ALL);
-
-	  /* If requested, add the shared object's sections to the TARGET's
-	     section table.  Do this immediately after mapping the object so
-	     that later nodes in the list can query this object, as is needed
-	     in solib-osf.c.  */
-	  if (target)
-	    {
-	      int count = (i->sections_end - i->sections);
-	      if (count > 0)
-		{
-		  int space = target_resize_to_sections (target, count);
-		  memcpy (target->to_sections + space,
-			  i->sections,
-			  count * sizeof (i->sections[0]));
-		}
-	    }
+   	  add_to_target_sections (from_tty, target, i);
 
 	  /* Notify any observer that the shared object has been
              loaded now that we've added it to GDB's tables.  */
@@ -716,6 +726,41 @@ solib_add (char *pattern, int from_tty, 
   }
 }
 
+void
+add_to_target_sections (int from_tty, struct target_ops *target, struct so_list *solib)
+{
+  /* If this is set, then the sections have been already added to the
+     target list.  */
+  if (solib->main)
+    return;
+
+  solib->from_tty = from_tty;
+
+  /* Fill in the rest of the `struct so_list' node.  */
+  catch_errors (solib_map_sections, solib,
+		"Error while mapping shared library sections:\n",
+		RETURN_MASK_ALL);
+
+  /* If requested, add the shared object's sections to the TARGET's
+     section table.  Do this immediately after mapping the object so
+     that later nodes in the list can query this object, as is needed
+     in solib-osf.c.  */
+  if (target)
+    {
+      int count = (solib->sections_end - solib->sections);
+      if (count > 0)
+	{
+	  int space = target_resize_to_sections (target, count);
+          if (debug_solib)
+             fprintf_unfiltered (gdb_stdlog,
+                                 "add_to_target_sections: add %s to to_sections\n",
+                                 solib->so_original_name);
+	  memcpy (target->to_sections + space,
+		  solib->sections,
+		  count * sizeof (solib->sections[0]));
+	}
+    }
+}
 
 /*
 
@@ -1035,4 +1080,12 @@ This takes precedence over the environme
 				     reload_shared_libraries,
 				     show_solib_search_path,
 				     &setlist, &showlist);
+
+  add_setshow_boolean_cmd ("solib", no_class, &debug_solib,
+			   _("\
+Set debugging of GNU/Linux shlib module.\n"), _("\
+Show debugging status of GNU/Linux shlib module.\n"), _("\
+Enables printf debugging output of GNU/Linux shlib module.\n"),
+			   NULL, NULL,
+			   &setdebuglist, &showdebuglist);
 }
Index: gdb/elfread.c
===================================================================
--- gdb/elfread.c	2008-01-01 23:53:09.000000000 +0100
+++ gdb/elfread.c	2008-02-27 08:57:31.000000000 +0100
@@ -644,7 +644,7 @@ elf_symfile_read (struct objfile *objfil
   /* If we are reinitializing, or if we have never loaded syms yet,
      set table to empty.  MAINLINE is cleared so that *_read_psymtab
      functions do not all also re-initialize the psymbol table. */
-  if (mainline)
+  if (mainline == 1)
     {
       init_psymbol_list (objfile, 0);
       mainline = 0;
Index: gdb/Makefile.in
===================================================================
--- gdb/Makefile.in	2008-02-27 08:57:20.000000000 +0100
+++ gdb/Makefile.in	2008-02-27 08:57:31.000000000 +0100
@@ -1914,7 +1914,7 @@ amd64-tdep.o: amd64-tdep.c $(defs_h) $(a
 	$(dummy_frame_h) $(frame_h) $(frame_base_h) $(frame_unwind_h) \
 	$(inferior_h) $(gdbcmd_h) $(gdbcore_h) $(objfiles_h) $(regcache_h) \
 	$(regset_h) $(symfile_h) $(gdb_assert_h) $(amd64_tdep_h) \
-	$(i387_tdep_h)
+	$(i387_tdep_h) $(exceptions_h)
 annotate.o: annotate.c $(defs_h) $(annotate_h) $(value_h) $(target_h) \
 	$(gdbtypes_h) $(breakpoint_h)
 arch-utils.o: arch-utils.c $(defs_h) $(arch_utils_h) $(buildsym_h) \
Index: gdb/amd64-tdep.c
===================================================================
--- gdb/amd64-tdep.c	2008-02-27 08:57:19.000000000 +0100
+++ gdb/amd64-tdep.c	2008-02-27 08:57:31.000000000 +0100
@@ -36,6 +36,7 @@
 #include "symfile.h"
 #include "dwarf2-frame.h"
 #include "gdb_assert.h"
+#include "exceptions.h"
 
 #include "amd64-tdep.h"
 #include "i387-tdep.h"
@@ -731,16 +732,28 @@ amd64_alloc_frame_cache (void)
    Any function that doesn't start with this sequence will be assumed
    to have no prologue and thus no valid frame pointer in %rbp.  */
 
-static CORE_ADDR
-amd64_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
-			struct amd64_frame_cache *cache)
+struct amd64_analyze_prologue_data
+  {
+    CORE_ADDR pc, current_pc;
+    struct amd64_frame_cache *cache;
+    CORE_ADDR retval;
+  };
+
+static int
+amd64_analyze_prologue_1 (void *data_pointer)
 {
+  struct amd64_analyze_prologue_data *data = data_pointer;
+  CORE_ADDR pc = data->pc, current_pc = data->current_pc;
+  struct amd64_frame_cache *cache = data->cache;
   static gdb_byte proto[3] = { 0x48, 0x89, 0xe5 }; /* movq %rsp, %rbp */
   gdb_byte buf[3];
   gdb_byte op;
 
   if (current_pc <= pc)
-    return current_pc;
+    {
+      data->retval = current_pc;
+      return 1;
+    }
 
   op = read_memory_unsigned_integer (pc, 1);
 
@@ -753,18 +766,57 @@ amd64_analyze_prologue (CORE_ADDR pc, CO
 
       /* If that's all, return now.  */
       if (current_pc <= pc + 1)
-        return current_pc;
+        {
+	  data->retval = current_pc;
+	  return 1;
+        }
 
       /* Check for `movq %rsp, %rbp'.  */
       read_memory (pc + 1, buf, 3);
       if (memcmp (buf, proto, 3) != 0)
-	return pc + 1;
+	{
+	  data->retval = pc + 1;
+	  return 1;
+	}
 
       /* OK, we actually have a frame.  */
       cache->frameless_p = 0;
-      return pc + 4;
+      data->retval = pc + 4;
+      return 1;
     }
 
+  data->retval = pc;
+  return 1;
+}
+
+/* Catch memory read errors and return just PC in such case.
+   It occurs very early on enable_break->new_symfile_objfile->
+   ->breakpoint_re_set->decode_line_1->decode_variable_1->
+   ->find_function_start_sal  */
+
+static CORE_ADDR
+amd64_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
+			struct amd64_frame_cache *cache)
+{
+  int status;
+  struct amd64_analyze_prologue_data data;
+  struct ui_file *saved_gdb_stderr;
+
+  /* Suppress error messages.  */
+  saved_gdb_stderr = gdb_stderr;
+  gdb_stderr = ui_file_new ();
+
+  data.pc = pc;
+  data.current_pc = current_pc;
+  data.cache = cache;
+  status = catch_errors (amd64_analyze_prologue_1, &data, "", RETURN_MASK_ALL);
+
+  /* Stop suppressing error messages.  */
+  ui_file_delete (gdb_stderr);
+  gdb_stderr = saved_gdb_stderr;
+
+  if (status)
+    return data.retval;
   return pc;
 }
 



1.1                  src/patchsets/gdb/6.8/50_all_gdb-pie-2.patch

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/50_all_gdb-pie-2.patch?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.8/50_all_gdb-pie-2.patch?rev=1.1&content-type=text/plain

Index: 50_all_gdb-pie-2.patch
===================================================================
http://bugs.gentoo.org/223533

Index: gdb-6.8/gdb/testsuite/configure
===================================================================
--- gdb-6.8.orig/gdb/testsuite/configure	2007-12-29 06:01:30.000000000 -0800
+++ gdb-6.8/gdb/testsuite/configure	2008-03-30 09:00:52.000000000 -0700
@@ -3104,7 +3104,7 @@
 
 
 
-                                                                                                                                                                                              ac_config_files="$ac_config_files Makefile gdb.ada/Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile gdb.cp/Makefile gdb.disasm/Makefile gdb.dwarf2/Makefile gdb.fortran/Makefile gdb.server/Makefile gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile"
+                                                                                                                                                                                              ac_config_files="$ac_config_files Makefile gdb.ada/Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile gdb.cp/Makefile gdb.disasm/Makefile gdb.dwarf2/Makefile gdb.fortran/Makefile gdb.server/Makefile gdb.pie/Makefile gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile"
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
 # tests run on this system so they can be shared between configure
@@ -3665,6 +3665,7 @@
   "gdb.dwarf2/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.dwarf2/Makefile" ;;
   "gdb.fortran/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.fortran/Makefile" ;;
   "gdb.server/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.server/Makefile" ;;
+  "gdb.pie/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.pie/Makefile" ;;
   "gdb.java/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.java/Makefile" ;;
   "gdb.mi/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.mi/Makefile" ;;
   "gdb.modula2/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.modula2/Makefile" ;;
Index: gdb-6.8/gdb/testsuite/configure.ac
===================================================================
--- gdb-6.8.orig/gdb/testsuite/configure.ac	2007-10-25 13:30:26.000000000 -0700
+++ gdb-6.8/gdb/testsuite/configure.ac	2008-03-30 09:00:22.000000000 -0700
@@ -114,7 +114,7 @@
   gdb.ada/Makefile \
   gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile \
   gdb.cp/Makefile gdb.disasm/Makefile gdb.dwarf2/Makefile \
-  gdb.fortran/Makefile gdb.server/Makefile \
+  gdb.fortran/Makefile gdb.server/Makefile gdb.pie/Makefile \
   gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile \
   gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile \
   gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile])
Index: gdb-6.8/gdb/testsuite/gdb.pie/Makefile.in
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/Makefile.in	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,19 @@
+VPATH = @srcdir@
+srcdir = @srcdir@
+
+EXECUTABLES =
+MISCELLANEOUS = arch.inc
+
+all info install-info dvi install uninstall installcheck check:
+	@echo "Nothing to be done for $@..."
+
+clean mostlyclean:
+	-rm -f *~ *.o a.out *.x *.ci *.tmp
+	-rm -f core core.coremaker coremaker.core corefile $(EXECUTABLES)
+	-rm -f $(MISCELLANEOUS)
+
+distclean maintainer-clean realclean: clean
+	-rm -f *~ core
+	-rm -f Makefile config.status config.log
+	-rm -f *-init.exp
+	-rm -fr *.log summary detail *.plog *.sum *.psum site.*
Index: gdb-6.8/gdb/testsuite/gdb.pie/attach.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/attach.c	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,20 @@
+/* This program is intended to be started outside of gdb, and then
+   attached to by gdb.  Thus, it simply spins in a loop.  The loop
+   is exited when & if the variable 'should_exit' is non-zero.  (It
+   is initialized to zero in this program, so the loop will never
+   exit unless/until gdb sets the variable to non-zero.)
+   */
+#include <stdio.h>
+
+int  should_exit = 0;
+
+int main ()
+{
+  int  local_i = 0;
+
+  while (! should_exit)
+    {
+      local_i++;
+    }
+  return 0;
+}
Index: gdb-6.8/gdb/testsuite/gdb.pie/attach.exp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/attach.exp	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,432 @@
+#   Copyright 1997, 1999, 2002 Free Software Foundation, Inc.
+
+# 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@×××××××××××.edu
+
+if $tracelevel then {
+	strace $tracelevel
+	}
+
+set prms_id 0
+set bug_id 0
+
+# On HP-UX 11.0, this test is causing a process running the program
+# "attach" to be left around spinning.  Until we figure out why, I am
+# commenting out the test to avoid polluting tiamat (our 11.0 nightly
+# test machine) with these processes. RT
+#
+# Setting the magic bit in the target app should work.  I added a
+# "kill", and also a test for the R3 register warning.  JB
+if { [istarget "hppa*-*-hpux*"] } {
+    return 0
+}
+
+# are we on a target board
+if [is_remote target] then {
+    return 0
+}
+
+set testfile "attach"
+set srcfile  ${testfile}.c
+set srcfile2 ${testfile}2.c
+set binfile  ${objdir}/${subdir}/${testfile}
+set binfile2 ${objdir}/${subdir}/${testfile}2
+set escapedbinfile  [string_to_regexp ${objdir}/${subdir}/${testfile}]
+set cleanupfile ${objdir}/${subdir}/${testfile}.awk
+
+#execute_anywhere "rm -f ${binfile} ${binfile2}"
+remote_exec build "rm -f ${binfile} ${binfile2}"
+# For debugging this test
+#
+#log_user 1
+
+# Clean out any old files from past runs.
+#
+remote_exec build "${cleanupfile}"
+
+# build the first test case
+#
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug "additional_flags= -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+# Build the in-system-call test
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug "additional_flags= -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if [get_compiler_info ${binfile}] {
+    return -1
+}
+
+proc do_attach_tests {} {
+   global gdb_prompt
+   global binfile
+   global escapedbinfile
+   global srcfile
+   global testfile
+   global objdir
+   global subdir
+   global timeout
+
+   # Start the program running and then wait for a bit, to be sure
+   # that it can be attached to.
+   #
+   set testpid [eval exec $binfile &]
+   exec sleep 2
+
+   # Verify that we cannot attach to nonsense.
+   #
+   send_gdb "attach abc\n"
+   gdb_expect {
+      -re ".*Illegal process-id: abc.*$gdb_prompt $"\
+                      {pass "attach to nonsense is prohibited"}
+      -re "Attaching to.*, process .*couldn't open /proc file.*$gdb_prompt $"\
+                      {
+                        # Response expected from /proc-based systems.
+                        pass "attach to nonsense is prohibited" 
+                      }
+      -re "Attaching to.*$gdb_prompt $"\
+                      {fail "attach to nonsense is prohibited (bogus pid allowed)"}
+      -re "$gdb_prompt $" {fail "attach to nonsense is prohibited"}
+      timeout         {fail "(timeout) attach to nonsense is prohibited"}
+   }
+
+   # Verify that we cannot attach to what appears to be a valid
+   # process ID, but is a process that doesn't exist.  Traditionally,
+   # most systems didn't have a process with ID 0, so we take that as
+   # the default.  However, there are a few exceptions.
+   #
+   set boguspid 0
+   if { [istarget "*-*-*bsd*"] } {
+       # In FreeBSD 5.0, PID 0 is used for "swapper".  Use -1 instead
+       # (which should have the desired effect on any version of
+       # FreeBSD, and probably other *BSD's too).
+       set boguspid -1
+   }
+   send_gdb "attach $boguspid\n"
+   gdb_expect {
+       -re "Attaching to.*, process $boguspid.*No such process.*$gdb_prompt $"\
+	       {
+	   # Response expected on ptrace-based systems (i.e. HP-UX 10.20).
+	   pass "attach to nonexistent process is prohibited"
+       }
+       -re "Attaching to.*, process $boguspid failed.*Hint.*$gdb_prompt $"\
+	       {
+	   # Response expected on ttrace-based systems (i.e. HP-UX 11.0).
+	   pass "attach to nonexistent process is prohibited"
+       }
+       -re "Attaching to.*, process $boguspid.*denied.*$gdb_prompt $"\
+	       {pass "attach to nonexistent process is prohibited"}
+       -re "Attaching to.*, process $boguspid.*not permitted.*$gdb_prompt $"\
+	       {pass "attach to nonexistent process is prohibited"}
+       -re "Attaching to.*, process .*couldn't open /proc file.*$gdb_prompt $"\
+	       {
+	   # Response expected from /proc-based systems.
+	   pass "attach to nonexistent process is prohibited"
+       }
+       -re "$gdb_prompt $" {fail "attach to nonexistent process is prohibited"}
+       timeout {
+	   fail "(timeout) attach to nonexistent process is prohibited"
+       }
+   }
+
+   # Verify that we can attach to the process by first giving its
+   # executable name via the file command, and using attach with
+   # the process ID.
+   #
+   # (Actually, the test system appears to do this automatically
+   # for us.  So, we must also be prepared to be asked if we want
+   # to discard an existing set of symbols.)
+   #
+   send_gdb "file $binfile\n"
+   gdb_expect {
+      -re "Load new symbol table from.*y or n.*$" {
+         send_gdb "y\n"
+         gdb_expect {
+            -re "Reading symbols from $escapedbinfile\.\.\.*done.*$gdb_prompt $"\
+                            {pass "(re)set file, before attach1"}
+            -re "$gdb_prompt $" {fail "(re)set file, before attach1"}
+            timeout         {fail "(timeout) (re)set file, before attach1"}
+         }
+      }
+      -re "Reading symbols from $escapedbinfile\.\.\.*done.*$gdb_prompt $"\
+                      {pass "set file, before attach1"}
+      -re "$gdb_prompt $" {fail "set file, before attach1"}
+      timeout         {fail "(timeout) set file, before attach1"}
+   }
+
+   send_gdb "attach $testpid\n"
+   gdb_expect {
+      -re "Attaching to program.*`?$escapedbinfile'?, process $testpid.*main.*at .*$srcfile:.*$gdb_prompt $"\
+                      {pass "attach1, after setting file"}
+      -re "$gdb_prompt $" {fail "attach1, after setting file"}
+      timeout         {fail "(timeout) attach1, after setting file"}
+   }
+
+   # Verify that we can "see" the variable "should_exit" in the
+   # program, and that it is zero.
+   #
+   send_gdb "print should_exit\n"
+   gdb_expect {
+      -re ".* = 0.*$gdb_prompt $"\
+                      {pass "after attach1, print should_exit"}
+      -re "$gdb_prompt $" {fail "after attach1, print should_exit"}
+      timeout         {fail "(timeout) after attach1, print should_exit"}
+   }
+
+   # Detach the process.
+   #
+   send_gdb "detach\n"
+   gdb_expect {
+      -re "Detaching from program: .*$escapedbinfile.*$gdb_prompt $"\
+                      {pass "attach1 detach"}
+      -re "$gdb_prompt $" {fail "attach1 detach"}
+      timeout         {fail "(timeout) attach1 detach"}
+   }
+
+   # Wait a bit for gdb to finish detaching
+   #
+   exec sleep 5
+
+   # Purge the symbols from gdb's brain.  (We want to be certain
+   # the next attach, which won't be preceded by a "file" command,
+   # is really getting the executable file without our help.)
+   #
+   set old_timeout $timeout
+   set timeout 15 
+   send_gdb "file\n"
+   gdb_expect {
+      -re ".*gdb internal error.*$" { 
+          fail "Internal error, prob. Memory corruption" 
+      }
+      -re "No executable file now.*Discard symbol table.*y or n.*$" {
+         send_gdb "y\n"
+         gdb_expect {
+            -re "No symbol file now.*$gdb_prompt $"\
+                            {pass "attach1, purging symbols after detach"}
+            -re "$gdb_prompt $" {fail "attach1, purging symbols after detach"}
+            timeout         {fail "(timeout) attach1, purging symbols after detach"}
+         }
+      }
+      -re "$gdb_prompt $" {fail "attach1, purging file after detach"}
+      timeout         {
+          fail "(timeout) attach1, purging file after detach"
+      }
+   }
+   set timeout $old_timeout
+
+   # Verify that we can attach to the process just by giving the
+   # process ID.
+   #
+   send_gdb "attach $testpid\n"
+   gdb_expect {
+      -re "Attaching to process $testpid.*Reading symbols from $escapedbinfile.*main.*at .*$gdb_prompt $"\
+                      {pass "attach2"}
+      -re "$gdb_prompt $" {fail "attach2"}
+      timeout         {fail "(timeout) attach2"}
+   }
+
+   # Verify that we can modify the variable "should_exit" in the
+   # program.
+   #
+   send_gdb "set should_exit=1\n"
+   gdb_expect {
+      -re "$gdb_prompt $" {pass "after attach2, set should_exit"}
+      timeout         {fail "(timeout) after attach2, set should_exit"}
+   }
+
+   # Verify that the modification really happened.
+   #
+   send_gdb "tbreak 19\n"
+   gdb_expect {
+      -re "Breakpoint .*at.*$srcfile, line 19.*$gdb_prompt $"\
+                      {pass "after attach2, set tbreak postloop"}
+      -re "$gdb_prompt $" {fail "after attach2, set tbreak postloop"}
+      timeout         {fail "(timeout) after attach2, set tbreak postloop"}
+   }
+   send_gdb "continue\n"
+   gdb_expect {
+      -re "main.*at.*$srcfile:19.*$gdb_prompt $"\
+                      {pass "after attach2, reach tbreak postloop"}
+      -re "$gdb_prompt $" {fail "after attach2, reach tbreak postloop"}
+      timeout         {fail "(timeout) after attach2, reach tbreak postloop"}
+   }
+
+   # Allow the test process to exit, to cleanup after ourselves.
+   #
+   send_gdb "continue\n"
+   gdb_expect {
+      -re "Program exited normally.*$gdb_prompt $"\
+                      {pass "after attach2, exit"}
+      -re "$gdb_prompt $" {fail "after attach2, exit"}
+      timeout         {fail "(timeout) after attach2, exit"}
+   }
+
+   # Make sure we don't leave a process around to confuse
+   # the next test run (and prevent the compile by keeping
+   # the text file busy), in case the "set should_exit" didn't
+   # work.
+   #
+   remote_exec build "kill -9 ${testpid}"
+   # Start the program running and then wait for a bit, to be sure
+   # that it can be attached to.
+   #
+   set testpid [eval exec $binfile &]
+   exec sleep 2
+
+   # Verify that we can attach to the process, and find its a.out
+   # when we're cd'd to some directory that doesn't contain the
+   # a.out.  (We use the source path set by the "dir" command.)
+   #
+   send_gdb "dir ${objdir}/${subdir}\n"
+   gdb_expect {
+      -re ".*Source directories searched: .*$gdb_prompt $"\
+                      {pass "set source path"}
+      -re "$gdb_prompt $" {fail "set source path"}
+      timeout         {fail "(timeout) set source path"}
+   }
+
+   send_gdb "cd /tmp\n"
+   gdb_expect {
+      -re ".*Working directory /tmp.*$gdb_prompt $"\
+                      {pass "cd away from process' a.out"}
+      -re "$gdb_prompt $" {fail "cd away from process' a.out"}
+      timeout         {fail "(timeout) cd away from process' a.out"}
+   }
+
+   # Explicitly flush out any knowledge of the previous attachment.
+   send_gdb "symbol\n"
+   gdb_expect {
+      -re ".*Discard symbol table from.*y or n. $"\
+                      {send_gdb "y\n"
+                       gdb_expect {
+                          -re ".*No symbol file now.*$gdb_prompt $"\
+                                          {pass "before attach3, flush symbols"}
+                          -re "$gdb_prompt $" {fail "before attach3, flush symbols"}
+                          timeout         {fail "(timeout) before attach3, flush symbols"}
+                       }
+                      }
+      -re ".*No symbol file now.*$gdb_prompt $"\
+                      {pass "before attach3, flush symbols"}
+      -re "$gdb_prompt $" {fail "before attach3, flush symbols"}
+      timeout         {fail "(timeout) before attach3, flush symbols"}
+   }
+   send_gdb "exec\n"
+   gdb_expect {
+      -re ".*No executable file now.*$gdb_prompt $"\
+                      {pass "before attach3, flush exec"}
+      -re "$gdb_prompt $" {fail "before attach3, flush exec"}
+      timeout         {fail "(timeout) before attach3, flush exec"}
+   }
+
+   send_gdb "attach $testpid\n"
+   gdb_expect {
+      -re "Attaching to process $testpid.*Reading symbols from $escapedbinfile.*main.*at .*$gdb_prompt $"\
+                      {pass "attach when process' a.out not in cwd"}
+      -re "$gdb_prompt $" {fail "attach when process' a.out not in cwd"}
+      timeout         {fail "(timeout) attach when process' a.out not in cwd"}
+   }
+
+   send_gdb "kill\n"
+   gdb_expect {
+      -re ".*Kill the program being debugged.*y or n. $"\
+                      {send_gdb "y\n"
+                       gdb_expect {
+                          -re "$gdb_prompt $" {pass "after attach3, exit"}
+                          timeout {fail "(timeout) after attach3, exit"}
+                       }
+                      }
+      -re "$gdb_prompt $" {fail "after attach3, exit"}
+      timeout         {fail "(timeout) after attach3, exit"}
+   }
+
+   # Another "don't leave a process around"
+   remote_exec build "kill -9 ${testpid}"
+}
+
+proc do_call_attach_tests {} {
+   global gdb_prompt
+   global binfile2
+
+   # Start the program running and then wait for a bit, to be sure
+   # that it can be attached to.
+   #
+   set testpid [eval exec $binfile2 &]
+   exec sleep 2
+
+   # Attach
+   #
+   gdb_test "file $binfile2" ".*" "force switch to gdb64, if necessary"
+   send_gdb "attach $testpid\n"
+   gdb_expect {
+      -re ".*warning: reading register.*I.*O error.*$gdb_prompt $" {
+         fail "attach call, read register 3 error"
+     }
+     -re "Attaching to.*process $testpid.*libc.*$gdb_prompt $" {
+         pass "attach call"
+     }
+      -re "$gdb_prompt $" {fail "attach call"}
+      timeout         {fail "(timeout) attach call"}
+   }
+
+   # See if other registers are problems
+   #
+   send_gdb "i r r3\n"
+   gdb_expect {
+       -re ".*warning: reading register.*$gdb_prompt $" {
+           pass "CHFts23490: known bug"
+       }
+       -re ".*r3.*$gdb_prompt $" {
+           pass "Bug fixed, Yayyy!"
+       }
+       timeout { fail "timeout on info reg" }
+   }
+
+   # Get rid of the process
+   #
+   gdb_test "p should_exit = 1" ".*"
+   gdb_test "c" ".*Program exited normally.*"
+   
+   # Be paranoid
+   #
+    remote_exec build "kill -9 ${testpid}"
+
+}
+
+
+# Start with a fresh gdb
+#
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}
+
+# This is a test of gdb's ability to attach to a running process.
+#
+do_attach_tests
+
+# Test attaching when the target is inside a system call
+#
+gdb_exit
+gdb_start
+
+gdb_reinitialize_dir $srcdir/$subdir
+do_call_attach_tests
+
+return 0
Index: gdb-6.8/gdb/testsuite/gdb.pie/attach2.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/attach2.c	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,24 @@
+/* This program is intended to be started outside of gdb, and then
+   attached to by gdb.  Thus, it simply spins in a loop.  The loop
+   is exited when & if the variable 'should_exit' is non-zero.  (It
+   is initialized to zero in this program, so the loop will never
+   exit unless/until gdb sets the variable to non-zero.)
+   */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int  should_exit = 0;
+
+int main ()
+{
+  int  local_i = 0;
+
+  sleep( 10 ); /* System call causes register fetch to fail */
+               /* This is a known HPUX "feature"            */
+  while (! should_exit)
+    {
+      local_i++;
+    }
+  return (0);
+}
Index: gdb-6.8/gdb/testsuite/gdb.pie/break.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/break.c	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,146 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 1992, 1993, 1994, 1995, 1999, 2002, 2003 Free Software
+   Foundation, Inc.
+
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Please email any bugs, comments, and/or additions to this file to:
+   bug-gdb@×××××××××××.edu  */
+
+#ifdef vxworks
+
+#  include <stdio.h>
+
+/* VxWorks does not supply atoi.  */
+static int
+atoi (z)
+     char *z;
+{
+  int i = 0;
+
+  while (*z >= '0' && *z <= '9')
+    i = i * 10 + (*z++ - '0');
+  return i;
+}
+
+/* I don't know of any way to pass an array to VxWorks.  This function
+   can be called directly from gdb.  */
+
+vxmain (arg)
+char *arg;
+{
+  char *argv[2];
+
+  argv[0] = "";
+  argv[1] = arg;
+  main (2, argv, (char **) 0);
+}
+
+#else /* ! vxworks */
+#  include <stdio.h>
+#  include <stdlib.h>
+#endif /* ! vxworks */
+
+#ifdef PROTOTYPES
+extern int marker1 (void);
+extern int marker2 (int a);
+extern void marker3 (char *a, char *b);
+extern void marker4 (long d);
+#else
+extern int marker1 ();
+extern int marker2 ();
+extern void marker3 ();
+extern void marker4 ();
+#endif
+
+/*
+ *	This simple classical example of recursion is useful for
+ *	testing stack backtraces and such.
+ */
+
+#ifdef PROTOTYPES
+int factorial(int);
+
+int
+main (int argc, char **argv, char **envp)
+#else
+int
+main (argc, argv, envp)
+int argc;
+char *argv[], **envp;
+#endif
+{
+#ifdef usestubs
+    set_debug_traps();  /* set breakpoint 5 here */
+    breakpoint();
+#endif
+    if (argc == 12345) {  /* an unlikely value < 2^16, in case uninited */ /* set breakpoint 6 here */
+	fprintf (stderr, "usage:  factorial <number>\n");
+	return 1;
+    }
+    printf ("%d\n", factorial (atoi ("6")));  /* set breakpoint 1 here */
+    /* set breakpoint 12 here */
+    marker1 ();  /* set breakpoint 11 here */
+    marker2 (43); /* set breakpoint 20 here */
+    marker3 ("stack", "trace"); /* set breakpoint 21 here */
+    marker4 (177601976L);
+    argc = (argc == 12345); /* This is silly, but we can step off of it */ /* set breakpoint 2 here */
+    return argc;  /* set breakpoint 10 here */
+}
+
+#ifdef PROTOTYPES
+int factorial (int value)
+#else
+int factorial (value)
+int value;
+#endif
+{
+  if (value > 1) {  /* set breakpoint 7 here */
+	value *= factorial (value - 1);
+    }
+    return (value); /* set breakpoint 19 here */
+}
+
+#ifdef PROTOTYPES
+int multi_line_if_conditional (int a, int b, int c)
+#else
+int multi_line_if_conditional (a, b, c)
+  int a, b, c;
+#endif
+{
+  if (a    /* set breakpoint 3 here */
+      && b
+      && c)
+    return 0;
+  else
+    return 1;
+}
+
+#ifdef PROTOTYPES
+int multi_line_while_conditional (int a, int b, int c)
+#else
+int multi_line_while_conditional (a, b, c)
+  int a, b, c;
+#endif
+{
+  while (a /* set breakpoint 4 here */
+      && b
+      && c)
+    {
+      a--, b--, c--;
+    }
+  return 0;
+}
Index: gdb-6.8/gdb/testsuite/gdb.pie/break.exp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/break.exp	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,973 @@
+#   Copyright 1988, 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2002, 2003, 2004
+#   Free Software Foundation, Inc.
+
+# 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@×××××××××××.edu
+
+# This file was written by Rob Savoye. (rob@××××××.com)
+
+# Test the same stuff but with PIE executables
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+
+#
+# test running programs
+#
+set prms_id 0
+set bug_id 0
+
+set testfile "break"
+set srcfile ${testfile}.c
+set srcfile1 ${testfile}1.c
+set binfile ${objdir}/${subdir}/${testfile}
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}0.o" object {debug "additional_flags=-w -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}1.o" object {debug "additional_flags=-w -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if  { [gdb_compile "${binfile}0.o ${binfile}1.o" "${binfile}" executable {debug "additional_flags=-w -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if [get_compiler_info ${binfile}] {
+    return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}
+
+if [target_info exists gdb_stub] {
+    gdb_step_for_stub;
+}
+#
+# test simple breakpoint setting commands
+#
+
+# Test deleting all breakpoints when there are none installed,
+# GDB should not prompt for confirmation.
+# Note that gdb-init.exp provides a "delete_breakpoints" proc
+# for general use elsewhere.
+
+send_gdb "delete breakpoints\n"
+gdb_expect {
+     -re "Delete all breakpoints.*$" {
+	    send_gdb "y\n"
+	    gdb_expect {
+		-re "$gdb_prompt $" {
+		    fail "Delete all breakpoints when none (unexpected prompt)"
+		}
+		timeout	{ fail "Delete all breakpoints when none (timeout after unexpected prompt)" }
+	    }
+	}
+     -re ".*$gdb_prompt $"       { pass "Delete all breakpoints when none" }
+    timeout	            { fail "Delete all breakpoints when none (timeout)" }
+}
+
+#
+# test break at function
+#
+gdb_test "break main" \
+    "Breakpoint.*at.* file .*$srcfile, line.*" \
+    "breakpoint function"
+
+#
+# test break at quoted function
+#
+gdb_test "break \"marker2\"" \
+    "Breakpoint.*at.* file .*$srcfile1, line.*" \
+    "breakpoint quoted function"
+
+#
+# test break at function in file
+#
+gdb_test "break $srcfile:factorial" \
+    "Breakpoint.*at.* file .*$srcfile, line.*" \
+    "breakpoint function in file"
+
+set bp_location1 [gdb_get_line_number "set breakpoint 1 here"]
+
+#
+# test break at line number
+#
+# Note that the default source file is the last one whose source text
+# was printed.  For native debugging, before we've executed the
+# program, this is the file containing main, but for remote debugging,
+# it's wherever the processor was stopped when we connected to the
+# board.  So, to be sure, we do a list command.
+#
+gdb_test "list main" \
+    ".*main \\(argc, argv, envp\\).*" \
+    "use `list' to establish default source file"
+gdb_test "break $bp_location1" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location1\\." \
+    "breakpoint line number"
+
+#
+# test duplicate breakpoint
+#
+gdb_test "break $bp_location1" \
+    "Note: breakpoint \[0-9\]+ also set at pc.*Breakpoint \[0-9\]+ at.* file .*$srcfile, line $bp_location1\\." \
+    "breakpoint duplicate"
+
+set bp_location2 [gdb_get_line_number "set breakpoint 2 here"]
+
+#
+# test break at line number in file
+#
+gdb_test "break $srcfile:$bp_location2" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location2\\." \
+    "breakpoint line number in file"
+
+set bp_location3 [gdb_get_line_number "set breakpoint 3 here"]
+set bp_location4 [gdb_get_line_number "set breakpoint 4 here"]
+
+#
+# Test putting a break at the start of a multi-line if conditional.
+# Verify the breakpoint was put at the start of the conditional.
+#
+gdb_test "break multi_line_if_conditional" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location3\\." \
+    "breakpoint at start of multi line if conditional"
+
+gdb_test "break multi_line_while_conditional" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location4\\." \
+    "breakpoint at start of multi line while conditional"
+
+set bp_location5 [gdb_get_line_number "set breakpoint 5 here"]
+set bp_location6 [gdb_get_line_number "set breakpoint 6 here"]
+
+#
+# check to see what breakpoints are set
+#
+if [target_info exists gdb_stub] {
+    set main_line $bp_location5
+} else {
+    set main_line $bp_location6
+}
+
+if {$hp_aCC_compiler} {
+    set proto "\\(int\\)"
+} else {
+    set proto ""
+}
+
+set bp_location7 [gdb_get_line_number "set breakpoint 7 here"]
+set bp_location8 [gdb_get_line_number "set breakpoint 8 here" $srcfile1]
+set bp_location9 [gdb_get_line_number "set breakpoint 9 here" $srcfile1]
+
+gdb_test "info break" \
+    "Num Type\[ \]+Disp Enb Address\[ \]+What.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:$main_line.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in marker2 at .*$srcfile1:($bp_location8|$bp_location9).*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in factorial$proto at .*$srcfile:$bp_location7.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:$bp_location1.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:$bp_location1.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:$bp_location2.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in multi_line_if_conditional at .*$srcfile:$bp_location3.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in multi_line_while_conditional at .*$srcfile:$bp_location4" \
+    "breakpoint info"
+
+# FIXME: The rest of this test doesn't work with anything that can't
+# handle arguments.
+# Huh? There doesn't *appear* to be anything that passes arguments
+# below.
+if [istarget "mips-idt-*"] then {
+    return
+}
+
+#
+# run until the breakpoint at main is hit. For non-stubs-using targets.
+#
+if ![target_info exists use_gdb_stub] {
+  if [istarget "*-*-vxworks*"] then {
+    send_gdb "run vxmain \"2\"\n"
+    set timeout 120
+    verbose "Timeout is now $timeout seconds" 2
+  } else {
+	send_gdb "run\n"
+  }
+  gdb_expect {
+    -re "The program .* has been started already.*y or n. $" {
+	send_gdb "y\n"
+	exp_continue
+    }
+    -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $"\
+	                    { pass "run until function breakpoint" }
+    -re ".*$gdb_prompt $"       { fail "run until function breakpoint" }
+    timeout	            { fail "run until function breakpoint (timeout)" }
+  }
+} else {
+    if ![target_info exists gdb_stub] {
+	gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue"
+    }
+}
+
+#
+# run until the breakpoint at a line number
+#
+gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location1.*$bp_location1\[\t \]+printf.*factorial.*" \
+			"run until breakpoint set at a line number"
+
+#
+# Run until the breakpoint set in a function in a file
+#
+for {set i 6} {$i >= 1} {incr i -1} {
+	gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, factorial \\(value=$i\\) at .*$srcfile:$bp_location7.*$bp_location7\[\t \]+.*if .value > 1. \{.*" \
+			"run until file:function($i) breakpoint"
+}
+
+#
+# Run until the breakpoint set at a quoted function
+#
+gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, (0x\[0-9a-f\]+ in )?marker2 \\(a=43\\) at .*$srcfile1:($bp_location8|$bp_location9).*" \
+		"run until quoted breakpoint"
+#
+# run until the file:function breakpoint at a line number in a file
+#
+gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location2.*$bp_location2\[\t \]+argc = \\(argc == 12345\\);.*" \
+		"run until file:linenum breakpoint"
+
+# Test break at offset +1
+set bp_location10 [gdb_get_line_number "set breakpoint 10 here"]
+
+gdb_test "break +1" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location10\\." \
+    "breakpoint offset +1"
+
+# Check to see if breakpoint is hit when stepped onto
+
+gdb_test "step" \
+    ".*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location10.*$bp_location10\[\t \]+return argc;.*breakpoint 10 here.*" \
+    "step onto breakpoint"
+
+#
+# delete all breakpoints so we can start over, course this can be a test too
+#
+delete_breakpoints
+
+#
+# test temporary breakpoint at function
+#
+
+gdb_test "tbreak main" "Breakpoint.*at.* file .*$srcfile, line.*" "Temporary breakpoint function"
+
+#
+# test break at function in file
+#
+
+gdb_test "tbreak $srcfile:factorial" "Breakpoint.*at.* file .*$srcfile, line.*" \
+	"Temporary breakpoint function in file"
+
+#
+# test break at line number
+#
+send_gdb "tbreak $bp_location1\n"
+gdb_expect {
+    -re "Breakpoint.*at.* file .*$srcfile, line $bp_location1.*$gdb_prompt $" { pass "Temporary breakpoint line number #1" }
+	-re ".*$gdb_prompt $"   { pass "Temporary breakpoint line number #1" }
+	timeout	    { fail "breakpoint line number #1 (timeout)" }
+}
+
+gdb_test "tbreak $bp_location6" "Breakpoint.*at.* file .*$srcfile, line $bp_location6.*" "Temporary breakpoint line number #2"
+
+#
+# test break at line number in file
+#
+send_gdb "tbreak $srcfile:$bp_location2\n"
+gdb_expect {
+    -re "Breakpoint.*at.* file .*$srcfile, line $bp_location2.*$gdb_prompt $" { pass "Temporary breakpoint line number in file #1" }
+	-re ".*$gdb_prompt $"   { pass "Temporary breakpoint line number in file #1" }
+	timeout	    { fail "Temporary breakpoint line number in file #1 (timeout)" }
+}
+
+set bp_location11 [gdb_get_line_number "set breakpoint 11 here"]
+gdb_test  "tbreak $srcfile:$bp_location11" "Breakpoint.*at.* file .*$srcfile, line $bp_location11.*" "Temporary breakpoint line number in file #2"
+
+#
+# check to see what breakpoints are set (temporary this time)
+#
+gdb_test "info break" "Num Type.*Disp Enb Address.*What.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$main_line.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in factorial$proto at .*$srcfile:$bp_location7.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location1.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location6.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location2.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location11.*" \
+    "Temporary breakpoint info"
+
+
+#***********
+
+# Verify that catchpoints for fork, vfork and exec don't trigger
+# inappropriately.  (There are no calls to those system functions
+# in this test program.)
+#
+if ![runto_main] then { fail "break tests suppressed" }
+
+send_gdb "catch\n"
+gdb_expect {
+  -re "Catch requires an event name.*$gdb_prompt $"\
+          {pass "catch requires an event name"}
+  -re "$gdb_prompt $"\
+          {fail "catch requires an event name"}
+  timeout {fail "(timeout) catch requires an event name"}
+}
+
+
+set name "set catch fork, never expected to trigger"
+send_gdb "catch fork\n"
+gdb_expect {
+  -re "Catchpoint \[0-9\]* .fork..*$gdb_prompt $"
+          {pass $name}
+  -re "Catch of fork not yet implemented.*$gdb_prompt $"
+	  {pass $name}
+  -re "$gdb_prompt $"
+          {fail $name}
+  timeout {fail "(timeout) $name"}
+}
+
+
+set name "set catch vfork, never expected to trigger"
+send_gdb "catch vfork\n"
+
+# If we are on HP-UX 10.20, we expect an error message to be
+# printed if we type "catch vfork" at the gdb gdb_prompt.  This is
+# because on HP-UX 10.20, we cannot catch vfork events.
+
+if [istarget "hppa*-hp-hpux10.20"] then {
+    gdb_expect {
+	-re "Catch of vfork events not supported on HP-UX 10.20..*$gdb_prompt $"
+		{pass $name}
+	-re "$gdb_prompt $"
+		{fail $name}
+	timeout {fail "(timeout) $name"}
+    }
+} else {
+    gdb_expect {
+	-re "Catchpoint \[0-9\]* .vfork..*$gdb_prompt $"
+		{pass $name}
+	-re "Catch of vfork not yet implemented.*$gdb_prompt $"
+		{pass $name}
+	-re "$gdb_prompt $"
+		{fail $name}
+	timeout {fail "(timeout) $name"}
+    }
+}
+
+set name "set catch exec, never expected to trigger"
+send_gdb "catch exec\n"
+gdb_expect {
+  -re "Catchpoint \[0-9\]* .exec..*$gdb_prompt $"
+          {pass $name}
+  -re "Catch of exec not yet implemented.*$gdb_prompt $"
+	  {pass $name}
+  -re "$gdb_prompt $" {fail $name}
+  timeout {fail "(timeout) $name"}
+}
+
+# Verify that GDB responds gracefully when asked to set a breakpoint
+# on a nonexistent source line.
+#
+send_gdb "break 999\n"
+gdb_expect {
+  -re "No line 999 in file .*$gdb_prompt $"\
+          {pass "break on non-existent source line"}
+  -re "$gdb_prompt $"\
+          {fail "break on non-existent source line"}
+  timeout {fail "(timeout) break on non-existent source line"}
+}
+
+# Run to the desired default location. If not positioned here, the
+# tests below don't work.
+#
+gdb_test "until $bp_location1" "main .* at .*:$bp_location1.*" "until bp_location1"
+
+
+# Verify that GDB allows one to just say "break", which is treated
+# as the "default" breakpoint.  Note that GDB gets cute when printing
+# the informational message about other breakpoints at the same
+# location.  We'll hit that bird with this stone too.
+#
+send_gdb "break\n"
+gdb_expect {
+  -re "Breakpoint \[0-9\]*.*$gdb_prompt $"\
+          {pass "break on default location, 1st time"}
+  -re "$gdb_prompt $"\
+          {fail "break on default location, 1st time"}
+  timeout {fail "(timeout) break on default location, 1st time"}
+}
+
+send_gdb "break\n"
+gdb_expect {
+  -re "Note: breakpoint \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
+          {pass "break on default location, 2nd time"}
+  -re "$gdb_prompt $"\
+          {fail "break on default location, 2nd time"}
+  timeout {fail "(timeout) break on default location, 2nd time"}
+}
+
+send_gdb "break\n"
+gdb_expect {
+  -re "Note: breakpoints \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
+          {pass "break on default location, 3rd time"}
+  -re "$gdb_prompt $"\
+          {fail "break on default location, 3rd time"}
+  timeout {fail "(timeout) break on default location, 3rd time"}
+}
+
+send_gdb "break\n"
+gdb_expect {
+  -re "Note: breakpoints \[0-9\]*, \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
+          {pass "break on default location, 4th time"}
+  -re "$gdb_prompt $"\
+          {fail "break on default location, 4th time"}
+  timeout {fail "(timeout) break on default location, 4th time"}
+}
+
+# Verify that a "silent" breakpoint can be set, and that GDB is indeed
+# "silent" about its triggering.
+#
+if ![runto_main] then { fail "break tests suppressed" }
+
+send_gdb "break $bp_location1\n"
+gdb_expect {
+  -re "Breakpoint (\[0-9\]*) at .*, line $bp_location1.*$gdb_prompt $"\
+          {pass "set to-be-silent break bp_location1"}
+  -re "$gdb_prompt $"\
+          {fail "set to-be-silent break bp_location1"}
+  timeout {fail "(timeout) set to-be-silent break bp_location1"}
+}
+
+send_gdb "commands $expect_out(1,string)\n"
+send_gdb "silent\n"
+send_gdb "end\n"
+gdb_expect {
+  -re ".*$gdb_prompt $"\
+          {pass "set silent break bp_location1"}
+  timeout {fail "(timeout) set silent break bp_location1"}
+}
+
+send_gdb "info break $expect_out(1,string)\n"
+gdb_expect {
+  -re "\[0-9\]*\[ \t\]*breakpoint.*:$bp_location1\r\n\[ \t\]*silent.*$gdb_prompt $"\
+          {pass "info silent break bp_location1"}
+  -re "$gdb_prompt $"\
+          {fail "info silent break bp_location1"}
+  timeout {fail "(timeout) info silent break bp_location1"}
+}
+send_gdb "continue\n"
+gdb_expect {
+  -re "Continuing.\r\n$gdb_prompt $"\
+          {pass "hit silent break bp_location1"}
+  -re "$gdb_prompt $"\
+          {fail "hit silent break bp_location1"}
+  timeout {fail "(timeout) hit silent break bp_location1"}
+}
+send_gdb "bt\n"
+gdb_expect {
+  -re "#0  main .* at .*:$bp_location1.*$gdb_prompt $"\
+          {pass "stopped for silent break bp_location1"}
+  -re "$gdb_prompt $"\
+          {fail "stopped for silent break bp_location1"}
+  timeout {fail "(timeout) stopped for silent break bp_location1"}
+}
+
+# Verify that GDB can at least parse a breakpoint with the
+# "thread" keyword.  (We won't attempt to test here that a
+# thread-specific breakpoint really triggers appropriately.
+# The gdb.threads subdirectory contains tests for that.)
+#
+set bp_location12 [gdb_get_line_number "set breakpoint 12 here"]
+send_gdb "break $bp_location12 thread 999\n"
+gdb_expect {
+  -re "Unknown thread 999.*$gdb_prompt $"\
+          {pass "thread-specific breakpoint on non-existent thread disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "thread-specific breakpoint on non-existent thread disallowed"}
+  timeout {fail "(timeout) thread-specific breakpoint on non-existent thread disallowed"}
+}
+send_gdb "break $bp_location12 thread foo\n"
+gdb_expect {
+  -re "Junk after thread keyword..*$gdb_prompt $"\
+          {pass "thread-specific breakpoint on bogus thread ID disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "thread-specific breakpoint on bogus thread ID disallowed"}
+  timeout {fail "(timeout) thread-specific breakpoint on bogus thread ID disallowed"}
+}
+
+# Verify that GDB responds gracefully to a breakpoint command with
+# trailing garbage.
+#
+send_gdb "break $bp_location12 foo\n"
+gdb_expect {
+  -re "Junk at end of arguments..*$gdb_prompt $"\
+          {pass "breakpoint with trailing garbage disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "breakpoint with trailing garbage disallowed"}
+  timeout {fail "(timeout) breakpoint with trailing garbage disallowed"}
+}
+
+# Verify that GDB responds gracefully to a "clear" command that has
+# no matching breakpoint.  (First, get us off the current source line,
+# which we know has a breakpoint.)
+#
+send_gdb "next\n"
+gdb_expect {
+  -re ".*$gdb_prompt $"\
+          {pass "step over breakpoint"}
+  timeout {fail "(timeout) step over breakpoint"}
+}
+send_gdb "clear 81\n"
+gdb_expect {
+  -re "No breakpoint at 81..*$gdb_prompt $"\
+          {pass "clear line has no breakpoint disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "clear line has no breakpoint disallowed"}
+  timeout {fail "(timeout) clear line has no breakpoint disallowed"}
+}
+send_gdb "clear\n"
+gdb_expect {
+  -re "No breakpoint at this line..*$gdb_prompt $"\
+          {pass "clear current line has no breakpoint disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "clear current line has no breakpoint disallowed"}
+  timeout {fail "(timeout) clear current line has no breakpoint disallowed"}
+}
+
+# Verify that we can set and clear multiple breakpoints.
+#
+# We don't test that it deletes the correct breakpoints.  We do at
+# least test that it deletes more than one breakpoint.
+#
+gdb_test "break marker3" "Breakpoint.*at.*" "break marker3 #1"
+gdb_test "break marker3" "Breakpoint.*at.*" "break marker3 #2"
+gdb_test "clear marker3" {Deleted breakpoints [0-9]+ [0-9]+.*}
+
+# Verify that a breakpoint can be set via a convenience variable.
+#
+send_gdb "set \$foo=$bp_location11\n"
+gdb_expect {
+  -re "$gdb_prompt $"\
+          {pass "set convenience variable \$foo to bp_location11"}
+  timeout {fail "(timeout) set convenience variable \$foo to bp_location11"}
+}
+send_gdb "break \$foo\n"
+gdb_expect {
+  -re "Breakpoint (\[0-9\]*) at .*, line $bp_location11.*$gdb_prompt $"\
+          {pass "set breakpoint via convenience variable"}
+  -re "$gdb_prompt $"\
+          {fail "set breakpoint via convenience variable"}
+  timeout {fail "(timeout) set breakpoint via convenience variable"}
+}
+
+# Verify that GDB responds gracefully to an attempt to set a
+# breakpoint via a convenience variable whose type is not integer.
+#
+send_gdb "set \$foo=81.5\n"
+gdb_expect {
+  -re "$gdb_prompt $"\
+          {pass "set convenience variable \$foo to 81.5"}
+  timeout {fail "(timeout) set convenience variable \$foo to 81.5"}
+}
+send_gdb "break \$foo\n"
+gdb_expect {
+  -re "Convenience variables used in line specs must have integer values..*$gdb_prompt $"\
+          {pass "set breakpoint via non-integer convenience variable disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "set breakpoint via non-integer convenience variable disallowed"}
+  timeout {fail "(timeout) set breakpoint via non-integer convenience variable disallowed"}
+}
+
+# Verify that we can set and trigger a breakpoint in a user-called function.
+#
+send_gdb "break marker2\n"
+gdb_expect {
+    -re "Breakpoint (\[0-9\]*) at .*, line ($bp_location8|$bp_location9).*$gdb_prompt $"\
+          {pass "set breakpoint on to-be-called function"}
+  -re "$gdb_prompt $"\
+          {fail "set breakpoint on to-be-called function"}
+  timeout {fail "(timeout) set breakpoint on to-be-called function"}
+}
+send_gdb "print marker2(99)\n"
+gdb_expect {
+  -re "The program being debugged stopped while in a function called from GDB.\r\nWhen the function .marker2$proto. is done executing, GDB will silently\r\nstop .instead of continuing to evaluate the expression containing\r\nthe function call...*$gdb_prompt $"\
+          {pass "hit breakpoint on called function"}
+  -re "$gdb_prompt $"\
+          {fail "hit breakpoint on called function"}
+  timeout {fail "(timeout) hit breakpoint on called function"}
+}
+
+# As long as we're stopped (breakpointed) in a called function,
+# verify that we can successfully backtrace & such from here.
+#
+# In this and the following test, the _sr4export check apparently is needed
+# for hppa*-*-hpux.
+#
+send_gdb "bt\n"
+gdb_expect {
+    -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*_sr4export.*$gdb_prompt $"\
+            {pass "backtrace while in called function"}
+    -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*function called from gdb.*$gdb_prompt $"\
+	    {pass "backtrace while in called function"}
+    -re "$gdb_prompt $"\
+            {fail "backtrace while in called function"}
+    timeout {fail "(timeout) backtrace while in called function"}
+}
+
+# Return from the called function.  For remote targets, it's important to do
+# this before runto_main, which otherwise may silently stop on the dummy
+# breakpoint inserted by GDB at the program's entry point.
+#
+send_gdb "finish\n"
+gdb_expect {
+    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.* in _sr4export.*$gdb_prompt $"\
+            {pass "finish from called function"}
+    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*function called from gdb.*$gdb_prompt $"\
+            {pass "finish from called function"}
+    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*Value returned.*$gdb_prompt $"\
+            {pass "finish from called function"}
+    -re "$gdb_prompt $"\
+            {fail "finish from called function"}
+    timeout {fail "(timeout) finish from called function"}
+}
+
+# Verify that GDB responds gracefully to a "finish" command with
+# arguments.
+#
+if ![runto_main] then { fail "break tests suppressed" }
+
+send_gdb "finish 123\n"
+gdb_expect {
+  -re "The \"finish\" command does not take any arguments.\r\n$gdb_prompt $"\
+          {pass "finish with arguments disallowed"}
+  -re "$gdb_prompt $"\
+          {fail "finish with arguments disallowed"}
+  timeout {fail "(timeout) finish with arguments disallowed"}
+}
+
+# Verify that GDB responds gracefully to a request to "finish" from
+# the outermost frame.  On a stub that never exits, this will just
+# run to the stubs routine, so we don't get this error...  Thus the 
+# second condition.
+#
+
+send_gdb "finish\n"
+gdb_expect {
+  -re "\"finish\" not meaningful in the outermost frame.\r\n$gdb_prompt $"\
+          {pass "finish from outermost frame disallowed"}
+  -re "Run till exit from.*\r\n$gdb_prompt $" {
+     pass "finish from outermost frame disallowed"
+  }
+  -re "$gdb_prompt $"\
+          {fail "finish from outermost frame disallowed"}
+  timeout {fail "(timeout) finish from outermost frame disallowed"}
+}
+
+# Verify that we can explicitly ask GDB to stop on all shared library
+# events, and that it does so.
+#
+if [istarget "hppa*-*-hpux*"] then {
+  if ![runto_main] then { fail "break tests suppressed" }
+
+  send_gdb "set stop-on-solib-events 1\n"
+  gdb_expect {
+    -re "$gdb_prompt $"\
+            {pass "set stop-on-solib-events"}
+    timeout {fail "(timeout) set stop-on-solib-events"}
+  }
+
+  send_gdb "run\n"
+  gdb_expect {
+    -re ".*Start it from the beginning.*y or n. $"\
+            {send_gdb "y\n"
+             gdb_expect {
+               -re ".*Stopped due to shared library event.*$gdb_prompt $"\
+                       {pass "triggered stop-on-solib-events"}
+               -re "$gdb_prompt $"\
+                       {fail "triggered stop-on-solib-events"}
+               timeout {fail "(timeout) triggered stop-on-solib-events"}
+             }
+            }
+    -re "$gdb_prompt $"\
+            {fail "rerun for stop-on-solib-events"}
+    timeout {fail "(timeout) rerun for stop-on-solib-events"}
+  }
+
+  send_gdb "set stop-on-solib-events 0\n"
+  gdb_expect {
+    -re "$gdb_prompt $"\
+            {pass "reset stop-on-solib-events"}
+    timeout {fail "(timeout) reset stop-on-solib-events"}
+  }
+}
+
+# Hardware breakpoints are unsupported on HP-UX.  Verify that GDB
+# gracefully responds to requests to create them.
+#
+if [istarget "hppa*-*-hpux*"] then {
+  if ![runto_main] then { fail "break tests suppressed" }
+
+  send_gdb "hbreak\n"
+  gdb_expect {
+    -re "No hardware breakpoint support in the target.*$gdb_prompt $"\
+            {pass "hw breaks disallowed"}
+    -re "$gdb_prompt $"\
+            {fail "hw breaks disallowed"}
+    timeout {fail "(timeout) hw breaks disallowed"}
+  }
+
+  send_gdb "thbreak\n"
+  gdb_expect {
+    -re "No hardware breakpoint support in the target.*$gdb_prompt $"\
+            {pass "temporary hw breaks disallowed"}
+    -re "$gdb_prompt $"\
+            {fail "temporary hw breaks disallowed"}
+    timeout {fail "(timeout) temporary hw breaks disallowed"}
+  }
+}
+
+#********
+
+
+#
+# Test "next" over recursive function call.
+#
+
+proc test_next_with_recursion {} { 
+    global gdb_prompt
+    global decimal
+    global binfile
+
+    if [target_info exists use_gdb_stub] {
+	# Reload the program.
+	delete_breakpoints
+	gdb_load ${binfile};
+    } else {
+	# FIXME: should be using runto
+	gdb_test "kill" "" "kill program" "Kill the program being debugged.*y or n. $" "y"
+
+	delete_breakpoints
+    }
+
+    gdb_test "break factorial" "Breakpoint $decimal at .*" "break at factorial"
+
+    # Run until we call factorial with 6
+
+    if [istarget "*-*-vxworks*"] then {
+	send_gdb "run vxmain \"6\"\n"
+    } else {
+	gdb_run_cmd
+    }
+    gdb_expect {
+	-re "Break.* factorial .value=6. .*$gdb_prompt $" {}
+	-re ".*$gdb_prompt $" {
+	    fail "run to factorial(6)";
+	    gdb_suppress_tests;
+	}
+	timeout { fail "run to factorial(6) (timeout)" ; gdb_suppress_tests }
+    }
+
+    # Continue until we call factorial recursively with 5.
+
+    if [gdb_test "continue" \
+	"Continuing.*Break.* factorial .value=5. .*" \
+	"continue to factorial(5)"] then { gdb_suppress_tests }
+
+    # Do a backtrace just to confirm how many levels deep we are.
+
+    if [gdb_test "backtrace" \
+	"#0\[ \t\]+ factorial .value=5..*" \
+	"backtrace from factorial(5)"] then { gdb_suppress_tests }
+
+    # Now a "next" should position us at the recursive call, which
+    # we will be performing with 4.
+
+    if [gdb_test "next" \
+	".* factorial .value - 1.;.*" \
+	"next to recursive call"] then { gdb_suppress_tests }
+
+    # Disable the breakpoint at the entry to factorial by deleting them all.
+    # The "next" should run until we return to the next line from this
+    # recursive call to factorial with 4.
+    # Buggy versions of gdb will stop instead at the innermost frame on
+    # the line where we are trying to "next" to.
+
+    delete_breakpoints
+
+    if [istarget "mips*tx39-*"] {
+	set timeout 60
+    }
+    # We used to set timeout here for all other targets as well.  This
+    # is almost certainly wrong.  The proper timeout depends on the
+    # target system in use, and how we communicate with it, so there
+    # is no single value appropriate for all targets.  The timeout
+    # should be established by the Dejagnu config file(s) for the
+    # board, and respected by the test suite.
+    #
+    # For example, if I'm running GDB over an SSH tunnel talking to a
+    # portmaster in California talking to an ancient 68k board running
+    # a crummy ROM monitor (a situation I can only wish were
+    # hypothetical), then I need a large timeout.  But that's not the
+    # kind of knowledge that belongs in this file.
+
+    gdb_test next "\[0-9\]*\[\t \]+return \\(value\\);.*" \
+	    "next over recursive call"
+
+    # OK, we should be back in the same stack frame we started from.
+    # Do a backtrace just to confirm.
+
+    set result [gdb_test "backtrace" \
+	    "#0\[ \t\]+ factorial .value=120.*\r\n#1\[ \t\]+ \[0-9a-fx\]+ in factorial .value=6..*" \
+	    "backtrace from factorial(5.1)"]
+    if { $result != 0 } { gdb_suppress_tests }
+
+    if [target_info exists gdb,noresults] { gdb_suppress_tests }
+  gdb_continue_to_end "recursive next test"
+   gdb_stop_suppressing_tests;
+}
+
+test_next_with_recursion
+
+
+#********
+
+# build a new file with optimization enabled so that we can try breakpoints
+# on targets with optimized prologues
+
+set binfileo2 ${objdir}/${subdir}/${testfile}o2
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}O0.o" object {debug "additional_flags=-w -O2 -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}O1.o" object {debug "additional_flags=-w -O2 -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if  { [gdb_compile "${binfile}O0.o ${binfile}O1.o" "${binfileo2}" executable {debug "additional_flags=-w -fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+if [get_compiler_info ${binfileo2}] {
+    return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfileo2}
+
+if [target_info exists gdb_stub] {
+    gdb_step_for_stub;
+}
+
+#
+# test break at function
+#
+gdb_test "break main" \
+    "Breakpoint.*at.* file .*$srcfile, line.*" \
+    "breakpoint function, optimized file"
+
+#
+# test break at function
+#
+gdb_test "break marker4" \
+    "Breakpoint.*at.* file .*$srcfile1, line.*" \
+    "breakpoint small function, optimized file"
+
+#
+# run until the breakpoint at main is hit. For non-stubs-using targets.
+#
+if ![target_info exists use_gdb_stub] {
+  if [istarget "*-*-vxworks*"] then {
+    send_gdb "run vxmain \"2\"\n"
+    set timeout 120
+    verbose "Timeout is now $timeout seconds" 2
+  } else {
+	send_gdb "run\n"
+  }
+  gdb_expect {
+    -re "The program .* has been started already.*y or n. $" {
+	send_gdb "y\n"
+	exp_continue
+    }
+    -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $"\
+	                    { pass "run until function breakpoint, optimized file" }
+    -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $"\
+	                    { pass "run until function breakpoint, optimized file (code motion)" }
+    -re ".*$gdb_prompt $"       { fail "run until function breakpoint, optimized file" }
+    timeout	            { fail "run until function breakpoint, optimized file (timeout)" }
+  }
+} else {
+    if ![target_info exists gdb_stub] {
+	gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue, optimized file"
+    }
+}
+
+#
+# run until the breakpoint at a small function
+#
+
+#
+# Add a second pass pattern.  The behavior differs here between stabs
+# and dwarf for one-line functions.  Stabs preserves two line symbols
+# (one before the prologue and one after) with the same line number, 
+# but dwarf regards these as duplicates and discards one of them.
+# Therefore the address after the prologue (where the breakpoint is)
+# has no exactly matching line symbol, and GDB reports the breakpoint
+# as if it were in the middle of a line rather than at the beginning.
+
+set bp_location13 [gdb_get_line_number "set breakpoint 13 here" $srcfile1]
+set bp_location14 [gdb_get_line_number "set breakpoint 14 here" $srcfile1]
+send_gdb "continue\n"
+gdb_expect {
+    -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
+	pass "run until breakpoint set at small function, optimized file"
+    }
+    -re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
+	pass "run until breakpoint set at small function, optimized file"
+    }
+    -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*" {
+        # marker4() is defined at line 46 when compiled with -DPROTOTYPES
+	pass "run until breakpoint set at small function, optimized file (line bp_location14)"
+    }
+    -re ".*$gdb_prompt " {
+	fail "run until breakpoint set at small function, optimized file"
+    }
+    timeout {
+	fail "run until breakpoint set at small function, optimized file (timeout)"
+    }
+}
+
+
+# Reset the default arguments for VxWorks
+if [istarget "*-*-vxworks*"] {
+    set timeout 10
+    verbose "Timeout is now $timeout seconds" 2
+    send_gdb "set args main\n"
+    gdb_expect -re ".*$gdb_prompt $" {}
+}
Index: gdb-6.8/gdb/testsuite/gdb.pie/break1.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/break1.c	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,44 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 1992, 1993, 1994, 1995, 1999, 2002, 2003 Free Software
+   Foundation, Inc.
+
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Please email any bugs, comments, and/or additions to this file to:
+   bug-gdb@×××××××××××.edu  */
+
+/* The code for this file was extracted from the gdb testsuite
+   testcase "break.c". */
+
+/* The following functions do nothing useful.  They are included
+   simply as places to try setting breakpoints at.  They are
+   explicitly "one-line functions" to verify that this case works
+   (some versions of gcc have or have had problems with this).
+  
+   These functions are in a separate source file to prevent an
+   optimizing compiler from inlining them and optimizing them away. */
+
+#ifdef PROTOTYPES
+int marker1 (void) { return (0); }	/* set breakpoint 15 here */
+int marker2 (int a) { return (1); }	/* set breakpoint 8 here */
+void marker3 (char *a, char *b) {}	/* set breakpoint 17 here */
+void marker4 (long d) {}		/* set breakpoint 14 here */
+#else
+int marker1 () { return (0); }		/* set breakpoint 16 here */
+int marker2 (a) int a; { return (1); }	/* set breakpoint 9 here */
+void marker3 (a, b) char *a, *b; {}	/* set breakpoint 18 here */
+void marker4 (d) long d; {}		/* set breakpoint 13 here */
+#endif
Index: gdb-6.8/gdb/testsuite/gdb.pie/corefile.exp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/corefile.exp	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,243 @@
+# Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+# Free Software Foundation, Inc.
+
+# 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@×××××××××××.edu
+
+# This file was written by Fred Fish. (fnf@××××××.com)
+
+if $tracelevel then {
+	strace $tracelevel
+}
+
+set prms_id 0
+set bug_id 0
+
+# are we on a target board
+if ![isnative] then {
+    return
+}
+
+set testfile "coremaker"
+set srcfile ${testfile}.c
+set binfile ${objdir}/${subdir}/${testfile}
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug "additional_flags=-fpie -pie"}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+# Create and source the file that provides information about the compiler
+# used to compile the test case.
+if [get_compiler_info ${binfile}] {
+    return -1;
+}
+
+# Create a core file named "corefile" rather than just "core", to
+# avoid problems with sys admin types that like to regularly prune all
+# files named "core" from the system.
+#
+# Arbitrarily try setting the core size limit to "unlimited" since
+# this does not hurt on systems where the command does not work and
+# allows us to generate a core on systems where it does.
+#
+# Some systems append "core" to the name of the program; others append
+# the name of the program to "core"; still others (like Linux, as of
+# May 2003) create cores named "core.PID".  In the latter case, we
+# could have many core files lying around, and it may be difficult to
+# tell which one is ours, so let's run the program in a subdirectory.
+set found 0
+set coredir "${objdir}/${subdir}/coredir.[getpid]"
+file mkdir $coredir
+catch "system \"(cd ${coredir}; ulimit -c unlimited; ${binfile}; true) >/dev/null 2>&1\""
+#      remote_exec host "${binfile}"
+foreach i "${coredir}/core ${coredir}/core.coremaker.c ${binfile}.core" {
+    if [remote_file build exists $i] {
+	remote_exec build "mv $i ${objdir}/${subdir}/corefile"
+	set found 1
+    }
+}
+# Check for "core.PID".
+if { $found == 0 } {
+    set names [glob -nocomplain -directory $coredir core.*]
+    if {[llength $names] == 1} {
+        set corefile [file join $coredir [lindex $names 0]]
+        remote_exec build "mv $corefile ${objdir}/${subdir}/corefile"
+        set found 1
+    }
+}
+if { $found == 0 } {
+    # The braindamaged HPUX shell quits after the ulimit -c above
+    # without executing ${binfile}.  So we try again without the
+    # ulimit here if we didn't find a core file above.
+    # Oh, I should mention that any "braindamaged" non-Unix system has
+    # the same problem. I like the cd bit too, it's really neat'n stuff.
+    catch "system \"(cd ${objdir}/${subdir}; ${binfile}; true) >/dev/null 2>&1\""
+    foreach i "${objdir}/${subdir}/core ${objdir}/${subdir}/core.coremaker.c ${binfile}.core" {
+	if [remote_file build exists $i] {
+	    remote_exec build "mv $i ${objdir}/${subdir}/corefile"
+	    set found 1
+	}
+    }
+}
+
+# Try to clean up after ourselves. 
+remote_file build delete [file join $coredir coremmap.data]
+remote_exec build "rmdir $coredir"
+    
+if { $found == 0  } {
+    warning "can't generate a core file - core tests suppressed - check ulimit -c"
+    return 0
+}
+
+#
+# Test that we can simply startup with a "-core=corefile" command line arg
+# and recognize that the core file is a valid, usable core file.
+# To do this, we must shutdown the currently running gdb and restart
+# with the -core args.  We can't use gdb_start because it looks for
+# the first gdb prompt, and the message we are looking for occurs
+# before the first prompt.  Also, we can't include GDBFLAGS because
+# if it is empty, this confuses gdb with an empty argument that it
+# grumbles about (said grumbling currently being ignored in gdb_start).
+# **FIXME**
+#
+# Another problem is that on some systems (solaris for example), there
+# is apparently a limit on the length of a fully specified path to 
+# the coremaker executable, at about 80 chars.  For this case, consider
+# it a pass, but note that the program name is bad.
+
+gdb_exit
+if $verbose>1 then {
+    send_user "Spawning $GDB -nw $GDBFLAGS -core=$objdir/$subdir/corefile\n"
+}
+
+set oldtimeout $timeout
+set timeout [expr "$timeout + 60"]
+verbose "Timeout is now $timeout seconds" 2
+eval "spawn $GDB -nw $GDBFLAGS -core=$objdir/$subdir/corefile"
+expect {
+    -re "Couldn't find .* registers in core file.*$gdb_prompt $" {
+        fail "args: -core=corefile (couldn't find regs)"
+    }
+    -re "Core was generated by .*coremaker.*\r\n\#0  .*\(\).*\r\n$gdb_prompt $" {
+	pass "args: -core=corefile"
+    }
+    -re "Core was generated by .*\r\n\#0  .*\(\).*\r\n$gdb_prompt $" {
+	pass "args: -core=corefile (with bad program name)"
+    }
+    -re ".*registers from core file: File in wrong format.* $" {
+	fail "args: -core=corefile (could not read registers from core file)"
+    }
+    -re ".*$gdb_prompt $"	{ fail "args: -core=corefile" }
+    timeout 		{ fail "(timeout) starting with -core" }
+}
+
+
+#
+# Test that startup with both an executable file and -core argument.
+# See previous comments above, they are still applicable.
+#
+
+close;
+
+if $verbose>1 then {
+    send_user "Spawning $GDB -nw $GDBFLAGS $binfile -core=$objdir/$subdir/corefile\n"
+}
+
+
+eval "spawn $GDB -nw $GDBFLAGS $binfile -core=$objdir/$subdir/corefile";
+expect {
+    -re "Core was generated by .*coremaker.*\r\n\#0  .*\(\).*\r\n$gdb_prompt $" {
+	pass "args: execfile -core=corefile"
+    }
+    -re "Core was generated by .*\r\n\#0  .*\(\).*\r\n$gdb_prompt $"	 {
+	pass "args: execfile -core=corefile (with bad program name)"
+    }
+    -re ".*registers from core file: File in wrong format.* $" {
+	fail "args: execfile -core=corefile (could not read registers from core file)"
+    }
+    -re ".*$gdb_prompt $"	{ fail "args: execfile -core=corefile" }
+    timeout 		{ fail "(timeout) starting with -core" }
+}
+set timeout $oldtimeout
+verbose "Timeout is now $timeout seconds" 2
+
+close;
+
+# Now restart normally.
+
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}
+
+# Test basic corefile recognition via core-file command.
+
+send_gdb "core-file $objdir/$subdir/corefile\n"
+gdb_expect {
+    -re ".* program is being debugged already.*y or n. $" {
+	# gdb_load may connect us to a gdbserver.
+	send_gdb "y\n"
+	exp_continue;
+    }
+    -re "Core was generated by .*coremaker.*\r\n\#0  .*\(\).*\r\n$gdb_prompt $" {
+	pass "core-file command"
+    }
+    -re "Core was generated by .*\r\n\#0  .*\(\).*\r\n$gdb_prompt $" {
+	pass "core-file command (with bad program name)"
+    }
+    -re ".*registers from core file: File in wrong format.* $" {
+	fail "core-file command (could not read registers from core file)"
+    }
+    -re ".*$gdb_prompt $"	{ fail "core-file command" }
+    timeout 		{ fail "(timeout) core-file command" }
+}
+
+# Test correct mapping of corefile sections by printing some variables.
+
+gdb_test "print coremaker_data" "\\\$$decimal = 202"
+gdb_test "print coremaker_bss" "\\\$$decimal = 10"
+gdb_test "print coremaker_ro" "\\\$$decimal = 201"
+
+gdb_test "print func2::coremaker_local" "\\\$$decimal = \\{0, 1, 2, 3, 4\\}"
+
+# Somehow we better test the ability to read the registers out of the core
+# file correctly.  I don't think the other tests do this.
+
+gdb_test "bt" "abort.*func2.*func1.*main.*" "backtrace in corefile.exp"
+gdb_test "up" "#\[0-9\]* *\[0-9xa-fH'\]* in .* \\(.*\\).*" "up in corefile.exp"
+
+# Test ability to read mmap'd data
+
+gdb_test "x/8bd buf1" ".*:.*0.*1.*2.*3.*4.*5.*6.*7" "accessing original mmap data in core file"
+setup_xfail "*-*-sunos*" "*-*-ultrix*" "*-*-aix*"
+set test "accessing mmapped data in core file"
+gdb_test_multiple "x/8bd buf2" "$test" {
+    -re ".*:.*0.*1.*2.*3.*4.*5.*6.*7.*$gdb_prompt $" {
+	pass "$test"
+    }
+    -re "0x\[f\]*:.*Cannot access memory at address 0x\[f\]*.*$gdb_prompt $" {
+	fail "$test (mapping failed at runtime)"
+    }
+    -re "0x.*:.*Cannot access memory at address 0x.*$gdb_prompt $" {
+	fail "$test (mapping address not found in core file)"
+    }
+}
+
+# test reinit_frame_cache
+
+gdb_load ${binfile}
+gdb_test "up" "#\[0-9\]* *\[0-9xa-fH'\]* in .* \\(\\).*" "up in corefile.exp (reinit)"
+
+gdb_test "core" "No core file now."
Index: gdb-6.8/gdb/testsuite/gdb.pie/coremaker.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-6.8/gdb/testsuite/gdb.pie/coremaker.c	2008-03-30 08:59:12.000000000 -0700
@@ -0,0 +1,142 @@
+/* Copyright 1992, 1993, 1994, 1995, 1996, 1999
+   Free Software Foundation, Inc.
+
+   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
+   the Free Software Foundation; either version 2 of the License, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* Simple little program that just generates a core dump from inside some
+   nested function calls. */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#ifndef __STDC__
+#define	const	/**/
+#endif
+
+#define MAPSIZE (8 * 1024)
+
+/* Don't make these automatic vars or we will have to walk back up the
+   stack to access them. */
+
+char *buf1;
+char *buf2;
+
+int coremaker_data = 1;	/* In Data section */
+int coremaker_bss;	/* In BSS section */
+
+const int coremaker_ro = 201;	/* In Read-Only Data section */
+
+/* Note that if the mapping fails for any reason, we set buf2
+   to -1 and the testsuite notices this and reports it as
+   a failure due to a mapping error.  This way we don't have
+   to test for specific errors when running the core maker. */
+
+void
+mmapdata ()
+{
+  int j, fd;
+
+  /* Allocate and initialize a buffer that will be used to write
+     the file that is later mapped in. */
+
+  buf1 = (char *) malloc (MAPSIZE);
+  for (j = 0; j < MAPSIZE; ++j)
+    {
+      buf1[j] = j;
+    }
+
+  /* Write the file to map in */
+
+  fd = open ("coremmap.data", O_CREAT | O_RDWR, 0666);
+  if (fd == -1)
+    {
+      perror ("coremmap.data open failed");
+      buf2 = (char *) -1;
+      return;
+    }
+  write (fd, buf1, MAPSIZE);
+
+  /* Now map the file into our address space as buf2 */
+
+  buf2 = (char *) mmap (0, MAPSIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+  if (buf2 == (char *) -1)
+    {
+      perror ("mmap failed");
+      return;
+    }
+
+  /* Verify that the original data and the mapped data are identical.
+     If not, we'd rather fail now than when trying to access the mapped
+     data from the core file. */
+
+  for (j = 0; j < MAPSIZE; ++j)
+    {
+      if (buf1[j] != buf2[j])
+	{
+	  fprintf (stderr, "mapped data is incorrect");
+	  buf2 = (char *) -1;
+	  return;
+	}
+    }
+}
+
+void
+func2 ()
+{
+  int coremaker_local[5];
+  int i;
+
+#ifdef SA_FULLDUMP
+  /* Force a corefile that includes the data section for AIX.  */
+  {
+    struct sigaction sa;
+
+    sigaction (SIGABRT, (struct sigaction *)0, &sa);
+    sa.sa_flags |= SA_FULLDUMP;
+    sigaction (SIGABRT, &sa, (struct sigaction *)0);
+  }
+#endif
+
+  /* Make sure that coremaker_local doesn't get optimized away. */
+  for (i = 0; i < 5; i++)
+    coremaker_local[i] = i;
+  coremaker_bss = 0;
+  for (i = 0; i < 5; i++)
+    coremaker_bss += coremaker_local[i];
+  coremaker_data = coremaker_ro + 1;
+  abort ();
+}
+
+void
+func1 ()
+{
+  func2 ();
+}
+
+int main ()
+{
+  mmapdata ();
+  func1 ();
+  return 0;
+}
+



-- 
gentoo-commits@l.g.o mailing list