2011-07-25 Pedro Alves <pedro@codesourcery.com>

	Split internal, momentary and user breakpoints breakpoint_ops
	tables.

	gdb/
	* breakpoint.c (internal_breakpoint_ops)
	(momentary_breakpoint_ops): Forward declare.
	(create_internal_breakpoint): Add new breakpoint_ops parameter.
	Pass it down, rather than hardcoding bkpt_breakpoint_ops.
	(create_overlay_event_breakpoint)
	(create_std_terminate_master_breakpoint)
	(create_exception_master_breakpoint): Create breakpoints with
	internal_breakpoint_ops vtable.
	(set_longjmp_breakpoint): Create momentary breakpoints with
	momentary_breakpoint_ops vtable, using
	momentary_breakpoint_from_master.
	(create_thread_event_breakpoint, create_jit_event_breakpoint)
	(create_solib_event_breakpoint): Create breakpoints with
	internal_breakpoint_ops vtable.
	(set_momentary_breakpoint): Create breakpoints with
	momentary_breakpoint_ops vtable.
	(momentary_breakpoint_from_master): New, factored out from
	clone_momentary_breakpoint.
	(clone_momentary_breakpoint): Adjust.
	(watch_command_1): Create scope breakpoints with
	momentary_breakpoint_ops vtable.
	(bkpt_re_set): Remove handling of internal and momentary
	breakpoints.
	(bkpt_print_mention, bkpt_print_recreate): New.
	(bkpt_breakpoint_ops): Adjust.
	(internal_bkpt_re_set, internal_bkpt_check_status)
	(internal_bkpt_print_it, internal_bkpt_print_mention)
	(internal_bkpt_print_recreate, internal_breakpoint_ops): New.
	(momentary_bkpt_re_set, momentary_bkpt_check_status)
	(momentary_bkpt_print_it, momentary_bkpt_print_mention)
	(momentary_bkpt_print_recreate): New.
	(momentary_breakpoint_ops): New.

2 files changed, 336 insertions, 183 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ec1d3b32768..f4e048f4506 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,43 @@
 2011-07-25  Pedro Alves  <pedro@codesourcery.com>
 
+	Split internal, momentary and user breakpoints breakpoint_ops
+	tables.
+
+	* breakpoint.c (internal_breakpoint_ops)
+	(momentary_breakpoint_ops): Forward declare.
+	(create_internal_breakpoint): Add new breakpoint_ops parameter.
+	Pass it down, rather than hardcoding bkpt_breakpoint_ops.
+	(create_overlay_event_breakpoint)
+	(create_std_terminate_master_breakpoint)
+	(create_exception_master_breakpoint): Create breakpoints with
+	internal_breakpoint_ops vtable.
+	(set_longjmp_breakpoint): Create momentary breakpoints with
+	momentary_breakpoint_ops vtable, using
+	momentary_breakpoint_from_master.
+	(create_thread_event_breakpoint, create_jit_event_breakpoint)
+	(create_solib_event_breakpoint): Create breakpoints with
+	internal_breakpoint_ops vtable.
+	(set_momentary_breakpoint): Create breakpoints with
+	momentary_breakpoint_ops vtable.
+	(momentary_breakpoint_from_master): New, factored out from
+	clone_momentary_breakpoint.
+	(clone_momentary_breakpoint): Adjust.
+	(watch_command_1): Create scope breakpoints with
+	momentary_breakpoint_ops vtable.
+	(bkpt_re_set): Remove handling of internal and momentary
+	breakpoints.
+	(bkpt_print_mention, bkpt_print_recreate): New.
+	(bkpt_breakpoint_ops): Adjust.
+	(internal_bkpt_re_set, internal_bkpt_check_status)
+	(internal_bkpt_print_it, internal_bkpt_print_mention)
+	(internal_bkpt_print_recreate, internal_breakpoint_ops): New.
+	(momentary_bkpt_re_set, momentary_bkpt_check_status)
+	(momentary_bkpt_print_it, momentary_bkpt_print_mention)
+	(momentary_bkpt_print_recreate): New.
+	(momentary_breakpoint_ops): New.
+
+2011-07-25  Pedro Alves  <pedro@codesourcery.com>
+
 	Implement most breakpoint_ops methods for all breakpoint types,
 	and move the default handlings to the proper callbacks.
 
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 9626cdd58a4..a89b35fbaac 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -115,6 +115,11 @@ struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
 				       struct symtab_and_line,
 				       enum bptype, struct breakpoint_ops *);
 
