[PATCH 2/3] gdbserver lwp_info: Initialize fields, use new/delete

[Simon Marchi <simon dot marchi at ericsson dot com>]

This patch minimally C++ifies gdbdserver's lwp_info, by initializing its
fields, using new/delete to (de-)allocate it and changing some field
types to bool.  This is in preparation of using a unique_ptr in lwp_info
in the following patch.

gdb/gdbserver/ChangeLog:

	* linux-low.h (struct lwp_info): Initialize fields,
	<stop_expected, stopped, status_pending_p, stepping,
	must_set_ptrace_flags, collecting_fast_tracepoint,
	thread_known>: Change type to bool.
	* linux-low.c (delete_lwp): De-allocate lwp_info with delete.
	(handle_extended_wait): Adjust to bool.
	(add_lwp): Allocate lwp_info with new.
	(linux_create_inferior): Adjust to bool.
	(linux_post_create_inferior): Likewise.
	(linux_attach_lwp): Likewise.
	(linux_attach): Likewise.
	(linux_detach_one_lwp): Likewise.
	(thread_still_has_status_pending_p): Likewise.
	(maybe_move_out_of_jump_pad): Likewise.
	(linux_low_filter_event): Likewise.
	(linux_wait_for_event_filtered): Likewise.
	(linux_wait_1): Likewise.
	(send_sigstop): Likewise.
	(mark_lwp_dead): Likewise.
	(move_out_of_jump_pad_callback): Likewise.
	(linux_resume_one_lwp_throw): Likewise.
	(linux_set_resume_request): Likewise.
	(proceed_one_lwp): Likewise.
	(reset_lwp_ptrace_options_callback): Likewise.
	* thread-db.c (find_one_thread): Likewise.
	(attach_thread): Likewise.
---
 gdb/gdbserver/linux-low.c | 94 +++++++++++++++++++++++------------------------
 gdb/gdbserver/linux-low.h | 52 +++++++++++++-------------
 gdb/gdbserver/thread-db.c |  4 +-
 3 files changed, 73 insertions(+), 77 deletions(-)

diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 3d7cfe3..e650b0d 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -415,7 +415,7 @@ delete_lwp (struct lwp_info *lwp)
 
   remove_thread (thr);
   free (lwp->arch_private);
-  free (lwp);
+  delete lwp;
 }
 
 /* Add a process to the common process list, and set its private
@@ -535,9 +535,9 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
 	  gdb_assert (child_proc != NULL);
 	  child_lwp = add_lwp (ptid);
 	  gdb_assert (child_lwp != NULL);
-	  child_lwp->stopped = 1;
-	  child_lwp->must_set_ptrace_flags = 1;
-	  child_lwp->status_pending_p = 0;
+	  child_lwp->stopped = true;
+	  child_lwp->must_set_ptrace_flags = true;
+	  child_lwp->status_pending_p = false;
 	  child_thr = get_lwp_thread (child_lwp);
 	  child_thr->last_resume_kind = resume_stop;
 	  child_thr->last_status.kind = TARGET_WAITKIND_STOPPED;
@@ -589,7 +589,7 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
 	  /* The status_pending field contains bits denoting the
 	     extended event, so when the pending event is handled,
 	     the handler will look at lwp->waitstatus.  */
-	  event_lwp->status_pending_p = 1;
+	  event_lwp->status_pending_p = true;
 	  event_lwp->status_pending = wstat;
 
 	  /* Link the threads until the parent event is passed on to
@@ -630,7 +630,7 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
 	 or leave it stopped.  linux_resume_one_lwp is a nop if it
 	 thinks the thread is currently running, so set this first
 	 before calling linux_resume_one_lwp.  */
-      new_lwp->stopped = 1;
+      new_lwp->stopped = true;
 
       /* If we're suspending all threads, leave this one suspended
 	 too.  If the fork/clone parent is stepping over a breakpoint,
@@ -645,14 +645,14 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
 	 If we do get another signal, be sure not to lose it.  */
       if (WSTOPSIG (status) != SIGSTOP)
 	{
-	  new_lwp->stop_expected = 1;
-	  new_lwp->status_pending_p = 1;
+	  new_lwp->stop_expected = true;
+	  new_lwp->status_pending_p = true;
 	  new_lwp->status_pending = status;
 	}
       else if (report_thread_events)
 	{
 	  new_lwp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
-	  new_lwp->status_pending_p = 1;
+	  new_lwp->status_pending_p = true;
 	  new_lwp->status_pending = status;
 	}
 
@@ -712,8 +712,8 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
 	= xstrdup (linux_proc_pid_to_exec_file (lwpid_of (event_thr)));
 
       /* Mark the exec status as pending.  */
