2005-04-17 21:16:13 +02:00
|
|
|
#ifndef GDBSTUB_H
|
|
|
|
#define GDBSTUB_H
|
|
|
|
|
2007-02-22 02:48:01 +01:00
|
|
|
#define DEFAULT_GDBSTUB_PORT "1234"
|
2005-04-17 21:16:13 +02:00
|
|
|
|
2009-03-12 21:12:48 +01:00
|
|
|
/* GDB breakpoint/watchpoint types */
|
|
|
|
#define GDB_BREAKPOINT_SW 0
|
|
|
|
#define GDB_BREAKPOINT_HW 1
|
|
|
|
#define GDB_WATCHPOINT_WRITE 2
|
|
|
|
#define GDB_WATCHPOINT_READ 3
|
|
|
|
#define GDB_WATCHPOINT_ACCESS 4
|
|
|
|
|
2023-10-09 18:40:51 +02:00
|
|
|
typedef struct GDBFeature {
|
|
|
|
const char *xmlname;
|
|
|
|
const char *xml;
|
2024-02-27 15:43:20 +01:00
|
|
|
const char *name;
|
|
|
|
const char * const *regs;
|
2023-11-06 19:50:58 +01:00
|
|
|
int num_regs;
|
2023-10-09 18:40:51 +02:00
|
|
|
} GDBFeature;
|
|
|
|
|
2023-11-06 19:51:00 +01:00
|
|
|
typedef struct GDBFeatureBuilder {
|
|
|
|
GDBFeature *feature;
|
|
|
|
GPtrArray *xml;
|
2024-02-27 15:43:20 +01:00
|
|
|
GPtrArray *regs;
|
2023-11-06 19:51:00 +01:00
|
|
|
int base_reg;
|
|
|
|
} GDBFeatureBuilder;
|
|
|
|
|
2021-01-08 23:42:44 +01:00
|
|
|
|
2008-10-11 19:55:29 +02:00
|
|
|
/* Get or set a register. Returns the size of the register. */
|
2024-02-27 15:43:16 +01:00
|
|
|
typedef int (*gdb_get_reg_cb)(CPUState *cpu, GByteArray *buf, int reg);
|
|
|
|
typedef int (*gdb_set_reg_cb)(CPUState *cpu, uint8_t *buf, int reg);
|
2023-08-29 18:15:28 +02:00
|
|
|
|
2024-02-27 15:43:17 +01:00
|
|
|
/**
|
|
|
|
* gdb_init_cpu(): Initialize the CPU for gdbstub.
|
|
|
|
* @cpu: The CPU to be initialized.
|
|
|
|
*/
|
|
|
|
void gdb_init_cpu(CPUState *cpu);
|
|
|
|
|
2023-08-29 18:15:28 +02:00
|
|
|
/**
|
|
|
|
* gdb_register_coprocessor() - register a supplemental set of registers
|
|
|
|
* @cpu - the CPU associated with registers
|
|
|
|
* @get_reg - get function (gdb reading)
|
|
|
|
* @set_reg - set function (gdb modifying)
|
|
|
|
* @num_regs - number of registers in set
|
|
|
|
* @xml - xml name of set
|
|
|
|
* @gpos - non-zero to append to "general" register set at @gpos
|
|
|
|
*/
|
2013-06-28 21:27:39 +02:00
|
|
|
void gdb_register_coprocessor(CPUState *cpu,
|
2020-03-16 18:21:41 +01:00
|
|
|
gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
|
2024-02-27 15:43:14 +01:00
|
|
|
const GDBFeature *feature, int g_pos);
|
2005-04-17 21:16:13 +02:00
|
|
|
|
2020-04-30 21:01:19 +02:00
|
|
|
/**
|
|
|
|
* gdbserver_start: start the gdb server
|
|
|
|
* @port_or_device: connection spec for gdb
|
|
|
|
*
|
|
|
|
* For CONFIG_USER this is either a tcp port or a path to a fifo. For
|
|
|
|
* system emulation you can use a full chardev spec for your gdbserver
|
|
|
|
* port.
|
|
|
|
*/
|
|
|
|
int gdbserver_start(const char *port_or_device);
|
2010-03-29 21:23:47 +02:00
|
|
|
|
2023-11-06 19:51:00 +01:00
|
|
|
/**
|
|
|
|
* gdb_feature_builder_init() - Initialize GDBFeatureBuilder.
|
|
|
|
* @builder: The builder to be initialized.
|
|
|
|
* @feature: The feature to be filled.
|
|
|
|
* @name: The name of the feature.
|
|
|
|
* @xmlname: The name of the XML.
|
|
|
|
* @base_reg: The base number of the register ID.
|
|
|
|
*/
|
|
|
|
void gdb_feature_builder_init(GDBFeatureBuilder *builder, GDBFeature *feature,
|
|
|
|
const char *name, const char *xmlname,
|
|
|
|
int base_reg);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gdb_feature_builder_append_tag() - Append a tag.
|
|
|
|
* @builder: The builder.
|
|
|
|
* @format: The format of the tag.
|
|
|
|
* @...: The values to be formatted.
|
|
|
|
*/
|
|
|
|
void G_GNUC_PRINTF(2, 3)
|
|
|
|
gdb_feature_builder_append_tag(const GDBFeatureBuilder *builder,
|
|
|
|
const char *format, ...);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gdb_feature_builder_append_reg() - Append a register.
|
|
|
|
* @builder: The builder.
|
|
|
|
* @name: The register's name; it must be unique within a CPU.
|
|
|
|
* @bitsize: The register's size, in bits.
|
|
|
|
* @regnum: The offset of the register's number in the feature.
|
|
|
|
* @type: The type of the register.
|
|
|
|
* @group: The register group to which this register belongs; it can be NULL.
|
|
|
|
*/
|
|
|
|
void gdb_feature_builder_append_reg(const GDBFeatureBuilder *builder,
|
|
|
|
const char *name,
|
|
|
|
int bitsize,
|
|
|
|
int regnum,
|
|
|
|
const char *type,
|
|
|
|
const char *group);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gdb_feature_builder_end() - End building GDBFeature.
|
|
|
|
* @builder: The builder.
|
|
|
|
*/
|
|
|
|
void gdb_feature_builder_end(const GDBFeatureBuilder *builder);
|
|
|
|
|
2023-11-06 19:50:59 +01:00
|
|
|
/**
|
|
|
|
* gdb_find_static_feature() - Find a static feature.
|
|
|
|
* @xmlname: The name of the XML.
|
|
|
|
*
|
|
|
|
* Return: The static feature.
|
|
|
|
*/
|
|
|
|
const GDBFeature *gdb_find_static_feature(const char *xmlname);
|
|
|
|
|
2024-02-27 15:43:27 +01:00
|
|
|
/**
|
|
|
|
* gdb_read_register() - Read a register associated with a CPU.
|
|
|
|
* @cpu: The CPU associated with the register.
|
|
|
|
* @buf: The buffer that the read register will be appended to.
|
|
|
|
* @reg: The register's number returned by gdb_find_feature_register().
|
|
|
|
*
|
|
|
|
* Return: The number of read bytes.
|
|
|
|
*/
|
|
|
|
int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* typedef GDBRegDesc - a register description from gdbstub
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
int gdb_reg;
|
|
|
|
const char *name;
|
|
|
|
const char *feature_name;
|
|
|
|
} GDBRegDesc;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gdb_get_register_list() - Return list of all registers for CPU
|
|
|
|
* @cpu: The CPU being searched
|
|
|
|
*
|
|
|
|
* Returns a GArray of GDBRegDesc, caller frees array but not the
|
|
|
|
* const strings.
|
|
|
|
*/
|
|
|
|
GArray *gdb_get_register_list(CPUState *cpu);
|
|
|
|
|
2021-05-16 19:56:55 +02:00
|
|
|
void gdb_set_stop_cpu(CPUState *cpu);
|
|
|
|
|
2023-10-09 18:40:51 +02:00
|
|
|
/* in gdbstub-xml.c, generated by scripts/feature_to_c.py */
|
|
|
|
extern const GDBFeature gdb_static_features[];
|
2010-09-18 09:02:16 +02:00
|
|
|
|
2010-03-29 21:23:47 +02:00
|
|
|
#endif
|