+static struct breakpoint *
+  momentary_breakpoint_from_master (struct breakpoint *orig,
+				    enum bptype type,
+				    struct breakpoint_ops *ops);
+
 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
 
 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
@@ -231,6 +236,10 @@ static int is_masked_watchpoint (const struct breakpoint *b);
 #define is_marker_spec(s)						\
   (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
 
+/* Forward declarations.  */
+static struct breakpoint_ops internal_breakpoint_ops;
+static struct breakpoint_ops momentary_breakpoint_ops;
+
 /* A reference-counted struct command_line.  This lets multiple
    breakpoints share a single command list.  */
 struct counted_command_line
@@ -2066,7 +2075,8 @@ set_breakpoint_number (int internal, struct breakpoint *b)
 
 static struct breakpoint *
 create_internal_breakpoint (struct gdbarch *gdbarch,
-			    CORE_ADDR address, enum bptype type)
+			    CORE_ADDR address, enum bptype type,
+			    struct breakpoint_ops *ops)
 {
   struct symtab_and_line sal;
   struct breakpoint *b;
@@ -2077,7 +2087,7 @@ create_internal_breakpoint (struct gdbarch *gdbarch,
   sal.section = find_pc_overlay (sal.pc);
   sal.pspace = current_program_space;
 
-  b = set_raw_breakpoint (gdbarch, sal, type, &bkpt_breakpoint_ops);
+  b = set_raw_breakpoint (gdbarch, sal, type, ops);
   b->number = internal_breakpoint_number--;
   b->disposition = disp_donttouch;
 
@@ -2172,7 +2182,8 @@ create_overlay_event_breakpoint (void)
 
       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
-                                      bp_overlay_event);
+                                      bp_overlay_event,
+				      &internal_breakpoint_ops);
       b->addr_string = xstrdup (func_name);
 
       if (overlay_debugging == ovly_auto)
@@ -2240,7 +2251,8 @@ create_longjmp_master_breakpoint (void)
 	    }
 
 	  addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
-	  b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master);
+	  b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
+					  &internal_breakpoint_ops);
 	  b->addr_string = xstrdup (func_name);
 	  b->enable_state = bp_disabled;
 	}
@@ -2295,7 +2307,8 @@ create_std_terminate_master_breakpoint (void)
 
       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
-                                      bp_std_terminate_master);
+                                      bp_std_terminate_master,
+				      &internal_breakpoint_ops);
       b->addr_string = xstrdup (func_name);
       b->enable_state = bp_disabled;
     }
@@ -2345,7 +2358,8 @@ create_exception_master_breakpoint (void)
       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
 						 &current_target);
-      b = create_internal_breakpoint (gdbarch, addr, bp_exception_master);
+      b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
+				      &internal_breakpoint_ops);
       b->addr_string = xstrdup (func_name);
       b->enable_state = bp_disabled;
     }
@@ -5728,9 +5742,11 @@ set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
 	&& (b->type == bp_longjmp_master
 	    || b->type == bp_exception_master))
       {
-	struct breakpoint *clone = clone_momentary_breakpoint (b);
+	enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
+	struct breakpoint *clone;
 
-	clone->type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
+	clone = momentary_breakpoint_from_master (b, type,
+						  &momentary_breakpoint_ops);
 	clone->thread = thread;
       }
 
@@ -5790,8 +5806,8 @@ set_std_terminate_breakpoint (void)
     if (b->pspace == current_program_space
 	&& b->type == bp_std_terminate_master)
       {
-	struct breakpoint *clone = clone_momentary_breakpoint (b);
-	clone->type = bp_std_terminate;
+	momentary_breakpoint_from_master (b, bp_std_terminate,
+					  &momentary_breakpoint_ops);
       }
 }
 
@@ -5811,8 +5827,9 @@ create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
 {
   struct breakpoint *b;
 
-  b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
-  
+  b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
+				  &internal_breakpoint_ops);
+
   b->enable_state = bp_enabled;
   /* addr_string has to be used or breakpoint_re_set will delete me.  */
   b->addr_string
@@ -5847,7 +5864,8 @@ create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
 {
   struct breakpoint *b;
 
-  b = create_internal_breakpoint (gdbarch, address, bp_jit_event);
+  b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
+				  &internal_breakpoint_ops);
   update_global_location_list_nothrow (1);
   return b;
 }