-      event_lwp->stopped = 1;
-      event_lwp->status_pending_p = 1;
+      event_lwp->stopped = true;
+      event_lwp->status_pending_p = true;
       event_lwp->status_pending = wstat;
       event_thr->last_resume_kind = resume_continue;
       event_thr->last_status.kind = TARGET_WAITKIND_IGNORE;
@@ -935,11 +935,7 @@ save_stop_reason (struct lwp_info *lwp)
 static struct lwp_info *
 add_lwp (ptid_t ptid)
 {
-  struct lwp_info *lwp;
-
-  lwp = XCNEW (struct lwp_info);
-
-  lwp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
+  lwp_info *lwp = new lwp_info;
 
   if (the_low_target.new_thread != NULL)
     the_low_target.new_thread (lwp);
@@ -1007,7 +1003,7 @@ linux_create_inferior (const char *program,
 
   ptid = ptid_build (pid, pid, 0);
   new_lwp = add_lwp (ptid);
-  new_lwp->must_set_ptrace_flags = 1;
+  new_lwp->must_set_ptrace_flags = true;
 
   post_fork_inferior (pid, program);
 
@@ -1029,7 +1025,7 @@ linux_post_create_inferior (void)
       int options = linux_low_ptrace_options (proc->attached);
 
       linux_enable_event_reporting (lwpid_of (current_thread), options);
-      lwp->must_set_ptrace_flags = 0;
+      lwp->must_set_ptrace_flags = false;
     }
 }
 
@@ -1050,7 +1046,7 @@ linux_attach_lwp (ptid_t ptid)
 
   /* We need to wait for SIGSTOP before being able to make the next
      ptrace call on this LWP.  */
-  new_lwp->must_set_ptrace_flags = 1;
+  new_lwp->must_set_ptrace_flags = true;
 
   if (linux_proc_pid_is_stopped (lwpid))
     {
@@ -1113,7 +1109,7 @@ linux_attach_lwp (ptid_t ptid)
      because we are guaranteed that the add_lwp call above added us to the
      end of the list, and so the new thread has not yet reached
      wait_for_sigstop (but will).  */
-  new_lwp->stop_expected = 1;
+  new_lwp->stop_expected = true;
 
   return 0;
 }
@@ -1220,7 +1216,7 @@ linux_attach (unsigned long pid)
 
       if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGSTOP)
 	{
-	  lwp->status_pending_p = 1;
+	  lwp->status_pending_p = true;
 	  lwp->status_pending = wstat;
 	}
 
@@ -1514,7 +1510,7 @@ linux_detach_one_lwp (struct lwp_info *lwp)
 		      target_pid_to_str (ptid_of (thread)));
 
       kill_lwp (lwpid_of (thread), SIGCONT);
-      lwp->stop_expected = 0;
+      lwp->stop_expected = false;
     }
 
   /* Pass on any pending signal for this thread.  */
@@ -1774,7 +1770,7 @@ thread_still_has_status_pending_p (struct thread_info *thread)
 	{
 	  if (debug_threads)
 	    debug_printf ("discarding pending breakpoint status\n");
-	  lp->status_pending_p = 0;
+	  lp->status_pending_p = false;
 	  return 0;
 	}
     }
@@ -2181,7 +2177,7 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
 	     reporting to GDB.  Otherwise, it's an IPA lib bug: just
 	     report the signal to GDB, and pray for the best.  */
 
-	  lwp->collecting_fast_tracepoint = 0;
+	  lwp->collecting_fast_tracepoint = false;
 
 	  if (r != 0
 	      && (status.adjusted_insn_addr <= lwp->stop_pc
@@ -2456,7 +2452,7 @@ linux_low_filter_event (int lwpid, int wstat)
 
       child_ptid = ptid_build (lwpid, lwpid, 0);
       child = add_lwp (child_ptid);
-      child->stopped = 1;
+      child->stopped = true;
       current_thread = child->thread;
     }
 
@@ -2474,7 +2470,7 @@ linux_low_filter_event (int lwpid, int wstat)
 
   thread = get_lwp_thread (child);
 
-  child->stopped = 1;
+  child->stopped = true;
 
   child->last_status = wstat;
 
@@ -2531,7 +2527,7 @@ linux_low_filter_event (int lwpid, int wstat)
 	      /* The process is started, but GDBserver will do
 		 architecture-specific setup after the program stops at
 		 the first instruction.  */
-	      child->status_pending_p = 1;
+	      child->status_pending_p = true;
 	      child->status_pending = wstat;
 	      return child;
 	    }
