aboutsummaryrefslogtreecommitdiffstats
path: root/main/gdb
diff options
context:
space:
mode:
Diffstat (limited to 'main/gdb')
-rw-r--r--main/gdb/50_all_gdb-pie-1.patch1330
-rw-r--r--main/gdb/50_all_gdb-pie-2.patch2122
-rw-r--r--main/gdb/80_all_gdb-6.5-dwarf-stack-overflow.patch54
-rw-r--r--main/gdb/APKBUILD37
4 files changed, 3466 insertions, 77 deletions
diff --git a/main/gdb/50_all_gdb-pie-1.patch b/main/gdb/50_all_gdb-pie-1.patch
new file mode 100644
index 0000000000..a20771f689
--- /dev/null
+++ b/main/gdb/50_all_gdb-pie-1.patch
@@ -0,0 +1,1330 @@
+2007-11-02 Jan Kratochvil <jan.kratochvil@redhat.com>
+
+ Port to GDB-6.7.1.
+
+2007-11-02 Jan Kratochvil <jan.kratochvil@redhat.com>
+
+ Port to post-GDB-6.7.1 multi-PC breakpoints.
+
+2007-11-09 Jan Kratochvil <jan.kratochvil@redhat.com>
+
+ * solib-svr4.c (svr4_current_sos): Fix segfault on NULL EXEC_BFD.
+
+2008-02-24 Jan Kratochvil <jan.kratochvil@redhat.com>
+
+ Port to GDB-6.8pre.
+
+2008-02-27 Jan Kratochvil <jan.kratochvil@redhat.com>
+
+ Port to gdb-6.7.50.20080227.
+
+Index: gdb/dwarf2read.c
+===================================================================
+--- a/gdb/dwarf2read.c 2008-02-27 08:57:20.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/auxv.c 2008-01-16 17:27:37.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/auxv.h 2008-01-01 23:53:09.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/breakpoint.h 2008-02-01 17:24:46.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/symfile-mem.c 2008-01-01 23:53:13.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/infrun.c 2008-02-27 08:57:20.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/objfiles.c 2008-01-01 23:53:12.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/solib-svr4.c 2008-02-27 08:57:19.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/varobj.c 2008-02-04 08:49:04.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/solist.h 2008-01-07 16:19:58.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/varobj.h 2008-01-30 08:17:31.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/symfile.c 2008-01-29 23:47:20.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/breakpoint.c 2008-02-27 08:57:20.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/solib.c 2008-01-07 16:19:58.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/elfread.c 2008-01-01 23:53:09.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/Makefile.in 2008-02-27 08:57:20.000000000 +0100
++++ b/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
+===================================================================
+--- a/gdb/amd64-tdep.c 2008-02-27 08:57:19.000000000 +0100
++++ b/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;
+ }
+
diff --git a/main/gdb/50_all_gdb-pie-2.patch b/main/gdb/50_all_gdb-pie-2.patch
new file mode 100644
index 0000000000..946d055018
--- /dev/null
+++ b/main/gdb/50_all_gdb-pie-2.patch
@@ -0,0 +1,2122 @@
+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@prep.ai.mit.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@prep.ai.mit.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@prep.ai.mit.edu
++
++# This file was written by Rob Savoye. (rob@cygnus.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@prep.ai.mit.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@prep.ai.mit.edu
++
++# This file was written by Fred Fish. (fnf@cygnus.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;
++}
++
diff --git a/main/gdb/80_all_gdb-6.5-dwarf-stack-overflow.patch b/main/gdb/80_all_gdb-6.5-dwarf-stack-overflow.patch
deleted file mode 100644
index 2c3c2cbae6..0000000000
--- a/main/gdb/80_all_gdb-6.5-dwarf-stack-overflow.patch
+++ /dev/null
@@ -1,54 +0,0 @@
-http://bugs.gentoo.org/144833
-
-for gdb/ChangeLog:
-2006-08-22 Will Drewry <wad@google.com>
- Tavis Ormandy <taviso@google.com>
-
- * dwarf2read.c (decode_locdesc): Enforce location description stack
- boundaries.
- * dwarfread.c (locval): Likewise.
-
-2007-10-15 Jan Kratochvil <jan.kratochvil@redhat.com>
-
- Port to GDB-6.7.
-
-Index: gdb-6.7/gdb/dwarf2read.c
-===================================================================
---- gdb-6.7.orig/gdb/dwarf2read.c 2007-10-15 00:08:30.000000000 +0200
-+++ gdb-6.7/gdb/dwarf2read.c 2007-10-15 21:42:43.000000000 +0200
-@@ -9070,8 +9070,7 @@ dwarf2_fundamental_type (struct objfile
- callers will only want a very basic result and this can become a
- complaint.
-
-- Note that stack[0] is unused except as a default error return.
-- Note that stack overflow is not yet handled. */
-+ Note that stack[0] is unused except as a default error return. */
-
- static CORE_ADDR
- decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
-@@ -9088,7 +9087,7 @@ decode_locdesc (struct dwarf_block *blk,
-
- i = 0;
- stacki = 0;
-- stack[stacki] = 0;
-+ stack[++stacki] = 0;
-
- while (i < size)
- {
-@@ -9270,6 +9269,16 @@ decode_locdesc (struct dwarf_block *blk,
- dwarf_stack_op_name (op));
- return (stack[stacki]);
- }
-+ /* Enforce maximum stack depth of size-1 to avoid ++stacki writing
-+ outside of the allocated space. Also enforce minimum > 0.
-+ -- wad@google.com 14 Aug 2006 */
-+ if (stacki >= sizeof (stack) / sizeof (*stack) - 1)
-+ internal_error (__FILE__, __LINE__,
-+ _("location description stack too deep: %d"),
-+ stacki);
-+ if (stacki <= 0)
-+ internal_error (__FILE__, __LINE__,
-+ _("location description stack too shallow"));
- }
- return (stack[stacki]);
- }
diff --git a/main/gdb/APKBUILD b/main/gdb/APKBUILD
index 71ca88ecda..67bb5d19de 100644
--- a/main/gdb/APKBUILD
+++ b/main/gdb/APKBUILD
@@ -1,7 +1,7 @@
# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
pkgname=gdb
-pkgver=7.2
-pkgrel=0
+pkgver=6.8
+pkgrel=4
pkgdesc="The GNU Debugger"
url="http://sources.redhat.com/gdb/"
license="GPL3"
@@ -9,25 +9,19 @@ depends=
makedepends="ncurses-dev expat-dev"
subpackages="$pkgname-doc"
source="http://ftp.gnu.org/gnu/$pkgname/$pkgname-$pkgver.tar.bz2
- 80_all_gdb-6.5-dwarf-stack-overflow.patch
+ 50_all_gdb-pie-1.patch
+ 50_all_gdb-pie-2.patch
"
# patches were found here:
-# http://distfiles.gentoo.org/distfiles/gdb-7.2-patches-1.tar.xz
-_builddir="$srcdir"/$pkgname-$pkgver
-prepare() {
- cd "$_builddir"
- for i in $source; do
- case $i in
- *.patch)
- msg "Applying $i"
- patch -p1 -i "$srcdir"/$i || return 1
- ;;
- esac
+# http://distfiles.gentoo.org/distfiles/$pkgname-$pkgver-patches-1.3.tar.lzma
+
+build () {
+ cd "$srcdir/$pkgname-$pkgver"
+ for i in ../*.patch; do
+ msg "Applying $i"
+ patch -p1 < $i || return 1
done
-}
-build () {
- cd "$_builddir"
./configure --prefix=/usr \
--disable-nls \
--without-system-readline \
@@ -35,10 +29,6 @@ build () {
--mandir=/usr/share/man \
--infodir=/usr/share/info
make || return 1
-}
-
-package() {
- cd "$_builddir"
make DESTDIR="$pkgdir" install || return 1
rm -f "$pkgdir"/usr/share/info/dir
# those are provided by binutils
@@ -46,5 +36,6 @@ package() {
rm -rf "$pkgdir"/usr/lib
}
-md5sums="64260e6c56979ee750a01055f16091a5 gdb-7.2.tar.bz2
-eb81ee111ba23682d4257dad50e01de0 80_all_gdb-6.5-dwarf-stack-overflow.patch"
+md5sums="c9da266b884fb8fa54df786dfaadbc7a gdb-6.8.tar.bz2
+7d5bcb23ffbadb9ce6ac24f37003f619 50_all_gdb-pie-1.patch
+33992db76732d26c6d1a3703b52e2c94 50_all_gdb-pie-2.patch"
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-20 08:42:22 +0000