/* Multi-thread control defs for remote server for GDB.
   Copyright (C) 1993-2026 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifndef GDBSERVER_GDBTHREAD_H
#define GDBSERVER_GDBTHREAD_H

#include "gdbsupport/function-view.h"
#include "gdbsupport/intrusive_list.h"
#include <memory>

struct btrace_target_info;
struct regcache;

struct thread_info : public intrusive_list_node<thread_info>
{
  thread_info (ptid_t id, process_info *process, void *target_data)
    : id (id), m_process (process), m_target_data (target_data)
  {}

  /* Return the process owning this thread.  */
  process_info *process () const
  { return m_process; }

  struct regcache *regcache ()
  { return m_regcache.get (); }

  void set_regcache (std::unique_ptr<struct regcache> regcache)
  { m_regcache = std::move (regcache); }

  void *target_data ()
  { return m_target_data; }

  /* The id of this thread.  */
  ptid_t id;

  /* The last resume GDB requested on this thread.  */
  enum resume_kind last_resume_kind = resume_continue;

  /* The last wait status reported for this thread.  */
  struct target_waitstatus last_status;

  /* True if LAST_STATUS hasn't been reported to GDB yet.  */
  int status_pending_p = 0;

  /* Given `while-stepping', a thread may be collecting data for more
     than one tracepoint simultaneously.  E.g.:

    ff0001  INSN1 <-- TP1, while-stepping 10 collect $regs
    ff0002  INSN2
    ff0003  INSN3 <-- TP2, collect $regs
    ff0004  INSN4 <-- TP3, while-stepping 10 collect $regs
    ff0005  INSN5

   Notice that when instruction INSN5 is reached, the while-stepping
   actions of both TP1 and TP3 are still being collected, and that TP2
   had been collected meanwhile.  The whole range of ff0001-ff0005
   should be single-stepped, due to at least TP1's while-stepping
   action covering the whole range.

   On the other hand, the same tracepoint with a while-stepping action
   may be hit by more than one thread simultaneously, hence we can't
   keep the current step count in the tracepoint itself.

   This is the head of the list of the states of `while-stepping'
   tracepoint actions this thread is now collecting; NULL if empty.
   Each item in the list holds the current step of the while-stepping
   action.  */
  struct wstep_state *while_stepping = nullptr;

  /* Branch trace target information for this thread.  */
  struct btrace_target_info *btrace = nullptr;

  /* Thread options GDB requested with QThreadOptions.  */
  gdb_thread_options thread_options = 0;

private:
  process_info *m_process;
  std::unique_ptr<struct regcache> m_regcache = nullptr;
  void *m_target_data;
};

/* Return a pointer to the first thread, or NULL if there isn't one.  */

thread_info *get_first_thread (void);

thread_info *find_thread_ptid (ptid_t ptid);

/* Find any thread of the PID process.  Returns NULL if none is
   found.  */
thread_info *find_any_thread_of_pid (int pid);

/* Find the first thread for which FUNC returns true.  Return NULL if no thread
   satisfying FUNC is found.  */

thread_info *find_thread (gdb::function_view<bool (thread_info *)> func);

/* Like the above, but only consider threads with pid PID.  */

thread_info *find_thread (int pid,
			  gdb::function_view<bool (thread_info *)> func);

/* Find the first thread that matches FILTER for which FUNC returns true.
   Return NULL if no thread satisfying these conditions is found.  */

thread_info *find_thread (ptid_t filter,
			  gdb::function_view<bool (thread_info *)> func);

/* Invoke FUNC for each thread.  */

void for_each_thread (gdb::function_view<void (thread_info *)> func);

/* Like the above, but only consider threads matching PTID.  */

void for_each_thread
  (ptid_t ptid, gdb::function_view<void (thread_info *)> func);

/* Find a random thread that matches PTID and for which FUNC (THREAD)
   returns true.  If no entry is found then return nullptr.  */

thread_info *find_thread_in_random
  (gdb::function_view<bool (thread_info *)> func);

/* Like the above, but only consider threads matching PTID.  */

thread_info *find_thread_in_random
  (ptid_t ptid, gdb::function_view<bool (thread_info *)> func);

/* Switch the current thread.  */

void switch_to_thread (thread_info *thread);

/* Save/restore current thread.  */

class scoped_restore_current_thread
{
public:
  scoped_restore_current_thread ();
  ~scoped_restore_current_thread ();

  DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread);

  /* Cancel restoring on scope exit.  */
  void dont_restore () { m_dont_restore = true; }

private:
  bool m_dont_restore = false;
  process_info *m_process;
  thread_info *m_thread;
};

#endif /* GDBSERVER_GDBTHREAD_H */