call_function_by_hand doesn't restore target async?

[dje@google.com (Doug Evans)]

Hi.

Should there be a cleanup to restore target_async_mask?

call_function_by_hand has this:

  {
    struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
    struct cleanup *old_cleanups2;
    int saved_async = 0;
    struct thread_info *tp = inferior_thread ();

    /* Save this thread's ptid, we need it later but the thread
       may have exited.  */
    this_thread_ptid = tp->ptid;

    /* If all error()s out of proceed ended up calling normal_stop
       (and perhaps they should; it already does in the special case
       of error out of resume()), then we wouldn't need this.  */
    make_cleanup (breakpoint_auto_delete_contents, NULL);

    disable_watchpoints_before_interactive_call_start ();
    tp->proceed_to_finish = 1; /* We want stop_registers, please... */

    if (target_can_async_p ())
      saved_async = target_async_mask (0);

    old_cleanups2 = make_cleanup_restore_integer (&suppress_resume_observer);
    suppress_resume_observer = 1;
    make_cleanup_restore_integer (&suppress_stop_observer);
    suppress_stop_observer = 1;
    proceed (real_pc, TARGET_SIGNAL_0, 0);
    do_cleanups (old_cleanups2);

    if (saved_async)
      target_async_mask (saved_async);

    enable_watchpoints_after_interactive_call_stop ();

    discard_cleanups (old_cleanups);
  }

target.h has this:

/* This is to be used ONLY within call_function_by_hand(). It provides
   a workaround, to have inferior function calls done in sychronous
   mode, even though the target is asynchronous. After
   target_async_mask(0) is called, calls to target_can_async_p() will
   return FALSE , so that target_resume() will not try to start the
   target asynchronously. After the inferior stops, we IMMEDIATELY
   restore the previous nature of the target, by calling
   target_async_mask(1). After that, target_can_async_p() will return
   TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.

   FIXME ezannoni 1999-12-13: we won't need this once we move
   the turning async on and off to the single execution commands,
   from where it is done currently, in remote_resume().  */

#define target_async_mask(MASK)	\
  (current_target.to_async_mask (MASK))

I don't see any other calls to target_async_mask.  Given that it's
only to be used by call_function_by_hand that's understandable,
but then I don't understand how target_async_mask gets restored
if proceed errors out.

I'll add a fix to my dummy-frames patch if there's a bug here.
If there isn't a bug I'll at least add a comment. :-)
[and I'll need to start breaking it into a set of smaller patches ...]