@@ -2544,7 +2540,7 @@ linux_low_filter_event (int lwpid, int wstat)
       int options = linux_low_ptrace_options (proc->attached);
 
       linux_enable_event_reporting (lwpid, options);
-      child->must_set_ptrace_flags = 0;
+      child->must_set_ptrace_flags = false;
     }
 
   /* Always update syscall_state, even if it will be filtered later.  */
@@ -2590,7 +2586,7 @@ linux_low_filter_event (int lwpid, int wstat)
     {
       if (debug_threads)
 	debug_printf ("Expected stop.\n");
-      child->stop_expected = 0;
+      child->stop_expected = false;
 
       if (thread->last_resume_kind == resume_stop)
 	{
@@ -2623,7 +2619,7 @@ linux_low_filter_event (int lwpid, int wstat)
 	}
     }
 
-  child->status_pending_p = 1;
+  child->status_pending_p = true;
   child->status_pending = wstat;
   return child;
 }
@@ -2719,7 +2715,7 @@ linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
 	{
 	  enqueue_one_deferred_signal (requested_child,
 				       &requested_child->status_pending);
-	  requested_child->status_pending_p = 0;
+	  requested_child->status_pending_p = false;
 	  requested_child->status_pending = 0;
 	  linux_resume_one_lwp (requested_child, 0, 0, NULL);
 	}
@@ -2745,7 +2741,7 @@ linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
 	debug_printf ("Got an event from pending child %ld (%04x)\n",
 		      lwpid_of (event_thread), event_child->status_pending);
       *wstatp = event_child->status_pending;
-      event_child->status_pending_p = 0;
+      event_child->status_pending_p = false;
       event_child->status_pending = 0;
       current_thread = event_thread;
       return lwpid_of (event_thread);
@@ -2820,7 +2816,7 @@ linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
 	{
 	  event_child = get_thread_lwp (event_thread);
 	  *wstatp = event_child->status_pending;
-	  event_child->status_pending_p = 0;
+	  event_child->status_pending_p = false;
 	  event_child->status_pending = 0;
 	  break;
 	}
@@ -3480,7 +3476,7 @@ linux_wait_1 (ptid_t ptid,
       event_child->collecting_fast_tracepoint
 	= linux_fast_tracepoint_collecting (event_child, NULL);
 
-      if (event_child->collecting_fast_tracepoint != 1)
+      if (!event_child->collecting_fast_tracepoint)
 	{
 	  /* No longer need this breakpoint.  */
 	  if (event_child->exit_jump_pad_bkpt != NULL)
@@ -3507,7 +3503,7 @@ linux_wait_1 (ptid_t ptid,
 	    }
 	}
 
-      if (event_child->collecting_fast_tracepoint == 0)
+      if (!event_child->collecting_fast_tracepoint)
 	{
 	  if (debug_threads)
 	    debug_printf ("fast tracepoint finished "
@@ -3845,7 +3841,7 @@ linux_wait_1 (ptid_t ptid,
 	 starvation.  */
       if (ptid_equal (ptid, minus_one_ptid))
 	{
-	  event_child->status_pending_p = 1;
+	  event_child->status_pending_p = true;
 	  event_child->status_pending = w;
 
 	  select_event_lwp (&event_child);
@@ -3853,7 +3849,7 @@ linux_wait_1 (ptid_t ptid,
 	  /* current_thread and event_child must stay in sync.  */
 	  current_thread = get_lwp_thread (event_child);
 
-	  event_child->status_pending_p = 0;
+	  event_child->status_pending_p = false;
 	  w = event_child->status_pending;
 	}
 
@@ -4050,7 +4046,7 @@ send_sigstop (struct lwp_info *lwp)
   if (debug_threads)
     debug_printf ("Sending sigstop to lwp %d\n", pid);
 
-  lwp->stop_expected = 1;
+  lwp->stop_expected = true;
   kill_lwp (pid, SIGSTOP);
 }
 
@@ -4093,7 +4089,7 @@ static void
 mark_lwp_dead (struct lwp_info *lwp, int wstat)
 {
   /* Store the exit status for later.  */
-  lwp->status_pending_p = 1;
+  lwp->status_pending_p = true;
   lwp->status_pending = wstat;
 
   /* Store in waitstatus as well, as there's nothing else to process
@@ -4110,10 +4106,10 @@ mark_lwp_dead (struct lwp_info *lwp, int wstat)
     }
 
   /* Prevent trying to stop it.  */
-  lwp->stopped = 1;
+  lwp->stopped = true;
 
   /* No further stops are expected from a dead lwp.  */
-  lwp->stop_expected = 0;
+  lwp->stop_expected = false;
 }
 
 /* Return true if LWP has exited already, and has a pending exit event
@@ -4229,7 +4225,7 @@ move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
 
       if (wstat)
 	{
-	  lwp->status_pending_p = 0;
+	  lwp->status_pending_p = false;
 	  enqueue_one_deferred_signal (lwp, wstat);
 
 	  if (debug_threads)
@@ -4392,7 +4388,7 @@ linux_resume_one_lwp_throw (struct lwp_info *lwp,
      Code in this function that requires register access should be
      guarded by proc->tdesc == NULL or something else.  */
 
-  if (lwp->stopped == 0)
+  if (!lwp->stopped)
     return;
 
   gdb_assert (lwp->waitstatus.kind == TARGET_WAITKIND_IGNORE);
@@ -4575,7 +4571,7 @@ linux_resume_one_lwp_throw (struct lwp_info *lwp,
      later try to stop the LWP and hang forever waiting for a stop
      status.  Note that we must not throw after this is cleared,
      otherwise handle_zombie_lwp_error would get confused.  */
-  lwp->stopped = 0;
+  lwp->stopped = false;
   lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
 }
 
@@ -4606,7 +4602,7 @@ check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
   if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread)) == 0)
     {
       lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
-      lp->status_pending_p = 0;
+      lp->status_pending_p = false;
       return 1;
     }
   return 0;
@@ -4739,7 +4735,7 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
 	      && !lwp->status_pending_p
 	      && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
 	    {
-	      lwp->status_pending_p = 1;
+	      lwp->status_pending_p = true;
 
 	      if (debug_threads)
 		debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
@@ -5294,7 +5290,7 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except)
 
   if (thread->last_resume_kind == resume_stop
       && lwp->pending_signals_to_report == NULL
-      && lwp->collecting_fast_tracepoint == 0)
+      && !lwp->collecting_fast_tracepoint)
     {
       /* We haven't reported this LWP as stopped yet (otherwise, the
 	 last_status.kind check above would catch it, and we wouldn't
@@ -6466,7 +6462,7 @@ reset_lwp_ptrace_options_callback (struct inferior_list_entry *entry,
   if (!lwp->stopped)
     {
       /* Stop the lwp so we can modify its ptrace options.  */
-      lwp->must_set_ptrace_flags = 1;
+      lwp->must_set_ptrace_flags = true;
       linux_stop_lwp (lwp);
     }
   else
