mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
3666a04883
This commits the result of running gdb/copyright.py as per our Start of New Year procedure... gdb/ChangeLog Update copyright year range in copyright header of all GDB files.
211 lines
5.9 KiB
C++
211 lines
5.9 KiB
C++
/* Displaced stepping related things.
|
|
|
|
Copyright (C) 2020-2021 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 DISPLACED_STEPPING_H
|
|
#define DISPLACED_STEPPING_H
|
|
|
|
#include "gdbsupport/array-view.h"
|
|
#include "gdbsupport/byte-vector.h"
|
|
|
|
struct gdbarch;
|
|
struct thread_info;
|
|
|
|
/* True if we are debugging displaced stepping. */
|
|
|
|
extern bool debug_displaced;
|
|
|
|
/* Print a "displaced" debug statement. */
|
|
|
|
#define displaced_debug_printf(fmt, ...) \
|
|
debug_prefixed_printf_cond (debug_displaced, "displaced",fmt, ##__VA_ARGS__)
|
|
|
|
enum displaced_step_prepare_status
|
|
{
|
|
/* A displaced stepping buffer was successfully allocated and prepared. */
|
|
DISPLACED_STEP_PREPARE_STATUS_OK,
|
|
|
|
/* This particular instruction can't be displaced stepped, GDB should fall
|
|
back on in-line stepping. */
|
|
DISPLACED_STEP_PREPARE_STATUS_CANT,
|
|
|
|
/* Not enough resources are available at this time, try again later. */
|
|
DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE,
|
|
};
|
|
|
|
enum displaced_step_finish_status
|
|
{
|
|
/* Either the instruction was stepped and fixed up, or the specified thread
|
|
wasn't executing a displaced step (in which case there's nothing to
|
|
finish). */
|
|
DISPLACED_STEP_FINISH_STATUS_OK,
|
|
|
|
/* The thread started a displaced step, but didn't complete it. */
|
|
DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED,
|
|
};
|
|
|
|
/* Data returned by a gdbarch displaced_step_copy_insn method, to be passed to
|
|
the matching displaced_step_fixup method. */
|
|
|
|
struct displaced_step_copy_insn_closure
|
|
{
|
|
virtual ~displaced_step_copy_insn_closure () = 0;
|
|
};
|
|
|
|
using displaced_step_copy_insn_closure_up
|
|
= std::unique_ptr<displaced_step_copy_insn_closure>;
|
|
|
|
/* A simple displaced step closure that contains only a byte buffer. */
|
|
|
|
struct buf_displaced_step_copy_insn_closure : displaced_step_copy_insn_closure
|
|
{
|
|
buf_displaced_step_copy_insn_closure (int buf_size)
|
|
: buf (buf_size)
|
|
{}
|
|
|
|
/* The content of this buffer is up to the user of the class, but typically
|
|
original instruction bytes, used during fixup to determine what needs to
|
|
be fixed up. */
|
|
gdb::byte_vector buf;
|
|
};
|
|
|
|
/* Per-inferior displaced stepping state. */
|
|
|
|
struct displaced_step_inferior_state
|
|
{
|
|
displaced_step_inferior_state ()
|
|
{
|
|
reset ();
|
|
}
|
|
|
|
/* Put this object back in its original state. */
|
|
void reset ()
|
|
{
|
|
failed_before = false;
|
|
in_progress_count = 0;
|
|
unavailable = false;
|
|
}
|
|
|
|
/* True if preparing a displaced step ever failed. If so, we won't
|
|
try displaced stepping for this inferior again. */
|
|
bool failed_before;
|
|
|
|
/* Number of displaced steps in progress for this inferior. */
|
|
unsigned int in_progress_count;
|
|
|
|
/* If true, this tells GDB that it's not worth asking the gdbarch displaced
|
|
stepping implementation to prepare a displaced step, because it would
|
|
return UNAVAILABLE. This is set and reset by the gdbarch in the
|
|
displaced_step_prepare and displaced_step_finish methods. */
|
|
bool unavailable;
|
|
};
|
|
|
|
/* Per-thread displaced stepping state. */
|
|
|
|
struct displaced_step_thread_state
|
|
{
|
|
/* Return true if this thread is currently executing a displaced step. */
|
|
bool in_progress () const
|
|
{
|
|
return m_original_gdbarch != nullptr;
|
|
}
|
|
|
|
/* Return the gdbarch of the thread prior to the step. */
|
|
gdbarch *get_original_gdbarch () const
|
|
{
|
|
return m_original_gdbarch;
|
|
}
|
|
|
|
/* Mark this thread as currently executing a displaced step.
|
|
|
|
ORIGINAL_GDBARCH is the current gdbarch of the thread (before the step
|
|
is executed). */
|
|
void set (gdbarch *original_gdbarch)
|
|
{
|
|
m_original_gdbarch = original_gdbarch;
|
|
}
|
|
|
|
/* Mark this thread as no longer executing a displaced step. */
|
|
void reset ()
|
|
{
|
|
m_original_gdbarch = nullptr;
|
|
}
|
|
|
|
private:
|
|
gdbarch *m_original_gdbarch = nullptr;
|
|
};
|
|
|
|
/* Control access to multiple displaced stepping buffers at fixed addresses. */
|
|
|
|
struct displaced_step_buffers
|
|
{
|
|
explicit displaced_step_buffers (gdb::array_view<CORE_ADDR> buffer_addrs)
|
|
{
|
|
gdb_assert (buffer_addrs.size () > 0);
|
|
|
|
m_buffers.reserve (buffer_addrs.size ());
|
|
|
|
for (CORE_ADDR buffer_addr : buffer_addrs)
|
|
m_buffers.emplace_back (buffer_addr);
|
|
}
|
|
|
|
displaced_step_prepare_status prepare (thread_info *thread,
|
|
CORE_ADDR &displaced_pc);
|
|
|
|
displaced_step_finish_status finish (gdbarch *arch, thread_info *thread,
|
|
gdb_signal sig);
|
|
|
|
const displaced_step_copy_insn_closure *
|
|
copy_insn_closure_by_addr (CORE_ADDR addr);
|
|
|
|
void restore_in_ptid (ptid_t ptid);
|
|
|
|
private:
|
|
|
|
/* State of a single buffer. */
|
|
|
|
struct displaced_step_buffer
|
|
{
|
|
explicit displaced_step_buffer (CORE_ADDR addr)
|
|
: addr (addr)
|
|
{}
|
|
|
|
/* Address of the buffer. */
|
|
const CORE_ADDR addr;
|
|
|
|
/* The original PC of the instruction currently being stepped. */
|
|
CORE_ADDR original_pc = 0;
|
|
|
|
/* If set, the thread currently using the buffer. If unset, the buffer is not
|
|
used. */
|
|
thread_info *current_thread = nullptr;
|
|
|
|
/* Saved copy of the bytes in the displaced buffer, to be restored once the
|
|
buffer is no longer used. */
|
|
gdb::byte_vector saved_copy;
|
|
|
|
/* Closure obtained from gdbarch_displaced_step_copy_insn, to be passed to
|
|
gdbarch_displaced_step_fixup_insn. */
|
|
displaced_step_copy_insn_closure_up copy_insn_closure;
|
|
};
|
|
|
|
std::vector<displaced_step_buffer> m_buffers;
|
|
};
|
|
|
|
#endif /* DISPLACED_STEPPING_H */
|