Blob Blame History Raw
2005-01-20  Jeff Johnston  <jjohnstn@redhat.com>

	* symtab.h (find_line_pc): Change prototype to new api
	which returns a list of pc values and the number of list elements.
	* symtab.c (find_line_pc): Change function to new api which
	returns a list of pc values.  Support recognizing a base ctor
	or dtor and finding an additional pc value for the in-charge
	ctor or dtor accordingly.
	(find_line_common): Change api to accept a start_index argument
	which determines where to start searching from in the line table.
	(find_line_by_pc): New function.
	* breakpoint.c (resolve_sal_pc_list): New function.
	(breakpoint_sals_to_pc): Support multiple pc values for a
	line in a ctor/dtor.
	(gdb_breakpoint): Change call to find_line_pc to use new api.
	(break_command_1): Move resolve_sals_to_pc earlier due to the
	fact it now can extend the sal list.
	* mi/mi-cmd-disas.c (mi_cmd_disassemble): Change call to
	find_line_pc to new api.
	* tui/tui-layout.c (extract_display_start_addr): Ditto.
	* tui/tui-win.c (make_visible_with_new_height): Ditto.
	* tui/tui-winsource.c (tui_update_source_windows_with_addr): Ditto.

2007-09-22  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* symtab.c (find_line_pc): Support also the `$allocate' and `$delete'
	variants.  Support searching for the `$base' name even if the bare name
	was found first.
	* breakpoint.c (breakpoint_sals_to_pc): Support more than two returned
	PC values.

2007-09-25  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* breakpoint.c (breakpoint_sals_to_pc): New parameter ADDR_STRING_P.
	Expand also *ADDR_STRING_P if multiple PCs were found.
	(break_command_1, do_captured_breakpoint): Pass also the ADDR_STRING
	variable to be updated.

2007-10-05  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* breakpoint.c (breakpoint_sals_to_pc): Provide "%42" suffix to the
	multiple-PC breakpoints' ADDR_STRINGs.
	(breakpoint_re_set_one): New variables ID_S, ID, PC_LIST, NUM_PC_VALUES.
	Parse the "%42" suffix of the multiple-PC breakpoints's ADDR_STRINGs.

2007-10-14  Jan Kratochvil  <jan.kratochvil@redhat.com>

	Port to GDB-6.7.

Index: gdb-6.7/gdb/mi/mi-cmd-disas.c
===================================================================
--- gdb-6.7.orig/gdb/mi/mi-cmd-disas.c	2007-08-23 20:08:48.000000000 +0200
+++ gdb-6.7/gdb/mi/mi-cmd-disas.c	2007-10-14 23:26:23.000000000 +0200
@@ -143,11 +143,18 @@ mi_cmd_disassemble (char *command, char 
 
   if (line_seen && file_seen)
     {
+      CORE_ADDR *pc_list;
+      int num_pc_values;
+
       s = lookup_symtab (file_string);
       if (s == NULL)
 	error (_("mi_cmd_disassemble: Invalid filename."));
-      if (!find_line_pc (s, line_num, &start))
+      if (!find_line_pc (s, line_num, &pc_list, &num_pc_values))
 	error (_("mi_cmd_disassemble: Invalid line number"));
+      /* FIXME: What do we do with multiple pc values for ctors/dtors
+                under mi?  */
+      start = pc_list[0];
+      xfree (pc_list);
       if (find_pc_partial_function (start, NULL, &low, &high) == 0)
 	error (_("mi_cmd_disassemble: No function contains specified address"));
     }
Index: gdb-6.7/gdb/tui/tui-layout.c
===================================================================
--- gdb-6.7.orig/gdb/tui/tui-layout.c	2007-08-23 20:08:50.000000000 +0200
+++ gdb-6.7/gdb/tui/tui-layout.c	2007-10-14 23:26:23.000000000 +0200
@@ -516,7 +516,8 @@ extract_display_start_addr (void)
 {
   enum tui_layout_type cur_layout = tui_current_layout ();
   CORE_ADDR addr;
-  CORE_ADDR pc;
+  CORE_ADDR *pc_list;
+  int num_pc_values;
   struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 
   switch (cur_layout)
@@ -525,8 +526,11 @@ extract_display_start_addr (void)
     case SRC_DATA_COMMAND:
       find_line_pc (cursal.symtab,
 		    TUI_SRC_WIN->detail.source_info.start_line_or_addr.u.line_no,
-		    &pc);
-      addr = pc;
+		    &pc_list, &num_pc_values);
+      /* FIXME: What do we do with multiple pc values for ctors/dtors or
+                inlined functions?  */
+      addr = pc_list[0];
+      xfree (pc_list);
       break;
     case DISASSEM_COMMAND:
     case SRC_DISASSEM_COMMAND:
Index: gdb-6.7/gdb/tui/tui-win.c
===================================================================
--- gdb-6.7.orig/gdb/tui/tui-win.c	2007-08-23 20:08:50.000000000 +0200
+++ gdb-6.7/gdb/tui/tui-win.c	2007-10-14 23:26:23.000000000 +0200
@@ -1359,8 +1359,16 @@ make_visible_with_new_height (struct tui
 	    }
 	  else
 	    {
+              CORE_ADDR *pc_list;
+              int num_pc_values;
 	      line.loa = LOA_ADDRESS;
-	      find_line_pc (s, cursal.line, &line.u.addr);
+	      if (find_line_pc (s, cursal.line, &pc_list, &num_pc_values))
+                {
+                  /* FIXME: What do we do with multiple pc values for
+                            ctors/dtors and inlined functions?  */
+                  line.u.addr = pc_list[0];
+                  xfree (pc_list);
+                }
 	    }
 	  tui_update_source_window (win_info, s, line, TRUE);
 	}
Index: gdb-6.7/gdb/tui/tui-winsource.c
===================================================================
--- gdb-6.7.orig/gdb/tui/tui-winsource.c	2007-08-23 20:08:50.000000000 +0200
+++ gdb-6.7/gdb/tui/tui-winsource.c	2007-10-14 23:26:23.000000000 +0200
@@ -173,14 +173,21 @@ tui_update_source_windows_with_addr (COR
 void
 tui_update_source_windows_with_line (struct symtab *s, int line)
 {
-  CORE_ADDR pc;
+  CORE_ADDR pc = 0;
+  CORE_ADDR *pc_list;
+  int num_pc_values;
   struct tui_line_or_address l;
   
   switch (tui_current_layout ())
     {
     case DISASSEM_COMMAND:
     case DISASSEM_DATA_COMMAND:
-      find_line_pc (s, line, &pc);
+      /* FIXME: What do we do with multiple pc values for ctors/dtors?  */
+      if (find_line_pc (s, line, &pc_list, &num_pc_values))
+        {
+          pc = pc_list[0];
+          xfree (pc_list);
+        }
       tui_update_source_windows_with_addr (pc);
       break;
     default:
@@ -189,7 +196,12 @@ tui_update_source_windows_with_line (str
       tui_show_symtab_source (s, l, FALSE);
       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 	{
-	  find_line_pc (s, line, &pc);
+          /* FIXME: What do we do with multiple pc values for ctors/dtors?  */
+          if (find_line_pc (s, line, &pc_list, &num_pc_values))
+            {
+              pc = pc_list[0];
+              xfree (pc_list);
+            }
 	  tui_show_disassem (pc);
 	}
       break;
Index: gdb-6.7/gdb/symtab.c
===================================================================
--- gdb-6.7.orig/gdb/symtab.c	2007-10-12 22:35:58.000000000 +0200
+++ gdb-6.7/gdb/symtab.c	2007-10-14 23:26:23.000000000 +0200
@@ -73,7 +73,9 @@ static void sources_info (char *, int);
 
 static void output_source_filename (const char *, int *);
 
-static int find_line_common (struct linetable *, int, int *);
+static int find_line_common (struct linetable *, int, int, int *);
+
+static int find_line_by_pc (struct linetable *, CORE_ADDR, int *);
 
 /* This one is used by linespec.c */
 
@@ -2252,6 +2254,9 @@ find_pc_line (CORE_ADDR pc, int notcurre
 /* Find line number LINE in any symtab whose name is the same as
    SYMTAB.
 
+   If INDEX is non-NULL, use the value as the starting index in the
+   linetable to start at.
+
    If found, return the symtab that contains the linetable in which it was
    found, set *INDEX to the index in the linetable of the best entry
    found, and set *EXACT_MATCH nonzero if the value returned is an
@@ -2268,13 +2273,19 @@ find_line_symtab (struct symtab *symtab,
      so far seen.  */
 
   int best_index;
+  int start_index;
   struct linetable *best_linetable;
   struct symtab *best_symtab;
 
+  if (index)
+    start_index = *index;
+  else
+    start_index = 0;
+
   /* First try looking it up in the given symtab.  */
   best_linetable = LINETABLE (symtab);
   best_symtab = symtab;
-  best_index = find_line_common (best_linetable, line, &exact);
+  best_index = find_line_common (best_linetable, line, start_index, &exact);
   if (best_index < 0 || !exact)
     {
       /* Didn't find an exact match.  So we better keep looking for
@@ -2305,7 +2316,7 @@ find_line_symtab (struct symtab *symtab,
 	if (strcmp (symtab->filename, s->filename) != 0)
 	  continue;
 	l = LINETABLE (s);
-	ind = find_line_common (l, line, &exact);
+	ind = find_line_common (l, line, start_index, &exact);
 	if (ind >= 0)
 	  {
 	    if (exact)
@@ -2341,13 +2352,23 @@ done:
    Returns zero for invalid line number (and sets the PC to 0).
    The source file is specified with a struct symtab.  */
 
+static CORE_ADDR empty_pc_list = (CORE_ADDR)0;
+
 int
-find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
+find_line_pc (struct symtab *symtab, int line, CORE_ADDR **pc_array,
+              int *num_elements)
 {
   struct linetable *l;
-  int ind;
+  int ind = 0;
+  char *name;
+  CORE_ADDR main_pc;
+  struct minimal_symbol *minsym;
+  struct minimal_symbol *minsym2;
+
+
+  *pc_array = &empty_pc_list;
+  *num_elements = 0;
 
-  *pc = 0;
   if (symtab == 0)
     return 0;
 
@@ -2355,7 +2376,73 @@ find_line_pc (struct symtab *symtab, int
   if (symtab != NULL)
     {
       l = LINETABLE (symtab);
-      *pc = l->item[ind].pc;
+      main_pc = l->item[ind].pc;
+      *pc_array = xmalloc (sizeof (CORE_ADDR) * 3);
+      *num_elements = 0;
+      (*pc_array)[(*num_elements)++] = main_pc;
+      minsym = lookup_minimal_symbol_by_pc (main_pc);
+      if (minsym != NULL && minsym->ginfo.language == language_cplus)
+	{
+	  char *src = minsym->ginfo.language_specific.cplus_specific.demangled_name;
+	  char *src_point = strchr (src, '(');
+	  char *s, *point;
+	  /* Keep "" last as the trimming part always matches it.  */
+	  const char *variants[] = {"$base","$allocate","$delete",""};
+	  int i;
+
+	  if (src_point != NULL)
+	    {
+	      char *dst = xmalloc (strlen (src) + strlen ("$allocate") + 1);
+	      char *dst_point = dst + (src_point - src);
+
+	      memcpy (dst, src, src_point - src);
+
+	      /* Trim out any variant markers there first.  */
+	      for (i = 0; i < ARRAY_SIZE (variants); i++)
+		{
+		  size_t len = strlen (variants[i]);
+
+		  if (dst_point - dst >= len
+		      && memcmp (dst_point - len, variants[i], len) == 0)
+		    {
+		      dst_point -= len;
+		      /* In fact it should not be needed here.  */
+		      break;
+		    }
+		}
+
+	      /* And now try to append all of them.  */
+	      for (i = 0; i < ARRAY_SIZE (variants); i++)
+		{
+		  size_t len = strlen (variants[i]);
+		  struct minimal_symbol *minsym2;
+
+		  memcpy (dst_point, variants[i], len);
+		  strcpy (dst_point + len, src_point);
+	      
+		  minsym2 = lookup_minimal_symbol (dst, NULL, NULL);
+		  if (minsym2 != NULL)
+		    {
+		      /* We have recognized we have a ctor or dtor and have
+			 located our line in the not-in-charge version.  We
+			 also have located the in-charge version's minsym.
+			 From this, we can find the index for the first line
+			 line in the in-charge ctor/dtor and then search forward
+			 for the specified line, thereby finding the 2nd match.  */
+		      int exact;
+		      int ind = find_line_by_pc (l, minsym2->ginfo.value.address,
+						 &exact);
+		      if (ind >= 0)
+			{
+			  ind = find_line_common (l, line, ind, &exact);
+			  if (ind >= 0 && l->item[ind].pc != main_pc)
+			    (*pc_array)[(*num_elements)++] = l->item[ind].pc;
+			}
+		    }
+		}
+	      xfree (dst);
+	    }
+	}
       return 1;
     }
   else
@@ -2373,12 +2460,22 @@ find_line_pc_range (struct symtab_and_li
 		    CORE_ADDR *endptr)
 {
   CORE_ADDR startaddr;
+  CORE_ADDR *pc_list;
+  int num_pc_values;
   struct symtab_and_line found_sal;
 
   startaddr = sal.pc;
-  if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
+  if (startaddr == 0 
+      && !find_line_pc (sal.symtab, sal.line, &pc_list, &num_pc_values))
     return 0;
 
+  /* FIXME: have to handle ctors/dtors where line equates to multiple
+            pc ranges.  */
+  if (startaddr == 0)
+    startaddr = pc_list[0];
+
+  xfree (pc_list);
+
   /* This whole function is based on address.  For example, if line 10 has
      two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
      "info line *0x123" should say the line goes from 0x100 to 0x200
@@ -2408,7 +2505,7 @@ find_line_pc_range (struct symtab_and_li
    Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
 
 static int
-find_line_common (struct linetable *l, int lineno,
+find_line_common (struct linetable *l, int lineno, int start_index,
 		  int *exact_match)
 {
   int i;
@@ -2427,7 +2524,7 @@ find_line_common (struct linetable *l, i
     return -1;
 
   len = l->nitems;
-  for (i = 0; i < len; i++)
+  for (i = start_index; i < len; i++)
     {
       struct linetable_entry *item = &(l->item[i]);
 
@@ -2451,6 +2548,52 @@ find_line_common (struct linetable *l, i
   return best_index;
 }
 
+/* Given a line table and a pc value, return the index into the line
+   table for the line with pc >= specified pc value.
+   Return -1 if none is found.  The value is >= 0 if it is an index.
+
+   Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
+
+static int
+find_line_by_pc (struct linetable *l, CORE_ADDR pc,
+	         int *exact_match)
+{
+  int i;
+  int len;
+
+  /* BEST is the smallest linenumber > LINENO so far seen,
+     or 0 if none has been seen so far.
+     BEST_INDEX identifies the item for it.  */
+
+  if (l == 0)
+    return -1;
+
+  len = l->nitems;
+  for (i = 0; i < len; i++)
+    {
+      struct linetable_entry *item = &(l->item[i]);
+
+      /* Return the first (lowest address) entry which matches or
+         exceeds the given pc value.  */
+      if (item->pc == pc)
+	{
+	  *exact_match = 1;
+	  return i;
+	}
+
+      if (item->pc > pc)
+	{
+	  *exact_match = 0;
+	  return i;
+	}
+    }
+
+  /* If we got here, we didn't get a match.  */
+
+  *exact_match = 0;
+  return -1;
+}
+
 int
 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
 {
Index: gdb-6.7/gdb/symtab.h
===================================================================
--- gdb-6.7.orig/gdb/symtab.h	2007-08-23 20:08:45.000000000 +0200
+++ gdb-6.7/gdb/symtab.h	2007-10-14 23:26:23.000000000 +0200
@@ -1271,13 +1271,16 @@ extern struct symtab_and_line find_pc_se
 
 /* Given a symtab and line number, return the pc there.  */
 
-extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
+extern int find_line_pc (struct symtab *, int, CORE_ADDR **, int *);
 
 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
 			       CORE_ADDR *);
 
 extern void resolve_sal_pc (struct symtab_and_line *);
 
+extern void resolve_sal_pc_list (struct symtab_and_line *, CORE_ADDR **,
+				 int *);
+
 /* Given a string, return the line specified by it.  For commands like "list"
    and "breakpoint".  */
 
Index: gdb-6.7/gdb/breakpoint.c
===================================================================
--- gdb-6.7.orig/gdb/breakpoint.c	2007-10-13 05:29:58.000000000 +0200
+++ gdb-6.7/gdb/breakpoint.c	2007-10-14 23:26:23.000000000 +0200
@@ -5325,12 +5325,70 @@ parse_breakpoint_sals (char **address,
 
 static void
 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
-		       char *address)
+		       char *address, char ***addr_string_p)
 {    
-  int i;
-  for (i = 0; i < sals->nelts; i++)
-    {
-      resolve_sal_pc (&sals->sals[i]);
+  int i, j, incr;
+  int num_pc_values = 1;
+
+  /* If a line has multiple pc values, we want to create an sal for
+     each pc value so we will end up creating n breakpoints.  */
+  for (i = 0; i < sals->nelts; i+=incr)
+    {
+      CORE_ADDR *pc_list;
+      incr = 1;
+
+      resolve_sal_pc_list (&sals->sals[i], &pc_list, &num_pc_values);
+      if (num_pc_values != 0)
+        sals->sals[i].pc = pc_list[0];
+      if (num_pc_values > 1)
+        {
+          struct symtab_and_line *new_sals = 
+            xmalloc ((sals->nelts + num_pc_values - 1) 
+                     * sizeof (struct symtab_and_line));
+          char **new_addr_string;
+          char *addr_string_base;
+
+          /* Expand the SALS array.  */
+          memcpy (new_sals, sals->sals, (i + 1) 
+                  * sizeof (struct symtab_and_line));
+	  /* The one returned SALS entry is copied for all the PCs.  */
+          for (j = 1; j < num_pc_values; ++j)
+            {
+	      memcpy (&(new_sals[i + j]), &sals->sals[i], 
+		      sizeof (struct symtab_and_line));
+	    }
+          xfree (sals->sals);
+          sals->sals = new_sals;
+          sals->nelts += num_pc_values - 1;
+          for (j = 1; j < num_pc_values; ++j)
+            {
+              sals->sals[i + j].pc = pc_list[j];
+            }
+
+          /* Expand the *ADDR_STRING_P array.  */
+          new_addr_string = xmalloc ((sals->nelts + num_pc_values - 1)
+                                     * sizeof *new_addr_string);
+          memcpy (new_addr_string, *addr_string_p,
+                  (i + 1) * sizeof *new_addr_string);
+          /* The existing *ADDR_STRING_P entry must be copied for all the
+             multiple PCs. BREAKPOINT_RE_SET will follow the new trailing "%id"
+             syntax so it will get resolved right even later.  Do not use the
+             unambiguous NULL values (resolved to "0x%x" by CREATE_BREAKPOINTS)
+             as the address may change for the shared libraries.  */
+          addr_string_base = (*addr_string_p)[i];
+          for (j = 0; j < num_pc_values; ++j)
+            new_addr_string[i + j] = xstrprintf ("%s%%%d", addr_string_base, j);
+          xfree (addr_string_base);
+          memcpy (&new_addr_string[i + num_pc_values], &(*addr_string_p)[i + 1],
+                  (sals->nelts - (i + num_pc_values)) * sizeof *new_addr_string);
+          xfree (*addr_string_p);
+          *addr_string_p = new_addr_string;
+
+          incr = num_pc_values;
+        }
+
+      if (num_pc_values != 0)
+        xfree (pc_list);
 
       /* It's possible for the PC to be nonzero, but still an illegal
          value on some targets.
@@ -5465,6 +5523,10 @@ break_command_1 (char *arg, int flag, in
 
   if (!pending)
     {
+      /* Resolve all line numbers to PC's and verify that the addresses
+         are ok for the target.  */
+      breakpoint_sals_to_pc (&sals, addr_start, &addr_string);
+
       /* Make sure that all storage allocated to SALS gets freed.  */
       make_cleanup (xfree, sals.sals);
       
@@ -5495,11 +5557,6 @@ break_command_1 (char *arg, int flag, in
 	make_cleanup (xfree, addr_string[i]);
     }
 
-  /* Resolve all line numbers to PC's and verify that the addresses
-     are ok for the target.  */
-  if (!pending)
-    breakpoint_sals_to_pc (&sals, addr_start);
-
   /* Verify that condition can be parsed, before setting any
      breakpoints.  Allocate a separate condition expression for each
      breakpoint. */
@@ -5675,7 +5732,7 @@ do_captured_breakpoint (struct ui_out *u
     error (_("Garbage %s following breakpoint address"), address_end);
 
   /* Resolve all line numbers to PC's.  */
-  breakpoint_sals_to_pc (&sals, args->address);
+  breakpoint_sals_to_pc (&sals, args->address, &addr_string);
 
   /* Verify that conditions can be parsed, before setting any
      breakpoints.  */
@@ -5732,14 +5789,16 @@ gdb_breakpoint (char *address, char *con
 void
 resolve_sal_pc (struct symtab_and_line *sal)
 {
-  CORE_ADDR pc;
+  CORE_ADDR *pc_list;
+  int num_pc_values;
 
   if (sal->pc == 0 && sal->symtab != NULL)
     {
-      if (!find_line_pc (sal->symtab, sal->line, &pc))
+      if (!find_line_pc (sal->symtab, sal->line, &pc_list, &num_pc_values))
 	error (_("No line %d in file \"%s\"."),
 	       sal->line, sal->symtab->filename);
-      sal->pc = pc;
+      sal->pc = pc_list[0];
+      xfree (pc_list);
     }
 
   if (sal->section == 0 && sal->symtab != NULL)
@@ -5776,6 +5835,54 @@ resolve_sal_pc (struct symtab_and_line *
     }
 }
 
+/* Helper function for break_command_1 and disassemble_command.  */
+
+void
+resolve_sal_pc_list (struct symtab_and_line *sal, CORE_ADDR **pc_list,
+                     int *num_pc_values)
+{
+  *num_pc_values = 0;
+  if (sal->pc == 0 && sal->symtab != NULL)
+    {
+      if (!find_line_pc (sal->symtab, sal->line, pc_list, num_pc_values))
+	error ("No line %d in file \"%s\".",
+	       sal->line, sal->symtab->filename);
+      sal->pc = (*pc_list)[0];
+    }
+
+  if (sal->section == 0 && sal->symtab != NULL)
+    {
+      struct blockvector *bv;
+      struct block *b;
+      struct symbol *sym;
+      int index;
+
+      bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
+      if (bv != NULL)
+	{
+	  b = BLOCKVECTOR_BLOCK (bv, index);
+	  sym = block_function (b);
+	  if (sym != NULL)
+	    {
+	      fixup_symbol_section (sym, sal->symtab->objfile);
+	      sal->section = SYMBOL_BFD_SECTION (sym);
+	    }
+	  else
+	    {
+	      /* It really is worthwhile to have the section, so we'll just
+	         have to look harder. This case can be executed if we have 
+	         line numbers but no functions (as can happen in assembly 
+	         source).  */
+
+	      struct minimal_symbol *msym;
+
+	      msym = lookup_minimal_symbol_by_pc (sal->pc);
+	      if (msym)
+		sal->section = SYMBOL_BFD_SECTION (msym);
+	    }
+	}
+    }
+}
 void
 break_command (char *arg, int from_tty)
 {
@@ -7320,6 +7427,8 @@ breakpoint_re_set_one (void *bint)
   int *not_found_ptr = NULL;
   struct symtabs_and_lines sals;
   char *s;
+  char *id_s;
+  int id = -1;
   enum enable_state save_enable;
 
   switch (b->type)
@@ -7380,11 +7489,44 @@ breakpoint_re_set_one (void *bint)
       set_language (b->language);
       input_radix = b->input_radix;
       s = b->addr_string;
+      for (id_s = s + strlen (s) - 1; id_s >= s; id_s--)
+        {
+	  if (isdigit (*id_s))
+	    continue;
+	  if (*id_s == '%')
+	    break;
+	  id_s = NULL;
+	  break;
+	}
+      if (id_s >= s)
+        {
+	  s = alloca (id_s - b->addr_string + 1);
+	  memcpy (s, b->addr_string, id_s - b->addr_string);
+	  s[id_s - b->addr_string] = 0;
+	  id = atoi (id_s + 1);
+	}
       sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
 		            not_found_ptr);
       for (i = 0; i < sals.nelts; i++)
 	{
-	  resolve_sal_pc (&sals.sals[i]);
+	  CORE_ADDR *pc_list;
+	  int num_pc_values;
+
+	  resolve_sal_pc_list (&sals.sals[i], &pc_list, &num_pc_values);
+	  if (num_pc_values > 0)
+	    {
+	      if (id != -1)
+		{
+		  /* The number of PC values should not usually change.  */
+		  if (id >= num_pc_values)
+		    {
+		      delete_breakpoint (b);
+		      return 0;
+		    }
+		  sals.sals[i].pc = pc_list[id];
+		}
+	      xfree (pc_list);
+	    }
 
 	  /* Reparse conditions, they might contain references to the
 	     old symtab.  */