@@ -5881,7 +5899,8 @@ create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
 {
   struct breakpoint *b;
 
-  b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
+  b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
+				  &internal_breakpoint_ops);
   update_global_location_list_nothrow (1);
   return b;
 }
@@ -6880,7 +6899,7 @@ set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
      one.  */
   gdb_assert (!frame_id_inlined_p (frame_id));
 
-  b = set_raw_breakpoint (gdbarch, sal, type, &bkpt_breakpoint_ops);
+  b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
   b->enable_state = bp_enabled;
   b->disposition = disp_donttouch;
   b->frame_id = frame_id;
@@ -6896,20 +6915,18 @@ set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
   return b;
 }
 
-/* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
-   ORIG is NULL.  */
+/* Make a momentary breakpoint based on the master breakpoint ORIG.
+   The new breakpoint will have type TYPE, and use OPS as it
+   breakpoint_ops.  */
 
-struct breakpoint *
-clone_momentary_breakpoint (struct breakpoint *orig)
+static struct breakpoint *
+momentary_breakpoint_from_master (struct breakpoint *orig,
+				  enum bptype type,
+				  struct breakpoint_ops *ops)
 {
   struct breakpoint *copy;
 
-  /* If there's nothing to clone, then return nothing.  */
-  if (orig == NULL)
-    return NULL;
-
-  copy = set_raw_breakpoint_without_location (orig->gdbarch,
-					      orig->type, orig->ops);
+  copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
   copy->loc = allocate_bp_location (copy);
   set_breakpoint_location_function (copy->loc, 1);
 
@@ -6937,6 +6954,19 @@ clone_momentary_breakpoint (struct breakpoint *orig)
   return copy;
 }
 
+/* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
+   ORIG is NULL.  */
+
+struct breakpoint *
+clone_momentary_breakpoint (struct breakpoint *orig)
+{
+  /* If there's nothing to clone, then return nothing.  */
+  if (orig == NULL)
+    return NULL;
+
+  return momentary_breakpoint_from_master (orig, orig->type, orig->ops);
+}
+
 struct breakpoint *
 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
 				enum bptype type)
@@ -9121,7 +9151,8 @@ watch_command_1 (char *arg, int accessflag, int from_tty,
  	  scope_breakpoint
 	    = create_internal_breakpoint (frame_unwind_caller_arch (frame),
 					  frame_unwind_caller_pc (frame),
-					  bp_watchpoint_scope);
+					  bp_watchpoint_scope,
+					  &momentary_breakpoint_ops);
 
 	  scope_breakpoint->enable_state = bp_enabled;
 