@@ -6476,7 +6472,7 @@ reset_lwp_ptrace_options_callback (struct inferior_list_entry *entry,
       int options = linux_low_ptrace_options (proc->attached);
 
       linux_enable_event_reporting (lwpid_of (thread), options);
-      lwp->must_set_ptrace_flags = 0;
+      lwp->must_set_ptrace_flags = false;
     }
 
   return 0;
diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h
index 6328da0..dcc9315 100644
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -267,7 +267,7 @@ extern struct linux_target_ops the_low_target;
 struct lwp_info
 {
   /* Backlink to the parent object.  */
-  struct thread_info *thread;
+  struct thread_info *thread = NULL;
 
   /* If this flag is set, the next SIGSTOP will be ignored (the
      process will be immediately resumed).  This means that either we
@@ -275,109 +275,109 @@ struct lwp_info
      (so the SIGSTOP is still pending), or that we stopped the
      inferior implicitly via PTRACE_ATTACH and have not waited for it
      yet.  */
-  int stop_expected;
+  bool stop_expected = false;
 
-  /* When this is true, we shall not try to resume this thread, even
+  /* When this is greater than 0, we shall not try to resume this thread, even
      if last_resume_kind isn't resume_stop.  */
-  int suspended;
+  int suspended = 0;
 
   /* If this flag is set, the lwp is known to be stopped right now (stop
      event already received in a wait()).  */
-  int stopped;
+  bool stopped = false;
 
   /* Signal whether we are in a SYSCALL_ENTRY or
      in a SYSCALL_RETURN event.
      Values:
      - TARGET_WAITKIND_SYSCALL_ENTRY
      - TARGET_WAITKIND_SYSCALL_RETURN */
-  enum target_waitkind syscall_state;
+  enum target_waitkind syscall_state = TARGET_WAITKIND_IGNORE;
 
   /* When stopped is set, the last wait status recorded for this lwp.  */
-  int last_status;
+  int last_status = 0;
 
   /* If WAITSTATUS->KIND != TARGET_WAITKIND_IGNORE, the waitstatus for
      this LWP's last event, to pass to GDB without any further
      processing.  This is used to store extended ptrace event
      information or exit status until it can be reported to GDB.  */
-  struct target_waitstatus waitstatus;
+  struct target_waitstatus waitstatus = { TARGET_WAITKIND_IGNORE };
 
   /* A pointer to the fork child/parent relative.  Valid only while
      the parent fork event is not reported to higher layers.  Used to
      avoid wildcard vCont actions resuming a fork child before GDB is
      notified about the parent's fork event.  */
-  struct lwp_info *fork_relative;
+  struct lwp_info *fork_relative = NULL;
 
   /* When stopped is set, this is where the lwp last stopped, with
      decr_pc_after_break already accounted for.  If the LWP is
      running, this is the address at which the lwp was resumed.  */
-  CORE_ADDR stop_pc;
+  CORE_ADDR stop_pc = 0;
 
   /* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
      been reported.  */
-  int status_pending_p;
-  int status_pending;
+  bool status_pending_p = false;
+  int status_pending = 0;
 
   /* The reason the LWP last stopped, if we need to track it
      (breakpoint, watchpoint, etc.)  */
-  enum target_stop_reason stop_reason;
+  enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON;
 
   /* On architectures where it is possible to know the data address of
      a triggered watchpoint, STOPPED_DATA_ADDRESS is non-zero, and
      contains such data address.  Only valid if STOPPED_BY_WATCHPOINT
      is true.  */
-  CORE_ADDR stopped_data_address;
+  CORE_ADDR stopped_data_address = 0;
 
   /* If this is non-zero, it is a breakpoint to be reinserted at our next
      stop (SIGTRAP stops only).  */
-  CORE_ADDR bp_reinsert;
+  CORE_ADDR bp_reinsert = 0;
 
   /* If this flag is set, the last continue operation at the ptrace
      level on this process was a single-step.  */
-  int stepping;
+  bool stepping = false;
 
   /* Range to single step within.  This is a copy of the step range
      passed along the last resume request.  See 'struct
      thread_resume'.  */
-  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 */
 
   /* If this flag is set, we need to set the event request flags the
      next time we see this LWP stop.  */
-  int must_set_ptrace_flags;
+  bool must_set_ptrace_flags = false;
 
   /* If this is non-zero, it points to a chain of signals which need to
      be delivered to this process.  */
-  struct pending_signals *pending_signals;
+  struct pending_signals *pending_signals = NULL;
 
   /* A link used when resuming.  It is initialized from the resume request,
      and then processed and cleared in linux_resume_one_lwp.  */
-  struct thread_resume *resume;
+  struct thread_resume *resume = NULL;
 
   /* True if it is known that this lwp is presently collecting a fast
      tracepoint (it is in the jump pad or in some code that will
      return to the jump pad.  Normally, we won't care about this, but
      we will if a signal arrives to this lwp while it is
      collecting.  */
-  int collecting_fast_tracepoint;
+  bool collecting_fast_tracepoint = false;
 
   /* If this is non-zero, it points to a chain of signals which need
      to be reported to GDB.  These were deferred because the thread
      was doing a fast tracepoint collect when they arrived.  */
-  struct pending_signals *pending_signals_to_report;
+  struct pending_signals *pending_signals_to_report = NULL;
 
   /* When collecting_fast_tracepoint is first found to be 1, we insert
      a exit-jump-pad-quickly breakpoint.  This is it.  */
-  struct breakpoint *exit_jump_pad_bkpt;
+  struct breakpoint *exit_jump_pad_bkpt = NULL;
 
 #ifdef USE_THREAD_DB
-  int thread_known;
+  bool thread_known = false;
   /* The thread handle, used for e.g. TLS access.  Only valid if
      THREAD_KNOWN is set.  */
   td_thrhandle_t th;
 #endif
 
   /* Arch-specific additions.  */
-  struct arch_lwp_info *arch_private;
+  struct arch_lwp_info *arch_private = NULL;
 };
 
 int linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine);
diff --git a/gdb/gdbserver/thread-db.c b/gdb/gdbserver/thread-db.c
index 1ffb79d..4bb3c59 100644
--- a/gdb/gdbserver/thread-db.c
+++ b/gdb/gdbserver/thread-db.c
@@ -198,7 +198,7 @@ find_one_thread (ptid_t ptid)
   if (ti.ti_tid == 0)
     return 0;
 
-  lwp->thread_known = 1;
+  lwp->thread_known = true;
   lwp->th = th;
 
   return 1;
@@ -229,7 +229,7 @@ attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
 
   lwp = find_lwp_pid (ptid);
   gdb_assert (lwp != NULL);
-  lwp->thread_known = 1;
+  lwp->thread_known = true;
   lwp->th = *th_p;
 
   return 1;
-- 
2.7.4