2018-09-17 Tom Tromey <tom@tromey.com>
+ * gdbthread.h (struct thread_control_state): Add initializer.
+ (class thread_info) <control>: Remove initializer.
+ * inferior.h (struct inferior_control_state): Add initializer.
+ (class inferior) <control>: Remove initializer.
+ (exit_inferior_1): Update.
+ * infrun.c (struct infcall_control_state): Add constructors.
+ (save_infcall_control_state): Use new.
+ (restore_infcall_control_state, discard_infcall_control_state):
+ Use delete.
+
+2018-09-17 Tom Tromey <tom@tromey.com>
+
* infrun.c (struct infcall_suspend_state) <registers>: Now a
unique_ptr.
<siginfo_data>: Now a unique_xmalloc_ptr.
/* User/external stepping state. */
/* Step-resume or longjmp-resume breakpoint. */
- struct breakpoint *step_resume_breakpoint;
+ struct breakpoint *step_resume_breakpoint = nullptr;
/* Exception-resume breakpoint. */
- struct breakpoint *exception_resume_breakpoint;
+ struct breakpoint *exception_resume_breakpoint = nullptr;
/* Breakpoints used for software single stepping. Plural, because
it may have multiple locations. E.g., if stepping over a
conditional branch instruction we can't decode the condition for,
we'll need to put a breakpoint at the branch destination, and
another at the instruction after the branch. */
- struct breakpoint *single_step_breakpoints;
+ struct breakpoint *single_step_breakpoints = nullptr;
/* Range to single step within.
wait_for_inferior in a minor way if this were changed to the
address of the instruction and that address plus one. But maybe
not). */
- CORE_ADDR step_range_start; /* Inclusive */
- CORE_ADDR step_range_end; /* Exclusive */
+ CORE_ADDR step_range_start = 0; /* Inclusive */
+ CORE_ADDR step_range_end = 0; /* Exclusive */
/* Function the thread was in as of last it started stepping. */
- struct symbol *step_start_function;
+ struct symbol *step_start_function = nullptr;
/* If GDB issues a target step request, and this is nonzero, the
target should single-step this thread once, and then continue
thread stops in the step range above. If this is zero, the
target should ignore the step range, and only issue one single
step. */
- int may_range_step;
+ int may_range_step = 0;
/* Stack frame address as of when stepping command was issued.
This is how we know when we step into a subroutine call, and how
to set the frame for the breakpoint used to step out. */
- struct frame_id step_frame_id;
+ struct frame_id step_frame_id {};
/* Similarly, the frame ID of the underlying stack frame (skipping
any inlined frames). */
- struct frame_id step_stack_frame_id;
+ struct frame_id step_stack_frame_id {};
/* Nonzero if we are presently stepping over a breakpoint.
wait_for_inferior, which calls handle_inferior_event in a loop,
and until wait_for_inferior exits, this variable is changed only
by keep_going. */
- int trap_expected;
+ int trap_expected = 0;
/* Nonzero if the thread is being proceeded for a "finish" command
or a similar situation when return value should be printed. */
- int proceed_to_finish;
+ int proceed_to_finish = 0;
/* Nonzero if the thread is being proceeded for an inferior function
call. */
- int in_infcall;
+ int in_infcall = 0;
- enum step_over_calls_kind step_over_calls;
+ enum step_over_calls_kind step_over_calls = STEP_OVER_NONE;
/* Nonzero if stopped due to a step command. */
- int stop_step;
+ int stop_step = 0;
/* Chain containing status of breakpoint(s) the thread stopped
at. */
- bpstat stop_bpstat;
+ bpstat stop_bpstat = nullptr;
/* Whether the command that started the thread was a stepping
command. This is used to decide whether "set scheduler-locking
step" behaves like "on" or "off". */
- int stepping_command;
+ int stepping_command = 0;
};
/* Inferior thread specific part of `struct infcall_suspend_state'. */
/* State of GDB control of inferior thread execution.
See `struct thread_control_state'. */
- thread_control_state control {};
+ thread_control_state control;
/* State of inferior thread to restore after GDB is done with an inferior
call. See `struct thread_suspend_state'. */
struct inferior_control_state
{
+ inferior_control_state ()
+ : stop_soon (NO_STOP_QUIETLY)
+ {
+ }
+
+ explicit inferior_control_state (enum stop_kind when)
+ : stop_soon (when)
+ {
+ }
+
/* See the definition of stop_kind above. */
enum stop_kind stop_soon;
};
/* State of GDB control of inferior process execution.
See `struct inferior_control_state'. */
- inferior_control_state control {NO_STOP_QUIETLY};
+ inferior_control_state control;
/* True if this was an auto-created inferior, e.g. created from
following a fork; false, if this inferior was manually added by
struct inferior_control_state inferior_control;
/* Other fields: */
- enum stop_stack_kind stop_stack_dummy;
- int stopped_by_random_signal;
+ enum stop_stack_kind stop_stack_dummy = STOP_NONE;
+ int stopped_by_random_signal = 0;
/* ID if the selected frame when the inferior function call was made. */
- struct frame_id selected_frame_id;
+ struct frame_id selected_frame_id {};
};
/* Save all of the information associated with the inferior<==>gdb
struct infcall_control_state *
save_infcall_control_state (void)
{
- struct infcall_control_state *inf_status =
- XNEW (struct infcall_control_state);
+ struct infcall_control_state *inf_status = new struct infcall_control_state;
struct thread_info *tp = inferior_thread ();
struct inferior *inf = current_inferior ();
END_CATCH
}
- xfree (inf_status);
+ delete inf_status;
}
static void
/* See save_infcall_control_state for info on stop_bpstat. */
bpstat_clear (&inf_status->thread_control.stop_bpstat);
- xfree (inf_status);
+ delete inf_status;
}
\f
/* See infrun.h. */