@@ -10676,66 +10707,19 @@ bkpt_allocate_location (struct breakpoint *self)
 void
 bkpt_re_set (struct breakpoint *b)
 {
-  switch (b->type)
-    {
-    case bp_breakpoint:
-    case bp_hardware_breakpoint:
-    case bp_gnu_ifunc_resolver:
-      /* Do not attempt to re-set breakpoints disabled during
-	 startup.  */
-      if (b->enable_state == bp_startup_disabled)
-	return;
-
-      if (b->addr_string == NULL)
-	{
-	  /* Anything without a string can't be re-set.  */
-	  delete_breakpoint (b);
-	  return;
-	}
-
-      breakpoint_re_set_default (b);
-      break;
+  /* Do not attempt to re-set breakpoints disabled during startup.  */
+  if (b->enable_state == bp_startup_disabled)
+    return;
 
-    default:
-      printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
-      /* fall through */
-      /* Delete overlay event and longjmp master breakpoints; they
-	 will be reset later by breakpoint_re_set.  */
-    case bp_overlay_event:
-    case bp_longjmp_master:
-    case bp_std_terminate_master:
-    case bp_exception_master:
+  /* FIXME: is this still reachable?  */
+  if (b->addr_string == NULL)
+    {
+      /* Anything without a string can't be re-set.  */
       delete_breakpoint (b);
-      break;
-
-      /* This breakpoint is special, it's set up when the inferior
-         starts and we really don't want to touch it.  */
-    case bp_shlib_event:
-
-      /* Like bp_shlib_event, this breakpoint type is special.  Once
-	 it is set up, we do not want to touch it.  */
-    case bp_thread_event:
-
-      /* Keep temporary breakpoints, which can be encountered when we
-         step over a dlopen call and SOLIB_ADD is resetting the
-         breakpoints.  Otherwise these should have been blown away via
-         the cleanup chain or by breakpoint_init_inferior when we
-         rerun the executable.  */
-    case bp_until:
-    case bp_finish:
-    case bp_watchpoint_scope:
-    case bp_call_dummy:
-    case bp_std_terminate:
-    case bp_step_resume:
-    case bp_hp_step_resume:
-    case bp_longjmp:
-    case bp_longjmp_resume:
-    case bp_exception:
-    case bp_exception_resume:
-    case bp_jit_event:
-    case bp_gnu_ifunc_resolver_return:
-      break;
+      return;
     }
+
+  breakpoint_re_set_default (b);
 }
 
 int
@@ -10779,15 +10763,7 @@ bkpt_breakpoint_hit (const struct bp_location *bl,
 void
 bkpt_check_status (bpstat bs)
 {
-  struct breakpoint *b = bs->breakpoint_at;
-
-  if (b->type == bp_thread_event
-      || b->type == bp_overlay_event
-      || b->type == bp_longjmp_master
-      || b->type == bp_std_terminate_master
-      || b->type == bp_exception_master)
-    /* We do not stop for these.  */
-    bs->stop = 0;
+  /* nothing, always stop */
 }
 
 int
@@ -10847,6 +10823,144 @@ bkpt_print_it (bpstat bs)
       result = PRINT_SRC_AND_LOC;
       break;
 
+    default:
+      result = PRINT_UNKNOWN;
+      break;
+    }
+
+  do_cleanups (old_chain);
+  return result;
+}
+
+void
+bkpt_print_mention (struct breakpoint *b)
+{
+  if (ui_out_is_mi_like_p (uiout))
+    return;
+
+  switch (b->type)
+    {
+    case bp_breakpoint:
+    case bp_gnu_ifunc_resolver:
+      if (b->disposition == disp_del)
+	printf_filtered (_("Temporary breakpoint"));
+      else
+	printf_filtered (_("Breakpoint"));
+      printf_filtered (_(" %d"), b->number);
+      if (b->type == bp_gnu_ifunc_resolver)
+	printf_filtered (_(" at gnu-indirect-function resolver"));
+      break;
+    case bp_hardware_breakpoint:
+      printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
+      break;
+    }
+
+  say_where (b);
+}
+
+void
+bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
+{
+  if (tp->type == bp_breakpoint && tp->disposition == disp_del)
+    fprintf_unfiltered (fp, "tbreak");
+  else if (tp->type == bp_breakpoint)
+    fprintf_unfiltered (fp, "break");
+  else if (tp->type == bp_hardware_breakpoint
+	   && tp->disposition == disp_del)
+    fprintf_unfiltered (fp, "thbreak");
+  else if (tp->type == bp_hardware_breakpoint)
+    fprintf_unfiltered (fp, "hbreak");
+  else
+    internal_error (__FILE__, __LINE__,
+		    _("unhandled breakpoint type %d"), (int) tp->type);
+
+  if (tp->exp_string)
+    fprintf_unfiltered (fp, " %s", tp->exp_string);
+  else if (tp->addr_string)
+    fprintf_unfiltered (fp, " %s", tp->addr_string);
+  else
+    {
+      char tmp[40];
+
+      sprintf_vma (tmp, tp->loc->address);
+      fprintf_unfiltered (fp, " *0x%s", tmp);
+    }
+}
+
+/* The breakpoint_ops structure to be used in regular breakpoints.  */
+
+struct breakpoint_ops bkpt_breakpoint_ops =
+{
+  bkpt_dtor,
+  bkpt_allocate_location,
+  bkpt_re_set,
+  bkpt_insert_location,
+  bkpt_remove_location,
+  bkpt_breakpoint_hit,
+  bkpt_check_status,
+  bkpt_resources_needed,
+  null_works_in_software_mode,
+  bkpt_print_it,
+  NULL, /* print_one */
+  null_print_one_detail,
+  bkpt_print_mention,
+  bkpt_print_recreate
+};
+
+/* Virtual table for internal breakpoints.  */
+
+static void
+internal_bkpt_re_set (struct breakpoint *b)
+{
+  switch (b->type)
+    {
+      /* Delete overlay event and longjmp master breakpoints; they
+	 will be reset later by breakpoint_re_set.  */
+    case bp_overlay_event:
+    case bp_longjmp_master:
+    case bp_std_terminate_master:
+    case bp_exception_master:
+      delete_breakpoint (b);
+      break;
+
+      /* This breakpoint is special, it's set up when the inferior
+         starts and we really don't want to touch it.  */
+    case bp_shlib_event:
+
+      /* Like bp_shlib_event, this breakpoint type is special.  Once
+	 it is set up, we do not want to touch it.  */
+    case bp_thread_event:
+      break;
+    }
+}
+
+static void
+internal_bkpt_check_status (bpstat bs)
+{
+  /* We do not stop for these.  */
+  bs->stop = 0;
+}
+
+static enum print_stop_action
+internal_bkpt_print_it (bpstat bs)
+{
+  struct cleanup *old_chain;
+  struct breakpoint *b;
+  const struct bp_location *bl;
+  struct ui_stream *stb;
+  int bp_temp = 0;
+  enum print_stop_action result;
+
+  gdb_assert (bs->bp_location_at != NULL);
+
+  bl = bs->bp_location_at;
+  b = bs->breakpoint_at;
+
+  stb = ui_out_stream_new (uiout);
+  old_chain = make_cleanup_ui_out_stream_delete (stb);
+
+  switch (b->type)
+    {
     case bp_shlib_event:
       /* Did we stop because the user set the stop_on_solib_events
 	 variable?  (If so, we report this as a generic, "Stopped due
@@ -10888,9 +11002,85 @@ bkpt_print_it (bpstat bs)
       result = PRINT_NOTHING;
       break;
 
-    /* Fall through, we don't deal with these types of breakpoints
-       here.  */
+    default:
+      result = PRINT_UNKNOWN;
+      break;
+    }
+
+  do_cleanups (old_chain);
+  return result;
+}
 
