if (event_loop_p && target_can_async_p ())
if (target_can_async_p ())
until_break_command (char *arg, int from_tty, int anywhere){  struct symtabs_and_lines sals;  struct symtab_and_line sal;  struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);  struct breakpoint *breakpoint;  struct cleanup *old_chain;  struct continuation_arg *arg1;  clear_proceed_status ();  /* Set a breakpoint where the user wants it and at return from     this function */  if (default_breakpoint_valid)    sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,			  default_breakpoint_line, (char ***) NULL, NULL);  else    sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 			  0, (char ***) NULL, NULL);  if (sals.nelts != 1)    error ("Couldn't get information on specified line.");  sal = sals.sals[0];  xfree (sals.sals);	/* malloc'd, so freed */  if (*arg)    error ("Junk at end of arguments.");  resolve_sal_pc (&sal);  if (anywhere)    /* If the user told us to continue until a specified location,       we don't specify a frame at which we need to stop.  */    breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);  else    /* Otherwise, specify the current frame, because we want to stop only       at the very same frame.  */    breakpoint = set_momentary_breakpoint (sal,					   get_frame_id (deprecated_selected_frame),					   bp_until);  if (!event_loop_p || !target_can_async_p ())    old_chain = make_cleanup_delete_breakpoint (breakpoint);  else    old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);  /* If we are running asynchronously, and the target supports async     execution, we are not waiting for the target to stop, in the call     tp proceed, below. This means that we cannot delete the     brekpoints until the target has actually stopped. The only place     where we get a chance to do that is in fetch_inferior_event, so     we must set things up for that. */  if (event_loop_p && target_can_async_p ())    {      /* In this case the arg for the continuation is just the point         in the exec_cleanups chain from where to start doing         cleanups, because all the continuation does is the cleanups in         the exec_cleanup_chain. */      arg1 =	(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));      arg1->next         = NULL;      arg1->data.pointer = old_chain;      add_continuation (until_break_command_continuation, arg1);    }  /* Keep within the current frame, or in frames called by the current     one.  */  if (prev_frame)    {      sal = find_pc_line (get_frame_pc (prev_frame), 0);      sal.pc = get_frame_pc (prev_frame);      breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),					     bp_until);      if (!event_loop_p || !target_can_async_p ())	make_cleanup_delete_breakpoint (breakpoint);      else	make_exec_cleanup_delete_breakpoint (breakpoint);    }  proceed (-1, TARGET_SIGNAL_DEFAULT, 0);  /* Do the cleanups now, anly if we are not running asynchronously,     of if we are, but the target is still synchronous. */  if (!event_loop_p || !target_can_async_p ())    do_cleanups (old_chain);}