+static void
+internal_bkpt_print_mention (struct breakpoint *b)
+{
+  /* Nothing to mention.  These breakpoints are internal.  */
+}
+
+static void
+internal_bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
+{
+  gdb_assert_not_reached ("internal_bkpt_print_recreate called");
+}
+
+/* The breakpoint_ops structure to be used with internal
+   breakpoints.  */
+
+static struct breakpoint_ops internal_breakpoint_ops =
+{
+  bkpt_dtor,
+  bkpt_allocate_location,
+  internal_bkpt_re_set,
+  bkpt_insert_location,
+  bkpt_remove_location,
+  bkpt_breakpoint_hit,
+  internal_bkpt_check_status,
+  bkpt_resources_needed,
+  null_works_in_software_mode,
+  internal_bkpt_print_it,
+  NULL, /* print_one */
+  null_print_one_detail,
+  internal_bkpt_print_mention,
+  internal_bkpt_print_recreate
+};
+
+/* Virtual table for momentary breakpoints  */
+
+static void
+momentary_bkpt_re_set (struct breakpoint *b)
+{
+  /* Keep temporary breakpoints, which can be encountered when we step
+     over a dlopen call and SOLIB_ADD is resetting the breakpoints.
+     Otherwise these should have been blown away via the cleanup chain
+     or by breakpoint_init_inferior when we rerun the executable.  */
+}
+
+static void
+momentary_bkpt_check_status (bpstat bs)
+{
+  /* Nothing.  The point of these breakpoints is causing a stop.  */
+}
+
+static enum print_stop_action
+momentary_bkpt_print_it (bpstat bs)
+{
+  struct cleanup *old_chain;
+  struct breakpoint *b;
+  const struct bp_location *bl;
+  struct ui_stream *stb;
+  int bp_temp = 0;
+  enum print_stop_action result;
+
+  gdb_assert (bs->bp_location_at != NULL);
+
+  bl = bs->bp_location_at;
+  b = bs->breakpoint_at;
+
+  stb = ui_out_stream_new (uiout);
+  old_chain = make_cleanup_ui_out_stream_delete (stb);
+
+  switch (b->type)
+    {
     case bp_finish:
       if (ui_out_is_mi_like_p (uiout))
 	ui_out_field_string
@@ -10907,19 +11097,6 @@ bkpt_print_it (bpstat bs)
       result = PRINT_UNKNOWN;
       break;
 
-    case bp_none:
-    case bp_longjmp:
-    case bp_longjmp_resume:
-    case bp_exception:
-    case bp_exception_resume:
-    case bp_step_resume:
-    case bp_hp_step_resume:
-    case bp_watchpoint_scope:
-    case bp_call_dummy:
-    case bp_std_terminate:
-    case bp_jit_event:
-    case bp_gnu_ifunc_resolver:
-    case bp_gnu_ifunc_resolver_return:
     default:
       result = PRINT_UNKNOWN;
       break;
@@ -10929,99 +11106,37 @@ bkpt_print_it (bpstat bs)
   return result;
 }
 
-void
-bkpt_print_mention (struct breakpoint *b)
+static void
+momentary_bkpt_print_mention (struct breakpoint *b)
 {
-  if (ui_out_is_mi_like_p (uiout))
-    return;
-
-  switch (b->type)
-    {
-    case bp_breakpoint:
-    case bp_gnu_ifunc_resolver:
-      if (b->disposition == disp_del)
-	printf_filtered (_("Temporary breakpoint"));
-      else
-	printf_filtered (_("Breakpoint"));
-      printf_filtered (_(" %d"), b->number);
-      if (b->type == bp_gnu_ifunc_resolver)
-	printf_filtered (_(" at gnu-indirect-function resolver"));
-      say_where (b);
-      break;
-    case bp_hardware_breakpoint:
-      printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
-      say_where (b);
-      break;
-    case bp_until:
-    case bp_finish:
-    case bp_longjmp:
-    case bp_longjmp_resume:
-    case bp_exception:
-    case bp_exception_resume:
-    case bp_step_resume:
-    case bp_hp_step_resume:
-    case bp_call_dummy:
-    case bp_std_terminate:
-    case bp_watchpoint_scope:
-    case bp_shlib_event:
-    case bp_thread_event:
-    case bp_overlay_event:
-    case bp_jit_event:
-    case bp_longjmp_master:
-    case bp_std_terminate_master:
-    case bp_exception_master:
-    case bp_gnu_ifunc_resolver_return:
-      break;
-    }
+  /* Nothing to mention.  These breakpoints are internal.  */
 }
 
-void
-bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
+static void
+momentary_bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
 {
-  if (tp->type == bp_breakpoint && tp->disposition == disp_del)
-    fprintf_unfiltered (fp, "tbreak");
-  else if (tp->type == bp_breakpoint)
-    fprintf_unfiltered (fp, "break");
-  else if (tp->type == bp_hardware_breakpoint
-	   && tp->disposition == disp_del)
-    fprintf_unfiltered (fp, "thbreak");
-  else if (tp->type == bp_hardware_breakpoint)
-    fprintf_unfiltered (fp, "hbreak");
-  else
-    internal_error (__FILE__, __LINE__,
-		    _("unhandled breakpoint type %d"), (int) tp->type);
-
-  if (tp->exp_string)
-    fprintf_unfiltered (fp, " %s", tp->exp_string);
-  else if (tp->addr_string)
-    fprintf_unfiltered (fp, " %s", tp->addr_string);
-  else
-    {
-      char tmp[40];
-
-      sprintf_vma (tmp, tp->loc->address);
-      fprintf_unfiltered (fp, " *0x%s", tmp);
-    }
+  gdb_assert_not_reached ("momentary_bkpt_print_recreate called");
 }
 
-/* The breakpoint_ops structure to be used in regular breakpoints.  */
+/* The breakpoint_ops structure to be used with momentary
+   breakpoints.  */
 
-struct breakpoint_ops bkpt_breakpoint_ops =
+static struct breakpoint_ops momentary_breakpoint_ops =
 {
   bkpt_dtor,
   bkpt_allocate_location,
-  bkpt_re_set,
+  momentary_bkpt_re_set,
   bkpt_insert_location,
   bkpt_remove_location,
   bkpt_breakpoint_hit,
-  bkpt_check_status,
+  momentary_bkpt_check_status,
   bkpt_resources_needed,
   null_works_in_software_mode,
-  bkpt_print_it,
+  momentary_bkpt_print_it,
   NULL, /* print_one */
   null_print_one_detail,
-  bkpt_print_mention,
-  bkpt_print_recreate
+  momentary_bkpt_print_mention,
+  momentary_bkpt_print_recreate
 };
 
 /* The breakpoint_ops structure to be used in tracepoints.  */